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

Review · August 26, 2026

SCIM DID/VC Binding Extension

draft-kushwaha-scim-didvc-binding -01View on Datatracker →

draft-kushwaha-scim-didvc-binding-01, Saurabh Kushwaha (Oracle), submitted 24 August 2026. SCIM working group, intended status Standards Track. 45 pages.

The Problem Statement

An employee gets a verifiable employment credential. It lives in their wallet. They present it to a partner portal, a supplier, a customer. The company issued it but doesn't hold it and can't take it back.

Then the employee leaves. HR flips active to false in the HR system, SCIM deprovisions the downstream apps, and the credential in the wallet keeps verifying until it expires or somebody remembers to tell the issuer to revoke it.

That gap is the problem. SCIM knows the account state. The credential status list is what verifiers actually check. Nothing connects them.

The draft's framing is broader than that, and the abstract leads with schema. But the schema is the smaller half of the document. The real content is Sections 4.5 through 4.7: a classification model for deciding which SCIM attribute changes invalidate which credential claims, and a required procedure that fires when they do. Read it as "account lifecycle events drive credential revocation" rather than "DIDs in SCIM."

How the Spec Fits In

Three IANA registrations, one new resource type, one state machine.

  • A read-only User extension (primaryDid, bindingState, bindingRefs) so you can find bound users without a second query
  • A new IdentityBinding resource at /IdentityBindings holding the actual linkage, DID references, credential references, and lifecycle state
  • A ServiceProviderConfig extension for capability discovery

Normative dependencies: RFC 7643, RFC 7644, RFC 8259, BCP 14, RFC 9967, plus two W3C Recommendations: DID Core 1.0 and VC Data Model 2.0. RFC 9865 is informative.

Two structural facts matter more than the count.

The W3C dependency is the thing the WG has to decide about first. DID Core 1.0 became a W3C Recommendation in 2022 after the Director overruled formal objections, several of which were specifically about DID method proliferation and the absence of an interoperability story. The IETF has no consensus position on DIDs. This draft takes a normative dependency on that spec and its method registry. That is a working group scope question, not a technical review question, and it should get answered before anyone argues about attribute names.

The SCIM service provider gets two new jobs it doesn't have today. It becomes a verifiable credential verifier, or the thing that delegates to one and owns the result. And it becomes the component responsible for notifying credential issuers when accounts change. Section 4.7 step 6 is a MUST. No SCIM service provider does this now. Appendix D says IGA platforms are the natural clients, which implies the provider is the directory or IdP rather than a target application, but the document never says that out loud. It should, because it changes who has to build all of this.

On charter fit: this is the weakest of the author's four drafts. The closest hooks are "Updates to account state for capturing context of the state or change in state of the users account" and "Profiling SCIM relationships with other identity-centric protocols," and that second item names OAuth 2.0, OpenID Connect, Shared Signals, and FastFed. DIDs and VCs aren't on the list. The charter also says the WG "will consider publishing extensions to SCIM that have found broad adoption." This one has none. Compare that to the cursor pagination draft, which sits on an explicit charter line.

One naming problem worth fixing early. IdentityBinding is a brand new resource type, but its base schema is registered as urn:ietf:params:scim:schemas:extension:didvc:2.0:IdentityBinding. It isn't an extension. It doesn't extend anything. RFC 9944 registers its two new resource types as core:2.0:Device and core:2.0:EndpointApp, and draft-wzdk-scim-agent-resource uses core:2.0:Agent. This should be urn:ietf:params:scim:schemas:core:2.0:IdentityBinding. The other two URNs in the draft are genuine extensions and are named correctly.

High-Level Summary

Start with what a binding record holds. It points at one SCIM User. It lists one or more DIDs with their roles (primary, pairwise, delegated, recovery) and per-DID verification status. It lists credential references: issuer, types, status pointer, validity window. Critically, each credential entry also declares which SCIM attributes its claims came from, in boundSourceAttributes.

