Developer supply chain | November 7, 2026

An extension ID is not an artifact identity

The Cursor marketplace incident showed that a familiar publisher label and version can still arrive as different bytes through a different channel. Bind every AI coding extension to its registry, digest, signature, policy, endpoint, and observed effects, then recover the host rather than merely uninstalling the package.

Channel-bound identity Install receipts Effect recovery Evidence checked Nov 7
Extension artifact passing through a channel provenance gate before developer workstation activation

The incident was a distribution-boundary failure

On October 29, 2026, Cursor says versions 2.1.312 and 2.1.313 of an extension labeled Anthropic.claude-code were available through the Cursor VS Code Extension Marketplace from about 2:27 a.m. to 1:35 p.m. Pacific time. The builds were not produced by Anthropic. Cursor removed them, shut down and rebuilt its marketplace, rotated keys, and published detection and remediation instructions.

The narrow scope matters. Microsoft Security Research says the malicious packages were not published through the Microsoft Visual Studio Marketplace or npm's @anthropic-ai/claude-code package. Anthropic told Microsoft its systems were not compromised. Cursor says other extensions in its marketplace were not tampered with. Teams should not turn a channel-specific incident into a claim that every Claude Code package or registry was compromised.

The broader lesson is still serious. Developers reason about extensions by a visible triple: publisher, name, version. The endpoint actually executes bytes selected through an editor, updater, registry URL, proxy, cache, policy, and signature-verification path. If any of those coordinates change, the same visible triple may no longer identify the same artifact.

The community recognized this as a trust-boundary issue. The primary Hacker News thread reached 1,011 points and 553 comments, while r/ClaudeCode and r/cursor discussions focused on whether the affected build came from Cursor's marketplace or Anthropic's official channels. That confusion is operational evidence: incident response slows down when inventory records an extension ID but not the channel and artifact digest that supplied it.

“Anthropic.claude-code@2.1.313” is a label. “Digest X, signed by identity Y, fetched from channel Z under policy P” is an artifact identity.

Model trust as a tuple, not a marketplace badge

Cursor's current extension documentation says its editor routes extension search and downloads through a marketplace proxy and warns that the same extension ID can point to different publishers or code across registries. Microsoft documents a different distribution and trust path: the Visual Studio Marketplace signs extensions, and VS Code verifies the signature during install. Those are separate channels with separate controls and failure domains.

IntentApproved extension ID, business purpose, owner, allowed editor, and required privileges.
ResolutionEditor, registry, marketplace proxy, namespace, update policy, and selected version.
ArtifactVSIX bytes, digest, manifest, embedded dependencies, signature, provenance, and build identity.
ActivationEndpoint, user, workspace trust, extension host, filesystem, network, shell, and secret access.
EvidenceInstall receipt, activation telemetry, created effects, policy decision, and later updates or removal.

The minimum identity is therefore a tuple: (editor, channel, registry, publisher, extension_id, version, digest, signer/provenance, policy). A version is not globally unique. A namespace is not proof that one upstream project built the artifact. A signature can establish integrity and source relative to a root of trust, but only if policy names the expected signer and issuer. A clean malware scan does not prove provenance. Provenance does not prove absence of malicious source. These controls answer different questions.

QuestionEvidenceWhat it does not prove
Which bytes ran?Artifact digest and retained VSIXWho built or authorized them
Who signed the artifact?Verified certificate, identity, issuer, and signatureThat the signer intended safe behavior
How was it built?Verified SLSA-style provenance and source/build inputsThat the source is vulnerability-free
Which route supplied it?Registry URL, proxy, editor, updater, timestamp, and receiptThat every route with the same ID is equivalent
What did it do?Endpoint, process, file, identity, and network telemetryAll unobserved effects or attacker follow-on actions

The extension kept working while the injected loader acted first

Microsoft reconstructed an injected JavaScript function that ran before normal extension initialization. It collected host and user details, attempted to append an attacker-controlled key to SSH authorization, attempted to enable the local SSH service, launched reverse SSH forwarding, wrote platform-specific persistence, and later attempted to report host information and selected environment-variable names. The legitimate extension behavior continued, reducing the chance that a developer would notice the tampering.

