HTTP Message Signatures
RFC 9421 · HTTP Signatures · RFC 9421 HTTP Message Signatures
By Boston Identity · Explained · 5 min read
The short answer
HTTP Message Signatures let a sender sign selected parts of a web request or response. A recipient can check who holds the signing key and whether those parts changed, even when the message passes through intermediaries.
- What it is
- A standard
- Defined by
- IETF, RFC 9421 (Standards Track)
- Who it's for
- Teams protecting API traffic through gateways
- In our briefings
- 450by month, last 12
What is HTTP Message Signatures?
HTTP Message Signatures is the mechanism defined in RFC 9421, published by the Internet Engineering Task Force in February 2024. It signs selected parts of a Hypertext Transfer Protocol message, the request or response that web services exchange. A recipient can check the integrity and authenticity of those parts using a key it trusts for that context.§1
That matters when Transport Layer Security (TLS), which protects a network connection, ends at a gateway. A fresh connection from the gateway to the service protects that next leg, but TLS alone cannot give the service end-to-end proof of the original message. Signing at the message layer can protect selected values across that path, provided intermediaries leave those values intact.§1,§7.2.3
The standard is a toolkit. An application must define its required coverage, acceptable algorithms, key retrieval and verification context. It supports both public-key signatures and message authentication codes, where sender and verifier share a secret. The latter also lets the verifier create a valid signature, so the trust assumptions differ.§1.4,§7.3.3
A signature does not encrypt the message. Anyone with access to the message can read its signed values; TLS or an equivalent is still needed to protect information in transit.§7.1.2,§8.2
How does HTTP Message Signatures work?
A sender signs a request and a service verifies it. The selected values and policy checks below illustrate the standard’s signing and verification procedures.§3
Figure steps
- The signer selects its key and coverage
- The signer builds the signature base
- The signer attaches the proof
- The verifier checks the policy and key
- The verifier rebuilds and verifies
- The verifier enforces freshness rules
The verifier reconstructs the signed values from the received request and applies the application’s coverage, key and freshness rules.
Drawn from RFC 9421, sections 2–4 and 7.2.8
Swipe for the full figure →
The signer selects its key and coverage
The sender chooses a signing algorithm and suitable key under the application’s rules. It sets the creation time and, when applicable, an expiry. It chooses an ordered list of message parts to cover. A request signer should cover control data such as the method and destination; the application decides the exact list. Our example covers the method, target address and content digest, a hash of the body.§3.1
The signer builds the signature base
Both parties need the same bytes to check a signature. The sender turns the selected values into a standard text form, called the signature base. This process is canonicalization: rules for representing a value consistently despite some harmless HTTP changes. The final line includes the coverage list and signature parameters, binding the signature to its own metadata. The order must stay fixed.§2.5
The signer attaches the proof
The sender signs those bytes and adds two fields to the message. Signature-Input records the covered components and parameters. Signature carries the signature value. A shared label, such as sig1, pairs the entries. These fields must contain matching labels. The signature sits beside the message rather than wrapping it in a separate signed object.§3.1,§4
The verifier checks the policy and key
The recipient parses the two fields and selects the signature relevant to its application. It checks required coverage and parameters, then obtains the verification key using configuration or the application’s key lookup rules. It must reject a key it does not know or trust for this request. The algorithm must be allowed and fit the key; conflicting algorithm indications make verification fail.§3.2
The verifier rebuilds and verifies
The recipient rebuilds the signature base from the received message and checks the signature with the chosen key and algorithm. If a required signed value has changed, verification fails. When a content digest is covered, the recipient must also check that digest against the actual body: verifying the signed header alone would leave a substituted body undetected.§3.2,§7.2.8
The verifier enforces freshness rules
Any extra application requirements must be enforced during verification. These may include a maximum age, rejecting signatures after expiry, or checking that a nonce, a unique value for one message, has not been used before. A valid cryptographic signature cannot make a failed policy check pass. Which time limits and replay controls apply must come from the application’s rules.§3.2.1
Why does HTTP Message Signatures matter now?
The WIMSE workload-signature draft shows why coverage is an architectural choice: it omits the request authority because proxies rewrite it, and binds the recipient through a mandatory audience parameter instead.1 Its response-signing option can also require the client to reject an unsigned reply.2
Visa’s published Trusted Agent Protocol sample uses RFC 9421 signatures on agent requests, but our reading found no signed consumer mandate or consent record in that sample.3 The Human Continuity draft proposes a separate human-linked signature alongside Web Bot Auth’s agent signature on the same request; the link cannot yet be carried across origins.4 We read these uses as a reason to ask exactly what each signature proves, and whose authority remains outside it.3,4
Where does it fit?
| Compared with | How HTTP Message Signatures differs |
|---|---|
| WIMSE Workload-to-Workload Authentication with HTTP Signatures | The WIMSE draft applies HTTP Message Signatures to workload requests, choosing the signed components and a recipient-binding parameter. RFC 9421 supplies the general mechanism; that draft supplies workload-specific rules.1,§1.4 |
| Transaction Tokens | The WIMSE signature profile covers the Txn-Token header when present, along with its other protected request values. A transaction token can therefore be carried under a message signature rather than replacing that signature.1 |
| Structured Field Values for HTTP | RFC 9421 uses Structured Fields to encode its Signature-Input and Signature dictionaries. That grammar tells implementations how to parse the fields; the signature procedure still needs coverage, keys and cryptographic verification.§4,§3.2 |
What goes wrong?
- Unsigned values remain changeable. A signature can verify while an attacker changes an uncovered field that alters the application’s decision. The application should require enough coverage for its purpose, and the verifier should trust only signed components.§7.2.1
- Fresh does not mean unused. A captured signature can be replayed on a similar request even with sufficient coverage. A nonce lets a verifier detect repeats, and time limits narrow the opportunity. The WIMSE draft requires nonce and time parameters but does not strictly mandate replay protection.§7.2.2,5
- Proxies can break legitimate signatures by changing covered values. Test the actual path and choose coverage deliberately; do not simply remove checks when failures appear. The RFC advises comparing the sender’s and verifier’s signature bases to find unexpected changes.§7.2.3,§7.4.1
- A stolen signing key lets an attacker sign their own messages. Protect keys, plan rotation, and reject keys or algorithms that are inappropriate for the request. Cryptographic validity alone does not establish that the right party signed.§7.3.2,§7.3.4
What should a security leader ask?
- 01
Which method, destination, headers and body digest must every accepted request cover?
- 02
How does the recipient decide that a signing key belongs to a party allowed to make this request?
- 03
Which proxy changes have we tested against the signed values?
- 04
Where are repeated nonces detected across all receiving servers?
- 05
Do tests reject an altered body, missing signature and untrusted key?
Sources
- S1
HTTP Message Signatures (RFC 9421)Internet Engineering Task Force · Standards Track, February 2024
›Evidence: 5 claims from 3 briefings
- 1BI-FIND-2026-0382 · The IETF's stronger workload proof is built for the proxy in the middle, and it still lets a replay throughThe profile's most telling rule is a component it refuses to sign. Section 3 leaves the request's authority out of the signature because 'TLS-terminating proxies and load balancers commonly rewrite the authority', and binds the recipient instead through a mandatory wimse-aud parameter the recipient must check against its own configuration. What is signed is the method, path and query, the content digest when there is a body, and the Authorization, Txn-Token and Workload-Identity-Token headers when present, so a proxy can forward and re-address a call but cannot alter what it asks for. The draft still requires server-authenticated TLS on every hop: what it protects is the integrity of the call through the middle, and an intermediary still sees the identity token and the signature in the clear.
- 2BI-FIND-2026-0383 · The IETF's stronger workload proof is built for the proxy in the middle, and it still lets a replay throughThis is the only proof in the WIMSE set that lets the caller check what came back. Response signing is opportunistic by default, but a request that carries wimse-sign-response set to true turns it into an obligation: section 3.5 says the client 'MUST reject an unsigned response', a signed response must echo the request's nonce in wimse-req-nonce, and a server that must sign but cannot may not return a successful unsigned answer. The proof-token sibling has nothing like it. For a workload calling through a gateway it does not control, this is the difference between knowing the request was delivered intact and knowing the reply was.
- 3BI-FIND-2025-0063 · Visa's published Trusted Agent Protocol is sample code for signed requests, with no consent record or revocationAs published, Trusted Agent Protocol is a README and a five-component sample (agent, merchant front and back end, CDN proxy, agent registry). The agent signs each request with RFC 9421 HTTP message signatures, which the README says are "bound to your domain and the specific operation", and the merchant's proxy checks them against a sample public-key registry; Visa describes no production key directory. Consumer identifiers, payment account references for cards on file, loyalty numbers, email and phone, travel as query parameters "as consented by the consumer", but there is no signed mandate or consent record, no revocation, no agent vetting and no standards route. Mastercard's Verifiable Intent, by contrast, puts the person's signed limits in the credential.
- 4BI-FIND-2026-1153 · World's maker proposes a site-scoped handle for each verified human, and bars using it alone to log anyone inFor AI agents, the draft sets itself beside Web Bot Auth: "Web Bot Auth identifies the agent, and Human Continuity links those requests to the unique human on whose behalf it acts." Both can ride on one request as separate HTTP Message Signatures, each with its own tag. How an agent gets tied to its human is only an example: section 22.7 has a verifier use a separate agent_delegation purpose and keep a table of agent key thumbprints against the person's stored handle, account and an expiry. Delegation across origins is out of scope until a future extension, and an origin MUST NOT make a client obtain or present an artifact for another origin's audience. We read this as letting one site count a person's agents as that one person, with no way yet to carry the link to another site.
- 5BI-FIND-2026-0384 · The IETF's stronger workload proof is built for the proxy in the middle, and it still lets a replay throughThe draft requires the ingredients of replay protection and then declines to require the protection. Every signature must carry created, expires and a random nonce, with expiry 'on the order of minutes', and a message outside its window must be rejected; but the recipient 'MAY maintain a replay cache and SHOULD reject' a nonce it has seen, and section 6.4 states that replay protection 'is not strictly mandated because of implementation considerations'. A captured request replayed to a different member of the same cluster inside the window succeeds. The same posture runs through the proof-token draft and the OAuth attestation draft: freshness is the sender's duty, caching is the receiver's choice.
›In our briefings
The claim each of the newest briefings on HTTP Message Signatures would have you leave with.
Revision -02 of Shankarlingam's draft says the delay before a disabled agent is refused is "a property of the receiver's configuration, not of the token alone", and that passing the receiver's checks does not show a disabled client is refused within the bound the receiver computes. Raising the maximum token age, DNS caching, caching of issuer metadata and keys, or the clock-skew allowance lengthens the time a disabled client is still accepted, while every signature, issuer, client, audience and DNS check keeps passing. Those checks, the draft says, "establish that a token is authentic; they do not establish that the client is still enabled." A receiver SHOULD recompute the bound before any change to those settings takes effect, and SHOULD test it directly, again after any change to those settings: obtain link tokens for a test client, disable it at a time not known to whoever observes the receiver, keep presenting tokens issued before the disable, and compare the last acceptance with the time the authorization server records the disable. The receiver meets its bound if that gap does not exceed the computed delay. It SHOULD also log the maximum age in effect with each verification result, and the security section says receivers SHOULD treat such changes as security relevant. The draft describes this test and reports no results from running it.
A disabled agent's old tokens still pass every check; a DNS draft now asks receivers to time how longBI-FIND-2026-2345
AAuth's premise is that an OAuth client or an API key has no identity of its own and that SPIFFE and WIMSE stop at one trust domain, so it gives each agent one: an identifier of the form aauth:local@domain issued by an Agent Provider and bound to the agent's own signing key by a short-lived agent token (the draft recommends Ed25519, which every party must support), so that 'every agent has its own cryptographic identity' and 'the first API call to a resource is the registration'. No credential in the protocol is a bearer credential; every request is signed, and a resource can challenge for more at any time. In its lightest mode the draft pitches this as a drop-in for API keys: 'this replaces API keys with cryptographic identity.' What an agent token attests about the software behind the key is left to companion specifications.
AAuth gives every agent its own key, then keeps the delegation chain out of the token on purposeBI-FIND-2026-0365
Richer's draft would add another way to bind an OAuth access token to a client's key, beside DPoP and mutual TLS. Its introduction says the work "complements and builds on experience with" those two, and the draft names no gap in either; when to use which is left to an editor's note, and the security and privacy sections are marked TBD. The authors argued for it on the mailing list during the adoption call that closed on 5 October. Paul Bastian cited DPoP shortcomings he had co-presented at the OAuth Security Workshop and TLS that ends at DDoS-protection or corporate proxies. Richer said HTTP Message Signatures (RFC 9421) is now published and widely deployed. Neil Madden, replying to Bastian's workshop slides, suggested summarising some of their rationale in the draft's introduction. Nine people supported adoption, five of them authors, and four objected: Dick Hardt said the group had already solved key binding with DPoP, and Michael Jones and Brian Campbell, two of DPoP's co-authors, said another method would hurt interoperability. The chairs had posted no decision by 12 October.
The OAuth working group split over a token-binding draft that never says what DPoP lacksBI-FIND-2026-0862
›Cited in 45 briefings
Every briefing that discusses this term, newest first.
- A disabled agent's old tokens still pass every check; a DNS draft now asks receivers to time how long
Draft · · IETF Datatracker · Sriram Shankarlingam, HexaEight · Oct 20, 2026
- AAuth gives every agent its own key, then keeps the delegation chain out of the token on purpose
Draft · · IETF Datatracker · Dick Hardt, Hellō · Sep 25, 2026
- The OAuth working group split over a token-binding draft that never says what DPoP lacks
Draft · · IETF Datatracker · Justin Richer et al. · Jul 28, 2026
- Hassan's agent delegation draft now classes granting access as execute, not write
Draft · · IETF Datatracker · Amr Hassan · Oct 22, 2026
- An agent-mandate draft checks who may delegate, and now intends to carry its chain in Asor's format
Draft · · IETF Datatracker · Claudiu Hulea, Braincap SRL · Oct 24, 2026
- WIMSE's agent draft adds how an agent's access ends and where policy engines fit, without a new requirement
Draft · · IETF WIMSE Working Group · Pieter Kasselman et al. · Sep 15, 2026
- WIMSE credentials -03: a valid signature proves trust-domain membership, not which workload is calling
Draft · · IETF Datatracker · Brian Campbell et al. · Jul 2, 2026
- Web Bot Auth's working-group draft names a bot by its key URL and defines no revocation
Draft · · IETF Datatracker · Thibault Meunier et al. · Oct 29, 2026
- Agent URI draft -04 ties an agent's name to a key document and bars OAuth servers from trusting the name alone
Draft · · IETF Datatracker · Yaswanth Narvaneni et al. · Oct 20, 2026
- Agent delegation records not anchored in trusted time become deniable once timestamps can be forged
Draft · · IETF Datatracker · V.K. Uppalapati · Sep 29, 2026
- Drake's agent registry names who may issue an agent's token, and its answer has no signature of its own
Draft · · IETF Datatracker · Christopher Drake, 1id.com · Sep 25, 2026
- One global registry for AI agent identities, and no one allowed to switch an identity off
Draft · · IETF Datatracker · Christopher Drake, 1id.com · Oct 27, 2026
- AAuth carries the signals an agent's approval needs, Hardt says; the brain that decides does not exist yet
Podcast · · Collateral Dialogue · Self-Driving Software: What OAuth Can’t Do for AI Agents | Dick Hardt, Hello · Sep 2, 2026
- Of 30 deployed AI agents, 7 publish how a website can recognize them and one signs its requests
Paper · · arXiv · Leon Staufer et al. · Feb 19, 2026
- The IETF's stronger workload proof is built for the proxy in the middle, and it still leaves replay protection optional
Draft · · IETF Datatracker · Joseph A. Salowey et al. · Oct 20, 2026
- An individual IETF draft takes a workload's role and group out of its name and puts them in separate metadata
Draft · · IETF Datatracker · Shlomo Zalman Heigh et al. · Oct 16, 2026
- Six companies' agent-auth draft, since adopted by the WIMSE group, keeps credentials out of the model's reach
Draft · · IETF Internet-Draft (individual submission, since adopted by the WIMSE working group) · Pieter Kasselman et al. · Jul 6, 2026
- An end-to-end encrypted draft would hide an AI agent's task from the broker, but not who sent it or to whom
Draft · · IETF Datatracker · Hamdy Atakora, Imara Labs · Sep 21, 2026
- World's maker proposes a site-scoped handle for each verified human, and bars using it alone to log anyone in
Draft · · IETF Datatracker · Aurélien Brézun, Tools for Humanity · Aug 6, 2026
- OpenA2A's draft aims to keep secrets from the agent, and says no implementation yet supports its new controls
Draft · · IETF Datatracker · Abdel Fane, OpenA2A · Oct 2, 2026
- Before an agent pays or changes data, Schrock's last check treats it as untrusted and keeps the record itself
Draft · · IETF Datatracker · Iman Schrock, EMILIA Protocol · Sep 26, 2026
- The signing-key draft under AAuth offers eight ways to trust a key, and only one says who the agent works for
Draft · · IETF Datatracker · Dick Hardt et al. · Sep 13, 2026
- TPX replaces an app's embedded AI provider key with a capped, metered grant the user approves at their provider
Article · · tokenpony.dev · Alex Polvi · Jul 20, 2026
- AAuth's bootstrap guide makes device attestation optional and lets a new key mean a new agent
Draft · · IETF Datatracker · Dick Hardt, Hellō · Sep 28, 2026
- DIF's agent spec names every AI agent by a DID; the IETF's Agent Name Service switched to domain names
Article · · Decentralized Identity Foundation (KYA-OS) · Dylan Hobbs et al. · Jul 29, 2026
- Visa's published Trusted Agent Protocol is sample code for signed requests, with no consent record or revocation
Article · · GitHub (visa/trusted-agent-protocol) · Visa · Oct 14, 2025
- Folding every hop's signature into one would stop anyone stripping a signed hop out of an agent's request
Draft · · IETF Datatracker · Tirumaleswar Reddy.K et al. · Sep 28, 2026
- AAuth's R3 lets an agent ask for an API's named operations, and a person approve one exact call
Draft · · IETF Datatracker · Dick Hardt · Sep 28, 2026
- AAuth Events gives an agent an inbox, and the subscription tells the resource which agent is listening
Draft · · IETF Datatracker · Dick Hardt · Sep 28, 2026
- Hardt's AAuth Budgets caps what an agent may spend at each resource, and hides the person's real limit from it
Draft · · IETF Datatracker · Dick Hardt · Sep 28, 2026
- Coetzee's agent token is good for one declared call, and the hard part is hashing that call the same way twice
Draft · · IETF Datatracker · Rudolf Jacobus Coetzee · Jul 19, 2026
- WIMSE mutual TLS -03 ties certificate acceptance to trust-domain anchors
Draft · · IETF Datatracker · Joseph A. Salowey et al. · Jul 6, 2026
- The IETF's simplest workload proof proves the key and leaves the request unprotected, and the draft says so itself
Draft · · IETF Datatracker · Brian Campbell et al. · Aug 27, 2026
- OAuth handles an agent in one company, working while you watch. The OpenID paper says that is where it stops.
Article · · OpenID Foundation · Tobin South et al. · Oct 2025
- A valid delegation chain cannot replace required human approval or proof of key possession
Draft · · IETF Datatracker · Karthik Rampalli, Glyphzero Labs · Jul 6, 2026
- An OAuth draft lets device checks set an app's scopes; a first review found a copied app could reuse the result
Draft · · IETF Datatracker · Efe Kahraman, Mekarge · Jun 9, 2026
- Protocol 427 offers agents a reusable spending allowance, then ties each signed proof to one request
Draft · · IETF Datatracker · John Paul McGraw et al. · May 6, 2026
- A cross-domain agent trust draft requires the call chain, then leaves its format to a version that never came
Draft · · IETF Datatracker · Daniel King et al. · Mar 15, 2026
- An MCP signing draft shows a client who wrote a tool, and admits a poisoned tool can still be validly signed
Draft · · IETF Datatracker · Raza Sharif, CyberSecAI · Mar 14, 2026
- Rosenberg and White's AAuth now has the resource server, not the agent, write and sign the approval text
Draft · · IETF Datatracker · Jonathan Rosenberg et al. · Oct 20, 2025
- WIMSE leaves its application proof choice open, with different integrity coverage
Draft · · IETF Datatracker · Brian Campbell et al. · Oct 16, 2025
- In GNAP (RFC 9635), a client is known by its key, and tokens stay key-bound unless the server flags them bearer
Article · · RFC Editor · Justin Richer et al. · Oct 1, 2024
- In May 2023, Parecki described OAuth 2.1 as consolidation and DPoP as token protection
Video · · Identiverse - A CRA Resource · Jun 17, 2024
- A Content-Digest header can show a body arrived intact, not who sent it; RFC 9530 points to TLS or a signature for that
Article · · RFC Editor · Roberto Polli et al. · Feb 1, 2024
- A valid RFC 9421 signature does not prove who signed; key and algorithm checks are left to each profile
Article · · RFC Editor · Annabelle Backman et al. · Feb 1, 2024
Related terms
What appears alongside HTTP Message Signatures in the same briefings.
AAuth (Hardt)WIMSE Workload Proof TokenAttenuated Delegation Profile for Automated AgentsChatGPT AgentAI Agent IndexProof of possessionWIMSEDigest Fields (RFC 9530)
Was this explainer useful?
Share this explainer
Pass it on. Every claim has a permanent number, so what you share today still points at the same words next year.