Review · November 10, 2026
CIMD Software Statement Registration, Putting a Reviewed Client ID Metadata Document Through Dynamic Client Registration
The problem it's solving
The CIMD Software Statement draft lets a third party sign a digest of one exact version of a client's Client ID Metadata Document. That statement carries no metadata, only the digest.
Dynamic Client Registration expects the opposite. A software statement in RFC 7591 carries metadata values that override the request. Hand a digest-only statement to a plain RFC 7591 server and it registers whatever redirect URIs and keys the request contains, none of which anyone reviewed.
This draft defines how an AS registers a client from such a statement. The AS fetches the document, checks the digest, and takes every metadata value from the document. The registration expires with the statement, and the client renews it by sending a newer one.
The stated audience is deployments that want to keep DCR, "for example to assign their own client identifiers or manage registrations under RFC 7592."
How it fits in the working group
It fits the charter. It profiles RFC 7591 and RFC 7592 and extends an adopted WG draft (CIMD) by way of an unadopted individual draft by the same author. It has no meaning without that base draft.
It adds no new role. The statement issuer from the base draft now controls how long a DCR registration lives.
It changes RFC 7591 behavior in three ways. Request metadata is ignored entirely. Registrations expire. The token endpoint and PAR endpoint can modify a registration.
The normative dependencies are CIMD, the base statement draft, and seven RFCs: 6749, 7519, 7591, 7592, 8414, PAR, and the Security BCP.
The wire surface is small: one response member (registration_expires_at), one AS metadata value, and temporarily_unavailable extended to the registration endpoints. Renewal reuses the base draft's software_statement request parameter.
What the mechanism actually does
Registration takes everything from the document. The client sends an RFC 7591 request with the statement in software_statement. The AS validates the statement, fetches the CIMD at the statement's sub, and compares digests. Every registered value comes from the document. Nothing comes from the request, at registration or in any later RFC 7592 update.
The AS assigns its own client_id. It must not reuse the CIMD URL. The same software can then be known at one AS under two identifiers: the URL at runtime and an opaque ID through registration.
The registration expires with the statement. The AS returns registration_expires_at. After that time, authorization, token, PAR, and RFC 7592 update requests are rejected with statement_required. Issued access tokens are not revoked, and the AS should keep the dead registration so it can be restored.
Renewal happens on ordinary requests. The client adds a newer statement from the same issuer to a token request, a PAR request, or an RFC 7592 update. The AS fetches the document again, re-derives all metadata, and swaps the governing statement in one atomic update. The update stands even if the request carrying it is then rejected.
Some documents can't be registered at all. Any custom scheme, loopback, or localhost redirect URI causes rejection. So does a document that permits a shared-secret method. Registration has no "review-only" fallback like the base draft has.
Public clients get one shared registration. It has no credential and no registration access token. A second registration request for the same issuer and URL returns the existing registration. Every grant under it needs PKCE and a DPoP key, as in the base draft.
Required issuers apply here too. If a tenant requires a named issuer for a URL prefix, registrations governed by another issuer's statement stop working in that tenant. The client has to register again.
So why register at all?
This is the question the draft doesn't answer well.
CIMD exists so a client doesn't have to register. The AS in this draft still fetches the CIMD, still checks the digest, and still gets all metadata from the document. The registration adds an AS-assigned client_id and a cached snapshot of the metadata.
The snapshot has one real benefit. In the base draft, every edit to the document breaks new grants until the issuer re-reviews. Here the registration keeps the last reviewed version, and the client keeps working until its statement expires.
The RFC 7592 benefit is thin. Updates can't change metadata. What remains is read, delete, and one of three ways to deliver a renewal.
Significant interoperability concerns
Generic DCR clients will be surprised. A stock RFC 7591 client sends redirect_uris and jwks and gets back a registration that may contain different values. Its registration then expires on a schedule announced in a member it doesn't know about.
Repeated registration has three allowed outcomes. For a confidential client, the AS can reject the request, treat it as idempotent, or create a second registration. A client can't tell which one it will get. An idempotent response can't return the registration access token, so a client that lost its credentials is stuck.
The first registrant wins. Statements are bearer artifacts. Under the suggested default of one registration per issuer and URL, anyone holding a copy can register first, hold the registration access token, and block the real publisher. The draft says so in Section 11.1 and adds "This specification defines no way to displace such a registration."
Renewal doesn't prove who is renewing. An attacker with a stolen client key can renew forever using statements the issuer distributes to every deployment. The draft's advice is to treat compromise as a reason to register again.
The token endpoint now writes to the client registration. A refresh request can change redirect URIs, keys, and scopes for every instance sharing that registration. Concurrent deliveries "resolve to the most recently issued statement." This is new behavior for the token endpoint and needs careful implementation in a clustered AS.
Key rotation has a required order. A client with inline jwks must authenticate with the old key until the replacement is applied, then switch. Retire the old key early and the client can't authenticate the request that would fix it.
The metadata flag says too little. software_statement_registration_supported doesn't say whether the AS registers public clients, supports RFC 7592 renewal, or what its repeated-registration policy is.
PAR support is conditionally mandatory. It is required when a confidential client's grants all need an authorization request or refresh token and RFC 7592 updates aren't offered. That condition is hard for either side to evaluate.
Native and desktop clients are excluded again. Loopback and custom-scheme redirects are rejected outright. Claude Desktop, VS Code, and Cursor can't use this.
Mechanisms that could be removed
- Public client registration (Sections 3.2, most of 3.3). A shared, credential-less registration that any statement holder can fetch is a lookup from CIMD URL to opaque ID. Public clients should use the CIMD URL directly under the base draft.
- Two of the three renewal paths. Token, PAR, and RFC 7592 update each have different rules for an older statement (Table 3). Pick one. The token endpoint path alone covers confidential clients with refresh tokens or client credentials.
- The tenant restriction table (Section 3.1). Five rows on how a replacement changes tenant confinement. This follows from the base draft's
aud_tenantmachinery and could go with it. - Section 7's error mapping. Two pages assigning codes to roughly twenty conditions. Most resolve to
invalid_software_statementorinvalid_client_metadata. - Section 11.4 on observable state. It concludes the disclosures are accepted.
- Section 10. It opens by saying it adds no requirement.
What remains is short: take all metadata from the digest-matched document, never from the request, expire the registration with the statement, and accept a newer statement on a token request. That could be a section of the base draft.
Writing quality
The writing is precise and in correct IETF style. The security considerations are candid, including about the squatting problem the draft leaves open.
At 22 pages it is the shortest of the three documents and the easiest to follow. The five-step processing order in Section 5 is clear.
It can't be read alone. "Current," "effective expiry," "permitted method," "required issuer," and "review-only" are defined in the base draft. Many requirements are stated only as a pointer, such as "apply Section 5.6.2 of [STATEMENT]."
Three small issues. It cites the base draft at -00 when -01 was posted the same day, and it leans on that draft's section numbers throughout. It says withdrawal "requires an extension" without citing the lifecycle companion that exists. It has no informative references section.
The justification for the whole document is one sentence in the introduction. A deployment that wants its own client identifiers could map the URL to an internal ID without any protocol.
Background of the author
Sole author, Karl McGuinness, listed as Independent, formerly at Okta.
The Datatracker profile could not be fetched for this review. The figures below are from the profile as checked for the October reviews, plus what is in the drafts archive.
- 0 published RFCs
- 16 active Internet-Drafts and 2 expired, as of mid-October 2026
- Co-author of ID-JAG, an adopted WG document
Not a new author, and writing at a very high rate. The archive holds 21 distinct individual OAuth drafts under his name. This draft went from -00 to -01 on 2 November, the same day as CIMD -03, to align its authentication method rules with that revision.
Questions worth raising
- Who needs DCR on top of CIMD? The AS fetches and trusts the same document either way. Which deployments can't use the URL as the client identifier, and is that a protocol problem or an implementation detail?
- Should the token endpoint modify a client registration? RFC 7592 exists for that. Using it as the only renewal path would keep the token endpoint read-only with respect to client metadata.
- Is the squatting problem acceptable? A statement that permits registration and leaks gives its holder the registration. Should registration require proof of a key in the reviewed document?
- Is the cached snapshot the real feature? Surviving document edits between reviews is useful. The base draft could get the same result by letting the AS keep the last digest-matched document.
- Does this belong in the base draft? The interoperable core is a few rules. A separate document adds a second identifier for the same client and a second set of error mappings.
For the two drafts this one sits between, read the base statement draft and the lifecycle companion.