Anchoring Audit Logs to RFC 3161 Timestamps

A hash chain and a Merkle root prove a controlled-substance log is internally consistent, but they cannot prove when it existed — nothing in a self-computed digest stops an operator from rebuilding the whole structure after the fact and claiming it is original. RFC 3161 timestamping supplies the missing external witness: a Time-Stamp Authority (TSA) signs a token binding your hash to a trusted clock, so you can later prove the hash — and every event beneath it — existed no later than that moment. This recipe takes a Merkle root (or any log-segment hash), obtains a timestamp token, stores it with the segment, and verifies that the token binds that exact hash at that time. It sits within Merkle-Tree Audit Anchoring, which produces the root, and pairs with Building Merkle Proofs for Inventory Events, which proves a single event belongs to that anchored root.

The exchange is deliberately minimal and privacy-preserving. The client sends only a hash — never the log, never any patient data — inside a TimeStampReq. The TSA returns a TimeStampResp carrying a signed token (TimeStampToken) that embeds the submitted hash (the message imprint), a generation time, and the authority’s signature. Verification later recomputes the hash from the retained root, confirms it matches the imprint in the token, and checks the TSA signature and time. If all three hold, existence-at-time is established from the stored token alone, offline.

Problem framing

The parent reference reduces a batch of controlled-substance events to a single Merkle root and states that the root is submitted to a Time-Stamp Authority. This recipe is that submission and its verification. The distinction it makes concrete is subtle but decisive for an audit: a root you computed yourself proves integrity — nobody altered the batch — but not existence-at-time. Only a signature from an independent party over your hash, tied to that party’s clock, converts “we say this is unchanged” into “a third party attests this existed by time T.” Under 21 CFR § 1304.04, a two-year-old record must be both retrievable and credible; the timestamp token is what makes a recomputed root credible years later.

Two failure modes make this operation easy to get subtly wrong: hashing the wrong bytes (so the token binds something other than the anchored root) and trusting a token without validating the TSA’s certificate chain (so a forged or expired token passes). The implementation below is structured so the hashed bytes are unambiguous and verification checks the binding, the signature, and the time as three separate gates.

Prerequisites & environment

• Python 3.11+, with the rfc3161ng client for the ASN.1 request/response encoding and cryptography for certificate handling. Hashing stays in the standard-library hashlib.
• A TSA endpoint and its trust anchor. You need the TSA’s HTTP URL and the CA certificate (or the TSA signing certificate) used to validate returned tokens. Treat the certificate as configuration loaded from your key store, never hardcoded.
• Regulatory context to hold: 21 CFR § 1304.04 (retained, retrievable records — the token makes retention provable), 45 CFR § 164.312(c)(1) (integrity — the imprint binding is an integrity check), and 45 CFR § 164.312(b) (audit controls — the token is part of the audit artifact). The root you anchor comes from Merkle-Tree Audit Anchoring; a single event within it is proven by building Merkle proofs.

Implementation: request, store, and verify a timestamp token

The module wraps the TSA exchange behind two functions. anchor_root submits the root’s SHA-256 digest and returns an immutable AnchorToken; verify_anchor recomputes the digest from the retained root, checks it against the token, validates the TSA signature against the trust anchor, and extracts the attested time. Structured logging records the root and time only — never the log body.

from __future__ import annotations

import hashlib
import logging
from dataclasses import dataclass
from datetime import datetime, timezone

import rfc3161ng   # ASN.1 TimeStampReq/Resp encoding for RFC 3161

logger = logging.getLogger("pharmacy.audit.rfc3161")


@dataclass(frozen=True)
class AnchorToken:
    """A stored RFC 3161 token binding one Merkle root to an attested time."""

    root_hex: str          # the exact hash that was anchored
    token_der: bytes       # DER-encoded TimeStampToken as returned by the TSA
    gen_time: str          # TSA-attested genTime, ISO-8601 UTC
    tsa_name: str


def anchor_root(root: bytes, tsa_url: str, tsa_certificate: bytes,
                tsa_name: str) -> AnchorToken:
    """Request a timestamp for a Merkle root and return an immutable token.

    Only the SHA-256 digest of the root leaves the boundary — never the log or
    any PHI — satisfying minimum-necessary disclosure under 45 CFR 164.312(a)(1).
    """
    imprint = hashlib.sha256(root).digest()          # hash the EXACT anchored bytes
    stamper = rfc3161ng.RemoteTimestamper(
        tsa_url, certificate=tsa_certificate, hashname="sha256",
    )
    # Submit the precomputed digest so the imprint is unambiguous and reproducible.
    token_der = stamper(digest=imprint, return_tsr=False)
    gen_time = rfc3161ng.get_timestamp(token_der)    # datetime from the token

    token = AnchorToken(
        root_hex=root.hex(),
        token_der=token_der,
        gen_time=gen_time.astimezone(timezone.utc).isoformat(),
        tsa_name=tsa_name,
    )
    logger.info(
        "rfc3161_anchor_issued root=%s gen_time=%s tsa=%s",
        token.root_hex, token.gen_time, token.tsa_name,
    )
    return token


