Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconPlant prompt-injection in repo content
-
DeliveryAgent creates out-of-workspace symlink
-
ExploitForce canonicalization to fail
-
InstallWrite through symlink, bypass approval
-
C2Overwrite cursorsandbox helper
-
ExecuteNext command runs unsandboxed
-
ImpactArbitrary code execution as user
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Symlink resolution safety
|
| Exploitation Conditions | Exploitation requires Cursor prior to 3.0 running its default agent terminal sandbox, and requires the AI agent to be influenced to act maliciously (e.g., via prompt injection in repository/content the agent processes) - the description's 'malicious agent' is the core prerequisite. The attacker must get the agent to (1) create an in-workspace symlink whose target is outside the workspace, and (2) force path canonicalization to fail, achievable by pointing the symlink at a non-existent target or by removing read permission from the path. Limiting factors: the victim must be using the agent feature (the sandbox only governs agent-run commands), the attack needs an avenue to steer the agent (so an isolated agent working only on fully trusted local code is not exposed), and impact runs under the invoking user's OS privileges, not root. No additional human approval is needed because the bug specifically bypasses the approval gate - only a 'benign prompt' from the user is involved. |
| Impact | Signals are largely consistent on high severity: the vendor CVSS 4.0 base score is 9.3 with vector AV:N/AC:L/AT:N/PR:N/UI:N and high confidentiality, integrity, and availability impact, reflecting a reliable, low-complexity bypass that needs no special attack requirements. The realistic risk hinges on one precondition the raw vector understates - exploitation requires a 'malicious agent,' i.e. the attacker must influence what Cursor's AI agent does, plausibly via prompt injection embedded in repository content, documentation, or external data the agent ingests; the description notes 'no user interaction beyond a benign prompt,' so a developer simply using the agent on attacker-influenced content is enough. No EPSS score, KEV listing, or POC is present in the provided data, so there is no current evidence of in-the-wild or automated exploitation; the threat is presently theoretical-but-credible rather than confirmed active. Note a tension to verify: the CVSS marks AV:N, but the write primitive itself is local to the host running Cursor - the 'network' vector is justified only through remote delivery of malicious agent input, not direct remote interaction with a listening service. Treat this as a high-priority patch for any environment running Cursor with the default agent sandbox, especially where agents process untrusted repositories. |
| Exploit ScenarioDerived | A developer asks Cursor's agent to work on a repository that contains attacker-planted prompt-injection content; acting on it, the agent creates an in-workspace symlink pointing outside the workspace and ensures canonicalization fails (target absent or read permission removed). The agent then issues a Write through the symlink - bypassing approval - to overwrite the cursorsandbox helper, so the next agent terminal command executes unsandboxed on the host under the user's privileges. No public exploit code is identified at this time, but the low complexity (AC:L) and lack of required user interaction make the technique highly reliable once an agent is influenced. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jun 25, 2026
Sandbox escape leading to non-sandboxed remote code execution in Cursor (the AI code editor) prior to version 3.0, where a malicious agent can write files outside the protected workspace. Cursor canonicalizes a Write target to confirm it stays in-workspace, but when canonicalization fails it insecurely falls back to the raw path and writes without approval; an agent can deliberately force this failure via an in-workspace symlink pointing outside the workspace (target missing or read permission stripped) to write arbitrary files under the user's privileges. Overwriting the cursorsandbox helper then causes later commands to run unsandboxed, yielding full RCE with no user interaction beyond a benign prompt. There is no public exploit identified at time of analysis and it is not listed in CISA KEV.
RemediationAI
Upgrade to Cursor 3.0 or later, which fixes the canonicalization fail-open behavior - this is the primary and vendor-confirmed remediation (Vendor-released patch: 3.0), documented in advisory GHSA-3v8f-48vw-3mjx (https://github.com/cursor/cursor/security/advisories/GHSA-3v8f-48vw-3mjx). Until upgrading, reduce exposure by not running the agent against untrusted or attacker-influenced repositories and codebases, since the attack requires the agent to be steered into creating the malicious symlink and write; treat agent processing of third-party code as the trigger to avoid. Where the workflow allows, disable or avoid auto-approved agent Write/terminal actions so writes require explicit human review (trade-off: significantly more interruptions and reduced agent autonomy), and run Cursor under a least-privileged OS user without write access to sensitive locations or the cursorsandbox helper path so a successful symlink write cannot overwrite the sandbox binary (trade-off: may break workflows expecting broad filesystem access). These are mitigations only; none fully closes the fail-open path the way the 3.0 fix does.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The flaw is a link-following / path-canonicalization weakness (CWE-59) in Cursor's agent terminal sandbox, which is enabled by default in pre-3.0 builds and is meant to confine agent-issued file writes to the user's workspace. The intended control resolves (canonicalizes) the target path and rejects writes whose real path lands outside the workspace. The defect is the fail-open fallback: when canonicalization errors out, the code reverts to the original, unresolved path and proceeds without the normal approval gate. Because symlink resolution can be made to fail deterministically - pointing a symlink at a non-existent target, or removing read permission on a component of the path - an attacker controls the failure condition rather than encountering it by chance. The affected component is cpe:2.3:a:cursor:cursor across all versions before 3.0. This is a classic TOCTOU-style symlink bypass of a security boundary, amplified because the sandbox helper binary (cursorsandbox) itself becomes a writable target, turning a file-write primitive into code execution.
Know when Cursor gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Malicious agent input can be delivered remotely (AV:N) and the bypass is deterministic (AC:L, PR:N, UI:N); escaping the sandbox to compromise the host is a scope change (S:C) with full C/I/A loss.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
1DescriptionCVE.org
Cursor is a code editor built for programming with AI. Prior to 3.0, Cursor runs agent terminal commands in a sandbox by default. Before a Write, the agent canonicalizes the target path to confirm it stays inside the workspace, but when canonicalization fails it falls back to the original path and writes without approval. A malicious agent can create an in-workspace symlink that points outside the workspace and force canonicalization to fail - either because the target does not exist or because read permission is removed from the path - so the agent writes through the symlink to an arbitrary location without approval. A malicious agent could write arbitrary files outside the workspace under the user's privileges. This enables non-sandboxed Remote Code Execution - for example by overwriting the cursorsandbox helper so later commands run unsandboxed - with no user interaction beyond a benign prompt. This vulnerability is fixed in 3.0.
Executive ViewAI
A critical sandbox escape vulnerability in Cursor AI code editor (versions prior to 3.0) allows remote code execution when users interact with malicious agents; no public exploit has been identified at time of analysis. Development teams using Cursor risk code compromise and supply chain contamination through unauthorized modification of dependencies and application code.
No vendor-released patch identified at time of analysis. Disable Cursor or restrict usage to isolated, air-gapped systems. Enforce mandatory code review for all commits with explicit file-level examination; implement file system monitoring for Cursor processes; restrict Cursor to verified internal agents and prompts; establish application allowlist preventing Cursor from modifying critical files, configuration, and dependency manifests.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Arbitrary code execution in Cursor for Windows 3.2.16 lets remote attackers run code on a developer's machine by plantin
Remote code execution in Cursor IDE 1.6.23 and below can be triggered by prompt injection that abuses case-insensitive p
Cursor AI code editor before 2.3 allows prompt injection to bypass the Agent's Allowlist mode. Shell built-ins can execu
Sandbox escape leading to non-sandboxed remote code execution affects the Cursor AI code editor prior to version 3.0, wh
Cursor is a code editor built for programming with AI. In versions 1.7 and below, automatic loading of project-specific
Remote code execution in Cursor CLI Agent 1.7 and earlier can be triggered by unauthenticated attackers through prompt i
Cursor is a code editor built for programming with AI. Rated high severity (CVSS 8.8), this vulnerability is remotely ex
Cursor is a code editor built for programming with AI. In versions 1.7 and below, when MCP uses OAuth authentication wit
Cursor is a code editor built for programming with AI. Rated high severity (CVSS 8.8), this vulnerability is remotely ex
Cursor is a code editor built for programming with AI. Rated high severity (CVSS 8.8), this vulnerability is remotely ex
Cursor is a code editor built for programming with AI. versions up to 2.0 is affected by os command injection.
Cursor is a code editor built for programming with AI. Rated high severity (CVSS 8.7), this vulnerability is remotely ex
EUVD-2026-39536
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB