Binding is canonicalization — the thumbprint question behind an agenda line
Reading the Draft · No. 25 · Sources cited in this piece · the text the address layer is anchored to, quoted sentence by sentence: draft-li-rttp-iqa-addressing-02 (full text) · series page and revision history: datatracker · the thumbprint specification, quoted verbatim: RFC 7638 (JSON Web Key Thumbprint) · the proof-of-possession specification, quoted verbatim: RFC 9449 (OAuth 2.0 DPoP) · the agenda that posed the question: public-agentprotocol, November 2026 · the series piece this one answers at the address layer: No. 2, canonical or reject · Sister pillars: RTTP (rttp://, CRI 27) · IQA (iqa://, CRI 28)
This week a working group at W3C published the agenda for its next meeting, and two of its lines are one question wearing two coats. One line records a principle everyone repeats and few protocols wire up: an authentication result cannot be passed to a resource server as authorization — the server receives a proof, not a permission. The other asks how a key bound to a decentralized identifier should attach to a proof-of-possession token. Strip the vocabulary and the second question is narrower and older: when two parties must agree that two textual forms are the same key, who decides what the same means? This piece's claim is that the answer decides more than it appears to: binding is canonicalization — every binding mechanism is, at its core, a published decision about canonical form, followed by a hash.
The thumbprint is a canonicalization decision
The oldest widely deployed answer is a 2015 specification of a page and a half. RFC 7638 defines the thumbprint of a JSON Web Key, and almost its entire content is a canonicalization decision. The construction, verbatim: a JSON object “containing only the required members of a JWK representing the key and with no whitespace or line breaks before or after any syntactic elements and with the required members ordered lexicographically by the Unicode code points of the member names.” Required members only — optional metadata is excluded. Lexicographic order — the writer's arrangement is erased. No whitespace — the serializer's taste is erased. What survives is the smallest set of bytes that any two independent implementations must produce identically, and the thumbprint is the SHA-256 of exactly those octets. Everything else about the key — the pretty-printed copy, the reordered one, the annotated one — hashes to nothing, because it was never part of the key.
DPoP makes the decision into a chain
Six years later, RFC 9449 turned that thumbprint into a binding chain. The confirmation member, verbatim: “The value of the jkt member MUST be the base64url encoding ... of the JWK SHA-256 Thumbprint (according to [RFC7638]) of the DPoP public key (in JWK format) to which the access token is bound.” The access token does not carry the key; it carries the digest of the key's canonical form. At the resource server the chain closes with two moves: the proof must present the same key the token is bound to — “check that the public key of the DPoP proof matches the public key to which the access token is bound” — and the standard's sentence is absolute: “The resource server MUST NOT grant access to the resource unless all checks are successful.” The proof itself carries ath, a hash of the access token: binding in the other direction, proof to token, same recipe — hash the canonical bytes, compare. Both ends of the chain are thumbprint equalities, and note what the resource server is actually checking: not whether the caller is authenticated — the issuer already decided that — but whether the proof in front of it is bound to the same canonical bytes the token names. The server receives a proof, not a permission.
The address layer makes the stricter half of the same decision
Our draft makes the same category of decision at a different layer — the address layer — and it makes the stricter half of it. Section 4.2 fixes the canonical form of both schemes, verbatim: “The canonical form is lowercase US-ASCII. Uppercase is invalid input, not a formatting difference: a parser MUST NOT normalise it, because two distinct strings would then map onto one address.” Section 4.4 then derives the routing address from that canonical form alone: canonical_authority = intent . pillar . root (lowercase, US-ASCII), ROUTE_SHARD = SHA-256(ASCII(canonical_authority))[0:16]. The derived address is, structurally, a thumbprint: smallest canonical byte string, hash, truncation. Where RFC 7638 merely defines one canonical object among the possible renderings, the scheme declares every other rendering invalid input — canonical-or-reject, no silent normalisation — because a normalising parser is precisely a parser that lets two distinct strings converge on one address. The series argued this at the address layer in No. 2; the agenda line argues it at the token layer; the two arguments are the same argument.
What the agenda line is really saying
Read from the other end, the agenda's first line — authentication cannot be passed to a resource server as authorization — is the same sentence as the binding rule. What crosses the wire between issuer and server is never the authority itself, only digests of canonical forms: the token is a digest-bound object, the proof is a digest-carrying signature. The receiving side's entire job is to re-derive and compare, and its entire authority is refusal. Binding is not a ceremony performed around the key; it is the canonical-form decision wearing a signature — which is why the decision cannot be left implicit. A scheme that never publishes its canonical form does not have binding; it has hope: two implementations that never agreed on what the same means, exchanging bytes that mean whatever each of them decides.
One line: wherever a protocol binds an identity to bytes, the binding was decided the moment its canonical form was published — RFC 7638 canonicalizes then hashes, RFC 9449 compares thumbprints and MUST NOT grant on mismatch, and the scheme in this series canonicalizes or rejects and hashes the authority into the address: three mechanisms, one shape — the form decides, the hash remembers, the receiver compares.