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

Review · November 10, 2026

CIMD Software Statements, a Third-Party Review Pinned to the Exact Bytes of a Client's Metadata

draft-mcguinness-oauth-cimd-sw-stmt -01View on Datatracker →

The problem it's solving

A Client ID Metadata Document is self-asserted. The client publishes its own metadata at a URL and can change it at any time. An AS that allowlists the URL knows who the client is. It has no record of which redirect URIs, keys, and scopes someone actually reviewed.

This draft lets a third party sign off on one specific version of the document. The issuer puts a SHA-256 digest of the document's exact bytes in a signed JWT. Any AS that trusts that issuer can check the live document against the digest before admitting the client.

The target is deployments where someone other than the client decides which software can connect. Examples are a marketplace or registry vouching for clients at authorization servers it doesn't run, or an enterprise approving a hosted client for use at its SaaS vendors.

How it fits in the working group

It fits the charter. It extends an adopted WG draft (CIMD) and reuses the software statement from Dynamic Client Registration. CIMD Section 4.3 already says software statements may be used and leaves the details open. This draft is the profile for that.

It does not add a new role to the protocol flow. The statement issuer is never in the request path. It does add a new trust relationship: the AS is configured out of band with issuers whose reviews it accepts, for which client URL prefixes, and for which tenants.

The normative dependencies are CIMD, ID-JAG (only for the aud_tenant claim), seven OAuth RFCs including PAR, DPoP, and PKCE, plus the usual JWT and JOSE set.

The new surface area is moderate: one request parameter, two JWT claims, one client metadata member, three AS metadata values, one error code, and one media type. It also asks IANA to extend temporarily_unavailable to the token and PAR endpoints.

This is one of three documents. Registration through DCR and statement lifecycle (withdrawal, supersession, re-checking on refresh) are in companion drafts by the same author. How a client obtains a statement is out of scope everywhere.

What the mechanism actually does

The statement is a small JWT. It has iss, sub (the CIMD URL), iat, exp, jti, and cimd_digest. Optional aud and aud_tenant restrict where it applies. It carries no client metadata. The reviewed document is the only source of metadata.

The client delivers it one of two ways. It can send a software_statement parameter in a token request or a pushed authorization request. Or it can publish its statements at a software_statements_uri named in its CIMD, and an AS that supports pulling fetches them. Presenting is mandatory for the AS to support. Pulling is optional.

The AS validates against configured trust. Issuers and their keys are configured out of band. The AS fetches the CIMD, hashes it, and compares. On a mismatch it rejects, or falls back to its policy for unreviewed CIMD clients.

The AS then binds the presenter to the document. A confidential client must authenticate with a key the reviewed document carries, such as private_key_jwt. A public client must use PKCE and bind a DPoP key.

Some statements count for nothing. If the reviewed document has any redirect URI another app on the device could claim (a custom scheme, loopback, or localhost), every statement over it is "review-only." The AS treats the client as if it had no statement.

The AS can require a specific issuer. A tenant can be configured so that clients under a URL prefix are only admitted with a current statement from a named issuer. This is the enterprise allowlist case.

The statement is checked once, when the grant opens. Refresh checks the key is still in the document. It does not re-check the statement or the digest. Expiry of a statement ends nothing already issued.

So who can actually use this?

Server-hosted confidential clients. That is where the binding holds: the issuer reviewed a document, the document carries a key, the client proves that key.

Most CIMD clients in the field today are not that. Desktop MCP clients like Claude Desktop, VS Code, and Cursor use loopback or custom-scheme redirects. Under this draft their statements are review-only. If a tenant configures a required issuer covering them, they are excluded from that tenant outright.

Public clients with https redirects get a weaker deal. They need PAR and DPoP to present a statement, and the draft says plainly that the binding "does not hold against a party that controls the user agent." Anyone holding a copy of the statement can open a grant under the reviewed client's name with their own account.

The draft is honest about all of this. Table 2 in the security considerations lists what admission does and does not establish. The practical result is that the mechanism serves backend agents and web apps, and defers the desktop and mobile population to a future attested-key extension built on Attestation-Based Client Authentication.

Significant interoperability concerns

Every document change causes a gap. The digest covers exact bytes, including whitespace. The draft notes that a changed document is always served before a statement over it exists. Under a required issuer, new grants fail from the moment the client deploys a change until the issuer re-reviews. Rotating an inline jwks key or fixing a typo in client_name triggers this.

