Skip to main content

vm2 CVE-2026-92944

| EUVDEUVD-2026-81593 CRITICAL
Protection Mechanism Failure (CWE-693)
9.3
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Submit malicious JS to vm2 sandbox on Node 26
  2. Delivery
    Return async Promise with attacker Symbol.species
  3. Exploit
    finally() bypasses stale V8 protector wrapper
  4. Execution
    Reach host Function constructor and process
  5. Impact
    Execute 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity + public POC available.
1 public PoC Patch available 0.6% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

vm2 3.10.2 <3.11.7

Affected Packages

npm vm2 fix: 3.11.7

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

Vendor (VulnCheck) PRIMARY 9.3 CRITICAL
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
vuln.today AI 10.0 CRITICAL

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H
Red Hat 9.8 HIGH

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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.

Blast Radius

ecosystem impact
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 13 npm packages depend on vm2 (3 direct, 10 indirect)

Ecosystem-wide dependent count for version 3.10.2.

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

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.6%
Top 54% exploitable
Prevalence
Medium
popular but deprecated Node.js sandboxing library, niche runtime dependency
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC Yes
EPSS 0.6%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity + public POC available
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
Poc
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

67
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +46
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

More in Vm2

View all
CVE-2023-37466 CRITICAL POC
10.0 Jul 14

vm2 is an advanced vm/sandbox for Node.js. Rated critical severity (CVSS 10.0), this vulnerability is remotely exploitab

CVE-2023-32314 CRITICAL POC
10.0 May 15

vm2 is a sandbox that can run untrusted code with Node's built-in modules. Rated critical severity (CVSS 10.0), this vul

CVE-2023-30547 CRITICAL POC
10.0 Apr 17

vm2 is a sandbox that can run untrusted code with whitelisted Node's built-in modules. Rated critical severity (CVSS 10.

CVE-2023-29199 CRITICAL POC
10.0 Apr 14

There exists a vulnerability in source code transformer (exception sanitization logic) of vm2 for versions up to 3.9.15,

CVE-2022-36067 CRITICAL POC
10.0 Sep 06

vm2 is a sandbox that can run untrusted code with whitelisted Node's built-in modules. Rated critical severity (CVSS 10.

CVE-2021-23449 CRITICAL POC
10.0 Oct 18

This affects the package vm2 before 3.9.4 via a Prototype Pollution attack vector, which can lead to execution of arbitr

CVE-2026-26956 CRITICAL POC
9.8 May 04

Full sandbox escape with arbitrary code execution allows remote attackers to break out of vm2's Node.js sandbox environm

CVE-2026-24120 CRITICAL POC
9.8 May 04

Sandbox escape in vm2 for Node.js allows remote unauthenticated attackers to execute arbitrary commands on the host syst

CVE-2026-45411 CRITICAL POC
9.8 May 13

Sandbox escape in vm2 (patriksimek/vm2) versions prior to 3.11.3 enables remote code execution on the host Node.js proce

CVE-2026-22709 CRITICAL POC
9.8 Jan 26

Sandbox escape in vm2 Node.js sandbox before 3.10.2 via Promise.prototype.then/catch callback sanitization bypass. PoC a

CVE-2023-29017 CRITICAL POC
9.8 Apr 06

vm2 is a sandbox that can run untrusted code with whitelisted Node's built-in modules. Rated critical severity (CVSS 9.8

CVE-2022-25893 CRITICAL POC
9.8 Dec 21

The package vm2 before 3.9.10 are vulnerable to Arbitrary Code Execution due to the usage of prototype lookup for the We

Vendor StatusVendor

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy