Case study · Authority Replay · A02

Can a consumed authority be replayed?

A command authorization is meant to be used once. The real risk isn't only an outsider sending commands — it's a captured, already-valid authorization being replayed after it should be spent. This is a controlled test of whether an action gate rejects that replay — backed by evidence anyone can re-run.

Target  robot action gate Environment  synthetic · software-only Physical motion  none Method  Authority Continuity Assessment

The attack — authority replay

A legitimate authorization is issued for one action and consumed. The adversary then re-submits the same authorization, hoping the gate trusts it again because it was valid once.

01 · issue
Authorization granted for one action
02 · consume
Action authorized, authority marked spent
03 · replay
Same authority re-submitted by adversary
04 · verdict
Rejected — AUTHORITY_ALREADY_CONSUMED

Result

# replay of a consumed authority request.authority = <previously valid, now spent> gate.evaluate() → DENIED reason = AUTHORITY_ALREADY_CONSUMED simulated_effect = none — mock actuator never engaged

The gate treated the second use as an attack, not a retry. It didn't re-authorize — and, the part most systems get wrong, it didn't report success while silently doing nothing. The verdict and the simulated effect matched.

Evidence — tamper-evident capsule

Every run emits a signed evidence capsule: the decision, its reason, the parameters and a verification token. In testing, every tampering attempt was caught — altering a record, the reason, the stored token or a signature all make verification fail. It's built to be checked by a party who didn't run the test.

  • Every mutation rejected — a flipped byte, a changed reason, a swapped token or a broken signature all return verification = False.
  • One residual gap — the signing key is stored beside the capsule, so it proves internal consistency unless the key arrives through a trusted channel.
  • Enforcement is real — in a mutated copy, removing the single-use check makes the replay test fail. Three independent layers guard it.
  • Not a test double — the checks drive the real action gate directly, and prove the robot never moved.

Independent verification — claim ≠ proof

A result reported by the tool that produced it is a claim, not proof. So the suite was re-run from a clean environment — fresh virtual environment, freshly installed dependencies, no reuse of the build that produced the original numbers — and the repository state was hashed before and after.

# clean-room re-run python3 -m venv --clear cleanvenv # Python 3.12.3 pip install cryptography pytest qrcode pytest A02 + P1 + P2 -q 134 passed · 47 subtests passed · 0 failed · 0 skipped git status + SHA-256(results/*) → identical before and after

Reproduced from scratch — not taken on trust. The run altered nothing: git status and the evidence-file hashes were identical before and after. Pinned to an immutable commit, so this case stays valid over time.

What this does not prove

Synthetic, not physical. This ran software-only against a mock actuator. No robot moved; physical validation remains blocked pending an independent hardware stop. Nothing here is a claim about physical hardware.

Tamper-evident, not yet authenticated. Every content, token or signature change tested was detected. The one residual gap: the signing key sits beside the capsule, so a party able to rewrite all of it could produce a self-consistent set. A trusted external channel for the key closes this.

Reproduced, not certified. A passing test count is evidence the behaviour holds under the cases tested. It is not a certification, and not a guarantee against untested inputs.

// What we can state

In a synthetic environment, Cyber Kimura demonstrated that a consumed authority cannot be replayed: a second request carrying an already-used authorization was rejected (AUTHORITY_ALREADY_CONSUMED) by an enforcement path confirmed through mutation testing, backed by a tamper-evident evidence capsule — and the result was reproduced independently from a clean environment, with the repository verified unchanged.

Next case: Authority After Change — does an unused permission survive a new activation? →

Does your autonomous system actually hold the line?

AI agents, drones, robots — one method: does authority hold, end to end, and keep holding after things change?

Request an assessment →