Internet-Draft Attested Fence Receipts November 2026
Watts Expires 18 May 2027 [Page]
Workgroup:
Remote ATtestation ProcedureS
Internet-Draft:
draft-watts-rats-attested-fence-receipt-00
Published:
Intended Status:
Experimental
Expires:
Author:
D. O. Watts
GoodShyt Group Inc.

Attested Fence Receipts: Hardware-Rooted Evidence of Authority-Epoch Enforcement at Consequential Sinks

Abstract

Revoking the authority of a delegated agent is not the same as proving that no consequential effect can still be committed under that authority. A revocation cut applied at one resource sink is not evidence of enforcement at another sink, and a software acknowledgement from a sink is only as trustworthy as the software that produced it. This document defines the Attested Fence Receipt (AFR), an Entity Attestation Token (EAT) profile emitted by the hardware-rooted Attesting Environment of a consequential sink after the sink has durably applied an authority-epoch fence. It further defines a verification procedure for individual receipts, a closure-evaluation procedure over a declared sink set that yields CLOSED, PARTIAL, FAILED, or UNKNOWN, and a hardware fence profile that binds the fence to measured state: an extend-only authority register, a monotonic counter, counter-gated derivation of per-epoch effect-attestation keys, and PCR-bound key release. The mechanism supplies the per-sink evidence that revocation-closure determinations require, and it is designed so that the absence of evidence can never be read as closure.

About This Document

This note is to be removed before publishing as an RFC.

This is a private research candidate. It has not been submitted to the IETF Datatracker, has not been reviewed by any working group, and does not carry IETF consensus. It is written in the form of an Internet-Draft so that it can be submitted without restructuring once the owner-controlled review gates recorded in the accompanying research note have been passed. The intended discussion venue, if submitted, is the Remote ATtestation ProcedureS (RATS) Working Group mailing list (rats@ietf.org), with notice to the Web Authorization Protocol (OAuth) and Workload Identity in Multi System Environments (WIMSE) Working Groups.

A reference implementation, 14 receipt test vectors, and 7 closure test vectors accompany this document (Section 12).

Status of This Memo

This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.

Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.

Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."

This Internet-Draft will expire on 18 May 2027.

▲

Table of Contents

1. Introduction

Agentic systems derive and distribute authority across delegated agents, workloads, queues, and long-running operations. [I-D.watts-oauth-agent-revocation-closure] establishes a protocol-neutral model for revocation closure in such systems: authority epochs, delegation lineage, admission fencing, a closure state machine (REQUESTED, PROPAGATING, CLOSED, PARTIAL, FAILED, UNKNOWN), and a Closure Receipt that records the scope, status, and evidence of a closure determination. That document deliberately leaves two things open: it defines no wire format for closure evidence, and it defines no mechanism by which an individual enforcement point proves that it has actually applied a fence. It names missing or delayed acknowledgements as both an evidence gap (Section 15 of [I-D.watts-oauth-agent-revocation-closure]) and a threat (Section 19 of that document).

This document fills that slot. Its starting point is an experimental observation. In a controlled two-sink experiment with separately implemented and separately persisted effect sinks, a revocation cut committed at sink A (advancing its authority epoch from 7 to 8) was followed by sink B, which had not yet received the cut, committing a valid queued request from a delegated descendant that A had never observed. After B received and durably applied its own signed cut, no further old-epoch effect appeared in B's journal. The two results are not in tension; they refer to two different predicates:

   CutCommitted(A, 8)  =/=>  Closed({A, B}, 7)

A cut at one sink is a local fact. Closure over a set of sinks is a claim about every sink in the set, and it needs per-sink evidence. The experiment also showed why a plain software acknowledgement is weak evidence: sink B's acknowledgement was a local observation produced by the same software whose correct behaviour was in question, and in a related single-sink experiment the sink's own persistent epoch could be silently rolled back by reopening its database with an older value.

The Attested Fence Receipt (AFR) addresses both weaknesses:

On top of the receipt, Section 8 specifies how a Closure Verifier evaluates a declared sink set and maps the result onto the closure states of [I-D.watts-oauth-agent-revocation-closure]. The evaluation is monotone and fails closed: an empty sink set, a missing receipt, a receipt that does not verify, or the absence of a normal-path witness yields UNKNOWN, never CLOSED.

1.1. Requirements Language

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

1.2. Non-Goals

This document does not define a revocation endpoint, a token format for authority, a delegation grammar, a queue protocol, a consensus protocol, or a transport. It does not replace the closure model of [I-D.watts-oauth-agent-revocation-closure]; it supplies evidence to it. It does not claim that a CLOSED determination over a declared sink set says anything about sinks outside that set. It does not define a new hardware root of trust; it profiles existing DICE and TPM primitives. Nothing in this document reverses effects that were committed before a fence.

2. Terminology

This document uses the terms Attester, Attesting Environment, Target Environment, Verifier, Relying Party, Evidence, Attestation Results, Reference Values, and Endorsements as defined in [RFC9334]; the terms Claim, Claims-Set, profile, and nonce as used in [RFC9711]; and the terms Authority Epoch, Authority Root, Consequential Sink, Pending Operation, Closure Barrier, Closure Receipt, Authority Graph, Declared Scope, and Normal-Path Witness as defined in Section 2 of [I-D.watts-oauth-agent-revocation-closure].

Cut:
An integrity-protected, issuer-authenticated message from an Authority Root instructing one consequential sink to advance from authority epoch E_prev to authority epoch E_new. A cut is addressed to exactly one sink (its audience) within one Declared Scope.
Cut Identifier:
The SHA-256 digest of the complete authenticated cut message as received by the sink. It is the handle by which a Closure Verifier correlates receipts with the cut it issued.
Fence:
The sink-local, durable, irreversible transition from E_prev to E_new, applied atomically with respect to effect commitment, after which no admission under E_prev can commit at that sink and every pending operation admitted under E_prev has been discharged (Section 5).
Fence Sequence:
The sink-local sequence number of the journal record that commits the fence. Sink-local sequence numbers are totally ordered within one sink and are not comparable across sinks.
Fence Mode:
One of the mechanisms by which a sink makes a fence irreversible: durable transaction, measured extend, key ratchet, or sealed release (Section 9). Modes compose.
Authority Register:
An extend-only measurement register (a PCR or equivalent) reserved for cut identifiers. Its value after a fence is a function of every cut applied at the sink since power-on.
Epoch Key:
The effect-attestation key of one authority epoch at one sink. Effects committed under an epoch are attested with that epoch's key. Under the key-ratchet fence mode, the epoch key of a superseded epoch cannot be derived or used after the fence.
Attested Fence Receipt (AFR):
An EAT, serialized as a CWT or JWT, produced by the Attesting Environment of a consequential sink, whose Claims-Set describes one fence at that sink (Section 6).
Declared Sink Set:
The enumerated identities of every consequential sink that a closure determination claims to cover. It is the sink-level projection of the Declared Scope.
Closure Verifier:
The entity that appraises Attested Fence Receipts (acting as a RATS Verifier) and evaluates closure over a Declared Sink Set (acting as the closure evaluator of [I-D.watts-oauth-agent-revocation-closure]). The two roles MAY be separated; Section 8 is written for the combined case.
Fence Witness:
A receipt that has been verified with result FENCED for a specific (scope, sink, E_prev, cut identifier) tuple.

3. Principles

