Review · November 20, 2026
Exact-Action Identifiers Adds an Action Hash Member to RAR and a Registry of Hashing Schemes
The problem it's solving
A user approves a €250 payment to one account. The request that reaches the payment API later might say €2,500, or name a different account. The resource server needs a way to check that the operation in front of it is the one that was approved.
RAR already lets a token carry the approved amount and payee as structured fields. This draft adds a digest of those fields next to them. The resource server hashes the operation it is about to perform and compares the result to the digest in the token.
Several drafts already define ways to hash an action, and their outputs aren't comparable. So the draft's actual contribution is a shared member name and a registry that says which hashing scheme a given value uses.
What the mechanism actually does
It defines two members for RAR authorization details objects.
action_id is a string made of a registered scheme prefix and a scheme-specific value, such as canactid:1:payment.release.1:jcs-sha256:<digest>. action is the optional JSON object the digest was computed from.
Neither member applies to any existing RAR type. A type has to opt in by writing a "type profile" that names the accepted schemes, pins their versions, and defines how the API's operations map to the scheme's input.
The AS validates the identifier, recomputes it from action when that is present, and keeps action_id in the granted details. It must carry the constraint through refresh and token exchange.
The resource server builds the scheme input from the real request, derives the identifier, and compares strings. It is not allowed to use the token's action object as the input. A mismatch is a 403 with insufficient_scope.
The draft also adds an exact_action_schemes_supported metadata parameter for both the AS and the resource server, a new IANA registry of scheme prefixes, and one initial entry for the author's own Canonical Action Identifier.
How it fits in the working group
It's in charter in the narrow sense. It extends RFC 9396, adds one parameter to AS Metadata and Protected Resource Metadata, and reuses the RFC 6750 error. It defines no new endpoints, grant types, roles, or error codes.
The normative dependency list is short: RFC 6749, 6750, 8414, 9396, 9728, and one individual draft. That one draft is the problem. The only registered scheme is CAID, an individual submission by the same author, cited at a pinned revision. CAID's own action-type and suite registries are still proposals.
RAR deliberately has no registry of object members, and the draft acknowledges this. It can't register action_id anywhere, so the member exists only when a type definition says it does.
So what does the hash add over plain RAR fields?
This is the first question the working group will ask.
A resource server that receives amount, currency, and beneficiary_account in the granted authorization details can compare those fields to the request directly. That is how RAR payment types work today.
The draft's own rules make the hash harder to justify. The resource server must independently construct the input from the actual operation, using a mapping the type profile defines. Any resource server that can do that already knows every field that matters and could compare them one by one.
A digest earns its place when the approved details can't travel with the token, for size or confidentiality reasons. The draft doesn't make that argument. Its Privacy Considerations point the other way, noting that unsalted digests over predictable fields can be guessed.
A digest is also useful as a compact value to pass down a call chain. The draft explicitly declines to define that for Transaction Tokens.
Significant interoperability concerns
Nothing interoperates on this draft alone. Every decision that affects the wire is pushed to the type profile: which schemes, which versions, the operation mapping, consistency rules between action and other fields, replay handling, and what happens when several objects match. The draft defines no type. Its example uses an "illustrative, unregistered type."
The scheme prefix doesn't identify the derivation. For CAID, the profile must also pin the spec revision, the action-type definition digest, the suites, and "required external value-set snapshots." Two deployments can agree on canactid:1: and still compute different identifiers for the same payment. That undercuts the reason for having a registry.
The discovery metadata tells a client almost nothing. The draft says the values are "capability hints" that don't indicate which types or action definitions are supported. Its own open issues list says per-type discovery is left to profiles. RAR Metadata is the adopted work for describing what a type requires, and the draft doesn't mention it.
insufficient_scope gives the client nothing to act on. A client can't tell an action mismatch from a missing scope. The draft cites the Transaction Authorization Challenge as related work, which is the natural way to tell the client what to get approved, but defines no connection to it.
The registry would launch with one entry that can't be finalized. The draft says the CAID reference "must be reconciled with that specification's status" before publication. It also asks for a second independent scheme and adopting type as evidence. Neither exists yet.
Mechanisms that could be removed
The registry. With one scheme from the same author, and with the prefix not being enough to pin a derivation anyway, a type definition can simply name the derivation it uses. The first open issue asks the working group whether the shared member and registry are useful beyond individual type profiles. That's the right question, and today the answer looks like no.
Both metadata parameters. They are optional, aggregate, and explicitly not sufficient for a client to do anything.
Section 6.1 and most of Section 10. These cover replay, at-most-once execution, and unknown outcomes, then state that the draft defines none of it. One paragraph saying replay protection is out of scope would do.
Section 9. Four paragraphs on Transaction Tokens, the transaction challenge, OpenID4VP, and an effectuation draft, each ending with a statement that this document doesn't change or depend on them.
Writing quality
The mechanics are right. BCP 14 language is used correctly, the IANA templates are complete, and the draft reads RFC 9396 accurately, including the rule that an AS rejects unknown fields.
The prose has a distinctive problem. A large share of the sentences say what the mechanism does not do. The abstract ends with a list of four things identifier equality doesn't establish, and that pattern repeats in nearly every section. Disclaimers are fine in Security Considerations. Here they outnumber the requirements.
Many of the MUSTs can't be tested. "The AS and RS MUST agree on those inputs" and "ensure that the provider receives semantically identical values" describe a goal for a deployment. No implementation can be checked against them.
It runs 19 pages to define one string member, one optional object, and a registry. The same content fits in half that.
The implementation status is honest about its limits. It describes a local JavaScript check with one payment fixture, and says plainly that it isn't an AS, a resource server, or a complete CAID implementation.
Background of the author
Iman Schrock (EMILIA Protocol, Inc.). Zero published RFCs and no expired drafts on Datatracker. 29 active Internet-Drafts, most of them individual submissions under the draft-schrock-ep-* and related names covering authorization receipts, evidence records, revocation statements, and quorum for the EMILIA Protocol.
This is a new IETF author writing at a very high rate, with no expired drafts to show a history before this year. The draft is one piece of a large single-vendor document set, and its only registered scheme comes from that same set. The author contact is a shared company address.
The draft is more modest than most of that set. It claims no new hashing or authorization mechanism and asks the working group directly whether the idea is useful. The useful answer is to ask for one real RAR type that needs a digest where field comparison won't work.