On October 29, Cursor confirmed that tampered copies of the Claude Code extension had appeared in its VS Code extension marketplace: versions 2.1.312 and 2.1.313 for macOS and Windows, available for about 11 hours. Anthropic didn't publish these builds. Once installed, they collected host details, appended an attacker's SSH key to authorized_keys, and tried to set up a reverse tunnel that kept reconnecting.
Anyone who uses AI coding tools should spend ten minutes on this. Not because of how many people were hit (Cursor later put the upper bound at 5,000), but because the problem it exposes is common: coding-agent extensions run with permission to execute commands and read and write files, and if the distribution channel is compromised, "installed from the official marketplace" doesn't guarantee you got the official code.
The short version: If you installed or updated the Claude Code extension in Cursor on macOS or Windows on October 29, run the one-line check from the official notice for the
svc-telemetrykey. If it's there, clean up with the official script and rotate every credential that machine could reach, from a different, clean machine. If you weren't affected, use this as a reason to tighten three things: how quickly high-privilege extensions update, which long-lived credentials sit on your dev machine, and whether SSH login is enabled.
This guide first walks through checking and cleanup using Cursor's two official posts, then the intrusion path Cursor published on November 13, and finally turns it into habits that apply to extensions, MCP servers, and Skills alike.
What happened on October 29
Figure 1: Cursor's October 29 security notice. The indicators of compromise and affected versions were updated on the morning of October 30.
According to the notice, the malicious builds were in Cursor's VS Code extension marketplace between about 2:27 a.m. and 1:35 p.m. Pacific time on October 29. The code ran as soon as the extension loaded, with no Claude conversation needed, and did three things:
- Collected and reported host details: hostname, username, OS and architecture, home directory path, environment variable names, working directories, the configured Git email, and public IP. Note that it took the variable names, not their values, though the notice warns that this doesn't rule out the attacker reaching credentials later through the backdoor.
- Tried to open a backdoor: it appended an SSH public key labeled
svc-telemetrytoauthorized_keys, tried to turn on the local SSH service, and tried to open a reverse SSH tunnel to the attacker's server. - Installed persistence: a LaunchAgent disguised as a system service on macOS, and on Windows a scheduled task that tries to run as SYSTEM, with a Startup-folder script as fallback. Background scripts retried the tunnel roughly every 60 seconds.
Cursor's assessment is that turning on the local SSH service needs admin rights, so on most macOS and Windows machines that step failed and the attacker couldn't log in through the tunnel. The attacker's server has also been taken offline with the hosting provider's help. But the key, the persistence scripts, and the host report did happen, so the notice asks everyone potentially affected to follow the cleanup steps rather than skip them because it "probably didn't work."
Step 1: Check whether you're in scope
You only need to dig further if all three are true:
- You use Cursor, and the extension came from Cursor's built-in marketplace.
- You're on macOS or Windows.
- You installed or updated the Claude Code extension, including by auto-update, between 2:27 a.m. and 1:35 p.m. Pacific time on October 29.
Cursor's November 13 update adds that the upstream Open VSX registry never had these two builds, and Anthropic's official release wasn't tampered with. If you install only through Microsoft's marketplace in VS Code, or use only the command-line Claude Code, this package didn't reach you through that channel.
If you can't remember whether you updated in that window, just check for the key. On macOS, run this in Terminal:
grep -qs svc-telemetry ~/.ssh/authorized_keys && echo "svc-telemetry key found" || echo "No key found; machine not impacted"On Windows, run this in PowerShell:
$files = "$HOME\.ssh\authorized_keys", "C:\ProgramData\ssh\administrators_authorized_keys" | Where-Object { Test-Path $_ }
if ($files -and (Select-String svc-telemetry $files)) { "svc-telemetry key found" } else { "No key found; machine not impacted" }Both commands come straight from the official notice. They only search; they don't change any files. No key found means that key wasn't added to this machine.
Step 2: If you find the key
Here is the order the notice gives, arranged as you'd actually do it:
- Isolate first. Disconnect the machine from the network, or at least stop using it to sign in to anything important. In a team, have your security lead search endpoint, network, and extension-install telemetry for the indicators to find other affected machines.
- Run the official cleanup script. On macOS, download
remediate-macos.shand run it as the affected user, not as root. On Windows, downloadremediate-windows.ps1and run it in PowerShell opened with Run as Administrator. The scripts remove the malicious extension, the persistence, running tunnel processes, and the key, and exit with a non-zero status if anything remains. Download them only from Cursor's notice page. - Don't stop at uninstalling the extension. The notice stresses that the payload drops standalone scripts that keep running, so uninstalling alone won't clear it. Places to check by hand include, on macOS,
~/Library/LaunchAgents/com.apple.sysmond.plist,~/.config/.smt, and~/.config/.smtk; on Windows, a scheduled task named SysMon,%USERPROFILE%\.config\smt.cmd, andsysmon.cmdin the Startup folder. The notice also lists Linux locations; use the original for the full list. - Rotate credentials from a clean machine. Treat everything this computer could read as exposed: Git hosting tokens and SSH keys, cloud access keys, model API keys, database passwords, and browser sessions. Do the rotation on a trusted device, or the same backdoor could pick up the new credentials too.
- Decide whether to rebuild. The notice says to assess whether the host should be rebuilt. If Cursor ever ran with admin rights on that machine, or your logs show the tunnel actually connected, we'd lean toward a clean reinstall.
The November 13 update: how the builds got into the marketplace
Two weeks later, Cursor published its findings. The chain didn't start in Cursor's marketplace or at Anthropic, but at a third-party training and inference vendor.
Figure 2: The path as described in Cursor's November 13 update. What was altered was the marketplace's distribution cache; the upstream source stayed clean.
In Cursor's account, an access key it had issued to the vendor was exposed there, and the attacker used it to copy data from a read-only storage bucket. The bucket held limited coding-agent traces, mostly from 2025 and from sessions without Privacy Mode. A small number contained credentials that hadn't been redacted, and fewer than 0.01% of customers had API credentials exposed this way. The attacker used those credentials to reach some SaaS tools Cursor uses, obtained another credential from an internal system, and placed the tampered extension directly on the cache that serves the extension marketplace.
Cursor lists as unaffected: prompts and code from users with Privacy Mode on, the production systems that run Cursor, the Cursor app and its official updates (no release signing keys were exposed), customer code repositories, and every other extension in the marketplace. Cursor says the last attacker activity it saw was on November 1, and it was blocked.
For individual developers, this chain carries two direct lessons:
- Keys you paste into agent conversations may live longer than you think. The starting point here was unredacted credentials in historical traces. Don't paste production secrets into AI chats or support tickets, and if you don't want sessions retained for training, make sure the tool's privacy mode is on.
- "The official marketplace" is a chain, not a single point. The extension author, the upstream registry, the marketplace's mirrors and caches, and your local updater: if any link is altered, you get a package that looks normal.
Lowering the risk: everyday habits for extensions, MCP, and Skills
This time it was an editor extension, but MCP servers, agent Skills, and plugins are the same kind of thing: they're distributed by third parties and can run code on your machine. We suggest sorting them by what they can execute rather than treating every extension the same.
Figure 3: Spend the extra time only on high-privilege components. Theme-only extensions can keep auto-updating.
Give high-privilege extensions an update cooling-off period. The malicious builds were up for about 11 hours. Visual Studio Code now waits 12 hours after an extension update is published before installing it automatically; you can lengthen that with extensions.autoUpdateDelay, or right-click an extension and turn off Auto Update for it alone. Source Cursor is built on VS Code, but whether it offers the same delay setting depends on your version, so check its settings page. For coding-agent extensions, we lean toward turning off auto-update, updating by hand once a week after checking that the version number matches the official changelog, and updating immediately for security fixes.
Check the source, not just the name. Before installing, confirm the publisher, the source repository, and that the version matches the official changelog. Since version 1.97, VS Code asks you to confirm trust the first time you install from a third-party publisher; don't click through that dialog on autopilot. For MCP servers, prefer official implementations or ones whose source you can read, and pin versions. See the security risks of MCP.
Keep long-lived credentials off your dev machine. The first thing this payload collected was environment variable names and your Git email. Use short-lived tokens where you can; give cloud accounts a separate, limited development role; and keep production secrets out of local .env files. It's the point we keep making in setting permissions before you let an AI agent use your computer: whatever an agent can reach, an attacker riding on the agent can reach.
Turn off remote login if you don't use it, and glance at `authorized_keys` now and then. The key step in this backdoor was enabling local SSH, and on most machines it failed for lack of admin rights. On a Mac you don't log into remotely, check that Remote Login is off under System Settings → General → Sharing. On Windows, confirm the OpenSSH server isn't installed. Every line in authorized_keys should be a key you recognize.
Teams should be able to answer "who installed which version." The slowest part of an incident is working out the scope. Keep an allowlist of approved extensions and include extension installs and updates in endpoint logging. If you have device management, set auto-update and update delay centrally by policy.
Who should act, and who can skip ahead
Act now if: you installed or updated the Claude Code extension in Cursor on macOS or Windows on October 29; you're a tech or security lead responsible for a fleet of dev machines; or you keep production credentials on your dev machine.
You can read just the second half if: you use only VS Code with Microsoft's marketplace, use only the command-line Claude Code, or never installed this extension. You don't need to clean anything up, but the update cooling-off period and keeping long-lived credentials off your dev machine are worth doing.
If you're still choosing a coding tool, see Claude Code vs. Cursor. This incident wasn't a vulnerability in Claude Code itself and doesn't show that either product is safer, but it is a reminder that the more tools you use, the more distribution channels you have to trust.
Frequently asked questions
I use the Claude Code extension in VS Code. Am I affected?
According to Cursor's notice, the malicious builds existed only in the distribution cache for Cursor's VS Code extension marketplace. Neither the upstream Open VSX registry nor Anthropic's official release had them. VS Code users who install through Microsoft's marketplace weren't on this distribution path.
I found the key. Is uninstalling the extension enough?
No. The notice says the payload drops standalone persistence scripts that uninstalling won't remove. Run the official cleanup script, rotate every credential the machine could reach from a clean device, and assess whether to rebuild the system.
I didn't find the key. Should I do anything?
No cleanup is needed. Two things are worth doing anyway: switch coding extensions to manual updates or add an update delay, and check your dev machine for long-lived API keys and cloud access keys.
Can MCP servers and Skills have the same problem?
Yes. They're also distributed by third parties and can also run code locally. Follow the flow in Figure 3: first ask what it can do, then check the source and version, and don't update high-privilege components the moment a new version appears.
Summary
The malicious code in this incident didn't exploit any editor vulnerability. It simply used a distribution channel people already trusted. For individuals, the most useful steps are three: check once for svc-telemetry, give high-privilege extensions an update cooling-off period, and move long-lived credentials off your dev machine. Teams should add a fourth: always be able to say which extensions, at which versions, are on each machine.