That last field is what makes the propagation work. If the credential claims "works in Engineering," the entry says that claim came from the enterprise department attribute. Now a change to department is a computable event rather than a judgment call.

Then a policy decides what a change means. Three options per credential. strict treats any change to any bound attribute as invalidating. role-sensitive (the default) only reacts to role, group, employment status, and entitlement changes, so a new phone number doesn't nuke an employment credential. advisory records the signal and revokes nothing, leaving the decision to an operator.

Partial revocation is the best idea in the document. Whole-credential revocation is the wrong hammer when an employee transfers departments. The "is an employee" claim is still true. Only the department claim went stale. The draft gives three ways to handle that: per-claim status references, reissuance with just the still-true claims, or a server-recorded list of revoked claims for credentials that can't be split. That is real thinking about a real operational problem, and I haven't seen it addressed anywhere else in the identity standards space.

When something does change, a defined procedure runs. Find every active or suspended binding for that user. Recompute the fingerprint. Classify per credential. Apply the policy. Emit a SCIM event per RFC 9967. Notify the issuer. Section 4.7.1 extends this to group operations, including transitive expansion of nested groups, because credentials that claim group membership break when the group changes rather than when the user does.

So what should a leader take away? The design instinct is right and the specific problem is one enterprises will hit the moment they issue their first workforce credential. Three things stand in the way.

The verification step is out of scope, and it's the step that matters. A client POSTs a binding. The server is supposed to verify the client controls the DID before activating. How the client proves that control is explicitly not defined, and there is no attribute anywhere in the schema to carry a proof, a presentation, or a challenge response. Section 8.4 tells implementers to go adopt something and cites OID4VP and DIF Presentation Exchange as suggestions. Meanwhile Section 8.2.1 states binding integrity as a security property the protocol provides, including "demonstrated control over the DID." It can't provide that. The mechanism isn't there. In practice, the only outcome a conformant client can produce from a conformant request is a binding stuck in pending.

Revocation is terminal, and account deactivation forces it. Section 4.4 says revoked is terminal and servers MUST NOT move a revoked binding back to any other state. Section 4.7 step 4 says that if the User is deactivated, the binding MUST transition to revoked. Put those together. An employee goes on parental leave and HR deactivates the account. Every DID binding is permanently destroyed. Every credential is revoked. When they come back, they need a new binding resource and a full reissuance of everything. Same for an account suspended pending an investigation that clears them. Same for an HR sync that misfires for ten minutes. The draft has a suspended state and uses it for "the DID resolver was unreachable," which is a much less consequential situation than "this person is temporarily not working here."

The requirements land on a component that usually can't meet them. Notify the issuer. Update per-claim status references. Revoke credentials. In most deployments the SCIM service provider is a target application. It has no relationship with a credential issuer. Even when the provider is the IdP, "notify the issuer out of band, mechanism unspecified" is not a conformance criterion anyone can test. This is the same layering problem as the author's agent governance draft, where token revocation requirements landed on a provisioning schema. It's becoming a pattern in this author's work and it's worth naming as a pattern rather than fixing four times.

Significant Interoperability Concerns

Short version: everything about reading and querying binding state is specified well enough to interoperate. Nothing about establishing a binding is.

There is no defined path to an active binding. Covered above, and it's the blocker. Section 4.1 says the server MUST create the resource in pending "unless synchronous validation has already succeeded," which raises the obvious question of how synchronous validation could succeed from a POST body with nowhere to put a proof. Every deployment will invent its own out-of-band channel, and no client will port between two of them.

bindingState has no derivation algorithm. Section 3.1 says the server MUST derive all three User extension attributes from the binding resources. Section 3.1.1 then specifies the algorithm for primaryDid only. Take a user with one active binding and one revoked binding. What is bindingState? Nothing in the document says. Two servers will answer differently, and bindingState is the required attribute that clients are meant to filter on.

