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.
- A leaf is
SHA-256(0x00 ‖ h), wherehis the 32 bytes of a record's hash (the bytes its hexhashmember spells). - An interior node is
SHA-256(0x01 ‖ left ‖ right). - The root of the empty log is
SHA-256of the empty string. - A record's leaf index counts from 0.
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>
- The text is three lines, each ended by a line feed: the origin (
antler.ai/<workspace id>/log), the tree size in decimal without leading zeros, and the root hash in standard base64. Further lines may follow before the blank line; a verifier keeps them as part of the signed text and does not interpret them. - A blank line separates the text from one signature line per signer. A signature line is an em dash (U+2014), a space, the key name, a space, and the standard base64 of 4 bytes of key id followed by the 64-byte Ed25519 signature. The signature is over the text, from its first byte through the line feed that ends its last line (not the blank line).
- The key name is the origin. The key id is the first 4 bytes of
SHA-256(key name ‖ 0x0A ‖ 0x01 ‖ public key). - A note is at most 65,536 bytes and has at most 16 signature lines. The text holds no control character but the line feeds, and no empty line.
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:
- If
leaf >= tree_size, fail. Setfn = leaf,sn = tree_size - 1,r= the leaf hash. - For each
pinhashes: ifsnis 0, fail. Iffnis odd orfn == sn, setr = node(p, r)and, whenfnis even, shiftfnandsnright untilfnis odd or 0. Otherwise setr = node(r, p). Then shiftfnandsnright once. - The proof holds when
snis 0 andris 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:
- If
fromis 0, the proof must be empty and holds. Iffrom == to, the proof must be empty and the roots equal. - If
fromis a power of two, put the first root at the front ofhashes. - Set
fn = from - 1,sn = to - 1; shift both right whilefnis odd. Setfr = sr =the first hash. - For each further hash
c: ifsnis 0, fail. Iffnis odd orfn == sn, setfr = node(c, fr),sr = node(c, sr)and, whenfnis even, shift both right untilfnis odd or 0. Otherwise setsr = node(sr, c). Then shift both right once. - The proof holds when
fris the first root,srthe second andsnis 0.
Signed objects
{"purpose":"report","key_id":"<16 hex>","payload":"<base64>","sig":"<base64>"}
payloadis the standard base64 of the bytes that were signed.sigis the Ed25519 signature overSHA-256("antler-<purpose>-v1" ‖ 0x00 ‖ payload bytes): the purpose is part of what is signed, so a signature made for one purpose never verifies for another.key_idis the first 8 bytes of the SHA-256 of the public key, in hex. A verifier looks the key up among the keys pinned for the purpose it expects.- The object's hash is the SHA-256 of the payload bytes.
The purposes of a workspace's keys, and the prefix each signs under:
| Purpose | Signs | Signed as |
|---|---|---|
policy | The policy a device applies | a signed object, prefix antler-policy-v1 |
approval | An approver's decision | a signed object, prefix antler-approval-v1 |
receipt | Ingest receipts | a signed object, prefix antler-receipt-v1 |
report | Reports, and a search export's trailer | a signed object, prefix antler-report-v1 |
checkpoint | Checkpoints | a signed note (above), with no prefix: the origin line plays its part |
audit | The records of the server's chain | a 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:
- from the documents' published keys (a bundle's manifest, a search export's header, or a key file given apart), it keeps each key whose fingerprint is pinned for its purpose;
- a pinned fingerprint that matches no published key makes the result invalid: the evidence was not signed with the keys the verifier was told to trust;
- keys that no fingerprint names are not used.
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.