]> Palo Alto Networks

joe@salowey.net

Intuit

yaronf.ietf@gmail.com

Applications and Real-Time Workload Identity in Multi System Environments workload identity The WIMSE architecture defines authentication and authorization for software workloads in a variety of runtime environments, from the most basic ones to complex multi-service, multi-cloud, multi-tenant deployments. This document defines one of the mechanisms to provide workload authentication, using HTTP Signatures. While only applicable to HTTP traffic, the protocol provides end-to-end protection of requests (and optionally, responses), even when service traffic is not end-to-end encrypted, that is, when TLS proxies and load balancers are used. Authentication is based on the Workload Identity Token (WIT). About This Document The latest revision of this draft can be found at . Status information for this document may be found at . Discussion of this document takes place on the Workload Identity in Multi System Environments Working Group mailing list (), which is archived at . Subscribe at . Source for this draft and an issue tracker can be found at .

Introduction This document defines authentication and authorization in the context of interaction between two workloads. This is the core component of the WIMSE architecture . This document focuses on HTTP-based services, and the workload-to-workload call consists of a single HTTP request and its response. One option to protect such traffic is through Mutual TLS (mTLS), and this usage is defined in . Many deployments prefer application-layer approaches, whether for lack of Certification Authority (CA) infrastructure or because inter-service communication consists of multiple TLS hops. This document defines one such WIMSE approach for application-layer protection. We define a profile of the HTTP Signatures protocol to protect the service traffic. Service authentication uses the Workload Identity Token (WIT) defined in , and the signature uses the private key associated with the WIT and thus proves possession of that key. WIMSE is specifying two approaches for application-layer protection, both using the newly introduced Workload Identity Token . The first alternative is inspired by the OAuth DPoP specification . The second is based on the HTTP Message Signatures RFC , and it is defined in this document. includes a comparison of the two approaches.

Deployment Architecture and Message Flow Refer to Sec. 1.2 of for the deployment architecture which is common to both application-level approaches, as well as the transport-level one.

Conventions and Definitions All terminology in this document follows . 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 when, and only when, they appear in all capitals, as shown here.

The Protocol: Authentication Based on HTTP Message Signatures This protocol uses the Workload Identity Token and the private key associated with its public key, to sign the HTTP request and optionally, the response. Formally, this is a profile of the Message Signatures specification . The request is signed as per . The following derived components MUST be signed:

• @method
• @path
• @query

This profile uses @path and @query rather than @request-target, which is NOT RECOMMENDED outside HTTP/1.1 (). @query is included even when the request has no query component; in that case its value is ? (). The @authority derived component is not included: TLS-terminating proxies and load balancers commonly rewrite the authority (see and ), so signing it would break those deployments. Recipient binding is carried instead by the mandatory wimse-aud signature parameter (). In addition, the following request headers MUST be signed when they exist:

• Content-Type
• Content-Digest
• Authorization
• Txn-Token
• Workload-Identity-Token

If the response is signed, the following components MUST be signed:

• @status
• @method;req
• @path;req
• @query;req
• Content-Type if it exists
• Content-Digest if it exists
• Workload-Identity-Token

To ensure the message is fully integrity-protected, if the request or response includes a message body, the sender MUST include (and the receiver MUST verify) a Content-Digest header. This implies the receiver MUST compute the Content-Digest value for the message content received and compare it with the Content-Digest value provided in the message. For both requests and responses, the following signature parameters MUST be included:

• created
• expires - expiration MUST be short, e.g. on the order of minutes. This profile is for individual request/response exchanges; mechanisms for long-lived batch-style workloads are out of scope.
• nonce
• tag - the value for implementations of this specification is wimse-workload-to-workload

For requests only, the following signature parameter MUST also be included:

• wimse-aud ()

For requests only, the following signature parameter MAY also be included:

• wimse-sign-response ()

For responses only, the following signature parameter MUST also be included:

• wimse-req-nonce ()

