A Hidden Key Rode In on an AI Update

Cursor served a trojanized Claude Code extension with an SSH backdoor; here's how to find and remove it on your clients' dev machines.

A code editor's extension store handed out a booby-trapped copy of a popular AI coding tool, and the add-on quietly dropped a remote-access key onto developer laptops. On 13 November 2026, Cursor disclosed that a leaked vendor key let attackers publish trojanized Claude Code builds 2.1.312 and 2.1.313 to its marketplace, reaching up to 5,000 developers. Check every client's developer machines for the planted backdoor today.

TL;DR

  • On 13 November 2026, Cursor disclosed a leaked vendor key let attackers push trojanized Claude Code builds 2.1.312 and 2.1.313 to its marketplace on 29 October.
  • Any client who installed or updated Anthropic.claude-code 2.1.312 or 2.1.313 in Cursor during the 29 October window is exposed; check ~/.ssh/authorized_keys for an svc-telemetry key.
  • Remove the planted SSH key and persistence, rotate every secret those machines could reach, then rebuild — Cursor warns uninstalling the extension alone may not be enough.
  • Up to 5,000 developers may have received the build; fewer than 0.05% of users had coding-agent traces exposed and fewer than 0.01% had API credentials exposed.

What happened in the Cursor data breach and who was hit?

On 29 October 2026, attackers used a stolen credential to place a malicious Claude Code extension — versions 2.1.312 and 2.1.313 — in the cache that serves Cursor's extension marketplace, where the builds stayed live for about 11 hours. The root cause, disclosed on 13 November, was a Fireworks AI key Cursor had issued to its inference vendor and left exposed, which let the attacker reach old coding-agent traces, the unredacted credentials buried in them, and finally a marketplace publishing credential — a textbook AI developer supply chain attack.

Up to 5,000 developers may have received those builds, per Cursor. There is no CVE for this incident: it was a compromise of a distribution channel, not a software flaw in Anthropic's product, and Cursor says its official extension and the Open VSX marketplace were never affected, though earlier researcher reports differed. The tampered extension installed an attacker SSH key, set up persistence, and tried to open a reverse SSH tunnel — an SSH backdoor that can outlive the extension.

Security firm Wiz calls this wave "Black October" — at least nine disclosed attacks on AI developer platforms in October, nearly all driven by stolen credentials that grant access to AI models, including a poisoned package that stole keys from every client that installed it.

How do I check if my clients got the trojanized Claude Code extension?

