Cursor Marketplace Breach: Fireworks Key Leak Led to Backdoor

A third-party key leak at Fireworks AI allowed threat actors to access unredacted AI conversation traces, pivot into Cursor internal tooling, and distribute a trojanised Claude Code extension.

TL;DR

  • Vendor Fireworks AI exposed a read-only cloud storage key issued by Cursor, enabling threat actors to exfiltrate unredacted AI agent conversation traces.
  • Unedited credentials inside the non-Privacy Mode session logs compromised API keys for less than 0.01% of Cursor customers, allowing attackers to access Cursor’s internal SaaS tooling and archived non-production repositories.
  • On 29 October 2026, attackers used stolen internal credentials to inject trojanised builds of Anthropic’s official Claude Code extension (versions 2.1.313 and 2.1.312) into Cursor’s marketplace distribution cache.
  • The trojanised extension attempted to deploy a persistent SSH backdoor on developer endpoints; up to 5,000 users requested the cached builds during an 11-hour exposure window.
  • Cursor contained the incident by clearing the marketplace cache, deactivating the vendor key, migrating inference traffic away from Fireworks AI, and rotating internal credentials, with no further malicious activity detected post-1 November 2026.

In late October 2026, a complex multi-stage supply-chain incident demonstrated how vendor credential exposure and unredacted AI telemetry can combine to compromise local developer environments. The cursor marketplace breach originated not from a zero-day flaw in the IDE core codebase, but through an exposed access key issued to third-party inference provider Fireworks AI. According to vendor disclosures reported by The Hacker News, threat actors leveraged this key to access a shared storage bucket containing historical coding agent conversation logs, extracting embedded operational credentials.

The stolen secrets granted attackers access to select internal Software-as-a-Service (SaaS) applications used by Cursor. From this access point, the attackers obtained administrative tokens that allowed direct modification of Cursor’s extension marketplace caching infrastructure. On 29 October 2026, the threat actors uploaded trojanised versions of Anthropic’s official Claude Code extension directly into the distribution cache, targeting developer endpoints with a persistent SSH backdoor payload.

Although Cursor contained the compromise within days—severing integrations with Fireworks AI and purging the infected cache layer—the incident highlights critical systemic risks in modern AI development stacks. When prompt traces retain authentication tokens and third-party AI pipelines lack strict boundary controls, minor vendor leaks can rapidly escalate into enterprise distribution attacks. Security teams evaluating AI tools must look beyond static code repository scanning and address the implicit trust placed in telemetry storage and extension edge caches.

1. The Fireworks AI Key Leak and Attack Chain Summary

The compromise sequence spanned multiple distinct operational domains, moving from a third-party AI model vendor into Cursor’s cloud infrastructure, and ultimately reaching client developer workstations. The attack chain relied on credential reuse and unredacted data lakes rather than binary exploitation of the Cursor client application itself.

+---------------------+       +------------------------+       +------------------------+
| Fireworks AI Key    | ----> | Shared Read-Only       | ----> | Unredacted Agent       |
| Exposure (Vendor)   |       | Storage Bucket Exfil   |       | Telemetry Traces       |
+---------------------+       +------------------------+       +------------------------+
                                                                            |
                                                                            v
+---------------------+       +------------------------+       +------------------------+
| Developer Endpoint  | <---- | Extension Marketplace  | <---- | Stolen Internal SaaS   |
| SSH Backdoor Target |       | Cache Poisoning        |       | Administrative Access  |
+---------------------+       +------------------------+       +------------------------+

The primary vector began when an access key issued by Cursor to Fireworks AI was exposed during a security incident at Fireworks AI. Attackers used this key to authenticate against a read-only cloud storage bucket host maintained by Cursor to pass data to Fireworks AI for model training. The bucket contained historical coding agent session traces, primarily from 2025, belonging to users who had not enabled Privacy Mode.