The following signature parameters in the Signature-Input header MUST NOT be used:

• keyid - The signing key is sent along with the message in the WIT. Additionally specifying the key identity would add confusion.
• alg - The signature algorithm is specified in the jwk section of the cnf claim in the WIT. See and Sec. 3.3.7 of for details.

It is RECOMMENDED to include only one signature with the HTTP message. The WIMSE signature is the one whose tag parameter is wimse-workload-to-workload (). If no signature has that tag value, the message does not carry a WIMSE HTTP signature. If more than one signature has that tag value, the recipient MUST reject the message. When more than one signature is present, recipients MUST use that tag to find the WIMSE signature; they MUST NOT choose by label (). Senders MUST generate each nonce at random with sufficient length that the probability of collision is negligible among all nonces a recipient might observe within the lifetime of a signature. Members of a sender cluster therefore need not coordinate nonce generation. Recipients MAY maintain a replay cache and SHOULD reject a message (request or response) whose nonce they have already seen. What nonces are remembered, and for how long, is a local policy matter; this document does not require replay caches to be shared across validators. Without such sharing, replay to a different cluster member can still succeed. For clarity: the signature's lifetime (the expires signature parameter) is different and typically much shorter than the WIT's lifetime, denoted by its exp claim. Implementers need to be aware that the WIT is extracted from the message before the message signature is validated. Recipients of signed HTTP messages MUST validate the WIT as specified in before validating the HTTP message signature. They MUST ensure that the message is not processed further before it has been fully validated.

Signature Algorithms The HTTP message signature algorithm is determined by the alg member of the cnf.jwk object in the WIT ("The Workload Identity Token" in ). This profile does not define a separate algorithm baseline; general-purpose implementations inherit the requirement that ES256 MUST be supported from that document. The alg signature parameter MUST NOT be used, as specified above. Recipients MUST verify the HTTP message signature using the algorithm identified by cnf.jwk.alg and MUST reject the message if that algorithm is not acceptable under local policy for the peer's trust domain. See also on key and algorithm specification downgrades.

The wimse-aud Signature Parameter defines signature parameters for HTTP message signatures: metadata carried in the Signature-Input field alongside the covered components. That metadata is covered by the signature as the @signature-params component value (Section 2.3 of ), which is always the last line of the signature base. This document defines the wimse-aud signature metadata parameter for requests. It is a String parameter. Using a signature parameter carries the audience explicitly in Signature-Input, so the value is protected by the signature and is not affected by hop-by-hop rewriting of the request URI. The sender MUST set wimse-aud to an audience value that identifies the intended recipient of the request. By default, the sender uses the HTTP target URI () of the request, without query or fragment components, as known to the sender. When intermediaries rewrite the request URI, or when that string would not match what the recipient expects, the sender uses a deployment-specific audience value that the recipient can recognize. The audience identifies the intended recipient of the proof; it is distinct from the sender's Workload Identifier in the WIT sub claim. The recipient MUST be able to verify that the audience refers to it, using trusted configuration rather than untrusted request fields such as Host. See "Workload Identifiers and Authentication Granularity" in .

The wimse-sign-response Signature Parameter This document defines the wimse-sign-response signature metadata parameter for requests. It is a Boolean parameter. When present with the value true, the client requires the server to sign the HTTP response to this request as specified in . When the parameter is omitted, or present with the value false, the client does not require a signed response via this parameter. If the client is configured to require a signed response, it MUST include wimse-sign-response with the Boolean value true in the request's Signature-Input. This parameter is not mandatory. Moreover, the server MAY sign the response even if this parameter is missing from the request or is present with the value false.

The wimse-req-nonce Signature Parameter This document defines the wimse-req-nonce signature metadata parameter for signed responses. It is a String parameter. This parameter binds requests to responses and prevents a malicious server-side component or middlebox from replaying responses to the wrong client. Every signed response MUST include wimse-req-nonce. The server MUST set it to the value of the nonce signature parameter from the Signature-Input of the request that triggered the response.