The mechanism in this document follows from eight principles. They generalize the non-collapse rule of [I-D.watts-oauth-agent-revocation-closure] ("revocation request != authorization invalidation != revocation closure") to the evidence layer. They are stated here so that an implementation can be checked against the intent even where the normative text is silent.

P-1.

Locality of cuts. A cut committed at one sink is evidence about that sink only. It MUST NOT be used to infer enforcement at any other sink.

P-2.

Acknowledgement is not enforcement. A statement that a cut was received is not evidence that it was applied. Evidence of enforcement MUST be bound to the durable sink state that the fence changed and to the identity of the sink that changed it.

P-3.

Fence before acknowledge. A sink MUST durably apply a fence before it emits any receipt for that fence. A receipt for an unapplied fence is a forgery.

P-4.

Absence is UNKNOWN. Missing, unverifiable, stale, or mis-bound evidence yields UNKNOWN. An empty Declared Sink Set yields UNKNOWN. A closure determination MUST NOT be promoted by the absence of a counterexample.

P-5.

Evidence is content-bound. A receipt is bound to the epoch it fences, the cut that caused it, the sink that applied it, the challenge that requested it, and the measured configuration under which it was applied. Changing any of these invalidates the receipt for closure purposes. (This is an established mechanism, not a claim of novelty; see Appendix D.)

P-6.

Receipts are not credentials. A receipt carries no bearer authority. Possession of a receipt MUST NOT grant admission anywhere.

P-7.

Closure is scoped and monotone. A determination applies to its Declared Sink Set only. Adding evidence can move a determination toward CLOSED; losing evidence can never produce CLOSED. Evaluation MUST be idempotent.

P-8.

Hardware binding strengthens, never replaces, enforcement. Measured-state binding makes a receipt hard to forge from compromised sink software; it does not make the sink's admission logic correct. Sink-side admission fencing (Section 8 of [I-D.watts-oauth-agent-revocation-closure]) remains required.

4. Architecture

The roles map onto the RATS architecture as follows.

 .------------.   cut (signed, per sink)    .--------------------.
 | Authority  |---------------------------->| Consequential Sink |
 | Root       |                             |  Target Env: gate  |
 '------------'                             |   software, journal|
       | declares scope,                    |  Attesting Env:    |
       | sink set, epoch                    |   DICE/TPM/TEE     |
       v                                    '--------------------'
 .------------.   nonce                              |
 | Closure    |-------------------------------------->|
 | Verifier   |<--------------------------------------'
 | (RATS      |   Attested Fence Receipt (EAT)
 |  Verifier +|
 |  closure   |   Reference Values / Endorsements
 |  evaluator)|<---------------- (CoRIM etc.) ---- RVP / Endorser
 '------------'
       | closure state + evidence digest
       v
 .------------.
 | Relying    |   (e.g. the party that may rely on CLOSED,
 | Party      |    or the issuer of the Closure Receipt)
 '------------'
Figure 1: Roles and messages

The Authority Root issues one cut per sink in the Declared Sink Set. Each sink applies the fence (Section 5) and, on challenge, its Attesting Environment emits an Attested Fence Receipt (Section 6). The Closure Verifier appraises each receipt against Reference Values for that sink (Section 7) and evaluates the Declared Sink Set (Section 8). The result and the digest of the receipt set are what the Closure Receipt of Section 11 of [I-D.watts-oauth-agent-revocation-closure] carries in its status and evidence fields.

Receipts MAY be conveyed in any RATS topology. In the background-check topology the Relying Party forwards receipts to the Verifier; in the passport topology the sink obtains an Attestation Result (for example an EAR [I-D.ietf-rats-ear]) and presents that. Receipts and results MAY be wrapped in a Conceptual Message Wrapper [RFC9999] for transport, and MAY be registered as Signed Statements with a Transparency Service [RFC9943] when a durable public record of fence application is desired. None of these conveyances change the semantics defined here.

5. The Fence

A fence is the sink-local realization of the admission barrier and queue fencing required by Sections 8 and 9 of [I-D.watts-oauth-agent-revocation-closure]. This section states what a sink MUST have done before it may emit a receipt.

5.1. Cut Validation

A sink MUST validate a cut before applying it. The sink MUST verify the cut's signature under a trust anchor configured for the Authority Root; MUST verify that the cut's audience equals the sink's own configured identity (a request's or cut's self-declared audience is never authoritative on its own); MUST verify that the cut's scope identifier equals the sink's configured Declared Scope; MUST verify that E_prev equals the sink's current authority epoch; and MUST verify that E_new is strictly later than E_prev in the ordering defined for the scope. A cut that fails any check MUST be rejected without side effects and MUST NOT produce a receipt.

The Cut Identifier is SHA-256 over the complete authenticated cut message exactly as received. Where the cut is a COSE_Sign1 structure [RFC9052], the digest is over the tagged, deterministically encoded [RFC8949] COSE_Sign1 bytes.

5.2. Fence Application

Fence application MUST be atomic with respect to effect commitment at the sink: there is one linearization point (for example the commit of a single database transaction, or a single-threaded journal append) at which the sink's authority epoch changes, and no effect commits "concurrently with" that point. Within the fence transaction the sink:

  1. discharges every pending operation admitted under E_prev: each is either rejected, revalidated and re-admitted under E_new by an independent authorization, or recorded as completed before the fence. Pending operations whose state cannot be determined MUST be counted as unresolved;
  2. records the highest sink-local sequence number of any effect committed under E_prev (afr_last_prev_seq);
  3. appends a FENCE record to its durable journal and assigns it the next sequence number (afr_fence_seq);
  4. invokes the hardware fence primitive (Section 9): extends the Authority Register with the Cut Identifier, advances the monotonic counter, and makes the epoch key of E_prev underivable;
  5. durably sets its authority epoch to E_new.

After the fence, the sink MUST deny any admission that presents E_prev as its epoch, regardless of signature validity, grant validity, or witness status. A sink MUST NOT infer that another sink has fenced from its own fence (P-1).

5.3. Sequence Numbers

The sink's journal MUST assign strictly increasing sequence numbers to every committed effect, rejection, and fence record. These numbers are the only ordering a receipt reports. They are sink-local integers, not timestamps, and MUST NOT be compared across sinks. The invariant that a receipt attests is:

   for every effect e committed at this sink under E_prev:
        seq(e) < afr_fence_seq

A receipt whose afr_last_prev_seq is greater than or equal to its afr_fence_seq reports a violation of this invariant by the sink itself. Such a receipt is valid evidence of failure (Section 7).

5.4. Power Cycles and Restores

The fence MUST survive power cycles, crashes, and restoration of the sink's software state from a backup. The durable authority epoch, the journal, and the cut history are software state; the Authority Register is volatile and the monotonic counter is persistent hardware state. On power-on the sink MUST re-establish the Authority Register from its durable cut history before producing any receipt (Section 9.2). If, after a restore, the sink's software epoch disagrees with the hardware monotonic counter, the sink MUST NOT apply new cuts, MUST NOT issue receipts, and SHOULD raise an operational alarm. Effects committed by such a sink cannot be attested under the superseded epoch (Section 9.3), which is the property that makes the restore detectable by a verifier of effect attestations.

6. Attested Fence Receipt

6.1. Token Format

An Attested Fence Receipt is an EAT [RFC9711]. The CBOR serialization is a CWT [RFC8392] protected by COSE_Sign1 [RFC9052]; the JSON serialization is a JWT [RFC7519] protected by JWS. Implementations MUST support the CBOR serialization. The profile identifier is the tag URI tag:goodshyt.fun,2026:afr#00, carried in the eat_profile claim.