The default material change policy has deployment-defined semantics. role-sensitive is the default, and Section 4.5.2 requires the server to document which attribute paths count as role-related. So the default value of the attribute that decides whether credentials get revoked means whatever each deployment says it means. Two providers, same binding, same credential, same declared policy, opposite behavior. Section 4.5.3's example table helps, and it's explicitly labeled deployment-dependent.

materialChangeMask can't be used by anyone. It's server-computed, exposed to clients as read-only, and Section 4.5.1 says servers MUST NOT expose how it's computed. So a client can compare it to a value it read earlier and learn that some bound attribute changed, without learning which. SCIM already has meta.version and meta.lastModified for change detection, and Section 4.7 step 5 already emits an event that carries the actual classification. The mask is server-internal state that got promoted into the wire format.

claim-scoped partial revocation has no credential-format binding. Section 4.6.1 defines the mode, and then says credential formats for per-claim status are out of scope, with a pointer at Bitstring Status List and SD-JWT as things implementers "SHOULD consult." So a client can discover the mode is supported, select it, and still have no idea what will happen. This is the mode used in the draft's own example in Appendix B.2.

Section 4.6.2 has MUSTs pointing at values that don't exist. The server MUST record the prior credential reference as historical "using the relationship=historical indicator if defined by the deployment's credentials sub-attribute extensions." historical is not in any enumeration in this document, and relationship is a dids sub-attribute, not a credentials one. The same paragraph says the server MUST set the prior entry's status to "pending revocation," which is also not one of the five values credentials.status can take, by recording it in the free-text statusReason. A normative requirement whose satisfaction depends on a deployment-defined extension is not a requirement.

The claim-flag mode has no reader. Section 4.6.3 says a verifier that consults the binding sees claim-level state, and a verifier that consults only the credential's status reference doesn't. That's an accurate description of the mechanism's weakness, but it skips the harder question: how does a verifier consult the binding? Verifiers are relying parties out in the world. /IdentityBindings sits behind SCIM authorization, and Section 9 requires access be restricted to authorized clients. There is no read path here for the party the mechanism is designed to inform.

The group cascade has no scale bound. Section 4.7.1 requires transitive expansion of nested groups, propagation per affected member, completion within the published interval, and a delayed-cascade event when that's impossible. Remove 50,000 people from a group and that's 50,000 propagation runs, each recomputing fingerprints per credential and potentially notifying issuers. The draft says the cascade is classification-driven to bound the blast radius, which is true of the revocations but not of the work. And propagationIntervalSeconds is one number for the whole provider, so it has to be sized for the worst case, which makes it close to useless as the risk signal Section 3.4 says relying parties can use it for.

Section 5.1 invents a partial filter dialect. MUST support eq on seven attributes, MUST support co and pr on two, MUST support and, and or and not are OPTIONAL. RFC 7644 already defines filtering and ServiceProviderConfig already advertises what a provider supports. A per-resource-type mandatory subset with optional boolean operators produces a filter language that neither matches RFC 7644 nor is discoverable.

Two vocabularies use pairwise to mean different things. correlationModel=pairwise is a privacy declaration about reuse across relying parties. dids.relationship=pairwise is a functional role for one DID inside the binding. Section 3.3 is an entire section explaining that these are not redundant, and it works, but needing a section to explain that identically-named values mean different things is the signal to rename one of them.

Mechanisms That Could Be Removed

Forty-five pages and about 13,000 words to define three schema URNs and one state machine. The -00 was 76KB, this revision is 114KB. It grew 50% in one revision.

materialChangeMask. Server-internal, uninterpretable by clients, duplicated by ETags for change detection and by the Section 4.7 event for classification. Cutting it also removes an error condition and a MUST NOT about algorithm disclosure.

partialRevocationMode=claim-flag. The draft concedes it's the weakest of the three, and its intended consumer has no way to reach the data. Keep the concept in security considerations as a note about credentials that can't be split. Drop the mode from the enumeration.