Signing the Response Protecting the response by signing it with the server's WIT is RECOMMENDED but not required. In particular, if the response may be exceptionally large or is expected to be streamed, signing it may not be practical. Response signing is required of the server for a given exchange when either of the following is true:

• The request's Signature-Input includes wimse-sign-response with the Boolean value true ().
• Local policy at the server requires response signing for that exchange.

If the server is required to sign the response but cannot produce a signed response (for example, because the response is streamed or exceptionally large), it MUST NOT return a successful unsigned response; it MUST return an error as described in . The client MUST reject an unsigned response when the request's Signature-Input included wimse-sign-response with the Boolean value true. If the client did not require a signed response via wimse-sign-response, server-side local-policy signing is opportunistic from the client's point of view: the client has no signal that a signature was expected, so a middlebox that strips a signed response leaves an ordinary unsigned response that the client MUST accept. The server MAY still sign in that case. Whenever a signed response is present, the client MUST validate it and reject it if validation fails. When validating a signed response, the client MUST verify that wimse-req-nonce is present and equals the nonce from the corresponding request. As described in , either client or server MAY send an Accept-Signature header. That header indicates a preference for signed messages; it does not mandate that a response be signed. Only wimse-sign-response with the Boolean value true creates such a mandate (, ). When both are present, the server MUST treat wimse-sign-response as authoritative for whether a signed response is required. When a client sends Accept-Signature in a request, it MUST list the response components it wishes to have signed, including at least those specified above for signed responses. When a server sends Accept-Signature in a response, it MUST list the request components it wishes to have signed in subsequent requests, minimally those specified above for signed requests. Accept-Signature MUST NOT be used to request coverage weaker than this profile.

Error Conditions Errors may occur during the processing of the message signature. If the signature verification fails for any reason, such as an invalid signature, an expired validity time window, or a malformed data structure, an error is returned. Typically, this will be in response to an API call. An HTTP status code such as 400 (Bad Request) is appropriate. The response could include more details as per , such as an indicator that the wrong key material or algorithm was used. The use of HTTP status code 401 is NOT RECOMMENDED for this purpose because it requires a WWW-Authenticate with acceptable HTTP auth mechanisms in the error response and an associated Authorization header in the subsequent request. The use of these headers for the WIT is not compatible with this specification. If the client required a signed response via wimse-sign-response and the server cannot sign the response, the server SHOULD return 400 (Bad Request) or 501 (Not Implemented), optionally with a problem details body indicating that a signed response cannot be provided.

Example Requests and Responses The following non-normative examples illustrate this profile with two algorithms: Ed25519 () for svcA/svcB, and ES256 for svcC. The first exchange is svcA calling svcB; the second is svcB calling svcC.

Ed25519: svcA calling svcB Following is a signed request and a signed response using Ed25519. The caller (svcA) uses this keypair:

svcA Private Key (Ed25519)

The caller uses its keypair and generates the following HTTP request:

Signed Request (svcA to svcB)

Assuming that the workload being called (svcB) has the following keypair:

svcB Private Key (Ed25519)

A signed response would be:

Signed Response (svcB to svcA)

ES256: svcB calling svcC The following exchange uses ES256 at the callee (svcC). The caller is svcB, using the Ed25519 keypair above. The callee (svcC) uses this keypair:

svcC Private Key (ES256)

A signed request from svcB to svcC:

Signed Request (svcB to svcC)

A signed response from svcC:

Signed Response (svcC to svcB)

Implementation Status Note to RFC Editor: please remove this section, as well as the reference to RFC 7942, before publication. This section records the status of known implementations of the protocol defined by this specification at the time of posting of this Internet-Draft, and is based on a proposal described in . The description of implementations in this section is intended to assist the IETF in its decision processes in progressing drafts to RFCs. Please note that the listing of any individual implementation here does not imply endorsement by the IETF. Furthermore, no effort has been spent to verify the information presented here that was supplied by IETF contributors. This is not intended as, and must not be construed to be, a catalog of available implementations or their features. Readers are advised to note that other implementations may exist. According to RFC 7942, "this will allow reviewers and working groups to assign due consideration to documents that have the benefit of running code, which may serve as evidence of valuable experimentation and feedback that have made the implemented protocols more mature. It is up to the individual working groups to use this information as they see fit".

