Run the verifier on your laptop. Verify the receipt yourself, without trusting us.

Eleven files, all readable in any text editor. The package uses real Ed25519 cryptography against synthetic data. The eight files below ship with three more — public_key.json (required by the verify command), verifier_transcript.txt (the recorded verifier run, every mode), and the MIT LICENSE.

The topic crosswalk and methodology are published as markdown; HIPAA and Reg S-P control mappings are excluded and no control-satisfaction claim is made.

Run time depends on the local Python environment; no completion-time benchmark is claimed.

1. Download the package. Download the ZIP (225 KB; SHA-256 35ab06cf906b05965ad8962e5e80fb98a744d4990ba3ee41b314e210c259e868), or pull the individual files from sample-package/.
2. Install the dependencies.

   pip install cryptography rfc8785

   Those are the only Python packages the verifier requires. cryptography does Ed25519; rfc8785 does the JSON canonicalization used by artifacts stamped rfc8785-jcs-v1. Requires Python 3.9+; developed and verified on Python 3.12 with cryptography 46.x and rfc8785 0.1.x.
3. Run the verifier.

   python verifier_cli.py --receipt receipt.json --public-key-file public_key.json

   Expected output:

   == VeilEngine Receipt Verifier ==
   Loading receipt: receipt.json
   Receipt: VERIFIED
     receipt rcpt_2026-05-18T14:32:11Z_a1b2c3d4: signature verified [ve-canonical-json-v1]; declares key id vke_synthetic_2026-05
   
   Overall: PASS

   The verifier exits with code 0 on PASS, 1 on FAIL, 2 on an argument or environment error.
4. Walk the chain. The session export carries three hash-linked events. This replays the links and each event’s signature, stopping at the first break:

   python verifier_cli.py --chain session_export.json --public-key-file public_key.json

   Recorded output:

   == VeilEngine Receipt Verifier ==
   Loading chain: session_export.json
     event[0] sequence=0: PASS (metadata hash + chain link + signature)
     event[1] sequence=1: PASS (metadata hash + chain link + signature)
     event[2] sequence=2: PASS (metadata hash + chain link + signature)
   Chain: VERIFIED (3 events); declares key id vke_synthetic_2026-05
   
   Overall: PASS

5. Verify the export whole. One command checks the envelope signature, the chain, every receipt under its own canonicalization, the manifest hashes, the binding that holds the bundle, the chain wrapper, every event and every receipt to one session and one tenant — each of those layers has to declare both, and a receipt that declares its identity at two paths has to declare it the same way at both — and the recomputed chain-tip anchor:

   python verifier_cli.py --session-export session_export.json --public-key-file public_key.json

   Recorded output:

   == VeilEngine Receipt Verifier ==
   Loading session export: session_export.json
     [PASS] envelope  signature verified [rfc8785-jcs-v1]; declares key id vke_synthetic_2026-05
     [PASS] chain     3 events; prev_event_hash links + per-event signatures; declares key id vke_synthetic_2026-05
     [PASS] receipts  1 receipt(s) verified under their own canonicalization; declares key id vke_synthetic_2026-05
     [PASS] manifest  signature verified [ve-canonical-json-v1]; 10 artifact hashes match; declares key id vke_synthetic_2026-05
     [PASS] binding   bundle, chain wrapper, 3 event(s) and 1 receipt(s) all declare session sess_synthetic_clinic_001 and tenant tenant_synthetic_demo
     [PASS] anchor    chain tip recomputed: 3 events, sha256-rfc8785-jcs-v1
   Session export: VERIFIED
   
   Overall: PASS

To verify the manifest and its artifact hashes on their own, point the verifier at the manifest: python verifier_cli.py --manifest manifest.json --public-key-file public_key.json. To verify against the pinned keyring instead of a single key — the path that survives a signing-key rotation — swap the key flag: python verifier_cli.py --session-export session_export.json --public-keyring-file public_keyring.json. Keyring verification also requires the chain-tip anchor, so a truncated export cannot pass it. To check the verifier before trusting its verdict, run python verifier_cli.py --self-test: it signs a payload that canonicalizes differently under each supported scheme and confirms the tool rejects a modified payload, a wrong key, a signature made under the wrong canonicalization, an unrecognized canonicalization identifier, a receipt spliced in from another session, a receipt carrying a different tenant, a bundle or chain wrapper that declares no tenant, a receipt that declares conflicting identities at its nested and top-level paths, an identity declared at a present path as anything but a non-empty string, conflicting key ids at an object’s two key-id paths, a wrong root shape for any mode, a manifest descriptor that is empty, untyped or escaping the package directory, a JSON object that names one key twice, an event declaring a false hash of itself, unsigned fields beside the signed export in its wrapper, an artifact dated outside its key’s validity window, a missing or stale chain anchor, and a keyring whose key descriptors are malformed, duplicated, aliased or carrying private-key material.

The receipt records a hypothetical workflow at a fictional mid-market healthcare clinic. The patient name, MRN, DOB, diagnosis codes, and clinician identity are entirely synthetic and are labeled "synthetic": true in the receipt metadata. No real clinical data appears in any artifact.

The signer key (vke_synthetic_2026-05) is a synthetic Ed25519 keypair generated solely for the sample. The private key is intentionally exposed in sign_and_verify.py so anyone can regenerate the signatures and confirm the verification path. The sample does not establish any production signing arrangement.

The package uses Ed25519 signatures, SHA-256 hashes, and JSON canonicalization against synthetic artifacts. It establishes only the behavior a buyer can reproduce with this sample and verifier.