Consuloji: Deep Dives into Overseas AI日本語

How a Single Leaked Vendor Key Led to Rogue Extensions for 5,000 Users: Anatomy of the Cursor Breach

Published: November 15, 2026

Listen or watch on YouTube

A comprehensive technical forensic analysis of the October-November 2026 Cursor security incident, dissecting the upstream inference key compromise, unredacted credentials in training traces, marketplace cache poisoning, and the anatomy of persistent developer backdoors.

Japanese Edition (Original Article): Read on note Video Episode: Watch on YouTube

Disclaimer: This analysis is based strictly on publicly verifiable primary sources, including official incident post-mortems and security advisories released by Anysphere (Cursor). It is intended exclusively for defensive systems architecture and engineering risk mitigation.


1. Executive Summary: The Upstream Paradox in Agentic AI

Across the contemporary software engineering landscape, developers and enterprise engineering teams have rapidly delegated code generation, shell execution, and complex multi-file refactoring to autonomous AI coding tools. By integrating directly into integrated development environments and terminal sessions, tools such as Cursor offer unprecedented operational leverage. Developers witness hundreds of lines of code generated, tested, and integrated with zero syntax errors, fostering an implicit assumption of underlying system integrity.

However, on November 13, 2026, Anysphere published a detailed forensic update concerning a multi-stage security incident that fundamentally challenges the perimeter assumptions of AI-assisted software development. The incident did not originate from a vulnerability in Cursor’s core client application, nor was it caused by a direct penetration of its production infrastructure. Instead, the breach began upstream: an access key issued to Fireworks, an external vendor contracted for model training and inference services, was leaked from Fireworks’ environment.

Using this single credential, an adversary accessed a read-only cloud storage bucket designated for vendor data synchronization. Inside this bucket lay historical coding agent execution traces from 2025, gathered from user sessions where Privacy Mode was disabled. Critically, a fraction of these offline training traces contained unredacted, plaintext API keys and access tokens accidentally pasted into prompts or code buffers by end users.

Armed with these exposed user credentials, the adversary pivoted into select internal software-as-a-service (SaaS) tools utilized by the Cursor operational team. From there, on October 29, 2026, the attacker directly poisoned the edge cache serving the Cursor VS Code Extension Marketplace. For an exposure window of approximately 11 hours, malicious, unauthorized builds of Anthropic’s popular Claude Code extension (versions 2.1.312 and 2.1.313) were distributed to up to 5,000 requesting users. These poisoned builds contained malicious payloads that installed persistent reverse tunnels and injected an unauthorized public SSH key into the developer machine’s authorized keys file.

This incident marks a watershed moment in artificial intelligence engineering. It demonstrates with crystalline clarity that the security perimeter of an AI tool is defined not merely by its immediate production endpoints, but by the weakest link in its entire data pipeline, including third-party model inference providers and offline telemetry storage.

Figure 1: Anatomy of the Chained AI Supply Chain Incident


2. Upstream Compromise: The Fireworks Key Leak and Storage Infiltration

To construct an effective defensive architecture against supply chain attacks, systems architects must examine the initial point of ingress. According to Cursor’s official incident disclosure, the root vector was entirely external to Cursor’s operational datacenter.

flowchart TD
    Vendor["Third-Party Inference Vendor (Fireworks)"] -- "Key Leaked from Vendor Env" --> Attacker["Adversary"]
    Attacker -- "Uses Compromised Key" --> S3["Read-Only Shared S3 Bucket"]
    S3 -- "Exfiltrates Historical Data" --> Traces["Coding Agent Traces (2025 Offline Data)"]
    Traces -- "Harvests Plaintext Secrets" --> PlaintextKeys["Unredacted User API Keys & Tokens"]
    PlaintextKeys -- "Lateral Movement" --> InternalSaaS["Cursor Internal SaaS & Support Tools"]
    InternalSaaS -- "Compromised Credentials" --> MarketplaceCache["Extension Marketplace Cache"]
    MarketplaceCache -- "Serves Poisoned Builds" --> Devs["Up to 5,000 Developers (Malicious Extension)"]

Cursor had issued an access credential to Fireworks to facilitate data sharing for fine-tuning and inference workflows. This credential subsequently leaked from Fireworks’ custody. While Fireworks has not released a granular technical post-mortem detailing whether the leak stemmed from an environmental misconfiguration, employee credential compromise, or third-party intrusion, the consequence was immediate: the attacker used this valid credential to authenticate against Cursor’s cloud storage.

The target was a read-only storage bucket used specifically to stage data for Fireworks. Because the key possessed valid cryptographic signing and read permissions, standard perimeter access controls recognized the requests as authorized vendor operations. The attacker copied the staged data corpus without triggering perimeter boundary rejections.