Cofide

• Organization: Cofide
• Implementation: https://github.com/cofide/wimse-s2s-httpsig-poc
• Maturity:
  • WIT + HTTP Message Signatures: proof-of-concept
• Coverage: WIT, HTTP Message Signatures
• License: Apache 2.0
• Contact: jason@cofide.io
• Last updated: 13-Nov-2025

wimsey

• Organization: independent
• Implementation: https://github.com/kanywst/wimsey
• Maturity:
  • WIT + HTTP Message Signatures: alpha
• Coverage: WIT, HTTP Message Signatures, signed responses
• License: Apache 2.0
• Contact: kanywst on GitHub
• Last updated: 08-Sep-2026

Security Considerations This section includes security considerations that are specific to the HTTP Signature protocol defined here. Refer to for more generic security considerations associated with the workload identity and its WIT representation.

Workload Identity Token and Proof of Possession The Workload Identity Token (WIT) is bound to a secret cryptographic key and is always presented with a proof of possession (PoP) as described in . The WIT is a general purpose token that can be presented in multiple contexts. The WIT and its PoP are only used in the application-layer options, and neither is used in mTLS. The WIT MUST NOT be used as a bearer token. While this helps reduce the sensitivity of the token it is still possible that a token and its PoP may be captured and replayed within the PoP's lifetime. The HTTP Signature profile presented here binds the PoP to the critical parts of the HTTP request (and potentially response), including the request method, path, query, the intended audience (wimse-aud), and the message content. The audience is a signed signature parameter rather than a re-derived URI component, so it survives intermediaries that rewrite the authority. This profile does not cover @authority for that reason (). This eliminates most of the risk associated with active attackers on a middlebox. In addition, the following mitigations should be used:

• Preventing Eavesdropping and Interception with TLS

An attacker observing or intercepting the communication channel can view the token and its PoP and attempt to replay it to gain an advantage. In order to prevent this, the token and PoP MUST be sent over a secure, server authenticated TLS connection unless a secure channel is provided by some other mechanisms. Hostname validation according to Section 6.3 of MUST be performed by the client.

• Limiting Signature Lifespan

The signature lifespan MUST be limited by using a tight expires value, taking into account potential clock skew and processing latency, but usually within minutes of the message sending time. Signatures received outside their validity time MUST be rejected.

• Replay Protection

A signed message includes the nonce signature parameter. This parameter SHOULD be used by the receiver to perform basic replay protection: a nonce that has already been seen SHOULD cause the message to be rejected. Depending upon the design of the system it may be difficult to synchronize the replay cache across all message validators. If an attacker can somehow influence the identity of the validator (e.g. which cluster member receives the message) then replay protection would not be effective.

Middle Boxes In some deployments the Workload Identity Token and PoP (signature) may pass through multiple systems. The communication between the systems is over TLS, but the WIT and signature are available in the clear at each intermediary. While the intermediary cannot modify the token or the information within the signature without detection, it can attempt to capture and replay the message or modify unsigned information, such as any HTTP headers that remain unsigned. HTTP permits intermediaries to transform messages (). This profile is intended to remain verifiable across common TLS-terminating proxies and load balancers: it does not cover @authority, and it carries recipient binding in wimse-aud (). An intermediary MAY add its own HTTP message signature to a message that already carries a WIMSE signature. Recipients continue to identify the WIMSE signature by its tag value wimse-workload-to-workload and MUST NOT select by label (). If an intermediary changes a component covered by the WIMSE signature, verification of that signature fails. This document does not define a profile for stripping the origin WIMSE signature and replacing it with a new WIMSE signature at the intermediary. Such resigning would authenticate the intermediary rather than the origin workload and is left to deployment-specific policy outside this specification. Mitigations listed in the protocol provide a reasonable level of security in these situations, in particular if responses are signed in addition to requests. See also for the distinction between client-mandated and opportunistic response signing.