Precision matters when translating that chain into response decisions. Code capability is not the same as successful access. Microsoft says host privileges, SSH configuration, the attacker's server, and platform behavior affected whether a tunnel could result in remote access. Cursor says errors and permission requirements blocked SSH access on most macOS and Windows hosts. The presence of the svc-telemetry key or a persistence file is stronger host evidence than the fact that a vulnerable version was installed; neither fact by itself proves what an attacker later accessed.

The payload also illustrates why uninstall is a weak recovery boundary. It wrote artifacts outside the extension directory: an SSH authorization entry, LaunchAgent or startup objects, scripts, identity files, and retry loops. Removing the VSIX cannot automatically reverse those changes. A later clean version can coexist with persistence created by the earlier activation.

AI coding extensions deserve especially strict treatment because their ordinary permissions are already consequential. They inspect repositories, run tools, invoke shells, read environment context, and integrate with source control. The security problem is not that the extension contains AI. It is that a high-privilege developer automation surface was distributed through a channel whose visible identity did not bind the actual artifact to Anthropic's build.

Write the trust policy before the next extension update

Fleet policy should declare approved channels and expected cryptographic identity for each extension, not only an allowlist of IDs. Pinning every version forever is usually impractical, but an update can be held in a staging ring until its channel, digest, signature/provenance, requested capabilities, and behavior pass review. Emergency security updates can use a shorter path without discarding the receipt.

contract: developer-extension/v1
extension:
  id: "Anthropic.claude-code"
  purpose: "approved agentic coding"
resolution:
  allowed_editors: ["vscode-managed"]
  allowed_registries: ["https://marketplace.visualstudio.com"]
  fallback_registries: []
artifact:
  require_digest_receipt: true
  require_signature: true
  expected_publisher: "Anthropic"
  expected_signer_identity: "policy-managed-identity"
  require_provenance: "when-publisher-provides"
activation:
  pilot_ring: "developer-canary"
  prohibited_capabilities: ["unapproved-startup-persistence"]
  record_network_destinations: true
response:
  retain_previous_artifact: true
  revoke_sessions_on_confirmed-execution: true
  uninstall_is_not_remediation: true

Do not copy the placeholder signer into production. Resolve the identity and issuer from the publisher and registry's real signing design, then test verification failure. SLSA's verification model is useful because it treats provenance as evidence that a consumer must compare against expectations. Sigstore's model similarly separates the artifact signature, certificate identity and issuer, root of trust, and transparency-log inclusion.

Policy must also define channel transitions. If an organization moves from Microsoft Marketplace to Open VSX, a vendor proxy, or a private mirror, it should treat the first artifact as a new supplier path. Compare source, manifest, dependencies, digest, signature identity, and behavior. An automatic fallback to “any registry that has this ID” defeats the channel binding.

Verify before activation and emit a receipt

The installer or endpoint-management layer should resolve an artifact into quarantine, calculate its digest, verify signature and provenance against policy, inspect its manifest and package contents, and only then make it available to the extension host. Scan results are inputs, not the final authority. A malicious artifact that evades a scanner should still fail when its signer, issuer, build identity, or digest is outside policy.

async function admitExtension(request, policy) {
  const artifact = await fetchToQuarantine(request.channel, request.id, request.version)
  const digest = sha256(artifact.bytes)
  const signature = await verifyRegistrySignature(artifact, policy.trustRoots)
  const provenance = await verifyProvenance(artifact, policy.expectedBuild)

  assert(policy.allowedRegistries.includes(artifact.registry))
  assert(signature.publisher === policy.expectedPublisher)
  assert(signature.identity === policy.expectedSignerIdentity)
  if (policy.requireProvenance) assert(provenance.matchesPolicy)

  const analysis = await inspectVsix(artifact.bytes)
  assertNoForbiddenCapabilities(analysis, policy)
  return installAndReceipt(artifact, digest, signature, provenance, analysis)
}

The receipt makes later scope resolution possible. Without it, responders must infer whether an endpoint used Cursor's proxy, Microsoft Marketplace, Open VSX, an offline VSIX, or a private cache. Record enough to answer that question without depending on a developer's memory.

