Skip to main content

Forensic Audit Trail Discovery

Most logging surfaces tell you what happened. The forensic question is harder: who did it, when, with what authorisation context, and can the answer survive a courtroom challenge. For regulated industries, the answer is not optional — investigators, auditors, and (occasionally) lawyers need to trace specific operations to specific identities with cryptographic certainty.

This tutorial walks through using the Context extension to run a forensic discovery query against the audit log, surface the human identity that performed an operation, and verify the audit chain is intact end-to-end.

Discovery querytime windowresource scopeoperation typeaudit ledgerEvent detailsubjectMFA stateGate sessionrequest IDsignaturerequest IDAPI access logPolicy decisions logApplication logsVerify chain segmentchain, signatures, anchorSigned forensic bundlePDF + JSON manifest
One query yields signed event details whose request ID reaches the correlated logs, and the result can be verified and exported as evidence.

Prerequisites​

  • A Warden-role account on the project
  • Context installed in the project (Trailblazer extension — installed by default in most plans)
  • A specific question to investigate (we'll use: "Who decrypted record cust_kQ3pZ9rL2sW8's SSN field between 14:00 and 15:00 UTC on 2026-05-13?")

Step 1 — Open Context discovery​

In the Console, navigate to Context → Discovery. The interface presents a query composer with three axes:

  • Time window — from / to with timezone selection
  • Resource scope — collection, record id, field name, file path, etc.
  • Operation type — read, write, encrypt, decrypt, policy decision, MFA event

Step 2 — Build the query​

For our investigation:

  • Time window: 2026-05-13 14:00:00 UTC to 2026-05-13 15:00:00 UTC
  • Resource scope: collection:customers, record_id: cust_kQ3pZ9rL2sW8, field: ssn
  • Operation type: decrypt

Context assembles the query and executes against the audit ledger. The result surface shows:

Time (UTC)OperationSubjectSubject contextRequest ID
14:23:08.412data.read.field.revealedusr_aB4cD5eF6gH9role=support, MFA=verified, gate-session sess_p2qRreq_xZ7yW8
14:47:22.901data.read.field.revealedusr_jK1mN2pQ3rS4role=compliance, MFA=verified, gate-session sess_t5uVreq_aB9cD2

Two events in the window. Each carries the calling subject's hardware-attested identity (not just "the application service"), the MFA state at the time of the operation, the Gate session through which the request arrived, and the request ID for correlation with other surfaces.

Step 3 — Drill into a specific event​

Click on the first row. Context opens the full event detail:

Event: data.read.field.revealed
Timestamp: 2026-05-13T14:23:08.412847Z
Subject: usr_aB4cD5eF6gH9 (Mira Sato, [email protected])
Subject type: user
Roles: support, contact-center
MFA state: verified at 2026-05-13T14:22:51.103Z (17 seconds before operation)
Gate session: sess_p2qR8sT9uV (issued 2026-05-13T13:45:02Z)
Resource: customers/cust_kQ3pZ9rL2sW8 / field=ssn
Policy decision: rule "customers-ssn-decrypt-with-mfa" → allow
Request ID: req_xZ7yW8aB2c3
Signature: rsa-sha256:b7c... (verifiable against Kibo public key kbo-2026)

Every claim in this record is cryptographically attributable:

  • The Subject field carries the user's identity from Gate's verified session token
  • The MFA state reflects the session token's MFA claim at the time of the operation
  • The Gate session ties the request to the specific Gate session that issued the authorisation
  • The Signature is Kibo's RSA-2048+SHA-256 platform signature over this entry; verifiable offline

Step 4 — Correlate across surfaces​

The Request ID (req_xZ7yW8aB2c3) is the cross-surface correlation key. The same ID appears in:

  • API access log — the HTTP request that initiated this operation
  • Policy decisions log — the policy evaluation that authorised the operation
  • Application logs — if your application instruments with requestId (which the SDK propagates automatically)

The Context detail view offers one-click jumps to each correlated surface. You can reconstruct the complete request fan-out:

14:23:08.398 api GET /customers/cust_kQ3pZ9rL2sW8 from 192.168.x.x
14:23:08.401 policy customers.read rule "support-read-customer" → allow
14:23:08.412 kibo decrypt customers.ssn (this event)
14:23:08.418 api response 200 (length 1247)

Twenty milliseconds of activity, fully attributed.

Step 5 — Verify the chain is intact​

Forensic value depends on the audit chain being verifiably untampered. From the event detail view, click Verify chain segment to run an in-Console verification:

Verifying segment 247,318 → 247,322
Hash chain: intact (5/5 links)
Signatures: 5/5 verified against Kibo public key
External transparency anchor: matched at checkpoint 2026-05-13T15:00:00Z
Status: VALID

For high-stakes investigations (audit committee review, legal discovery), run the full offline verification per Tutorials → Warden → Out-of-Band Ledger Verification. The in-Console verification is sufficient for routine discovery; the offline tool is the authoritative answer for adversarial scrutiny.

Step 6 — Export the discovery as evidence​

Context supports exporting any discovery result as a signed evidence bundle:

Export → Signed forensic bundle (PDF + JSON manifest)

The bundle contains:

  • The full event detail for every result row, with signature verification status per entry
  • The query that produced the result set
  • The investigator's identity (you), timestamp, and a fresh investigation-token signature
  • The platform's signature over the bundle (so the bundle itself is tamper-evident)

The PDF is the human-readable summary; the JSON manifest is the machine-verifiable counterpart. Both reference the same hash-chain checkpoint, so an external auditor can independently verify the bundle against the published audit chain.

What just happened​

In about three minutes of click-through work, you:

  • Identified the two specific subjects who decrypted a sensitive field in the investigation window
  • Confirmed each operation had a fresh MFA claim and a verified Gate session
  • Correlated each operation across API, policy, and application logs
  • Verified the audit chain segment is cryptographically intact
  • Produced a signed evidence bundle suitable for audit committee review

The forensic certainty is not a process attestation; it is a property of the chain itself. The same investigation from any other Warden, run six months later, would produce the same bundle because the underlying records are tamper-evident and signed — any alteration would break the hash chain and be detectable.

Next​