Privacy Considerations WITs and the signatures may contain private information such as user names or other identities. Care must be taken to prevent disclosure of this information. The use of TLS helps protect the privacy of WITs and PoPs. WITs are typically associated with a workload and not a specific user, however in some deployments the workload may be associated directly to a user. In those cases a deployment should evaluate if the disclosure of WITs or signatures can be used to track a user.

Security Goals This section defines semiformal security goals for this protocol, when used in conjunction with the WIT credential. Our aim is to inform developers and for these goals to eventually evolve into formal verification of the protocol.

Prerequisites The following are out of scope of the protocol and their security is assumed.

• There exists a WIT Issuer which is trusted to issue credentials honestly.
• Workloads have a way to authenticate themselves to the Issuer and be provisioned with a valid WIT, associated with their WIMSE identity.
• All workloads are provisioned with trust anchors that allow them to validate incoming WITs.
• The entire authorization subsystem is out of scope and trusted. This can potentially include provisioning and enforcement of an authorization policy, issuance of transaction tokens and workload attestation.
• All workload-to-workload traffic is TLS-protected. However TLS may be terminated on one or more middleboxes and the TLS endpoint identity (or identities) is not associated with a WIMSE identity.
• As a result, all workload-to-workload traffic is confidential and (assuming honest participants) is only available to sender, receiver, and any TLS-terminating middleboxes that process the traffic.

Authentication

• A workload receiving a request can validate that it is signed correctly, and can identify the sender.
• A workload receiving a response can similarly validate the signature and identify the sender when a signed response is present.
• The above implies that a stolen WIT cannot be used by an entity other than its owner.

Integrity

• Covered components of a request cannot be modified without detection by the recipient. Integrity of all present HTTP headers specified in this document is protected, as well as the derived components listed in , the signature parameters (including wimse-aud and wimse-sign-response on requests and wimse-req-nonce on responses) as covered by @signature-params in , and the message content (when present).
• Covered components of a signed response cannot be modified without detection by the recipient.
• This profile is designed so that, for typical REST APIs, the essential parts of the message are covered by the signature.
• Headers not specified in this document may remain unsigned and could potentially be modified or deleted by intermediaries without detection.

Replay and Deletion

• Replay protection is not strictly mandated because of implementation considerations (e.g., distributed system challenges with synchronizing replay caches across validators). Therefore it is not claimed as a goal, though implementations SHOULD attempt to detect replays where feasible. We note that since most of the message is signed, replay attacks are only possible in a context where the request would be accepted as valid, and this mitigates the risk to some extent.
• When a signed response is present, validating wimse-req-nonce mitigates replay of that response to a client other than the one that sent the triggering request.
• Undetected deletion of a request/response pair is prevented only when the client required a signed response via wimse-sign-response with the Boolean value true and rejects an unsigned response. Server local-policy signing alone does not provide that guarantee ().

IANA Considerations

HTTP Signature Metadata Parameters Registration IANA is requested to register the following entries in the "HTTP Signature Metadata Parameters" registry , per the registration template in Section 6.3.1 of :

• wimse-aud, per .
• wimse-sign-response, per .
• wimse-req-nonce, per .

wimse-aud

• Name: wimse-aud
• Description: String; the WIMSE message audience. Request signatures only; binds the HTTP message signature to the intended recipient.
• Reference: RFC XXX, .

wimse-sign-response

• Name: wimse-sign-response
• Description: Boolean; when true on a request signature, the client requires the server to sign the corresponding HTTP response.
• Reference: RFC XXX, .

wimse-req-nonce

• Name: wimse-req-nonce
• Description: String; on response signatures, the nonce value from the triggering request's Signature-Input; binds the response to that request.
• Reference: RFC XXX, .

