Touchstone

Check the work

Verify

The bundle is the record; this site is only a rendering of it. Download the file and check the signature, the ledger digest, the compilation artifacts, every control hash and both roots — offline, on your machine.

The bundle

Download ustb-2026-08-17-1.json sha256 of the file:
914ea892…10bfc955show full value 914ea892e181d7bad2583da5c1f377b3f1ee9bf197c5a799b8d5f8cc10bfc955

The checks below are Python 3. Check 1 needs the cryptography package; the rest are standard library only. Run each next to the downloaded bundle.

Five checks, offline

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("ustb-2026-08-17-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

Sequence 1 names the exact approval ledger it was signed under by digest. This recomputes it from the ledger text carried in the bundle.

# check_ledger.py
import hashlib, json

bundle = json.load(open("ustb-2026-08-17-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)

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("ustb-2026-08-17-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 all eight from the control records in the bundle.

# check_content_hashes.py
import hashlib, json

bundle = json.load(open("ustb-2026-08-17-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 8 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.

# check_roots.py
import hashlib, json

bundle = json.load(open("ustb-2026-08-17-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")

This page runs no JavaScript. Everything above is a static rendering of the bundle you can download — nothing on this page is computing the answer for you.

The on-chain record

Network
X Layer testnet · chain id 1952
Registry
0x0dAb4A5B7dd24434Ab6564734E26d3d76985352C
Publisher
0x86A100BDdF8754c95fec97BeC96dBFd64Be44710
Block
38526525
Transaction
0x510714…5be6b869show full value 0x5107140c5c9c755026de5e3193e14b9863aacc2962f78b8516bf00075be6b869

The publication transaction is public: view it on the X Layer testnet explorer.

What these checks do not cover

The bundle carries evidence digests, not the evidence artifacts themselves, so these checks cannot replay retrieval or normalization. And no check here proves the issuer's figures are true — only that they were published, checked against a cited predicate, and signed. The five limitations carried inside the signed report are reproduced verbatim here.