cone_size int64 6 16 ⌀ | expected stringclasses 2
values | explanation stringclasses 8
values | file stringlengths 7 23 | graph stringlengths 12 1.2k ⌀ | license stringclasses 2
values | n_edges int64 0 78 | n_paths int64 0 10 | n_signals int64 0 22 | observation stringclasses 1
value | paths stringclasses 8
values | reaching_secrets listlengths 0 2 ⌀ | refusal_reason stringclasses 3
values | scored bool 2
classes | secrets listlengths 0 3 | shortest_path_length int64 2 5 ⌀ | source stringlengths 634 4.51k | verdict stringclasses 3
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
6 | CONSTANT_TIME | null | barrett_ct.v | {"a_reg": ["a", "rst", "start"], "cadd": ["Q", "sub"], "cnt": ["W", "rst", "running", "start"], "csub": ["Q", "cadd"], "done": ["W", "cnt", "running"], "prod": ["V", "a_reg"], "r": ["DW", "csub"], "running": ["rst", "start"], "sub": ["a_reg", "tq"], "t": ["K", "prod"], "tq": ["Q", "t"]} | CC-BY-4.0 | 26 | 0 | 19 | done | null | [] | null | true | [
"a"
] | null | // barrett_ct — CONSTANT-TIME Barrett modular reduction for Kyber / ML-KEM (q = 3329). This is the REAL,
// value-correct Barrett reduce (the same construction as the reference `barrett_reduce`), not a placeholder:
//
// t = round(v * a / 2^K) with v = round(2^K / q) = 20159, K = 26 (the canonical Kyber constan... | CONSTANT_TIME |
7 | LEAKY | LEAKY — 'done' depends on a.
How each secret reaches it (shortest path first):
a
├─ acc
└─ done
Each arrow is a dependency edge: an assignment, or a condition guarding
one. The analysis over-approximates, so a path may be unreachable at run
time — read it and decide. That is why it is printed. | barrett_leaky.v | {"acc": ["Q", "a", "rst", "running", "start"], "done": ["Q", "acc", "running"], "r": ["DW", "acc"], "running": ["rst", "start"]} | CC-BY-4.0 | 12 | 1 | 9 | done | [{"secret": "a", "observation": "done", "signals": ["a", "acc", "done"], "length": 2}] | [
"a"
] | null | true | [
"a"
] | 2 | // barrett_leaky — the NON-constant-time counterpart of `barrett_ct`: a naive "reduce by repeated subtraction"
// normalization that LOOPS `acc -= Q` until `acc < Q`. This is a real, tempting implementation (no multiplier,
// tiny area — a common way people "just reduce mod q") but the NUMBER of iterations, hence the c... | LEAKY |
6 | CONSTANT_TIME | null | barrett_buggy.v | {"a_reg": ["a", "rst", "start"], "cadd": ["Q", "sub"], "cnt": ["W", "rst", "running", "start"], "csub": ["Q", "cadd"], "done": ["W", "cnt", "running"], "prod": ["V", "a_reg"], "r": ["DW", "csub"], "running": ["rst", "start"], "sub": ["a_reg", "tq"], "t": ["K", "prod"], "tq": ["Q", "t"]} | CC-BY-4.0 | 26 | 0 | 19 | done | null | [] | null | true | [
"a"
] | null | // barrett_buggy — a BUGGY Barrett reduction (the WS-B teeth): identical to `barrett_ct.v` except the Barrett
// SHIFT is WRONG (K = 25 instead of the canonical 26). The reciprocal constant V = round(2^26/3329) is
// calibrated for a 2^26 shift; using 2^25 scales the quotient estimate `t` by ~2x, an error far outside w... | CONSTANT_TIME |
6 | CONSTANT_TIME | null | ct_cmp.v | {"cnt": ["W", "rst", "running", "start"], "diff": ["W", "cnt", "rst", "running", "start", "xr", "yr"], "done": ["W", "cnt", "running"], "equal": ["diff"], "running": ["rst", "start"], "xr": ["W", "cnt", "rst", "running", "start", "x"], "yr": ["W", "cnt", "rst", "running", "start", "y"]} | CC-BY-4.0 | 29 | 0 | 12 | done | null | [] | null | true | [
"x",
"y"
] | null | // ct_cmp — CONSTANT-TIME equality/compare that ALWAYS scans all W bits (the memcmp-hardening pattern used
// against timing side channels in MAC/tag comparison). It accumulates a difference flag every cycle but never
// exits early, so `done = running & (cnt == W)` is a data-oblivious counter — completion timing is in... | CONSTANT_TIME |
9 | LEAKY | LEAKY — 'done' depends on x, y.
How each secret reaches it (shortest path first):
x
├─ xr
└─ done
y
├─ yr
└─ done
Each arrow is a dependency edge: an assignment, or a condition guarding
one. The analysis over-approximates, so a path may be unreachable at run
time — read it and decide. That is why it is ... | cmp_leaky.v | {"diff": ["rst", "running", "start", "xr", "yr"], "done": ["diff", "running", "xr", "yr"], "equal": ["diff"], "running": ["rst", "start"], "xr": ["diff", "rst", "running", "start", "x", "yr"], "yr": ["diff", "rst", "running", "start", "xr", "y"]} | CC-BY-4.0 | 24 | 10 | 10 | done | [{"secret": "x", "observation": "done", "signals": ["x", "xr", "done"], "length": 2}, {"secret": "x", "observation": "done", "signals": ["x", "xr", "diff", "done"], "length": 3}, {"secret": "x", "observation": "done", "signals": ["x", "xr", "yr", "done"], "length": 3}, {"secret": "x", "observation": "done", "signals": ... | [
"x",
"y"
] | null | true | [
"x",
"y"
] | 2 | // cmp_leaky — the LEAKY counterpart of `ct_cmp`: the classic early-exit memcmp that stops at the first
// differing bit, so `done` timing leaks the position of the first mismatch (a textbook tag/MAC timing oracle).
// Its completion cone contains operand bits, so no operand-free inductive invariant exists and the
// s... | LEAKY |
8 | CONSTANT_TIME | null | ct_div_wide.v | {"a_shift": ["WIDTH", "a", "done_now", "resetn", "running", "start"], "b_reg": ["b", "resetn", "running", "start"], "cnt": ["done_now", "resetn", "running", "start"], "done": ["done_now", "resetn", "running", "start"], "done_now": ["CW", "WIDTH", "cnt", "running"], "ge": ["b_reg", "rem_shifted"], "q": ["done_now", "q_r... | CC-BY-4.0 | 54 | 0 | 19 | done | null | [] | null | true | [
"a",
"b"
] | null | // ct_div_wide — a parameterized CONSTANT-TIME restoring divider with wipe-on-done, in clean RTL.
//
// Purpose (SCALE demonstration): the completion signal `done` is a pure function of the iteration COUNTER
// (cnt == W), never of the operand data — so the divider runs EXACTLY W fixed cycles regardless of a/b, i.e.
//... | CONSTANT_TIME |
16 | LEAKY | LEAKY — 'done' depends on a, b.
How each secret reaches it (shortest path first):
a
├─ a_shift
├─ rem_shifted
├─ rem_next
├─ rem_reg
├─ done_now
└─ done
b
├─ b_reg
├─ rem_next
├─ rem_reg
├─ done_now
└─ done
Each arrow is a dependency edge: an assignment, or a condition guarding
one. The an... | ct_div_leaky.v | {"a_shift": ["WIDTH", "a", "done_now", "resetn", "running", "start"], "b_reg": ["b", "resetn", "running", "start"], "cnt": ["done_now", "resetn", "running", "start"], "done": ["done_now", "resetn", "running", "start"], "done_now": ["CW", "WIDTH", "cnt", "rem_reg", "running"], "ge": ["b_reg", "rem_shifted"], "q": ["done... | CC-BY-4.0 | 55 | 8 | 19 | done | [{"secret": "a", "observation": "done", "signals": ["a", "a_shift", "rem_shifted", "rem_next", "rem_reg", "done_now", "done"], "length": 6}, {"secret": "a", "observation": "done", "signals": ["a", "a_shift", "rem_shifted", "ge", "rem_next", "rem_reg", "done_now", "done"], "length": 7}, {"secret": "a", "observation": "d... | [
"a",
"b"
] | null | true | [
"a",
"b"
] | 5 | // ct_div_leaky — the LEAKY TWIN of ct_div_wide (the teeth for the constant-time scaling proof).
//
// IDENTICAL to ct_div_wide EXCEPT the completion `done_now` also fires on an EARLY-EXIT when the running
// remainder reaches zero (`rem_reg == 0`). That makes the completion cycle DATA-DEPENDENT: for operands whose
// ... | LEAKY |
6 | CONSTANT_TIME | null | ct_gcd.v | {"a": ["K", "a_in", "b", "iter", "rst", "running", "start"], "b": ["K", "a", "b_in", "iter", "rst", "running", "start"], "done": ["K", "iter", "running"], "gcd_out": ["a"], "iter": ["K", "rst", "running", "start"], "running": ["rst", "start"]} | CC-BY-4.0 | 24 | 0 | 11 | done | null | [] | null | true | [
"a_in",
"b_in"
] | null | // ct_gcd — fixed-iteration (constant-time) GCD. `done` is a function ONLY of a cycle counter `iter`
// that advances unconditionally while running, so completion time is FIXED (K cycles) regardless of the
// secret operands — i.e. the timing observable is data-oblivious. The datapath still reduces the secret
// operan... | CONSTANT_TIME |
9 | LEAKY | LEAKY — 'done' depends on a_in, b_in.
How each secret reaches it (shortest path first):
a_in
├─ a
├─ eq
└─ done
b_in
├─ b
├─ eq
└─ done
Each arrow is a dependency edge: an assignment, or a condition guarding
one. The analysis over-approximates, so a path may be unreachable at run
time — read it and ... | euclid_gcd.v | {"a": ["a_in", "b", "eq", "rst", "running", "start"], "b": ["a", "b_in", "eq", "rst", "running", "start"], "done": ["eq", "running"], "eq": ["a", "b"], "gcd_out": ["a"], "running": ["rst", "start"]} | CC-BY-4.0 | 19 | 4 | 10 | done | [{"secret": "a_in", "observation": "done", "signals": ["a_in", "a", "eq", "done"], "length": 3}, {"secret": "a_in", "observation": "done", "signals": ["a_in", "a", "b", "eq", "done"], "length": 4}, {"secret": "b_in", "observation": "done", "signals": ["b_in", "b", "eq", "done"], "length": 3}, {"secret": "b_in", "observ... | [
"a_in",
"b_in"
] | null | true | [
"a_in",
"b_in"
] | 3 | // euclid_gcd — subtractive Euclidean GCD. The canonical NON-constant-time datapath: the number of
// reduction steps (hence the cycle at which `done` asserts) depends on the SECRET operands, so the
// completion time leaks operand structure. This is the negative / found-bug design: a self-composition
// proof of timin... | LEAKY |
6 | CONSTANT_TIME | null | euclid_gcd_repaired.v | {"a": ["K", "a_in", "b", "iter", "rst", "running", "start"], "b": ["K", "a", "b_in", "iter", "rst", "running", "start"], "done": ["K", "iter", "running"], "gcd_out": ["a"], "iter": ["K", "rst", "running", "start"], "running": ["rst", "start"]} | CC-BY-4.0 | 24 | 0 | 11 | done | null | [] | null | true | [
"a_in",
"b_in"
] | null | // euclid_gcd_repaired — the CERTIFIED REPAIR of `euclid_gcd.v` (WS-C). Generated by applying ONE known
// countermeasure class (fixed-trip-count / data-oblivious control) to the leaky design, in response to its
// timing-leak counterexample. This is NOT a hand-written ct_gcd: it PRESERVES euclid's own subtractive
// r... | CONSTANT_TIME |
6 | CONSTANT_TIME | null | ct_modmul.v | {"acc": ["W", "ar", "br", "cnt", "rst", "running", "start"], "ar": ["a", "rst", "start"], "br": ["W", "b", "cnt", "rst", "running", "start"], "cnt": ["W", "rst", "running", "start"], "done": ["W", "cnt", "running"], "mr": ["m", "rst", "start"], "result": ["W", "acc"], "running": ["rst", "start"]} | CC-BY-4.0 | 30 | 0 | 14 | done | null | [] | null | true | [
"a",
"b",
"m"
] | null | // ct_modmul — CONSTANT-TIME double-and-add modular multiplication `a*b mod m` (a building block of RSA/ECC
// scalar routines). Every cycle it doubles the accumulator and conditionally adds `a`, with a conditional
// modular reduction — but the multiplier bit only SELECTS values; it never gates control. Completion
// ... | CONSTANT_TIME |
6 | LEAKY | LEAKY — 'done' depends on b.
How each secret reaches it (shortest path first):
b
├─ br
└─ done
Each arrow is a dependency edge: an assignment, or a condition guarding
one. The analysis over-approximates, so a path may be unreachable at run
time — read it and decide. That is why it is printed. | modmul_leaky.v | {"acc": ["W", "ar", "br", "rst", "running", "start"], "ar": ["a", "rst", "start"], "br": ["b", "rst", "running", "start"], "done": ["br", "running"], "mr": ["m", "rst", "start"], "result": ["W", "acc"], "running": ["rst", "start"]} | CC-BY-4.0 | 22 | 1 | 13 | done | [{"secret": "b", "observation": "done", "signals": ["b", "br", "done"], "length": 2}] | [
"b"
] | null | true | [
"a",
"b",
"m"
] | 2 | // modmul_leaky — the LEAKY counterpart of `ct_modmul`: it early-exits once the residual multiplier `br` is
// zero (skipping the remaining doublings), so `done` timing leaks the multiplier's MSB position. The
// completion cone contains operand bits, so the self-composition proof correctly REFUSES to certify it.
modul... | LEAKY |
6 | CONSTANT_TIME | null | ct_mul.v | {"acc": ["W", "cnt", "mcand", "mplier", "rst", "running", "start"], "cnt": ["W", "rst", "running", "start"], "done": ["W", "cnt", "running"], "mcand": ["W", "a", "cnt", "rst", "running", "start"], "mplier": ["W", "b", "cnt", "rst", "running", "start"], "prod": ["acc"], "running": ["rst", "start"]} | CC-BY-4.0 | 29 | 0 | 12 | done | null | [] | null | true | [
"a",
"b"
] | null | // ct_mul — CONSTANT-TIME shift-add multiplier. Runs EXACTLY W iterations regardless of the operands:
// every cycle it conditionally adds the (shifted) multiplicand based on the current multiplier bit, but the
// bit only SELECTS a value — it never gates the control. Completion `done = running & (cnt == W)` is a plain... | CONSTANT_TIME |
6 | LEAKY | LEAKY — 'done' depends on b.
How each secret reaches it (shortest path first):
b
├─ mplier
└─ done
Each arrow is a dependency edge: an assignment, or a condition guarding
one. The analysis over-approximates, so a path may be unreachable at run
time — read it and decide. That is why it is printed. | mul_leaky.v | {"acc": ["mcand", "mplier", "rst", "running", "start"], "done": ["mplier", "running"], "mcand": ["W", "a", "mplier", "rst", "running", "start"], "mplier": ["b", "rst", "running", "start"], "prod": ["acc"], "running": ["rst", "start"]} | CC-BY-4.0 | 20 | 1 | 11 | done | [{"secret": "b", "observation": "done", "signals": ["b", "mplier", "done"], "length": 2}] | [
"b"
] | null | true | [
"a",
"b"
] | 2 | // mul_leaky — the LEAKY counterpart of `ct_mul`: it early-exits as soon as the residual multiplier becomes
// zero, so `done` fires after a number of cycles equal to the multiplier's MSB position — a timing channel
// that leaks the secret operand's bit-length. The completion cone contains operand bits (via `mplier==0... | LEAKY |
6 | CONSTANT_TIME | null | modexp_ct.v | {"acc": ["W", "cnt", "e", "rst", "running", "sq", "start"], "cnt": ["W", "rst", "running", "start"], "done": ["W", "cnt", "running"], "e": ["W", "cnt", "exp", "rst", "running", "start"], "result": ["acc"], "running": ["rst", "start"], "sq": ["W", "base", "cnt", "rst", "running", "start"]} | CC-BY-4.0 | 29 | 0 | 12 | done | null | [] | null | true | [
"base",
"exp",
"modulus"
] | null | // modexp_ct — CONSTANT-TIME square-and-multiply-ALWAYS modular exponentiation control, the standard RSA
// timing-attack countermeasure (the always-multiply / constant-time-exponentiation defense — the exponent
// bit never gates control, only selects a value; this is the always-multiply class, distinct from but in th... | CONSTANT_TIME |
8 | LEAKY | LEAKY — 'done' depends on exp.
How each secret reaches it (shortest path first):
exp
├─ e
└─ done
Each arrow is a dependency edge: an assignment, or a condition guarding
one. The analysis over-approximates, so a path may be unreachable at run
time — read it and decide. That is why it is printed. | modexp_leaky.v | {"acc": ["W", "cnt", "e", "rst", "running", "sq", "start"], "cnt": ["W", "e", "rst", "running", "start"], "done": ["W", "cnt", "e", "running"], "e": ["W", "cnt", "exp", "rst", "running", "start"], "result": ["acc"], "running": ["rst", "start"], "sq": ["W", "base", "cnt", "e", "rst", "running", "start"]} | CC-BY-4.0 | 32 | 2 | 12 | done | [{"secret": "exp", "observation": "done", "signals": ["exp", "e", "done"], "length": 2}, {"secret": "exp", "observation": "done", "signals": ["exp", "e", "cnt", "done"], "length": 3}] | [
"exp"
] | null | true | [
"base",
"exp",
"modulus"
] | 2 | // modexp_leaky — the NON-constant-time counterpart of `modexp_ct`: a square-and-multiply modular
// exponentiation that EARLY-EXITS when the remaining exponent register is all zeros. That is a real,
// tempting optimization (skip the trailing zero exponent bits), but it makes the completion cycle — hence
// `done` — d... | LEAKY |
6 | CONSTANT_TIME | null | x25519_fieldmul.v | {"acc": ["W", "ar", "br", "cnt", "rst", "running", "start"], "ar": ["opa", "rst", "start"], "br": ["W", "cnt", "opb", "rst", "running", "start"], "cnt": ["W", "rst", "running", "start"], "done": ["W", "cnt", "running"], "mr": ["modulus", "rst", "start"], "result": ["W", "acc"], "running": ["rst", "start"]} | CC-BY-4.0 | 30 | 0 | 14 | done | null | [] | null | true | [
"opa",
"opb",
"modulus"
] | null | // x25519_fieldmul — CONSTANT-TIME field multiplication `opa * opb mod modulus`, the inner primitive of an
// X25519 / Curve25519 Montgomery-ladder step (the field GF(2^255-19), modeled here at a tractable width W).
// The completion-channel CT ARGUMENT is width-parametric in structure, BUT this committed RTL is fixed ... | CONSTANT_TIME |
6 | LEAKY | LEAKY — 'done' depends on opb.
How each secret reaches it (shortest path first):
opb
├─ br
└─ done
Each arrow is a dependency edge: an assignment, or a condition guarding
one. The analysis over-approximates, so a path may be unreachable at run
time — read it and decide. That is why it is printed. | x25519_fieldmul_leaky.v | {"acc": ["W", "ar", "br", "rst", "running", "start"], "ar": ["opa", "rst", "start"], "br": ["opb", "rst", "running", "start"], "done": ["br", "running"], "mr": ["modulus", "rst", "start"], "result": ["W", "acc"], "running": ["rst", "start"]} | CC-BY-4.0 | 22 | 1 | 13 | done | [{"secret": "opb", "observation": "done", "signals": ["opb", "br", "done"], "length": 2}] | [
"opb"
] | null | true | [
"opa",
"opb",
"modulus"
] | 2 | // x25519_fieldmul_leaky — the LEAKY counterpart of `x25519_fieldmul`: it early-exits once the residual
// multiplier `br` is zero, skipping the remaining doublings, so `done` timing leaks the secret multiplier's
// most-significant set-bit position (its bit-length). The completion cone therefore contains operand bits,... | LEAKY |
null | null | null | barrett_spec.v | {"r": ["a"]} | CC-BY-4.0 | 1 | 0 | 2 | null | null | null | null | false | [] | null | // barrett_spec — the PUBLIC golden specification for the Kyber / ML-KEM Barrett reduction (WS-B): the plain
// arithmetic contract `r == a mod 3329` over the full 16-bit coefficient domain. This is the FIPS/spec-level
// reference the `barrett_ct` datapath is bit-exact to, over ALL 2^16 inputs. Purely combinational — ... | null |
null | null | null | alu_unprotected.v | {"_unused": ["a2", "b2", "op2"], "error_flag": [], "out": ["r0"], "r0": ["a", "b", "op"]} | CC-BY-4.0 | 7 | 0 | 10 | null | null | null | null | false | [] | null | // alu_unprotected — the UNPROTECTED ALU: same datapath as `parity_alu.v`, but NO fault detection
// (`error_flag` hardwired 0). The teeth for WS-A: a single modeled stuck-at in the OUT datapath corrupts `out`
// with error_flag never rising, so the golden_faulted 2-safety miter finds an UNDETECTED fault (`differ` SAT)... | null |
null | null | null | parity_alu.v | {"error_flag": ["r0", "r1"], "out": ["r0"], "r0": ["a", "b", "op"], "r1": ["a2", "b2", "op2"]} | CC-BY-4.0 | 9 | 0 | 10 | null | null | null | null | false | [] | null | // parity_alu — a fault-RESISTANT 4-bit ALU (the PROVEN side of the fault-injection twin, WS-A).
//
// The datapath `r0 = op(a,b)` is computed TWICE by two structurally-distinct copies (r0 from a/b/op, r1 from
// a2/b2/op2) and compared: `error_flag = |(r0 ^ r1)` — a concurrent-error-detection (CED) duplicate-and-compa... | null |
null | null | null | parity_alu_singlebit.v | {"error_flag": ["r0", "r1"], "out": ["r0"], "r0": ["a", "b", "op"], "r1": ["a2", "b2", "op2"]} | CC-BY-4.0 | 9 | 0 | 10 | null | null | null | null | false | [] | null | // parity_alu_singlebit — a PARTIAL countermeasure (the second WS-A teeth): the duplicate-and-compare covers
// only output bits [2:0] and IGNORES bit 3, mirroring `pcpi_div_halfwipe.v` (a countermeasure that protects
// only part of the state). A single modeled stuck-at on the bit-3 datapath corrupts `out[3]` while `e... | null |
null | null | null | pcpi_div.v | null | ISC | 0 | 0 | 0 | null | null | null | line 70: preprocessor directive is outside the supported Verilog subset ('`ifdef'). Dependencies created by it would be invisible to the cone analysis, so no verdict is returned. Flatten the design to a single module of assign/always statements, or analyse the submodule directly with --module. | false | [] | null | // Vendored standalone copy of picorv32_pcpi_div (the RISC-V DIV/REM co-processor) from
// the upstream picorv32 project (ISC license) -- see LICENSE-FIXTURES for full attribution.
// Completion is (!quotient_msk && running); quotient_msk is a pure 1<<31 >>1 shift register — so the
// completion cycle is data-oblivious... | UNKNOWN |
null | null | null | pcpi_div_wiped.v | {"dividend": ["divisor", "instr_div", "instr_rem", "pcpi_rs1", "quotient_msk", "resetn", "running", "start"], "divisor": ["instr_div", "instr_rem", "pcpi_rs2", "quotient_msk", "resetn", "running", "start"], "instr_any_div_rem": ["instr_div", "instr_divu", "instr_rem", "instr_remu"], "instr_div": ["pcpi_insn", "pcpi_rea... | ISC | 78 | 0 | 22 | null | null | null | null | false | [] | null | // WS-7 — no-secret-residue repair of picorv32_pcpi_div. Byte-identical to rtl_ct/pcpi_div.v EXCEPT that on the
// completion cycle (`!quotient_msk && running`) the operand-derived scratch registers are ZEROED, so no operand
// residue survives past `done`. pcpi_rd is a non-blocking assignment from the PRE-clock quotie... | null |
null | null | null | pcpi_div_halfwipe.v | {"dividend": ["divisor", "instr_div", "instr_rem", "pcpi_rs1", "quotient_msk", "resetn", "running", "start"], "divisor": ["instr_div", "instr_rem", "pcpi_rs2", "quotient_msk", "resetn", "running", "start"], "instr_any_div_rem": ["instr_div", "instr_divu", "instr_rem", "instr_remu"], "instr_div": ["pcpi_insn", "pcpi_rea... | ISC | 76 | 0 | 22 | null | null | null | null | false | [] | null | // WS-7 TEETH — a DELIBERATELY INCOMPLETE wipe. Identical to pcpi_div_wiped.v except it clears only `dividend`
// and leaves `divisor` holding operand-derived residue at completion. residue_check MUST still REFUSE this
// variant: a partial wipe is not no-residue. If this were accepted, the property would be vacuous.
m... | null |
null | null | null | pcpi_mul.v | null | ISC | 0 | 0 | 0 | null | null | null | line 67: for loop is outside the supported Verilog subset ('for ('). Dependencies created by it would be invisible to the cone analysis, so no verdict is returned. Flatten the design to a single module of assign/always statements, or analyse the submodule directly with --module. | false | [] | null | // Vendored standalone copy of picorv32_pcpi_mul (the RISC-V MUL/MULH co-processor) from
// the upstream picorv32 project (ISC license) -- see LICENSE-FIXTURES for full attribution.
// Completion is `pcpi_ready <= mul_finish`, and `mul_finish <= mul_counter[6]` where `mul_counter`
// is loaded from a fixed constant (63... | UNKNOWN |
null | null | null | tb_ct.v | null | CC-BY-4.0 | 0 | 0 | 0 | null | null | null | line 12: module instantiation is outside the supported Verilog subset ('euclid_gcd EU ('). Dependencies created by it would be invisible to the cone analysis, so no verdict is returned. Flatten the design to a single module of assign/always statements, or analyse the submodule directly with --module. | false | [] | null | // Cross-check testbench: does the ACTUAL RTL behave as the hand-authored z3 relation claims?
// - euclid_gcd: two secret operand pairs must complete at DIFFERENT cycles (the leak is real in RTL).
// - ct_gcd: any secret operand pair must complete at the SAME fixed cycle (constant-time in RTL).
// Prints "DONE ... | UNKNOWN |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.