The format, so you never need our tool.

1  hash chain     were findings added, removed or reordered after the run?
2  manifest hash  does the signed payload still hash to the recorded value?
3  signature      is this an ECDSA P-256 signature over that payload?
4  published key  is the signing key OUR key, or just some key?

Check 4 is the one people skip. A valid signature only says that
somebody signed the file. Anyone can generate a key and sign anything.

{
  "manifest": {
    "caseId":         "zerorecall-en-ilk",
    "target":         "who or what was to be erased",
    "runAt":          "ISO 8601",
    "forgetScore":    0-100,
    "scopeStatement": "what was and was not examined",
    "chainRoot":      "sha256 hex of the last link (GENESIS if empty)",
    "chain":          [ { "index", "prevHash", "finding", "hash" } ],
    "stationsSummary":[ { "station", "ran", "score", "probes" } ],
    "timeAnchor":     { ... },        // optional
    "supersedes":     { "manifestHash", "reason" },  // optional
    "targetProvenance": {             // optional, absent in packs before 2026-08-20
      "mode": "live" | "mock" | "unspecified",
      "note": "what the producer knew about the target at run time"
    },
    "independentAnchor": {            // optional, absent in packs before 2026-08-20,
      "kind", "reference", "note"     // and not produced yet by anything
    }
  },
  "manifestHash": "sha256 hex of the canonical manifest",
  "signature":    "base64",
  "algorithm":    "ecdsa-p256-sha256",
  "publicKeyPem": "-----BEGIN PUBLIC KEY----- ...",
  "signedAt":     "ISO 8601"
}

Optional fields may be absent in older packs. Absence is not a defect:
a verifier reports it as a missing observation, it does not fail the pack.
What "supersedes" means is a published rule, not a hint. See /archive-policy.

"targetProvenance" states what the producer knew about the target when the
run happened: a live endpoint, a mock/demo environment, or unspecified. It
sits inside the manifest, so it is covered by the signature and cannot be
edited after signing without failing the manifest-hash check. A verifier
shows it; it never rejects a pack over it. A "mock" pack is a valid pack
that honestly says what it audited.

"independentAnchor" is reserved. Today all four checks are internal
consistency: the pack agrees with its own signature and with our published
key. Nothing yet ties a pack to a system outside ours. When our transparency
log becomes publicly queryable, this field will carry that reference. Until
then no pack has it, and a verifier should say "not yet available" rather
than imply external anchoring exists.

The Python verifier below needs NO change for these fields: it
canonicalizes the whole manifest object, so any optional field present is
automatically part of the hashed and signed payload.

# WRONG: default escapes "ç" to "\u00e7" and the hash no longer matches
json.dumps(obj, sort_keys=True, separators=(",", ":"))

# RIGHT
json.dumps(obj, sort_keys=True, separators=(",", ":"), ensure_ascii=False)

curl -O https://www.zerorecall.ai/demo-reports/zerorecall-en-ilk.pack.json
curl -O https://www.zerorecall.ai/.well-known/zerorecall-signing-key.pem

import base64, hashlib, json, sys
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.exceptions import InvalidSignature

GENESIS = "0" * 64

def canonical(v):
    return json.dumps(v, sort_keys=True, separators=(",", ":"),
                      ensure_ascii=False)   # see the trap above

def sha256(s):
    return hashlib.sha256(s.encode("utf-8")).hexdigest()

pack = json.load(open(sys.argv[1]))
m = pack["manifest"]

prev, chain_ok = GENESIS, True
for i, link in enumerate(m["chain"]):
    if link["index"] != i or link["prevHash"] != prev:
        chain_ok = False; break
    h = sha256("%s|%d|%s" % (prev, i, canonical(link["finding"])))
    if h != link["hash"]:
        chain_ok = False; break
    prev = h

payload = canonical(m)
hash_ok = sha256(payload) == pack["manifestHash"]

pub = serialization.load_pem_public_key(pack["publicKeyPem"].encode())
try:
    pub.verify(base64.b64decode(pack["signature"]),
               payload.encode("utf-8"), ec.ECDSA(hashes.SHA256()))
    sig_ok = True
except InvalidSignature:
    sig_ok = False

norm = lambda p: "".join(p.split())
key_ok = norm(open(sys.argv[2]).read()) == norm(pack["publicKeyPem"])

for name, v in [("chain", chain_ok), ("manifest hash", hash_ok),
                ("signature", sig_ok), ("published key", key_ok)]:
    print("%-15s %s" % (name, "OK" if v else "FAIL"))
print("=> %s" % ("VALID" if all([chain_ok, hash_ok, sig_ok, key_ok]) else "INVALID"))

1  tamper-evident structure   findings sit in a hash chain, a Merkle
                              root, or something equivalent, so adding,
                              removing or reordering one after the run
                              is detectable

2  a published canonicalization rule
                              two independent implementations must
                              produce the same bytes over the same
                              content, or "the signature checks out"
                              is only testable by the vendor itself

3  a signature over the canonical payload
                              not a checksum of the file. A checksum
                              proves the bytes did not rot in transit;
                              a signature proves who committed to them

4  a publicly published, pinnable key
                              independent of the tool doing the
                              checking. Without it, check 3 only proves
                              that somebody signed the file