Internet-Draft WPT Message Binding November 2026
Nandakumar & Jennings Expires 20 May 2027 [Page]
Workgroup:
Workload Identity in Multi System Environments
Internet-Draft:
draft-nandakumar-wimse-wpt-message-binding-00
Published:
Intended Status:
Standards Track
Expires:
Authors:
S. Nandakumar
Cisco
C. Jennings
Cisco Systems

Message Binding for Workload Proof Tokens

Abstract

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.

About This Document

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/.

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 20 May 2027.

▲

Table of Contents

1. Introduction

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:

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).

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. Terminology

Message:

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.

Credential member:

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.

Canonicalization profile:

A named rule that maps a message to the octets hashed into mth.

2. Carrying a WPT in a Message

When a WPT accompanies a message rather than an HTTP request:

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.

2.1. On an HTTP Request

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.

3. The mth Claim

mth:

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.

4. The nonce Claim

nonce:

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.

5. Canonicalization Profiles

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.

5.1. json-jcs

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.

5.2. HTTP Header Fields

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.

6. Use in SD-JWT Key Binding JWTs

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.

7. Relationship to Other Work

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.

8. Security Considerations

Canonicalization:

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.

Nonce handling:

A nonce that is predictable or reused allows replay. Nonces MUST have at least 128 bits of entropy and be accepted at most once.

Replay records:

"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.

Repeated actions:

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].

Clocks:

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.

Partial coverage:

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.

Intermediaries:

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.

9. Privacy Considerations

mth reveals nothing beyond a hash of a message the verifier already holds. nonce values SHOULD be random rather than derived from identifiers.

10. IANA Considerations

10.1. JSON Web Token Claims

  • Claim Name: mth

  • Claim Description: Hash of the message a proof of possession accompanies, under a canonicalization profile

  • Change Controller: IETF

  • Reference: Section 3

The nonce claim is already registered.

10.2. WIMSE Message Canonicalization Profiles

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

11. References

11.1. Normative References

[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/rfc/rfc2119>.
[RFC6234]
Eastlake 3rd, D. and T. Hansen, "US Secure Hash Algorithms (SHA and SHA-based HMAC and HKDF)", RFC 6234, DOI 10.17487/RFC6234, , <https://www.rfc-editor.org/rfc/rfc6234>.
[RFC7515]
Jones, M., Bradley, J., and N. Sakimura, "JSON Web Signature (JWS)", RFC 7515, DOI 10.17487/RFC7515, , <https://www.rfc-editor.org/rfc/rfc7515>.
[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/rfc/rfc8174>.
[RFC8785]
Rundgren, A., Jordan, B., and S. Erdtman, "JSON Canonicalization Scheme (JCS)", RFC 8785, DOI 10.17487/RFC8785, , <https://www.rfc-editor.org/rfc/rfc8785>.
[RFC9901]
Fett, D., Yasuda, K., and B. Campbell, "Selective Disclosure for JSON Web Tokens", RFC 9901, DOI 10.17487/RFC9901, , <https://www.rfc-editor.org/rfc/rfc9901>.
[WIMSE-CREDS]
Campbell, B., Salowey, J. A., Schwenkschuster, A., Sheffer, Y., and Y. Rosomakho, "WIMSE Workload Credentials", Work in Progress, Internet-Draft, draft-ietf-wimse-workload-creds-03, , <https://datatracker.ietf.org/doc/html/draft-ietf-wimse-workload-creds-03>.
[WIMSE-WPT]
Campbell, B. and A. Schwenkschuster, "WIMSE Workload Proof Token", Work in Progress, Internet-Draft, draft-ietf-wimse-wpt-02, , <https://datatracker.ietf.org/doc/html/draft-ietf-wimse-wpt-02>.

11.2. Informative References

[AGG-SIG]
Reddy.K, T., Tschofenig, H., and Y. Sheffer, "Authenticated Provenance for WIMSE Delegation Chains", Work in Progress, Internet-Draft, draft-reddy-wimse-aggregate-signatures-01, , <https://datatracker.ietf.org/doc/html/draft-reddy-wimse-aggregate-signatures-01>.
[DIALOG-BINDING]
Reddy.K, T. and Z. Sarker, "Binding Agent Dialogs to WIMSE and OAuth Credentials", Work in Progress, Internet-Draft, draft-reddy-wimse-oauth-dialog-binding-00, , <https://datatracker.ietf.org/doc/html/draft-reddy-wimse-oauth-dialog-binding-00>.
[IDEMPOTENCY]
Jena, J., Dalal, S., and D. Tishkin, "The Idempotency-Key HTTP Header Field", Work in Progress, Internet-Draft, draft-ietf-httpapi-idempotency-key-header-08, , <https://datatracker.ietf.org/doc/html/draft-ietf-httpapi-idempotency-key-header-08>.
[MoQ-C4M]
Lemmons, C., Simon, G., Nandakumar, S., and W. Law, "Authorization scheme for MOQT using Common Access Tokens", Work in Progress, Internet-Draft, draft-ietf-moq-c4m-02, , <https://datatracker.ietf.org/doc/html/draft-ietf-moq-c4m-02>.
[MOQT]
Nandakumar, S., Vasiliev, V., Swett, I., and A. Frindell, "Media over QUIC Transport", Work in Progress, Internet-Draft, draft-ietf-moq-transport-23, , <https://datatracker.ietf.org/doc/html/draft-ietf-moq-transport-23>.
[RFC9421]
Backman, A., Ed., Richer, J., Ed., and M. Sporny, "HTTP Message Signatures", RFC 9421, DOI 10.17487/RFC9421, , <https://www.rfc-editor.org/rfc/rfc9421>.
[RFC9449]
Fett, D., Campbell, B., Bradley, J., Lodderstedt, T., Jones, M., and D. Waite, "OAuth 2.0 Demonstrating Proof of Possession (DPoP)", RFC 9449, DOI 10.17487/RFC9449, , <https://www.rfc-editor.org/rfc/rfc9449>.
[ROUGHTIME]
Ladd, W. and M. Dansarie, "Roughtime: A Protocol for Rough Time Synchronization", RFC 10049, DOI 10.17487/RFC10049, , <https://www.rfc-editor.org/rfc/rfc10049>.
[TXN-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/html/draft-ietf-oauth-transaction-tokens-11>.
[WIMSE-ARCH]
Salowey, J. A., Rosomakho, Y., and H. Tschofenig, "Workload Identity in a Multi System Environment (WIMSE) Architecture", Work in Progress, Internet-Draft, draft-ietf-wimse-arch-08, , <https://datatracker.ietf.org/doc/html/draft-ietf-wimse-arch-08>.
[WIMSE-HTTPSIG]
Salowey, J. A. and Y. Sheffer, "WIMSE Workload-to-Workload Authentication with HTTP Signatures", Work in Progress, Internet-Draft, draft-ietf-wimse-http-signature-08, , <https://datatracker.ietf.org/doc/html/draft-ietf-wimse-http-signature-08>.

Acknowledgments

This document builds on the WIMSE Workload Proof Token and on the dth claim of agent dialog binding.

Authors' Addresses

Suhas Nandakumar
Cisco
Cullen Jennings
Cisco Systems