The Cursor supply chain attack that SecurityWeek has now traced back to Fireworks AI is a textbook illustration of how modern software supply chain compromises actually unfold in 2026 — not through a single catastrophic zero-day, but through the quiet theft of one access key that unlocks a chain of downstream trust relationships. According to the reporting, an attacker stole an access key belonging to Fireworks AI — the inference provider integrated into AI coding workflows — and used it to exfiltrate additional credentials. Those exfiltrated credentials, in turn, gave the attacker the ability to push malicious copies of the Claude Code extension to users of Cursor, the AI-powered code editor.
If your developers use Cursor, or your CI/CD and development tooling chains depend on AI-assisted coding extensions, this incident matters to you directly. Developer workstations are among the highest-value assets in your environment: they hold source code, cloud credentials, SSH keys, signing certificates, and access to production deployment pipelines. A malicious extension running inside a developer's editor inherits all of that trust. This post breaks down the attack chain, what you should be hunting for right now, and how to harden your environment against the next iteration of this exact pattern.
Technical Analysis: Anatomy of the Attack Chain
The Kill Chain
Based on the SecurityWeek reporting, the intrusion unfolded in distinct, dependency-linked stages:
-
Initial access — stolen Fireworks AI access key. The attacker obtained an access key tied to Fireworks, the AI inference platform. Whether this key was phished, leaked, or pulled from an exposed repository has not been disclosed, but the entry point was a valid credential — no exploit was required. This is consistent with the dominant initial access vector we see across IR engagements: valid accounts and stolen tokens, not vulnerability exploitation.
-
Credential exfiltration from within Fireworks' environment. Using that access key, the attacker pivoted to exfiltrate additional credentials. This is the critical amplification step: one key became many. Cloud and SaaS environments routinely store secrets, API tokens, and service credentials in environment variables, configuration stores, and metadata services that a sufficiently privileged key can read.
-
Abuse of publishing trust — malicious Claude Code extension copies. The exfiltrated credentials included whatever tokens or signing/publishing authority were needed to push malicious copies of the Claude Code extension. Because the malicious builds were pushed through legitimate publishing channels, they carried the implicit trust of the official distribution path. Users who updated or installed the extension received attacker-controlled code executed inside their editor context.
Why This Pattern Is So Dangerous
This is not an isolated technique — it is the defining supply chain pattern of the AI-tooling era. AI coding assistants and their extensions operate with broad local privileges: they read your codebase, execute terminal commands, access language servers, and frequently hold API tokens for model providers. A compromised extension is effectively a remote access trojan with a pre-installed foothold on developer endpoints.
Key characteristics defenders should internalize:
- No CVE, no patch to race. There is no software vulnerability at the center of this incident. The 'vulnerability' is the concentration of trust in long-lived access keys and the transitive trust between AI service providers and extension marketplaces. Detection, not patching, is your primary control.
- Legitimate distribution channels were abused. Signature checks and marketplace trust signals may not have flagged the malicious copies because they were pushed with valid credentials through authorized paths.
- Blast radius extends beyond Cursor. Any organization whose developers installed or auto-updated the affected Claude Code extension copies during the exposure window should assume potential credential exposure on those endpoints: cloud keys, repository tokens, SSH keys, and any secrets accessible from the developer's environment.
Exploitation Status
This is a confirmed, active, in-the-wild compromise — not a theoretical risk. Malicious extension copies were published and distributed. Organizations should treat the question not as 'were we targeted?' but as 'did any endpoint in our fleet install or update the extension during the attack window?'
Detection & Response
The detections below target the observable behaviors this class of attack produces: editor extensions spawning unexpected child processes, credential and secrets access from editor or extension processes, and audit of installed extension provenance. Tune the extension paths and process names to your actual deployment.
Sigma Rules
---
title: VS Code or Cursor Extension Spawning Suspicious Child Process
id: 3f9c1a72-8b4d-4e6f-a2c1-9d7e5f3b8a01
status: experimental
description: Detects code editor processes (Cursor, VS Code) spawning shells, scripting engines, or credential-access tooling, consistent with a malicious editor extension executing payloads.
references:
- https://www.securityweek.com/cursor-supply-chain-attack-started-at-fireworks/
- https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/04/06
tags:
- attack.execution
- attack.t1059
logsource:
category: process_creation
product: windows
detection:
selection_parent:
ParentImage|endswith:
- '\cursor.exe'
- '\code.exe'
selection_child:
Image|endswith:
- '\powershell.exe'
- '\pwsh.exe'
- '\cmd.exe'
- '\wscript.exe'
- '\cscript.exe'
- '\rundll32.exe'
- '\curl.exe'
- '\wget.exe'
- '\certutil.exe'
filter_known_good:
CommandLine|contains:
- 'extensions\\ms-vscode'
- 'git.exe'
condition: selection_parent and selection_child and not filter_known_good
falsepositives:
- Legitimate extensions that spawn shells for build/debug tasks (tune per-extension baseline)
level: high
---
title: Editor Process Accessing Credential or Secrets Stores
id: 8e2d4b61-3c7a-4f5e-b9d2-6a1c4e8f7d02
status: experimental
description: Detects code editor or extension host processes reading browser credential stores, SSH keys, or cloud CLI credential files — behavior consistent with credential exfiltration by a compromised extension.
references:
- https://www.securityweek.com/cursor-supply-chain-attack-started-at-fireworks/
- https://attack.mitre.org/techniques/T1552/
author: Security Arsenal
date: 2026/04/06
tags:
- attack.credential_access
- attack.t1552.001
- attack.t1552.004
logsource:
category: file_event
product: windows
detection:
selection_process:
Image|endswith:
- '\cursor.exe'
- '\code.exe'
selection_target:
TargetFilename|contains:
- '\.ssh\id_'
- '\.aws\credentials'
- '\.azure\'
- '\.config\gcloud\'
- '\Login Data'
- '\.env'
- '\.npmrc'
- '\.netrc'
condition: selection_process and selection_target
falsepositives:
- Git credential helpers and legitimate cloud extensions; baseline by extension source
level: high
KQL — Microsoft Sentinel / Defender
This hunt identifies editor processes (Cursor/VS Code) that spawn network connections to uncommon external destinations combined with suspicious child process execution — the composite behavior of a malicious extension phoning home or exfiltrating data. Extend the lookback to cover the full exposure window once the vendor confirms it.
let Lookback = 14d;
let EditorProcesses = dynamic(["cursor.exe", "code.exe"]);
let SuspiciousChildren = DeviceProcessEvents
| where TimeGenerated > ago(Lookback)
| where InitiatingProcessFileName has_any (EditorProcesses)
| where FileName in~ ("powershell.exe", "pwsh.exe", "cmd.exe", "curl.exe", "wget.exe", "rundll32.exe", "certutil.exe", "node.exe")
| project DeviceId, DeviceName, ChildProcess = FileName, ChildCmd = ProcessCommandLine, ChildTime = TimeGenerated, AccountName;
let SuspiciousNet = DeviceNetworkEvents
| where TimeGenerated > ago(Lookback)
| where InitiatingProcessFileName has_any (EditorProcesses)
| where RemoteUrl !has_any ("microsoft.com", "visualstudio.com", "cursor.sh", "anthropic.com", "openai.com", "github.com", "githubusercontent.com", "fireworks.ai")
| project DeviceId, RemoteUrl, RemoteIP, NetTime = TimeGenerated;
SuspiciousChildren
| join kind=inner SuspiciousNet on DeviceId
| where abs(datetime_diff('minute', ChildTime, NetTime)) <= 30
| project DeviceName, AccountName, ChildProcess, ChildCmd, ChildTime, RemoteUrl, RemoteIP
| summarize arg_max(ChildTime, *) by DeviceName, ChildCmd
| order by ChildTime desc
Velociraptor VQL
Use this artifact to sweep your fleet for recently modified extension files in Cursor/VS Code extension directories and correlate them with editor-spawned processes. A sudden mass-modification timestamp on extension files inside the exposure window is a strong investigative pivot.
-- Hunt for recently modified editor extensions and editor-spawned child processes
SELECT FullPath, Mtime, Size,
basename(path=FullPath) AS ExtensionFile
FROM glob(globs='C:/Users/*/.cursor/extensions/**/*',
accessor='ntfs')
WHERE Mtime > now() - (14 * 24 * 3600)
AND FullPath =~ '(?i)claude|anthropic'
ORDER BY Mtime DESC
-- Identify child processes spawned by Cursor editor across the fleet
SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE Exe =~ '(?i)(powershell|pwsh|cmd|curl|wget|node|rundll32)\.exe$'
AND Ppid IN (
SELECT Pid FROM pslist() WHERE Exe =~ '(?i)(cursor|code)\.exe$'
)
Remediation Script — Extension Provenance Audit
Run this PowerShell script across developer endpoints (via your RMM, Intune, or GPO startup script) to inventory installed Cursor/VS Code extensions, flag recently modified extension directories, and export the results for central review. This does not remove anything automatically — in an active IR you want evidence preserved before remediation.
# Audit Cursor and VS Code extension installations for supply chain compromise indicators
# Run as the target user or SYSTEM with user profile enumeration
$ReportPath = "$env:TEMP\extension_audit_$(Get-Date -Format 'yyyyMMdd_HHmmss').csv"
$Results = @()
$ExtensionRoots = @(
"$env:USERPROFILE\.cursor\extensions",
"$env:USERPROFILE\.vscode\extensions"
) | Where-Object { Test-Path $_ }
$ExposureWindowDays = 30 # Widen once vendor confirms exact malicious publish window
$Cutoff = (Get-Date).AddDays(-$ExposureWindowDays)
foreach ($Root in $ExtensionRoots) {
Get-ChildItem -Path $Root -Directory | ForEach-Object {
$ext = $_
$packageJson = Join-Path $ext.FullName 'package.json'
$publisher = 'unknown'; $version = 'unknown'
if (Test-Path $packageJson) {
try {
$pkg = Get-Content $packageJson -Raw | ConvertFrom-Json
$publisher = $pkg.publisher
$version = $pkg.version
} catch { }
}
$recentWrite = (Get-ChildItem $ext.FullName -Recurse -File -ErrorAction SilentlyContinue |
Where-Object { $_.LastWriteTime -gt $Cutoff } |
Sort-Object LastWriteTime -Descending |
Select-Object -First 1)
$Results += [PSCustomObject]@{
ExtensionDir = $ext.Name
Publisher = $publisher
Version = $version
Root = $Root
LastModified = $ext.LastWriteTime
NewestFile = if ($recentWrite) { $recentWrite.FullName } else { 'none' }
NewestFileTime = if ($recentWrite) { $recentWrite.LastWriteTime } else { $null }
FlagRecentMod = ($ext.LastWriteTime -gt $Cutoff)
IsClaudeExt = ($ext.Name -match '(?i)claude|anthropic')
}
}
}
$Results | Export-Csv -Path $ReportPath -NoTypeInformation
Write-Host "[+] Audit complete: $ReportPath"
Write-Host "[!] Priority review items:"
$Results | Where-Object { $_.IsClaudeExt -or $_.FlagRecentMod } |
Format-Table ExtensionDir, Publisher, Version, LastModified, IsClaudeExt -AutoSize
For Linux/macOS developer workstations, the equivalent fleet sweep:
#!/bin/bash
# Audit Claude/Anthropic extensions and recent modifications on macOS/Linux dev endpoints
REPORT="/tmp/extension_audit_$(date +%Y%m%d_%H%M%S).txt"
echo "=== Extension Audit $(hostname) $(date -u) ===" > "$REPORT"
for ROOT in "$HOME/.cursor/extensions" "$HOME/.vscode/extensions"; do
[ -d "$ROOT" ] || continue
echo "--- $ROOT ---" >> "$REPORT"
# Extensions modified in the last 30 days (widen per vendor advisory)
find "$ROOT" -maxdepth 1 -type d -mtime -30 -print >> "$REPORT"
# Flag Claude/Anthropic-scoped extensions specifically
find "$ROOT" -maxdepth 1 -type d -iname '*claude*' -o -iname '*anthropic*' >> "$REPORT"
done
# Check for editor-spawned suspicious processes still running
ps auxww | grep -Ei '(cursor|code)' | grep -Ei '(curl|wget|nc |bash -i|base64)' >> "$REPORT"
echo "[+] Report written to $REPORT"
Remediation and Hardening
Immediate Actions (First 24 Hours)
- Identify exposed endpoints. Query your software inventory for Cursor installations and enumerate installed Claude Code extension versions. Cross-reference install/update timestamps against the exposure window published by the vendors. Any endpoint that installed or updated the extension during that window goes into the investigation queue.
- Isolate and preserve. For suspected endpoints, isolate from the network but do not reimage yet — capture memory and disk artifacts (the VQL artifacts above are a starting point) so you can determine what the malicious copy did and what it touched.
- Rotate everything the endpoint could reach. Treat every credential accessible from a potentially compromised developer workstation as exposed: cloud IAM keys and CLI tokens, git hosting PATs and SSH keys, npm/PyPI/Docker Hub tokens, CI/CD service account credentials, API keys stored in
.envfiles, and browser-stored session tokens. Rotation order matters: identity-provider and cloud credentials first, then code-hosting, then package registries. - Hunt for downstream use of stolen credentials. Review cloud audit logs (CloudTrail, Azure Activity Log, GCP Audit Logs), git hosting audit logs, and SaaS sign-in logs for access from unfamiliar IPs or unusual patterns during and after the exposure window. The attacker who ran this campaign demonstrated intent to monetize credentials — assume any stolen key was used or sold.
Structural Controls (This Quarter)
- Eliminate long-lived access keys in AI/SaaS integrations. The root cause at Fireworks was a stolen access key. Push your own vendors — and your own teams — toward short-lived, workload-identity-based credentials (OIDC federation, SPIFFE/SPIRE, managed identities) with automatic rotation. Where keys must exist, scope them minimally and alert on anomalous use.
- Enforce extension allowlisting for developer tools. VS Code and Cursor extensions are executable code delivered outside your software approval process. Establish an allowlist, pin approved extension versions, and disable auto-update for high-privilege extensions until your team can validate releases. Treat extension marketplaces as untrusted supply chain ingress points.
- Demand transitive trust transparency from vendors. Your risk model must now account for your vendors' vendors. Cursor's compromise flowed through Fireworks. Update your vendor risk assessments to ask specifically: which third parties hold credentials that could push code or configuration into your product, and how are those credentials protected?
- Segment developer workstations. Developers need powerful local tooling, but that tooling does not need standing access to production. Enforce just-in-time elevation, short-lived cloud sessions, and network segmentation so that a compromised editor cannot reach production control planes directly.
- Deploy endpoint telemetry on dev machines. Developer endpoints are chronically under-instrumented because of performance concerns and culture. This incident is your business case: ensure EDR coverage, process lineage logging, and DNS/network egress visibility on every machine that writes or builds code.
Monitor Vendor Advisories
Track official statements from Cursor (Anysphere), Anthropic (Claude Code), and Fireworks AI for confirmed malicious version numbers, the exact exposure window, and published indicators of compromise. Pin your scoping to vendor-confirmed version ranges rather than assumptions — over-scoping wastes IR hours; under-scoping leaves attacker footholds in place.
The Bigger Lesson
Every element of this attack — stolen SaaS credential, credential exfiltration at scale, abuse of legitimate publishing trust — is a pattern we have been warning clients about for years, now applied to the AI development toolchain. AI coding assistants have quietly become privileged infrastructure with massive local access and minimal security governance. If your threat model still treats editor extensions as benign productivity tools, this incident is the corrective. Inventory your AI tooling, govern what can publish and update code in your environment, and instrument your developer fleet like the production-adjacent asset class it actually is.
Related Resources
Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub
Is your security operations ready?
Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.