Run these observe-only checks on each developer machine; nothing you find is executed. Indicators are from Cursor's security notice and Phorion's analysis.

  1. Preserve evidence. Copy the suspect SSH and config artifacts off each box and hash them before you touch anything. Pass: "$D.sha256" exists with one line per copied file.

    # run as the affected user on each Mac/Linux dev machine
    D="$HOME/ir-$(date +%Y%m%d-%H%M)"; mkdir -p "$D"
    cp -a ~/.ssh/authorized_keys ~/.config/.smt ~/.config/.smtk "$D"/ 2>/dev/null
    # errors for absent files are expected
    sudo find "$D" -type f -exec sha256sum {} + | sudo tee "$D.sha256"
    
    # run in PowerShell on each Windows dev machine
    $D="$env:USERPROFILE\ir-$(Get-Date -Format yyyyMMdd-HHmm)"; New-Item -ItemType Directory -Force $D | Out-Null
    Copy-Item "$env:USERPROFILE\.ssh\authorized_keys","$env:USERPROFILE\.config\smt.cmd","$env:USERPROFILE\.config\smtk" $D -ErrorAction SilentlyContinue
    Get-ChildItem $D -Recurse -File | Get-FileHash -Algorithm SHA256 | Export-Csv "$D.sha256.csv" -NoTypeInformation
    
  2. Look for the attacker's SSH key. The backdoor adds a key commented svc-telemetry for every local user; any hit means that machine is compromised — isolate it. Pass: no output.

    sudo grep -rl 'svc-telemetry' /root/.ssh/authorized_keys /home/*/.ssh/authorized_keys /Users/*/.ssh/authorized_keys 2>/dev/null
    
    Get-ChildItem C:\Users\*\.ssh\authorized_keys,C:\ProgramData\ssh\administrators_authorized_keys -Force -ErrorAction SilentlyContinue | Select-String svc-telemetry
    
  3. Hash the installed extension. This finds the trojanized extension.js by its known-bad SHA-256 across every user's Cursor extensions folder. Pass: no output.

    sudo find /Users/*/.cursor/extensions /home/*/.cursor/extensions -type f -name extension.js 2>/dev/null -exec sha256sum {} + | grep -i 'ecb58cb29078d9646ad1dcdbe51526f2d9cfea06be5fb2ab183e8ecc3ab6bf15'
    
    Get-ChildItem "C:\Users\*\.cursor\extensions" -Recurse -Filter extension.js -Force -ErrorAction SilentlyContinue | Get-FileHash -Algorithm SHA256 | Where-Object Hash -eq 'ECB58CB29078D9646AD1DCDBE51526F2D9CFEA06BE5FB2AB183E8ECC3AB6BF15'
    
  4. List persistence and any live tunnel. This shows the disguised LaunchAgent, scheduled task, cron entry and dropped scripts, plus any reverse-SSH process still running right now. Pass: no listing and no ssh -R/autossh process.

    ls -la /Users/*/Library/LaunchAgents/com.apple.sysmond.plist /Users/*/.config/.smt /home/*/.config/.smt 2>/dev/null
    sudo ls -la /etc/cron* /var/spool/cron/* 2>/dev/null
    ps -eo pid,ppid,user,comm,args --forest | grep -E 'ssh .*-R|autossh' | grep -v grep
    
    schtasks /query /tn SysMon 2>$null
    Get-ChildItem "$env:APPDATA\Microsoft\Windows\Start Menu\Programs\Startup\sysmon.cmd" -ErrorAction SilentlyContinue
    
  5. Hunt the C2 address in your logs. Search DNS, proxy and firewall logs that cover 29 October onward for the attacker IP 134.209.82.225; any contact means treat the host as a likely compromise and escalate. Pass: no match (on-box logs cover a short window, so use the client's SIEM for the full period).

    sudo grep -rE '134\.209\.82\.225' /var/log 2>/dev/null
    

How do I fix the Cursor extension backdoor on client machines?

Work top to bottom; do not stop at uninstalling the extension.

  1. Isolate any machine that failed a check. Pull compromised hosts off the network so the tunnel can't be used. Pass: the host cannot reach 134.209.82.225 (checked with ping from the host, which times out).

  2. Run Cursor's remediation script. It removes the extension, persistence, tunnel processes and the attacker SSH key, and exits non-zero if anything remains. Pass: exit=0.

    # macOS: run as the affected user, NOT root
    curl -fsSL https://cursor.com/static/security/claude-code-extension/remediate-macos.sh -o /tmp/rem.sh
    bash /tmp/rem.sh; echo "exit=$?"
    
    # Windows: elevated PowerShell (Run as Administrator)
    irm https://cursor.com/static/security/claude-code-extension/remediate-windows.ps1 -OutFile $env:TEMP\rem.ps1
    powershell -ExecutionPolicy Bypass -File $env:TEMP\rem.ps1; "exit=$LASTEXITCODE"
    
  3. Confirm the key and persistence are gone. Rerun check 2 and check 4 by hand in case the script could not run. Pass: both print nothing.

  4. Rotate every secret those machines could reach. From a trusted system, rotate API keys, cloud keys, Git credentials and SSH keys that lived on or were used from the host, then confirm the old ones fail. Pass: a test call with an old key returns an auth error (HTTP 401/403).

  5. Rebuild high-value hosts. Cursor warns that uninstalling alone may leave standalone persistence running, so reimage developer laptops that showed payload execution from known-good media. Pass: the rebuilt host passes checks 2–5.

Where KinoSec fits

KinoSec's autonomous web app and API pentest does not scan developer laptops for the svc-telemetry SSH backdoor — the steps above do that. What it does test is the entry point this chain abused: whether each client's internet-facing apps, APIs and cloud leak the kind of credentials or over-scoped keys an attacker could pick up from the outside and chain inward. Autonomous web app and API pentesting for your clients runs the same reconnaissance a real attacker would — with your client's permission, scope limits and a report they can act on — and surfaces exposed secrets and reachable keys before someone else finds them. A breach that starts with one leaked vendor key is exactly the failure an outside-in pentest is built to catch early.

Frequently Asked Questions

Was the real Claude Code extension or Open VSX affected?

No. Per Cursor, only the copies served from Cursor's own marketplace cache — Anthropic.claude-code versions 2.1.312 and 2.1.313 — were trojanized. Cursor says Anthropic's official extension and the Open VSX marketplace were never compromised, and that this was not a flaw in Anthropic's product. Earlier third-party researcher reports differed on the exact scope.

How do I check a Mac or Windows machine for the Cursor extension backdoor?

Check three things in this order. First, the SSH key: on a Mac run grep svc-telemetry ~/.ssh/authorized_keys; on Windows search authorized_keys for svc-telemetry. Second, the extension: look for folders named anthropic.claude-code-2.1.313-* under the Cursor extensions directory. Third, persistence: on a Mac run ls ~/Library/LaunchAgents/com.apple.sysmond.plist, and on Windows run schtasks /query /tn SysMon. Any hit means that machine needs the full fix.

Is uninstalling the Claude Code extension enough to be safe?

No. Cursor warns that the backdoor installs standalone persistence and an SSH key that keep working after the extension is gone. Run Cursor's remediation script, remove the attacker key, rotate any secret the machine could reach, and rebuild developer laptops that showed the payload ran. Treat the host as compromised until every check comes back clean.

How should my clients vet the AI coding tools and extensions their developers install?

Treat every AI developer tool and its extensions as part of the supply chain, because a single leaked vendor key — here, a Fireworks AI key — backdoored builds that thousands trusted. Pin extension versions, watch for silent auto-updates, keep developer secrets out of plain environment variables where a recon payload can read their names, and give build and dev machines network egress rules so an outbound tunnel stands out. Periodic outside-in testing of the apps and cloud those developers push to closes the loop.