Cursor security breach Claude Code: Fireworks AI Data Leak

The Cursor security breach Claude Code incident via Fireworks AI leaked 5,000 SSH backdoors. Learn how this AI coding agent data leak exposed your keys.

A software engineer in a dim office looking at a laptop screen displaying red warning lines, with a coffee mug nearby and server racks in the background

Intro

Cursor confirmed that a breach of Fireworks AI credentials allowed attackers to distribute a malicious Claude Code extension through their marketplace, exposing up to 5,000 developers to potential SSH backdoors and data leaks. This incident represents a critical failure in the AI coding agent data leak supply chain, where unredacted API credentials stored in third-party inference buckets became the vector for compromise. The situation is not just about a hacked extension; it is about how easily sensitive operational data can flow from your coding environment into an external provider’s storage, only to be retrieved by an attacker who already knows where to look.

I run a small VPS hosting business, and I deal with real customers who often panic when I mention a “credential leak.” This Cursor event is that panic, made concrete. The breach started when hackers obtained an access key from Fireworks AI, a third-party provider for AI model training and inference. They used this exposed key to copy data from a read-only storage bucket that Cursor used to share information with Fireworks. This bucket contained historical AI coding-agent traces from 2025, collected from users who had not enabled Privacy Mode. Because these users had not secured their data, the traces included unredacted API credentials. These credentials gave the attackers the ability to access additional Cursor systems, leading to the theft of support emails, usage metrics, and archived source code containing business contacts.

The attack did not target Anthropic’s legitimate extension directly. Instead, the hackers exploited a stolen credential to publish malicious versions of the Claude Code extension, specifically 2.1.312 and 2.1.313, on Cursor’s VS Code extension marketplace on October 29. These malicious builds remained available for approximately 11 hours before removal. The malware attempted to install persistent SSH keys on developers’ computers. While coding errors likely prevented execution on most Windows and macOS systems where SSH was not already enabled, the risk is real for anyone who uses remote access tools. The incident highlights a broader trend I call “Black October,” where attackers target AI developer platforms to steal authentication credentials for unauthorized inference billing. This is not just a Cursor problem; it is a systemic issue with how AI coding agents handle data privacy.

As a site owner, you might think your code is safe because it is on your local machine or a private repository. But when you use an AI agent that sends traces to a third-party provider, that boundary disappears. The analogy is like leaving your house key in a shared mailbox that the mail carrier can access, but the mail carrier is now compromised. You cannot just assume the key is safe because it was in a “read-only” bucket. The key was in your hands, and if you did not enable Privacy Mode, you handed it over. This event forces a reevaluation of how we trust third-party inference providers. It is no longer enough to say the data is encrypted in transit; you must ensure that the storage configuration prevents unredacted credentials from being copied by an attacker who has access to the provider’s API keys. The immediate impact is clear: your API keys are likely in that stolen data if you did not enable Privacy Mode. You need to rotate them now.

Background: The Fireworks AI Vulnerability

Background: The Fireworks AI Vulnerability

To understand how a malicious extension ended up in the Cursor marketplace, you have to look at the supply chain behind the AI models themselves. Cursor does not run all inference in-house; it relies on third-party providers like Fireworks AI for model training and serving. The breach originated when attackers obtained an access key stored on Fireworks AI. This was not a brute-force hack of a strong password; it was a compromise of a credential that should have been treated like a root token for the entire data pipeline.

Once the attackers held that key, they accessed a read-only storage bucket that Cursor used to share historical data with Fireworks. This bucket contained AI coding-agent traces from 2025. These traces were not just logs of code; they were raw records of conversations between developers and the AI agents. Crucially, this data came from users who had not enabled Privacy Mode. For these users, their interactions were eligible for model training, meaning the full context of their work was stored.

The specific detail that turned this data leak into a systemic breach was the presence of unredacted API credentials within those traces. Because users were often pasting their own environment variables, API keys, and configuration files directly into the coding agent to get help, the AI recorded those strings. When the attackers copied the bucket, they did not just get code snippets; they got live credentials. Cursor’s incident report, as detailed by BleepingComputer (opens in new tab), notes that fewer than 0.05% of users had coding-agent traces exposed, and fewer than 0.01% had API credentials compromised. While those percentages sound low, they represent a significant number of developers in absolute terms, given the user base size.