Section 8.2's "Precisely:" restatements. The five named security properties are a good idea and the informal statements are useful. The pseudo-formal versions restate requirements already in Sections 3 and 4 in notation that doesn't support any analysis the document actually performs. And 8.2.1's version asserts a fact about the past that the spec's own scope decisions make impossible. Keep the names and the informal statements, cut the formalism.

The mandatory filter matrix in Section 5.1. Replace with: filtering follows RFC 7644, and providers SHOULD support filtering on these attributes. The list is a useful implementation note. It's not interoperability content once ServiceProviderConfig already advertises filter support.

Appendix D should stay exactly where it is. It's the best section in the document. Four paragraphs on how this relates to credential status lists, CAEP and RISC, OAuth token introspection, and IGA platforms, and the token introspection comparison is genuinely clarifying: a verifier holding a presented credential has no introspection endpoint, and this record is where an equivalent freshness signal would come from. That paragraph explains the draft's purpose better than the abstract does. Consider promoting some of it into Section 1.

Split the document. The single biggest improvement available. The schema (Sections 3, 5, 7, appendices) is one deliverable. The lifecycle-to-revocation propagation model (Sections 4.5, 4.6, 4.7) is a different and more interesting one. Right now the more interesting half is buried in the middle of a 45-page schema document, and nobody reviewing schema attributes is going to give Section 4.6 the attention it deserves. Two documents at 20 pages each would each get reviewed.

Writing Quality

The prose is competent IETF prose. BCP 14 keywords are used correctly and consistently. Sentences are well formed. Tables are properly built with captions. Terminology is inherited from the referenced specs rather than redefined. Normative and informative references are split correctly with full citations. The examples in Appendix B are realistic and consistent with the schema. Section 9 on privacy is substantive rather than boilerplate: it cites the specific correlation warnings in DID Core and VC Data Model 2.0, correctly identifies that credentials.holder and credentialSubjectId make the SCIM server a correlation point that partially defeats pairwise DIDs, and says plainly that the provider is a correlation point even when everything is done right. That section is better than most.

Section 3 gets the "deliberately not unified" decision on the three status vocabularies right, and says so up front rather than letting a reviewer discover the inconsistency and file it as a bug. Good instinct.

Then there's the document history, which has a problem worth mentioning because of what it signals. This is revision -01. Datatracker shows -00 and -01 and nothing else. Appendix E contains two changelogs: "Changes Since -01" and "Changes Since -00." The first one says it makes "the capabilities introduced in -01 discoverable." So the -02 content got submitted as -01, or the author has been accumulating changes faster than the revision numbering. Either way it's the same signal as the 50% growth: features are being added faster than a working group can absorb them.

Smaller items:

  • The header says Standards Track. Datatracker's intended status field is empty. Worth setting.
  • Section 4.6.2 uses "pending revocation" as if it were a status value.
  • Acknowledgments say feedback will be credited "in future revisions," so no reviewers are named yet.
  • Section 8.7 on DID method classes is a genuinely good addition. The observation that did:key cannot be deactivated, so revocation has to run entirely through SCIM state and credential status, is the kind of thing that only shows up when someone has thought about deployment.

On concision: the ideas fit in about 22 pages, or two documents of 20. The excess isn't padding. It's mechanism, which is the harder problem, because you can't cut it without cutting features.

Background of the Author

Saurabh Kushwaha (Oracle Corporation). 0 RFCs, 4 active Internet-Drafts, 0 expired. No IETF group roles. New author, and currently the most prolific individual contributor to the SCIM working group.

All four drafts are SCIM:

  • draft-kushwaha-scim-didvc-binding (this one, at -01)
  • draft-kushwaha-scim-agent-governance
  • draft-kushwaha-scim-tenant-resource
  • draft-kushwaha-scim-attr-cursor-pagination

