Cursor's Security Incident, Explained: How a Leaked Vendor Key Became a Malicious Extension on 5,000 Machines
On Nov 13, 2026, Cursor published its investigation: a key exposed by vendor Fireworks let an attacker copy 2025 agent traces, then plant a malicious Claude Code extension on the marketplace cache. At most 5,000 users got it in about 11 hours — and uninstalling it alone may not be enough.

On November 13, 2026, Cursor published an investigation update on its official blog, explaining what really happened in the security incident from two weeks earlier. On October 29, Cursor first disclosed that it was investigating a security incident: a malicious, unauthorized copy of Anthropic's Claude Code extension had turned up in Cursor's VS Code extension marketplace. After two weeks of investigation, Cursor has now laid out the full attack chain: the starting point was not a breach of Cursor's own production systems, nor a vulnerability in Claude Code itself, but a key issued to a vendor that leaked — and following that key, the attacker worked their way to the extension marketplace cache and finally pushed a poisoned extension onto the machines of up to 5,000 people.
This is worth reading carefully, not because the damage was enormous — by Cursor's account, the vast majority of customers were not affected — but because it exposes the most fragile link in the age of AI coding tools: the editor, the extension marketplace, and the conversation records your agents leave behind all sit on top of a long supply chain, and when any unremarkable link in that chain breaks, it is developers' machines that pay for it. One sentence in the update deserves to be remembered first by everyone who uses Cursor or Claude Code: if you installed or updated the Claude Code extension from the Cursor marketplace on October 29, and the version was 2.1.312 or 2.1.313, "uninstalling the extension alone may not be enough."
How it happened, step by step
Step one happened at Fireworks. Fireworks is a vendor that provided training and inference services to Cursor, and Cursor had issued it an access key. That key was exposed by Fireworks — Cursor's wording is blunt. The attacker took the key and copied data from a read-only storage bucket, the channel Cursor used to share data with Fireworks. The bucket held a limited set of coding agent traces, mostly from 2025, from sessions not in Privacy Mode — sessions Cursor was permitted to use for model training. The problem was that a small number of those traces contained credentials that had not been redacted. In other words, keys and passwords that should have been scrubbed before entering the training data slipped through, and ended up sitting in a shared storage bucket.
Step two: starting with the credentials fished out of those traces, the attacker reached some of the SaaS tools Cursor used. From there, they got access to things including select archived, non-production Cursor source code repositories, some of them containing business contact information; limited customer support data and email conversations; product usage metrics and contact details; summaries of some coding agent conversations; and some credentials users had sent to the Cursor support team. Note the scope here: "select" and "limited," and non-production repositories, not the production systems that run the service. But even so, a company's support emails, internal source code, and credentials users sent to support, all being read through at once, is serious enough — it means the attacker was holding not one key, but a whole ring of them.
Meanwhile, Cursor's monitoring systems spotted the unauthorized activity. Cursor says that once it became aware, it deactivated the vendor's key, opened an incident response workstream, and began revoking and rotating credentials, cutting off each new access as it was found. Out of an abundance of caution, it also temporarily disabled some internal and product services, going well beyond what the evidence required, which disrupted certain Cursor features for a while; each was restored once it was safe to do so. That detail is worth noting: many companies' first instinct after an incident is to play down the impact, whereas here Cursor admits the shutdowns went further than the evidence demanded — at least in posture, it is not pretending everything was under control.
Step three, the most damaging one, happened on October 29 itself. Using a stolen credential from the exposed data from its internal systems, the attacker placed malicious, unauthorized copies of Anthropic's Claude Code extension directly on the cache used to serve the Cursor VS Code extension marketplace. Cursor draws three important lines here: first, Anthropic did not publish this copy; second, this was not a vulnerability in Anthropic's product; third, the marketplace source, Open VSX, never had the malware. In other words, the poison did not come from the upstream extension registry, and Claude Code itself was not breached — someone bypassed the source entirely and contaminated the distribution cache on Cursor's side. Your editor goes to the marketplace to fetch an extension, it fetches what is in the cache, and if the cache has been swapped, what you get is the poisoned build — without you noticing anything, because it carries Claude Code's name and version number.
Step four was notification and containment. On October 30, Cursor published a security notice on its blog and on X, with indicators of compromise, remediation steps, and scripts to check your system, and began notifying affected users and team admins through in-app notices and email. Where credentials were exposed, Cursor 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 customer support or business data may have been involved, Cursor says it notified customers directly. Finally, Cursor says it believes the incident is contained: the last attacker activity it has seen was on November 1, and it was blocked. Monitoring continues, and if new information emerges that affects customers, they will be contacted directly.
The key numbers, taken one at a time
First, "at most 5,000 people." The official wording is that at most 5,000 users who requested specific cached versions of the extension on October 29 potentially received the malicious build. Three qualifiers matter, and none can be dropped: first, "at most" — this is an upper bound, not a confirmed victim count; second, "requested specific cached versions" — not everyone who installed Claude Code that day was hit, only those who happened to hit the poisoned cache version; third, "potentially received" — Cursor does not say all 5,000 installed the malicious build. The malicious version was available for approximately 11 hours before it was removed; Cursor then took the whole extension marketplace offline, and worked with the cloud provider hosting the attacker's server to take that down too. Eleven hours does not sound long, but for an extension marketplace with automatic updates, it is plenty — many people never notice their extension quietly updating itself in the background.
Next, "less than 0.01%." That is the share of customers who had API credentials exposed. The percentage is tiny, but it cannot be read on its own — it has to be read together with another figure: among users not using Privacy Mode, coding agent traces were exposed for fewer than 0.05% of users. So the exposure was genuinely narrow, but it was not spread evenly — it was concentrated among users who had not turned on Privacy Mode. Cursor says these users have each been notified directly, and if you did not receive a notification, your data was not in these traces. That is a check you can run on yourself: no notification means you can mostly relax; a notification means follow what it says.
Two more numbers are easy to miss, but they matter for understanding the boundaries of the incident. First, "mostly from 2025": the traces that were copied came mostly from 2025 sessions, not recent data. In other words, the attacker got hold of old data kept for historical offline analysis, not the live data you are sending to Cursor right now. Second, "November 1": the last attacker activity Cursor has seen, and it was blocked. The official wording is "we believe the incident is contained," not "it is definitively over" — the word "believe" leaves a little room, monitoring is ongoing, and the language does not overclaim. That is, if anything, the more honest way to put it.
Who can relax, and who needs to act now
The update includes a dedicated "what was not affected" list, and it is worth going through item by item, because for most users this list is the reassurance. First, if you use Privacy Mode, your prompts and code were not affected — the exposed traces came only from sessions not in Privacy Mode. This is the first time Privacy Mode has been shown to actually work in a real incident: it is not a decorative toggle, but a genuine dividing line. Second, any data or live traffic you are sending to Cursor right now was not affected; the exposed trace data was limited to storage used for historical offline analysis. Third, the production systems and infrastructure that run Cursor were not affected. Fourth, the Cursor app and its official updates were not affected — Cursor ships from a separate code hosting system the attacker never accessed, and no release signing keys were exposed. Fifth, customer code repositories were not affected. Sixth, no other extension in the marketplace was affected; Cursor says it validated that all other extensions were authentic, and reviewed and rebuilt the marketplace store. Seventh, other products including Cloud Agents for customer teams, Grok Bot, and all other SpaceX SI products were not affected. Eighth, active inference requests were not exposed, and as a precaution all inference has been moved away from the third-party training and inference vendor. Ninth, any plugins downloaded from the Cursor Marketplace were not affected.
The list is long, but what it really says is one thing: the damage was contained to two places — historical trace data, and the extension marketplace cache during those 11 hours on October 29. Beyond that, Cursor's core services, your code, and your live conversations were outside the blast radius. For the vast majority of users, this list is the conclusion: you are most likely fine, carry on.
But "most likely fine" is not the same as "everyone is fine." Two groups of people need to act right away. The first is anyone who installed or updated the Claude Code extension from the Cursor marketplace on October 29, with version 2.1.312 or 2.1.313 — whether or not you received a notification, go through the steps in the October 30 security notice in full. The second is anyone who received a notice from Cursor saying their credentials or support data may have been involved — the notice will list the specific keys to rotate, so rotate them as listed, not just a few of them. Team admins should pay particular attention: Cursor sent the list of keys to rotate to team admins, so if you manage a team, check your email and in-app notices first, rather than waiting for team members to come asking one by one.
"Uninstalling the extension alone may not be enough" — the weightiest sentence in the whole update
The sentence most worth underlining in the entire official update is this one: "Uninstalling the extension alone may not be enough." Why would Cursor say that? The update does not explain in detail what the malicious extension actually did on a machine — it does not say whether it stole credentials, left a backdoor, or sent data out. But the statement itself carries a judgment: merely deleting the extension does not guarantee the machine is clean. Any experienced developer hearing that should immediately think of the possibilities: the extension may have written other things to disk while it ran, may have changed configuration files, may have left something behind on the system. The update does not say which of these it was, but it clearly asks affected users to follow the full steps in the security notice rather than just deleting the extension and moving on.
There is a second layer to this sentence: it draws the responsibility line clearly. Cursor did not say "delete the extension and you will be fine," nor did it hedge vaguely. It said directly that uninstalling on its own is not enough. That is an uncomfortable but useful reminder for users: remediation after a security incident is usually not one action, but a set of actions. Running the check scripts in the notice, inspecting the system, rotating credentials — none of these steps can be skipped. If you did install one of those two versions around October 29, do not take the shortcut of only deleting the extension — spending half an hour going through the notice properly is far cheaper than discovering a problem later and cleaning up then.
One more thing: the update does not disclose the specific behavior of the malicious extension — it does not say what it stole, what it changed, or which server it talked to. The October 30 security notice contains indicators of compromise and check scripts, but this November 13 investigation update does not repeat those technical details. So any claim about "what this malicious extension does," unless it comes from Cursor's own security notice, should be treated with skepticism first. This article will not fill in what the official account left out, either.
Questions this update does not answer
No matter how candid an investigation update is, there will be things it leaves unclear. Picking those out is not nitpicking — readers deserve to know which conclusions are settled and which are still open. The first unanswered question: how exactly was the Fireworks key exposed? Cursor only says the key was "exposed by Fireworks," without saying how — whether Fireworks' own systems were breached, whether the key was sent somewhere it should not have gone, or something else entirely. The source of the leak was not in Cursor's own hands, and Cursor may not have the full picture, but for readers the question matters a great deal: it decides whether this was a targeted attack on Fireworks or a lapse in the vendor's everyday handling. The official account does not say, and this article will not guess.
The second unanswered question: did the attacker actually use the stolen credentials? Cursor says the attacker "accessed" source repositories, support data, usage metrics, and conversation summaries, and that it asked third parties to revoke the exposed credentials — but it does not say whether the attacker actually used those credentials to cause further damage, nor whether there is evidence the data was used elsewhere after being downloaded. Likewise, what the malicious extension did once installed on users' machines is not explained in this update. Without that information, readers cannot accurately judge how much real risk they faced, and can only proceed on the most cautious assumption — which is one reason Cursor asks affected users to go through the full remediation process.
The third unanswered question: behind the 5,000 figure, how many people actually installed the poisoned build? The official wording is "at most 5,000 users potentially received" it — an upper bound estimated from request volumes, not an actual installation count. The real number of installs may have been far below 5,000, or close to it; the update gives no more precise figure. Nor does it say whether anything was taken from affected machines before the attacker's server was taken down. None of this necessarily means Cursor is hiding something — as of November 13, some questions simply have no exact answer yet — but readers should be clear-eyed about it: the official conclusion is "we believe the incident is contained," not "all the damage has been fully tallied."
The fourth unanswered question concerns the timeline itself. How much time passed between the attacker obtaining the key, copying the traces, getting into the SaaS tools, and finally pushing the malicious extension on October 29? The update gives no specific dates for the key exposure or the trace copying, only that the traces were mostly from 2025. Readers therefore have no way of knowing whether the gap between the first step and the last was days, weeks, or months. That span actually matters: if the attacker lay low for a long time before acting, this was a patient operation; if the whole chain moved fast, the chain itself was fragile. The official account does not say, so for now it is a question to keep on file for a future update.
If you use Cursor or Claude Code, here is what to check now
Start with the most direct check: open your editor and look at the Claude Code extension's version and install history. If you use the Cursor marketplace and installed or updated Anthropic.claude-code around October 29, and the version happens to be 2.1.312 or 2.1.313, go through the steps in Cursor's October 30 security notice in full, including running the check scripts it provides. Do not just delete the extension, and do not glance at the version number and assume you are fine — the steps in the notice are the complete process the official account endorses. The exact steps and scripts are in that security notice; this article does not restate or rewrite them, because the details of a security procedure must come from the official notice verbatim — getting even one step wrong in a paraphrase could mislead someone.
Second, check your notifications. Cursor says it has notified every affected user and team admin through in-app notices and email. Open Cursor and look at the in-app notices, then search your email — including the spam folder — to confirm whether you received such a notice. If you did not, you are most likely outside the exposed set; if you did, follow exactly what the notice says, especially the list of keys to rotate. If you are a team admin, handle this first: the list was sent to you, and your teammates' credentials may be waiting on you to rotate them.
Third, take the opportunity to check any credentials you have ever handed to Cursor support. The official account says the data the attacker reached included "some credentials users had sent to the Cursor support team." If you have ever pasted an API key, access token, or similar secret directly into a support ticket or email, rotate those credentials whether or not this incident touched you. Pasting secrets into a support conversation is a bad habit in itself — the right approach is to give support only the minimum information needed to solve the problem, and never send keys outright. This incident is just one more proof of why not.
Fourth, reconsider whether Privacy Mode should be on. The most concrete lesson of this incident is that users with Privacy Mode on had their prompts and code unaffected, while those without it were the ones whose traces could be exposed. The cost of Privacy Mode is that your sessions cannot be used for model training; what you get in return is a genuine data boundary. If you have been running on the defaults and never thought about this switch, now is a good time to look at it. For an individual developer, it costs nothing to decide; for a team, it is worth agreeing internally whether the default should be on or off — it should not be a question nobody has ever considered.
Finally, there is a broader check worth doing for anyone who uses AI coding tools: where do your extensions come from, and is automatic updating on? In this incident, what was poisoned was not the source of the extension, but a cache on the distribution path. Open VSX was clean, Anthropic's product had no vulnerability, and users were still hit. That shows "the extension itself is fine" is not the same as "the extension you installed is fine" — any link in between, a cache, a mirror, a marketplace service, can be tampered with and turn something clean into something dirty. There is not much you can do day to day, but at least two things are real and practical: first, do not install extensions from unknown third-party marketplaces; second, after an important extension updates, glance at the version number and release time — if you see a version you do not recognize, pause and check before installing. The reason an 11-hour window could reach 5,000 people is largely that automatic updates meant many of them never realized they had installed a new version at all.
What Cursor says it has already changed
The second half of the update lists the measures already taken, and going through them one by one, the changes are substantive — though a few are worth thinking about. First, all inference traffic has been moved off Fireworks, the key issued to it has been deactivated, and its access to all shared data sets has been cut off. That is the decisive step: the vendor at the center of the incident has been disconnected outright, rather than kept on with a fresh key. Second, every exposed Cursor credential found has been rotated, highest risk first, and as a precaution all credentials in use across internal systems have been rotated, even where there was no evidence of exposure. Third, all other extensions in the marketplace have been validated as authentic, and the whole VS Code extension marketplace has been reviewed and rebuilt. Fourth, network access restrictions have been expanded so that, where possible, compromised credentials cannot be used outside their intended location. Fifth, secret scanning and protections have been added across all code repositories, and scanning has been expanded to other internal data sources. Sixth, as a precaution, all production infrastructure and services have been redeployed, and every internal service was reviewed before being restored. Seventh, external forensics experts have been engaged to support the investigation. Eighth, everyone affected has been contacted.
The item most worth noting in that list is the fifth: secret scanning across all repositories, expanded to other internal data sources. Recall where this whole incident started — traces containing "credentials that had not been redacted." The failure was in the redaction step. Failed redaction is not a hard technical problem; it is a process problem: before data enters a training set or a shared storage bucket, there should have been a check to strip credentials out, and that check missed some. Adding secret scanning is the right medicine for that, but it treats "don't let it happen again," not "what about what already leaked." What already leaked has been copied away; all Cursor can do is revoke and rotate, and the update admits as much.
One more thing worth saying: Cursor says it "redeployed all production infrastructure and services." That is a very expensive action — no company redeploys its entire production environment for an incident that is already contained unless it has a reason. Doing it anyway suggests Cursor is not one hundred percent certain about what the attacker touched, and chose the most thorough option available. That is caution, and it is also a kind of honesty: it amounts to admitting that however complete the investigation looks, there may be corners it has not seen. For users, that is actually a reassuring signal — a company willing to pay the cost of a full redeployment for "things we may not have found" is more credible than one thumping its chest and saying "definitely nothing is wrong."
Why this is not just "Cursor had an incident"
On the surface, this looks like an ordinary vendor key leak: modest in scale, limited in impact, handled reasonably promptly. But placed in the wider context of AI coding tools, it means considerably more. Over the past two years, developers have handed more and more of their work to AI coding tools: writing code, changing code, running tests, looking up documentation, even letting agents change production configurations directly. For these tools to work, they need access to your code, your prompts, your API keys, your repository permissions. Your editor stopped being a plain text editor a while ago — it is the foothold of an agent holding everything you own.
That is exactly why the security boundary of an AI coding tool is far wider, and far more fragile, than that of traditional software. When traditional software has a security problem, it is usually a vulnerability in some component; when an AI coding tool has one, it can be training-data redaction done badly, a key issued to a vendor managed loosely, or a cache in the extension marketplace being poisoned — and every one of those paths touches real user data and real machines. In this incident, the attacker did not even need to breach Cursor's production systems or find a vulnerability in Claude Code; all it took was one leaked vendor key plus a cache nobody was watching, and the poisoned extension reached 5,000 machines. How cheap that attack path was is the genuinely chilling part.
For the industry as a whole, this incident leaves at least three lessons. The first is about training data: as long as you keep training on users' real sessions, redaction is not a step that can be "good enough." The fact that unredacted credentials were mixed into Cursor's traces shows a gap in the redaction process, and that gap became the starting point of an entire attack chain. Any company training on real user data should treat this incident as a free audit: has your redaction process been independently verified? Could your training data also contain things that should not be there?
The second lesson is about vendor management: how much access a key issued to a vendor should have, which data it can reach, how often it should be rotated — these look like small questions day to day, and only reveal themselves as big ones after an incident. Cursor's subsequent move — cutting off Fireworks' access to all data and moving away all inference traffic — itself suggests the data-sharing relationship before the incident may have been broader than necessary. The principle of least privilege is easy to state and takes sustained effort to practice — and this incident is the price of not putting in that effort.
The third lesson is about distribution: extension marketplaces, plugin marketplaces, model marketplaces — these "marketplaces" have become the main channel through which developers get their tools, but their security model still rests on the assumption that "a clean source means clean distribution." This incident broke that assumption: the source, Open VSX, was clean, and people were hit anyway, because the contamination happened at the cache layer. For any platform running a similar marketplace, that is a warning: verifying the source alone is not enough — caches, mirrors, and CDNs in between need signature verification and integrity checks too. Otherwise the next thing to be poisoned could be a different marketplace, a different cache, a different 5,000 people.
Back to the reader: what this incident ultimately says is simple. AI coding tools give you a great deal of convenience, but they also stretch your chain of trust very long. Your code, your keys, your conversation records have to pass through the editor, the extension marketplace, the model vendor, and the training-data pipeline before they become those few lines on your screen. Every link in that chain is worth one more question: is it safe? Cursor has now opened up its own chain and talked through it — not perfectly, and with some questions left unanswered, but at least it talked. The best response from users is neither panic nor indifference, but to use the moment to run the checks that are due: look at your extension versions, check your notifications, look at the Privacy Mode switch, and rotate the keys that should have been rotated long ago. None of that takes long, but the next time something like this happens, those are the things standing between you and being hit.
Cursor says that if anything important changes, it will update this blog post. In other words, the November 13 update may not be the last chapter of this incident. If there are further developments — a more precise victim count, a disclosure of what the malicious extension did, an explanation of how the Fireworks key leaked — they will be worth following up. Until then, start with the steps in the October 30 security notice, and get the checks done.
Comments (0)
Sources
Related articles
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.