Signing algorithms: implementations MUST support EdDSA with Ed25519 [RFC8032] [RFC9053] (COSE alg -8) and SHOULD support ES256. The signing key MUST be an attestation key of the sink's Attesting Environment, for example a DICE alias key certified by the device's layered certificate chain [TCG-DICE-ATT] or a TPM 2.0 restricted signing key [TPM2]. The key identifier (kid) in the protected header MUST equal the sink's UEID. The unprotected header MUST be empty. Protected header and Claims-Set MUST be encoded deterministically (Section 4.2.1 of [RFC8949]) so that the Cut Identifier and receipt digests are reproducible across implementations.

A receipt describes exactly one fence. A sink that has applied several cuts emits one receipt per cut and MAY chain them with afr_prev_receipt.

6.2. Claims

Table 1 lists the Claims-Set. CWT keys in the private-use negative range are used pending registration (Section 15); JSON names are used in the JWT serialization, where all byte-string values are base64url-encoded without padding. In column P, M means the claim is REQUIRED, O means OPTIONAL, and C means conditionally REQUIRED as stated in the Meaning column.

Table 1: AFR Claims-Set
Claim Key Type P Meaning
eat_profile 265 tstr M MUST be tag:goodshyt.fun,2026:afr#00
eat_nonce 10 bstr (8..64) M Challenge supplied by the Closure Verifier (Section 6.5)
ueid 256 bstr M Device identity of the sink's Attesting Environment; MUST equal the COSE kid
iat 6 time M Time of receipt issuance (not of the fence)
exp 4 time O After this time the receipt MUST NOT be accepted as fresh
measurements 273 per RFC 9711 M Measured state of the gate software and the Authority Register (Section 6.4)
afr_sink_id -76000 tstr M The sink's configured identity (its audience name); MUST NOT be copied from the cut
afr_scope_id -76001 tstr M Declared Scope identifier
afr_epoch_prev -76002 tstr M Superseded authority epoch E_prev
afr_epoch_new -76003 tstr M Current authority epoch E_new after the fence
afr_cut_id -76004 bstr (32) M Cut Identifier of the applied cut
afr_fence_seq -76005 uint M Sink-local sequence number of the FENCE record
afr_last_prev_seq -76006 uint M Highest sequence number of any effect committed under E_prev; 0 if none
afr_pending -76007 map M Discharge accounting: rejected, revalidated, completed-pre-fence, unresolved
afr_fence_modes -76008 uint (bits) M Fence modes in effect (Section 9.1)
afr_auth_pcr -76009 map C Authority Register index and post-fence value; REQUIRED when the measured-extend mode is set
afr_epoch_key -76010 COSE_Key C Public effect-attestation key of E_new; REQUIRED when the key-ratchet mode is set
afr_monotonic -76011 uint M Hardware monotonic counter value after the fence
afr_cfg_digest -76012 bstr (32) M Digest of the sink's gate configuration (identity, scope, trust anchors, register assignment, modes)
afr_prev_receipt -76013 bstr (32) O Digest of the previous receipt emitted by this sink, forming a chain

Epoch values are opaque text in [I-D.watts-oauth-agent-revocation-closure]. This profile restricts them to the decimal representation of an unsigned 64-bit integer without leading zeros, so that "strictly later" is integer comparison and the value can be mirrored by a hardware counter. Deployments with a different epoch ordering MUST define a mapping to this form.

The afr_pending map has four unsigned-integer members keyed 0 (rejected), 1 (revalidated under E_new), 2 (completed before the fence), and 3 (unresolved). A sink that cannot account for a pending operation MUST count it as unresolved rather than omit it.

6.3. CDDL

afr-claims = {
  &(eat_profile: 265) => "tag:goodshyt.fun,2026:afr#00",
  &(eat_nonce: 10) => bstr .size (8..64),
  &(ueid: 256) => bstr .size (7..33),
  &(iat: 6) => ~time,
  ? &(exp: 4) => ~time,
  &(measurements: 273) => [ + measurements-format ],
  &(afr-sink-id: -76000) => tstr,
  &(afr-scope-id: -76001) => tstr,
  &(afr-epoch-prev: -76002) => epoch-text,
  &(afr-epoch-new: -76003) => epoch-text,
  &(afr-cut-id: -76004) => bstr .size 32,
  &(afr-fence-seq: -76005) => uint,
  &(afr-last-prev-seq: -76006) => uint,
  &(afr-pending: -76007) => afr-pending-map,
  &(afr-fence-modes: -76008) => uint .bits afr-fence-mode,
  ? &(afr-auth-pcr: -76009) => afr-auth-register,
  ? &(afr-epoch-key: -76010) => COSE_Key,
  &(afr-monotonic: -76011) => uint,
  &(afr-cfg-digest: -76012) => bstr .size 32,
  ? &(afr-prev-receipt: -76013) => bstr .size 32,
  * $$afr-claims-extension,
}

epoch-text = text .regexp "0|[1-9][0-9]*"

afr-pending-map = {
  &(rejected: 0) => uint,
  &(revalidated: 1) => uint,
  &(completed-pre-fence: 2) => uint,
  &(unresolved: 3) => uint,
}

afr-fence-mode = &(
  durable-transaction: 0,
  measured-extend: 1,
  key-ratchet: 2,
  sealed-release: 3,
)

afr-auth-register = {
  &(index: 0) => uint,
  &(value: 1) => bstr .size 32,
}

; payload of the "application/afr-pcrs+cbor" measurements-format
; entry: register index -> current value
afr-pcr-map = { * uint => bstr .size 32 }

; measurements-format and COSE_Key are imported from RFC 9711
; and RFC 9052 respectively.

6.4. Measurements

The measurements claim MUST contain the current values of the Authority Register and of every register that measures the gate software whose behaviour the fence depends on (boot chain, gate binary, policy, configuration). This profile defines one measurements-format content type, application/afr-pcrs+cbor, whose payload is the afr-pcr-map above. Implementations whose Attesting Environment produces DICE certificates with TcbInfo extensions [TCG-DICE-ATT] or TPM quotes MAY carry those instead, or in addition, using EAT submodules. A Closure Verifier MUST have Reference Values (for example CoRIM [I-D.ietf-rats-corim]) for the gate measurements of each sink in the Declared Sink Set.

6.5. Freshness

A receipt MUST carry a nonce chosen by the Closure Verifier for this challenge (eat_nonce). The fence itself is not fresh in the nonce sense; it is a durable past event, and the same fence MAY be attested again later under a new nonce. Freshness therefore applies to the receipt, not to the fence, and a Closure Verifier that holds a verified receipt for a fence does not need a fresh one to retain the FENCED determination (P-7). A Cut Identifier MAY additionally serve as a multi-nonce in the sense of [I-D.ietf-rats-epoch-markers] when the Authority Root distributes cuts as Epoch Markers; the eat_nonce claim MUST still be present and MUST equal the verifier's challenge.

6.6. JSON Serialization

In the JWT serialization the claim names are the names of Table 1, byte strings are base64url without padding, the afr_pending and afr_auth_pcr maps use the member names given in Section 6.3 as JSON object keys, and afr_epoch_key is a JWK. The JWS protected header MUST carry alg and kid only. Receipt digests in the JSON serialization are computed over the JWS Compact Serialization bytes.