References Normative References Palo Alto Networks Zscaler University of the Bundeswehr Munich The increasing prevalence of cloud computing and micro service architectures has led to the rise of complex software functions being built and deployed as workloads, where a workload is defined as software executing for a specific purpose, potentially comprising one or more running instances. This document discusses an architecture for designing and standardizing protocols and payloads for conveying workload identity and security context information. This document describes a mechanism for creating, encoding, and verifying digital signatures or message authentication codes over components of an HTTP message. This mechanism supports use cases where the full HTTP message may not be known to the signer and where the message may be transformed (e.g., by intermediaries) before reaching the verifier. This document also describes a means for requesting that a signature be applied to a subsequent HTTP message in an ongoing HTTP exchange. Ping Identity CyberArk Defakto Security Intuit Zscaler The WIMSE architecture defines authentication and authorization for software workloads in a variety of runtime environments, from the most basic ones up to complex multi-service, multi-cloud, multi- tenant deployments. This document defines the credentials that workloads use to represent their identity. They can be used in various protocols to authenticate workloads to each other. To use these credentials, workloads must provide proof of possession of the associated private key material, which is covered in other documents. This document focuses on the credentials alone, independent of the proof-of- possession mechanism. In many standards track documents several words are used to signify the requirements in the specification. These words are often capitalized. This document defines these words as they should be interpreted in IETF documents. This document specifies an Internet Best Current Practices for the Internet Community, and requests discussion and suggestions for improvements. RFC 2119 specifies common key words that may be used in protocol specifications. This document aims to reduce the ambiguity by clarifying that only UPPERCASE usage of the key words have the defined special meanings. The Hypertext Transfer Protocol (HTTP) is a stateless application-level protocol for distributed, collaborative, hypertext information systems. This document describes the overall architecture of HTTP, establishes common terminology, and defines aspects of the protocol that are shared by all versions. In this definition are core protocol elements, extensibility mechanisms, and the "http" and "https" Uniform Resource Identifier (URI) schemes. This document updates RFC 3864 and obsoletes RFCs 2818, 7231, 7232, 7233, 7235, 7538, 7615, 7694, and portions of 7230. This document defines a "problem detail" to carry machine-readable details of errors in HTTP response content to avoid the need to define new error response formats for HTTP APIs. This document obsoletes RFC 7807. This document describes a simple process that allows authors of Internet-Drafts to record the status of known implementations by including an Implementation Status section. This will allow reviewers and working groups to assign due consideration to documents that have the benefit of running code, which may serve as evidence of valuable experimentation and feedback that have made the implemented protocols more mature. This process is not mandatory. Authors of Internet-Drafts are encouraged to consider using the process for their documents, and working groups are invited to think about applying the process to all of their protocol specifications. This document obsoletes RFC 6982, advancing it to a Best Current Practice. Many application technologies enable secure communication between two entities by means of Transport Layer Security (TLS) with Internet Public Key Infrastructure using X.509 (PKIX) certificates. This document specifies procedures for representing and verifying the identity of application services in such interactions. This document obsoletes RFC 6125. Informative References n.d. Palo Alto Networks Zscaler The WIMSE architecture defines authentication and authorization for software workloads in a variety of runtime environments, from the most basic ones to complex multi-service, multi-cloud, multi-tenant deployments. This document profiles a workload authentication based on X.509 workload identity certificates using mutual TLS (mTLS). Ping Identity Defakto Security The WIMSE architecture defines authentication and authorization for software workloads in a variety of runtime environments, from basic deployments to complex multi-service, multi-cloud, multi-tenant systems. This document specifies the Workload Proof Token (WPT), a mechanism for workloads to prove possession of the private key associated with a Workload Identity Token (WIT). The WPT is a signed JWT that binds the workload's authentication to a specific HTTP request, providing application-layer proof of possession for workload-to-workload communication. This specification is designed to work alongside the WIT credential format defined in draft-ietf- wimse-workload-creds and can be combined with other WIMSE protocols in multi-hop call chains. This document describes a mechanism for sender-constraining OAuth 2.0 tokens via a proof-of-possession mechanism on the application level. This mechanism allows for the detection of replay attacks with access and refresh tokens. CrowdStrike Practical Identity LLC Defakto Security Transaction Tokens (Txn-Tokens) are designed to maintain and propagate user identity, workload identity and authorization context throughout the Call Chain within a trusted domain during the processing of external requests (e.g. such as API calls) or requests initiated internally within the Trust Domain. Txn-Tokens ensure that this context is preserved throughout the Call Chain thereby enhancing security and consistency in complex, multi-service architectures. This specification refers to cryptographic algorithm identifiers that fully specify the cryptographic operations to be performed, including any curve, key derivation function (KDF), and hash functions, as being "fully specified". It refers to cryptographic algorithm identifiers that require additional information beyond the algorithm identifier to determine the cryptographic operations to be performed as being "polymorphic". This specification creates fully-specified algorithm identifiers for registered JSON Object Signing and Encryption (JOSE) and CBOR Object Signing and Encryption (COSE) polymorphic algorithm identifiers, enabling applications to use only fully-specified algorithm identifiers. It deprecates those polymorphic algorithm identifiers. This specification updates RFCs 7518, 8037, and 9053. It deprecates polymorphic algorithms defined by RFCs 8037 and 9053 and provides fully-specified replacements for them. It adds to the instructions to designated experts in RFCs 7518 and 9053.