This is the largest of the four by a wide margin. At 114KB it's bigger than the other three combined, and bigger than any adopted SCIM working group draft.

The contrast with the agent governance draft is the useful signal. That one credits Danny Zollner and Pamela Dingle for specific feedback, has an explicit "Out of Scope" section recording four attributes that were cut and why, and got smaller in response to review. This draft names no reviewers, has no cut list, and grew 50% between revisions. Same author, opposite trajectory. The agent draft demonstrates the author can take scope feedback and act on it, which is the strongest argument for engaging on this one in detail rather than just pointing at the page count.

Affiliation is Oracle and the email is an Oracle address, unlike the agent governance draft's personal Gmail. Sole author, so this doesn't carry co-author review, and there's no evidence yet of list feedback shaping it.

Suggested Feedback

Ask the charter question before the technical ones. Does the SCIM WG want DID and VC binding in scope at all? The charter's protocol profiling list names OAuth 2.0, OpenID Connect, Shared Signals, and FastFed. This takes a normative dependency on two W3C Recommendations, one of which shipped over formal objections about exactly the interoperability properties an IETF standards-track document would need to rely on. The answer might well be yes, and the underlying problem is real. But the WG should decide deliberately, and everything else in this review is wasted effort if the answer is no.

Say the thing about activation plainly. There is no defined way for a client to create an active binding. Proof delivery is out of scope, there's no schema slot for a proof, and Section 8.2.1 claims binding integrity as a delivered security property anyway. Two paths out: bring a minimal proof mechanism into scope, or state clearly that activation is deployment-specific and remove the Section 8.2.1 claim. Leaving both as they are means the document specifies a record of a verification it declines to specify.

Propose the split. The propagation model in 4.5 through 4.7 is the valuable contribution and it's the part least likely to get properly reviewed at current length. It's also the part that isn't really about DIDs: a mapping from account lifecycle events to credential-level revocation actions would be useful independent of whether the credential is a VC. Suggest that as a separate, shorter document. This is the highest-leverage piece of feedback available.

Terminal revoked plus forced revocation on deactivation is an operational cliff. Concrete framing: an employee on parental leave loses every DID binding permanently and needs a full reissuance on return. There's already a suspended state being used for a much less serious condition. User deactivation should route there. Worth raising as a design issue rather than a text fix, because it interacts with the state machine and with the pairwise uniqueness rule.

Specify bindingState derivation. Section 3.1.1 does this for primaryDid and stops. bindingState is required, read-only, and the thing clients filter on, and there's no rule for aggregating multiple bindings.

Fix the URN before anyone registers it. urn:ietf:params:scim:schemas:core:2.0:IdentityBinding, matching RFC 9944 and the Agent resource draft. New resource types don't belong in the extension: namespace.

Drop materialChangeMask. Uninterpretable by clients, duplicated by ETags and by the propagation event.

Point at RFC 9967's registered event types. Section 4.7 step 5 requires emitting SCIM events and says the type "SHOULD indicate" the change class. RFC 9967 already registers prov:activate, prov:deactivate, and prov:patch. Say which existing types apply and register any genuinely new ones, rather than describing what the type should indicate.

Raise the layering point once, as a pattern. Requirements on the SCIM service provider to notify issuers, revoke credentials, and update per-claim status references aren't testable when the provider is a target application, and the mechanism is out of scope even when it isn't. This shows up in the agent governance draft too. Better to discuss it once as "which requirements in these drafts belong in normative text versus deployment guidance" than to file it four times.

On the merits: the underlying problem is real and nobody else is working on it. The partial revocation design and Appendix D are the strongest material in any of this author's four drafts. But the document is currently 45 pages describing the bookkeeping around a verification step it doesn't define, with an operational failure mode that would surface in the first week of a real deployment. The path forward isn't more sections. It's a split, a decision about DID scope from the chairs, and a defined way to activate a binding.