To draw an everyday physical analogy: consider a luxury high-rise condominium with state-of-the-art biometric access gates and round-the-clock security personnel. The building management entrusts an emergency master key to an external commercial cleaning contractor so they can service specific utility closets. If that cleaning contractor leaves the master key sitting on an unsecured desk in their suburban office and a burglar steals it, the burglar can walk straight into the condominium’s private archives without tripping the front-door alarms. The building’s core structural defenses remain intact, yet its archived assets are fully exposed.

Figure 2: The Ingress Vector at Upstream Inference


3. The Data Exposure Vector: Unredacted Secrets in Agent Execution Traces

Once inside the shared storage repository, what specific data did the adversary obtain? The contents of the storage bucket comprised historical execution traces generated by Cursor’s coding agent, primarily dating from the calendar year 2025.

Under Cursor’s data governance framework, users who operate with Privacy Mode enabled have their code snippets, terminal inputs, and prompts excluded from persistent offline storage. However, for sessions where Privacy Mode was disabled, execution traces were stored to support model evaluation, training, and algorithmic optimization.

The systemic vulnerability arose within the data sanitization pipeline. Within these historical agent traces, a small proportion contained unredacted credentials. When software engineers interact with agentic tools, they frequently paste environment variables, configuration files, test curl commands, or authorization headers into their chat contexts or scratchpads. If an automated scrubbing mechanism fails to catch a high-entropy string, that raw credential becomes permanently embedded within the serialized JSON trace file.

The adversary performed offline parsing across the exfiltrated dataset, extracting plaintext API keys, database credentials, and service tokens. Armed with these authentic credentials, the attacker achieved lateral traversal into several corporate software-as-a-service platforms utilized by Cursor’s internal engineering and support staff.

Through these compromised SaaS platforms, the adversary gained unauthorized visibility into:

  1. Archived, non-production Cursor source code repositories, some containing internal technical documentation and business contact details.
  2. Limited customer support ticketing histories and operational email correspondence.
  3. Product usage telemetry, behavioral analytics, and administrative contact records.
  4. Historical summaries of coding agent conversations.
  5. Specific credentials that individual users had manually transmitted to the customer support team during troubleshooting engagements.

Critically, Cursor’s official post-mortem confirmed several domains that remained completely uncompromised throughout the campaign:

  • Production systems, runtime clusters, and core backend infrastructure running the live Cursor service.
  • Live inference requests and active user traffic.
  • User code repositories stored on client machines or hosted on third-party version control platforms (such as GitHub or GitLab).
  • The official Cursor desktop application binaries, client auto-update channels, and release cryptographic signing keys.
  • All prompt data, context windows, and code generated by users who maintained Privacy Mode in an enabled state.

Figure 3: Unredacted Secrets and Lateral Traversal


4. Forensic Dissection: Separating Three Distinct Baseline Metrics

In the wake of public security disclosures, sensationalized media reporting and social media summaries frequently conflate distinct statistical denominators, generating misleading narratives regarding the true blast radius of an incident. In the Cursor event, three separate quantitative metrics were disclosed in the official post-mortem. Conflating these numbers represents an egregious failure of analytical rigor.

Metric Identifier Disclosed Value Exact Mathematical Denominator Common Secondary Misconception
API Credential Exposure Fewer than 0.01% Total Enterprise & Team Customers Conflated with individual users to claim widespread account leakage
Agent Trace Exposure Fewer than 0.05% Total Individual Users with Privacy Mode Disabled Added directly to 0.01% to manufacture a fictitious 0.06% overall metric
Malicious Build Reach At most 5,000 Users Users Requesting Specific Cached Builds on October 29 Misreported as 5,000 compromised corporate enterprises

Let us dissect each denominator rigorously:

A. The Customer Denominator (Fewer than 0.01%)

The post-mortem explicitly states: “API credentials were exposed for fewer than 0.01% of customers.” In enterprise SaaS nomenclature, a “customer” represents a contracting entity, company account, or billing workspace. This metric measures the fraction of organizational accounts whose members had unredacted keys captured in the historical trace dataset.

B. The Privacy-Disabled User Denominator (Fewer than 0.05%)

The disclosure specifies: “For users not using Privacy Mode, coding agent traces were exposed for fewer than 0.05% of users.” This denominator is entirely distinct from the customer count. It isolates the subset of individual end-user accounts who actively operated with Privacy Mode disabled. If an organization maintained Privacy Mode across all corporate seats, its exposure within this category was precisely zero.

C. The Marketplace Cache Window Denominator (At Most 5,000 Users)

The third metric pertains exclusively to the supply chain distribution on October 29, 2026: “At most 5,000 users who requested specific cached versions of the extension on October 29 potentially received the malicious build.” This figure represents an absolute ceiling of developer workstations whose IDE clients queried the corrupted cache layer during an 11-hour synchronization window.