The vulnerability here is not just a technical failure in Fireworks; it is a design failure in how data flows through these platforms. A “read-only” bucket is not safe if it contains secrets. It is akin to a library that allows anyone with a library card to read books, but those books are filled with your home address and social security number. The attackers used these stolen credentials to move laterally within Cursor’s infrastructure, accessing internal systems and SaaS tools. They stole archived source code, support emails, usage metrics, and even credentials that customers had previously shared with Cursor’s support team. This highlights a critical gap in how we think about third-party inference providers. We assume the provider is a neutral conduit, but when they hold the keys to your data pipeline, they become a single point of failure. If your AI coding agent stores unredacted secrets in a training bucket, you are effectively publishing your private keys to anyone who can get hold of the provider’s access tokens. The lesson is stark: if you use a third-party inference provider, you must assume that your data is not just stored, but is also exposed to that provider’s entire security posture.

What’s happening now: The Marketplace Extension Hack

The stolen credentials did not just sit idle. On October 29, attackers leveraged a compromised key to publish malicious versions of Anthropic’s Claude Code extension directly onto Cursor’s VS Code extension marketplace. Specifically, they injected malicious builds, designated as versions 2.1.312 and 2.1.313, into the cache layer that serves the marketplace. This is a critical distinction that often gets glossed over in initial reports. The attack did not compromise Anthropic’s legitimate extension repository or the Open VSX marketplace. Instead, it targeted the specific caching infrastructure Cursor uses to serve extensions to its own users. This architectural detail explains why the compromise was so localized yet so dangerous. The attackers did not need to hack Anthropic. They only needed to hijack the delivery pipeline between Cursor and its customer base.

These malicious builds remained available for approximately 11 hours before Cursor detected the anomaly and removed them. In the world of software supply chain attacks, an eleven-hour window is effectively an eternity. It is enough time for thousands of developers to open their editor, notice a “new version available” notification for a tool they trust, and click update. Cursor estimates that up to 5,000 users requested these specific affected versions during that exposure window. For context, if you run a small development agency with twenty engineers, and if even a tenth of them use Cursor as their primary editor, the statistical probability of at least one engineer pulling down a poisoned build is non-trivial. You do not need a massive enterprise to fall in the blast radius of an 11-hour malware distribution event. You just need a developer with an auto-update policy enabled and a standard workflow.

The payload itself was a modified version of the legitimate Claude Code extension. The attackers injected malicious JavaScript that executed upon installation. Its goal was not to log keystrokes in the traditional sense, but to establish a persistent remote access channel. The malware attempted to install an attacker-controlled SSH key onto the developer’s machine, enable SSH access if it was not already active, and configure persistence mechanisms to ensure the backdoor survived reboots. Think of it like a tenant moving into your office building. Instead of just renting a desk, they are trying to take a copy of your master key, drill a new lock on the back door that only they can open, and set up a routine that ensures they can always walk in, even after you change the locks on the front door. The intent was clear: establish a foothold that would outlast any immediate cleanup efforts by IT teams or the affected developers themselves.

What it means in practice

Did the malware actually execute those SSH backdoors on your systems? Probably not, but the nuance matters here. Security researchers who analyzed the malicious JavaScript found significant coding errors in the payload. Specifically, the logic that attempted to enable SSH services and install the rogue key likely failed on most Windows and macOS environments where the SSH subsystem was not already explicitly active in the background. If you run a standard developer workstation, you probably do not have an SSH server running locally, which means the malware had nowhere to latch onto. The attempt to enable it via command line likely triggered errors or security prompt failures, rendering the persistence mechanism inert. However, “inert” is a dangerous word for security professionals. It assumes every environment is standard. If you run custom development containers, always-on build servers, or macOS laptops with remote login enabled for your team, the surface area changes entirely. Do not assume the broken code saved you. Assume the code executed and verify your local authorized_keys files in your user home directories and system root directories. Look for any SSH public keys you do not recognize.

What data was actually stolen is less about your code and more about your operational metadata. Cursor disclosed that the attackers pulled archived, non-production source code repositories, some of which contained business contact information. They also took limited customer support emails, product usage metrics, and summaries of AI coding agent conversations. For a small business, this is the part that hurts. Those support emails likely contain your client lists, contract details, and internal discussions that reveal your technical debt or future roadmap. It is not just a privacy leak; it is a competitive intelligence leak. An attacker holding your support inbox from 2025 knows exactly which bugs your customers complain about and which features you promised but have not shipped.

The broader risk lies in how the initial vector propagated. The breach began with an access key stored on Fireworks AI, a third-party inference provider. Cursor used Fireworks for model training and inference, sharing data via a read-only storage bucket. Because many users had not enabled Privacy Mode, historical coding agent traces, including unredacted API credentials, were stored in that bucket. This is not just a Cursor problem. If you use Cursor, and you have not enabled Privacy Mode, your coding history is likely being used for model training and stored in third-party infrastructure. The Fireworks AI vulnerability exposed that these storage configurations are shared or accessible in ways that create massive supply chain risk. Other customers of Fireworks, including Notion, have also reported breaches linked to similar infrastructure exposures. The issue is the assumption that read-only storage is a safe boundary. It is not, if the provider’s own security is compromised.

