| Internet-Draft | Sink-Attested Closure Evidence | November 2026 |
| Watts | Expires 19 May 2027 | [Page] |
Revoking delegated authority in an agentic system is complete only when every place that can still act on that authority has stopped. Existing work defines the states of that process but leaves its evidence format open. This document defines Sink-Attested Closure Evidence (SACE): a small set of COSE-signed objects and one deterministic algorithm. An authority root signs a Scope Manifest naming the sinks a closure claim covers, and a Cut Statement raising the minimum admissible authority epoch. Each sink signs an Epoch Acknowledgement with its own key, binding the cut to the sequence number of the last effect it committed before applying it. Each committed effect yields a signed Effect Receipt. From these objects any party can compute one of three verdicts: CLOSED, UNKNOWN, or VIOLATED. A VIOLATED verdict comes with a transferable proof consisting of two signatures by the same sink. A sink that never acknowledges blocks CLOSED until it is removed from scope. An optional binding ties the acknowledging key to remote attestation evidence. This document makes no claim that a sink which signs an acknowledgement actually enforces it; it makes a sink that does not enforce it provably accountable for every effect it receipts.¶
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 19 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
A revocation request, a token invalidation, and the end of delegated authority are three different events. [I-D.watts-oauth-agent-revocation-closure] names that distinction, defines authority epochs and closure states, and leaves the wire encoding of closure receipts to a future profile. It defines no acknowledgement signed by an enforcement point, no manifest format, no sequence mechanism, and no state for a detected breach. This document is such a profile.¶
A simple two-sink arrangement shows why the gap matters. Sink A commits a cut to epoch 8. Sink B, which has not received the cut, then accepts an epoch-7 request from a delegation descendant that A has never seen. The cut is committed at A, and closure does not hold over {A, B}. Four things are missing in that arrangement:¶
SACE answers each point with a concrete object.¶
SACE defines evidence objects and their evaluation. It does not define how cuts are transported, how grants are issued, or any new token format. It works with any authorization system that can attach an integer authority epoch to each admitted request.¶
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.¶
Seven principles constrain the mechanism. Each is enforced by a specific rule later in this document.¶
All SACE objects are COSE_Sign1 structures [RFC9052] whose payload is a CBOR map with integer keys, encoded using the deterministic encoding requirements of Section 4.2 of [RFC8949]. The protected header MUST carry "alg", "kid", and "typ" [RFC9596]. A receiver MUST reject an object whose payload is not deterministically encoded, has duplicate keys, or has keys that this document does not define.¶
One closure round has six steps. Transport between parties is out of scope; any channel works because every object is self-authenticating.¶
The admission rule at a sink is one comparison: admit a request only if its authority epoch is greater than or equal to the floor. This is the admission fencing of [I-D.watts-oauth-agent-revocation-closure]; SACE adds the evidence that it happened.¶
A sink is in exactly one of four states for each scope. The state, the floor, the sequence counter, and the chain head are a single durable record and change only inside the transaction described for each event.¶
| State | Meaning | Requests in the scope |
|---|---|---|
| UNENROLLED | The sink holds no manifest that lists it. | Refused. |
| ACTIVE(f) | The sink is listed and its floor is f. | Admitted if the authority epoch is at least f. |
| HALTED | The sink cannot show that its durable record is current. | Refused until the sink re-acknowledges the latest cut. |
| RETIRED | A later manifest no longer lists the sink. | Refused. |
| Event | From | To | Action in one transaction |
|---|---|---|---|
| Manifest lists the sink | UNENROLLED | HALTED | Store the manifest digest; seq = 0; chain head = zero. |
| Cut with epoch e > f | ACTIVE(f) or HALTED | ACTIVE(e) | Set floor to e; record w = seq; sign and store the SEA. |
| Cut with epoch e <= f | ACTIVE(f) | ACTIVE(f) | None; return the stored SEA for f. |
| Request with epoch >= f | ACTIVE(f) | ACTIVE(f) | seq = seq + 1; write the effect; sign and store the ER; advance the chain head. |
| Request with epoch < f | ACTIVE(f) | ACTIVE(f) | None; refuse with reason "floor". |
| Restore, or rollback-resistant counter disagrees with the record | ACTIVE(f) | HALTED | None; refuse all requests. |
| New manifest omits the sink | any | RETIRED | Store the manifest digest. |
A newly listed sink starts in HALTED, not ACTIVE, so that it cannot admit a request before it has acknowledged the latest cut. Its first SEA has watermark 0.¶
Three invariants follow from the table and are what an implementation needs to preserve:¶
A Scope Manifest is the signed, complete list of sinks that one closure claim covers. Its "typ" is "application/sace-manifest+cose". It is signed by the AR.¶
| Key | Name | Type | Rule |
|---|---|---|---|
| 1 | scope_id | bstr, 16 bytes | Random; fixed for the life of the scope. |
| 2 | manifest_seq | uint | Starts at 1. Each new manifest increments it by one. |
| 3 | prev_manifest | bstr / null | Digest of the preceding manifest; null when manifest_seq is 1. |
| 4 | members | array of member | Sorted by sink_id in bytewise order. No duplicates. |
| 5 | att_profile | tstr | OPTIONAL. If present, every acknowledgement carries attestation under this profile (Section 15). |
Each member is an array [sink_id, key_thumbprint, class]: a text identifier, the COSE Key Thumbprint [RFC9679] (SHA-256) of the sink's acknowledgement key, and a text label for the sink class.¶
The following rules apply:¶
A Cut Statement raises the floor for one scope. Its "typ" is "application/sace-cut+cose". It is signed by the AR.¶
| Key | Name | Type | Rule |
|---|---|---|---|
| 1 | scope_id | bstr | As in the manifest. |
| 2 | manifest | bstr | Digest of the Scope Manifest this cut applies to. |
| 3 | epoch | uint | The new floor e. Authority epochs below e are revoked. |
| 4 | prev_epoch | uint | The floor this cut supersedes. Less than epoch. |
| 5 | cut_nonce | bstr, 16 bytes | Random. Makes two cuts to the same epoch distinguishable. |
| 6 | issued_at | uint | Seconds since the Unix epoch. Informational only. |
A sink processes a Cut Statement as follows, entirely inside the same serializable transaction that guards effect commits:¶
Step 2 makes reordered and replayed cuts harmless: a cut to 9 arriving before a cut to 8 leaves the floor at 9, and a replayed cut to 7 cannot lower it. A sink MUST store the exact bytes of each acknowledgement it signs and return those bytes on any repeat, so that an honest sink never produces two different acknowledgements for one cut.¶
A Sink Epoch Acknowledgement (SEA) is a sink's own signed statement that it raised its floor, and where its effect counter stood when it did. Its "typ" is "application/sace-ack+cose". It MUST be signed by the key whose thumbprint the manifest lists for that sink. An acknowledgement signed by the AR, a proxy, or a coordinator on the sink's behalf is not an SEA.¶
| Key | Name | Type | Rule |
|---|---|---|---|
| 1 | scope_id | bstr | As in the manifest. |
| 2 | manifest | bstr | Digest of the manifest the sink is listed in. |
| 3 | sink_id | tstr | The sink's identifier in that manifest. |
| 4 | cut | bstr | Digest of the Cut Statement that caused this floor. |
| 5 | applied_epoch | uint | The floor now in force at this sink. |
| 6 | prev_epoch | uint | The floor it replaced at this sink. |
| 7 | watermark | uint | w: the sink's seq at the instant the floor was raised. |
| 8 | chain_head | bstr | Digest of the Effect Receipt with seq = w; 32 zero bytes if w is 0. |
| 9 | applied_at | uint | Sink-local time. Informational only. |
| 10 | attestation | bstr | OPTIONAL. An EAT, per Section 15. |
By signing an SEA, a sink asserts two things and nothing else:¶
The watermark is what makes the second assertion checkable. Without it, an old-epoch receipt could always be explained as having been committed just before the cut. With it, the sink has fixed in advance which side of the line every sequence number falls on.¶
An SEA satisfies a cut with epoch e if it is validly signed, names the same scope and manifest, and has applied_epoch greater than or equal to e. A sink that moved directly to a later epoch therefore also acknowledges every earlier cut.¶
An Effect Receipt (ER) is a sink's signed record of one committed effect. Its "typ" is "application/sace-effect+cose". It is signed by the same key as the sink's SEAs.¶
| Key | Name | Type | Rule |
|---|---|---|---|
| 1 | scope_id | bstr | As in the manifest. |
| 2 | sink_id | tstr | As in the manifest. |
| 3 | seq | uint | Previous seq plus one. No gaps, no reuse. |
| 4 | authority_epoch | uint | The epoch of the grant under which the effect was admitted. |
| 5 | effect | bstr | SHA-256 of the canonical effect description. Never the effect itself. |
| 6 | prev | bstr | Digest of the ER with seq minus one; 32 zero bytes when seq is 1. |
The sink MUST assign seq, write the effect, and persist the ER in one atomic transaction. An effect without a receipt, or a receipt without an effect, is a sink fault.¶
A deployment that already emits per-action receipts in another format, for example a signed statement as in [I-D.noa-scitt-ai-agent-receipt], MAY use that format instead, provided that each receipt is signed by the manifest-listed key and carries sink_id, seq, authority_epoch, and prev under the sink's signature. Registering receipts in a Transparency Service [RFC9943] is RECOMMENDED where a sink might withhold them (Section 23).¶
The verdict is a pure function of its inputs: one Scope Manifest M, one Cut Statement C with epoch e, a set of SEAs, a set of ERs, an optional set of Checkpoints (Section 14), and, when M sets att_profile, the Evaluator's appraisal policy for that profile (Section 15). It uses no clock and no network.¶
A sink makes a sequence commitment whenever it signs a statement that binds a sequence number n to a receipt digest d. Four statements do so:¶
For each member s of M, an Evaluator computes a member status:¶
Steps 2 to 4 apply to every SEA from s, not only to those that satisfy C. The reported watermark of s is that of the satisfying SEA with the lowest applied_epoch, or null if there is none. It is reported for UNACKED and VIOLATED members too, when a satisfying SEA exists.¶
The verdict over M and C is then:¶
| Verdict | Condition | State in the base model |
|---|---|---|
| VIOLATED | At least one member is VIOLATED. | FAILED, with proof attached |
| CLOSED | Every member is ACKED, and the non-vacuity check passes. | CLOSED |
| UNKNOWN | Anything else. | PROPAGATING, PARTIAL, or UNKNOWN |
A member that has not signed a satisfying SEA is UNACKED, and a verdict with an UNACKED member is not CLOSED. No other evidence changes this. In particular, an Evaluator MUST NOT report CLOSED on the basis of:¶
The only way to reach CLOSED without a member's acknowledgement is to remove the member from scope: the AR issues a new manifest that omits it and a new cut over that manifest. The verdict over the old manifest stays UNKNOWN and is retained (Section 20). Removal is therefore always visible as a change of scope and never as a closure.¶
This rule chooses safety over liveness. A deployment that cannot tolerate one unresponsive sink blocking closure needs smaller scopes, not a weaker rule.¶
Every VIOLATED status is backed by exactly two objects signed by the same sink key. Anyone holding the manifest can check the proof offline, and the sink cannot attribute it to the network, the AR, or another sink.¶
| Type | The two objects | What they show |
|---|---|---|
| 1: Stale commit | An SEA with applied_epoch = a and watermark = w; an ER with authority_epoch < a and seq > w | The sink committed revoked authority after stating that it had stopped. |
| 2: Equivocation | Two SEAs with the same cut and any differing field | The sink told two parties different things about one cut. |
| 3: Forked chain | Two objects, each an ER, an SEA, or a Checkpoint, that make conflicting sequence commitments (Section 10) | The sink keeps two histories, or acknowledged a chain head it did not have. |
A violation proof is a CBOR array [proof_type, object_1, object_2]. It needs no signature of its own, because its force comes from the two signatures it contains. Type 3 covers four concrete forms, all detected by one rule: two ERs with the same seq; an ER whose "prev" disagrees with the receipt it names; an SEA whose chain_head disagrees with the receipt at its watermark; and a Checkpoint whose chain_head disagrees with a receipt, an SEA, or another Checkpoint.¶
To verify a proof, a party holding the manifest checks that both objects are validly signed by the same manifest-listed key, that they are different objects, and that running steps 2 to 4 of Section 10 over those two objects alone yields the stated type. A pair that does not convict on its own is not a proof, even if the member is VIOLATED on other evidence.¶
The distinction from simpler tests is deliberate. "An old-epoch effect after A's cut" proves nothing about B. "An old-epoch effect at B beyond B's own signed watermark" proves that B broke its word.¶
A sink restored from a backup taken before a cut will have a lower floor and will produce a stale-commit proof against itself once it commits. Sinks therefore MUST persist the floor in storage that a restore cannot roll back, or refuse all requests in the scope after a restore until they have re-acknowledged the latest cut.¶
An Evaluator MAY publish its result as a Verdict Record. Its "typ" is "application/sace-verdict+cose". It is signed by the Evaluator's key and is a wire encoding for the closure receipt of [I-D.watts-oauth-agent-revocation-closure].¶
| Key | Name | Type | Rule |
|---|---|---|---|
| 1 | manifest | bstr | Digest of the manifest evaluated. |
| 2 | cut | bstr | Digest of the cut evaluated. |
| 3 | verdict | uint | 0 UNKNOWN, 1 CLOSED, 2 VIOLATED. |
| 4 | members | array | [sink_id, status, watermark / null] per member, sorted by sink_id. |
| 5 | verdict_digest | bstr | As defined in Section 17, over keys 1 to 4. |
| 6 | proofs | array | Present if and only if the verdict is VIOLATED. One violation proof per VIOLATED member. |
A relying party that receives a Verdict Record MUST check, in order:¶
These checks establish less than re-evaluation does, and the difference matters:¶
This section states what the mechanism guarantees, under which assumptions, and what it does not guarantee. The arguments are informal sketches, not machine-checked proofs.¶
A sink is called honest if it follows Sections 5 to 9, its signing key is not known to any other party, and its durable record is not rolled back.¶
Claim: no set of objects signed by an honest sink contains a violation proof.¶
Sketch. Stale commit: let the sink sign an SEA with applied_epoch a and watermark w. By I3, every effect committed after the fence has seq above w and was admitted against a floor of at least a (by I1), so its authority_epoch is at least a. Every effect with authority_epoch below a was therefore committed before the fence and has seq at most w. Equivocation: the sink stores the bytes of each SEA and returns them on repeat, so it signs one SEA per floor value. Forked chain: by I2 each seq value is assigned once, so one ER exists per seq.¶
This property holds under any message ordering, partition, or clock offset, because none of them is an input to the sink's transaction or to the evaluation.¶
Claim: if a sink signs an SEA with applied_epoch a and watermark w, and also signs an ER with authority_epoch below a and seq above w, then every Evaluator that holds both objects and the manifest reports the member, and the verdict, as VIOLATED.¶
Sketch. Both objects pass step 1 of Section 10 because they are validly signed by the listed key. Step 4 compares every SEA with every ER from the same member, so the pair is found regardless of which cut is being evaluated.¶
The claim is conditional on the Evaluator holding both objects. A sink that never emits the ER is outside it; see Section 23.¶
Claim: for evidence sets X and Y with X a subset of Y, if the verdict over X is VIOLATED then the verdict over Y is VIOLATED, and if the verdict over Y is UNKNOWN then the verdict over X is not CLOSED.¶
Sketch. A violation proof contained in X is contained in Y. A member that is ACKED over X has a satisfying SEA in X, which is also in Y, so it is ACKED or VIOLATED over Y; the non-vacuity witness in X is also in Y. Hence CLOSED over X implies CLOSED or VIOLATED over Y.¶
Claim: the verdict, the member statuses, and the verdict digest depend only on the set of valid objects supplied, not on their order, their arrival time, or the Evaluator's clock.¶
Sketch. Every step of Section 10 quantifies over sets. The member list is sorted before the digest is taken. Where more than one SEA satisfies the cut, the reported watermark is taken from the one with the lowest applied_epoch, which is unique for an unconvicted member.¶
Claim: if the verdict over manifest M and a cut to epoch e is CLOSED, and (A1) every member of M is honest, and (A2) every system able to commit an effect under a grant in the scope is a member of M, then no effect under an authority epoch below e is committed anywhere after the last member's acknowledgement.¶
Sketch. By A1 and P1's argument, each member commits no such effect after its own fence. By A2 there is no other place where one could be committed.¶
Neither assumption is established by SACE. A1 is supported, not proven, by attestation (Section 15) and by the accountability of P2. A2 is a statement about the deployment: the manifest is the authority root's signed assertion of it, and the rules of Section 6 make a compliant unlisted sink refuse, but a non-compliant unlisted system is invisible to every object defined here.¶
Effect Receipts accumulate without bound. A Checkpoint lets a sink commit to its history up to a sequence number so that evidence stores can discard older receipts without losing the ability to detect a fork. Checkpoints are OPTIONAL. Its "typ" is "application/sace-checkpoint+cose". It is signed by the sink key.¶
| Key | Name | Type | Rule |
|---|---|---|---|
| 1 | scope_id | bstr | As in the manifest. |
| 2 | sink_id | tstr | As in the manifest. |
| 3 | seq | uint | The sequence number the checkpoint covers up to and including. |
| 4 | chain_head | bstr | Digest of the ER with that seq. |
| 5 | floor | uint | The sink's floor when the checkpoint was signed. |
| 6 | counts | map | For each authority epoch that appears in receipts 1..seq, the number of such receipts. |
An evidence store MAY discard the bytes of an ER from a sink once all of the following hold:¶
Condition 2 preserves stale-commit detection: an ER can convict a sink only against an SEA whose watermark is below its seq, and those comparisons have been made. Condition 3 preserves fork detection: a conflicting ER presented later for the same seq has a different digest. The "counts" map preserves the non-vacuity witness after the receipts that supplied it are gone: a non-zero count for an epoch below e in a Checkpoint with seq at or below the member's watermark is an acceptable witness.¶
A Checkpoint makes a sequence commitment, so a Checkpoint that disagrees with a receipt, an SEA, or another Checkpoint about the digest at some seq is a forked-chain proof (type 3). After discarding, the retained (seq, digest) pairs keep this detectable: a conflicting ER presented later is checked against them.¶
A Checkpoint is not an acknowledgement. It never makes a member ACKED, whatever floor it reports (Section 10.1).¶
A sink MUST NOT discard its own receipts or acknowledgements on the strength of a Checkpoint. Checkpoints permit pruning by evidence stores, not by the party the evidence is about.¶
An SEA says that a key signed a promise. Attestation says what software held that key. This section is OPTIONAL unless the manifest sets att_profile.¶
When present, the "attestation" field of an SEA is an Entity Attestation Token [RFC9711] in CWT form, used as Evidence or as an Attestation Result in the sense of [RFC9334]. The following rules bind it to the acknowledgement:¶
An Evaluator appraises the token under a policy for the profile that names the attester keys it accepts and the reference values for the measurement claims. The token passes only if it is signed by an accepted attester key, its "eat_nonce" and "cnf" claims match as above, and every measurement claim the profile defines equals a reference value. Any other outcome, including a missing token, an unknown profile, or a policy the Evaluator does not hold, leaves the member UNACKED. It never makes the member VIOLATED: a failed appraisal shows that the evidence is insufficient, not that the sink broke a promise.¶
This document does not define a concrete profile. A profile document specifies the measurement claims, their encoding, and how attester keys are endorsed. The test vectors in Appendix C use a test-only profile, "urn:example:sace-sim-attester:1", with a software attester key and a single 32-byte measurement claim under the private-use claim key -75000. It demonstrates the binding rules above and has no security value.¶
Where a sink is an agent runtime built on a layered device identity, in which a device secret is extended through each boot stage and the model weights and runtime configuration are measured before any key is released, a profile SHOULD require the model digest and the configuration digest among the measured components. An acknowledgement is then tied to one exact model and configuration, and stops verifying when either changes.¶
The limit of this section is as follows. Attestation appraises the signer's software state at signing time. It does not show that the software is correct, that it enforces the floor, or that it stays in that state afterwards. A member with valid attestation that later produces a stale-commit proof is VIOLATED like any other.¶
[I-D.watts-rats-attested-fence-receipt] defines an EAT profile in which a sink's Attesting Environment reports, among other claims, the sink-local sequence number at which the fence took effect and the highest sequence number of any effect committed under the previous epoch. Those two claims carry the same information as the SACE watermark.¶
A deployment can combine the documents in either of two ways:¶
The division of labour is as follows. The fence receipt carries hardware-rooted evidence of the sink's enforcement state at one moment. SACE carries the signed membership list, the per-effect record after that moment, and the two-signature proof when the record contradicts the acknowledgement. The exact claim-by-claim mapping, including whether the fence sequence number equals the watermark or the watermark plus one, is left to a profile document, because it depends on the numbering convention of the fence-receipt profile.¶
A verdict that depends on which library computed it is not evidence. Two Evaluators written independently, in different programming languages, given the same input objects, MUST produce the same verdict digest.¶
The verdict digest is SHA-256 over the deterministic CBOR encoding of:¶
verdict-input = [
manifest_digest : bstr,
cut_digest : bstr,
verdict : 0 / 1 / 2, ; UNKNOWN / CLOSED / VIOLATED
members : [ + [ sink_id : tstr,
status : 0 / 1 / 2,
; UNACKED / ACKED / VIOLATED
watermark : uint / null ] ]
; sorted by sink_id
]
¶
Conformance requirements:¶
The verdict digest identifies the outcome: who is convicted, who is acknowledged, at which watermark. It does not identify the evidence. Two evaluations that convict the same member on different proofs, or over different but equivalent sets of objects, produce the same digest. This is intended, because Evaluators holding different copies of the same evidence should agree. Proofs are compared separately, by verifying them.¶
Matching digests show that two Evaluators compute the same function. They show nothing about whether the sinks told the truth. Agreement is a precondition for trusting a verdict, not a reason to trust it.¶
Most sinks are, or sit in front of, a transactional database. This section shows how the three invariants of Section 5 map onto ordinary database features. It is guidance; the normative requirements are in Sections 5 to 9.¶
Three tables hold the SACE state. They live in the same database as the application data they protect, so that one transaction can cover both.¶
CREATE TABLE sace_state ( scope_id BLOB PRIMARY KEY, sink_id TEXT NOT NULL, manifest BLOB NOT NULL, -- digest of the current manifest floor INTEGER NOT NULL, -- lowest admissible authority epoch seq INTEGER NOT NULL, -- last assigned sequence number head BLOB NOT NULL -- digest of the receipt with that seq ); CREATE TABLE sace_ack ( scope_id BLOB NOT NULL, applied_epoch INTEGER NOT NULL, cut BLOB NOT NULL, watermark INTEGER NOT NULL, raw BLOB NOT NULL, -- exact signed bytes PRIMARY KEY (scope_id, applied_epoch) ); CREATE TABLE sace_effect ( scope_id BLOB NOT NULL, seq INTEGER NOT NULL, authority_epoch INTEGER NOT NULL, effect BLOB NOT NULL, raw BLOB NOT NULL, PRIMARY KEY (scope_id, seq) );¶
The primary key on sace_effect enforces I2: a second receipt with the same seq cannot be stored. The primary key on sace_ack enforces one acknowledgement per floor value.¶
Admission, the application write, the receipt, and the counter update are one transaction. The state row is read with a write lock so that no cut can be applied between the admission check and the commit.¶
BEGIN; -- with a write lock on sace_state; see below SELECT floor, seq, head FROM sace_state WHERE scope_id = :scope FOR UPDATE; -- refuse here if :authority_epoch < floor (reason: floor) -- refuse here if :audience <> this sink (reason: audience) -- application write(s) for the effect INSERT INTO sace_effect (scope_id, seq, authority_epoch, effect, raw) VALUES (:scope, :seq_plus_1, :authority_epoch, :effect_digest, :er); UPDATE sace_state SET seq = :seq_plus_1, head = :er_digest WHERE scope_id = :scope; COMMIT;¶
The receipt is signed inside the transaction, after seq and head are known and before COMMIT. If signing fails, the transaction is rolled back and no effect is committed.¶
BEGIN; SELECT manifest, floor, seq, head FROM sace_state WHERE scope_id = :scope FOR UPDATE; -- if :epoch <= floor: -- read sace_ack for floor, COMMIT, return its raw UPDATE sace_state SET floor = :epoch WHERE scope_id = :scope; INSERT INTO sace_ack (scope_id, applied_epoch, cut, watermark, raw) VALUES (:scope, :epoch, :cut_digest, :seq, :sea); COMMIT;¶
The watermark written into the SEA is the seq value read under the same lock. This is I3.¶
A restore from backup returns the floor to an earlier value. Three techniques, in increasing strength, keep a restored sink from admitting revoked authority:¶
An Evaluator that follows many scopes and sinks needs to keep the objects it receives and to ask questions of them. This section describes an evidence store and the analysis queries that correspond to the rules of Section 10. A query result is a lead, not a verdict: every finding is confirmed by running the evaluation algorithm over the signed objects the query points to.¶
CREATE TABLE ev_object ( digest BLOB PRIMARY KEY, typ TEXT NOT NULL, scope_id BLOB NOT NULL, sink_id TEXT, raw BLOB NOT NULL, received_at INTEGER NOT NULL ); CREATE TABLE ev_ack ( digest BLOB PRIMARY KEY REFERENCES ev_object(digest), scope_id BLOB, manifest BLOB, sink_id TEXT, cut BLOB, applied_epoch INTEGER, prev_epoch INTEGER, watermark INTEGER, chain_head BLOB ); CREATE TABLE ev_effect ( digest BLOB PRIMARY KEY REFERENCES ev_object(digest), scope_id BLOB, sink_id TEXT, seq INTEGER, authority_epoch INTEGER, effect BLOB, prev BLOB ); CREATE TABLE manifest_member ( manifest BLOB, sink_id TEXT, thumbprint BLOB, class TEXT, PRIMARY KEY (manifest, sink_id) ); CREATE INDEX ev_effect_ix ON ev_effect (scope_id, sink_id, seq); CREATE INDEX ev_ack_ix ON ev_ack (scope_id, sink_id, applied_epoch);¶
Stale commits: every pair of an acknowledgement and a later receipt under a revoked epoch.¶
SELECT a.sink_id, a.digest AS sea, e.digest AS er
FROM ev_ack a JOIN ev_effect e
ON e.scope_id = a.scope_id AND e.sink_id = a.sink_id
WHERE e.authority_epoch < a.applied_epoch
AND e.seq > a.watermark;
¶
Equivocation and forked chains: two different objects where one is allowed.¶
SELECT a.sink_id, a.digest, b.digest
FROM ev_ack a JOIN ev_ack b
ON a.scope_id = b.scope_id AND a.sink_id = b.sink_id
AND a.cut = b.cut
WHERE a.digest < b.digest;
SELECT a.sink_id, a.digest, b.digest
FROM ev_effect a JOIN ev_effect b
ON a.scope_id = b.scope_id AND a.sink_id = b.sink_id
AND a.seq = b.seq
WHERE a.digest < b.digest;
¶
Members that have not acknowledged a cut to epoch e. The member list comes from the manifest.¶
SELECT m.sink_id FROM manifest_member m
WHERE m.manifest = :manifest
AND NOT EXISTS (SELECT 1 FROM ev_ack a
WHERE a.scope_id = :scope AND a.manifest = :manifest
AND a.sink_id = m.sink_id AND a.applied_epoch >= :e);
¶
Withheld receipts: gaps in a sink's sequence, and receipts whose "prev" does not match the stored predecessor.¶
SELECT sink_id, seq + 1 AS missing_from FROM ev_effect e
WHERE scope_id = :scope
AND seq < (SELECT MAX(seq) FROM ev_effect
WHERE scope_id = e.scope_id AND sink_id = e.sink_id)
AND NOT EXISTS (SELECT 1 FROM ev_effect n
WHERE n.scope_id = e.scope_id AND n.sink_id = e.sink_id
AND n.seq = e.seq + 1);
SELECT e.sink_id, e.seq FROM ev_effect e JOIN ev_effect p
ON p.scope_id = e.scope_id AND p.sink_id = e.sink_id
AND p.seq = e.seq - 1
WHERE e.prev <> p.digest;
¶
A gap is not a violation proof. It shows that the store is missing a receipt, which may be the sink's doing or the transport's. A gap that persists after the sink has been asked for the missing sequence numbers is a reason to treat the sink's receipts as incomplete.¶
The following measures are derived from the store. They describe a deployment; none of them is an input to a verdict.¶
| Measure | Definition | Use |
|---|---|---|
| Acknowledgement coverage | Members with a satisfying SEA, divided by members in the manifest. | Progress of a closure round. Below 1 the verdict cannot be CLOSED. |
| Acknowledgement latency | For each member, received_at of its SEA minus received_at of the cut. | Sizing a closure budget. Uses store clocks only. |
| Exposure window count | For each member, the number of receipts under an epoch below e with seq at or below its watermark and received after the cut. | How much revoked authority was exercised between the AR's cut and the sink's fence. These effects are permitted and stand. |
| Receipt completeness | Receipts held for a sink divided by its highest seen seq. | Detecting withheld receipts. |
| Refusal breakdown | Counts of refusals at each sink by reason: floor, audience, expired, not enrolled. | Separating revocation effects from clock and configuration effects. Reported by sinks; not signed evidence. |
The exposure window count is the quantity that revocation latency actually costs. It can be read directly from signed objects, which is not true of a timeout-based estimate.¶
This section records the status of known implementations at the time of posting, per [RFC7942]. It is to be removed before publication as an RFC.¶
Two implementations exist, both written by the author of this document.¶
Both implementations have the same author and were written against the same text, so they share any misreading of it. Their agreement is evidence that the text is precise enough to implement twice, not the independent agreement that Section 17 asks for. All tests ran on one host. The partition is simulated by not delivering a cut, and the dishonest sink is the honest code with its admission check disabled. The conditions for an independent run in Appendix B are not yet met.¶
Each object supports a narrow statement. Reading more into an object than the table below allows is the most likely way to misuse this document.¶
| Object | Signed by | Shows | Does not show |
|---|---|---|---|
| Scope Manifest | AR | Which sinks and keys the AR asserts are the complete set for the scope. | That the set is in fact complete. |
| Cut Statement | AR | That the AR ordered the floor raised to e. | That any sink received or applied it. |
| SEA | Sink | That the holder of the sink key states its floor is a and its counter stood at w. | That the sink enforces the floor. |
| SEA with attestation | Sink and its attester | Additionally, the measured software that held the key at signing. | That the software is correct or unchanged since. |
| Effect Receipt | Sink | That the sink states it committed effect number seq under a given epoch. | That no other effect was committed. |
| Violation proof | Sink, twice | That the key holder made two statements that cannot both be true of an honest sink. | Whether the cause was malice, a bug, a rollback, or key theft. |
| Verdict record | Evaluator | The result of the algorithm over a stated set of objects. | Anything about objects the Evaluator did not hold. |
The following table places the acknowledgement defined here beside the nearest existing mechanisms, as this document reads them. It compares only the property at issue: evidence that a specific enforcement point stopped. The rows refer, in order, to [RFC7009], [CAEP], [I-D.noa-scitt-ai-agent-receipt], [I-D.watts-rats-attested-fence-receipt], and this document.¶
| Mechanism | Statement signed or returned by | Says the enforcement point applied the revocation | Later breach provable from signatures |
|---|---|---|---|
| Revocation endpoint response | Authorization server | No; the request was processed by the server. | No |
| Session-revoked event with delivery acknowledgement | Transmitter; receiver acknowledges delivery | No; delivery only. | No |
| Per-action receipt | The recording boundary | Not its purpose; it records individual actions. | Not by itself; it has no acknowledgement to contradict. |
| Attested fence receipt | Sink's Attesting Environment | Yes, with hardware-rooted state. | Within the receipt itself, when its own sequence claims conflict. |
| SEA (this document) | Sink key | Yes, as a signed claim with a watermark. | Yes; an SEA and a later ER form the proof. |
SACE gives accountability for what sinks sign. It does not give prevention, and it does not see what sinks decline to sign.¶
Closure is prospective. Effects with seq at or below w were committed under authority that was valid at the time. SACE identifies them; it does not reverse them.¶
A CLOSED verdict means that every listed sink has signed that it stopped, and that no signed evidence contradicts any of them. It does not mean that the sinks stopped.¶
Effect Receipts carry digests, not effect contents. Sequence numbers and sink identifiers still reveal activity volume per sink. Deployments that publish receipts need to consider whether that volume is sensitive.¶
IANA is requested to register six media types in the "Media Types" registry. The template below is for the first; the other five are identical except for the subtype name and the object named under "Applications that use this media type".¶
| Media type | Object |
|---|---|
| application/sace-manifest+cose | Scope Manifest |
| application/sace-cut+cose | Cut Statement |
| application/sace-ack+cose | Sink Epoch Acknowledgement |
| application/sace-effect+cose | Effect Receipt |
| application/sace-verdict+cose | Verdict record |
| application/sace-checkpoint+cose | Checkpoint |
Payload map keys are scoped to each object type and need no registry. An EAT profile identifier for Section 15 would be registered by a document defining a concrete profile, not by this one.¶
This appendix gives payload definitions for the five objects in the notation of [RFC8610]. Each payload is carried in a COSE_Sign1.¶
digest = bstr .size 32
scope-id = bstr .size 16
epoch = uint
sink-id = tstr
manifest = {
1 => scope-id,
2 => uint, ; manifest_seq
3 => digest / null, ; prev_manifest
4 => [ + member ], ; sorted by sink-id
? 5 => tstr ; att_profile
}
member = [ sink-id, digest, tstr ]
; id, key thumbprint, class
cut = {
1 => scope-id,
2 => digest, ; manifest
3 => epoch, ; new floor
4 => epoch, ; prev_epoch
5 => bstr .size 16, ; cut_nonce
6 => uint ; issued_at (informational)
}
ack = {
1 => scope-id,
2 => digest, ; manifest
3 => sink-id,
4 => digest, ; cut
5 => epoch, ; applied_epoch
6 => epoch, ; prev_epoch
7 => uint, ; watermark
8 => digest, ; chain_head
9 => uint, ; applied_at (informational)
? 10 => bstr ; attestation (EAT, CWT)
}
effect = {
1 => scope-id,
2 => sink-id,
3 => uint, ; seq
4 => epoch, ; authority_epoch
5 => digest, ; effect
6 => digest ; prev
}
verdict-record = {
1 => digest, ; manifest
2 => digest, ; cut
3 => 0 / 1 / 2, ; UNKNOWN / CLOSED / VIOLATED
4 => [ + [ sink-id, 0 / 1 / 2, uint / null ] ],
5 => digest, ; verdict digest
? 6 => [ + violation-proof ]
}
violation-proof = [ 1 / 2 / 3, bstr, bstr ]
; 1 stale commit: ack, effect
; 2 equivocation: ack, ack
; 3 forked chain: any two of ack, effect, checkpoint
checkpoint = {
1 => scope-id,
2 => sink-id,
3 => uint, ; seq covered
4 => digest, ; chain_head at seq
5 => epoch, ; floor
6 => { * epoch => uint } ; receipt counts by authority epoch
}
¶
This appendix describes the experiment that would test this specification, stating first the outcomes that would count against it. The two single-author implementations described in Section 21 exercise these arms in simulation; they do not meet the conditions for an independent run listed at the end of this appendix.¶
| Arm | Link AR to sink B | Cut ordering | Clock at B | Expected verdict |
|---|---|---|---|---|
| Baseline | up | in order | true | CLOSED, no stale commits |
| Partition | down | none delivered | true | UNKNOWN |
| Repair with reorder | up | 9 before 8 | true | CLOSED at 9 and at 8 |
| Replayed old cut | up | 7 after 8 | true | CLOSED, floor unchanged |
| Skew only | up | in order | +5 min | CLOSED; expiry rejections counted separately |
| Unlisted descendant | up | in order | true | Refused by audience rule; verdict unaffected |
| Listed descendant, unseen by A | late | in order | true | UNKNOWN until B acknowledges; then CLOSED |
| Dishonest sink | up | in order | true | VIOLATED with stale-commit proof |
| Rolled-back sink | up | in order | true | VIOLATED, or refusal if rollback-resistant |
| Vacuous scope | up | in order | true | UNKNOWN (non-vacuity fails) |
The following conditions apply to any run reported as a test of this document:¶
13 vectors accompany this document as a JSON file. Each gives the AR public key, the sink public keys, the full bytes of the manifest, cut, acknowledgements, effect receipts, and Checkpoints in hexadecimal, the attester policy where one applies, and the expected result. Signing keys are derived from fixed test labels and are for testing only. Two sinks, sink-a and sink-b, are listed; each commits one epoch-7 effect before a cut to epoch 8, except where noted.¶
manifest digest, no att_profile (all but two vectors) 6e57db47d44c041d513e6473e4328588dc92d04c2270de558f9be16538ae8497 cut digest over that manifest (epoch 8, prev_epoch 7) 40c8147351189afe761875dd5c8adca31e0a8d0c05eab7e20135a47085847c68 manifest digest with att_profile (attested-*, attestation-*) 3a04fd4cc0477f1508cf88d57daf5f253945c00251d0c16edefa72ad28dbde4f cut digest over that manifest ea22aeca5b7e133c6f66d865ccb591bfb39c1853494b1d64746da2e2380a32bf¶
| Vector | Members (sink:status/watermark) | Verdict | Proof types |
|---|---|---|---|
| baseline-closed | sink-a:1/1 sink-b:1/1 | CLOSED | - |
| partition-unknown | sink-a:1/1 sink-b:0/- | UNKNOWN | - |
| stale-commit-violated | sink-a:1/1 sink-b:2/1 | VIOLATED | 1 |
| vacuous-unknown | sink-a:1/0 sink-b:1/0 | UNKNOWN | - |
| attested-closed | sink-a:1/1 sink-b:1/1 | CLOSED | - |
| attestation-mismatch-unknown | sink-a:1/1 sink-b:0/1 | UNKNOWN | - |
| checkpoint-witness-closed | sink-a:1/1 sink-b:1/1 | CLOSED | - |
| equivocation-violated | sink-a:1/1 sink-b:2/1 | VIOLATED | 2 |
| forked-chain-violated | sink-a:1/1 sink-b:2/1 | VIOLATED | 3 |
| ack-head-fork-violated | sink-a:1/1 sink-b:2/1 | VIOLATED | 3 |
| checkpoint-fork-violated | sink-a:1/1 sink-b:2/1 | VIOLATED | 3 |
| broken-prev-link-violated | sink-a:1/1 sink-b:2/1 | VIOLATED | 3 |
| silent-sink-unknown | sink-a:1/1 sink-b:0/- | UNKNOWN | - |
Expected verdict digests:¶
baseline-closed ae4bb0ce0590efcb55fcf0effed92139f9b610bf0c99243e0cd35fbfa5b56199 partition-unknown f647d8963f1d868b7bdc037fea06a1cf7530b4f75487a2f04897f2d7a474f100 stale-commit-violated 09f64b653e191e8d6cff34f11ac5f022b64d1b366e033a97e19915db290cecf2 vacuous-unknown baee56483dc6332bb653481c90c0ffa1d2cfe005c3d75873621d5b2c2b72c723 attested-closed b3b28e877b38da9ec86a629ef1db9a90a6bbd3d532b9a43010a0b7e8408eb3ac attestation-mismatch-unknown 8fc77f708789b841d6923df3098b29d3adf6a538485a44aa40ce31c996dd7e07 checkpoint-witness-closed ae4bb0ce0590efcb55fcf0effed92139f9b610bf0c99243e0cd35fbfa5b56199 equivocation-violated 09f64b653e191e8d6cff34f11ac5f022b64d1b366e033a97e19915db290cecf2 forked-chain-violated 09f64b653e191e8d6cff34f11ac5f022b64d1b366e033a97e19915db290cecf2 ack-head-fork-violated 09f64b653e191e8d6cff34f11ac5f022b64d1b366e033a97e19915db290cecf2 checkpoint-fork-violated 09f64b653e191e8d6cff34f11ac5f022b64d1b366e033a97e19915db290cecf2 broken-prev-link-violated 09f64b653e191e8d6cff34f11ac5f022b64d1b366e033a97e19915db290cecf2 silent-sink-unknown f647d8963f1d868b7bdc037fea06a1cf7530b4f75487a2f04897f2d7a474f100¶
Several vectors are worth reading closely. In vacuous-unknown both members are ACKED and the verdict is UNKNOWN, because no epoch-7 effect exists. In attestation-mismatch-unknown, sink-b's acknowledgement carries a token with the wrong measurement: sink-b is UNACKED, not VIOLATED, and its watermark is still reported. In checkpoint-witness-closed no receipts are supplied and the Checkpoints alone provide the witness. In silent-sink-unknown, sink-a has acknowledged and committed five further effects and signed a Checkpoint, and sink-b has signed nothing; the verdict and its digest are identical to partition-unknown. All five VIOLATED vectors share one verdict digest because they convict the same member (Section 17).¶
These results were produced by the Python implementation and reproduced by the Go implementation described in Section 21.¶
Two sinks, sink-a and sink-b, are listed in manifest 1 of a scope. Both have floor 7. Each has committed one effect under epoch 7, so each has seq = 1.¶
Case 1, both acknowledge. The AR signs a cut to epoch 8. Each sink raises its floor to 8 and signs an SEA with applied_epoch = 8, prev_epoch = 7, watermark = 1. An Evaluator holding the manifest, the cut, both SEAs, and the two ERs finds both members ACKED and the non-vacuity witness present (an epoch-7 ER with seq 1 at or below watermark 1). The verdict is CLOSED.¶
Case 2, partition. Only sink-a receives the cut. sink-b, still at floor 7, admits a further epoch-7 request and receipts it with seq = 2. The Evaluator finds sink-a ACKED and sink-b UNACKED. The verdict is UNKNOWN. The epoch-7 effect at sink-b is not a violation: sink-b has signed nothing that it contradicts. When the cut reaches sink-b, its SEA carries watermark = 2, and the verdict becomes CLOSED. The watermark records that the second effect fell on the permitted side of sink-b's own line.¶
Case 3, breach. Both sinks acknowledge as in case 1, with watermark = 1. sink-b then commits an epoch-7 request and receipts it with seq = 2. The Evaluator finds an SEA from sink-b with applied_epoch 8 and watermark 1, and an ER from sink-b with authority_epoch 7 and seq 2. Since 7 is below 8 and 2 is above 1, sink-b is VIOLATED, and the verdict is VIOLATED. The proof is the array [1, SEA, ER].¶
The only difference between the permitted effect in case 2 and the breach in case 3 is the position of seq 2 relative to the watermark that sink-b itself signed.¶
This section is to be removed before publication as an RFC.¶