What Happened
Cursor, the AI-powered code editor built on the VS Code foundation, has confirmed that a security incident traced back to a compromised API key issued to third-party AI infrastructure provider Fireworks allowed threat actors to access Cursor data and credentials. The attackers leveraged that access to distribute malicious Claude Code extensions — IDE extensions that execute with the full privileges of the developer's editor process.
This is a supply-chain incident in the truest sense: the initial intrusion vector was not Cursor's own infrastructure but a third-party dependency (Fireworks AI), and the payload delivery mechanism was the developer toolchain itself. No CVE has been assigned to this incident — this is a credential compromise and malicious extension distribution campaign, not a software vulnerability. That distinction matters for your response: there is no patch to deploy. The remediation is credential rotation, extension hygiene, and detection engineering.
If your developers use Cursor, VS Code forks, or Claude Code extensions, treat this as an active risk to your source code, secrets, and build pipelines. Developer workstations are among the highest-value endpoints in any enterprise: they hold cloud credentials, SSH keys, source code, CI/CD tokens, and session cookies for internal systems.
Technical Analysis
Attack Chain
- Initial compromise (third party): Threat actors obtained a compromised API key issued to Fireworks, an AI inference infrastructure provider used in Cursor's backend pipeline.
- Access to Cursor data and credentials: Using the stolen key, attackers accessed Cursor-held data, including user credentials and related secrets.
- Malicious extension distribution: The attackers pushed or promoted malicious extensions masquerading as legitimate Claude Code tooling. On VS Code-derived editors, extensions are Node.js code that runs inside the editor's extension host process (
Cursor.exespawningnode.exechildren on Windows, or thecursorprocess tree on macOS/Linux). - Execution and theft: Once installed, a malicious extension can read any file the developer can read —
.envfiles,~/.aws/credentials,~/.ssh/, browser session stores — spawn child processes, and exfiltrate data over HTTPS to attacker-controlled infrastructure. IDE extensions require no code signing enforcement equivalent to mobile app stores, and install prompts are routinely accepted by developers.
Why IDE Extensions Are a Dangerous Payload Vehicle
- Extensions execute arbitrary Node.js code with the developer's user privileges at editor startup — a built-in persistence mechanism.
- They are typically excluded from application allowlisting policies because the parent process (the editor) is trusted.
- Extension updates are silent and automatic, giving attackers a post-compromise update channel.
- Developer endpoints frequently sit outside the tightest EDR scrutiny compared to servers, and outbound HTTPS from an editor is indistinguishable from normal telemetry without destination analysis.
Exploitation Status
This is confirmed in-the-wild activity with real victim impact (credential access and malicious extension distribution). There is no CISA KEV entry because no CVE exists — KEV tracks vulnerabilities, and this is a credential/supply-chain compromise. Defenders should treat it with the same urgency as an actively exploited zero-day on any endpoint where Cursor or Claude Code extensions are deployed.
Detection & Response
The highest-fidelity detection surfaces are: (1) the editor/extension host spawning shells or scripting interpreters, (2) unexpected outbound network connections from editor processes, and (3) unexpected or recently modified extensions on disk. The rules below are tuned to those behaviors — validate in your environment before enforcing at block level, since some legitimate extensions (linters, formatters, debuggers) do spawn child processes.
---
title: Cursor or VS Code Extension Host Spawning Shell or Scripting Interpreter
id: 3f8c1a92-7b4d-4e6f-9a21-c5d8e2f10b47
status: experimental
description: Detects Cursor/VS Code extension host processes spawning command shells or scripting interpreters. Malicious IDE extensions commonly execute payloads via child shells shortly after install or editor startup.
references:
- https://www.darkreading.com/application-security/cursor-malicious-claude-code-extension-third-party-breach
- https://attack.mitre.org/techniques/T1195/002/
- https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/01/15
tags:
- attack.execution
- attack.t1059
- attack.t1195.002
logsource:
category: process_creation
product: windows
detection:
selection_parent:
ParentImage|endswith:
- '\Cursor.exe'
- '\Code.exe'
- '\node.exe'
selection_child:
Image|endswith:
- '\cmd.exe'
- '\powershell.exe'
- '\pwsh.exe'
- '\wscript.exe'
- '\cscript.exe'
- '\mshta.exe'
- '\curl.exe'
- '\certutil.exe'
filter_known_good:
ParentCommandLine|contains:
- '\extensions\ms-python.'
- '\extensions\ms-vscode.'
- '\extensions\github.copilot'
- '\extensions\dbaeumer.'
condition: selection_parent and selection_child and not filter_known_good
falsepositives:
- Legitimate extensions (Python/debugger/tooling extensions) spawning shells - tune the filter list to your approved extension inventory
level: high
---
title: Network Connection from IDE Extension Host to Uncommon Destination
id: 8b2e4d61-3c7a-4f95-b8e4-1a9d6c3f5e28
status: experimental
description: Detects Cursor/VS Code extension host (node.exe under editor paths) initiating outbound connections to ports or destinations atypical for marketplace, update, or AI API traffic. Malicious extensions exfiltrate over HTTPS from the extension host.
references:
- https://www.darkreading.com/application-security/cursor-malicious-claude-code-extension-third-party-breach
- https://attack.mitre.org/techniques/T1041/
author: Security Arsenal
date: 2026/01/15
tags:
- attack.exfiltration
- attack.t1041
- attack.t1195.002
logsource:
category: network_connection
product: windows
detection:
selection:
Image|contains:
- '\.cursor\'
- '\.vscode\'
Image|endswith: '\node.exe'
Initiated: 'true'
filter_ports:
DestinationPort:
- 443
condition: selection and not filter_ports
falsepositives:
- Extensions with local debugging, language servers, or dev-server integrations using non-443 ports - baseline before alerting
level: medium
---
title: Recently Created or Modified Extension Package in Cursor/VS Code Extensions Directory
id: 5c1f9b37-2d8e-4a46-a7c3-9e2b8d4f60a1
status: experimental
description: Detects creation or modification of package.json within user IDE extension directories outside of expected update windows. Malicious extensions masquerading as Claude Code tooling will appear as new or repackaged extension folders.
references:
- https://www.darkreading.com/application-security/cursor-malicious-claude-code-extension-third-party-breach
- https://attack.mitre.org/techniques/T1195/002/
author: Security Arsenal
date: 2026/01/15
tags:
- attack.persistence
- attack.t1195.002
logsource:
category: file_event
product: windows
detection:
selection:
TargetFilename|contains:
- '\.cursor\extensions\'
- '\.vscode\extensions\'
TargetFilename|endswith: '\package.json'
filter_updater:
Image|endswith:
- '\Cursor.exe'
- '\Code.exe'
condition: selection and not filter_updater
falsepositives:
- Manual extension development or sideloaded internal extensions
level: medium
// Hunt: Cursor/VS Code extension host spawning shells or downloaders (last 14 days)
// Surfaces the post-install execution behavior of malicious IDE extensions.
DeviceProcessEvents
| where TimeGenerated > ago(14d)
| where InitiatingProcessFileName in~ ("Cursor.exe", "Code.exe", "node.exe")
or InitiatingProcessCommandLine has_any (".cursor\\extensions", ".vscode\\extensions")
| where FileName in~ ("cmd.exe", "powershell.exe", "pwsh.exe", "mshta.exe", "wscript.exe", "cscript.exe", "curl.exe", "certutil.exe", "bitsadmin.exe")
| project TimeGenerated, DeviceName, AccountName,
InitiatingProcessFileName, InitiatingProcessCommandLine,
FileName, ProcessCommandLine, ProcessId, SHA256
| order by TimeGenerated desc;
// Hunt: Outbound connections from editor/extension-host processes to rare destinations
// Excludes known-good AI and marketplace endpoints; expand the allowlist for your org.
DeviceNetworkEvents
| where TimeGenerated > ago(14d)
| where InitiatingProcessFileName in~ ("Cursor.exe", "Code.exe", "node.exe")
| where InitiatingProcessCommandLine has_any (".cursor\\extensions", ".vscode\\extensions", "Cursor.exe")
| where not(RemoteUrl has_any ("cursor.sh", "cursor.com", "anthropic.com", "fireworks.ai",
"openai.com", "visualstudio.com", "microsoft.com", "github.com", "githubusercontent.com"))
| summarize ConnectionCount = count(), FirstSeen = min(TimeGenerated), LastSeen = max(TimeGenerated)
by DeviceName, InitiatingProcessFileName, RemoteUrl, RemoteIP, RemotePort
| where ConnectionCount > 10
| order by ConnectionCount desc;
// Hunt: Extension installs/modifications via Sysmon FileCreated (Event 11) ingested as SecurityEvent
// Requires Sysmon file-create events forwarded to Sentinel.
Event
| where TimeGenerated > ago(14d)
| where EventID == 11
| extend EvData = parse_xml(EventData)
| extend TargetFileName = tostring(EvData.DataItem.EventData.Data.[4].['#text'])
| extend Image = tostring(EvData.DataItem.EventData.Data.[5].['#text'])
| where TargetFileName has_any (".cursor\\extensions", ".vscode\\extensions")
| where TargetFileName endswith "package.json"
| where not(Image has_any ("Cursor.exe", "Code.exe"))
| project TimeGenerated, Computer, Image, TargetFileName
| order by TimeGenerated desc;
-- Artifact: Windows.Forensics.IDEExtensionAudit
-- Enumerates installed Cursor/VS Code extensions across user profiles, flags recent
-- modification times and non-allowlisted publishers, and lists extension-host
-- processes with shell children. Deploy as a fleet-wide hunt.
-- Part 1: Inventory extension package.json files across all user profiles
LET extension_inventory = SELECT
FullPath,
Mtime AS LastModified,
Size,
read_file(filename=FullPath, length=8192) AS PackageJson
FROM glob(globs='C:/Users/*/.cursor/extensions/*/package.json')
UNION
SELECT
FullPath,
Mtime AS LastModified,
Size,
read_file(filename=FullPath, length=8192) AS PackageJson
FROM glob(globs='C:/Users/*/.vscode/extensions/*/package.json');
-- Part 2: Flag suspicious entries - modified in last 30 days OR publisher not in allowlist
SELECT
FullPath,
LastModified,
Size,
parse_json(data=PackageJson).publisher AS Publisher,
parse_json(data=PackageJson).name AS ExtensionName,
parse_json(data=PackageJson).version AS Version
FROM extension_inventory
WHERE LastModified > (now() - 2592000)
OR Publisher !~ '^(ms-|github|redhat|google|anthropic|dbaeumer|esbenp)'
ORDER BY LastModified DESC;
-- Part 3: Live view - editor processes and any shell children (run separately as a second artifact if needed)
SELECT Pid, Ppid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE CommandLine =~ '(?i)(cursor|code)'
OR (Name =~ '(?i)(cmd|powershell|pwsh|mshta|wscript)'
AND Ppid IN (SELECT Pid FROM pslist() WHERE Name =~ '(?i)(cursor|code|node)'));
# Cursor/VS Code Extension Audit & Credential Exposure Response
# Run elevated on developer endpoints (or via your RMM) to inventory extensions,
# flag non-allowlisted publishers, and identify exposed secret files.
# Author: Security Arsenal IR Team
$report = @()
$extensionRoots = @(
"$env:USERPROFILE\.cursor\extensions",
"$env:USERPROFILE\.vscode\extensions"
)
# Adjust to your organization's approved publisher list
$approvedPublishers = @('ms-python','ms-vscode','ms-toolsai','github','redhat','google','dbaeumer','esbenp','anthropic')
foreach ($root in $extensionRoots) {
if (Test-Path $root) {
Get-ChildItem -Path $root -Directory | ForEach-Object {
$pkgPath = Join-Path $_.FullName 'package.json'
if (Test-Path $pkgPath) {
$pkg = Get-Content $pkgPath -Raw | ConvertFrom-Json
$publisher = if ($pkg.publisher) { $pkg.publisher } else { 'UNKNOWN' }
$approved = ($approvedPublishers | Where-Object { $publisher -like "$_*" }).Count -gt 0
$report += [PSCustomObject]@{
ExtensionDir = $_.Name
Publisher = $publisher
Version = $pkg.version
LastWriteTime = $_.LastWriteTime
Approved = $approved
Path = $_.FullName
}
}
}
}
}
Write-Host "=== EXTENSION INVENTORY ===" -ForegroundColor Cyan
$report | Sort-Object Approved, LastWriteTime -Descending | Format-Table -AutoSize
$suspicious = $report | Where-Object { -not $_.Approved }
if ($suspicious) {
Write-Host "=== UNAPPROVED EXTENSIONS - REVIEW AND REMOVE ===" -ForegroundColor Red
$suspicious | Format-Table ExtensionDir, Publisher, Path, LastWriteTime -AutoSize
# Uncomment to remove after validation:
# $suspicious | ForEach-Object { Remove-Item $_.Path -Recurse -Force }
}
# Check for high-value secret files readable by any extension (exposure scope assessment)
Write-Host "=== SECRET EXPOSURE CHECK ===" -ForegroundColor Yellow
$secretPaths = @(
"$env:USERPROFILE\.aws\credentials",
"$env:USERPROFILE\.azure\accessTokens.json",
"$env:USERPROFILE\.ssh\id_rsa",
"$env:USERPROFILE\.ssh\id_ed25519",
"$env:USERPROFILE\.kube\config",
"$env:USERPROFILE\.git-credentials"
)
foreach ($p in $secretPaths) {
if (Test-Path $p) { Write-Host "PRESENT (rotate if compromise suspected): $p" -ForegroundColor Yellow }
}
# Identify running extension-host child shells right now
Write-Host "=== EDITOR CHILD PROCESSES ===" -ForegroundColor Cyan
$editors = Get-Process -Name 'Cursor','Code','node' -ErrorAction SilentlyContinue
Get-CimInstance Win32Process | Where-Object {
$_.ParentProcessId -in $editors.Id -and
$_.Name -match 'cmd|powershell|pwsh|mshta|wscript'
} | Select-Object ProcessId, Name, CommandLine | Format-List
# Export full inventory for IR evidence preservation
$report | Export-Csv -Path "$env:TEMP\ide_extension_audit_$(Get-Date -Format yyyyMMdd_HHmmss).csv" -NoTypeInformation
Write-Host "Inventory exported to $env:TEMP" -ForegroundColor Green
Remediation
Immediate (0–24 hours):
- Rotate all potentially exposed credentials. Per Cursor's disclosure guidance, reset any API keys, session tokens, and passwords associated with your Cursor account — and critically, any secrets stored on developer endpoints that run Cursor: Fireworks/Anthropic/OpenAI API keys, AWS/Azure/GCP credentials, SSH private keys, GitHub tokens, and CI/CD service accounts. Assume key material on an affected endpoint is compromised.
- Audit and remove suspicious extensions. Run the inventory script above across your fleet. Remove any extension you cannot attribute to an approved publisher, especially anything installed or modified around the disclosure window. Cross-reference against the malicious extension names reported in the Dark Reading coverage and Cursor's official advisory channels.
- Reinstall from clean sources. For any developer who had a flagged extension, do not just uninstall — review endpoint telemetry for the full dwell period, and consider reimaging if shell execution or exfiltration indicators are present.
Short term (1–2 weeks):
- Enforce extension allowlisting. VS Code-derived editors support controlling which extensions can be installed (e.g., via
extensions.allowedpolicies, managed settings, or by blocking the marketplace and distributing approved extensions internally). Move developers from "install anything" to "install from the approved list." - Deploy the detection content above to your SIEM/EDR. Alert on editor extension hosts spawning shells — this is high-signal on developer endpoints once you filter your standard tooling extensions.
- Constrain egress from developer workstations. Editors legitimately need access to a small set of domains (marketplace, model providers, package registries). Alerting on HTTPS from editor processes to anything outside that baseline catches most extension-based exfiltration.
Strategic:
- Treat AI toolchain vendors as critical third parties. This incident began with a key issued to an AI infrastructure provider. Your vendor risk program must now explicitly cover AI coding assistants and their subprocessors: what keys are issued, what data flows through them, and what the blast radius is if their key material leaks.
- Protect secrets on developer endpoints. Enforce short-lived, scoped credentials (OIDC-based cloud auth instead of static keys), hardware-backed SSH keys, and secrets managers so that a compromised editor yields minimal reusable material.
Key Takeaway
There is no patch for this incident — the fix is operational: rotate credentials, audit extensions, and build detection around the editor process tree. The broader lesson is that the AI coding assistant supply chain is now an active attack surface. Defenders who treat IDE extensions as unmanaged code execution — because that is exactly what they are — will be positioned to catch the next one before credentials walk out the door.
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.