Tamper detection coverage on the signed audit chain

An attacker who has direct database access edits the row_hash of a chain row after the fact. The intent is to alter the content commitment for that event without leaving a trace. The offline verifier should catch the resulting break in the prev_hash linkage on the next row.

An attacker with direct database access deletes a chain row after the fact. Row count and chain linkage no longer agree with the closed epoch that used to bound the deleted row. The offline verifier detects this either through the prev_hash break at the next row or through the epoch boundary reference to a missing seq.

An attacker inserts a fabricated row into the log. The attacker may set the row hash and prev_hash to plausible looking sha256 shapes but has no way to reproduce the hash of a legitimate predecessor row that already exists at the target seq. The offline verifier detects the resulting prev_hash break as it walks forward.

An attacker modifies the prev_hash field of a middle row. The chain linkage now claims the row followed a different predecessor. The offline verifier catches the mismatch when the walk reaches that row.

An attacker rewrites the merkle_root of a closed epoch. Even the shape check fails because the field no longer carries a valid sha256 identifier. A cryptographic envelope re verification would also fail because the envelope was signed over the original root.

An attacker removes the signature envelope from a closed epoch. The signed head no longer commits to the epoch content. The offline verifier catches the missing envelope field.

An attacker with a broken classical primitive replaces the hybrid signature envelope with an envelope that carries only the Ed25519 signature. A verifier that requires both classical AND post quantum components rejects the envelope. This is the specific reason Etch ships hybrid signing rather than classical only.

An attacker adjusts an epoch's first_entry_seq or last_entry_seq so a range of rows falls outside the signed epoch. The rows are still on the log but appear to have never been sealed. The structural verifier catches the boundary reference to a non existent seq.

An attacker preserves the epoch boundary fields but changes the declared entry_count to a smaller number. The structural verifier catches the mismatch.

An attacker with direct database access rewrites the row_hash of an Etch parallel chain row. The Etch chain carries the same prev_hash walk invariant as the OSS chain, so the offline verifier catches the mismatch on the next row.

An attacker deletes an Etch chain row after the fact. The prev_hash of the next row no longer matches the surviving predecessor's row_hash. The offline verifier catches the break on the walk.

An attacker rewrites the kind field of a benign chain row to postmortem, fabricating a retroactive corrective action that was never attested. The row_hash was computed over the original kind so a downstream cryptographic re verify would catch the mutation, and the field level check catches the mismatch directly.

An attacker inserts a row into the cross chain reference projection index that claims an etch_chain_seq for which no chain row exists. The projection would report a phantom cross chain reference to any reader that trusts the projection without cross checking against the chain. The verifier detects the missing chain row and rejects the projection state.

An attacker mutates a cross chain reference row's target_chain_id to a value that does not match the sha256 shape emitted by compute_chain_id. The verifier rejects the row because no derived chain identifier could produce that string.