Conflating these figures—for instance, asserting that “5,000 companies had their API keys stolen” or that “0.06% of all data was leaked”—distorts the fundamental threat model. Defending against modern attacks requires precision in understanding where vulnerability density actually concentrates.

Figure 4: Quantitative Verification of Threat Metrics


5. Poisoning the Cache: The 11-Hour Distribution of Malicious Claude Code Builds

The most tactically sophisticated phase of the campaign occurred on October 29, 2026. Leveraging credentials harvested from Cursor’s internal SaaS tooling, the adversary gained administrative ingress into the content caching tier responsible for accelerating the Cursor VS Code Extension Marketplace.

Rather than attempting to compromise Open VSX—the open-source extension registry that serves as the upstream package authority for alternative VS Code distributions—the attacker targeted the intermediary caching layer maintained by Cursor to optimize edge delivery.

The attacker placed modified, malicious copies of Anthropic’s Claude Code extension directly onto the edge cache. The malicious packages were tagged with version numbers 2.1.312 and 2.1.313.

Several technical invariants must be underscored:

  1. Upstream Source Cleanliness: The canonical upstream repository on Open VSX never contained the malicious code.
  2. Anthropic Perimeter Independence: Anthropic did not author, publish, or endorse these modified builds. The incident did not exploit any architectural flaw or vulnerability in Anthropic’s Claude Code codebase.
  3. Targeted Delivery: The malicious package was returned only to client requests that hit the poisoned cache nodes between 2:27 AM Pacific Time and 1:35 PM Pacific Time on October 29, 2026—a window of 11 hours and 8 minutes.

Upon detecting anomalous operational telemetry, Cursor’s automated monitoring systems initiated emergency containment protocols. Engineering teams took the entire extension marketplace offline, purged the edge caches, and coordinated directly with the cloud infrastructure provider hosting the adversary’s command-and-control server to take down the external ingress domain.

Figure 5: Extension Marketplace Cache Poisoning


6. Payload Dissection: SSH Keys, Persistence Scripts, and the Myth of Simple Removal

For developers whose environments retrieved version 2.1.312 or 2.1.313 during the 11-hour window, the consequences went far beyond an untrusted editor plugin. The malicious package was designed as a multi-stage persistence dropper.

sequenceDiagram
    participant IDE as Cursor / VS Code Client
    participant Ext as Malicious Claude Code (2.1.312/313)
    participant SSH as ~/.ssh/authorized_keys
    participant OS as Host OS Background Daemon
    participant C2 as Attacker C2 Server

    IDE->>Ext: Installs / Updates Extension
    Ext->>SSH: Appends attacker public key (svc-telemetry)
    Ext->>OS: Spawns independent persistence scripts
    Ext->>OS: Opens encrypted reverse tunnel process
    OS->>C2: Establishes persistent outbound beacon
    Note over IDE,Ext: Developer uninstalls extension via UI
    Note over OS,C2: Persistence script & reverse tunnel CONTINUE RUNNING

A. The svc-telemetry SSH Injection

Upon activation, the extension script inspected the local filesystem and located the host user’s SSH configuration. On macOS and Linux systems, it opened ~/.ssh/authorized_keys; on Windows hosts, it targeted $HOME\.ssh\authorized_keys as well as C:\ProgramData\ssh\administrators_authorized_keys.

The payload appended the adversary’s cryptographic public key, deliberately disguising it with the benign identifier comment svc-telemetry. Once injected, any entity holding the corresponding private key could establish an authenticated interactive SSH session directly into the developer’s workstation, bypassing standard password authentication.

B. Decoupled Persistence and Reverse Tunnels

In addition to key injection, the payload dropped standalone execution scripts into hidden local directories and launched background daemon processes configured to maintain encrypted reverse tunnels back to the adversary’s command-and-control infrastructure.

This architectural decoupling represents the most dangerous facet of the attack: simply clicking “Uninstall” within the VS Code or Cursor extension manager was completely ineffective at neutralizing the intrusion. While the editor removed the extension files from the plugins directory, the background daemon processes, reverse tunnels, and injected SSH keys remained active in the host operating system.

To assist impacted engineers, Cursor published dedicated shell remediation scripts (remediate-macos.sh and corresponding Windows PowerShell sequences). These scripts specifically terminate active rogue processes, scrub the svc-telemetry entries from all authorized keys files, and exit with an explicit non-zero return code if any residual artifact is detected. Furthermore, because local environment variables might have been harvested prior to detection, Cursor recommended that affected organizations treat compromised machines as untrusted, execute complete operating system rebuilds, and rotate all credentials stored on or accessible from the machine.

Figure 6: Payload Execution and Persistence Dropper