I expect we will see a shift in how AI coding agents handle data retention. The days of defaulting to “we might use your code to make the AI better” without explicit, granular consent are ending. The cost of this breach, in both dollars and trust, is too high for anyone to ignore.

What to expect next

Cursor has already taken the immediate steps needed to stop the bleeding, and their incident report details specific remediation actions. They revoked the compromised Fireworks AI access key and rotated all exposed credentials. To prevent any further unauthorized extension distribution, they rebuilt their extension marketplace infrastructure and redeployed their production systems as a precaution. This is standard, but it does not undo the fact that malicious builds were available for eleven hours. You should also note that Cursor has moved all inference traffic away from Fireworks AI. This is a significant operational change. For a product that relies on third-party model providers, shifting the entire inference load away from a compromised partner indicates that trust in Fireworks’ security posture is, at least temporarily, broken. If you are building on similar multi-tenant AI infrastructure, this move suggests that providers are now more likely to sever ties with vendors who fail to maintain basic access control standards.

This incident is part of a wider pattern that security firm Wiz has labeled “Black October.” Over the past month, attackers have targeted development infrastructure across multiple platforms, including Railway, Northflank, Lightning AI, OpenCode, and Warp. The common thread is not just data theft; it is the misuse of stolen credentials to generate unauthorized AI inference. Attackers use compromised API keys to run expensive model tasks, racking up thousands of dollars in charges that land on the victim’s invoice. In the case of Railway, for instance, fraudulent charges reached approximately $740,000. Fireworks AI itself disclosed multiple breaches in October, including exposed API keys and access to development machines. This trend means that the risk to your infrastructure is not hypothetical. It is currently active, and the attack surface extends to any service that processes AI workloads for third parties.

I expect increased regulatory and contractual scrutiny on how AI coding agents handle data privacy and credential storage in the coming months. The assumption that read-only buckets are safe is being tested in courtrooms and boardrooms right now. More importantly, we will likely see a surge in demand for zero-trust architectures within AI development pipelines. You should anticipate that vendors will start providing more granular audit logs for inference data retention. For now, the industry is reacting, not proactively securing. Until these security controls become default, the burden of protection remains on you. You need to assume that any code you paste into an AI agent without explicit Privacy Mode settings is effectively public. The supply chain for AI development is currently the most unstable layer in modern software security, and the next breach is likely to happen in an environment you are using today.

Closing: Concrete Next Step

Your immediate action plan depends on whether you fall into the affected window. Check your extension history now. If you installed or updated the Claude Code extension between October 29 and early November, verify if you ran version 2.1.312 or 2.1.313. Most modern VS Code-based editors keep a local log of installed packages. On macOS or Linux, you can inspect ~/.cursor/extensions or check the command history for manual installations. If you are unsure, follow Cursor’s remediation guidance immediately. This usually involves removing the extension, checking your ~/.ssh/authorized_keys file for unauthorized entries, and reviewing your system’s launchd or systemd directories for persistent scripts that look like SSH configuration changes.

Do not wait for a security scan to catch this. The malware attempted to install persistent SSH keys, but coding errors likely prevented execution on many systems. Still, you cannot assume your machine is clean just because you did not notice any unusual behavior. A backdoor that sits dormant is still a backdoor. If you find anything suspicious, rotate your SSH keys across all your servers immediately. Use ssh-keygen to generate fresh key pairs and update your cloud provider’s security groups to allow only your new public key. This step is boring but essential. It cuts off the attackers’ primary entry point even if their script did execute partially.

Beyond the incident response, you need to change how you handle AI coding agent data. Enable Privacy Mode for all your Cursor and similar AI agent usage. This setting prevents your code, prompts, and traces from being stored in shared training buckets. Without Privacy Mode enabled, your unredacted API credentials and source code are sitting in a third-party storage bucket that could be compromised again. I have seen developers argue that Privacy Mode degrades the AI’s personalization, but that is a false tradeoff. You are not paying for your proprietary business logic to become public training data. The risk of unredacted data leaks outweighs the minor loss in model specificity. Treat Privacy Mode as a baseline security control, not an optional feature.

Finally, audit your third-party inference providers. If you use services like Fireworks, check their security documentation and data retention policies. Understand where your data goes and who has access to it. The breach exposed a gap in how Cursor shared data with Fireworks via a read-only bucket. Read-only does not mean secure if the access key is compromised. Assume any service that holds your secrets is a liability. If you run a VPS hosting business, apply this mindset to your customer data. Do not store customer credentials in shared buckets that serve multiple tenants. Isolate secrets per customer environment. The supply chain is the weak link, and you are the last line of defense. Take these steps now, before the next Black October hits your specific stack.