Document History RFC Editor: please remove before publication.

draft-ietf-wimse-http-signature-07

• WGLC: replace @request-target with @path/@query; select the WIMSE signature by tag (#297, #301).
• WGLC: tighten signed-response rules (wimse-sign-response, Accept-Signature, opportunistic local-policy signing, deletion detection) and require wimse-req-nonce on every signed response (#297, #301, #305).
• WGLC: clarify wimse-aud (defaults, deployment-specific values) and why @authority is not covered; nonce replay caching; algorithms via WIT cnf.jwk.alg; middlebox/proxy considerations (#297, #305).
• Clarify parameter types, wimse-sign-response false vs omitted, integrity goals, and short expires; make wimse-arch and RFC 9457 normative (#305).
• Regenerate examples for the profile changes; add an ES256 svcB-to-svcC exchange alongside Ed25519 svcA/svcB (#312, ).
• Reference the WIT validation procedure in (#290); consistent "proof of possession"/"PoP" wording.

draft-ietf-wimse-http-signature-06

• Add wimse-sign-response request signature parameter so clients can mandate a signed response; regenerate examples (#277).

draft-ietf-wimse-http-signature-05

• Regenerate non-normative request/response examples so the signed response includes wimse-req-nonce matching the request nonce (#274).

draft-ietf-wimse-http-signature-04

• On signed responses, require wimse-req-nonce (request binding); register with IANA. Non-normative response example not updated accordingly; the Signature value was not regenerated (see issue tracker).

draft-ietf-wimse-http-signature-03

• Replace Wimse-Audience HTTP header with the wimse-aud signature metadata parameter (); register with IANA (HTTP Signature Metadata Parameters). Non-normative request example updated accordingly; the Signature value was not regenerated (see issue tracker).

draft-ietf-wimse-http-signature-02

• Add new Wimse-Audience HTTP header (superseded by wimse-aud in -03).

draft-ietf-wimse-http-signature-01

• Clarified response signing.
• Clarified signature vs. token lifetime.
• Added security goals.
• Added an Implementation Status section.

draft-ietf-wimse-http-signature-00

• Initial version, extracted from the -07 draft with minimal edits.

draft-ietf-wimse-s2s-protocol-07

• Rework the WPT's oth claim.
• Update the media types.
• Discuss extensibility of WIT and WPT.
• Clarify error handling, specifically why not HTTP 401.
• Correct the code examples.
• Add registration request content for a wimse URI scheme.
• New section on key management.
• Use of the Accept-Signature header.

draft-ietf-wimse-s2s-protocol-06

• Explicit definition of the Workload Identity Certificate.
• Definition of the validation of workload identifiers as part of workload authentication. Still work in progress.

draft-ietf-wimse-s2s-protocol-05

• Removed the entire Workload Identity section which is now covered in the Architecture document.
• Content-Digest is mandatory with HTTP-Sig.
• Some wording on extending the protocol beyond HTTP.
• IANA considerations.

draft-ietf-wimse-s2s-protocol-04

• Require cnf.jwk.alg in WIT which restricts signature algorithm of WPT or HTTP-Sig.
• Replay protection as a SHOULD for both WPT and HTTP-Sig.
• Consolidate terminology with the Architecture draft.

draft-ietf-wimse-s2s-protocol-03

• Consistently use "workload".
• Implement comments from the SPIFFE community.
• Make iss claim in WIT optional and add wording about its relation to key distribution.
• Remove iss claim from WPT.
• Make jti claim in WIT optional.
• Error handling for the application-level methods.

draft-ietf-wimse-s2s-protocol-02

• Coexistence with bearer tokens.
• Improve the architecture diagram.
• Some more ABNF.
• Clarified identifiers and URIs.
• Moved an author to acknowledgments.

draft-ietf-wimse-s2s-protocol-01

• Addressed multiple comments from Pieter.
• Clarified WIMSE identity concepts, specifically "trust domain" and "workload identifier".
• Much more detail around mTLS, including some normative language.
• WIT (the identity token) is now included in the WPT proof of possession.
• Added a section comparing the DPoP-inspired app-level security option to the Message Signature-based alternative.

draft-ietf-wimse-s2s-protocol-00

• Initial WG draft, an exact copy of draft-sheffer-wimse-s2s-protocol-00
• Added this document history section

Comparing the DPoP Inspired Option with Message Signatures The two workload protection options have different strengths and weaknesses regarding implementation complexity, extensibility, and security. Here is a summary of the main differences between and .

• The DPoP-inspired solution is less HTTP-specific, making it easier to adapt for other protocols beyond HTTP. This flexibility is particularly valuable for asynchronous communication scenarios, such as event-driven systems.
• Message Signatures, on the other hand, benefit from an existing HTTP-specific RFC with some established implementations. This existing groundwork means that this option could be simpler to deploy, to the extent such implementations are available and easily integrated.
• Given that the WIT (Workload Identity Token) is a type of JWT, the DPoP-inspired approach that also uses JWT is less complex and technology-intensive than Message Signatures. In contrast, Message Signatures introduce an additional layer of technology, potentially increasing the complexity of the overall system.
• Message Signatures offer superior integrity protection, particularly by mitigating message modification by middleboxes. See also .
• A key advantage of Message Signatures is that they support response signing. This opens up the possibility for future decisions about whether to make response signing mandatory, allowing for flexibility in the specification and/or in specific deployment scenarios.
• In general, Message Signatures provide greater flexibility compared to the DPoP-inspired approach. Future versions of this specification (and subsequent implementations) can decide whether specific aspects of message signing, such as coverage of particular fields, should be mandatory or optional. Covering more fields will constrain the proof so it cannot be easily reused in another context, which is often a security improvement. The DPoP inspired approach could be designed to include extensibility to sign other fields, but this would make it closer to trying to reinvent Message Signatures.

Acknowledgments The authors would like to thank Pieter Kasselman for his detailed comments, Flemming Andreasen, Kieran Sweeney and Anton Sokolov for their WGLC reviews, as well as Jason Costello, Maartje Eyskens, Radosław Piliszek and kanywst for implementing this draft and sharing their learnings. We thank Daniel Feldman for his contributions to earlier versions of this document. We also thank Arndt Schwenkschuster and Brian Campbell who coauthored the grand unified WIMSE Workload to Workload protocol draft.