fips205-slhdsa-verified/verification/check.sh

104 lines
4.6 KiB
Bash
Raw Normal View History

#!/usr/bin/env bash
# The one-button claim for this repository (rigor invariant R3).
2026-07-23 09:34:59 +00:00
# Green output == the full claim. This script is the ONLY source of the
# word "proven" for this repo.
#
2026-07-23 09:34:59 +00:00
# Phase 1 — compile the extracted Lean model (gen/SlhVerify).
# Phase 2 — compile the proof files (Proofs/).
review round 2: in-Lean exact-cone audit + reproducibility + doc honesty Addresses the round-2 reviewer punch-list. No theorem statement, proof term, or fold definition changed; the eleven cones are unchanged (independent collectAxioms dump in verification/RECORDED-RUN.md). AUDIT GATE (both reviewers, the critical one) - Retire the bash #print-axioms text parser (fail-open on empty/truncated reports, and only a SUBSET check). Replace with verification/Proofs/Audit.lean: reads each certificate's cone from the kernel via collectAxioms and asserts EXACT set equality against its expected boundary. Extra axiom, dropped oracle, renamed/deleted cert, or an axiom/opaque sham each throw -> non-zero Lean exit. No text to misparse; nothing fails open. check.sh Phase 3 now just compiles it (and still requires the explicit PASSED line). - check-selftest.sh rewritten to attack the new gate: dead-file, smuggled extra axiom (named), dropped-oracle (subset would pass, exact must not), and a vanished certificate (the collectAxioms-returns-[] trap). All four rejected. REPRODUCIBILITY (GPT B1.4 / B1.5) - extract.sh refuses a wrong-commit or dirty source tree (fail-closed), takes an optional source-path arg, and pins the source commit. - verification/PROVENANCE.json: single machine-readable pin set (source + charon + aeneas commits/channel + lean + ocaml) with generated-file sha256. - Re-running extract.sh reproduces gen/SlhVerify/{Types,Funs}.lean byte-identically (companion fips205-source commit adds Cargo.lock + rust-toolchain.toml; verified not to perturb the model). DOC HONESTY (both reviewers) - README: fix the self-contradiction (apex "not yet proven" trailer vs the proven apex), the false "oracles kept OUTSIDE every cone" (they are INSIDE, by design), "deployed monomorphic path" and "semantics-identical for every parameter set" overclaims, "only two lines changed", stale snapshot head; retitle the stale future-tense "what will be claimed" section. - TRUSTED-BASE: drop "nothing proven yet"; add base_2b-inner and deployment- bridge non-claims explicitly; current pin. - ChainSpec header: "deployed monomorphic path" -> private verify_mono facade (comment only). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-24 17:13:55 +00:00
# Phase 3 — axiom audit, performed INSIDE Lean (Proofs/Audit.lean): each
# certificate's cone, read from the kernel via `collectAxioms`, must
# EQUAL its expected set EXACTLY — kernel-3 plus only the named SHA-2
# oracles. No text parsing (round-2 review closed that class of bug);
# any extra, any missing, a renamed/deleted cert, or an axiom/opaque
# sham is a Lean elaboration error → non-zero exit → fail-closed.
set -euo pipefail
HERE="$(cd "$(dirname "$0")" && pwd)"
source ~/aeneas-toolchain/env.sh
AENEAS_LEAN="$AENEAS_HOME/backends/lean"
2026-07-23 09:34:59 +00:00
TIMEOUT="${LEAN_TIMEOUT:-400}"
MEM="${LEAN_MEM_MB:-4096}"
GEN_MODULES=(
"SlhVerify/TypesExternal"
"SlhVerify/Types"
"SlhVerify/FunsExternal"
"SlhVerify/Funs"
)
2026-07-23 09:34:59 +00:00
# Proof files, in dependency order.
PROOFS=(
"ChainSpec"
"WotsSpec"
phase 2: THIRD CERTIFICATE — XMSS auth-path Merkle loop (Algorithm 10) fips205.xmss_loop_eq (Proofs/XmssSpec.lean): the extracted xmss_pk_from_sig_free_loop equals the explicit Merkle-path fold — at step k set the tree height to k+1, test bit k of the leaf index; even bit: tree_index := i/2 and H(node || auth[k]); odd bit: tree_index := (i-1)/2 and H(auth[k] || node). This pins the sibling hash ORDER, the address schedule, and the auth-path indexing of Merkle verification. Exact cone: [propext, Classical.choice, Quot.sound, verify_mono.oracle.h] — the first certificate where H enters; F does not (the loop runs above the WOTS+ computation). check.sh green over all three certificates. Fidelity review at authorship (three-way): extracted body (gen Funs.lean 761-801) == Rust verify_mono.rs xmss_pk_from_sig_free (verbatim from upstream xmss.rs, hash calls -> oracle) == FIPS 205 Algorithm 10, incl. the per-branch operation order (even: node-slice then auth[k]; odd: auth[k] then node-slice) and the k+1 tree height. Proof: the chain/wots recipe on a u32 range — u32_succ / fwd_succ / hnext / loop_unfold_bind reused VERBATIM from ChainSpec. New layer lesson (the one novel obstruction, on pattern): the loop body BRANCHES on the index bit, so the step lemma splits with by_cases + if_pos/if_neg; and the get_tree_index pair-bind needs its matcher made concrete before the tail normalizes — bind_congr + rintro to fix the scrutinee, then FULL simp (only full simp iota-reduces the pair matcher; simp only will not) with bind_assoc + bind_ok + the loop def closes each branch. The certificate's own induction threads the IH under the opaque binds of BOTH branches with bind_congr, per branch, ending exact ih. check.sh: PROOFS += XmssSpec, CERTS += fips205.xmss_loop_eq, audit imports XmssSpec (self-test structure anchors untouched). README: status three certificates, Algorithm numbering per upstream comments (wots=8, xmss=10). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-23 14:18:44 +00:00
"XmssSpec"
phase 2: FOURTH CERTIFICATE — hypertree layer walk (Algorithm 12) + de-plumbing fips205.ht_loop_eq (Proofs/HtSpec.lean): the extracted ht_verify_free_loop equals the explicit d-layer fold — at layer j: idx_leaf = idx_tree masked to h' bits (mask+cast), idx_tree >>= h', layer address j, tree address to the shifted index, node recomputed through xmss_pk_from_sig on the j-th XMSS signature. Pins the hypertree layer schedule; the final node == pk_root comparison sits one bind above in ht_verify_free (apex material). Exact cone: [propext, Classical.choice, Quot.sound, verify_mono.oracle.f, verify_mono.oracle.h, verify_mono.oracle.t_l] — kernel-3 plus exactly the three hash primitives the referenced WOTS+/XMSS machinery touches. THE LAYER'S OBSTRUCTION (one per layer, on pattern) was not the proof but the CONE: the first extraction of this loop carried Result-conversion plumbing (try_from/is_err/unwrap; transitively a Take iterator and the &u32 Sub instance) — all axioms, rightly rejected by the Phase-3 audit. Fixed at SOURCE level (fips205-source 6f6a9d6, 8 sites, semantics identical for every FIPS 205 parameter set, differential test re-run green), then re-extracted: the loop body is now straight-line and the proof is the plain chain/wots recipe (no branches; base case via loop.eq_1; step lemma closes by rfl; induction = bind_congr ×12). Also in this commit: - gen/ regenerated from the patched snapshot (loop bodies of the three prior certificates byte-identical modulo source line comments; all three proofs recompiled unchanged and re-audited green). - Dead-stub deletion (axiom-shadowing hygiene rule): the five obsoleted plumbing axioms + vestigial take.default removed from FunsExternal, the orphaned TryFromIntError type axiom removed from TypesExternal. The model's external surface is now: 5 SHA-2 oracles (the boundary), the Take iterator machinery used only by helpers::to_int (apex round's de-plumbing item), 3 zeroize blanket impls (never on the verify path), and the discharged-real u32 Step defs. - check.sh: PROOFS += HtSpec, CERTS += fips205.ht_loop_eq, audit import (self-test structure anchors untouched). README: four certificates + the de-plumbing record. Fidelity review at authorship (three-way): extracted body == Rust ht_verify_free (verbatim from upstream hypertree.rs, calls -> *_free) == FIPS 205 Algorithm 12, incl. mask-then-shift order and layer-then-tree address order. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-23 15:14:21 +00:00
"HtSpec"
phase 2: FIFTH CERTIFICATE — FORS pk-from-sig (Algorithm 17), inner + outer loops Two theorems, split into two files (METHOD-4 discipline — each proof a clean unit). NB: an early single-file/bare-rfl attempt appeared to "OOM at the clamp", but that memory pressure was a SYMPTOM of the runaway whnf diagnosed below, not a real memory need — the fixed proofs compile in seconds at the default caps. fips205.fors_inner_loop_eq (Proofs/ForsInnerSpec.lean): the extracted inner Merkle auth-path loop for ONE FORS tree (fors_pk_from_sig_free_loop0_loop0) equals the explicit auth-path fold — at level j set tree height j+1, test bit j of THIS tree's leaf index indices[i], hash the current node with auth.tree[j] in the bit order (even: node||auth[j]; odd: auth[j]||node), halving the tree index. Structurally the XMSS auth-path loop, but the bit source is indices[i]>>j and the loop returns the (adrs,node) pair. Cone: kernel-3 + verify_mono.oracle.h. fips205.fors_outer_loop_eq (Proofs/ForsOuterSpec.lean): the extracted outer per-tree loop (fors_pk_from_sig_free_loop0) equals the explicit K-tree fold — for each tree i, compute the leaf with F at tree index (i<<a)+indices[i], run the inner Merkle loop over the A levels, write the result to root[i]. Consumes the inner loop as an opaque sub-call. Cone: kernel-3 + verify_mono.oracle.{f,h} (F per leaf; H transitively through the inner loop). Fidelity review at authorship (three-way, both loops): extracted bodies (gen Funs.lean 893-933 inner, 954-985 outer) == Rust verify_mono.rs fors_pk_from_sig_free (verbatim from upstream fors.rs, hash calls -> oracle) == FIPS 205 Algorithm 17, incl. the even/odd sibling order and the (i<<a)+indices[i] leaf index. Proof: the branched-Merkle recipe (XMSS) for the inner loop (by_cases on the index bit, pair-bind matcher made concrete via bind_congr+rintro then full simp); the HT straight-line recipe for the outer loop, adapted (bind_congr-peeled step lemma + bind_congr x16 induction, both threading the inner-loop sub-call opaquely). loop_unfold_bind / u32_succ / fwd_succ / hnext reused verbatim from ChainSpec. check.sh: PROOFS += ForsInnerSpec, ForsOuterSpec; CERTS += the two fors certs; audit imports both; check.sh settings unchanged (400s/4096MB). ForsOuterSpec compiles in 4.4s / 2.4GB after the fix below. check.sh green over ALL SIX certificates with the axiom audit. README status -> FIVE certificates. DIAGNOSIS NOTE (honesty): ForsOuterSpec's fors_outer_step first closed with a bare `rfl`, which whnf'd the whole 16-bind body INCLUDING the inner-loop `loop` term and hit a DETERMINISTIC 4M-heartbeat timeout (never actually passed — an earlier "green" reading was a misread wrapper exit code; the real error was hidden by check.sh piping per-file output to /dev/null). Fix: peel the 16 binds with bind_congr so the closing rfl only sees the small loop-tail, and close the post-pair-rintro tail with a full simp (the pair `let` won't iota via simp only). This is the HtSpec straight-line recipe adapted for a body that nests a loop. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-23 21:56:56 +00:00
"ForsInnerSpec"
"ForsOuterSpec"
phase 2: INPUT-PREP layer — to_int, to_byte, WOTS+ checksum (3 kernel-3 certs) Three straight-line range-loop fidelity theorems (Proofs/InputPrepSpec.lean), each #print axioms = EXACTLY [propext, Classical.choice, Quot.sound] — pure byte/bit arithmetic, NO hash oracle enters (the cleanest cones in the campaign): - fips205.to_int_loop_eq (Algorithm 2, toInt): the extracted big-endian byte->u64 loop = the fold total <- (total<<8) + x[i]. - fips205.to_byte_loop_eq (Algorithm 3, toByte): the extracted u32->byte loop = the fold writing s[n-1-i] and shifting total right by 8. - fips205.wots_csum_loop_eq: the WOTS+ checksum loop = the fold csum <- csum + (W-1-msg[i]). All three are the straight-line recipe (hbody -> step lemma closed by rfl -> induction with bind_congr per bind). to_int + checksum use the usize range helpers (WotsSpec), to_byte the u32 range (ChainSpec); loop_unfold_bind reused. Also in this commit — DE-PLUMBING ROUND 2 landed (source bea1051, separate commit in fips205-source): to_int's iter().take() and base_2b's iter_mut() became index loops, so both extract to real definitions. Consequently: - gen/ regenerated (to_int_loop / base_2b_loop0 now clean StepUsize range loops with Slice.index_usize / Slice.update; the six prior certificates recompiled UNCHANGED and re-audited green against the new gen). - The core::iter::adapters::take::Take::next AXIOM — the LAST non-oracle, non-zeroize plumbing axiom on the verify path — is now unreferenced and was DELETED from FunsExternal (dead-stub hygiene rule). The model's external surface is now EXACTLY: the 5 SHA-2 oracles + 3 zeroize blanket impls (never on the verify path) + the discharged-real u32 Step defs. Nothing else. Fidelity review at authorship (three-way): extracted loop bodies (gen Funs.lean) == Rust helpers.rs to_int/to_byte + verify_mono checksum (verbatim FIPS 205 Alg 2/3) == the folds above. check.sh: PROOFS += InputPrepSpec; CERTS += the 3 certs; audit imports it. Green over ALL NINE certificates at default caps (400s/4096MB). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-24 06:55:34 +00:00
"InputPrepSpec"
phase 2: THE APEX — slh_verify_128s accepts iff recomputed root = pk_root fips205.slh_verify_128s_accepts_iff (Proofs/ApexSpec.lean): the extracted top-level SLH-DSA-SHA2-128s verifier returns `ok true` if and only if the recomputed hypertree root byte-equals the pinned public-key root pk.pk_root. There is NO acceptance path other than root equality. slh_verify_128s mprime sig pk = (do let root ← slhVerifyRoot 63 30 mprime sig pk ok (decide (root.val = pk.pk_root.val))) where slhVerifyRoot is byte-for-byte the extracted slh_verify_internal_free pipeline (H_msg digest -> md/idx_tree/idx_leaf split via to_int + masks -> fors_pk_from_sig -> hypertree recompute over xmss over wots over chain), with only the final ht_verify_free comparison factored out. #print axioms cone = EXACTLY [propext, Classical.choice, Quot.sound, verify_mono.oracle.{f, h, h_msg, t_l, t_len}] — the three kernel axioms plus PRECISELY the five SHA-2 hash oracles, and nothing else. No plumbing, no transpiler artifacts. This is the boundary the whole campaign targeted: the deployed verify path is machine-checked down to five named hash functions. Structure: - arrayEqU8_spec: the library array equality PartialEqArray.eq on two Array U8 N returns exactly the decidable byte-equality of their lists (a List.allM induction; the one real lemma). This is what makes "accepts" mean "root byte-equals pk_root" explicitly, in the spirit of the ed25519 verify_accepts_iff. - ht_verify_free_split: ht_verify_free = htVerifyRoot >>= (byte-compare to pk_root), via arrayEqU8_spec on the tail; bind_congr threads the setup. - slh_verify_internal_accepts_iff (generic, all param sets) + the 128s corollary: unfold the internal, rewrite the ht tail with the split, flatten with bind_assoc; both sides become the identical do-block (simp closes structurally — no whnf of the nested ht_verify_free_loop, the ForsOuter lesson). Honest scope: the apex is an ACCEPTANCE characterization — it pins that the top-level accept is exactly root equality over the extracted recomputation, whose every loop is individually fidelity-certified by the ten preceding theorems (chain/wots/xmss/ht/fors/input-prep). It does NOT re-derive the recomputation as a closed-form mathematical hypertree value; that composition of all ten fold-fidelity theorems into one expression is a further step, not claimed here. The security-relevant statement — an accepted signature means the verifier recomputed a root matching the pinned key, down to five hash oracles — is exactly what is proven. check.sh: PROOFS += ApexSpec; CERTS += fips205.slh_verify_128s_accepts_iff; audit imports it. Green over ALL ELEVEN certificates at default caps. The verify-path proof pyramid is COMPLETE. What remains before any LTL attestation is operator-gated and NOT started (the big halt): the pacta allowed-cone table entry + the append ceremony with the operator signing key. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-24 07:58:06 +00:00
"ApexSpec"
2026-07-23 09:34:59 +00:00
)
# Certificates whose axiom cones are audited, and the allowed extras beyond
# the three kernel axioms: the five SHA-2 verify-path oracles. A certificate
# is listed here only once it is genuinely proven.
CERTS=(
"fips205.chain_free_loop_eq"
"fips205.wots_loop1_eq"
phase 2: THIRD CERTIFICATE — XMSS auth-path Merkle loop (Algorithm 10) fips205.xmss_loop_eq (Proofs/XmssSpec.lean): the extracted xmss_pk_from_sig_free_loop equals the explicit Merkle-path fold — at step k set the tree height to k+1, test bit k of the leaf index; even bit: tree_index := i/2 and H(node || auth[k]); odd bit: tree_index := (i-1)/2 and H(auth[k] || node). This pins the sibling hash ORDER, the address schedule, and the auth-path indexing of Merkle verification. Exact cone: [propext, Classical.choice, Quot.sound, verify_mono.oracle.h] — the first certificate where H enters; F does not (the loop runs above the WOTS+ computation). check.sh green over all three certificates. Fidelity review at authorship (three-way): extracted body (gen Funs.lean 761-801) == Rust verify_mono.rs xmss_pk_from_sig_free (verbatim from upstream xmss.rs, hash calls -> oracle) == FIPS 205 Algorithm 10, incl. the per-branch operation order (even: node-slice then auth[k]; odd: auth[k] then node-slice) and the k+1 tree height. Proof: the chain/wots recipe on a u32 range — u32_succ / fwd_succ / hnext / loop_unfold_bind reused VERBATIM from ChainSpec. New layer lesson (the one novel obstruction, on pattern): the loop body BRANCHES on the index bit, so the step lemma splits with by_cases + if_pos/if_neg; and the get_tree_index pair-bind needs its matcher made concrete before the tail normalizes — bind_congr + rintro to fix the scrutinee, then FULL simp (only full simp iota-reduces the pair matcher; simp only will not) with bind_assoc + bind_ok + the loop def closes each branch. The certificate's own induction threads the IH under the opaque binds of BOTH branches with bind_congr, per branch, ending exact ih. check.sh: PROOFS += XmssSpec, CERTS += fips205.xmss_loop_eq, audit imports XmssSpec (self-test structure anchors untouched). README: status three certificates, Algorithm numbering per upstream comments (wots=8, xmss=10). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-23 14:18:44 +00:00
"fips205.xmss_loop_eq"
phase 2: FOURTH CERTIFICATE — hypertree layer walk (Algorithm 12) + de-plumbing fips205.ht_loop_eq (Proofs/HtSpec.lean): the extracted ht_verify_free_loop equals the explicit d-layer fold — at layer j: idx_leaf = idx_tree masked to h' bits (mask+cast), idx_tree >>= h', layer address j, tree address to the shifted index, node recomputed through xmss_pk_from_sig on the j-th XMSS signature. Pins the hypertree layer schedule; the final node == pk_root comparison sits one bind above in ht_verify_free (apex material). Exact cone: [propext, Classical.choice, Quot.sound, verify_mono.oracle.f, verify_mono.oracle.h, verify_mono.oracle.t_l] — kernel-3 plus exactly the three hash primitives the referenced WOTS+/XMSS machinery touches. THE LAYER'S OBSTRUCTION (one per layer, on pattern) was not the proof but the CONE: the first extraction of this loop carried Result-conversion plumbing (try_from/is_err/unwrap; transitively a Take iterator and the &u32 Sub instance) — all axioms, rightly rejected by the Phase-3 audit. Fixed at SOURCE level (fips205-source 6f6a9d6, 8 sites, semantics identical for every FIPS 205 parameter set, differential test re-run green), then re-extracted: the loop body is now straight-line and the proof is the plain chain/wots recipe (no branches; base case via loop.eq_1; step lemma closes by rfl; induction = bind_congr ×12). Also in this commit: - gen/ regenerated from the patched snapshot (loop bodies of the three prior certificates byte-identical modulo source line comments; all three proofs recompiled unchanged and re-audited green). - Dead-stub deletion (axiom-shadowing hygiene rule): the five obsoleted plumbing axioms + vestigial take.default removed from FunsExternal, the orphaned TryFromIntError type axiom removed from TypesExternal. The model's external surface is now: 5 SHA-2 oracles (the boundary), the Take iterator machinery used only by helpers::to_int (apex round's de-plumbing item), 3 zeroize blanket impls (never on the verify path), and the discharged-real u32 Step defs. - check.sh: PROOFS += HtSpec, CERTS += fips205.ht_loop_eq, audit import (self-test structure anchors untouched). README: four certificates + the de-plumbing record. Fidelity review at authorship (three-way): extracted body == Rust ht_verify_free (verbatim from upstream hypertree.rs, calls -> *_free) == FIPS 205 Algorithm 12, incl. mask-then-shift order and layer-then-tree address order. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-23 15:14:21 +00:00
"fips205.ht_loop_eq"
phase 2: FIFTH CERTIFICATE — FORS pk-from-sig (Algorithm 17), inner + outer loops Two theorems, split into two files (METHOD-4 discipline — each proof a clean unit). NB: an early single-file/bare-rfl attempt appeared to "OOM at the clamp", but that memory pressure was a SYMPTOM of the runaway whnf diagnosed below, not a real memory need — the fixed proofs compile in seconds at the default caps. fips205.fors_inner_loop_eq (Proofs/ForsInnerSpec.lean): the extracted inner Merkle auth-path loop for ONE FORS tree (fors_pk_from_sig_free_loop0_loop0) equals the explicit auth-path fold — at level j set tree height j+1, test bit j of THIS tree's leaf index indices[i], hash the current node with auth.tree[j] in the bit order (even: node||auth[j]; odd: auth[j]||node), halving the tree index. Structurally the XMSS auth-path loop, but the bit source is indices[i]>>j and the loop returns the (adrs,node) pair. Cone: kernel-3 + verify_mono.oracle.h. fips205.fors_outer_loop_eq (Proofs/ForsOuterSpec.lean): the extracted outer per-tree loop (fors_pk_from_sig_free_loop0) equals the explicit K-tree fold — for each tree i, compute the leaf with F at tree index (i<<a)+indices[i], run the inner Merkle loop over the A levels, write the result to root[i]. Consumes the inner loop as an opaque sub-call. Cone: kernel-3 + verify_mono.oracle.{f,h} (F per leaf; H transitively through the inner loop). Fidelity review at authorship (three-way, both loops): extracted bodies (gen Funs.lean 893-933 inner, 954-985 outer) == Rust verify_mono.rs fors_pk_from_sig_free (verbatim from upstream fors.rs, hash calls -> oracle) == FIPS 205 Algorithm 17, incl. the even/odd sibling order and the (i<<a)+indices[i] leaf index. Proof: the branched-Merkle recipe (XMSS) for the inner loop (by_cases on the index bit, pair-bind matcher made concrete via bind_congr+rintro then full simp); the HT straight-line recipe for the outer loop, adapted (bind_congr-peeled step lemma + bind_congr x16 induction, both threading the inner-loop sub-call opaquely). loop_unfold_bind / u32_succ / fwd_succ / hnext reused verbatim from ChainSpec. check.sh: PROOFS += ForsInnerSpec, ForsOuterSpec; CERTS += the two fors certs; audit imports both; check.sh settings unchanged (400s/4096MB). ForsOuterSpec compiles in 4.4s / 2.4GB after the fix below. check.sh green over ALL SIX certificates with the axiom audit. README status -> FIVE certificates. DIAGNOSIS NOTE (honesty): ForsOuterSpec's fors_outer_step first closed with a bare `rfl`, which whnf'd the whole 16-bind body INCLUDING the inner-loop `loop` term and hit a DETERMINISTIC 4M-heartbeat timeout (never actually passed — an earlier "green" reading was a misread wrapper exit code; the real error was hidden by check.sh piping per-file output to /dev/null). Fix: peel the 16 binds with bind_congr so the closing rfl only sees the small loop-tail, and close the post-pair-rintro tail with a full simp (the pair `let` won't iota via simp only). This is the HtSpec straight-line recipe adapted for a body that nests a loop. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-23 21:56:56 +00:00
"fips205.fors_inner_loop_eq"
"fips205.fors_outer_loop_eq"
phase 2: INPUT-PREP layer — to_int, to_byte, WOTS+ checksum (3 kernel-3 certs) Three straight-line range-loop fidelity theorems (Proofs/InputPrepSpec.lean), each #print axioms = EXACTLY [propext, Classical.choice, Quot.sound] — pure byte/bit arithmetic, NO hash oracle enters (the cleanest cones in the campaign): - fips205.to_int_loop_eq (Algorithm 2, toInt): the extracted big-endian byte->u64 loop = the fold total <- (total<<8) + x[i]. - fips205.to_byte_loop_eq (Algorithm 3, toByte): the extracted u32->byte loop = the fold writing s[n-1-i] and shifting total right by 8. - fips205.wots_csum_loop_eq: the WOTS+ checksum loop = the fold csum <- csum + (W-1-msg[i]). All three are the straight-line recipe (hbody -> step lemma closed by rfl -> induction with bind_congr per bind). to_int + checksum use the usize range helpers (WotsSpec), to_byte the u32 range (ChainSpec); loop_unfold_bind reused. Also in this commit — DE-PLUMBING ROUND 2 landed (source bea1051, separate commit in fips205-source): to_int's iter().take() and base_2b's iter_mut() became index loops, so both extract to real definitions. Consequently: - gen/ regenerated (to_int_loop / base_2b_loop0 now clean StepUsize range loops with Slice.index_usize / Slice.update; the six prior certificates recompiled UNCHANGED and re-audited green against the new gen). - The core::iter::adapters::take::Take::next AXIOM — the LAST non-oracle, non-zeroize plumbing axiom on the verify path — is now unreferenced and was DELETED from FunsExternal (dead-stub hygiene rule). The model's external surface is now EXACTLY: the 5 SHA-2 oracles + 3 zeroize blanket impls (never on the verify path) + the discharged-real u32 Step defs. Nothing else. Fidelity review at authorship (three-way): extracted loop bodies (gen Funs.lean) == Rust helpers.rs to_int/to_byte + verify_mono checksum (verbatim FIPS 205 Alg 2/3) == the folds above. check.sh: PROOFS += InputPrepSpec; CERTS += the 3 certs; audit imports it. Green over ALL NINE certificates at default caps (400s/4096MB). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-24 06:55:34 +00:00
"fips205.to_int_loop_eq"
"fips205.to_byte_loop_eq"
"fips205.wots_csum_loop_eq"
"fips205.base2b_outer_loop_eq"
phase 2: THE APEX — slh_verify_128s accepts iff recomputed root = pk_root fips205.slh_verify_128s_accepts_iff (Proofs/ApexSpec.lean): the extracted top-level SLH-DSA-SHA2-128s verifier returns `ok true` if and only if the recomputed hypertree root byte-equals the pinned public-key root pk.pk_root. There is NO acceptance path other than root equality. slh_verify_128s mprime sig pk = (do let root ← slhVerifyRoot 63 30 mprime sig pk ok (decide (root.val = pk.pk_root.val))) where slhVerifyRoot is byte-for-byte the extracted slh_verify_internal_free pipeline (H_msg digest -> md/idx_tree/idx_leaf split via to_int + masks -> fors_pk_from_sig -> hypertree recompute over xmss over wots over chain), with only the final ht_verify_free comparison factored out. #print axioms cone = EXACTLY [propext, Classical.choice, Quot.sound, verify_mono.oracle.{f, h, h_msg, t_l, t_len}] — the three kernel axioms plus PRECISELY the five SHA-2 hash oracles, and nothing else. No plumbing, no transpiler artifacts. This is the boundary the whole campaign targeted: the deployed verify path is machine-checked down to five named hash functions. Structure: - arrayEqU8_spec: the library array equality PartialEqArray.eq on two Array U8 N returns exactly the decidable byte-equality of their lists (a List.allM induction; the one real lemma). This is what makes "accepts" mean "root byte-equals pk_root" explicitly, in the spirit of the ed25519 verify_accepts_iff. - ht_verify_free_split: ht_verify_free = htVerifyRoot >>= (byte-compare to pk_root), via arrayEqU8_spec on the tail; bind_congr threads the setup. - slh_verify_internal_accepts_iff (generic, all param sets) + the 128s corollary: unfold the internal, rewrite the ht tail with the split, flatten with bind_assoc; both sides become the identical do-block (simp closes structurally — no whnf of the nested ht_verify_free_loop, the ForsOuter lesson). Honest scope: the apex is an ACCEPTANCE characterization — it pins that the top-level accept is exactly root equality over the extracted recomputation, whose every loop is individually fidelity-certified by the ten preceding theorems (chain/wots/xmss/ht/fors/input-prep). It does NOT re-derive the recomputation as a closed-form mathematical hypertree value; that composition of all ten fold-fidelity theorems into one expression is a further step, not claimed here. The security-relevant statement — an accepted signature means the verifier recomputed a root matching the pinned key, down to five hash oracles — is exactly what is proven. check.sh: PROOFS += ApexSpec; CERTS += fips205.slh_verify_128s_accepts_iff; audit imports it. Green over ALL ELEVEN certificates at default caps. The verify-path proof pyramid is COMPLETE. What remains before any LTL attestation is operator-gated and NOT started (the big halt): the pacta allowed-cone table entry + the append ceremony with the operator signing key. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-24 07:58:06 +00:00
"fips205.slh_verify_128s_accepts_iff"
2026-07-23 09:34:59 +00:00
)
echo "fips205-slhdsa-verified — check"
echo "==============================="
2026-07-23 09:34:59 +00:00
# ── Phase 1: model ──────────────────────────────────────────────────────────
echo "=== Phase 1: compile the extracted model ==="
cd "$AENEAS_LEAN"
lake env bash -c "
set -euo pipefail
2026-07-23 09:34:59 +00:00
cd '$HERE' && export LEAN_PATH=\"\$LEAN_PATH:\$PWD/gen:\$PWD\"
compile() { echo \" · \$1\"; LEAN_TIMEOUT=$TIMEOUT LEAN_MEM_MB=$MEM '$HERE/lean-guard' \"\${1}.lean\" >/dev/null || { echo \"FAIL: \$1\"; exit 1; }; }
for m in ${GEN_MODULES[*]}; do compile \"gen/\$m\"; done
"
2026-07-23 09:34:59 +00:00
# ── Phase 2: proofs ─────────────────────────────────────────────────────────
echo "=== Phase 2: compile the proofs ==="
cd "$AENEAS_LEAN"
lake env bash -c "
set -euo pipefail
cd '$HERE' && export LEAN_PATH=\"\$LEAN_PATH:\$PWD/gen:\$PWD\"
compile() { echo \" · \$1\"; LEAN_TIMEOUT=$TIMEOUT LEAN_MEM_MB=$MEM '$HERE/lean-guard' \"Proofs/\${1}.lean\" >/dev/null || { echo \"FAIL: Proofs/\$1\"; exit 1; }; }
for m in ${PROOFS[*]}; do compile \"\$m\"; done
# no dead proof files: everything under Proofs/ must be in the manifest
review round 2: in-Lean exact-cone audit + reproducibility + doc honesty Addresses the round-2 reviewer punch-list. No theorem statement, proof term, or fold definition changed; the eleven cones are unchanged (independent collectAxioms dump in verification/RECORDED-RUN.md). AUDIT GATE (both reviewers, the critical one) - Retire the bash #print-axioms text parser (fail-open on empty/truncated reports, and only a SUBSET check). Replace with verification/Proofs/Audit.lean: reads each certificate's cone from the kernel via collectAxioms and asserts EXACT set equality against its expected boundary. Extra axiom, dropped oracle, renamed/deleted cert, or an axiom/opaque sham each throw -> non-zero Lean exit. No text to misparse; nothing fails open. check.sh Phase 3 now just compiles it (and still requires the explicit PASSED line). - check-selftest.sh rewritten to attack the new gate: dead-file, smuggled extra axiom (named), dropped-oracle (subset would pass, exact must not), and a vanished certificate (the collectAxioms-returns-[] trap). All four rejected. REPRODUCIBILITY (GPT B1.4 / B1.5) - extract.sh refuses a wrong-commit or dirty source tree (fail-closed), takes an optional source-path arg, and pins the source commit. - verification/PROVENANCE.json: single machine-readable pin set (source + charon + aeneas commits/channel + lean + ocaml) with generated-file sha256. - Re-running extract.sh reproduces gen/SlhVerify/{Types,Funs}.lean byte-identically (companion fips205-source commit adds Cargo.lock + rust-toolchain.toml; verified not to perturb the model). DOC HONESTY (both reviewers) - README: fix the self-contradiction (apex "not yet proven" trailer vs the proven apex), the false "oracles kept OUTSIDE every cone" (they are INSIDE, by design), "deployed monomorphic path" and "semantics-identical for every parameter set" overclaims, "only two lines changed", stale snapshot head; retitle the stale future-tense "what will be claimed" section. - TRUSTED-BASE: drop "nothing proven yet"; add base_2b-inner and deployment- bridge non-claims explicitly; current pin. - ChainSpec header: "deployed monomorphic path" -> private verify_mono facade (comment only). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-24 17:13:55 +00:00
# (PROOFS) or be the audit driver (Audit, compiled in Phase 3).
2026-07-23 09:34:59 +00:00
for f in Proofs/*.lean; do b=\$(basename \"\$f\" .lean)
review round 2: in-Lean exact-cone audit + reproducibility + doc honesty Addresses the round-2 reviewer punch-list. No theorem statement, proof term, or fold definition changed; the eleven cones are unchanged (independent collectAxioms dump in verification/RECORDED-RUN.md). AUDIT GATE (both reviewers, the critical one) - Retire the bash #print-axioms text parser (fail-open on empty/truncated reports, and only a SUBSET check). Replace with verification/Proofs/Audit.lean: reads each certificate's cone from the kernel via collectAxioms and asserts EXACT set equality against its expected boundary. Extra axiom, dropped oracle, renamed/deleted cert, or an axiom/opaque sham each throw -> non-zero Lean exit. No text to misparse; nothing fails open. check.sh Phase 3 now just compiles it (and still requires the explicit PASSED line). - check-selftest.sh rewritten to attack the new gate: dead-file, smuggled extra axiom (named), dropped-oracle (subset would pass, exact must not), and a vanished certificate (the collectAxioms-returns-[] trap). All four rejected. REPRODUCIBILITY (GPT B1.4 / B1.5) - extract.sh refuses a wrong-commit or dirty source tree (fail-closed), takes an optional source-path arg, and pins the source commit. - verification/PROVENANCE.json: single machine-readable pin set (source + charon + aeneas commits/channel + lean + ocaml) with generated-file sha256. - Re-running extract.sh reproduces gen/SlhVerify/{Types,Funs}.lean byte-identically (companion fips205-source commit adds Cargo.lock + rust-toolchain.toml; verified not to perturb the model). DOC HONESTY (both reviewers) - README: fix the self-contradiction (apex "not yet proven" trailer vs the proven apex), the false "oracles kept OUTSIDE every cone" (they are INSIDE, by design), "deployed monomorphic path" and "semantics-identical for every parameter set" overclaims, "only two lines changed", stale snapshot head; retitle the stale future-tense "what will be claimed" section. - TRUSTED-BASE: drop "nothing proven yet"; add base_2b-inner and deployment- bridge non-claims explicitly; current pin. - ChainSpec header: "deployed monomorphic path" -> private verify_mono facade (comment only). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-24 17:13:55 +00:00
case \" ${PROOFS[*]} Audit \" in *\" \$b \"*) ;; *) echo \"DEAD FILE: Proofs/\$b.lean not in manifest\"; exit 1 ;; esac
2026-07-23 09:34:59 +00:00
done
"
review round 2: in-Lean exact-cone audit + reproducibility + doc honesty Addresses the round-2 reviewer punch-list. No theorem statement, proof term, or fold definition changed; the eleven cones are unchanged (independent collectAxioms dump in verification/RECORDED-RUN.md). AUDIT GATE (both reviewers, the critical one) - Retire the bash #print-axioms text parser (fail-open on empty/truncated reports, and only a SUBSET check). Replace with verification/Proofs/Audit.lean: reads each certificate's cone from the kernel via collectAxioms and asserts EXACT set equality against its expected boundary. Extra axiom, dropped oracle, renamed/deleted cert, or an axiom/opaque sham each throw -> non-zero Lean exit. No text to misparse; nothing fails open. check.sh Phase 3 now just compiles it (and still requires the explicit PASSED line). - check-selftest.sh rewritten to attack the new gate: dead-file, smuggled extra axiom (named), dropped-oracle (subset would pass, exact must not), and a vanished certificate (the collectAxioms-returns-[] trap). All four rejected. REPRODUCIBILITY (GPT B1.4 / B1.5) - extract.sh refuses a wrong-commit or dirty source tree (fail-closed), takes an optional source-path arg, and pins the source commit. - verification/PROVENANCE.json: single machine-readable pin set (source + charon + aeneas commits/channel + lean + ocaml) with generated-file sha256. - Re-running extract.sh reproduces gen/SlhVerify/{Types,Funs}.lean byte-identically (companion fips205-source commit adds Cargo.lock + rust-toolchain.toml; verified not to perturb the model). DOC HONESTY (both reviewers) - README: fix the self-contradiction (apex "not yet proven" trailer vs the proven apex), the false "oracles kept OUTSIDE every cone" (they are INSIDE, by design), "deployed monomorphic path" and "semantics-identical for every parameter set" overclaims, "only two lines changed", stale snapshot head; retitle the stale future-tense "what will be claimed" section. - TRUSTED-BASE: drop "nothing proven yet"; add base_2b-inner and deployment- bridge non-claims explicitly; current pin. - ChainSpec header: "deployed monomorphic path" -> private verify_mono facade (comment only). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-24 17:13:55 +00:00
# ── Phase 3: axiom audit (exact cone per certificate, inside Lean) ───────────
echo "=== Phase 3: axiom audit (exact cone per certificate — inside Lean) ==="
2026-07-23 09:34:59 +00:00
cd "$AENEAS_LEAN"
review round 2: in-Lean exact-cone audit + reproducibility + doc honesty Addresses the round-2 reviewer punch-list. No theorem statement, proof term, or fold definition changed; the eleven cones are unchanged (independent collectAxioms dump in verification/RECORDED-RUN.md). AUDIT GATE (both reviewers, the critical one) - Retire the bash #print-axioms text parser (fail-open on empty/truncated reports, and only a SUBSET check). Replace with verification/Proofs/Audit.lean: reads each certificate's cone from the kernel via collectAxioms and asserts EXACT set equality against its expected boundary. Extra axiom, dropped oracle, renamed/deleted cert, or an axiom/opaque sham each throw -> non-zero Lean exit. No text to misparse; nothing fails open. check.sh Phase 3 now just compiles it (and still requires the explicit PASSED line). - check-selftest.sh rewritten to attack the new gate: dead-file, smuggled extra axiom (named), dropped-oracle (subset would pass, exact must not), and a vanished certificate (the collectAxioms-returns-[] trap). All four rejected. REPRODUCIBILITY (GPT B1.4 / B1.5) - extract.sh refuses a wrong-commit or dirty source tree (fail-closed), takes an optional source-path arg, and pins the source commit. - verification/PROVENANCE.json: single machine-readable pin set (source + charon + aeneas commits/channel + lean + ocaml) with generated-file sha256. - Re-running extract.sh reproduces gen/SlhVerify/{Types,Funs}.lean byte-identically (companion fips205-source commit adds Cargo.lock + rust-toolchain.toml; verified not to perturb the model). DOC HONESTY (both reviewers) - README: fix the self-contradiction (apex "not yet proven" trailer vs the proven apex), the false "oracles kept OUTSIDE every cone" (they are INSIDE, by design), "deployed monomorphic path" and "semantics-identical for every parameter set" overclaims, "only two lines changed", stale snapshot head; retitle the stale future-tense "what will be claimed" section. - TRUSTED-BASE: drop "nothing proven yet"; add base_2b-inner and deployment- bridge non-claims explicitly; current pin. - ChainSpec header: "deployed monomorphic path" -> private verify_mono facade (comment only). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-24 17:13:55 +00:00
# Proofs/Audit.lean reads each cert's cone from the kernel (collectAxioms) and
# asserts SET EQUALITY against its expected boundary. Compiling it IS the audit:
# any mismatch throws → non-zero exit. We additionally require the explicit
# PASSED line, so a build that somehow exits 0 without running the audit still
# fails closed.
AUD_OUT=$(lake env bash -c "cd '$HERE' && export LEAN_PATH=\"\$LEAN_PATH:\$PWD/gen:\$PWD\" && LEAN_TIMEOUT=$TIMEOUT LEAN_MEM_MB=$MEM '$HERE/lean-guard' 'Proofs/Audit.lean'" 2>&1) || {
echo "$AUD_OUT" | sed 's/^/ /'
echo "AXIOM AUDIT FAILED (Audit.lean did not compile — cone mismatch, missing cert, or sham)"; exit 1; }
if ! grep -qF "exact-cone audit PASSED" <<<"$AUD_OUT"; then
echo "$AUD_OUT" | sed 's/^/ /'
echo "AXIOM AUDIT FAILED (no PASSED line — fail-closed)"; exit 1
fi
echo " ✓ exact-cone audit PASSED: each of the ${#CERTS[@]} certificate cones == its expected boundary set"
2026-07-23 09:34:59 +00:00
echo
review round 2: in-Lean exact-cone audit + reproducibility + doc honesty Addresses the round-2 reviewer punch-list. No theorem statement, proof term, or fold definition changed; the eleven cones are unchanged (independent collectAxioms dump in verification/RECORDED-RUN.md). AUDIT GATE (both reviewers, the critical one) - Retire the bash #print-axioms text parser (fail-open on empty/truncated reports, and only a SUBSET check). Replace with verification/Proofs/Audit.lean: reads each certificate's cone from the kernel via collectAxioms and asserts EXACT set equality against its expected boundary. Extra axiom, dropped oracle, renamed/deleted cert, or an axiom/opaque sham each throw -> non-zero Lean exit. No text to misparse; nothing fails open. check.sh Phase 3 now just compiles it (and still requires the explicit PASSED line). - check-selftest.sh rewritten to attack the new gate: dead-file, smuggled extra axiom (named), dropped-oracle (subset would pass, exact must not), and a vanished certificate (the collectAxioms-returns-[] trap). All four rejected. REPRODUCIBILITY (GPT B1.4 / B1.5) - extract.sh refuses a wrong-commit or dirty source tree (fail-closed), takes an optional source-path arg, and pins the source commit. - verification/PROVENANCE.json: single machine-readable pin set (source + charon + aeneas commits/channel + lean + ocaml) with generated-file sha256. - Re-running extract.sh reproduces gen/SlhVerify/{Types,Funs}.lean byte-identically (companion fips205-source commit adds Cargo.lock + rust-toolchain.toml; verified not to perturb the model). DOC HONESTY (both reviewers) - README: fix the self-contradiction (apex "not yet proven" trailer vs the proven apex), the false "oracles kept OUTSIDE every cone" (they are INSIDE, by design), "deployed monomorphic path" and "semantics-identical for every parameter set" overclaims, "only two lines changed", stale snapshot head; retitle the stale future-tense "what will be claimed" section. - TRUSTED-BASE: drop "nothing proven yet"; add base_2b-inner and deployment- bridge non-claims explicitly; current pin. - ChainSpec header: "deployed monomorphic path" -> private verify_mono facade (comment only). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-24 17:13:55 +00:00
echo "ALL GREEN — model compiles, proofs compile, and every certificate cone"
echo "equals EXACTLY the three kernel axioms plus its documented SHA-2 oracles."
2026-07-23 09:34:59 +00:00
echo "Certificates proven: ${CERTS[*]}"