{
  "receipt": "extension-install/v1",
  "endpoint": "managed-device-id",
  "editor": "vscode-managed@pinned-build",
  "registry": "https://marketplace.visualstudio.com",
  "channel": "enterprise-extension-ring",
  "extension": "Anthropic.claude-code",
  "version": "approved-version",
  "sha256": "recorded-artifact-digest",
  "signature": {"verified": true, "identity": "expected", "issuer": "expected"},
  "policy": "developer-extension-policy@commit",
  "installed_at": "RFC3339 timestamp",
  "previous_sha256": "prior-artifact-digest",
  "activation": "allowed"
}

Keep the receipt in a central inventory that can be queried by version, digest, channel, install window, editor, endpoint, user, and policy. Inventory is the difference between “send a company-wide message” and “isolate the exact 17 endpoints that activated these bytes during the affected window.”

Use rings, private distribution, and denial tests

Microsoft documents allowed-extension controls and private marketplaces for managed VS Code fleets. These are useful enforcement points, but the organization still needs its own identity tuple and receipt. An allowlist entry for Anthropic.claude-code is incomplete if the editor can resolve that ID from an unapproved registry.

  1. Inventory every VS Code-compatible editor, extension registry, marketplace proxy, private mirror, offline VSIX path, and updater in use.
  2. Define approved editor-channel-extension tuples with owners, purpose, privilege class, and expiry.
  3. Put updates through canary, limited-developer, and broad rings; preserve the exact artifact from every ring.
  4. Block signature-verification bypass and alert when users or managed settings disable it.
  5. Compare manifests, dependencies, entry points, native code, obfuscation, network destinations, startup changes, and requested capabilities with the prior artifact.
  6. Deny an artifact from the wrong registry even when publisher, extension ID, and version look correct.
  7. Test offline and proxy-failure behavior; the client must fail closed rather than silently select another registry.
  8. Record activation and runtime effects so a clean install receipt is not mistaken for a clean execution.

Developer exception paths need the same rigor. A team may legitimately need a pre-release or locally built extension. Give it a temporary channel, reviewer, digest, declared capabilities, isolated test environment, expiry, and promotion decision. “Install from VSIX” should not mean “outside policy.”

Recover the endpoint from effects, not packages

For the Cursor incident, start with the official scope: affected versions, Cursor marketplace channel, operating systems, and time window. Query receipts and endpoint telemetry. Preserve evidence before remediation when policy and incident severity require it. Cursor's official script and Microsoft's hunting guidance identify the published indicators, but responders should interpret a match as an investigative lead and a non-match as limited evidence, not universal proof of safety.

Build an effect ledger with states such as not_observed, attempted, observed, removed, exposure_unknown, and recovered. Cover extension package, processes, SSH configuration, authorization keys, scheduled tasks or LaunchAgents, scripts, identity files, network connections, downloaded or created files, environment exposure, accessed repositories, tokens, cloud sessions, and source-control credentials.

EvidenceWhat it supportsNext action
Affected digest installed, never activatedArtifact reached host; payload execution not shownPreserve, remove, verify non-activation evidence, review update path
svc-telemetry authorization keyPayload modified SSH authorizationIsolate, remove effects, investigate access and credentials
Published persistence artifactStartup persistence was writtenIsolate, stop processes, remove persistence, hunt execution history
Outbound connection to reported infrastructureNetwork contact from a process; context still requiredCorrelate process, time, endpoint, tunnel behavior, and follow-on activity
No known indicatorNo published indicator was observed by available sensorsDo not convert sensor absence into proof of no execution

Rotate credentials and revoke sessions from a trusted system when exposure analysis warrants it. Prioritize credentials accessible to the developer context: source-control tokens, cloud sessions, package-registry credentials, SSH keys, CI access, model-provider keys, and enterprise SSO sessions. Rebuilding a host may be safer than attempting surgical cleanup when persistence or access cannot be bounded. The incident commander, not the extension owner, should decide that threshold.