Date / Timeline Attack Chain Phase Affected Target Asset Operational & Threat Impact
Prior to October 2026 Telemetry Accumulation Shared Read-Only Cloud Storage Bucket Retention of non-Privacy Mode coding agent logs containing embedded API keys.
Early October 2026 Vendor Credential Theft Fireworks AI Infrastructure Cursor-issued read-only storage key exposed during Fireworks AI system compromise.
Mid-to-Late October 2026 Data Exfiltration & Pivot Cursor Internal SaaS Applications Attackers copied bucket data, extracted secrets, and accessed internal SaaS tools and archived repos.
29 October 2026 Marketplace Cache Poisoning Cursor Extension Marketplace Cache Trojanised Claude Code extensions (2.1.312 / 2.1.313) cached for 11 hours (~5,000 requests).
1 November 2026 Containment & Remediation Cursor Production & Vendor Integrations All unauthorized access halted; Fireworks key revoked; inference traffic migrated off vendor.

By parsing the unredacted session traces within the bucket, the attackers isolated active API keys and service tokens. These credentials allowed lateral movement into Cursor’s internal SaaS tooling. On 29 October 2026, the attackers used a credential harvested from these SaaS systems to overwrite the cached assets for Anthropic’s official Claude Code extension on Cursor’s extension delivery network. The malicious extension builds attempted to drop an SSH backdoor onto any developer workstation fetching the cached updates. Containment measures fully isolated the environment, with no further malicious activity detected after 1 November 2026.

2. Anatomy of the Pivot: From Shared Storage to Internal SaaS

The initial security failure occurred at the boundary between Cursor and its third-party inference partner, Fireworks AI. To facilitate model training and evaluation, Cursor provisioned a cloud storage bucket and issued access keys to Fireworks AI. The bucket permissions were configured as read-only. However, in object storage architectures, read-only permissions restrict object creation and deletion, but offer no restriction against full data extraction if the key is compromised.

When threat actors breached Fireworks AI, they obtained this read-only key and initiated bulk exfiltration of the bucket’s contents. The bucket stored agent traces—structured log files capturing prompt-response sequences, tool execution outputs, and contextual environment snapshots generated during user interactions with Cursor’s AI coding assistant. Because these traces were collected from sessions where users had not opted into Privacy Mode, the raw payload data was retained for engineering analysis and model fine-tuning.

Upon exfiltrating the storage bucket, the attackers systematically parsed the conversation logs for sensitive data. Within these traces, they uncovered valid authentication tokens and service credentials that users or automated workflows had passed into the AI agent environment. Specifically, unedited credentials embedded in the conversation traces exposed API keys associated with less than 0.01% of Cursor’s total user base. Crucially, a subset of these exposed credentials included administrative or developer access keys for select internal SaaS platforms utilized by Cursor’s engineering and operations teams.

Shared Vendor Keys and Identity Boundaries

Read-only bucket policies enforce data integrity, not data confidentiality. If object contents contain high-value operational credentials, exfiltration of read-only data provides attackers with the exact inputs needed to bypass identity providers and authentication gateways.

Using the harvested internal SaaS credentials, the threat actors established authenticated sessions within Cursor’s administrative environment. This secondary pivot granted access to sensitive internal assets, including:

  • Archived non-production Cursor source code repositories (some containing business contact details).
  • Customer support repositories, ticket histories, and internal email communications.
  • Product usage telemetry metrics and contact lists.
  • Summaries of customer coding agent sessions.
  • Cleartext credentials that users had explicitly attached in communications to the Cursor customer support team.

This lateral movement demonstrated how an isolated vendor breach can bypass external network perimeters when internal SaaS credentials are leaked via unredacted telemetry stores.

3. Unredacted Agent Telemetry: The Hidden Risk in AI Session Traces