7. Containment and Infrastructure Remediation: Rebuilding the Core

Following the identification of the incident, Cursor’s response protocol unfolded across several rigorous defensive phases.

First, operational teams severed all connections to Fireworks. All active inference traffic was immediately diverted to alternative model hosting providers. The credentials issued to Fireworks were revoked, and all shared data synchronization endpoints were decommissioned.

Second, the security team executed an exhaustive credential revocation sweep. Rather than limiting rotation to credentials with verified adversarial interaction, Cursor enacted an enterprise-wide prophylactic rotation: every single internal credential, API key, token, and service account secret across all internal systems was forcibly rotated.

Third, the entire extension marketplace infrastructure was rebuilt from scratch. Every extension package within the repository underwent automated and manual cryptographic verification against upstream sources to ensure no other package had suffered tampering. Additional network segmentation was instituted across third-party service providers, enforcing strict IP whitelisting and mutual TLS authentication so that compromised credentials cannot be exercised from unauthorized external IP addresses.

Fourth, automated secret scanning engines were integrated across all internal source repositories, continuous integration pipelines, and historical storage corpora, ensuring continuous real-time detection of high-entropy tokens.

The final adversarial activity was observed and successfully repelled on November 1, 2026. Following comprehensive monitoring in collaboration with external forensic investigators, the incident was declared formally contained.

Figure 7: Complete Containment and Infrastructure Overhaul


8. Actionable Blueprints: Three Deterministic Defense Invariants for AI Engineering

The Cursor breach provides an essential roadmap for securing modern development environments against AI-driven supply chain compromise. Enterprise security teams and individual engineers should enforce three non-negotiable operational invariants:

================================================================================
          THE THREE DETERMINISTIC DEFENSE INVARIANTS FOR AI TOOLING
================================================================================

[INVARIANT 1: IMMEDIATE ENDPOINT AND EXTENSION AUDIT]
  • Audit all development machines active on October 29, 2026 for rogue extensions.
  • Execute deterministic string checks across SSH authorized keys:
      grep -qs "svc-telemetry" ~/.ssh/authorized_keys
  • Treat hosts exhibiting hits as fully compromised; execute bare-metal reimaging.

[INVARIANT 2: TOTAL DEPRECATION OF LONG-LIVED STATIC CREDENTIALS]
  • Ban static, multi-month API tokens in local .env files and terminal profiles.
  • Enforce short-lived, cryptographically scoped STS credentials (15-60 minute TTL).
  • Integrate OpenID Connect (OIDC) identity brokering for all cloud interactions.

[INVARIANT 3: DETERMINISTIC DATA SANITIZATION AND PRE-COMMIT BOUNDARIES]
  • Mandate Privacy Mode across all corporate seats to prevent telemetry archiving.
  • Deploy local pre-commit hooks (e.g., git-secrets, detect-secrets) to halt commits.
  • Treat the entire third-party inference pipeline as untrusted, hostile territory.
================================================================================

Invariant 1: Immediate Endpoint and Extension Audit

Every organization employing VS Code, Cursor, or compatible derivatives must verify whether developer endpoints updated or installed Anthropic.claude-code on October 29, 2026. Run deterministic shell inspections across all user accounts:

grep -qs "svc-telemetry" ~/.ssh/authorized_keys && echo "[ALERT] Compromised key found" || echo "[OK] Clean"

If the identifier is located, isolate the machine from the corporate subnet immediately. Terminate external egress, collect memory dumps for forensic preservation, execute the official remediation scripts, and rebuild the host from known-good baseline images.

Invariant 2: Total Deprecation of Long-Lived Static Credentials

The core reason the adversary achieved lateral movement into internal SaaS systems was the presence of static, long-lived API tokens stored in historical log traces. Software organizations must accelerate the transition away from permanent static API keys. Developers must authenticate via short-lived credentials obtained through OpenID Connect (OIDC) or Security Token Services (STS), with lifetimes restricted to 15 to 60 minutes. When credentials expire automatically within the hour, a leaked log file from six months prior is rendered completely harmless.

Invariant 3: Deterministic Data Sanitization and Pre-Commit Boundaries

Never rely on post-hoc redaction algorithms to clean sensitive data after it has left the developer workstation. Enterprise administrators must enforce organizational policies that permanently lock Privacy Mode to the enabled state across all corporate AI seats. Furthermore, local developer tooling must incorporate strict pre-commit hooks that scan buffers for cryptographic keys, AWS secrets, and OAuth tokens before commands or files can be transmitted over the wire.

By treating the external AI inference supply chain as an inherently untrusted boundary, engineering organizations can harness the transformative productivity of coding agents while safeguarding the architectural integrity of their enterprise systems.

Figure 8: Actionable Defensive Invariants

Back to articles