Close only after inventory is reconciled, effects are removed or the host is rebuilt, session and credential actions are complete, source and cloud logs have been reviewed, affected repositories and pipelines have been assessed, and an independent reviewer signs the exact evidence packet. Reinstalling a clean extension is a later recovery step, not proof that the incident is over.

Failure modes that produce false confidence

FailureWhy it looks acceptableBlocking control
Allowlist by extension IDThe visible publisher and name matchBind editor, registry, channel, digest, and signer
Version-only inventoryResponders can search for 2.1.313Record the channel and artifact digest for every install
Scanner-only admissionNo known malware rule firesRequire independent identity and provenance policy
Signature without identity policyCryptographic verification succeedsMatch signer and issuer to an approved publisher path
Silent registry fallbackThe extension remains availableFail closed when the approved channel is unavailable
Uninstall-only responseThe extension disappears from the editorHunt files, keys, processes, persistence, network, and sessions
Indicator absence equals cleanPublished queries return no resultDocument sensor coverage and retain an unknown state
Clean update equals recoveryThe latest version is legitimateClose prior effects and credential exposure separately
Marketplace rebuild without fleet proofThe distribution service is healthyReconcile endpoint receipts and affected-time installations

A 30-day channel-hardening plan

Days 1-5: inventory editors, registries, proxies, private mirrors, extension IDs, installed versions, update settings, signature settings, endpoint telemetry, owners, and exception paths. Find where the same ID resolves differently.

Days 6-10: classify extensions by privilege and developer exposure. Write channel-bound policies for the highest-risk set. Capture baseline VSIX files, digests, manifests, signatures, provenance, and runtime behavior.

Days 11-15: add quarantine resolution, digesting, identity verification, static/dynamic analysis, and install receipts. Build denial fixtures for wrong registry, wrong signer, altered bytes, absent provenance, disabled verification, and silent fallback.

Days 16-20: enable canary rings and central inventory. Rehearse a malicious-update incident using inert fixtures that create harmless test effects outside the extension directory. Confirm that uninstall does not incorrectly close the exercise.

Days 21-25: integrate endpoint, identity, network, source-control, cloud, package-registry, and CI evidence. Define isolation, credential/session revocation, rebuild, reinstall, and independent closure thresholds.

Days 26-30: enforce approved channel tuples for the highest-risk extensions, expire temporary exceptions, review receipt coverage, and publish a change contract. Reopen admission whenever registry, proxy, publisher identity, signing root, editor updater, or extension privilege changes.

Measure coverage rather than policy count: percentage of extension installations with a digest and channel receipt; time to enumerate affected endpoints; percentage of privileged extensions under signer policy; unknown-effect backlog; recovery drill duration; and changes that bypass the approved ring.

Frequently asked questions

Was the official Claude Code extension compromised everywhere?

No. The official reports scope the malicious builds to Cursor's marketplace during a specific window. Microsoft says Visual Studio Marketplace and npm were not affected, and Anthropic says its systems did not create the malicious build.

Why not trust a verified publisher badge?

A badge represents rules inside one marketplace. It does not bind every registry, proxy, artifact digest, signer, or build. The consumer must verify the exact channel and artifact against its own policy.

Does signature verification solve the problem?

It is a strong integrity and source control when the client also verifies the expected signer, issuer, and channel. It does not prove that signed source is safe, and it cannot remove side effects after activation.

Should teams disable automatic extension updates?

Not universally. Managed rings can preserve security-update speed while adding quarantine, verification, receipts, and staged rollout. The right policy depends on privilege, exposure, fleet controls, and response capability.

When is a workstation rebuild justified?

Use the incident team's threshold. Rebuild is appropriate when persistent access, follow-on activity, credential exposure, or effect completeness cannot be bounded with sufficient confidence.

What is the minimum useful installation record?

Endpoint, editor/updater, registry and channel, publisher, extension ID, version, artifact digest, verified identity, policy decision, install and activation time, and previous artifact.

Sources and further reading

Sources were accessed November 7, 2026. Incident claims preserve the official channel, version, platform, and time boundaries. Payload capability, observed indicators, and confirmed attacker access are not treated as interchangeable.