AI coding assistants require deep context to generate accurate code, inspect project structures, and run terminal diagnostic commands. In normal operation, an agent may read local environment files (such as .env), execute shell scripts containing inline tokens, parse local ~/.aws/credentials configurations, or capture active HTTP request headers during API debugging. If these raw terminal streams and file context blocks are logged directly to central data lakes without rigorous secret sanitisation, the resulting telemetry becomes a high-density target for credential harvesters.

Standard static application security testing (SAST) and secret-scanning tools routinely miss credentials stored within natural language AI traces. Traditional regex pattern matchers target cleartext strings in source files (e.g. AWS_SECRET_ACCESS_KEY=...). However, AI session logs encapsulate code snippets inside nested JSON payloads, escape characters, base64-encoded tool outputs, and conversational context windows. As a result, standard ingestion pipelines fail to sanitize tokens embedded within natural language prompts or multi-turn agent execution steps.

{
  "session_id": "agent-trace-2025-08-14-09412",
  "user_prompt": "Help me debug this curl request to our internal deployment gateway",
  "tool_execution_log": {
    "command": "curl -H 'Authorization: Bearer eyJhbGciOiJKV1QiLC...' https://internal-deploy.example.net/api/v1/status",
    "exit_code": 0,
    "stdout": "{\"status\": \"authenticated\", \"role\": \"cluster-admin\"}"
  }
}

The impact of this telemetry leak was bounded by user configuration settings. Cursor confirmed that sessions conducted under Privacy Mode—a setting that opts users out of data retention for model training—were entirely absent from the compromised storage bucket. Privacy Mode prevented local agent traces from reaching the shared Fireworks AI storage layer.

For non-Privacy Mode sessions, however, the retention of raw traces created an unexpected exposure surface. Although less than 0.01% of total customers were impacted by key exposure, the high privilege level of the embedded credentials allowed the attackers to transition from external threat actors to internal SaaS operators.

4. Poisoning the Well: Extension Marketplace Cache Tampering

Modern integrated development environments maintain extension ecosystems to allow rapid installation of language servers, linters, and AI plugins. To serve extensions efficiently to millions of concurrent clients, IDE architectures use edge caching layers and Content Delivery Networks (CDNs). When a developer searches for or automatically updates an extension, the client queries a cached marketplace index and retrieves the distribution archive (typically a .vsix or compressed package).

On 29 October 2026, the threat actors executed the third stage of their attack by targeting Cursor’s extension marketplace delivery infrastructure. Using an internal administrative credential obtained during their SaaS tool pivot, the attackers gained write permissions to the cache layer responsible for serving marketplace extension payloads.

The attackers chose not to publish a new, suspicious extension. Instead, they targeted an established high-trust extension: Anthropic’s official Claude Code plugin. By overwriting the cached package files for an existing extension, the attackers ensured that clients updating their environments would fetch and execute the compromised software automatically, without triggering warnings associated with untrusted publishers.

Targeted Extension Versions

The trojanised builds placed on the marketplace cache were tagged as versions 2.1.312 and 2.1.313 of Anthropic’s Claude Code extension. Neither Anthropic’s source code repositories nor Anthropic’s official infrastructure were compromised; the tampering occurred exclusively on Cursor’s edge cache distribution layer.

The exposure window lasted approximately 11 hours on 29 October 2026. During this timeframe, Cursor’s telemetry indicates that at most 5,000 users requested the specific cached versions of the extension. Upon detecting the anomaly, Cursor incident response teams executed an aggressive containment protocol:

  • Purged versions 2.1.312 and 2.1.313 from the distribution cache and took the extension marketplace offline.
  • Deactivated the read-only storage key assigned to Fireworks AI and permanently severed all data-sharing pipelines with the vendor.
  • Migrated all active AI model inference traffic away from Fireworks AI to alternative backend infrastructure.
  • Revoked all compromised internal SaaS credentials and administrative tokens across the enterprise.
  • Coordinated with the external cloud service provider hosting the threat actor’s Command-and-Control (C2) server to take the malicious infrastructure offline.
  • Notified affected users directly and assisted in revoking exposed client-side credentials.

