The link is a hash of the previous hash and the stored canonical bytes
Each event joins the chain as a hash of the previous hash and the canonical bytes of the event. The platform stores those canonical bytes, and verification uses the stored bytes. A checker that parses the event, serialises it a second time, and hashes the fresh serialisation is examining a different object, even if a person would say the two texts look the same. The verifier does separately compare the stored bytes with the canonical form of the stored body, because an edit to the body column leaves the hash intact and only that comparison catches it.
There is a prior window in which no link exists yet. Enforcement can complete, and the decision can sit on the local spool, before a drain appends the event to the chain. Until that append, there is nothing for this hash to cover. This primer reserves the word checkpoint for a signed record of a chain head, which can only name events already stored.
The checkpoint is an Ed25519 signature over a record of the chain head
A checkpoint is an Ed25519 signature over the canonical JSON (RFC 8785) of its own body: the hash and sequence number of the chain head, the event count, a strictly increasing counter, and the hash of the previous checkpoint. It reaches event bytes only indirectly, because the head hash is built from every hash before it. A signature that verifies is evidence that the holder of that key asserted this head. The key lives on the appliance, so someone with root there can rewrite the chain and sign the new head, and the signature alone does not show that history was not rewritten. That question falls to an anchor off the box. Agreement by a person with a decision inside an event is a separate fact, and the signature does not create it.
A client SIEM is absent in this phase. Checkpoints here are really emitted and really signed. Acceptance by a third-party log system is not what the signature establishes. An emulated anchoring path can export the checkpoint. The export is a file leaving this appliance, not a receipt from a system the evaluating organisation operates. Readers who need that receipt will not find it in the signature.
Cadence advances only on a matching acknowledgement
The anchoring cadence moves when an acknowledgement arrives and its digest matches the checkpoint’s canonical bytes. The match is the condition. Elapsed time is not a condition. A design in which the cadence crept forward on a timer would be a different product, and this POC does not implement that timer.
The behaviour is easy to see, which is why it belongs in the demonstration rather than in a footnote. If no acknowledgement matches, the cadence does not advance. After a single checkpoint with no further match, it stalls. A picture of a smooth, self-running cadence describes a clock this build does not have. The honest picture is the stall until a matching acknowledgement shows up.
In this POC the acknowledger is a command-line stand-in
The acknowledger is a command-line tool standing in for a SIEM return channel. It sends back a digest of the exported checkpoint. The control plane compares that digest with the checkpoint’s stored canonical bytes, and on a match allows the cadence to move. On a mismatch the cadence stays where it is. The rule is small, and it is the whole substitute this phase has for a reply from an external log platform.
The command speaks from the evaluation environment. It is not an analyst seated in a security operations centre, and it is not an integration an estate has installed and operated. The stand-in label remains on the command for the entire evaluation. Describing the command as a production anchoring partnership would delete that label.
A byte flip in a replay shows the checker looking at stored bytes
A demonstration can alter a stored byte and watch the verifier fail. The verifier recomputes each row’s hash from its stored canonical bytes, so a flipped byte shows up as a hash mismatch and the failure names that row’s sequence number. Restore the byte and the recomputed hash matches again. The hash catches the flip, not the signature, which covers the checkpoint record rather than the event’s bytes. Recomputing every later hash to hide the flip moves the chain head away from the one the checkpoint names, though anyone holding the appliance key could then sign a new checkpoint over the new head.
The events in that replay are synthetic. The replay shows the verifier reacting to the object it was given. It does not show a production chain, a live estate, or a notice delivered to anyone outside the room. Synthetic events, real hashes over their stored bytes, and a real signature over the checkpoint is the accurate description. Live discovery, and a SIEM’s acceptance, remain outside the fixture.
How to read this
| Read it as | Which means | Do not read it as |
|---|---|---|
| Stored object | Canonical bytes, not a fresh serialisation | A hash of a re-parsed event |
| Checkpoint | Ed25519 over a record of the chain head | Proof a SIEM accepted it |
| Cadence | Moves when an acknowledgement matches | A clock that advances on its own |