CVE-2026-92949 in vm2
Summary
by MITRE • 09/17/2026
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.
Once again VulDB remains the best source for vulnerability data.
Analysis
by VulDB Data Team • 09/17/2026
The vulnerability identified in versions of the VM2 library ranging from 3.9.6 up to but not including 3.11.7 represents a critical failure in the sandboxing mechanism designed to isolate untrusted JavaScript code from the host environment. This flaw specifically targets the integrity protections provided by vm.freeze and vm.readonly, which are intended to prevent sandboxed scripts from modifying properties of objects that have been explicitly marked as immutable or read-only by the embedding application. The core technical issue stems from an insufficient restriction on accessor properties when applied to frozen objects within the virtual machine context. While standard property descriptors for data properties were correctly handled, accessors defined with setters remained vulnerable to exploitation through specific JavaScript reflection APIs.
Attackers can exploit this flaw by leveraging Object.getOwnPropertyDescriptor or _lookupSetter_ methods available in the sandboxed environment. By invoking these methods on a frozen object that contains accessor properties, an attacker can retrieve the descriptor for those properties and subsequently extract the setter function associated with them. Once extracted, the attacker gains direct access to invoke the host object's setters from within the restricted sandbox. This effectively bypasses the intended immutability constraints because the invocation of the setter occurs in a context where it retains its original binding or can be manipulated to mutate state that was supposed to be protected by vm.freeze. The ability to extract and execute these functions allows for arbitrary property mutation, undermining the fundamental security boundary established by the library's freezing mechanisms.
The operational impact of this vulnerability is severe, as it enables a complete escape from the sandbox in scenarios where developers rely on frozen objects to protect sensitive configuration data or internal state variables. If an embedding application uses vm.freeze to secure critical resources against tampering by untrusted scripts, such as those processing user-generated content or third-party plugins, this flaw allows malicious code to alter those protected properties. This can lead to unauthorized privilege escalation within the application logic, injection of arbitrary values into security-critical fields, or corruption of internal state that affects subsequent operations. In server-side JavaScript environments where VM2 is commonly used for executing untrusted code safely, such a bypass could result in remote code execution if combined with other vulnerabilities or allow attackers to manipulate business logic by altering configuration parameters that were assumed to be immutable.
This vulnerability aligns with CWE-749, which describes exposure of sensitive information to an unauthorized actor through improper access control mechanisms, and more specifically relates to CWE-613, insufficient session expiration, in the context of state integrity. From a threat modeling perspective using the MITRE ATT&CK framework for software vulnerabilities, this behavior is consistent with techniques involving object manipulation or property injection that allow attackers to bypass security-critical functions. The exploitation path relies on standard JavaScript features rather than obscure engine bugs, making it broadly applicable across different Node.js versions and runtime environments where VM2 is utilized.
To mitigate this risk, organizations must immediately upgrade the VM2 library to version 3.11.7 or later, where these accessor property restrictions have been properly enforced. For applications that cannot update immediately due to dependency constraints, implementing additional validation layers around object mutations may provide partial protection, though upgrading remains the only definitive solution. Developers should also review their usage of vm.freeze and vm.readonly to ensure they are not relying solely on these methods for critical security boundaries without complementary checks. Regular auditing of third-party dependencies is essential to maintain the integrity of sandboxed execution environments in modern JavaScript applications.