Cursor confirmed that no additional unauthorized activity was detected on its network past 1 November 2026. Crucially, the core Cursor application updates, production database systems, customer code repositories, and other marketplace extension downloads remained uncompromised throughout the event.

5. Payload Analysis: Persistence via Trojanised Extensions

The malicious payload embedded within Claude Code versions 2.1.312 and 2.1.313 was designed to convert the developer endpoint into an initial access vector for enterprise network penetration. While specific binary implementation details and the hosting cloud provider of the attacker infrastructure have not been publicly disclosed, the operational mechanics of extension-based backdoors follow well-defined execution paths within VS Code-derived architectures.

In VS Code and Cursor, extensions run inside a Node.js process context known as the Extension Host. This process runs with the unprivileged local user permissions of the developer logged into the workstation. When an extension is updated or loaded, the IDE executes the entry point defined in the extension’s package.json file (typically out/extension.js). Because the Extension Host process lacks strict sandbox isolation from the underlying operating system, an extension can run system commands, inspect local file systems, and initiate outbound network connections.

The trojanised Claude Code extension attempted to establish persistent remote access by modifying local SSH configurations. Upon activation, the extension script inspected the developer’s home environment for standard SSH configuration structures (such as ~/.ssh/authorized_keys on Linux and macOS). The payload attempted to inject an attacker-controlled public SSH key into the user’s configuration, enabling persistent passwordless SSH ingress if the workstation exposed an SSH daemon to the local network or over an active VPN tunnel.

Enterprise Blast Radius of Endpoint Compromise

Developer endpoints are high-value targets. A persistent shell on an engineer’s machine bypasses perimeter controls, capturing active AWS/GCP CLI tokens, Kubernetes context files (~/.kube/config), internal source code checkouts, and active corporate SSO session cookies.

Security teams auditing developer endpoints for potential exposure to Claude Code versions 2.1.312 or 2.1.313 can execute local diagnostic checks to identify modified extension files or compromised SSH configurations.

#!/usr/bin/env bash
# Diagnostic script to check for trojanised Claude Code extensions and SSH key modification
# Run locally on macOS/Linux workstations (test in staging environments prior to fleet deployment)

set -euo pipefail

echo "[+] Auditing Cursor Extension Directories..."
EXTENSION_DIRS=(
  "$HOME/.cursor/extensions"
  "$HOME/.vscode/extensions"
)

FOUND_MALICIOUS=0

for dir in "${EXTENSION_DIRS[@]}"; do
  if [ -d "$dir" ]; then
    # Search for trojanised version strings in installed extension paths
    MATCHES=$(find "$dir" -maxdepth 2 -type d -name "*claude-code*2.1.312*" -o -name "*claude-code*2.1.313*" 2>/dev/null || true)
    if [ -n "$MATCHES" ]; then
      echo "[!] WARNING: Trojanised extension path detected:"
      echo "$MATCHES"
      FOUND_MALICIOUS=1
    fi
  fi
done

if [ "$FOUND_MALICIOUS" -eq 0 ]; then
  echo "[+] No malicious Claude Code extension packages (2.1.312 / 2.1.313) found in default paths."
fi

echo "[+] Auditing SSH Authorized Keys modification dates..."
AUTHORIZES_FILE="$HOME/.ssh/authorized_keys"
if [ -f "$AUTHORIZES_FILE" ]; then
  echo "[*] Permissions and last modification date for $AUTHORIZES_FILE:"
  ls -la "$AUTHORIZES_FILE"
  echo "[*] Inspect the file manually to ensure all entries belong to authorized personnel."
else
  echo "[+] No local authorized_keys file found."
fi

For more detailed technical background on supply-chain mechanics affecting extension ecosystems, see our related analysis on Analyzing the Claude Code Extension SSH Backdoor Supply-Chain Attack.

6. Ecosystem Spillovers: Assessing Broader Impact Across Uber and Notion

