Products / vm2
vm2
78 records.
- vm2 Sandbox Access to Host Buffer.alloc Allows timeout Bypass Resulting in Memory Exhaustion Sandboxed code can call the host's Buffer.alloc with a huge size, which the synchronous native call cannot be interrupted by the vm2 timeout, exhausting host memory.
- vm2 NodeVM `nesting: true` bypasses `require: false` allowing sandbox escape and arbitrary OS command execution Sandboxed code under nesting mode can load the host vm2 package and spawn an unrestricted inner VM, skipping the outer require restrictions.
- vm2 has a NodeVM builtin allowlist bypass via `module` builtin's `Module._load` that allows sandbox escape Sandboxed code allowed to use the module builtin calls Module._load to import host modules such as child_process, skipping the builtin allowlist.
- vm2 has a NodeVM require.root bypass via symlink traversal that allows sandbox escape Path checks use path.resolve without following symlinks while require follows them, so sandboxed code can load host modules outside the allowed root.
- vm2 has a Sandbox Escape via Promise Constructor Unhandled Rejection (Process Crash DoS) Sandboxed code creates a Promise whose executor triggers an unhandled host-realm error that crashes the Node.js host process, a path the earlier fix missed.
- vm2 Host Promise Resolution Preserves Object Identity Across Sandbox Boundary vm2 passes host Promise results into the sandbox without cross-realm wrapping, letting sandboxed code keep host object identity and mutate host state.
- vm2 has a Sandbox Escape Vulnerability Reaching an internal handler through util.inspect lets sandboxed code obtain host prototypes and run shell commands outside the vm2 sandbox.
- vm2 is Vulnerable to Host File Path Disclosure via Stack Trace Information Leak Code inside the vm2 sandbox can read host file paths through CallSite methods that the wrapper failed to sanitise.
- vm2: Mutable Proxies for Host Intrinsic Prototypes Allows Sandbox Escape Mutable proxies to host prototypes let sandboxed JavaScript write to shared host intrinsics and break out of the VM.
- vm2's Transformer Fast-Path Bypass Exposes Internal State Variable A regex fast path skips AST checks for code without certain keywords, letting sandboxed code reach an internal state object with privileged functions.
- VM2 Has a Sandbox Escape Issue via SuppressedError Errors thrown from deferred DisposableStack callbacks expose a host-realm constructor through SuppressedError, letting code leave the vm2 sandbox.
- VM2 Has a WASM Sandbox Escape A host-realm TypeError surfaces unsanitised through WebAssembly exception handling, giving attacker code a constructor chain to the host process.
- VM2 Has Sandbox Breakout Through Promise Species A previous sandbox fix can be undone by overwriting built-ins used in its reset logic, letting sandboxed code reach the host process.
- VM2 Has Sandbox Breakout Through Inspect Function Access through vm2's inspect path reaches the host sandbox object, letting attacker code escape the sandbox and run host commands.
- VM2 Sandbox Breakout Through __lookupGetter__ A getter lookup inside vm2 returns host-side objects, letting sandboxed code reach the host Function constructor and run commands outside the sandbox.
- vm2 has a Sandbox Escape A promise callback in the sandbox is sanitised for one Promise realm but not the host-global one, letting sandboxed code reach host process objects.
- vm2 Sandbox Escape vulnerability A flaw in how vm2 sanitizes Promise handlers lets code running inside the sandbox reach the host and execute arbitrary code.
- vm2 Sandbox Escape vulnerability A custom inspect function lets code inside the vm2 sandbox break out and run arbitrary Node.js code on the host.
- vm2 vulnerable to Inspect Manipulation Code running inside the vm2 sandbox can obtain a writable reference to the inspect function and change console.log options, breaking isolation.
- vm2 Sandbox Escape vulnerability Unexpected creation of a host object through Proxy handling lets sandboxed code escape vm2 and run code on the host.
- vm2 Sandbox Escape vulnerability Sandboxed code triggers an unsanitised host exception inside the exception handler, gaining host-realm objects that it can use to run arbitrary code.
- vm2 Sandbox Escape vulnerability Exception sanitisation in the vm2 source transformer can be skipped, so raw host exception objects leak and let sandboxed code reach the host context.
- vm2 vulnerable to sandbox escape Host objects passed to Error.prepareStackTrace for unhandled async errors leak out of the vm2 sandbox, letting untrusted code run on the host.
- vm2 vulnerable to Arbitrary Code Execution A WeakMap prototype lookup in vm2 gives sandboxed code access to a host object, allowing it to escape the sandbox.
- vm2 vulnerable to Sandbox Escape resulting in Remote Code Execution on host Crafted JavaScript breaks out of the vm2 sandbox and runs code with the host's privileges.
- vm2 before 3.6.11 vulnerable to sandbox escape Infinite recursion triggers a host-side RangeError whose returned object exposes the host mainModule, allowing the sandboxed code to spawn child processes.
- Sandbox bypass in vm2 Host error objects leak through stack trace generation, letting sandboxed code reach host internals and run arbitrary code.
- Prototype Pollution in vm2 Prototype pollution inside vm2 lets sandboxed code escape its boundary and run arbitrary code on the host.