Tamper-Evident Logging

The foundational primitive of tamper evidence. A cryptographic hash function (e.g., SHA-256) takes an input of arbitrary length and produces a fixed-size, unique digest. Any alteration to the input, even a single bit, results in a completely different hash output—a property known as the avalanche effect. Log entries are hashed individually and then chained together, so a change to any historical record invalidates all subsequent hashes, making tampering computationally infeasible to hide.

A technique that links log entries sequentially to prevent insertion or deletion attacks. Each new log record includes the cryptographic hash of the immediately preceding record. This creates a forward integrity guarantee: an attacker cannot modify a past entry without recalculating every subsequent hash in the chain. The final hash, or root hash, serves as a succinct commitment to the entire history. Any auditor can verify the chain's integrity by recomputing the hashes from the start.

Hashing proves integrity, but not authorship. Digital signatures using asymmetric cryptography (e.g., ECDSA, Ed25519) bind a log entry to a specific identity. The logger signs the entry's hash with a private key, and any party can verify the signature with the corresponding public key. This provides non-repudiation: the signer cannot credibly deny having authored the log entry. In AI governance, this ties a specific model inference or decision to an accountable operator or system identity.

A hash chain proves sequence, but not absolute time. A Timestamping Authority (TSA) is a trusted third party that cryptographically binds a log entry's hash to a certified wall-clock time. The TSA countersigns the hash with its own private key, creating a timestamp token that proves the data existed before a specific moment. This is critical for regulatory compliance, establishing a verifiable chronology for events like model training completion or a high-risk decision.

To defend against a sophisticated adversary who compromises the logging system itself, a periodic integrity proof can be published to an external, immutable medium. The most common method is blockchain anchoring, where the root hash of a log segment is embedded in a public blockchain transaction. This leverages the blockchain's global consensus and immutability as an independent witness, making it impossible to rewrite history even with full system access.

The software and storage architecture must enforce that records can only be added, never overwritten or deleted. This is implemented through append-only logs and often reinforced with WORM (Write Once, Read Many) storage hardware. Combined with hash chaining, this ensures a complete, gap-free history. Any attempt to truncate the log is immediately evident because the chain of hashes is broken, and the expected final root hash will not match the truncated version.

A sequential application of a cryptographic hash function where each link incorporates the hash of the previous entry. This creates a verifiable, ordered sequence where altering any single record would require recalculating all subsequent hashes—a computationally infeasible task.

• Mechanism: H_n = hash(H_{n-1} || data_n)
• Use case: Securing sequential log entries before periodic anchoring
• Weakness: Tail truncation remains possible without external anchoring

A binary hash tree that efficiently verifies the integrity of large datasets by organizing data blocks into leaf nodes and computing pairwise hashes upward to a single Merkle root. This structure enables logarithmic-time inclusion proofs without revealing the entire dataset.

• Efficiency: O(log n) verification for any single record
• Application: Committing batches of log entries to a blockchain in a single transaction
• Key property: Tampering with any leaf invalidates the root hash

A cryptographic mechanism using asymmetric cryptography (public/private key pairs) to prove both the authenticity and integrity of a log entry. The signer uses a private key to generate a signature over the log data; verifiers use the corresponding public key to validate it.

• Algorithm examples: ECDSA, Ed25519, RSA-PSS
• Provides: Non-repudiation—the signer cannot credibly deny authorship
• Critical for: Attributing AI decisions to specific models or operators

A trusted third-party service that issues cryptographic timestamps proving data existed at a specific point in time. The TSA binds the hash of the submitted data with a precise time value and signs the combination using its own private key, per RFC 3161.

• Establishes: Verifiable chronology for audit trail ordering
• Trust model: Relies on the TSA's operational security and key management
• Alternative: Decentralized timestamps via blockchain anchoring

The process of embedding a cryptographic hash of an audit log or a Merkle root into a public blockchain transaction. This leverages the blockchain's global consensus and immutability to provide an external, independent integrity proof that cannot be reversed by any single organization.

• Common chains: Bitcoin (OP_RETURN), Ethereum (event emission)
• Benefit: Eliminates trust in a single logging infrastructure
• Cost consideration: Periodic batching via Merkle roots reduces transaction fees

A dedicated physical computing device that safeguards and manages digital keys for strong authentication and provides crypto-processing. HSMs are used to securely generate and store the private keys used for signing audit logs, ensuring keys cannot be extracted by compromised software.

• Certification: FIPS 140-2 Level 3 or higher
• Protects: Private keys from logical and physical extraction attacks
• Integration: Accessed via PKCS#11 or REST APIs for signing operations