Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit JavaScript to vm2 sandbox
-
DeliveryExploit getOwnPropertyDescriptor or util.inspect
-
ExploitExtract host Function constructor
-
ExecutionObtain host process object
-
ImpactExecute arbitrary host commands
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V15 - Secure Coding and Architecture Protection mechanism completeness
|
| Exploitation Conditions | No special conditions - remote unauthenticated exploitation against default configurations of vm2 3.10.4. Any application calling VM.run() or similar vm2 sandbox methods with attacker-controlled JavaScript input is vulnerable. Exploitation requires only the ability to pass JavaScript code to vm2's execution methods, which is the library's intended use case. Attack complexity is low (AC:L) because the escape techniques rely on standard JavaScript reflection APIs (Object.getOwnPropertyDescriptor, Proxy, util.inspect) available in all Node.js environments. No privileges (PR:N), no user interaction (UI:N), and no non-default configuration required. The only limiting factor is that the vulnerable application must be using vm2 3.10.4 specifically to sandbox untrusted code execution - applications not using vm2 or not exposing code execution to untrusted users are unaffected. |
| Impact | Critical real-world risk for any application using vm2 3.10.4 to execute untrusted code. CVSS 9.8 with AV:N/AC:L/PR:N/UI:N accurately reflects the severity - remote unauthenticated attackers can achieve complete system compromise with low complexity. The S:U (unchanged scope) understates impact since sandbox escape typically represents scope change from contained to host. KEV status unknown from provided data. Public exploit code status unconfirmed, but the GitHub security advisory GHSA-ffh4-j6h5-pg66 and detailed release notes listing eleven distinct patches suggest security researchers have thoroughly mapped exploit paths. Any service exposing vm2-based code execution to untrusted users (e.g., online code playgrounds, plugin systems, serverless function sandboxes) faces immediate remote code execution risk. SSVC assessment: exploitation likely automatable (reflection APIs are deterministic), technical impact is total system compromise, and utilities like vm2 have high deployment in developer tooling. This is a patch-immediately scenario with no effective workarounds short of disabling the sandbox feature entirely. |
| Exploit ScenarioDerived | An attacker submits malicious JavaScript code to a web service that uses vm2 3.10.4 to safely execute user-provided scripts (e.g., an online code playground or plugin system). The attacker's code exploits Function constructor leakage via getOwnPropertyDescriptor or util.inspect internal method exposure to obtain a reference to the host process object. With host process access, the attacker executes arbitrary commands (e.g., child_process.exec) to install backdoors, exfiltrate credentials, or pivot to internal network resources. The entire attack occurs within a single VM.run() invocation with no indication to the host application that sandbox boundaries were violated. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – May 04, 2026
Full sandbox escape with arbitrary code execution allows remote attackers to break out of vm2's Node.js sandbox environment (version 3.10.4) and execute commands on the host system. Attacker-controlled code running inside VM.run() can obtain the host process object and execute arbitrary host commands without any cooperation from the host application. EPSS data not available, but this represents complete failure of the sandbox security boundary. Patch released in version 3.10.5 addresses eleven distinct escape vectors including Function constructor leakage, proxy unwrapping, util.inspect exposure, and WebAssembly exception handling.
RemediationAI
Upgrade immediately to vm2 version 3.10.5 or later (https://github.com/patriksimek/vm2/releases/tag/v3.10.5). The patched version implements comprehensive fixes for eleven distinct sandbox escape vectors including Function constructor blocking across all access paths, proxy unwrapping prevention, util.inspect internal method sanitization, SuppressedError sub-error sanitization, and WebAssembly.JSTag blocking for Node 25 environments. No workarounds exist for version 3.10.4 - the sandbox security boundary is fundamentally broken. If immediate upgrade is impossible, disable all vm2-based code execution features until patching is complete. For defense in depth post-patch, run Node.js processes using vm2 with OS-level sandboxing (containers, seccomp, AppArmor) and minimal filesystem/network privileges, though this does not address the application-level escape. Refer to GHSA-ffh4-j6h5-pg66 for complete advisory details.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in npm
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
vm2 (cpe:2.3:a:patriksimek:vm2:*:*:*:*:*:*:*:*) is a Node.js library designed to provide sandboxed JavaScript execution environments. The vulnerability stems from CWE-693 (Protection Mechanism Failure) - specifically, multiple failures in the isolation boundary between guest and host JavaScript contexts. Version 3.10.4 contains at least eleven distinct escape paths discovered during remediation, including: Function constructor access via getOwnPropertyDescriptor, proxy handler exploitation, exposure of internal bridge methods (doPreventExtensions, getFactory) through util.inspect, nested property descriptor manipulation, SuppressedError object leakage, direct handler.get() calls, and WebAssembly.JSTag exception handling in Node 25. The sandbox relied on prototype manipulation and context isolation that could be bypassed through creative use of JavaScript reflection APIs and Node.js internals.
Know when Vm2 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
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
DescriptionCVE.org
vm2 is an open source vm/sandbox for Node.js. In version 3.10.4, vm2 is vulnerable to full sandbox escape with arbitrary code execution. Attacker code inside VM.run() obtains host process object and runs host commands with zero host cooperation. This issue has been patched in version 3.10.5.
Blast Radius
ecosystem impact- 11 npm packages depend on vm2 (1 direct, 10 indirect)
Ecosystem-wide dependent count for version 3.10.5.
Executive ViewAI
CVE-2026-26956 is a critical sandbox escape vulnerability in vm2 (Node.js sandboxing library) versions up to 3.10.4 that allows remote code execution on the host system without authentication. Any application using vm2 to execute untrusted code is exposed to complete host compromise, making this a priority remediation for development teams and container environments running vulnerable versions.
Vendor-released patch: vm2 version 3.10.5. If immediate patching is not possible, isolate affected systems from untrusted input sources, disable vm2 usage where feasible, and implement network-level restrictions on affected host processes. However, patching is the only reliable mitigation for this sandbox escape vector.
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.
vm2 is an advanced vm/sandbox for Node.js. Rated critical severity (CVSS 10.0), this vulnerability is remotely exploitab
vm2 is a sandbox that can run untrusted code with Node's built-in modules. Rated critical severity (CVSS 10.0), this vul
vm2 is a sandbox that can run untrusted code with whitelisted Node's built-in modules. Rated critical severity (CVSS 10.
There exists a vulnerability in source code transformer (exception sanitization logic) of vm2 for versions up to 3.9.15,
vm2 is a sandbox that can run untrusted code with whitelisted Node's built-in modules. Rated critical severity (CVSS 10.
This affects the package vm2 before 3.9.4 via a Prototype Pollution attack vector, which can lead to execution of arbitr
Sandbox escape in vm2 for Node.js allows remote unauthenticated attackers to execute arbitrary commands on the host syst
Sandbox escape in vm2 (patriksimek/vm2) versions prior to 3.11.3 enables remote code execution on the host Node.js proce
Sandbox escape in vm2 Node.js sandbox before 3.10.2 via Promise.prototype.then/catch callback sanitization bypass. PoC a
vm2 is a sandbox that can run untrusted code with whitelisted Node's built-in modules. Rated critical severity (CVSS 9.8
The package vm2 before 3.9.10 are vulnerable to Arbitrary Code Execution due to the usage of prototype lookup for the We
Sandbox escape in the vm2 Node.js library through 3.11.6 lets untrusted code running inside a NodeVM instance reach the
EUVD-2026-26995
GHSA-ffh4-j6h5-pg66
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB