SentraMind

Case

One flipped byte, a valid signature, a failed chain

A synthetic case: an auditor verifies a two-event chain, one byte changes, the checkpoint signature still verifies, and the verifier fails at that row with hash-mismatch.

Synthetic run After one byte changes at offset 288 of sequence 1, the signature still verifies and the verifier fails there with hash-mismatch.
signatureVerifies
First run true Second run true
verified
First run true Second run false
checkpointsChecked
First run 1 Second run 0
38 fields, including both events, the checkpoint and the changed byte

Event seq 0

eventType
incident.opened
recordedAt
2026-11-03T11:00:00.120Z
title
Synthetic incident one
prevHash
0000000000000000000000000000000000000000000000000000000000000000
hash
bcea73c25717acf888e076eb177f8d9d794f7bf398b0736d67d812537d42b710

Event seq 1

eventType
incident.opened
recordedAt
2026-11-03T11:01:00.120Z
title
Synthetic incident two
prevHash
bcea73c25717acf888e076eb177f8d9d794f7bf398b0736d67d812537d42b710
hash
22d2868d44369c22b75c0615c362c49f6f426c905d73a1dd63afaf8ead2e0bef

Checkpoint

checkpointCounter
0
recordedAt
2026-11-03T11:05:00.120Z
chainHeadSeq
1
chainHeadHash
22d2868d44369c22b75c0615c362c49f6f426c905d73a1dd63afaf8ead2e0bef
eventCount
2
signingKeyIsThrowaway
true
signaturePrefix
sqZYm6TcPpQiELhc
anchorTarget
file-export
standIn
emulated-siem-anchoring

First run

signatureVerifies
true
verified
true
eventsChecked
2
checkpointsChecked
1
checkpointFailures
[]

One byte changed

seq
1
field
stored canonical bytes
byteOffset
288
byteBefore
0x53
byteAfter
0x52
titleAsStoredAfter
Rynthetic incident two

Second run

signatureVerifies
true
verified
false
eventsChecked
2
checkpointsChecked
0
checkpointFailures
[]
failure
seq=1 kind=hash-mismatch
expectedHash
61fd45048ac483573b2866cfc34c5f16baa9868faab1d7139d5679658fa02c38
observedHash
22d2868d44369c22b75c0615c362c49f6f426c905d73a1dd63afaf8ead2e0bef

11:00 to 11:05: two events and a checkpoint

An auditor is checking a short chain from 3 November 2026 (all times UTC). Two incident.opened events are on it, recorded at 11:00:00.120 and 11:01:00.120, titled “Synthetic incident one” and “Synthetic incident two”. Each event’s canonical bytes are stored. Its hash covers the previous event’s hash and those bytes, so the second event, sequence 1, carries the first event’s hash bcea73c2… and has the hash 22d2868d….

At 11:05:00.120 a checkpoint is signed. Its body says the chain head is sequence 1, gives the head hash 22d2868d…, and counts 2 events. The signature covers that body. It reaches the events only through the hash the body names.

The auditor’s first run passes

The auditor runs the verifier and reads verified: true, with eventsChecked: 2 and checkpointsChecked: 1. The signature verifies too. That result means something specific: every hash was recomputed from the stored bytes and matched, the links between events held, and the checkpoint’s head matched the chain the verifier had just recomputed. It hashes the stored bytes rather than a fresh rendering of the event, which could hide a change to what was actually kept, and separately compares a fresh rendering with those bytes to catch an edit to the body.

One byte changes

Later, one byte in the stored bytes of sequence 1 changes, at offset 288, from 0x53 to 0x52: the letter S becomes R. The tool that produced this case makes that change on purpose, so the result can be reproduced. The title inside those bytes now reads “Rynthetic incident two”. Nothing else moves: the stored hash, the link, and the checkpoint are as they were.

A change of one letter in a long audit history is not something a person catches by reading it.

The second run: two answers

The auditor runs the same checks and gets two answers that look contradictory.

The signature still verifies. The checkpoint body names a hash, and that hash has not changed. The signature has no view on whether the stored bytes still produce it.

The verifier fails: verified: false, at sequence 1, with kind hash-mismatch. It recomputes 61fd4504… from the bytes and finds 22d2868d… stored beside them. The break is detected by the hash, and the signature plays no part in that.

The same output reads checkpointsChecked: 0. That zero means the verifier never compared this checkpoint with the chain. It checked the signature, which passed, and did not count that as a check. The verifier stops at the first bad row, so the head the checkpoint names sits outside the part of the chain it verified. An auditor who looked only at the signature would come away with the wrong answer, and so would one who read that zero, beside an empty list of checkpoint failures, as a clean checkpoint.

What it came to, and its limits

The auditor can state one thing with confidence: the stored bytes at sequence 1 no longer match the hash written for that row. The verifier does not say who changed them, when, or why, and it cannot restore them from a hash.

A valid signature only shows that something holding the appliance’s key asserted that head. In this run the key is a throwaway derived from a public label, so the signature here carries no authority at all. On an appliance, someone with root could reach that key, rewrite the chain and sign a new checkpoint over it. Only a copy of the head held off the box would expose that. This checkpoint’s anchor target is file-export under the stand-in emulated-siem-anchoring, so no external system holds its head.

The chain was built in memory, so the database path that sequences events under a lock did not run. The hash and verifier are the same code the product uses. Two events say nothing about performance over a long chain.

How to read this

How to read this
Read it asWhich meansDo not read it as
Before the change Verified: 2 events and 1 checkpoint checked A live estate
After one byte Signature still verifies; chain fails at sequence 1 with hash-mismatch A signature that vouches for the bytes
checkpointsChecked: 0 Signature checked, but never compared with the chain A checkpoint that vouches for the chain

This case is synthetic. The people, inputs and destinations in it are invented for explanation, and the records are what the packages produced from them. None of it is a customer, a deployment or a measured incident.