The Marketplace Backdoor Started at an Inference Vendor

November 17, 2026 · SPR{K3 Research

On October 29, a trojanized build of Anthropic's Claude Code extension sat on Cursor's marketplace for roughly eleven hours. Developers who received it as an automatic update got a package that quietly added an attacker-controlled SSH key, labeled svc-telemetry, to ~/.ssh/authorized_keys, opened a reverse tunnel, and exfiltrated environment variable names containing KEY, TOKEN, and SECRET. Cursor removed the build, Anthropic published a replacement, and a short postmortem followed.

On November 13, Cursor published a longer one, and the longer one is the news. The marketplace trojan was not the start of the story. It was the last step in a four-boundary chain that began at an inference vendor.

The chain as Cursor describes it

Cursor had issued an access key to Fireworks AI. Fireworks, as disclosed by Fireworks itself, suffered a cloud-provider breach in October. The attacker used Cursor's key to copy data from a read-only storage bucket Cursor had used to share coding-agent traces with Fireworks for model and quality work.

Those traces contained, in Cursor's own words, "unredacted credentials" for fewer than 0.01% of customers. The Hacker News quotes Cursor directly: "An attacker obtained an access key we had issued to Fireworks." With the credentials harvested from the traces, the attacker reached select Cursor SaaS tooling — archived non-production source repositories, limited customer support data, product usage metrics, summaries of some agent conversations. From one of those footholds the attacker obtained an internal credential, and with that credential placed the trojanized anthropic.claude-code builds (versions 2.1.312 and 2.1.313) into Cursor's extension marketplace cache. Cursor says up to 5,000 users who requested specific cached versions on October 29 could have received the malicious build.

Four boundaries, written as the compromised vendor describes them: inference subprocessor, shared dataset, SaaS estate, software distribution channel.

Agent traces as credential carriers

Three independent disclosures in a six-week window show the same primitive at different layers of the stack.

Apiiro's November 7 writeup through The Hacker News found 2,539 live secrets in 1,994 public GitHub repositories. The primitive was Claude Code's "Yes, and don't ask again" approval option, which saved the exact approved command — including any inline password or token — to .claude/settings.local.json.

NEAR AI's November 9 incident report describes an SGLang RCE. The post-exploitation finding is that API keys for two Cloud customers had been written to logs on the inference server.

Cursor's November 13 update is the third instance. The traces held the credentials; a stolen subprocessor key let an attacker read them.

The common shape is that an AI coding tool and its downstream infrastructure retained, as a side effect of operating, credentials that were never supposed to persist. Each incident had a different proximate cause — a UX decision, a logging bug, a shared-dataset arrangement — and the same underlying class of problem: the tool's own telemetry became a credential vault.

The marketplace cache was a trust boundary

A VS Code extension signed by a known publisher and served from a vendor-run marketplace carries roughly the same trust weight as the original. The attacker did not need to steal a code-signing key or a maintainer account. The attacker needed a credential that let them write into the cache that stands behind the publisher identity.

Cursor's October 30 notice and its November 13 update both state this plainly: Anthropic did not develop the malicious builds, Anthropic's systems and laptops were not compromised, and the distribution step was the point of compromise. A version pinned to a publisher is a weaker commitment than it reads as. The real commitment is "whoever currently holds the credentials to write into this publisher's slot."

What a defender can see without the vendor's internals

The chain itself was not visible to the enterprise defender — Cursor's Fireworks relationship, Fireworks' key handling, Cursor's internal access controls, and the marketplace cache all lived inside one or the other vendor. The downstream behavior was visible on the enterprise defender's own machines.

A compromised anthropic.claude-code extension on a developer laptop has to do things an uncompromised one does not: modify ~/.ssh/authorized_keys to add a key labeled svc-telemetry, install persistence via a macOS LaunchAgent (com.apple.sysmond) or a Windows scheduled task (SysMon), open a reverse tunnel to 134.209.82.225, and post to port 8099 at /beacon with the host's public IP, hostname, username, OS, Git email, and a filtered environment-variable inventory.

Each of those is a behavior. A behavioral layer on the developer host does not need Cursor's internal breach-response thread to flag a VS Code extension writing to ~/.ssh/authorized_keys, opening a reverse SSH tunnel, and posting an environment-variable inventory to a hard-coded IP. The signature lives at the host boundary the attacker's last step has to cross.

That is also the layer that catches the next version of this chain. The upstream details will change; the downstream footprint will look largely the same, because the attacker's goal is still to install something on a developer's machine.

The short version for operators

Hosts that installed anthropic.claude-code 2.1.312 or 2.1.313 from Cursor on October 29 should be treated as backdoored per Cursor's guidance; uninstalling the extension does not remove the SSH key or the persistence hooks. Fireworks keys issued across vendor relationships deserve the same treatment any publicly exposed credential does — assume they are compromised and rotate them. Agent-trace retention arrangements with inference subprocessors are worth revisiting on the same terms: a trace record is a credential-carrying artifact, and the record's downstream residency is a trust boundary.

The marketplace extension is the layer the operator sees. The inference subprocessor is the layer the chain started at. The runtime on the developer host is where the two meet.


SPR{K3 is a security research operation that pairs offensive vulnerability research with runtime behavioral defense. Defend is our runtime agent. To talk about a deployment, reach us at support@sprk3.com.