def verify_anchor(root: bytes, token: AnchorToken,
                  tsa_certificate: bytes) -> bool:
    """Confirm the token binds THIS root, is TSA-signed, and carries a time.

    Three independent gates: (1) the root still hashes to the stored root_hex,
    (2) the token's message imprint matches that hash under the TSA signature,
    (3) a genTime is present. A failure of any gate fails the anchor.
    """
    if root.hex() != token.root_hex:
        logger.warning("rfc3161_verify_failed reason=root_mismatch root=%s", root.hex())
        return False
    imprint = hashlib.sha256(root).digest()
    try:
        # check_timestamp validates the TSA signature over the imprint against
        # the trust anchor and confirms the imprint equals our digest.
        signature_ok = rfc3161ng.check_timestamp(
            token.token_der, digest=imprint, certificate=tsa_certificate,
        )
    except Exception:                                # malformed/expired/untrusted token
        logger.warning("rfc3161_verify_failed reason=signature root=%s", root.hex())
        return False

    result = bool(signature_ok) and bool(token.gen_time)
    logger.info(
        "rfc3161_verify result=%s root=%s gen_time=%s",
        "PASS" if result else "FAIL", token.root_hex, token.gen_time,
    )
    return result

The AnchorToken is frozen and stored beside its log segment, so the retained artifact carries everything an offline verifier needs: the root it commits to, the DER token, and the attested time. Nothing here reaches back to the event bodies, which is what lets the whole exchange run against a third-party TSA without any HIPAA exposure.

Verification & testing

The verification path must accept a genuine token bound to the correct root and reject a token checked against the wrong root. Because a real TSA round-trip is non-deterministic, the test seam swaps in a captured token and asserts the binding gates behave correctly; in CI you additionally run one live smoke test against a staging TSA.

import hashlib
import pytest
from rfc3161_anchor import AnchorToken, verify_anchor

TSA_CERT = open("tests/fixtures/tsa_ca.pem", "rb").read()


def _stored_token(root: bytes) -> AnchorToken:
    # Captured from a real TSA round-trip during fixture generation.
    return AnchorToken(
        root_hex=root.hex(),
        token_der=open("tests/fixtures/token.der", "rb").read(),
        gen_time="2026-07-16T14:07:33+00:00",
        tsa_name="staging-tsa",
    )


def test_matching_root_verifies():
    root = hashlib.sha256(b"batch-1001-root").digest()
    assert verify_anchor(root, _stored_token(root), TSA_CERT) is True


def test_wrong_root_is_rejected():
    root = hashlib.sha256(b"batch-1001-root").digest()
    other = hashlib.sha256(b"different-batch").digest()
    # The token commits to `root`; verifying it against `other` must fail fast.
    assert verify_anchor(other, _stored_token(root), TSA_CERT) is False

A successful anchor emits a single structured line proving the binding without leaking anything sensitive:

INFO pharmacy.audit.rfc3161 rfc3161_anchor_issued \
     root=b8f1c2...9a3e gen_time=2026-07-16T14:07:33+00:00 tsa=staging-tsa

During an inspection, re-running verify_anchor against the retained root reproduces this binding: a PASS establishes that the root — and, via an inclusion proof, any single event under it — existed by the attested gen_time, which is precisely the existence-at-time evidence 21 CFR § 1304.04 retention is meant to support.

Gotchas & compliance pitfalls

• Hashing the wrong bytes. The token binds whatever imprint you submit. If you anchor a hex string of the root, or the root plus a stray newline, the stored token will not match a root recomputed from bytes. Fix the exact bytes once — the raw 32-byte root — and hash those on both the anchor and verify paths.
• Skipping TSA certificate validation. A token is only as trustworthy as the certificate that signed it. Accepting a token without checking it against a pinned CA lets a forged or expired signing certificate pass. Load the trust anchor from your key store and validate every token against it, including certificate expiry at the time of verification, not just issuance.
• Confusing local clock with token time. The evidentiary time is the TSA’s genTime, not your server’s wall clock. Never substitute datetime.now() for the token time, and treat a token whose genTime predates the earliest event in the batch as a fault to quarantine rather than a record to trust.
• Offline batching and deferred anchoring. When the TSA is unreachable, compute and persist the root immediately and queue it as PENDING_ANCHOR; anchor it in order on reconnect. The deferred token’s genTime will legitimately be later than the events it covers — that is expected and acceptable, because existence-at-time is an upper bound. The durable-queue mechanics follow Fallback Routing for Offline Sync.
• Nonce omission on interactive requests. Include a nonce in the TimeStampReq so a response cannot be replayed from a cached exchange; verify the nonce echoes back on the round trip.
• Storing the token apart from the root. A token with no retained root proves nothing, and a root with no token has no time. Persist them together, redundantly — the token is the one artifact you cannot regenerate locally.

Frequently Asked Questions

Related

• Merkle-Tree Audit Anchoring — parent reference: how the root being anchored is built.
• Building Merkle Proofs for Inventory Events — proving one event belongs to the anchored root.
• Fallback Routing for Offline Sync — deferred anchoring when the TSA is offline.
• Core Architecture & DEA Compliance Frameworks — the retention and audit foundation this anchor supports.