The first thing the attacker read was a folder of last year's chat logs.
Cursor published its full incident report on November 13, and the chain it describes begins with the least alarming object in the environment. An access key Cursor had issued to Fireworks AI, its third-party inference provider, was exposed on the Fireworks side. The attacker used that key to copy a read-only storage bucket Cursor shared with Fireworks. The bucket held coding-agent traces, mostly from 2025, captured from sessions where Privacy Mode was off. A small number of those traces contained credentials that had never been redacted. Those credentials carried the attacker out of a read-only bucket and into the SaaS tools Cursor runs its business on, and from there into the cache that serves Cursor's extension marketplace, where a modified build of the Anthropic.claude-code extension wrote an SSH backdoor onto as many as 5,000 developer machines.
Cursor puts figures on the exposure: coding-agent traces for fewer than 0.05 percent of users outside Privacy Mode, and API credentials for fewer than 0.01 percent of customers. Those are small fractions of a large user base, and the part worth your attention is the mechanism rather than the fraction. An archive of transcripts that nobody had classified as a secret store turned out to be one, and it was the step that turned a vendor's leaked key into code execution on other people's laptops.
Who needs to run a check today
The host-level half of this has a date and a platform list on it. Cursor's security notice names versions 2.1.312 and 2.1.313 for darwin-arm64 and win32-x64, served from the Cursor marketplace cache on October 29, 2026 between roughly 02:27 and 13:35 Pacific. If no machine in your fleet installed or updated that extension from Cursor inside that eleven-hour window, you can skip the hunt. Linux builds are absent from the list. Anthropic's own published extension was unmodified, and the Claude Code CLI distributed through npm was outside this incident entirely.
The clean build is 2.1.314, and the malicious copies were gone by October 30. The Hacker News gathered the research on what was shipped instead: Jenn Gile of OpenSourceMalware found a 66-line loader prepended to the legitimate JavaScript bundle, firing when the extension and its webview load, and researcher Paul McCarty noted that the reconnaissance it sent included the names, though not the values, of up to forty environment variables matching credential keywords. Socket and Microsoft Security Research both reported no evidence the build reached Open VSX, the Visual Studio Marketplace or npm, and Anthropic stated its own systems and employee laptops were not involved.
If a laptop did take the build, here is what sits on it. The payload collected host and user details, including hostname, username, operating system, architecture, home directory, environment variable names, working directories, Git email address and public IP, and posted them to an attacker endpoint. It then added an SSH key commented svc-telemetry to the user's authorized_keys, tried to switch the local SSH service on, and tried to open a reverse tunnel back to the same address. Enabling the SSH service generally needs administrator rights that Cursor does not hold, so on most hosts that step failed. The key and the persistence were written regardless. Cursor reports the attacker server is offline and the last activity it observed was blocked on November 1, which means a backdoored laptop currently has nowhere to call and would start calling again the day someone stands a new listener up on that address. For a small company, the cost of leaving it there is a developer workstation with a stranger's key on it and no owner, which is the kind of finding that turns a routine cyber-insurance questionnaire into a long conversation.
The second half applies to every team that lets an AI coding agent read a terminal, whether or not anyone here touched Cursor. Agent transcripts record what you typed, and what developers type includes tokens. Stated for a non-technical owner: the tool your developers use to write code keeps a written record of their working sessions, that record is stored by the vendor and sometimes shared with the companies that run the models, and anyone who reads it reads whatever passwords and keys happened to be on screen.
The host hunt for the svc-telemetry key
Cursor publishes the indicators, so this is one pass over a known list rather than open-ended hunting. The unauthorized key fingerprint is SHA256:0Z6R+DF64Do2nwQic8a7kkfDLNNk4IiK+2U2Rci4htk, and the payload extension.js hashes to ecb58cb29078d9646ad1dcdbe51526f2d9cfea06be5fb2ab183e8ecc3ab6bf15. Run this as the affected user on macOS, and the same indicator set on Linux if an agent host there shares the profile:
grep -s svc-telemetry ~/.ssh/authorized_keys && echo "IMPACTED: unauthorized key present"
# dropped scripts and key material
ls -la ~/.config/.smt ~/.config/.smtk 2>/dev/null
ls -la "$TMPDIR"/.stk_* /tmp/.stk_* 2>/dev/null
# persistence
ls -la ~/Library/LaunchAgents/com.apple.sysmond.plist 2>/dev/null
crontab -l 2>/dev/null | grep -F '@reboot /bin/sh'
# live tunnel attempts, retried about every 60 seconds
pgrep -af 'autossh -M 0|ssh -N -R'
On Windows the same indicators land in different places, and the scheduled task is named SysMon so that it reads as the Sysinternals tool in a task list. Check the action, not the name:
$keys = @("$HOME\.ssh\authorized_keys", "C:\ProgramData\ssh\administrators_authorized_keys")
Select-String -Path $keys -Pattern 'svc-telemetry' -ErrorAction SilentlyContinue
Get-Item "$HOME\.config\smt.cmd","$HOME\.config\smtk" -ErrorAction SilentlyContinue
Get-Item "$env:TEMP\.stk_*" -ErrorAction SilentlyContinue
Get-Item "$env:APPDATA\Microsoft\Windows\Start Menu\Programs\Startup\sysmon.cmd" -ErrorAction SilentlyContinue
Get-ScheduledTask -TaskName 'SysMon' -ErrorAction SilentlyContinue |
ForEach-Object { $_.Actions | Select-Object Execute, Arguments }
Get-Process ssh,autossh -ErrorAction SilentlyContinue
If you keep proxy or firewall logs, query them for outbound TCP 22 and HTTP POSTs to port 8099 at /beacon on 134.209.82.225 across the whole of late October. Cursor is explicit that removing the extension does not remove the backdoor, because the payload drops standalone scripts, and that a host showing payload execution may need rebuilding. Rotate anything reachable from that host from a machine you trust, not from the host itself. Cursor ships remediation scripts for macOS and Windows that exit non-zero while anything remains, and running those beats hand-deleting files at speed.
A large enterprise treats agent telemetry as a log of secrets
Cursor is one name in a run of them. BleepingComputer, reporting the incident on November 14, places it inside a wave of October intrusions against AI developer platforms that researchers at Wiz have labeled Black October, alongside Railway, Northflank, Lightning AI, OpenCode, Warp and Fireworks itself. One of those produced roughly 740,000 dollars in fraudulent AI charges from stolen customer authentication secrets. The pattern across them is consistent: the platforms are young, they hold developer credentials by design, and they share data with each other through keys that nobody has inventoried.
In large organizations, secret scanning stopped being a source-code control years ago. It runs against the places secrets accumulate by accident: build logs, ticket attachments, support mailboxes, shared buckets, data sent to processors. Retention is capped so the readable window is short. Data-sharing with a vendor is inventoried, so somebody can answer which buckets a given provider's key can read, and network rules narrow where that key may be used from. Developer tooling is governed like any other software supply chain, with allowlisted extensions, pinned versions and scheduled updates.
Cursor's remediation list reads as that programme being built in retrospect. It moved all inference off Fireworks, deactivated the key and cut the provider's access to shared datasets, rotated every exposed credential plus everything in internal use, expanded network restrictions for service providers, validated the remaining marketplace extensions, rebuilt the marketplace and redeployed production infrastructure. The entry worth copying is this one: it added secret scanning across code repositories and other internal data sources. Agent traces were an internal data source nobody was scanning.
The first question I ask on any engagement that involves coding agents is which directories the agent writes to and how long that output survives. Teams can usually name the model and the editor. Almost nobody can name the path.
The same four controls on a two-person budget
None of the enterprise versions need a platform purchase. The right-sized forms cost an afternoon.
Turn Privacy Mode on, and read what it covers
Everything Cursor says was spared belongs to Privacy Mode users. The traces in the stolen bucket came from sessions where it was off, and Cursor was permitted to retain them for training. Every agent vendor has an equivalent switch with an equivalent scope, and that scope is the part to read before you trust it.
Stop sending credentials through the agent at all
A secret typed into a prompt, pasted into a session to debug an API call, or echoed by a command the agent ran is now in a transcript that leaves your laptop. Keep values in environment variables or a secret manager and let the agent see the variable name. We treat this as the single highest-value change a small team can make, because it removes the class rather than the instance.
Scan the transcripts you already have
Point this at wherever your agent keeps session state and read the hits. The truncation is deliberate, so a review does not print live secrets into another log:
AGENT_DIRS=("$HOME/.cursor" "$HOME/.claude" "$HOME/.config/Code/User/globalStorage")
grep -rInE 'AKIA[0-9A-Z]{16}|ghp_[A-Za-z0-9]{36}|sk-[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|-----BEGIN [A-Z ]*PRIVATE KEY-----' \
"${AGENT_DIRS[@]}" 2>/dev/null | cut -c1-160
Every hit is a credential to rotate and a habit to retire. Cap retention afterwards by deleting old session directories on a schedule, which is a cron entry rather than a project.
Pin extension versions and take updates deliberately
An eleven-hour window in a marketplace cache is short enough that a weekly update cadence would have missed it. Pin the versions your team runs, review the diff of a release before adopting it, and keep a list of which extensions are approved. Verify the hash when a vendor publishes one, as Cursor did here.
Read your own agent transcripts before someone else does
Two actions close this out. If any machine took 2.1.312 or 2.1.313 from the Cursor marketplace on October 29, run the indicator sweep above today and treat a hit as a rebuild, not a cleanup. Separately, and whatever editor your team uses, grep your own agent session directories this week and rotate what you find, because the credential that moved this intrusion from a storage bucket into a software marketplace was one a developer typed into a chat window and forgot. We help small teams work out which of their tools keep transcripts, where those transcripts live and what is sitting in them, and that review is usually a single session rather than a project.
Need expert cybersecurity guidance?
We provide hands-on cybersecurity consulting for organizations that need practitioner-level expertise, including reviews of what your AI developer tooling records and ships to third parties. Book a session with our team.
