Antler

In development

Early access

Docs

The log, checkpoints, proofs and signed objects

Every record the server accepts, from every device and from its own chain, has its hash appended to one append-only Merkle log per workspace. The server signs the log's state as checkpoints. A record is shown to be in the log by an inclusion proof, and one checkpoint is shown to extend another by a consistency proof. Everything else the server signs (receipts, reports, policies, approval decisions) is a signed object.

Vectors: 07-checkpoint, 08-inclusion, 09-consistency, 10-signed-object, 11-receipt.

The log

The log is the Merkle tree of RFC 6962, section 2.1, over record hashes in the order the server accepted them.

Checkpoints

A checkpoint is a signed note (the C2SP signed-note format) whose text is a C2SP checkpoint:

<origin>
<tree size>
<root hash>

— <key name> <signature>

A verifier accepts a note when at least one signature line names a pinned key (by name and key id) and verifies. A line that names a pinned key and does not verify makes the note invalid; lines of unknown keys are ignored. It then requires the origin to be the one it expects.

The checkpoint key is published as a verifier key: <key name>+<key id, 8 hex digits>+<base64 of 0x01 ‖ public key>.

Two verified checkpoints of one origin with the same size and different roots prove that the log was rewritten.

Inclusion proofs

{"record_hash":"<hex>","leaf":5,"tree_size":25,"hashes":["<hex>", "..."]}

hashes is the RFC 6962 audit path, the leaf's sibling first. A verifier computes the leaf from record_hash and checks the path against the root of a verified checkpoint whose size is tree_size, by RFC 9162, section 2.1.3.2:

  1. If leaf >= tree_size, fail. Set fn = leaf, sn = tree_size - 1, r = the leaf hash.
  2. For each p in hashes: if sn is 0, fail. If fn is odd or fn == sn, set r = node(p, r) and, when fn is even, shift fn and sn right until fn is odd or 0. Otherwise set r = node(r, p). Then shift fn and sn right once.
  3. The proof holds when sn is 0 and r is the root.

Consistency proofs

{"from":8,"to":25,"hashes":["<hex>", "..."]}

hashes is the RFC 6962 consistency proof that the tree of size from is a prefix of the tree of size to. With the roots of two verified checkpoints of those sizes, a verifier checks it by RFC 9162, section 2.1.4.2:

  1. If from is 0, the proof must be empty and holds. If from == to, the proof must be empty and the roots equal.
  2. If from is a power of two, put the first root at the front of hashes.
  3. Set fn = from - 1, sn = to - 1; shift both right while fn is odd. Set fr = sr = the first hash.
  4. For each further hash c: if sn is 0, fail. If fn is odd or fn == sn, set fr = node(c, fr), sr = node(c, sr) and, when fn is even, shift both right until fn is odd or 0. Otherwise set sr = node(sr, c). Then shift both right once.
  5. The proof holds when fr is the first root, sr the second and sn is 0.

Signed objects

{"purpose":"report","key_id":"<16 hex>","payload":"<base64>","sig":"<base64>"}

The purposes of a workspace's keys, and the prefix each signs under:

PurposeSignsSigned as
policyThe policy a device appliesa signed object, prefix antler-policy-v1
approvalAn approver's decisiona signed object, prefix antler-approval-v1
receiptIngest receiptsa signed object, prefix antler-receipt-v1
reportReports, and a search export's trailera signed object, prefix antler-report-v1
checkpointCheckpointsa signed note (above), with no prefix: the origin line plays its part
auditThe records of the server's chaina record signature (records.md), with no prefix

A verifier checks the signature over the payload bytes first and decodes the payload only then, strictly: an unknown member or trailing data makes it invalid. An object is at most 1 MiB.

Ingest receipts

A receipt is a signed object of purpose receipt whose payload is:

{"device_id":"d_…","accepted_through_seq":23,"head_hash":"<hex>","log_size":25,"time":"2026-11-06T00:00:00Z"}

It says the server accepted the device's chain through that seq, whose record has that hash, and that the log then held log_size leaves. A verifier checks the signature with a pinned receipt key, that device_id is the chain's, that head_hash is 64 lower-case hex digits when accepted_through_seq is not 0, that log_size is not negative and that time is RFC 3339 in UTC.

A receipt proves where a chain ends only when it is at least as new as the newest checkpoint it is shown beside (log_size not smaller than that checkpoint's size): an older receipt says nothing about records accepted after it.

Published keys and fingerprints

A workspace publishes its public keys as:

{"keys":[{"purpose":"report","key_id":"<16 hex>","key":"<base64 of the 32-byte key>"}, "..."]}

with the checkpoint key apart, as a verifier key (above), wherever a document carries keys (checkpoint_key). A key's key_id must be the one its bytes give.

A fingerprint is the SHA-256 of a public key, as 64 lower-case hex digits, written purpose:hex. Fingerprints are how a verifier pins keys it was not enrolled with:

Fingerprints must come from somewhere the workspace's operator does not serve: the company's MDM profile (its server_key_fingerprints, a map from purpose to a list of fingerprints) or a computer that pinned the keys when it enrolled. Never from the evidence itself, which lists them unsigned.

With the server's keys pinned this way, a device's key comes from the evidence. A verifier accepts it only when the pinned log (an inclusion proof against a verified checkpoint) or a pinned receipt covers the head of that device's chain, and it then checks every record's signature with it. That shows nobody but the workspace changed a record; it does not rule out a workspace that invented a device, which only that device's own key can.