Cursor traces trojanized extension to stolen Fireworks AI access key
Cursor revealed that a compromised Fireworks AI access key allowed attackers to steal internal data and distribute a malicious Claude Code extension to up to 5,000 users.
Cursor has confirmed that the recent distribution of a trojanized version of Anthropic’s official Claude Code extension was enabled by an access key stolen during a breach at Fireworks AI. The incident, which unfolded in late October 2026, allowed attackers to pivot from exposed vendor credentials into Cursor’s internal systems and ultimately compromise its extension marketplace cache.
What happened
The attack chain began when an attacker obtained an access key that Cursor had issued to Fireworks AI. According to Cursor, this key was exposed by Fireworks during a separate security incident. The attacker used the stolen key to copy data from a read-only storage bucket that Cursor used to share information with the AI provider. This bucket contained limited coding agent traces from user sessions that were not protected by Cursor’s Privacy Mode, most of which dated back to 2025.
Among these traces were unredacted API credentials belonging to less than 0.01% of customers. The attacker leveraged these credentials to access select software-as-a-service tools used by Cursor. This initial foothold allowed them to retrieve archived non-production source code repositories, limited customer support data, product usage metrics, and some credentials users had previously sent to support teams. Cursor responded by deactivating the vendor key, rotating credentials, and temporarily disabling internal services to contain the breach.
The second phase occurred on October 29, 2026. Using credentials stolen from the earlier internal access, the attacker placed trojanized versions of the Claude Code extension directly into the cache serving Cursor’s extension marketplace. These malicious builds, versions 2.1.312 and 2.1.313, attempted to install a persistent SSH backdoor on affected systems. The compromised extension was available for approximately 11 hours before Cursor removed it and took the marketplace offline. At most 5,000 users who requested specific cached versions during this window may have received the malicious build.
Key details
- The root cause was an access key issued to Fireworks AI that was exposed during a separate breach at that provider.
- Attackers accessed a read-only storage bucket containing coding agent traces from sessions without Privacy Mode enabled.
- Unredacted API credentials from less than 0.01% of customers were found in the exposed traces.
- The trojanized extension was distributed via the marketplace cache for about 11 hours on October 29, 2026.
- Up to 5,000 users potentially received the malicious build, which attempted to install an SSH backdoor.
- Cursor has moved all inference traffic off Fireworks and cut off its access to shared datasets.
Background
This incident highlights the risks inherent in supply chain dependencies, particularly when sharing data with third-party AI providers. Cursor’s Privacy Mode is a feature that allows users to opt out of having their session data used for model training. Sessions not protected by this mode were stored in the bucket that the attacker accessed. While the bucket was read-only, the presence of unredacted credentials within the data traces provided the attacker with the keys to move laterally into other internal systems.
Supply chain attacks often target the trust relationships between software vendors and their service providers. In this case, the compromise of a vendor’s credentials (Fireworks AI) directly impacted the security posture of its client (Cursor). This cascading effect is a common pattern in modern cloud environments, where access keys and API tokens serve as critical bridges between different platforms. If these bridges are not strictly monitored and rotated, a breach at one end can compromise the entire chain.
Why it matters
For teams that self-host or manage their own software stacks, this incident serves as a stark reminder of the dangers of hard-coded or long-lived credentials. The fact that API credentials were left unredacted in data traces suggests a gap in data sanitization processes. When developers send credentials to support teams or include them in logs and traces, they create potential exposure points. If these data sets are shared with third parties for training or analytics, the risk multiplies.
Furthermore, the compromise of the extension marketplace cache demonstrates how attackers can bypass standard update mechanisms. By injecting malicious code directly into the cache, the attacker ensured that users requesting specific versions received the trojanized build without triggering immediate alarms in the main repository. This method exploits the complexity of content delivery networks and caching layers, which are often overlooked in security audits. Teams relying on third-party extensions must assume that even official channels can be temporarily compromised.
What you can do
- Audit your use of third-party AI services and ensure that any shared data is stripped of credentials and sensitive information.
- Enable privacy-focused settings like Cursor’s Privacy Mode to prevent session data from being stored in shared training buckets.
- Rotate all API keys and access tokens regularly, especially those shared with external vendors or service providers.
- Monitor your extension and plugin installations for unexpected behavior, such as new SSH connections or unusual network traffic.
- Verify the integrity of critical updates by checking checksums or hashes against official sources when possible.
- Limit the permissions of access keys issued to third parties to the absolute minimum required for their function.



