Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit malicious JS to vm2 sandbox on Node 26
-
DeliveryReturn async Promise with attacker Symbol.species
-
Exploitfinally() bypasses stale V8 protector wrapper
-
ExecutionReach host Function constructor and process
-
ImpactExecute arbitrary code on host
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 (1) an application that runs attacker-controlled JavaScript inside vm2 versions 3.10.2 through 3.11.6 - the core vm2 threat model - and (2) the host running specifically on Node.js 26 with V8 14.6, whose stale PromiseThenLookupChain protector is the root cause. No special vm2 configuration (no require.external, no builtin allowlists, no unsafe options) is needed - this escapes a default vm2 setup - but the Node.js 26 runtime is a hard gate: identical vm2 versions on other Node major versions are not exploitable via this finding. Exploitation is remote and unauthenticated only in the sense that the sandbox itself is the attack surface; the practical prerequisite is that the deployment accepts and executes untrusted code. |
| Impact | This is a genuine high-priority sandbox escape, not a CVSS-inflated paper cut. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H) describes remote, low-complexity, unauthenticated arbitrary code execution with full confidentiality/integrity/availability loss - consistent with a real vm2 sandbox escape where the whole security value of the product is defeated. The key mitigating factor is a runtime precondition the CVSS score does not capture: exploitation depends on Node.js 26 with V8 14.6 and its stale PromiseThenLookupChain protector, so deployments on other Node major versions are not affected by this specific finding. Signals are otherwise sparse and should be read honestly: no EPSS probability, no CISA KEV listing, and no explicitly published exploit code (a technical write-up likely exists in the GHSA/VulnCheck advisories but is not confirmed as weaponized PoC). Exploitation status is therefore 'no public exploit identified at time of analysis.' The overriding contextual gate is vm2's threat model - vm2 exists specifically to run untrusted JavaScript, so any escape is critical FOR THOSE deployments but irrelevant to installs that never feed attacker-controlled code to the sandbox. Net: treat as critical wherever vm2 runs untrusted input on Node 26; deprioritize where Node 26 is not in use. |
| Exploit ScenarioDerived | An application uses vm2 (3.10.2-3.11.6) on Node.js 26 to sandbox untrusted user-supplied JavaScript (e.g. a code-runner, template engine, or plugin host). The attacker submits an async function whose returned Promise carries an attacker-controlled constructor via Symbol.species; because Promise.prototype.finally() bypasses vm2's wrapper due to the stale V8 protector, the attacker walks to the host Function constructor and process object and executes arbitrary code on the host. No public weaponized exploit is confirmed, though the advisory likely documents the technique. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 17, 2026
Sandbox escape in the vm2 npm library versions 3.10.2 through 3.11.6, when running on Node.js 26, allows attacker-supplied JavaScript to break out of the sandbox and reach the host Function constructor and process object, resulting in arbitrary code execution. The escape is unauthenticated and requires no special vm2 configuration - no require.external, builtin allowlists, or unsafe options - but it is gated on the Node.js 26 / V8 14.6 runtime, so the same vm2 versions on other Node.js major versions are not affected by this finding. No public exploit code and no confirmed active exploitation were identified at time of analysis; the practical prerequisite is that a deployment accepts and executes untrusted code inside vm2, which is the library's core threat model.
RemediationAI
Patch available per vendor advisory: upgrade vm2 to the fixed release identified in GHSA-27g9-p43v-cw3v - the advisory does not state an exact patched version in the available data, but the upstream fix is carried by commits 7b26e81087ec88c287d9a4812f969d412f32774e and 4635ddd85839461c8ad791990023a477efefe7bd, so consumers should move to the first vm2 release containing both commits and re-verify with 'npm ls vm2' rather than relying on a floating semver range. If an immediate vm2 upgrade is not possible, the most reliable compensating control is the runtime gate itself: pin the host to a Node.js LTS line other than 26, since the escape depends on the stale PromiseThenLookupChain protector in V8 14.6 and does not reproduce on the other Node.js majors; the trade-off is that this defers a platform upgrade and leaves you on a non-target runtime while the affected Node.js 26 image remains in the build pipeline. Where untrusted code execution is genuinely required and neither of those options is available, move the untrusted workload out of the host process entirely - run it in a separate low-privilege process or container with seccomp/AppArmor confinement, no network egress by default, and a read-only filesystem - accepting the added operational complexity and latency of process-level isolation, and treat that as containment rather than a fix, because an escape from that boundary would then be bounded only by the OS sandbox. Disabling or monkey-patching Promise.prototype.finally inside untrusted contexts should not be relied upon as a mitigation, since it breaks legitimate async code and is trivially bypassed by other paths through the same stale protector.
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 Node.js sandbox library that runs untrusted JavaScript inside V8's vm module while using Proxy wrappers and host-object proxies to mediate every path back to real host intrinsics such as Function, process, and require. Correctness of that mediation depends on V8 invalidating its internal caches when the underlying object shapes change; specifically, vm2 relies on the PromiseThenLookupChain protector to detect when Promise.prototype.then/finally behaviour can no longer be trusted. On Node.js 26 with V8 14.6 that protector is stale, so Promise.prototype.finally() is reached through a code path that bypasses vm2's wrapper protections. An attacker supplies an async function that returns a Promise whose constructor carries an attacker-controlled Symbol.species; the unwrapped lookups returned along the stale chain hand back host intrinsics rather than sandbox proxies, and from the host Function constructor plus process the attacker achieves arbitrary code execution in the host process. This is classified CWE-693 (Protection Mechanism Failure): the sandbox's protective mechanism itself fails - there is no memory-safety bug and no malformed input, only an assumption about V8 engine internals that no longer holds on the affected runtime. The assigned CVSS 4.0 score of 9.3 (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H) and the independent assessment (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H) both reflect full confidentiality, integrity, and availability impact with the scope change characteristic of a successful sandbox escape.
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:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Default-config sandbox escape from guest to host is a scope change (S:C) yielding full host code execution (C/I/A:H); network-reachable and low-complexity for an attacker already permitted to submit sandbox code, though gated on Node 26.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
vm2 versions 3.10.2 through 3.11.6 contain a sandbox escape vulnerability on Node.js 26 where Promise.prototype.finally() bypasses vm2's wrapper protections due to a stale PromiseThenLookupChain protector in V8 14.6. Attackers can exploit this by creating an async function that returns a Promise with an attacker-controlled constructor Symbol.species, allowing them to reach the host Function constructor and process object for arbitrary code execution.
Technical POC Analysis
CWE-693: Protection Mechanism Failure.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Latest POC
1 public PoC link from github
Sign in to open the public PoC links collected for this CVE.
Executive ViewAI
CVE-2026-92944 is a sandbox escape in the widely used vm2 JavaScript isolation library (versions 3.10.2 through 3.11.6) that allows untrusted code to break containment and execute arbitrary commands on the underlying host, but only when those versions run on Node.js 26. Any product or internal service that accepts and runs customer-supplied, partner-supplied, or third-party JavaScript inside vm2 on that runtime is in scope, which is the exact use case vm2 exists for. Exploitation requires no special configuration and no credentials, so the practical exposure is determined almost entirely by whether the organization has standardized on Node.js 26 - a decision that may be made by platform engineering rather than by the application owners who carry the risk.
Apply vendor patch.
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
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-81593
GHSA-27g9-p43v-cw3v
NVD
CVE.org
EPSS
Exploit-DB