7. Receipt Verification

A Closure Verifier evaluates one receipt against an expectation tuple (scope, sink, E_prev, Cut Identifier, nonce, current time), the sink's Reference Values (UEID, attestation public key or certificate chain, expected gate measurements, expected configuration digest), and the verifier's own monotone state for that sink (highest monotonic counter seen, cut history, last receipt digest). The result is one of:

INVALID:
the receipt is not evidence of anything;
FENCED:
the receipt is a Fence Witness for the expectation tuple;
PARTIAL:
the fence was applied but unresolved pending operations remain;
FAILED:
the receipt is evidence that the sink violated the fence invariant or that its state regressed.

The steps below MUST be performed in order, and the first failing step determines the result. Any step not listed as producing FAILED or PARTIAL produces INVALID.

  1. Structure and signature. Decode the CWT and COSE_Sign1 strictly. The kid MUST equal the sink's UEID from Reference Values. Verify the signature under the sink's attestation key. Verify that the Claims-Set contains every REQUIRED claim and no claim outside this profile other than registered EAT claims the verifier understands.
  2. Profile and types. eat_profile MUST equal the AFR profile identifier. Every claim MUST have the type and size of Section 6.3. afr_epoch_new MUST be strictly greater than afr_epoch_prev.
  3. Binding. ueid, afr_sink_id, afr_scope_id, afr_epoch_prev, afr_cut_id, eat_nonce, and afr_cfg_digest MUST each equal the corresponding value of the expectation tuple or Reference Values. A mismatch in any one of them means the receipt answers a different question; it MUST NOT be reused for this one.
  4. Freshness. iat MUST be within the verifier's acceptance window relative to the current time, and exp, if present, MUST not have passed.
  5. Measured TCB. Every expected gate measurement MUST match the corresponding entry in measurements. A receipt from unreferenced gate software is INVALID even if every other claim is consistent: the verifier has no basis to trust what that software says it did.
  6. Monotonicity. If afr_monotonic is lower than the highest value previously verified for this sink, the result is FAILED (MONOTONIC_REGRESSION). If the measured-extend mode is set, recompute the expected Authority Register value by extending from the all-zero value over the verifier's recorded cut history for this sink up to and including the expected Cut Identifier; if the receipt is for a cut already in the history, use the history prefix ending at that cut. The receipt's afr_auth_pcr value and the Authority Register entry in measurements MUST both equal the recomputed value; otherwise the result is FAILED (AUTH_REGISTER_MISMATCH). If the key-ratchet mode is set, afr_epoch_key MUST be a well-formed public key. The durable-transaction mode MUST be set.
  7. Chain. If afr_prev_receipt is present and the verifier holds a previous receipt digest for this sink, they MUST match; otherwise the result is FAILED (RECEIPT_CHAIN_BROKEN).
  8. Self-incrimination. If afr_last_prev_seq is greater than or equal to afr_fence_seq, the result is FAILED (POST_FENCE_PREV_EPOCH_EFFECT).
  9. Discharge. If the unresolved count in afr_pending is greater than zero, the result is PARTIAL. Otherwise the result is FENCED.

Only when the result is FENCED or PARTIAL does the verifier update its monotone state for the sink: the highest monotonic value, the cut history (appending the Cut Identifier if new), and the last receipt digest. Verification MUST be idempotent: verifying the same receipt twice, or a later re-issued receipt for the same fence, MUST yield the same result. The reference implementation realizes this by recomputing the Authority Register chain from the recorded cut history rather than from a single "current" expected value.

A FAILED result is actionable evidence and MUST be surfaced, not merely discarded. It indicates that the sink, its storage, or its hardware state is inconsistent with the claimed fence.

8. Closure Evaluation over a Declared Sink Set

Given a Declared Scope S, an authority epoch E_prev, the Declared Sink Set K = {k_1, ..., k_n}, the Cut Identifier c_i sent to each sink, the challenge nonce n_i issued to each sink, the set of receipts collected, Reference Values for every sink, a boolean Normal-Path Witness (Section 10 of [I-D.watts-oauth-agent-revocation-closure]), and the set U of sinks known to exist but not in K ("unindexed"), the Closure Verifier computes:

  if K is empty:                        return UNKNOWN (EMPTY_SCOPE)
  for each k_i in K:
      r_i := verify_receipt(receipt_i, (S, k_i, E_prev, c_i, n_i))
             or INVALID (NO_RECEIPT) if none was collected
  if any r_i == FAILED:                 return FAILED
  if any r_i == INVALID
     or not NormalPathWitness:          return UNKNOWN
  if any r_i == PARTIAL or U nonempty:  return PARTIAL
  return CLOSED

The determination applies to (S, E_prev, K) only. The Closure Verifier MUST record, alongside the status, the per-sink results and an evidence digest computed as SHA-256 over the deterministically encoded, sorted list of the digests of every receipt that contributed. That digest is the value for the evidence_digest field of the Closure Receipt of [I-D.watts-oauth-agent-revocation-closure], and the per-sink results populate its unresolved-paths field.

Requirements:

