Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit script to vm2 sandbox
-
DeliveryThrow revisited host-wrapped AggregateError
-
ExploitBypass cycle detection in handleException
-
ExecutionReach unsanitized host proxy in errors array
-
PersistExecute code on Node.js host
-
ImpactDisclose process info / full RCE
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 | Requires that the host application actually runs attacker-controlled JavaScript inside a vulnerable vm2 instance (version before 3.11.8) - this is vm2's normal use case, so it is not an exotic prerequisite. Beyond that, the attacker must specifically craft a host-wrapped AggregateError that is revisited within a single exception-handler traversal so that handleException's cycle-detection is bypassed and an unsanitized host proxy in the errors array is reached. Limiting factors: exploitation is not fully trivial (CVSS AC:H/AT:P) because the malformed-error/traversal condition must be arranged precisely; no authentication or user interaction is needed once untrusted code reaches the sandbox; environments that do not execute untrusted code in vm2, or that have migrated off vm2 (deprecated since 2023), are not exposed. |
| Impact | This is a genuine high-priority issue where the CVSS signals and the technical facts align rather than conflict. The vendor CVSS 4.0 score of 9.5 reflects a full sandbox escape from vm2 to the Node.js host, yielding remote code execution and process information disclosure - the most severe outcome possible for a sandbox library, whose entire purpose is to contain untrusted code. The vector correctly encodes AV:N, PR:N, UI:N (any untrusted script the app runs can attempt it) alongside AC:H and AT:P, which honestly capture that the attacker must craft a specific revisited host-wrapped AggregateError to defeat the cycle-detection logic in handleException - this is not a trivial one-liner. Scope-change metrics (SC:H/SI:H/SA:H) are justified because the impact crosses the sandbox/host trust boundary. However, EPSS is not provided, this CVE is NOT in CISA KEV, and no public exploit code is referenced, so there is no evidence of active exploitation - the priority derives from impact severity and the low bar of the vm2 threat model (many apps deliberately feed attacker code to vm2), not from confirmed in-the-wild use. One data caveat worth flagging: the cited fixed version 3.11.8 does not match publicly-known vm2 release history (the project stopped at 3.9.19 and was deprecated in 2023 in favor of isolated-vm) - verify the exact affected/fixed versions with the vendor advisory. |
| Exploit ScenarioDerived | An application uses vm2 to sandbox untrusted or user-supplied JavaScript (e.g., a code playground, serverless function runner, or template/formula engine). The attacker submits script that constructs and throws a host-wrapped AggregateError whose errors array is revisited during a single exception-handler traversal, defeating handleException's cycle detection so an unsanitized host proxy is exposed. Grabbing that proxy, the attacker pivots to the Node.js host to execute arbitrary code and read process information. No public POC is referenced, but this is the classic vm2 escape pattern and the flaw is an incomplete fix of prior Error.cause sanitization. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 17, 2026
Sandbox escape in vm2 before 3.11.8 allows unauthenticated remote attackers to achieve full remote code execution and host process information disclosure by crafting a host-wrapped AggregateError that is revisited within a single exception-handler traversal, bypassing handleException's cycle detection and exposing unsanitized host proxies in the errors array. The flaw is an incomplete fix for Error.cause sanitization, and exploitation requires the host application to execute attacker-controlled JavaScript inside a vulnerable vm2 instance, which is vm2's normal use case, though the malformed-error and traversal condition is non-trivial (CVSS AC:H/AT:P). No public exploit identified at time of analysis; environments that do not run untrusted code in vm2, or that have migrated off the deprecated vm2, are not exposed.
RemediationAI
Vendor-released patch: vm2 3.11.8. Upgrade to vm2 3.11.8 or later as the primary fix, per the advisory at https://github.com/patriksimek/vm2/security/advisories/GHSA-x965-fc75-jpqh. Because vm2 is deprecated and no longer receives feature updates, organizations should treat this as an opportunity to migrate to a maintained sandbox such as isolated-vm, which eliminates the vulnerable code path entirely. If immediate upgrade is not possible, the only reliable compensating control is to avoid executing untrusted JavaScript inside vm2 until the patch is applied; disabling or restricting vm2 usage in production reduces exposure but may break functionality that relies on sandboxed execution. Network-level restrictions do not help because exploitation requires the host application to run attacker-supplied code inside the sandbox, not direct network access to vm2. Additional detail is available in the VulnCheck advisory at https://www.vulncheck.com/advisories/vm2-before-3.11.8-sandbox-escape-rce-via-aggregateerror.
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 is a widely used Node.js sandbox library that uses Node's vm module and Proxy objects to run untrusted JavaScript in a restricted context. CVE-2026-92934 is classified as CWE-693 (Protection Mechanism Failure) because the sandbox's error-sanitization mechanism for Error.cause is incomplete. The specific flaw lies in how vm2 handles host-wrapped AggregateError objects: when such an error is caught and traversed within a single exception-handler pass, the cycle-detection logic in handleException can be bypassed, allowing the sandboxed code to reach an unsanitized host proxy embedded in the error's errors array. This yields a full sandbox escape, enabling remote code execution and disclosure of host process information. The affected CPE is cpe:2.3:a:patriksimek:vm2:*:*:*:*:*:*:*:* and the vendor advisory is at GHSA-x965-fc75-jpqh, with a VulnCheck advisory also available.
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
CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H
Untrusted sandboxed code needs no auth (PR:N) but must craft a precise revisited-AggregateError traversal (AC:H); escape crosses sandbox to host so S:C with full C/I/A:H RCE.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
vm2 before 3.11.8 contains an incomplete fix for Error.cause sanitization that allows sandbox escape when revisited host-wrapped AggregateError objects are caught within a single exception handler traversal. Attackers can exploit cycle detection bypass in handleException to access unsanitized host proxies embedded in the errors array, enabling full remote code execution and process information disclosure from the sandbox.
Articles & Coverage 1
Technical POC Analysis
The flaw is a protection-mechanism failure, CWE-693, in vm2's exception sanitizer.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A critical sandbox escape in the deprecated vm2 JavaScript sandbox library (CVE-2026-92934, CVSS 9.5) lets an attacker who supplies JavaScript to a vm2 instance break out of the sandbox and execute arbitrary code with the host process's privileges, potentially handing over the underlying application server. Because running untrusted code inside vm2 is the library's core purpose, any team still using it for multi-tenant, plugin, or rule-engine execution faces a direct path from normal application traffic to full host compromise. Leadership should treat this as an architectural risk rather than a patch-management item: no vendor-released patch has been identified at time of analysis, so the durable fix is removing vm2 from the codebase, with environments that have already migrated off the library not exposed.
No vendor-released patch identified at time of analysis. Interim mitigations: migrate off the deprecated vm2 library; remove or disable execution of untrusted or attacker-controlled JavaScript inside vm2; isolate affected workloads in separate processes or containers under least-privilege OS users with seccomp/AppArmor profiles; restrict egress network access from affected hosts; and monitor for unexpected child processes, host-level anomalies, or suspicious outbound connections.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
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
Full sandbox escape with arbitrary code execution allows remote attackers to break out of vm2's Node.js sandbox environm
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
EUVD-2026-81584
GHSA-4xmw-hh9q-4q7c
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB