AICENT.COM
← Back to Blog

Binding is canonicalization — the thumbprint question behind an agenda line

2026-11-16 · RTTP · IQA
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.

RFC 7638 · 9449 · the binding chainevery arrow is a decision about canonical form; every box after the hash is an equality over digeststhe keytwo textual forms · same keycanonical formrequired members · lexicographic · no whitespaceSHA-256of the UTF-8 octetsthumbprintcnf.jkt in the tokenat the resource serverproof presents the key → re-derive the thumbprint → compare with cnf.jktmismatch → MUST NOT grant access unless all checks are successfulthe token never carries the key · it carries a digest of the key’s canonical form · the server verifies a binding, and a binding is an equality over canonical bytes
Figure 1: the binding chain. The key's textual forms collapse into one canonical object, the object hashes into a thumbprint, the thumbprint rides in the token, and the resource server closes the chain by re-deriving and comparing — refusing rather than granting on mismatch.

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.

two layers · one shapetoken-layer binding and address-layer derivation are the same decision at different altitudestoken layer · RFC 7638 + 9449canonicalize key → hash → cnf.jkt → compare at RS → refuse on mismatchaddress layer · draft §4.2 + §4.4canonical-or-reject → hash authority → ROUTE_SHARD is the addressthe shared shapecanonical form first · hash second · equality at the receiver · refusal on divergenceuppercase inputinvalid, not normalised — two distinct strings must not map onto one addressproof key ≠ bound keyno access — the server receives a proof, not a permissionwhat crosses the wire is never the authority itself · only a digest of its canonical form · the receiver’s whole job is to re-derive and compare
Figure 2: the same decision at two altitudes. The token layer canonicalizes the key and compares thumbprints; the address layer canonicalizes the authority and rejects non-canonical input at the parser. Both refuse the middle ground where implementations each decide what "the same" means.

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.

SEALED rttp://72b2a5a2.blog.aicent · iqa://72b2a5a21b13c51e80a4eb4340d31752.forge.iqa · seal record