Attest pack verifier

This page verifies an exported Attest pack in your browser. Nothing is uploaded — all hashing and signature checks run locally, offline. Drop the .zip pack itself, select every extracted file, just bundle.json for a single-visit pack, or a signed receipt JSON (e.g. a verify-live --sign report).

New here? The story of one contested visit — told entirely from signed data — explains why the record exists, and the site shows the rest. New to the math? Anatomy of a signed receipt decomposes one field-by-field, the seven gates show which check kills which attack, the battery page renders all 23 live verdicts — or take the two-minute tour of the headline features.

Verify the bundled sample pack — one click, fetched from this site

Verify the tampered twin — the same pack, but someone inflated the contested visit's observed span from 65.25 to 135.25 minutes. Watch the signature catch it

Run the whole gauntlet — every artifact on this page verified in sequence: the clean pack, its older sibling from weeks ago, the doctored twin, all three attacks, the real-API sweep, the signed fork, the Bitcoin anchor — scored against the shared oracle
the oracle is the verdict each artifact was built to produce — agreement means the verifier and the published spec say the same thing about all nine.

Compare two packs — the clean pack vs its doctored twin: each verifies on its own merits, then their signed membership diffs member-by-member — the moved field named — and the two signed log heads reconcile
"the copy the agency produced" vs "the copy I kept" — two packs that both verify can still carry different records. Or drop any two exported zips at once for the same compare. What it looks like written down.

Compare across time — the pack exported last week vs the pack exported today: their signed log heads are not adjacent, so the reconcile walks the newer pack's embedded checkpoint chain hop-by-hop — append-only growth proven offline, no server trust
the shape a real dispute takes: "the pack my family kept" vs "the pack the agency just produced" — provably the same log, only longer. What it looks like written down.

Or pick an attack — each is caught by a different layer:

Attack: deleted record — a visit bundle was removed, but the signed manifest still names its receipt

Attack: smuggled file — extra-evidence.json injected after signing; nothing signed commits to it

Attack: forged verifier — the embedded checker swapped for an always-green stub; the tooling pin names its bytes

Verify the signed report from a real sweep against the Ring Partner API — a lone receipt, verified by the same math

Verify the caught fork — a signed monitor observation documenting two irreconcilable views of one log, proven inside its own signed tree head

Verify the sample pack pinned to this site's issuer document — the trust anchor arrives over a different surface than the artifact it anchors

Verify this page — hash the bytes you're reading against the issuer-signed verify.html pin inside the bundled sample pack
Proves the hosted copy is the exact pinned tool — a swapped verifier is caught, not trusted. (A hostile page could rewrite this check too; for a real dispute, the pack's own verify_case.py stays the stronger path.)

Verify this whole site — a signed manifest pins the sha256 of every artifact it ships; watch each file prove itself
Extends the self-check to the whole deployment: the manifest's own signature verifies first, then every listed file is fetched and hashed.

What this does and does not establish

A green result proves the signed records are intact and were issued under the pinned issuer key — integrity, not physical truth. It does not prove anyone was present, absent, or honest; it proves the evidence chain was not altered after signing. Media reported as "withheld" was deliberately redacted, not lost.

Trust note: this verifier file traveled inside the pack it is checking. For a dispute that matters, re-verify with a verifier obtained independently — the deployment's /verify-pack page, verify_case.py pinned from the issuing deployment, or the operator's hosted verifier — never trust only the copy a pack carries about itself.