Cursor Security Breach: How a Stolen Key Spread Malware

A stolen Fireworks key let attackers copy Cursor traces and publish a malicious Claude Code extension for eleven hours. Uninstalling it is not cleanup.

By Muhammad Saif and Aashan Khan · Techtribe co-founders

The Cursor security breach is a supply-chain incident, not a setting you forgot to tighten. An attacker started with a key Cursor had given to Fireworks, copied historical coding-agent traces, and on October 29, 2026 used a credential from that trail to put a malicious Claude Code extension on the cache that served Cursor's VS Code marketplace. The bad builds, Anthropic.claude-code 2.1.312 and 2.1.313, sat there for about eleven hours. Cursor says at most 5,000 people who asked for those cached versions could have received them. Anthropic did not publish the copy. Open VSX never had it.

That is a different problem from the permission question in what a coding agent is allowed to reach. Permissions decide what a trusted agent may do on a machine you chose. This incident is a vendor key, a training bucket, and a marketplace cache. The agent did not have to be tricked. The update channel was.

The Fireworks side of the same October is in what the Fireworks breach exposed. Read them together. One is the company that stored the traces. The other is the company whose key was in that store.

What Cursor says happened

Cursor's incident update, published November 13, 2026, is the account to use. The October 29 security notice is the account of the extension itself, including the checks. Secondary write-ups at BleepingComputer and The Hacker News retell those posts. When they disagree with Cursor, use Cursor.

The update's sequence has five steps, and the order matters.

It started at Fireworks. An attacker obtained an access key Cursor had issued to Fireworks. Cursor says the key was exposed by Fireworks, and that the attacker used it to copy data from a read-only storage bucket Cursor used to share data with them. The bucket held limited coding-agent traces, mostly from 2025, from sessions that were not in Privacy Mode, which Cursor says it was permitted to use for model training. A small number of those traces contained credentials that had not been redacted. Cursor's figure for API credentials in that set is less than 0.01 percent of customers. Starting from those credentials, the attacker reached select SaaS tools Cursor uses. From those tools they reached select archived non-production source repositories, some of which contained business contact information, plus limited customer-support data and email conversations, product usage metrics and contact details, summaries of some coding-agent conversations, and some credentials people had sent to Cursor support.

Cursor's monitoring saw the unauthorized activity. It deactivated the vendor key, opened an incident response, and started revoking credentials. As further access showed up, it cut that off too. It also disabled internal and product services beyond what the evidence required, which disrupted some Cursor features, and restored each one when it judged that safe.

On October 29 the attacker published the extension. Using a stolen credential from the exposed internal data, they placed malicious, unauthorized copies of Anthropic's Claude Code extension directly on the cache used to serve the Cursor VS Code extension marketplace. Cursor is explicit that Anthropic did not publish this copy and that this was not a vulnerability in Anthropic's product. The marketplace source, Open VSX, never had the malware. At most 5,000 users who requested specific cached versions that day potentially received the malicious build. It was available for approximately eleven hours. Cursor took it down, took the extension marketplace offline, and worked with the cloud provider hosting the attacker's server to take that server down.

On October 30 Cursor published the security notice, with indicators and scripts, and began notifying affected users and team admins in the product and by email. Where credentials were exposed, it says it emailed team admins a list of the specific keys to rotate and asked the third-party services that issued those credentials to revoke them. Where support or business data may have been involved, it notified those customers directly. People who installed or updated to the tampered 2.1.312 or 2.1.313 builds during the window are told to follow the notice. Uninstalling the extension alone may not be enough.

Cursor says the last attacker activity it has seen was on November 1, and that the activity was blocked. It says it will contact customers directly if it finds more that affects them. "Contained, as of this post" is not "nothing else will ever turn up." Assign someone to the security blog for the next month. A second update that widens the set is how these incidents usually continue.

What the extension tried to do

The October 29 notice is narrower than the November 13 update, and it is the one that tells a laptop owner what to look for. The bad builds were Anthropic.claude-code versions 2.1.312 and 2.1.313, for Windows and macOS, in the Cursor VS Code Extension Marketplace. The window was about 2:27 a.m. PT to 1:35 p.m. PT on October 29, 2026. Other extensions from the marketplace, and Cursor's other products, are called out as not part of this package.