The decisive experimental scenario of Section 1 evaluates as follows under this procedure: with K = {A, B}, A's FENCED receipt and no receipt from B, the result is UNKNOWN; B's hidden-descendant effect under E_prev is admitted at B during that window, and nothing in the evidence claimed otherwise. Once B applies its cut and emits a receipt whose afr_last_prev_seq (the hidden effect's sequence number) is below its afr_fence_seq, the result is CLOSED for (S, E_prev, {A, B}). Had B's old-epoch effect been committed after its fence, B's own receipt would carry afr_last_prev_seq >= afr_fence_seq and the result would be FAILED.

9. Hardware Fence Profile

This section specifies how a fence is bound to hardware state so that a receipt cannot be forged by the sink's own software and so that the fence survives software rollback. It is written against the primitives of a DICE layering architecture [TCG-DICE-HW] [TCG-DICE-ATT] with a DICE Protection Environment [TCG-DPE], and against the equivalent TPM 2.0 primitives [TPM2]. An informative mapping to one concrete identity-engine design appears in Appendix B.

9.1. Fence Modes

The afr_fence_modes claim is a bit set. A receipt MUST set bit 0 (durable transaction): the fence is a durable, atomic sink transaction as required by Section 5.2. The remaining bits declare which hardware bindings were applied. A Closure Verifier's policy decides which modes it requires; this document RECOMMENDS that a CLOSED determination intended to survive compromise of sink software require at least measured-extend and key-ratchet.

9.2. Measured Extend (bit 1)

The sink reserves one extend-only register as the Authority Register. On every fence it extends that register with the Cut Identifier:

   AuthReg := SHA-256( AuthReg || CutIdentifier )

The extend MUST be the standard SHA-256 of the 64-byte concatenation, including the SHA-256 padding block (the "TPM-style" extend). A measurement core that applies a single unpadded compression-function invocation to the 64-byte block produces a different value that no standards-based verifier can reproduce; see Appendix B for an instance of this discrepancy found in a reference design.

Because the register can only be extended, the post-fence value cannot be reverted by software within a power cycle. At power-on the register is zero; the sink MUST re-extend it with every Cut Identifier in its durable cut history, in order, before issuing any receipt. The verifier recomputes the same chain from the cuts it issued. A sink whose durable cut history was truncated by a restore will therefore present a register value that the verifier does not expect, and the receipt fails (Section 7, step 6). The register value is reported both in afr_auth_pcr and in measurements, so that a quote-style attester that signs only the register bank still binds it.

The monotonic counter (afr_monotonic) MUST be a hardware counter that persists across power cycles and that no software can decrement: a TPM 2.0 NV counter index, a one-time-programmable fuse bank, or an equivalent. It MUST be advanced inside the fence. It is what makes a software restore detectable even if the attacker also replays an old cut history: the counter cannot be returned to its earlier value. Counter capacity bounds the number of fences a sink can apply over its life; deployments using fuse banks MUST size them accordingly.

9.3. Key Ratchet (bit 2)

Every effect committed at the sink is attested under the epoch key of the epoch in force at commit time. The epoch key of E_prev MUST be unobtainable after the fence. Two complementary realizations are specified; an implementation claiming this mode MUST provide the second and SHOULD provide the first:

  1. Forward-secret ladder (within a power cycle). K_{n+1} = HMAC-SHA-256(K_n, "RATC" || counter), with K_n zeroized on advance. After the ratchet the previous key no longer exists in any register.
  2. Counter-gated derivation (across power cycles). The Attesting Environment derives the epoch key for epoch E as KDF(CDI_sealing, "EPKY" || E) and MUST refuse the derivation unless E equals the current monotonic counter value. Because the CDI is re-derived deterministically at every boot, a ladder alone would allow software to re-derive superseded keys after a reboot; counter gating closes that path.

The receipt commits to the public key of E_new in afr_epoch_key. A verifier of effect attestations (for example an auditor of the sink's journal) accepts an effect attestation under E_prev only if its sequence number is below the fence sequence reported by a verified receipt. A sink whose software has been rolled back can still mutate its own storage, but it cannot produce an effect attestation under E_prev, and any such unattested effect is visible as a fault in its journal.

In a DICE Protection Environment the epoch key is a derived context whose derivation input includes the counter value; DestroyContext on the superseded context realizes the ladder step [TCG-DPE]. On a TPM 2.0, the equivalent is a key whose authorization policy requires TPM2_PolicyNV equality against the counter index.

9.4. Sealed Release (bit 3)

Where committing an effect requires a secret (a model decryption key, a signing key for an external API, a storage encryption key), the sink MAY seal that secret under a policy that includes the Authority Register. After a fence, material sealed under the pre-fence register value cannot be unsealed, so the effect path is fenced cryptographically rather than only by the gate's decision logic. Material that must survive fences (telemetry keys, the attestation key itself) MUST NOT be sealed to the Authority Register. This mode converts P-8 from a statement about software correctness into a statement about key availability, but it does not remove the need for admission fencing: an effect that needs no sealed material is fenced only by the gate.

9.5. Receipt Emission

The receipt MUST be produced by the Attesting Environment from the durable fence record, not assembled by the gate software from values the gate chooses. The attestation key MUST be bound to the measured boot state (for example an alias key derived from a CDI that includes the gate measurements), so that altered gate software cannot sign with the referenced key. The afr_cfg_digest claim MUST be computed by the Attesting Environment over the configuration actually in force.

11. Conformance and Falsification Cases

An implementation claiming conformance MUST reproduce the following outcomes. Each case corresponds to a test in the reference implementation and, where marked, to a published test vector (Section 12). An observer falsifies a CLOSED determination by exhibiting, for a sink in the Declared Sink Set, an effect attested under E_prev whose sequence number is at or above the fence sequence of a receipt that verified FENCED.

Table 2: Conformance cases
Case Construction Required outcome Vector
F-1 Two operations pending at the fence; a stale E_prev request after the fence Both pending operations rejected; stale request denied; no E_prev effect after the fence -
F-2 Derive the E_prev epoch key after the fence Derivation refused -
F-3 Verify a receipt for the applied fence FENCED; afr_auth_pcr equals the recomputed chain AFR-V01, AFR-V02
F-4 Same receipt against a different epoch, sink, cut, nonce, or configuration digest INVALID in every case AFR-V03..V07
F-5 Receipt from a sink running gate software not in Reference Values INVALID (untrusted TCB) AFR-V08
F-6 Receipt with a flipped signature bit, or re-signed by a non-attester key INVALID AFR-V09
F-7 Receipt reporting afr_last_prev_seq >= afr_fence_seq FAILED AFR-V10
F-8 Receipt reporting unresolved pending operations PARTIAL AFR-V11
F-9 Receipt whose monotonic counter is below the verifier's recorded value FAILED AFR-V12
F-10 Two sinks; A fenced; B holds an unobserved descendant's queued request and no cut UNKNOWN with A's receipt only; B commits the E_prev effect; CLOSED once B's receipt arrives with the effect below its fence AFR-C01, AFR-C02
F-11 Empty Declared Sink Set; full receipts without a Normal-Path Witness UNKNOWN in both cases AFR-C07, AFR-C03
F-12 Full receipts, one unindexed sink known PARTIAL AFR-C04
F-13 Evaluate every subset of the receipts No subset ranks above the full set -
F-14 Restore the sink's software state from a pre-fence backup No E_prev effect attestation possible; cut re-application refused; no receipt issuable -
F-15 Power-cycle the sink after a fence Authority Register re-established; E_prev key still underivable; re-issued receipt verifies and chains -
F-16 Secret sealed to the Authority Register before the fence Unseal fails after the fence; secret sealed without the register still unseals -
F-17 Zeroize after a fence No receipt issuable -

12. Implementation Status

This section records the status of known implementations as described in [RFC7942]. It is to be removed before publication as an RFC.

A reference implementation accompanies this draft (Python 3.13, dependencies: cbor2 and cryptography; MIT-licensed test code under a private research hold). It contains a behavioural model of a DICE-style identity engine (extend-only registers, HMAC key ladder, PCR-bound sealing, monotonic counter, zeroize, EAT quote signer), a consequential sink with a durable journal and the fence of Section 5, the receipt builder and verifier of Section 6 and Section 7, the closure evaluator of Section 8, and a deterministic vector generator. Its own minimal COSE_Sign1/CWT encoder was cross-checked for byte identity against the signing path of an independent COSE library. At the time of writing: 25 tests pass, covering every case in Table 2; 14 receipt vectors (2 FENCED, 9 INVALID, 2 FAILED, 1 PARTIAL) and 7 closure vectors (1 CLOSED, 3 UNKNOWN, 2 PARTIAL, 1 FAILED) are byte-reproducible from labelled seeds.

Limitations: single host, synthetic keys, single-threaded sink model (atomicity is by construction, not demonstrated under concurrency), no real DICE certificate chain or TPM, no network, no crash-fault injection, and no independent reproduction by a separate engineering team. The implementation was developed with AI assistance alongside this document and is therefore not an independent interpretation of it.

13. Security Considerations

The security considerations of [RFC9334], [RFC9711], [RFC9052], and Section 19 of [I-D.watts-oauth-agent-revocation-closure] apply.

Compromised gate software. The central threat is a sink whose application software is compromised after the fence, or that was compromised before the fence and reports a fence it did not apply. Measured-extend binds the receipt to register state that software cannot revert; measured-TCB verification rejects receipts from software not in Reference Values; the attestation key is bound to measured boot state so that altered software cannot sign with the referenced key. What hardware binding does not do is make a referenced-but-buggy gate admit correctly; P-8 applies.

Compromised Attesting Environment. If the Attesting Environment itself is compromised (key extraction, fault injection, a defective PUF or fuzzy extractor), every guarantee in this document fails for that sink. The reference identity-engine design behind Appendix B treats tamper detection, zeroization latency, and side-channel resistance of its ECDSA and error-correction logic as separate workstreams; a deployment MUST assess them. A Closure Verifier SHOULD treat a sink whose endorsements are withdrawn as INVALID for all future receipts and SHOULD re-evaluate determinations that relied on it.

Rollback. Restoring a sink's storage from a pre-fence backup is the attack that motivated the monotonic counter. With the counter, the restored sink cannot re-apply the cut, cannot attest E_prev effects, and cannot issue a receipt; a verifier that has already recorded the fence retains the FENCED result (P-7) and will see any later receipt from that sink fail. Without a persistent counter, measured-extend alone protects only within a power cycle.

Replay and substitution. Receipts are bound to nonce, epoch, cut, sink, scope, and configuration. A receipt replayed for a later epoch, presented for another sink, or presented after a configuration change is INVALID. A Cut Identifier used as a multi-nonce does not protect against replay of the receipt to a different verifier; the per-verifier nonce does.

Self-incrimination and omission. A sink can lie by omission (under-reporting afr_last_prev_seq). Omission is detectable by auditing effect attestations against the receipt: an effect attestation under E_prev with a sequence number at or above the fence sequence contradicts the receipt and is signed by a key the sink could only hold before the fence. Deployments SHOULD retain effect attestations for the lifetime of the determinations that depend on them.

Unindexed sinks and incomplete graphs. No receipt protocol can prove the absence of a sink the Authority Root does not know about. The Declared Sink Set is a claim by the root; discovering a sink outside it withdraws CLOSED. Graph completeness is a deployment property and an audit target, not something this document establishes.

Clock and sequence semantics. Sink sequence numbers are local; receipts assert nothing about wall-clock order across sinks. iat depends on the sink's clock and is used only for a freshness window; a sink without a trusted clock SHOULD set iat from a trusted time source at the Closure Verifier's challenge or omit freshness claims other than the nonce.

Counter exhaustion and denial of service. An attacker who can cause many cuts can exhaust a fuse-based counter or starve a sink with fence transactions. Cut issuance is an Authority Root operation and MUST be authenticated and rate-limited. Large Declared Sink Sets multiply receipt collection; a verifier MUST bound the resources it spends per determination.

Key material in receipts. Receipts carry public keys and digests only. They MUST NOT carry CDIs, epoch private keys, sealed material, or helper data.

Measurement core correctness. The extend-computation discrepancy described in Section 9.2 is not merely an interoperability issue: a verifier that silently accepted vendor-specific extend arithmetic would be unable to recompute the Authority Register chain and would have to trust the sink's reported value, defeating step 6 of Section 7. Verifiers MUST recompute; sinks MUST use the standard extend.

14. Privacy Considerations

A receipt reveals the sink's UEID, its scope identifier, its epoch numbers, the digest of its configuration, and its measured software state. Together these can identify a device and its deployment. Receipts SHOULD be conveyed only to the Closure Verifier and Relying Parties that need them, SHOULD NOT be published without the sink owner's consent, and when registered with a Transparency Service SHOULD be registered as digests or with scope identifiers that are not linkable across unrelated deployments. The privacy considerations of [RFC9711] regarding UEIDs apply; a sink MAY use a semi-permanent UEID per scope. Epoch identifiers SHOULD NOT be reused as durable correlation identifiers across unrelated contexts (Section 18 of [I-D.watts-oauth-agent-revocation-closure]).

15. IANA Considerations

If this document proceeds, the following registrations would be requested. Values shown are placeholders in the CWT private-use range and are to be replaced by assigned values.

15.1. CWT Claims

Registration in the "CBOR Web Token (CWT) Claims" registry of the claims afr_sink_id, afr_scope_id, afr_epoch_prev, afr_epoch_new, afr_cut_id, afr_fence_seq, afr_last_prev_seq, afr_pending, afr_fence_modes, afr_auth_pcr, afr_epoch_key, afr_monotonic, afr_cfg_digest, and afr_prev_receipt, with the descriptions of Table 1, Change Controller IETF, and this document as the specification. Requested keys: -76000 through -76013 are used in this draft as placeholders and are NOT the requested values.

15.2. JSON Web Token Claims

Registration of the same claim names in the "JSON Web Token Claims" registry.

15.3. Media Types

Registration of application/afr-pcrs+cbor as the content type of the register-map measurements-format entry defined in Section 6.4, and of application/afr+cwt for the receipt itself.

15.4. EAT Profile

EAT profiles are identified by URI and need no registry action. The profile URI is tag:goodshyt.fun,2026:afr#00; a future revision would use a tag URI under ietf.org.

16. References

16.1. Normative References

[I-D.watts-oauth-agent-revocation-closure]
Watts, D. O., "Revocation Closure and Authority Epochs for Agent Delegation", Work in Progress, Internet-Draft, draft-watts-oauth-agent-revocation-closure-02, , <https://datatracker.ietf.org/doc/draft-watts-oauth-agent-revocation-closure/>.
[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC7519]
Jones, M., Bradley, J., and N. Sakimura, "JSON Web Token (JWT)", RFC 7519, DOI 10.17487/RFC7519, , <https://www.rfc-editor.org/info/rfc7519>.
[RFC8032]
Josefsson, S. and I. Liusvaara, "Edwards-Curve Digital Signature Algorithm (EdDSA)", RFC 8032, DOI 10.17487/RFC8032, , <https://www.rfc-editor.org/info/rfc8032>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/info/rfc8174>.
[RFC8392]
Jones, M., Wahlstroem, E., Erdtman, S., and H. Tschofenig, "CBOR Web Token (CWT)", RFC 8392, DOI 10.17487/RFC8392, , <https://www.rfc-editor.org/info/rfc8392>.
[RFC8949]
Bormann, C. and P. Hoffman, "Concise Binary Object Representation (CBOR)", STD 94, RFC 8949, DOI 10.17487/RFC8949, , <https://www.rfc-editor.org/info/rfc8949>.
[RFC9052]
Schaad, J., "CBOR Object Signing and Encryption (COSE): Structures and Process", STD 96, RFC 9052, DOI 10.17487/RFC9052, , <https://www.rfc-editor.org/info/rfc9052>.
[RFC9053]
Schaad, J., "CBOR Object Signing and Encryption (COSE): Initial Algorithms", RFC 9053, DOI 10.17487/RFC9053, , <https://www.rfc-editor.org/info/rfc9053>.
[RFC9334]
Birkholz, H., Thaler, D., Richardson, M., Smith, N., and W. Pan, "Remote ATtestation procedureS (RATS) Architecture", RFC 9334, DOI 10.17487/RFC9334, , <https://www.rfc-editor.org/info/rfc9334>.
[RFC9711]
Lundblade, L., Mandyam, G., O'Donoghue, J., and C. Wallace, "The Entity Attestation Token (EAT)", RFC 9711, DOI 10.17487/RFC9711, , <https://www.rfc-editor.org/info/rfc9711>.

16.2. Informative References

[CAG1]
Watts, D. O., "Constitutional Action Gate Profile for Agent-Mediated Internet Operations (draft-watts-constitutional-action-gate-00)", Unsubmitted private research candidate, with a two-sink revocation experiment; available from the author, .
[FENCING]
Kleppmann, M., "How to do distributed locking", , <https://martin.kleppmann.com/2016/02/08/how-to-do-distributed-locking.html>.
[I-D.chen-oauth-agent-revocation]
Chen, M. and L. Su, "OAuth 2.0 Agent Authorization Explicit Revocation", Work in Progress, Internet-Draft, draft-chen-oauth-agent-revocation-00, , <https://datatracker.ietf.org/doc/draft-chen-oauth-agent-revocation/>.
[I-D.ietf-oauth-transaction-tokens]
Tulshibagwale, A., Fletcher, G., and P. Kasselman, "Transaction Tokens", Work in Progress, Internet-Draft, draft-ietf-oauth-transaction-tokens-11, , <https://datatracker.ietf.org/doc/draft-ietf-oauth-transaction-tokens/>.
[I-D.ietf-rats-ar4si]
Voit, E., Birkholz, H., Hardjono, T., Fossati, T., and V. Scarlata, "Attestation Results for Secure Interactions", Work in Progress, Internet-Draft, draft-ietf-rats-ar4si-10, , <https://datatracker.ietf.org/doc/draft-ietf-rats-ar4si/>.
[I-D.ietf-rats-corim]
Birkholz, H., Fossati, T., Deshpande, Y., Smith, N., and W. Pan, "Concise Reference Integrity Manifest", Work in Progress, Internet-Draft, draft-ietf-rats-corim-12, , <https://datatracker.ietf.org/doc/draft-ietf-rats-corim/>.
[I-D.ietf-rats-ear]
Fossati, T., Voit, E., Trofimov, S., and H. Birkholz, "EAT Attestation Results", Work in Progress, Internet-Draft, draft-ietf-rats-ear-04, , <https://datatracker.ietf.org/doc/draft-ietf-rats-ear/>.
[I-D.ietf-rats-epoch-markers]
Birkholz, H., Fossati, T., Pan, W., Mihalcea, I., and C. Bormann, "Epoch Markers", Work in Progress, Internet-Draft, draft-ietf-rats-epoch-markers-05, , <https://datatracker.ietf.org/doc/draft-ietf-rats-epoch-markers/>.
[I-D.ietf-wimse-aims]
Kasselman, P., Lombardo, J., Rosomakho, Y., Campbell, B., Steele, N., and A. Parecki, "AI Identity Management System", Work in Progress, Internet-Draft, draft-ietf-wimse-aims-00, , <https://datatracker.ietf.org/doc/draft-ietf-wimse-aims/>.
[I-D.ietf-wimse-arch]
IETF WIMSE Working Group, "Workload Identity in a Multi System Environment (WIMSE) Architecture", Work in Progress, Internet-Draft, draft-ietf-wimse-arch-08, , <https://datatracker.ietf.org/doc/draft-ietf-wimse-arch/>.
[I-D.messous-eat-ai]
Messous, A., Morand, L., and P. C. Liu, "Entity Attestation Token (EAT) Profile for Autonomous AI Agents", Work in Progress, Internet-Draft, draft-messous-eat-ai-01, , <https://datatracker.ietf.org/doc/draft-messous-eat-ai/>.
[I-D.sokolov-rats-aep-composition]
Sokolov, A., "Composing Application-Layer Action Evidence with Remote Attestation Procedures", Work in Progress, Internet-Draft, draft-sokolov-rats-aep-composition-03, , <https://datatracker.ietf.org/doc/draft-sokolov-rats-aep-composition/>.
[IDENGINE]
Watts, D. O., "DICE-Based AI Identity Engine: reference RTL, firmware, verifier, signoff constraints, formal properties, and fuzzy extractor", Unpublished reference design tree; available from the author, .
[MS-TBS]
Microsoft, "Tbsi_Revoke_Attestation function (tbs.h)", <https://learn.microsoft.com/windows/win32/api/tbs/nf-tbs-tbsi_revoke_attestation>.
[RFC7009]
Lodderstedt, T., Dronia, S., and M. Scurtescu, "OAuth 2.0 Token Revocation", RFC 7009, DOI 10.17487/RFC7009, , <https://www.rfc-editor.org/info/rfc7009>.
[RFC7942]
Sheffer, Y. and A. Farrel, "Improving Awareness of Running Code: The Implementation Status Section", BCP 205, RFC 7942, DOI 10.17487/RFC7942, , <https://www.rfc-editor.org/info/rfc7942>.
[RFC9943]
Birkholz, H., Delignat-Lavaud, A., Fournet, C., Deshpande, Y., and S. Lasker, "An Architecture for Trustworthy and Transparent Digital Supply Chains", RFC 9943, DOI 10.17487/RFC9943, , <https://www.rfc-editor.org/info/rfc9943>.
[RFC9999]
Birkholz, H., Smith, N., Fossati, T., Tschofenig, H., and D. Glaze, "Remote ATtestation procedureS (RATS) Conceptual Message Wrapper (CMW)", RFC 9999, DOI 10.17487/RFC9999, , <https://www.rfc-editor.org/info/rfc9999>.
[TCG-DICE-ATT]
Trusted Computing Group, "DICE Attestation Architecture, Version 1.3 RC1 (public review)", , <https://trustedcomputinggroup.org/resource/dice-attestation-architecture/>.
[TCG-DICE-HW]
Trusted Computing Group, "Hardware Requirements for a Device Identifier Composition Engine", , <https://trustedcomputinggroup.org/resource/hardware-requirements-for-a-device-identifier-composition-engine/>.
[TCG-DPE]
Trusted Computing Group, "DICE Protection Environment, Version 1.0", , <https://trustedcomputinggroup.org/wp-content/uploads/DICE-Protection-Environment-Version-1.0_pub.pdf>.
[TPM2]
Trusted Computing Group, "Trusted Platform Module Library Specification, Family 2.0", , <https://trustedcomputinggroup.org/resource/tpm-library-specification/>.

Appendix A. Example Receipt

The receipt below is test vector AFR-V02: sink-bravo committed one effect under epoch 7 at sequence 1, then applied its cut at sequence 2. It is shown in CBOR Extended Diagnostic Notation with claim names as comments; the measurements payload is the deterministically encoded register map. Keys are generated from labelled seeds given in the vector file, so the token is reproducible byte for byte.

61(18([
  / protected / {
    1: / alg / -8,
    4: / kid / h'0197cb8f01f5c4992e85628e53cbf107b9'
  },
  / unprotected / {},
  / payload / {
    6: / iat / 1794700005,
    10: / eat_nonce / h'a4a834fc73fc8b534598fe8b51dccf04',
    256: / ueid / h'0197cb8f01f5c4992e85628e53cbf107b9',
    265: / eat_profile / "tag:goodshyt.fun,2026:afr#00",
    273: / measurements / [
      [ "application/afr-pcrs+cbor",
        h'a6025820277b...0b52' / register map, 6 entries / ]
    ],
    -76000: / afr_sink_id / "sink-bravo",
    -76001: / afr_scope_id / "scope:example:order-fulfilment",
    -76002: / afr_epoch_prev / "7",
    -76003: / afr_epoch_new / "8",
    -76004: / afr_cut_id /
      h'e8ab83fc2792cd5ad5130e31cc00bbedc16544356f74bc88
        e3e76edfc66a8d1d',
    -76005: / afr_fence_seq / 2,
    -76006: / afr_last_prev_seq / 1,
    -76007: / afr_pending / { 0: 0, 1: 0, 2: 0, 3: 0 },
    -76008: / afr_fence_modes / 7,
    -76009: / afr_auth_pcr / {
      0: 12,
      1: h'0f5f0c8fb2ee772c73d150157dc46752bd69cbbbb3b62d06
          14b722a1fb3d0b52'
    },
    -76010: / afr_epoch_key / {
      1: 1, -1: 6,
      -2: h'7dacf1341b315436bf7ddd9ad6e4f4cb17d8d46e14061f71
           63b529425ed025ee'
    },
    -76011: / afr_monotonic / 8,
    -76012: / afr_cfg_digest /
      h'86df66f20c58a9177a1ac78ad2abe6a3fdb3dbe480b42501
        904987396629398c'
  },
  / signature / h'b3a4ee29...d54d1c04'
]))

The Authority Register value equals SHA-256(0x00{32} || afr_cut_id), the verifier's recomputation from an empty cut history. The complete 692-byte token appears in hexadecimal in the vector file.

Appendix B. Mapping to a Reference Identity Engine

This appendix is informative. It maps the hardware fence profile onto one concrete DICE-style identity-engine design [IDENGINE]: an APB-controlled block with an SRAM-PUF unique device secret recovered by a BCH(2047, 639, t=128) fuzzy extractor, HMAC-SHA-256 layered CDI derivation, a sixteen-register extend-only measurement bank, a forward-secret key ladder, a PCR-policy-bound seal unit, a tamper controller with zeroize, OTP fuses, and an EAT quote signer.

Table 3: Fence profile elements and engine resources
Profile element Engine resource Note
Authority Register PCR index 12 (unassigned in the reference firmware header; indices 0-4 and 8-11 are taken) Extended via PCR_SEL/PCR_DATA/PCR_EXTEND
Monotonic counter OTP fuse bank via OTP_WR, one bit per fence, or an NV counter in the secure element reached over SPI Fuse capacity bounds fence count
Epoch key (within power cycle) key_ladder: K_{n+1} = HMAC(K_n, "RATC" || counter32 || 0^28) Ladder seed is the CDI; ratchet on fence
Epoch key (across power cycles) Counter-gated derivation from the CDI; requires a register compare against the counter before KDF strobe (not in the reference RTL; proposed) Needed because the CDI is re-derived at every boot
Sealed release seal_unit with SEAL_POLICY bit 12 set Formal property P7 (unseal fails when a bound PCR moved)
Receipt signer quote_signer with the alias key; nonce from NONCE register; PCR bank flattened into the quote AFR claims appended to the EAT payload
Zeroize tamper_ctrl; formal property P4 (all key state clears within 3 cycles) Receipts impossible after zeroize
Irreversibility Formal properties P1 (register changes only on its extend strobe) and P2 (never returns to reset value) Grounds measured-extend

Two findings from preparing this mapping are recorded because they bear on interoperability:

Suggested additional formal properties for the engine's property file, in the style of its existing P1-P11:

// P12: epoch-key derivation strobes only for the live counter
ap_epoch_key_gated: assert property (
    epk_strobe |-> (epk_epoch == otp_counter));

// P13: the monotonic counter never decreases (sticky)
ap_counter_monotone: assert property (
    otp_counter >= $past(otp_counter));

// P14: a fence advances the authority register and the
//      counter in the same cycle window (atomic fence)
ap_fence_atomic: assert property (
    fence_strobe |-> ##[0:3] (pcr_extend && pcr_sel == 4'd12
        && otp_counter == $past(otp_counter) + 1));

Appendix C. Relationship to the Constitutional Action Gate

This appendix is informative. The experiments summarized in Section 1 were performed on CAG-1 [CAG1], an action-time admission profile whose decision is a conjunction of verified critical conditions with three terminal outcomes (ALLOW, DENY, INDETERMINATE) and a separate invalid outcome for malformed input, such that neither DENY nor INDETERMINATE can be promoted to ALLOW. Its sink implementation binds decision, effect, and nonce consumption in one database transaction and treats the authority epoch as a live runtime input.

The fence in this document is the epoch-advance transaction of such a gate, made attestable. The gate's tri-outcome discipline is mirrored in the receipt verifier (INVALID is not DENY) and in the closure evaluator (UNKNOWN is not CLOSED). The local defects found and repaired while building the CAG-1 sinks informed specific requirements here: epoch rewind on reopen (the monotonic counter and Section 5.4), self-issued root authority (cut validation under a configured trust anchor, Section 5.1), cross-audience admission (afr_sink_id from configuration, not from the message), post-validation mutation (receipts built by the Attesting Environment from the durable record, Section 9.5), and the serialization defect in which an empty reasons list was emitted as null (strict deterministic encoding, Section 6.1).

Appendix D. Research Provenance and Novelty Assessment

This appendix is informative and is to be removed before publication. It records what this document claims and does not claim, in the ledger form used by the author's research programme.

EM-AFR-001 [CONJECTURE, T3]:
Attested per-sink fence receipts, evaluated over a Declared Sink Set with a normal-path witness and an unindexed-sink veto, convert the untested conjecture EM-DIST-003 of the two-sink experiment ("authenticated acknowledgements plus complete sink-graph coverage could support scoped closure") into a checkable procedure. Falsifier: a CLOSED determination over a covered set while a covered sink later exhibits an effect attestation under E_prev at or above the fence sequence of its FENCED receipt. Status: local tests pass; not independently reproduced.
EM-AFR-002 [DERIVED, T1 local]:
Counter-gated epoch-key derivation makes old-epoch effect attestation impossible after the fence in the behavioural model, including after software rollback (case F-14) and power cycle (case F-15). Falsifier: produce such an attestation on a conforming implementation.
EM-AFR-003 [ANOMALY, T1 local]:
The reference measurement bank's unpadded single-block extend is not standard SHA-256 and cannot be reproduced by a standards-based verifier. Recorded with a test; repair proposed in Appendix B.
EM-AFR-004 [ESTABLISHED]:
Content-bound invalidation (binding evidence to a configuration digest so that edits invalidate approvals) is established prior art in contract-lifecycle and signature systems; it is applied here, not claimed.

Prior art that bounds any novelty claim: PCR extension and event-counter increment as attestation invalidation in deployed platform software [MS-TBS]; TPM monotonic counters and tick-based unidirectional attestation; fencing tokens [FENCING]; DICE layered identity and DPE context destruction [TCG-DPE]; epoch markers as freshness epochs [I-D.ietf-rats-epoch-markers]; composition of action evidence with platform evidence [I-D.sokolov-rats-aep-composition]; and the closure model this document serves [I-D.watts-oauth-agent-revocation-closure]. The candidate contribution is the specific combination: a revocation-side (rather than action-side) attested event, bound to an extend-only register and a counter-gated key, with a verification and closure procedure that fails closed. Whether that combination is novel has not been established by an independent prior-art search. Confirmed novel discoveries: zero.

Disposition at the date of this draft: reference tests 25/25 pass; vectors reproducible; xml2rfc rendering clean; idnits NOT RUN; independent engineering review NOT RUN; independent prior-art search NOT RUN; IETF submission NOT PERFORMED. The source material for this document was the author's identity-engine design tree, the signoff and fuzzy-extractor notes, and the CAG-1 and multilingual-agreement research threads of 14 November 2026.

Acknowledgements

The two-sink counterexample that motivates this document was produced in AI-assisted research sessions on 14 November 2026. The RATS, OAuth, and WIMSE working groups' published work provided every primitive this document composes.

Author's Address

Deonté O'dell Watts
GoodShyt Group Inc.
San Francisco, CA
United States of America