Clients can't know which delivery mode to use. A client that only publishes works only at servers that advertise software_statement_pull_supported. A client that presents in a redirect flow needs the AS to support PAR. A client that wants to work everywhere does both.

The parameter name collides with CIMD. CIMD allows a software_statement member inside the document. This draft forbids consuming one from there, since a statement can't contain a digest of the document it sits in. The same name now means three things: the RFC 7591 registration member, the CIMD member, and this request parameter.

Issuance is undefined. Nothing says how a client asks a marketplace or an enterprise IdP for a statement, or how the issuer learns the document changed. Two issuers will build two APIs. The acknowledgments say an issuance draft existed and this was split from it.

Tenant handling depends on the AS's internal model. aud_tenant, issuer-confined-to-tenant, and required-issuer-per-tenant rules run through validation. The draft admits that neither the client nor the issuer can verify the server honored them.

Byte-exact retrieval is fragile across fetchers. The issuer and every AS must receive identical bytes. A client host that varies its response by user agent, region, or CDN edge breaks the comparison with no useful error for the client.

The statement format itself is tightly specified. Two implementations will agree on what a valid statement is.

Mechanisms that could be removed

  • The public client path. PAR plus DPoP plus PKCE, for a binding the draft says a statement holder can defeat. Start with confidential clients and add public clients alongside the attested-key extension.
  • Review-only as a defined state. Without the public client path, this collapses to "the AS ignores statements for documents it can't bind."
  • The tenant machinery. aud_tenant could be left to ID-JAG deployments or a later extension. A single-audience aud covers most cases.
  • statement_uses. Its only other value belongs to the companion registration draft.
  • Section 6's error mapping. Four pages assign an ordered error code to each failure. One new error code and a short table would do.
  • "Establishment" and most of Section 5.7. This is AS-internal bookkeeping. The interoperable part is two rules: code redemption and refresh must prove the same key, and the key must still be in the document.
  • Sections 11 and 12. Both open by saying they add no requirement.
  • One of the two delivery modes. Pull is closest to how CIMD already works and needs nothing from the client at request time. Presenting keeps a sensitive aud private. The WG should pick the default and justify the other.

What remains is the statement format, the digest rule, out-of-band issuer trust with a dedicated key set, and the confidential-client key binding. That is a 15-page document.

Writing quality

The writing is precise and in correct IETF style. Requirements are stated once and cross-referenced. The security considerations are unusually candid about what the mechanism does not prove. The example includes a real digest over a stated 287-octet document, which implementers can test against.

It is dense. There are eleven defined terms, including Establishment, Proven Key, Permitted Method, Selected Method, Effective Expiry, and Review-Only. Most paragraphs point to three other sections. Reading Section 5 requires holding the binding table in 5.5.2, the model selection in 5.6, and the exceptions in 5.6.3 at once.

At 44 pages it is long for a JWT profile with one new claim that matters. Much of the length is edge-case closure, such as 304 handling with strong entity tags and duplicate JSON member names.

Two small issues. It cites the registration companion at -00 when -01 was posted the same day. It lists statement lifecycle as an extension point without citing the lifecycle companion that exists.

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 now holds 21 distinct individual OAuth drafts under his name, including this three-document family posted on 2 November, the same day as CIMD -03.

Questions worth raising

  1. Is byte-exact the right binding? It's simple and unambiguous. It also turns every cosmetic change into a re-review and an admission gap. A digest over a canonical form, or over named members, would survive more changes. The draft lists partial review as a future extension.
  2. Should the WG take this before there's an answer for native and desktop clients? The largest CIMD population gets nothing from this draft and is locked out when a required issuer is configured.
  3. Where does this overlap with ID-JAG? For the enterprise case, the IdP can already refuse to issue an assertion for a client it hasn't approved. Section 10.2 says a statement serves when the issuer isn't in the request path. Is that case common enough to justify a second mechanism?
  4. Can it work without an issuance protocol? A marketplace can't offer this to clients without one, and the gap after each document change depends entirely on how fast re-issuance is.
  5. Does this belong in the CIMD document's Section 4.3, or should CIMD drop the software_statement member? The two documents currently give the same name to different things.
  6. Is one document reviewable without the other two? Grants outlive statements here by design. Whether that is acceptable depends on the lifecycle companion.

For the pieces this draft defers, read the registration and lifecycle companions.