Cursor describes the behavior in plain terms. The extension collects and reports host and user information: hostname, username, operating system, architecture, home-directory path, environment-variable names, working directories, configured Git email, and public IP. It attempts to add an attacker-controlled SSH key to authorized_keys, enable the local SSH service, and open a reverse SSH tunnel. Cursor says that outside highly unusual cases where Cursor was started with administrator privileges, errors in the malicious code meant this step would fail. Enabling the local SSH service needs admin rights the extension does not have on most macOS and Windows hosts. On those hosts the attacker could not have logged in through the tunnel. The extension still added the attacker's SSH key, installed persistence, and sent host details. Cursor says to follow the remediation anyway.

Persistence is the part that survives an uninstall. On macOS the notice describes a LaunchAgent. On Windows it describes a scheduled task that attempts to run as SYSTEM, with a Startup-script fallback. Background scripts retry the tunnel roughly every sixty seconds. The attacker server no longer functions. Cursor says it worked with the hosting provider to take it offline, so the reverse shell and the host-detail post are not functional. A dead server does not delete the key already written to the laptop, and it does not delete the plist or the scheduled task. Those are local files. They wait for a network that answers.

The notice tells you how to check without guessing. The malicious extension appends a public key whose comment is svc-telemetry. On a Mac, search ~/.ssh/authorized_keys for that comment. On Windows, search the user authorized_keys and, if it exists, the administrators authorized-keys file. Cursor publishes the exact commands and the remediation scripts on the notice. Use those. Do not retype a key from a blog, including this one. If the comment is present, Cursor says the machine is impacted: isolate it, remove the key and the persistence, decide whether the host should be rebuilt, and rotate credentials and sessions that were reachable from it, from a trusted system. The notice is explicit that the limited environment-variable collection does not rule out later credential access over the backdoor, for the hosts where the tunnel could actually come up.

Linux is in the indicator list even though the affected marketplace builds named in the notice are Windows and macOS. If a team shares dotfiles, a copied authorized_keys, or a config directory, the comment can travel. Search the comment. Do not assume the operating system in the notice is the only place a copied file can land.

What Cursor says was not hit

The update's negative list is as useful as the positive one, because a breach post gets retold until every product sounds breached.

Privacy Mode prompts and code were not in the exposed traces. For people not using Privacy Mode, coding-agent traces were exposed for fewer than 0.05 percent of users. Cursor says it identified those users and notified each of them. If you did not receive a notification, Cursor says your data was not in those traces. That 0.05 percent figure is traces. The earlier 0.01 percent figure is API credentials inside a small number of those traces. They are not the same set. Do not collapse them into "almost nobody."

Live traffic you are sending now was not in the copied bucket. The exposed traces were historical, for offline analysis. Production systems that run Cursor were not the path Cursor describes. The Cursor app, its official updates, and the code shipped to the client and to cloud services come from a separate code host the attacker never accessed, and no release signing keys were exposed. Cloud Agents for customer teams, and Cursor's other named products, are listed as not affected. Other extensions in the marketplace were validated as authentic, and the store was reviewed and rebuilt. Plugins from the Cursor Marketplace are listed separately as not part of this. Active inference requests were not exposed, and Cursor moved inference off the third-party vendor as a precaution. Customer code repositories were not in the exposed set Cursor describes.

Read that last line against the traces. A customer repository not being stolen is not the same as a trace of a session that edited that repository. A trace can contain a diff, a secret the model saw, or a command. Cursor's own split is the one to keep: repositories were not accessed as repositories; a small share of historical traces were copied; a smaller share of those contained unredacted API credentials. If you were notified, read the notice you were sent. It names the category. A blog cannot tell you which category you are in.

Archived non-production source is still source. Business contact information in a repo is still a list of people. Support emails are still the place customers paste tokens when they are stuck. Cursor says some credentials sent to support were in the accessed data, and that it asked the issuing services to revoke the ones it could name. If you pasted a production key into a support thread this year, do not wait to remember whether the thread was in the "limited" set. Rotate it. The cost of a wrong rotation is an afternoon. The cost of a right one you skipped is the key.

