| Internet-Draft | WPT Message Binding | November 2026 |
| Nandakumar & Jennings | Expires 20 May 2027 | [Page] |
The WIMSE Workload Proof Token (WPT) proves possession of a workload's key for an HTTP request and binds the tokens that travel with it. Agent protocols increasingly carry their messages over other transports, such as Media over QUIC, WebSocket, or QUIC streams, often through intermediaries that terminate TLS, such as relays, message brokers, or gateways. There, a proof has no HTTP request to bind to, and the intermediaries that forward a message do not verify it, so freshness has to be established by the receiving verifier. This document defines how a WPT is used with a message that carries it, adds a claim that binds the proof to the content of that message and a claim that echoes a nonce supplied by the verifier, and defines a registry of message canonicalization profiles, with a profile for JSON messages. The same claims can be used in an SD-JWT Key Binding JWT.¶
This note is to be removed before publishing as an RFC.¶
Status information for this document may be found at https://datatracker.ietf.org/doc/draft-nandakumar-wimse-wpt-message-binding/.¶
Discussion of this document takes place on the Workload Identity in Multi System Environments Working Group mailing list (mailto:wimse@ietf.org), which is archived at https://mailarchive.ietf.org/arch/browse/wimse/. Subscribe at https://www.ietf.org/mailman/listinfo/wimse/.¶
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.¶
A Workload Proof Token [WIMSE-WPT] is a short-lived JWT, signed with
the key confirmed by a Workload Identity Token (WIT) [WIMSE-CREDS],
that a workload attaches to an HTTP request. It binds the request's
target through aud; the WIT through wth; a Transaction Token
[TXN-TOKENS] through tth; and other tokens that carry end-user
identity or authorization context through oth
(Section 2 of [WIMSE-WPT]). It does not bind the request content,
and it relies on jti and a short lifetime against replay. Bindings
for non-HTTP protocols are left to future specifications
(Section 1 of [WIMSE-WPT]).¶
Agent protocols need such a binding for messages that are not HTTP
requests. An agent sends a control message, such as a request to open
a delegated dialog or a signed approval, on a stream or track, and the
message travels through intermediaries that terminate TLS, such as
the relays of Media over QUIC Transport [MOQT]. The receiver needs to know that the workload
holding the key sent this message, not a different one with the same
credentials attached, and that the proof is fresh. Agent
dialog binding [DIALOG-BINDING] meets the same need for HTTP with
the dth claim, which hashes the HTTP Dialog-Context field.¶
This document generalizes that approach to any message:¶
Section 2 says how a WPT travels inside a message and what its
aud is when there is no HTTP target URI.¶
mth (Section 3) is the hash of the message the WPT travels in,
computed under a named canonicalization profile.¶
nonce (Section 4) echoes a value the verifier supplied, so that a
verifier establishes freshness itself, without relying on the
intermediaries that forward the message.¶
Section 5 defines the registry of canonicalization profiles and one generic profile for JSON messages. Other documents can define profiles for other message formats.¶
A binding for a particular message format defines only a profile. This document defines everything else a verifier needs: the claim, how a WPT is carried and addressed outside HTTP, freshness, and the registry that bindings use.¶
The binding is generic: an HTTP request body is also a message. A WPT
on an HTTP request can carry mth over its body, binding the request
content as well as its target (Section 2.1).¶
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.¶
A unit of an application protocol that is sent and processed as a whole, such as a JSON object on a stream or an object on a media track.¶
The part of a message that carries the WIT, the WPT, and any other
tokens, such as a credentials member of a JSON message. The
application protocol names it. In a message with a header and a
payload, it can be a header field or a part of the payload. A
message carried with its
tokens outside it, such as an HTTP request body, has none.¶
A named rule that maps a message to the octets hashed into mth.¶
When a WPT accompanies a message rather than an HTTP request:¶
The WIT and the WPT travel in the message's credential member, as the application protocol defines. This document does not define the member.¶
aud is the workload identifier [WIMSE-ARCH] of the intended
receiver of the message, or another value the application protocol
defines, such as an agent identifier. It is not a URI of a request.¶
The WPT SHOULD contain nonce (Section 4) when the verifier has
supplied one.¶
wth, tth, and oth apply as in [WIMSE-WPT], with "request"
read as "message"; oth keys are names that the application protocol
defines for the tokens in its credential member.¶
Validation follows Section 2 of [WIMSE-WPT], except for the checks specific to the HTTP Authorization field, with the additions in Section 3 and Section 4.¶
A WPT on an HTTP request MAY also contain mth, computed over the
request content under a profile that fits its media type, such as
json-jcs for a JSON body. aud and the other claims stay as
[WIMSE-WPT] defines them for HTTP. The WPT then binds the request
content, which [WIMSE-WPT] alone does not (Section 1 of [WIMSE-WPT]), and the binding survives intermediaries that
re-serialize JSON. A verifier that finds mth in a WPT on an HTTP
request MUST verify it, and MUST reject the request if it does not
match.¶
The message hash. A JSON object with two members:¶
p: the name of a canonicalization profile from the registry in
Section 10.2.¶
h: the base64url encoding [RFC7515] of the SHA-256 hash
[RFC6234] of the octets that the profile produces for the
message.¶
"mth": {"p": "json-jcs", "h": "pLk2tQ3m...Gv0"}
¶
A verifier MUST recognize the profile named in p, compute the hash
of the received message under it, and reject the message if the hash
differs from h. A verifier that does not recognize the profile MUST
reject the message.¶
Because mth covers the message content, a WPT cannot be moved to a
different message even within its lifetime, and an intermediary cannot
change the message without detection. The message's credential
member (Section 1.2) is left out of the hash, because the WPT that
carries mth is itself in that member and cannot hash itself.¶
A string that the verifier supplied to the signer earlier, for example in a previous message of the same protocol exchange.¶
A verifier that supplied a nonce MUST check that the WPT echoes it and
that it has not accepted that nonce before. The application protocol
defines how nonces are supplied and how long they are valid. A
verifier that relies on nonce for freshness does not need to keep
jti values beyond the nonce's validity, which suits protocols in
which a message can arrive through any of several intermediaries.¶
A profile fits the message's format. json-jcs (Section 5.1) suits
JSON messages that intermediaries may re-serialize. A message that is
not JSON, such as a binary media payload, needs a profile
defined for its format. Such a profile hashes the message's octets as
delivered and, where a message's position matters, the fields that
identify it, so that a signed message cannot be replayed elsewhere.¶
The json-jcs profile applies to messages that are a single JSON
object. The application protocol names the credential member, if the
message has one. The profile produces the JSON Canonicalization Scheme
[RFC8785] serialization of the message with the credential member
removed. A JSON HTTP request body has no credential member, because
the WPT travels in a header field; the profile then covers the whole
body (Section 2.1).¶
An application protocol that uses json-jcs MUST state the name of the
credential member, and MAY register a profile of its own whose name
identifies the protocol and whose rule is json-jcs with that member.¶
mth on an HTTP request (Section 2.1) covers only the content. This
document defines no profile for HTTP header fields: the WIMSE HTTP
Message Signatures profile [WIMSE-HTTPSIG] [RFC9421] covers chosen
components, and [DIALOG-BINDING] covers the Dialog-Context field
with dth. A request signed that way that carries an
Idempotency-Key field [IDEMPOTENCY] MUST include that field among
the covered components, so that the key cannot be removed or replaced
in transit.¶
An SD-JWT Key Binding JWT [RFC9901] already carries nonce and
aud. A KB-JWT that accompanies a message MAY include mth, with the
meaning defined here, when the SD-JWT is presented in the message's
credential member.¶
Dialog binding [DIALOG-BINDING] binds the HTTP Dialog-Context field
with dth. Where the dialog context is carried inside a message
rather than an HTTP field, mth serves the same purpose and covers
the rest of the message as well. The two can coexist: an HTTP request
uses dth; a message on another transport uses mth.¶
Aggregate signatures for delegation chains [AGG-SIG] attribute
changes to request and response bodies at each hop of an HTTP chain.
mth binds one message to one sender; it does not by itself provide
provenance across hops.¶
DPoP [RFC9449] identifies the HTTP request by method and target URI.
The CAT-4-MOQT profile of DPoP [MoQ-C4M] replaces these with the
MOQT action, Track Namespace, and Track Name, so that a relay can
check that a token's holder authorized that action. Such a proof covers
the action, not the objects published, and is verified by the relay.
mth complements it: the receiving workload verifies that the sender
holds the key and sent this message content, end to end through any
intermediaries.¶
An agent protocol can register its own profile and use mth to bind
delegation credentials to the control message that opens a delegated
dialog.¶
On an HTTP request (Section 2.1), mth covers only the request content.
HTTP Message Signatures [RFC9421], as profiled for workloads in
[WIMSE-HTTPSIG], also cover header fields, but cover the octets of
the content, which an intermediary that re-serializes it changes. A
deployment that must protect header fields uses HTTP Message
Signatures; one that needs only the content bound, across such
intermediaries, can use mth. JSON-RPC protocols over HTTP, such as
A2A and MCP, are an example.¶
Signer and verifier must produce identical octets. Profiles MUST
define canonicalization precisely; json-jcs relies on [RFC8785].
A verifier MUST reject a message whose JSON contains duplicate member
names.¶
A nonce that is predictable or reused allows replay. Nonces MUST have at least 128 bits of entropy and be accepted at most once.¶
"Accepted at most once" holds only if every instance of a verifier
consults the same record. A verifier that runs as several instances
MUST share its record of accepted nonces and jti values, keyed by
issuer, audience, and value, and keep each entry until the WPT's
exp or the nonce's validity ends. An instance that cannot reach the
record MUST reject the message.¶
mth binds a WPT to one message, but a signer can send the same
operation again as a new message with a new WPT. Detecting that is
the application's task. An application protocol whose messages
cause side effects SHOULD carry an idempotency key in the message,
where mth covers it, and a receiver SHOULD bind each key to the
first message accepted under it and reject a later message with the
same key and a different hash. This rule applies to HTTP requests
that carry Idempotency-Key [IDEMPOTENCY].¶
exp and iat checks assume a correct clock. A verifier that
cannot trust its clock, for example after a restart without a time
source, MUST NOT accept WPTs until it can; a secure time source such
as Roughtime [ROUGHTIME] can provide this.¶
mth covers what its profile covers. json-jcs covers the message,
not the metadata that the transport carries around it, such as the
stream, channel, or topic it was sent on. An application protocol
that relies on such metadata MUST include it in the message or use a
profile that covers it.¶
mth makes modification of a message detectable but does not hide
its content from intermediaries. Confidentiality across them needs
end-to-end encryption of the message.¶
mth reveals nothing beyond a hash of a message the verifier already
holds. nonce values SHOULD be random rather than derived from
identifiers.¶
Claim Name: mth¶
Claim Description: Hash of the message a proof of possession accompanies, under a canonicalization profile¶
Change Controller: IETF¶
The nonce claim is already registered.¶
IANA is requested to create the "WIMSE Message Canonicalization Profiles" registry, with the policy Specification Required. Each entry has a Profile Name, a Description, and a Reference.¶
Initial entries:¶
Profile Name: json-jcs¶
Description: JCS of a JSON message with its credential member removed¶
Reference: Section 5.1¶
This document builds on the WIMSE Workload Proof Token and on the
dth claim of agent dialog binding.¶