← Blog
Supply Chain AttackAI Developer ToolsCursorClaude Code

Cursor supply chain attack: a backdoored Claude Code extension traced to Fireworks AI

A Cursor key exposed in the Fireworks AI breach let attackers serve a backdoored Claude Code extension (2.1.312/2.1.313) for ~11 hours. How to clean up.

Zero Hunt Research··7 min read

Published by Zero Hunt, an autonomous AI red team on an on-premise appliance running private AI: automated penetration testing for networks and infrastructure, black-box or gray-box, with a human approving every step that matters.

For about eleven hours on October 29, developers who installed or updated Anthropic's Claude Code extension from the Cursor VS Code marketplace could have pulled a tampered build that opened an SSH backdoor on their machine. The extension was not compromised at Anthropic, and the public Open VSX source never carried the malware. The tampered copy lived only in Cursor's own cache — and the thread that put it there runs back through a stolen Cursor access key that was sitting inside Fireworks AI when Fireworks was breached. This is the clearest supply-chain-of-a-supply-chain we have seen in AI developer tooling, and the operational lesson is uncomfortable: the trust boundary you thought you had did not exist.

Developing story — first published 16:55 CET (15:55 UTC), 16 November 2026. Updated as Cursor, Fireworks, and investigators publish more.

The attack chain, from Fireworks AI to your editor

Cursor's own incident update lays out the pivot. An attacker obtained an access key that Cursor had issued to Fireworks AI, which — per Cursor — was exposed in the Fireworks breach. With that key the attacker copied data from a read-only storage bucket Cursor used to share data with Fireworks. The bucket held limited coding-agent traces, mostly from 2025, from sessions that were not in Privacy Mode.

A small number of those traces contained credentials that had not been redacted — Cursor says fewer than 0.01% of customers had API credentials exposed this way. Those unredacted secrets were enough to reach select SaaS tools Cursor uses, and from there the attacker touched archived non-production source repositories, limited customer-support data and email, product-usage metrics, summaries of some coding-agent conversations, and some credentials users had pasted into support tickets.

A single unredacted secret inside a 2025 debug trace became the master key to the support desk, the SaaS stack, and ultimately the extension cache. Nobody "hacked Cursor's production." They walked in through the data Cursor had already handed to a vendor.

On October 29, using a stolen credential pulled from that internal access, the attacker placed malicious, unauthorized copies of Anthropic.claude-code directly onto the cache that serves the Cursor VS Code extension marketplace. Anthropic did not publish those copies and this was not a flaw in Anthropic's product; the marketplace source, Open VSX, never held the malware. It was served to anyone who requested the cached versions during the window.

What the backdoored Claude Code extension actually did

Per Cursor's security notice, the payload in extension.js ran in three stages:

  • Host reconnaissance — hostname, username, OS, architecture, home directory, environment-variable names, working directories, configured Git email, and public IP, POSTed to the attacker at 134.209.82.225:8099/beacon (T1082).
  • SSH backdoor — it added an attacker key (svc-telemetry) to authorized_keys, tried to enable the local SSH service, and opened a reverse SSH tunnel back to 134.209.82.225 (T1098.004, T1021.004, T1572). The tunnel step needs admin rights and often failed — but where it succeeded, the attacker had an interactive foothold.
  • Persistence — a com.apple.sysmond LaunchAgent on macOS, or a SysMon scheduled task (with a Startup-folder fallback) on Windows, re-launching background scripts that retry the tunnel roughly every 60 seconds (T1543.001, T1053.005).

The single most important line in Cursor's notice: uninstalling the extension is not enough. The payload drops standalone persistence scripts that keep running after the extension is gone.

Am I affected, and how do I check?

You are in scope only if you installed or updated Anthropic.claude-code version 2.1.312 or 2.1.313 on macOS or Windows from the Cursor marketplace between roughly 02:27 and 13:35 PT on October 29, 2026. Cursor puts the upper bound at about 5,000 users who requested the cached versions in that window — an upper bound on exposure, not a count of confirmed infections.

Check for the backdoor key directly. On macOS/Linux:

grep -qs svc-telemetry ~/.ssh/authorized_keys \
  && echo "svc-telemetry key found — IMPACTED" \
  || echo "No key found; not impacted via authorized_keys"

On Windows, check both $HOME\.ssh\authorized_keys and C:\ProgramData\ssh\administrators_authorized_keys for the string svc-telemetry. If the key is present, treat the host as compromised and work the runbook below.

Remediation