The Fireworks AI security incident was not limited to Cursor. Because Fireworks AI operates as a multi-tenant infrastructure provider delivering model inference services to numerous technology companies, the compromise of its internal credentials created a systemic ripple effect across independent enterprise environments.

On 9 October 2026, ride-hailing vendor Uber was notified by a service provider (identified by industry reports as Fireworks AI) that an unauthorized third party had compromised internal credentials used to access Uber’s service account. Following an internal investigation completed on 13 October 2026, Uber confirmed in filings with the State of California that the attackers used these stolen credentials to access Uber data hosted on the provider’s platform, including driver’s license information. The exact total volume of driver records exposed has not been publicly disclosed by Uber.

Similarly, productivity platform Notion confirmed that data belonging to its environment was exfiltrated during the same Fireworks AI breach. The threat actors used stolen provider credentials to pivot into Notion’s hosted resources, replicating the cross-tenant data harvesting pattern seen in the Cursor event.

Impacted Organisation Disclosure Date Compromise Vector Exfiltrated / Impacted Data Assets
Cursor November 2026 Exposed Storage Key & Pivot to SaaS Agent traces, internal SaaS data, non-prod repos, support logs, 11-hr cache poisoning.
Uber 9 October 2026 Compromised Service Provider Credentials Hosted account data, including driver’s license records (total volume undisclosed).
Notion November 2026 Compromised Service Provider Credentials Enterprise application data hosted on vendor infrastructure.

This widespread impact illustrates the risk inherent in modern AI service integration models. When enterprises share API keys, database access, or training telemetry with third-party model hosts, the security posture of the customer becomes strictly bound to the operational security of the inference vendor. A single credential leakage at the vendor layer can simultaneously compromise multiple independent software supply chains.

7. Mitigation and Hardening Framework for AI Developer Environments

Securing enterprise developer fleets against telemetry leaks and marketplace supply-chain poisoning requires controls spanning data loss prevention (DLP), API hygiene, and distribution cache validation. Engineering leaders should implement the following defensive controls.

Automated Telemetry Redaction Pipelines

Organisations processing LLM prompts and agent execution logs must deploy pre-ingestion redaction services. Natural language telemetry must be stripped of high-entropy strings, Bearer tokens, cloud provider keys, and internal IP addresses before logs are committed to storage buckets or shared with model providers.

# Example: Pre-Ingestion Telemetry Sanitiser (Python)
# Filters high-entropy tokens and API keys prior to storage logging

import re
import sys

SECRET_REGEXES = [
    # Generic API Bearer Tokens & Secret Keys
    re.compile(r'(?i)(bearer|token|secret|api[_\-]?key)\s*[:=]\s*["\']?([a-z0-9\-_=]{16,})["\']?'),
    # Cloud Infrastructure Access Keys (e.g. AWS Key Identifiers)
    re.compile(r'(A3T[A-Z0-9]|AKIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASIA)[A-Z0-9]{16}'),
    # Private Key Headers
    re.compile(r'-----BEGIN\s+(RSA|EC|DSA|OPENSSH)\s+PRIVATE\s+KEY-----'),
]

def sanitize_payload(raw_text: str) -> str:
    sanitized = raw_text
    for pattern in SECRET_REGEXES:
        sanitized = pattern.sub('[REDACTED_CREDENTIAL]', sanitized)
    return sanitized

if __name__ == "__main__":
    sample_prompt = "Debugging connection: AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE Bearer secret_str_1234567890123456"
    print("Sanitized Output:", sanitize_payload(sample_prompt))

Marketplace Cache Signing and Direct-Write Controls

Edge caches serving IDE plugins must enforce cryptographic package verification. Caching layers should act as read-only mirrors that only accept packages signed by trusted developer keys. Stolen administrative SaaS credentials should never grant direct permission to write or overwrite objects in public release caches without explicit, multi-party signature verification (such as Sigstore or custom KMS-backed package signing pipelines).

