Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessRun untrusted JS in vm2 sandbox
-
DeliveryLocate frozen host object exposed by embedder
-
ExploitExtract setter via getOwnPropertyDescriptor/__lookupSetter__
-
ExecutionInvoke host setter directly
-
ImpactMutate read-only host property
Vulnerability Assessment
| Weakness |
CWE
|
| Exploitation Conditions | Two conditions must both hold: (1) the host application runs attacker-controlled/untrusted JavaScript inside a vm2 NodeVM (the standard vm2 threat model), and (2) the embedder relies on vm.freeze() or vm.readonly() to protect host objects that are reachable from the sandbox - if no host objects are frozen/readonly, there is nothing to bypass and no impact. Exploitation is limited by high attack complexity (AC:H) and a present attack requirement (AT:P), and the impact ceiling is low: integrity-only mutation of read-only properties, with no confidentiality or availability impact and no code execution. The vulnerability is fixed in vm2 3.11.7; versions 3.9.6 through 3.11.6 are affected. vm2 being deprecated further narrows realistic exposure to legacy deployments. |
| Impact | This is a genuinely moderate, not critical, issue and the vendor CVSS 4.0 score of 6.3 (medium) reflects that honestly. The vector AV:N/AC:H/AT:P/PR:N/UI:N with only VI:L and SI:L (integrity-low on both the vulnerable and a subsequent system) tells the real story: this is an integrity-only protection bypass with no confidentiality (VC:N) or availability (VA:N) impact, and it carries a high attack complexity plus a present attack requirement (AC:H/AT:P), meaning exploitation is conditional rather than trivial. Exploitation status is no public exploit identified at time of analysis - there is no EPSS score, no CISA KEV listing, and no confirmed POC in the provided data (though the GHSA-633r-hq9m-c4ff advisory may contain technical detail). PR:N indicates no authentication is needed by the sandboxed script, which is expected: in the vm2 threat model the attacker IS the untrusted script already running inside the sandbox. Critically, unlike sibling vm2 CVEs in this wave (e.g. [[cve-2026-92956]], [[cve-2026-92957]], [[cve-2026-92955]]) this is NOT a full sandbox escape or RCE - it only lets sandboxed code defeat vm.freeze()/vm.readonly() and mutate host properties the embedder marked read-only. Real-world priority is therefore LOW-to-MEDIUM: it only matters to embedders who both run untrusted code in vm2 AND rely on freeze/readonly as a security boundary. The bigger contextual signal is that vm2 is deprecated and unmaintained, so any deployment is already outside vendor support. |
| Exploit ScenarioDerived | An application runs untrusted plugin/user JavaScript inside a vm2 NodeVM and exposes a host configuration or capability object that it froze via vm.freeze() or vm.readonly(), trusting the sandbox to keep it immutable. The sandboxed script calls Object.getOwnPropertyDescriptor() or __lookupSetter__() on that object to retrieve the host-realm setter function, then invokes it directly to overwrite the supposedly read-only property. No public exploit code is identified, and the high attack complexity means the technique depends on the embedder actually having frozen host objects reachable from the sandbox. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 17, 2026
Sandbox escape and read-only bypass in vm2 3.9.6 through 3.11.6 lets untrusted JavaScript running inside a NodeVM defeat the vm.freeze() and vm.readonly() protections and mutate host object properties that the embedder explicitly marked immutable. An attacker uses Object.getOwnPropertyDescriptor() or __lookupSetter__() to recover host-realm setters from accessor properties on frozen objects and invoke them directly, circumventing the Proxy-based restrictions. The CVSS 4.0 vector (PR:N, AC:H, AT:P, VI:L/SI:L, no C/I/A beyond low integrity) confirms unauthenticated access but high attack complexity and an integrity-only ceiling with no code execution; two prerequisites must hold (untrusted code executed in vm2, and reliance on vm.freeze()/vm.readonly() to protect reachable host objects). No public exploit identified at time of analysis, there is no CISA KEV listing, and vm2 is deprecated, which further narrows realistic exposure to legacy deployments using versions 3.9.6 to 3.11.6.
RemediationAI
Vendor-released patch: vm2 3.11.7 - upgrade to 3.11.7 or later, as documented in the GitHub advisory GHSA-633r-hq9m-c4ff and the VulnCheck advisory (https://www.vulncheck.com/advisories/vm2-3.9.6-before-3.11.7-sandbox-bypass-via-accessor-descriptor). Where upgrading is not immediately possible, do not treat vm.freeze() or vm.readonly() as a security boundary: pass only deep-copied plain data (for example via structuredClone or JSON round-tripping) into the sandbox instead of live host objects that carry setters, or re-define exposed objects with data-only descriptors and null prototypes so that no accessor functions cross the boundary - the trade-off is that in-place callbacks and by-reference mutation of host state stop working and legitimate API surface may need reworking, and any host object still reachable with a setter reintroduces the bypass. Because vm2 is deprecated and no longer actively maintained, medium-term remediation should be migration of untrusted-code execution to a maintained isolation mechanism such as isolated-vm or a separate process using node:child_process/worker_threads with OS-level sandboxing (seccomp, containers, restricted user), noting that Node's built-in node:vm module is explicitly not a security boundary. Also inventory dependencies for residual vm2 3.9.6-3.11.6 usage, since the deprecation means downstream patching is unlikely to arrive through normal transitive dependency updates.
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 sandboxing library (patriksimek:vm2, CPE cpe:2.3:a:patriksimek:vm2:*:*:*:*:*:*:*:*) that emulates isolation by wrapping host objects in Proxies and by exposing helpers such as vm.freeze() and vm.readonly(), which are intended to make host objects immutable from inside the sandbox. The root cause is CWE-471, Modification of Assumed-Immutable Data: the sandbox's freeze/readonly logic does not strip or neutralize accessor (getter/setter) properties, so a frozen object can still carry a setter function that is a live reference into the host realm. Because Object.getOwnPropertyDescriptor() returns the raw descriptor - including the set accessor - and the legacy Object.prototype.__lookupSetter__() returns the same function reference, a sandboxed script can obtain the host setter and call it directly, bypassing the Proxy traps that would otherwise block property writes. This is a property-descriptor/semantics flaw rather than a memory-safety or code-injection bug: the primitive achieved is unauthorized mutation of host state the embedder believed was immutable, matching the integrity-only (VI:L/SI:L) impact in the assessed CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:C/C:N/I:L/A:N vector and the vendor CVSS 4.0 score of 6.3. The problem is fixed in vm2 3.11.7, and the package is deprecated, so the affected code base is largely legacy.
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:N/VI:L/VA:N/SC:N/SI:L/SA:N
Sandboxed attacker (PR:N in vm2 model) crosses the sandbox boundary to mutate host state (S:C, I:L); no confidentiality or availability impact; conditional technique so AC:H.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
1DescriptionCVE.org
vm2 versions from 3.9.6 before 3.11.7 fail to properly restrict access to accessor properties on frozen objects, allowing sandboxed scripts to bypass vm.freeze() and vm.readonly() protections. Attackers can use Object.getOwnPropertyDescriptor() or __lookupSetter__() to extract and invoke host object setters directly, mutating properties the embedder explicitly marked read-only.
Blast Radius
ecosystem impact- 29 npm packages depend on vm2 (7 direct, 22 indirect)
Ecosystem-wide dependent count for version 3.9.6.
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
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
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-81598
GHSA-633r-hq9m-c4ff
NVD
CVE.org
EPSS
VulDB
Exploit-DB