| Internet-Draft | Approval-Act Record | November 2026 |
| Ashcroft, et al. | Expires 20 May 2027 | [Page] |
A standing authorization grant is an artifact that outlives the event that produced it. Existing authentication-strength vocabulary (acr/amr) describes authentication events and travels on tokens. Nothing carries a record of how a standing grant's approval was performed to the party verifying the grant, possibly days later and with no human present. This document defines an approval-act record: evidence of the approval ceremony, bound to the exact grant issuance approved, and carried in-band with the grant it authorizes. It defines one initial evidence type (WebAuthn assertions over a hash of the canonical grant), states precisely which of the record's claims a verifier can recompute, which rest on vendor attestation, and which remain attested by the operator, and provides a worked example with a failure matrix.¶
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 20 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.¶
The Monday/Thursday problem, stated once. An operator approves a delegation on Monday behind a hardware authenticator. The agent acts on Thursday with no operator present. A token minted Thursday carries Thursday's acr: a service credential, or nothing. The approval act that actually stood behind the authority is invisible to every verifier that matters, and it cannot be reconstructed after the fact. If it is not captured when the grant is made, it is gone.¶
The unattended case is the reason standing grants exist, so this document treats it as the main case.¶
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.¶
C1. In-band. The record arrives inside, or inseparably with, the grant it describes, checkable at request time from retained material, with no token exchange the verifier cannot perform.¶
C2. Evidence relates to its issuer. The document states, per claim, who issues the evidence and what a verifier can recompute versus must take on attestation. It never implies the evidence outranks its issuer.¶
C3. Reuse existing vocabulary. acr/amr semantics (OIDC [OpenID.Core]), including the existing amr value "hwk" [RFC8176] and the EAP ACR values [OpenID.EAP] for phishing-resistant authentication, are reused, not reinvented.¶
C4. Verifier-required, not self-declared. Whether a record is demanded, and at what strength, is the relying party's policy. An asserted value a verifier cannot check is treated as absent.¶
C5. Parameters, not classes. Timing and artifact binding are parameters of the record rather than new assurance classes; see Section 5.¶
A grant carries at most one approval record. The grant itself MUST carry a unique issuance identifier (a serial, or issuance timestamp plus id) as a covered field. The REQUIRED form is deliberate. An optional identifier would create a third state, bound but content-only, that every verifier handles differently and no vocabulary names. A grant format that cannot carry an identifier is not excluded; it is priced, through captured binding, under Section 5.¶
Fields of the record:¶
The record, attestation included when present, MUST NOT exceed 8 KiB. A verifier that measures a record above the ceiling MUST conclude invalid: the check completed and the record failed it. Unverifiable is reserved for a check that could not be performed.¶
The record travels beside the grant. Its challenge is the hash of the grant bytes, and a grant already signed by its issuer cannot take a new member without changing the bytes its issuer signed. Keeping the record outside leaves the grant exactly as issued, so any grant format can carry a record, and no grant is re-issued to attach an approval.¶
In JSON, the grant and its record travel together in a wrapper object with two members, grant and approval_record.¶
Over HTTP, the record travels in its own header field, Approval-Record, alongside the grant. When the request is signed under the Web Bot Auth protocol (HTTP Message Signatures [RFC9421]), the signature MUST cover the Approval-Record field. A record stripped in transit then breaks the signature, where otherwise it would move the request silently from the record VALID column to record ABSENT (Section 8). The 8 KiB ceiling keeps the field inside common default per-header limits.¶
Three claims, three issuers.¶
Claim 1: This exact issuance was approved. The verifier recomputes the hash of the grant it holds, issuance identifier included, and checks it against the signed challenge. No issuer sits in that path; the claim is recomputable. The choice of semantics is deliberate and stated: the approval binds an issuance, not a content. Two re-issues of identical content are two approvals, and an approval of one is evidence for neither of the other. This is what makes an old record unreplayable onto a re-issued grant. A reader who wants content binding is asking for a different and weaker claim, and this document declines to blur them.¶
Claim 2: The approval was performed on a hardware authenticator with a user present and verified. The presence and verification flags ride inside the signed authenticator data, checkable against the credential public key. The hardware claim rests on enrollment-time attestation. Its issuer is the authenticator vendor: trust relocated to a party with no stake in any particular grant, not removed. Where the verifier holds no attestation for the credential, the hardware claim is reported as unattested while the presence and verification flags still verify. An authenticator identifier (AAGUID) carried without attestation is self-asserted and proves nothing about the hardware.¶
Claim 3: That credential belongs to that operator's approver. The residue. The party being graded states it, nothing recomputes it, and an operator could enroll its own credential and manufacture human-looking approvals. A verifier's confidence in claim 3 is exactly its confidence in the operator's enrollment practice, and this document says so plainly.¶
The honest composite: when all three claims verify, some human holding the enrolled credential approved this exact issuance.¶
Three partial states are named, so implementations have something to switch on other than a hard fail:¶
Two orthogonal parameters appear on every record.¶
artifact_binding = bound | captured¶
timing = fresh | standing¶
A single class value cannot express that bound plus standing is safe while captured plus standing is not. That asymmetry is the argument for parameters.¶
approved_at has an issuer, and it is the operator. Nothing the authenticator signs carries a clock. authenticatorData holds the RP ID hash, the flags, a signature counter (ordinal rather than temporal, and zero on a great many authenticators) and extension output. clientDataJSON holds the type, the challenge and the origin. So the record's one timestamp rides outside the signed material, and a verifier applying a freshness policy measured from approved_at is trusting the operator's clock while believing it is checking something.¶
The situation is better than pure trust by exactly one interval. The challenge covers the grant bytes, and the grant carries its issued-at inside those bytes. The assertion cannot exist before the grant it covers, so the covered issued-at is a lower bound on the approval act. The verifier's first sight of the record is an upper bound on its own clock. The approval provably lies inside that interval, and approved_at is an operator-asserted point within it.¶
Two freshness claims follow, named, so a verifier picks the one it can afford:¶
Three rules keep the checkable claim checkable:¶
When the approver credential is revoked, the revocation's effective time is compared with the interval above, not with approved_at:¶
Challenge construction. challenge = H(canonical grant bytes), where H is SHA-256 [RFC6234], fixed by this document. There is no per-record hash field, because a negotiable hash is a downgrade lever every verifier must defend forever. Agility lives in the registry: a future evidence_type, or a versioned entry, carries a different hash when one is needed.¶
Verifier procedure.¶
UV-required versus UP-sufficient maps to acr values per relying-party policy.¶
One agent. Operator anchor on one side (a JWK Set at a Signature-Agent URI the operator controls), approval-bound grant on the other. Materials are real WebAuthn assertions over real grant hashes, produced by a working prototype and labeled as such. The prototype mints a JCS grant, runs the passkey ceremony over its hash and verifies per Sections 4 to 6. The failure set is 13 vectors, one fault each, with each basis quoting the section it tests. The current fixture is a 1Password passkey with attestation "none", so the verifier reports claim 2's hardware claim as unattested.¶
Anchor outcomes are three: VALID; LAPSED, a conclusive outcome where the anchor expired and the verifier knows it; and UNREACHABLE, which is not an outcome because the check never completed. Anchor changed-hands is deliberately absent from the matrix. It is an ordering question between two events, which is record-layer territory, referenced rather than absorbed.¶
Cells report per-claim outcomes, not a single verdict.¶
| Record VALID | Record ABSENT | Record INVALID | |
|---|---|---|---|
| Anchor VALID | Claim 1 ok, Claim 2 ok, Claim 3 ok: accountable operator, human-approved this exact issuance | Accountable operator; approval strength unknown (status quo) | Invalid record. Forgery is one possible cause. The one cell treated worse than absent. |
| Anchor LAPSED (conclusive) | Claim 1 ok, Claim 2 ok, Claim 3 rests on an expired anchor: APPROVED BY AN ENROLLED CREDENTIAL, HOLDER ATTRIBUTION EXPIRED. A named partial state, not a hard fail. | Operator accountability expired; nothing else asserted | Invalid record, expired anchor: nothing, loudly |
| Anchor UNREACHABLE (no outcome) | Claim 1 ok, Claim 2 ok, Claim 3 unevaluated: APPROVED BY AN ENROLLED CREDENTIAL, HOLDER UNATTRIBUTED. A named partial state, not a hard fail. | NO VERDICT: the check never completed | Invalid is invalid regardless of anchor state |
Non-independence warning. The two axes share a trust root. Claim 3's issuer is the anchor party, so anchor-valid is a precondition of claim 3, not corroborating evidence for it. The anchor column and the claim 3 row are the same trust, spent twice; a reader must not sum them.¶
Per [RFC7942], to be removed before publication as an RFC. One prototype exists: a Cloudflare Worker that mints a JCS grant, performs the WebAuthn ceremony over its hash, verifies per Sections 4 to 6, and generates the 13-vector failure set from a real ceremony. Coverage: one 1Password passkey fixture, attestation "none". The vectors are available from the authors on request.¶
The record exposes an approval event and a credential identifier to every verifier of the grant. Three facts follow.¶
The credential public key is the sharpest exposure. A verifier needs it to check the assertion, so the record cannot withhold it. Where the approver is the person the agent acts for, every verifier receives the same key and can link all of that person's agents through it. The raw key is exactly the correlator the at-rest rule below exists for.¶
Pairwise credentials per relying party are INCOMPATIBLE with standing grants. They require enumerating the verifiers at approval time, and the reason standing grants exist is that you cannot.¶
The workable lever is at rest, not on the wire. A verifier SHOULD store H(credential_id, per-verifier salt) rather than the raw identifier. Per-verifier continuity survives, cross-verifier correlation ends, and C1 is untouched because nothing about the record changes. The protocol cannot enforce this, since it is storage policy, which is why it is a verifier SHOULD rather than a wire mechanism.¶
Drew, Alter Meridian Pty Ltd. Aurelien Brezun: parameters, not classes; the unique-human boundary.¶