hw-verify-paths

▶ Try the checker in your browser · Docs & overview

Dependency graphs and witness paths for constant-time RTL analysis — the reasoning, not just the label.

The companion dataset records what each design is: CONSTANT_TIME or LEAKY. This one records why. For every fixture it carries the full signal dependency graph, and for every leaky one the concrete chains of signals that carry a secret to the observation.

Why witness paths and not just verdicts

A verdict is a label. It is enough to measure a classifier and not enough to build one that can be trusted, because the underlying analysis is a syntactic over-approximation: it follows every dependency edge whether or not that path can be taken at run time. Some LEAKY verdicts are therefore paths that never execute.

A user staring at a bare verdict has no way to tell a real finding from a false one, and learns to distrust the tool. A user given key → key_r → cmp_eq → running → done can look at four signal names and decide. So the path is not decoration — it is what makes an over-approximate analysis usable by someone entitled to disagree with it.

That makes this a different artefact for a different purpose: reasoning traces for training or evaluating models that must explain a hardware-security finding rather than merely emit one.

Install

pip install datasets

Quickstart

from datasets import load_dataset
import json

ds = load_dataset("nickh007/hw-verify-paths", split="test")

leaky = [r for r in ds if r["verdict"] == "LEAKY"]
r = leaky[0]
print(r["file"], "->", r["reaching_secrets"])

for p in json.loads(r["paths"]):
    print(f"  {p['secret']}: {' -> '.join(p['signals'])}  ({p['length']} edges)")

graph and paths are JSON strings, because Arrow has no good column type for a ragged adjacency map. json.loads them.

Worked example — what a record actually looks like

$ python -c "
from datasets import load_dataset; import json
ds = load_dataset('nickh007/hw-verify-paths', split='test')
r = [x for x in ds if x['verdict'] == 'LEAKY'][0]
print(r['file'], '->', r['reaching_secrets'])
for p in json.loads(r['paths'])[:1]:
    print('  ', ' -> '.join(p['signals']), f\"({p['length']} edges)\")"
barrett_leaky.v -> ['a']
   a -> acc -> done (2 edges)

That is the whole point of this dataset: barrett_leaky.v is not merely labelled LEAKY, it carries the chain — the secret a reaches acc, which reaches the completion signal done.

Fields

Field	Meaning
file	fixture name
source	the full Verilog source
scored / expected	whether it is part of the scored benchmark, and its label
observation / secrets	the completion signal, and the declared secret inputs
verdict	CONSTANT_TIME, LEAKY, UNKNOWN, or null when unscored
refusal_reason	why no verdict was reached; null unless verdict is UNKNOWN
graph	JSON: signal → the signals it depends on (assignments and guards)
n_signals / n_edges	size of that graph
reaching_secrets	the secrets found in the observation's fan-in
cone_size	signals in the fan-in cone
paths	JSON list of {secret, observation, signals, length}
n_paths / shortest_path_length	path statistics
explanation	the rendered human-readable explanation
license	per record — four fixtures are ISC, the rest CC-BY-4.0

Honest scope

• UNKNOWN records carry no graph. Three fixtures use constructs the analysis cannot read, so there is nothing to trace. Their graph is null and their refusal_reason says which construct stopped it. Emitting an empty graph would make an unreadable design look like one with no dependencies.
• Paths are capped at 8 per secret. The number of paths through a dependency graph is exponential; n_paths is a bounded sample, shortest first, not a total.
• A path is syntactic. It shows a route the value could take, not one it necessarily does. That is the whole reason it is worth reading.
• Verdicts cover completion timing against the declared secrets — not power, EM, cache, or microarchitectural channels.

Reproducing it

Every record is computed from ctbench at build time:

pip install git+https://github.com/nickharris808/ctbench@main
python build.py --check     # fails if the committed data differs from a fresh build

The data cannot drift from the code that produced it, because the check is a test.

Licence

Records are CC-BY-4.0, except four fixtures derived from picorv32 by Claire Wolf, which remain ISC. The license field is per record rather than flattened, because flattening it would misstate the terms on those four.

Part of the hw-verify toolkit

• Live demo — the checker in your browser
• hw-verify dataset — verdicts, masking probes, patch certificates
• ctbench · ct-mask · patchproof · patchproof-verify

Citation

Every record here is generated by ctbench; cite that, using the CITATION.cff in its repository (GitHub renders a "Cite this repository" button from it).

Contributing

The most valuable contribution is a design whose witness path is wrong — a reported chain that is not a real dependency. See ctbench's CONTRIBUTING.

Part of the hw-verify toolkit

Project	What it does
▶ Live demo	Constant-time checker in your browser
Docs & overview	What the toolkit proves, and what it refuses
ctbench	The checker that generated every record here
hw-verify	One install, all three checkers
hw-verify dataset	The companion: verdicts rather than reasoning

The commercial boundary. Everything open analyses a design disclosed in full. Proving a property to a third party who never receives the design is a different problem and a commercial one.