Cursor published a full indicator set and two cleanup scripts. Follow the vendor steps; do not improvise around them.

  1. Validate. Run Cursor's platform script (remediate-macos.sh as the affected user, not root; remediate-windows.ps1 from an elevated PowerShell). They remove the extension, the persistence mechanisms, the running tunnel processes, and the attacker key, and exit non-zero if anything remains.
  2. Hunt across the fleet. Search endpoint, network, and extension-install telemetry for the published indicators:
Indicator Value
Malicious versions Anthropic.claude-code 2.1.312 · 2.1.313 (Win · macOS)
Payload extension.js SHA-256 ecb58cb29078d9646ad1dcdbe51526f2d9cfea06be5fb2ab183e8ecc3ab6bf15
C2 / beacon 134.209.82.225 · HTTP POST to :8099/beacon · reverse SSH on TCP 22
SSH backdoor key svc-telemetry (ed25519); add to deny-lists
macOS persistence ~/.config/.smt · ~/.config/.smtk · LaunchAgent com.apple.sysmond
Windows persistence %USERPROFILE%\.config\smt.cmd · scheduled task SysMon · Startup\sysmon.cmd
  1. Isolate any host showing payload execution or a backdoor, and remove the SSH key, persistence, and tunnel processes. Because the beacon leaked environment-variable names, assume the attacker had a shopping list even where the tunnel failed.
  2. Rebuild or clean, then rotate — from a trusted system. Rotate every credential and session reachable from an affected host. Cursor notes the limited env-var collection does not rule out later credential access over the backdoor, so treat anything that host could touch as exposed.
  3. Re-verify. Confirm authorized_keys no longer carries svc-telemetry, no SysMon/com.apple.sysmond persistence remains, and there is no outbound session to 134.209.82.225. Map your detections to T1195.002 (supply-chain compromise) so the hunt is repeatable. A clean uninstall log is not proof; absence of the key and the beacon is.

What is not known yet

  • How the attacker first got into Fireworks. The Fireworks bulletin describes unauthorized use of internal credentials on October 6 and a third-party-cloud compromise around October 23–24, but does not say how the initial credentials were obtained — nor does it name Cursor.
  • Which of the two Fireworks incidents exposed the Cursor key, and whether any environment-variable secrets were actually used over the backdoor.
  • The full blast radius. The same Fireworks compromise has been tied publicly to other customers — SecurityWeek links separate breaches at Notion and Uber to it. Fireworks says its investigation is ongoing.

Catching the second stage when the first one is signed

The hard truth of this incident is that the malicious artifact looked legitimate: the right publisher ID, served over the right marketplace channel, passing the checks a developer or an endpoint agent would run. Signature and version logic had nothing to flag, because the problem was not the version — it was the cache. What the backdoor did next is where it became visible: a reverse SSH tunnel to a never-seen IP, an HTTP beacon to :8099 every sixty seconds, a host that historically only talked to package registries suddenly holding an outbound session to a DigitalOcean address.

That is the detection surface a traffic-side model owns. Zero Hunt's AI Traffic Analysis runs a deep-learning model with four parallel inference heads — suspicious traffic, malware classification, attack type, and application fingerprinting — on the appliance GPU at multi-gigabit line rate, baselining what each host normally talks to. A backdoor that retries its tunnel every minute and beacons to an unknown ASN is loud on the wire even when the extension that dropped it sailed past the endpoint. It is caught while it is happening, not in the next morning's SIEM digest or a vendor notification three weeks later.

Upstream, the reason the chain reached so far is that the real attack surface — a data-sharing bucket, a vendor-held access key, unredacted secrets in old traces — was invisible to an asset inventory. Zero Hunt is an autonomous AI red team that runs on-premise on its own private models, with a human in the loop for anything that matters. Its 10-agent swarm maps that surface black-box, the way the attacker did, and proves which third-party integrations and leaked credentials are actually reachable — the questions a vendor questionnaire never answers. And because the engine runs on an appliance in your rack rather than calling an external inference provider, there is no third party holding a key to your toolchain in the first place. If you are weighing where your developers' AI stack should live, our on-premise platform buyer's guide works through exactly that trade-off. Talk to us if you want the surface mapped before someone else maps it for you.

Is this exploitable in your environment?

Zero Hunt answers that on your own network: an autonomous AI red team on an on-premise appliance, running on private AI, black-box or gray-box, with a human approving every step that matters. Proof of what is exploitable, the fix, and signed evidence — no data leaves your perimeter.