Verify a report

1 · The signature

The report was signed with Ed25519. This verifies the signature over the canonical report bytes, and that those bytes are the same report this site renders.

# check_signature.py — needs: pip install cryptography
import json
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

bundle = json.load(open("eip155-196-ustb-2026-08-21-3-policy-nav-settlement-1.json", encoding="utf-8"))
assert json.loads(bundle["report_canonical"]) == bundle["signed_report"]["report"]
key = Ed25519PublicKey.from_public_bytes(bytes.fromhex(bundle["published_key"]["public_key"]))
key.verify(bytes.fromhex(bundle["signed_report"]["signature"]),
           bundle["report_canonical"].encode("utf-8"))
print("signature verifies over report_canonical")

2 · The approval ledger

The report names the exact approval ledger it was signed under, by digest. This recomputes it from the ledger text carried in the bundle — no external constant, and nothing on this page, is involved.

# check_ledger.py
import hashlib, json

bundle = json.load(open("eip155-196-ustb-2026-08-21-3-policy-nav-settlement-1.json", encoding="utf-8"))
digest = hashlib.sha256(bundle["approval_ledger"].encode("utf-8")).hexdigest()
assert digest == bundle["signed_report"]["report"]["approval_ledger_sha256"]
print("approval ledger digest matches:", digest)

As of 2026-08-19 the approval ledger is version 2: every decision carries the approver's EIP-712 signature, from 0x537873b087654395CB0A487B50d0bFBe15fA16Bc. The digest check above is identical for both versions — signature recovery is the part the browser and CLI paths add on a version-2 ledger. Bundles published before the upgrade bind the version-1 ledger, the same decisions recorded without signatures, and the Terminal's panel says so rather than passing over it.

3 · The compilation artifacts

Each control points at the compilation artifact it was accepted in. This confirms every artifact in the bundle hashes to its own key, and that the report's provenance digests are exactly those artifacts.

# check_compilations.py
import hashlib, json

bundle = json.load(open("eip155-196-ustb-2026-08-21-3-policy-nav-settlement-1.json", encoding="utf-8"))
for digest, artifact in bundle["compilations"].items():
    assert hashlib.sha256(artifact.encode("utf-8")).hexdigest() == digest
assert set(bundle["compilations"]) == set(
    bundle["signed_report"]["report"]["compiler_provenance_digests"])
print("all", len(bundle["compilations"]), "compilation artifacts self-hash")

4 · The control content hashes

The report references each control by a hash of its canonical bytes. This recomputes every one of them from the control records in the bundle.

# check_content_hashes.py
import hashlib, json

bundle = json.load(open("eip155-196-ustb-2026-08-21-3-policy-nav-settlement-1.json", encoding="utf-8"))
records = {r["control_id"]: r for r in bundle["control_records"]}
for control in bundle["signed_report"]["report"]["controls"]:
    canonical = json.dumps(records[control["control_id"]],
                           sort_keys=True, separators=(",", ":"))
    assert hashlib.sha256(canonical.encode("utf-8")).hexdigest() == control["content_hash"]
print("all", len(bundle["signed_report"]["report"]["controls"]), "content hashes match")

5 · The roots

The control set root and evidence root are domain-separated ordered hash chains. This recomputes both from the bundle alone — the check the browser panel deliberately does not claim.

# check_roots.py
import hashlib, json

bundle = json.load(open("eip155-196-ustb-2026-08-21-3-policy-nav-settlement-1.json", encoding="utf-8"))
report = bundle["signed_report"]["report"]

def root(domain, items):
    state = hashlib.sha256(b"touchstone-root-v1:" + domain.encode()).digest()
    for item in items:
        canonical = json.dumps(item, sort_keys=True, separators=(",", ":"))
        state = hashlib.sha256(b"\x01" + state + canonical.encode()).digest()
    return state.hex()

controls = sorted(
    ({"content_hash": c["content_hash"], "control_id": c["control_id"]}
     for c in report["controls"]),
    key=lambda item: item["control_id"])
assert root("control-set", controls) == report["control_set_root"]

evidence = sorted(bundle["evidence_digests"],
                  key=lambda item: (item["source_id"], item["capture_role"]))
assert root("evidence", evidence) == report["evidence_root"]
print("control set root and evidence root both recompute")