Privacy Mode is a boundary, not a feeling

The update hangs a bright line on Privacy Mode. Prompts and code in Privacy Mode were not in the bucket. Sessions not in Privacy Mode were eligible for the training-share bucket, and that is the bucket that was copied. The line is real. It is also a product setting, and product settings drift.

A team plan can say Privacy Mode is on while a personal account on the same laptop is off. A trial, a second org, or an agent run from CI can be the session that was eligible. "We use Privacy Mode" is a sentence to test against the account that actually ran, in 2025, because the traces Cursor describes are mostly from 2025. A policy written in November 2026 does not rewrite a bucket filled last year.

This is the same shape as a zero-retention clause that covers one API and not the dataset beside it. The Fireworks bulletin taught that lesson from the provider side. Cursor's update teaches it from the customer side. The data that left was the data a contract allowed the vendor to hold for training, plus credentials that should never have been in a trace and were not fully redacted. Holding the data was permitted. Losing the key that could read the hold was not. Both facts can be true, and the second one is the incident.

If you are deciding whether to turn Privacy Mode on after the fact, turn it on. It does not pull back a trace already copied. It changes what the next bucket can contain. Pair it with a rule the setting cannot enforce: do not put live secrets in a prompt, a rules file, or a support reply. Redaction that fails 0.01 percent of the time is how a training corpus becomes a credential dump. Treat paste of a key into an agent as an incident of its own, on a Tuesday when nothing else is wrong.

The marketplace cache is the new install script

A lockfile pins a version. A marketplace cache is a place a stolen credential can write a version the lockfile never saw, for people who ask the cache for that version on that day. Cursor's description is specific. The malware was not in Open VSX. It was on the cache used to serve Cursor's VS Code extension marketplace. Someone who installed Claude Code from Anthropic, or who did not request those two versions on October 29, is not in the "at most 5,000" set. Someone who updated inside the window is.

That is why "we pin extensions" is only half a control. You can pin a version and still receive a tampered build of that version if the bytes behind the pin were replaced. The notice publishes hashes for the malicious VSIX files. If you keep extension artifacts, compare them to Cursor's list, on Cursor's page, not to a number copied into a chat. Hashes drift out of articles. The vendor page is the list that gets corrected, and Cursor already corrected the notice once, on October 30.

The same week you are cleaning laptops, read what a malicious npm package can do to the agent. That path is an install script and a hook in the repo. This path is a marketplace cache. MCP server security is the third door: a server entry that runs because the client starts it. A team that reviews only one of the three will feel done and still be exposed on the other two. The review is the channel that executes, not the brand on the editor.

Generated apps make the channel wider, because the editor is also the production path. A founder who built the product in Cursor, with cloud keys in the environment and the extension set to auto-update, had both the trace risk and the laptop risk. The trace risk depends on Privacy Mode and on whether Cursor notified them. The laptop risk depends on whether 2.1.312 or 2.1.313 was installed in that eleven-hour window. Those are independent. Check both. A clean authorized_keys does not mean your old traces were never copied. A notification that your traces were copied does not mean the extension ran.

What to do this week

Work from Cursor's pages, then from your own inventory. The order below is the order that avoids the usual mistake, which is rotating a key on a machine that still has the attacker's key in authorized_keys.

  1. If you installed or updated Anthropic.claude-code 2.1.312 or 2.1.313 from Cursor's marketplace on macOS or Windows between 2:27 a.m. and 1:35 p.m. PT on October 29, 2026, run Cursor's check for the svc-telemetry key comment. Use the commands on the notice.
  2. If the comment is there, isolate the host. Remove the key, the persistence, and any tunnel process using Cursor's remediation script, or rebuild the machine. Uninstalling the extension leaves the dropped scripts.
  3. Rotate credentials and sessions that were available on that host, from a different machine. Include cloud keys, npm tokens, GitHub tokens, and anything the agent could see in the environment. The notice says the payload's own collection was limited to names of environment variables, not values, and also says that does not rule out later access where the tunnel worked.
  4. If Cursor emailed you a list of keys, rotate those whether or not the laptop check is clean. The trace theft and the extension are two outcomes. You can be in one and not the other.
  5. If you pasted a secret into Cursor support, or into a session that was not in Privacy Mode in 2025, rotate it. Do not wait to be sure you were in the fraction of a percent. Cursor says it notified the people whose traces were copied. Silence is evidence you were not in that set. It is not evidence you never pasted a key.
  6. Turn Privacy Mode on for every account that runs against real code, including CI and the personal account on a work laptop. Write down the date you checked, not the date the policy was announced.
  7. Treat extension updates like dependency updates. Note who is allowed to install from the marketplace, and keep the notice open until you have recorded the result of the key search. A Slack message that says "we think we're fine" is not a record.