Enforcing Enterprise Privacy Defaults

Platform engineering teams deploying Cursor across enterprise fleets should enforce Privacy Mode centrally via configuration management policies. By locking Privacy Mode at the client level, organisations ensure that developer code snippets, terminal traces, and local environment states are never written to vendor-side training buckets.

Remediation Checklist for Exposed Workstations

If developer endpoints were active on 29 October 2026 and requested extension updates during the 11-hour exposure window, perform the following remediation steps immediately:

  1. Isolate and Reimage Affected Systems: Quarantine any system confirmed to have installed Claude Code version 2.1.312 or 2.1.313. Treat the machine as fully compromised.
  2. Rotate Local and Cloud Credentials: Revoke all SSH keys, AWS/GCP/Azure CLI sessions, Git personal access tokens, and corporate SSO session tokens present on the workstation.
  3. Audit SSH Configurations: Check ~/.ssh/authorized_keys across all local user accounts for unrecognized public keys added on or after 29 October 2026.
  4. Verify Marketplace Pinning: Restrict IDE extension sources to verified internal registries or mandate signed package downloads within enterprise endpoint management tools.

8. Key Takeaways for Security Leaders and Infrastructure Teams

The Cursor marketplace incident provides foundational lessons for platform architects, AppSec teams, and engineering leaders integrating AI infrastructure into production workflows:

  • AI Session Logs are Credential Vectors: Conversation histories, tool call logs, and prompt context stores must be classified as sensitive data assets. Unless sanitized by dedicated DLP tools, telemetry logs will retain raw secrets and must not be shared with external vendors via broad storage permissions.
  • Vendor Storage Isolation: Read-only access keys issued to third-party model providers must be bounded by minimal resource permissions, strict bucket access policies, and short expiration lifetimes. Vendor keys should never point to multi-use storage buckets containing unredacted user telemetry.
  • Zero-Trust Distribution Pipelines: Extensions served via CDNs or edge caches must require cryptographic signing prior to client execution. Storage and edge caches should never accept unvalidated binary overwrites, even when commands originate from authenticated internal administrative accounts.
  • Blast Radius Management: Security teams must assume developer workstations will occasionally be targeted via software supply chains. Strict network segmentation, device trust checks, short-lived cloud credentials, and zero-trust conditional access policies are required to prevent a local endpoint compromise from cascading into a cloud control plane breach.

Frequently asked questions

Were Cursor users who enabled Privacy Mode impacted by the credential leak?

No. Cursor confirmed that users who enabled Privacy Mode were completely unaffected by the credential leak. Privacy Mode prevents session traces from being stored or used for model training, meaning their data was never present in the shared read-only storage bucket accessed by the attackers.

How did attackers tamper with Anthropic’s Claude Code extension without compromising Anthropic?

The attackers did not breach Anthropic’s systems or source code. Instead, they used stolen Cursor internal SaaS credentials to gain administrative access to Cursor’s extension marketplace distribution cache. They used this access to overwrite the cached assets for the Claude Code extension with trojanised builds.

What specific versions of the Claude Code extension contained the SSH backdoor?

The trojanised payload was present exclusively in versions 2.1.312 and 2.1.313 of the Claude Code extension downloaded from the Cursor Marketplace cache during an 11-hour window on 29 October 2026. Official builds downloaded from other marketplaces were not affected.

What immediate steps should security teams take to verify whether developer workstations were compromised?

Security teams should inspect developer workstations for installed Claude Code extension directories matching versions 2.1.312 or 2.1.313. Teams should also audit ~/.ssh/authorized_keys files for unauthorized entries added on 29 October 2026, rotate all credentials stored on affected machines, and reimage compromised endpoints.

Sources and further reading

This article was drafted with AI assistance from the publicly cited sources and passed automated checks for structure and sourcing. Verify critical details against the vendor advisories linked above before acting.