Skip to main content
Attesso keeps a provable record: every mandate event is appended to one tamper-evident log, and each signed checkpoint commits to everything before it. Checking the record answers one question without trusting Attesso: has anything in the record been rewritten or removed since the snapshot you hold? Everything on this page verifies with a hash function and Attesso’s published log keys. No Attesso service is needed at verification time; you need Attesso only to fetch fresh checkpoints and proofs. The record log is an RFC 6962 Merkle tree. Leaves are per-event digests, so verification never needs event contents, and any RFC 6962 library or a page of code can check the proofs.

The artifacts

What each check proves

  • Checkpoint signature: the checkpoint was signed by Attesso’s log key and the signed bytes are exactly what you received. A checkpoint nobody can forge is what makes every later comparison meaningful.
  • Consistency: the tree you saved is contained in the newer tree, leaf for leaf and in order. If a single history leaf had been changed or removed, no consistency proof could exist. This is the check that catches rewrites and omissions.
  • Inclusion: each of your mandate’s events is a leaf of the checkpointed tree at the position the proof names. The events themselves come from the evidence bundle you hold; the record proof shows they were committed.
  • Time anchor (when present): the checkpoint’s hash was timestamped by an independent RFC 3161 authority at gen_time, so the checkpoint existed by that moment regardless of Attesso’s key.

The signed checkpoint

payload decodes to this canonical JSON; the signature covers these exact bytes:
  • tree_size counts every event in the log up to this checkpoint.
  • root_hash is the RFC 6962 root over the leaves.
  • prev_hash chains each checkpoint to its predecessor, so a set of checkpoints you collected over time also forms a chain.
Merkle hashing, if you verify by hand or in another language: the leaf hash of an event digest is SHA-256(0x00 || digest), interior nodes are SHA-256(0x01 || left || right), and a record proof’s event_digest field is sha256:<digest hex>.

The time anchor

anchors carries the RFC 3161 time anchors collected for a checkpoint, one object per token. A token is signed by a Time-Stamp Authority over the checkpoint’s hash. It is the independent half of the record: Attesso’s key alone could sign a backdated checkpoint, but a token from an authority that never spoke to Attesso fixes the checkpoint’s existence at a moment it attests.
To check one with ordinary tooling: decode token from standard base64 to a .tsr file, then inspect it with OpenSSL.
The token’s message imprint must equal the checkpoint’s hash, computed from the payload you hold (SHA-256 over the decoded payload bytes). Whether you trust that authority is your policy, not Attesso’s: check the token against the TSA’s published certificate, or treat it as a second signature over the same bytes. An unanchored checkpoint serves "anchors": [], and that is honest: the worker anchors on its next cycle when an authority is reachable.

Verify it (Go, standard library only)

check-the-record.go is the runnable recipe: it takes the artifacts above and prints one OK or FAIL line per check. Download it, then:
Exit code 0 means everything verified; exit code 1 names the checks that did not. The same steps are implementable in any language that has SHA-256 and ECDSA P-256; the example is a reference, not a dependency.

When the record proof lags

record-proof reports pending_events: the mandate’s events not yet covered by a published checkpoint (journal lag plus checkpoint lag). A non-zero count is normal right after activity; fetch again once the next checkpoint exists. checkpoint is null until the log’s first checkpoint, and inclusion proofs only exist for events the checkpoint covers.

Limits

  • The record proves the log only grows and that what you saw earlier is still contained. It is a point-in-time guarantee: re-check the latest checkpoint to extend it.
  • Checkpoints are signed by one published key; the keys page (/.well-known/record-log-jwks.json) retains rotated keys for the evidence-retention period. A compromised key can forge checkpoints until rotation; your previously saved checkpoints and the prev_hash chain still pin the earlier history.
  • Attesso fetches fresh proofs for you today. The proofs are offline verifiable, which is what makes them worth collecting.
See also: Verify evidence for the evidence bundle that carries a mandate’s events.