Cursor says it moved inference off Fireworks, deactivated the key, rotated exposed credentials and, as a precaution, credentials it had no evidence were exposed, rebuilt the marketplace, tightened network restrictions on providers, added secret scanning, and redeployed production infrastructure. That is Cursor's cleanup. Yours is the laptop, the keys you pasted, and the accounts that were not in Privacy Mode. Their redeploy does not rotate your GitHub token.

If the product itself was built by an agent that held production credentials, the extension check is the start, not the audit. An agent with a cloud key in its environment is an agent that can have used that key in a session whose trace was eligible to be stored. List those keys. The list is the work. A coding assistant that can deploy is a production system, and production systems get a named owner, a key scope, and a way to turn the tool off. That is AI agent development as an engineering problem: the tool is in the request path, so the tool's vendor incidents are your incidents.

The breach is a reminder with a date on it. The key you gave a model vendor can read the bucket you filled for training. The credential in that bucket can write the cache your editor trusts. Uninstall is not the end of the file the installer already wrote.

If this is your app, send the repo.

A 30-minute scope call. We read what is live, name what is dangerous, and quote a fixed scope.

How Techtribe checks a machine after a marketplace incident

We separate the two questions Cursor's own posts separate: whether a laptop installed the tampered extension, and whether a key or a trace may have left through the vendor. You get a written list of accounts, Privacy Mode state, and credentials to rotate, including the ones that lived in support threads and agent environments. We use the vendor's indicators. We do not invent a second set.

A one-time pass fits when the team is small and the editor is the main agent. A Dedicated Team fits when new tools keep getting a token and nobody owns the review of hooks, extensions, and MCP servers. The scope call is 30 minutes with a founder, and it is where we say which you are in.

Bring the list of who uses Cursor, whether Privacy Mode is actually on, and whether anyone installed or updated Claude Code on October 29. If a cloud key sat in the environment, say that first.

The fixed scope for taking a generated app to production is a page per tool: Lovable, Bolt, v0, and Replit.

Questions

What was the Cursor security breach?

Cursor says an attacker used an access key Cursor had issued to Fireworks, copied historical coding-agent traces from a read-only bucket, and on October 29, 2026 placed unauthorized copies of Anthropic's Claude Code extension on the cache that served Cursor's VS Code extension marketplace. Versions 2.1.312 and 2.1.313 were available for about eleven hours.

Did Anthropic publish the malicious extension?

No. Cursor says Anthropic did not publish the copy, that this was not a vulnerability in Anthropic's product, and that Open VSX, the marketplace source, never had the malware. The copies were placed on Cursor's cache.

Is uninstalling the extension enough?

Cursor says uninstalling is not enough. The payload drops persistence that can keep running after the extension is gone: an SSH key comment, a LaunchAgent on macOS, or a scheduled task on Windows. Use Cursor's check and remediation scripts, then rotate credentials from a trusted machine.

Were Privacy Mode users' prompts exposed?

Cursor says prompts and code were not exposed for people using Privacy Mode. For people not using Privacy Mode, it says coding-agent traces were exposed for fewer than 0.05 percent of users, and that it notified those users. If you did not get a notice, Cursor says your data was not in those traces.

Book a free call

Have a vibe-coded app in production?

30-minute free call. We'll read what you have, name what is dangerous, and quote a fixed scope.