The Scope Creep Automated reviews of new AI-related working group submissions

Review · November 20, 2026

Authenticated Provenance for WIMSE Delegation Chains

draft-reddy-wimse-aggregate-signatures -01View on Datatracker →

The Problem

A WIMSE HTTP signature authenticates one workload to the next workload. It says nothing about the workloads further back in the chain.

This draft wants the destination to see every workload that handled a request, and to know which ones changed it. The motivating case is agents handing sub-tasks to other agents, where the path is picked at runtime and nobody downstream knows what to expect.

How It Fits In

This is an extension of WIMSE Workload-to-Workload Authentication with HTTP Signatures, which is itself a profile of RFC 9421. The base draft explicitly leaves re-signing at intermediaries out of scope. This draft fills that gap.

The WIMSE charter names multi-hop context as a challenge, so the topic is in scope. Authorization is declared out of scope and left to OAuth.

It depends on three WIMSE drafts (architecture, workload credentials, HTTP signatures), RFC 9421, RFC 9530 Digest Fields, and the CFRG BLS signatures draft. It has no OAuth dependencies.

It adds a fair amount of new surface:

  • Two new HTTP fields, Signature-Aggregate and Workload-Identity-Tokens
  • Four new signature parameters: wimse-req-digest, wimse-resp-digest, wimse-req-path, wimse-req-query
  • A new tag value, wimse-delegation-chain, which sidesteps the base draft's rule to reject messages with more than one WIMSE signature
  • An override of the RFC 9421 requirement that Signature-Input and Signature carry the same labels

That last one changes HTTP Message Signatures behavior, so expect HTTPBIS to have opinions.

It is also not alone. draft-asor-wimse-agent-delegation-chain and several other individual drafts are chasing the same multi-hop problem with tokens instead of signatures.

Summary

There are two mechanisms.

Lineage digests. Every hop signs the digest of the body it received and the digest of the body it sent. The destination walks the chain and checks that each hop's output matches the next hop's input. A change shows up as belonging to the hop that signed for it. A change nobody signed for causes rejection.

Aggregate signature. Each hop folds its signature into one running value instead of appending its own. The destination verifies that one value against every hop's key and signature base. Individual signatures never travel alone, so a later party can't subtract one out.

Each hop's WIT rides along in a dictionary header keyed by signature label. Each hop also copies its own path and query into signature parameters, because later hops overwrite the real ones.

Responses work the same way in reverse.

So what does the aggregate add over the digests? One thing. It stops someone from erasing a hop that signed and forwarded the body unchanged. The draft is upfront about this in Appendix A.

Interoperability Concerns

Nothing can be implemented today. The only candidate algorithm is BLS, and the draft says its WIT algorithm identifier "will be defined in a separate specification." The BLS draft itself is still an unfinished CFRG document, cited normatively.

Every hop must use the same algorithm. A WIT carries one key. A workload that joins a chain needs a BLS key in its WIT, which means BLS for all its WIMSE signatures or a second WIT. Chains that cross trust domains make this harder.

The fallback mode has no wire format. Without an aggregate-capable algorithm, the draft says the chain "falls back to individual per-hop signatures." It never says how those are carried. The post-quantum case lands here, since ML-DSA doesn't aggregate.

Verification rules for earlier hops are missing. The base draft requires signatures to expire in minutes and requires the recipient to match wimse-aud. Earlier hops' entries were addressed to someone else and may have expired by the time a slow agent chain reaches the destination. The draft doesn't say what the destination does with either. The verification procedure only appears as prose around the example.

Authorization and Txn-Token aren't preserved. The base draft requires signing those headers when present. They change at every hop when each agent uses its own access token. The destination can't rebuild an earlier hop's signature base without the old values.

Method and content type can't change. A hop that receives a POST and delegates with a GET breaks the chain. That is a tight constraint for agents calling tools.

Fan-out breaks the response chain. An orchestrator that merges several responses marks its output as origin. The caller gets no in-band proof of who contributed, which is the common agent pattern.

Small things. Hops are told to check "each earlier hop's signature," which isn't possible with only an aggregate. Bodyless requests have no digest to chain.

Is the Aggregate Worth It?

The digests and the dictionary of WITs do most of the work. They are plain RFC 9421 with a few extra parameters.

The aggregate brings a new header, a pairing-based algorithm, the same-algorithm rule, and all-or-nothing verification where one bad hop fails the chain and the verifier can't tell which. The attack it stops is narrow: a downstream hop hiding an honest upstream hop that changed nothing.

The protection also has limits the draft doesn't discuss. The first hop's "aggregate" is just its own signature, sent in the clear to the second hop. Anyone who sees two consecutive messages can subtract and recover an individual signature.

A simpler option deserves a comparison. Each hop already signs wimse-aud, naming the next recipient. If the destination can map that to the next signer's identity, a stripped hop leaves a visible gap with ordinary signatures.

The size argument is weak for now. The aggregate saves one signature per hop. The WITs and Signature-Input entries still grow with every hop and are far larger. The draft admits this. "Verified in a single operation" also undersells the cost, since BLS verification over distinct messages still does work per hop.

My suggestion is to split the draft. Lineage digests and multi-WIT carriage could ship on today's algorithms. Aggregation could follow as an optional extension once an algorithm identifier exists.

Writing Quality

The writing is clear and well organized. It uses standard IETF structure and language, and the worked example with reconstructed signature bases is helpful.

It is honest about its limits. The trade-offs section and Appendix A say plainly what the mechanism does not do.

The weakness is thin normative text. There are few MUSTs, and no step-by-step signing or verification algorithm. The introduction states the base draft's limitation three times and could be cut by half.

The title says "delegation chain," but nothing is delegated here. This records the message path. Authority is out of scope.

Authors

Tirumaleswar Reddy.K (Nokia) has 39 RFCs since 2014, mostly in security, DNS, and DDoS signaling. He has 50 active drafts, heavy on post-quantum work, including two other WIMSE individual drafts. Very active writer.

Hannes Tschofenig (University of the Bundeswehr Munich) has 99 RFCs going back to 2005, including the Device Authorization Grant, Resource Indicators, and DTLS 1.3. He chairs the OAuth working group, co-authors the WIMSE architecture draft, and has 36 active drafts.

Yaron Sheffer (Intuit) has 15 RFCs, including the JWT BCP and the TLS recommendations. He has 11 active drafts and co-authors both WIMSE drafts this one extends: HTTP signatures and workload credentials.

This is an experienced author team, and one of them owns the base spec. The gaps above read as early-draft gaps, not inexperience.