Products / vm2
vm2
78 records.
- vm2 contains a sandbox escape vulnerability The NodeVM denylist omits child_process, so sandboxed code allowed to load builtins can require it and run host commands.
- vm2: Host Promise rejection from an exposed constructor can terminate the vm2 host process A rejected promise returned from an exposed host constructor is not marked handled, so Node terminates the host process.
- vm2: Default VM can mutate host TypedArray and ArrayBuffer intrinsics after the host-prototype pollution fix A prior fix blocked sandbox writes to classic host prototypes but omitted typed-array and ArrayBuffer intrinsics, so sandbox code can still mutate host objects.
- vm2: NodeVM zlib Buffers expose pooled host memory across the VM boundary A zlib result returned into the vm2 sandbox can be a pooled buffer exposing its full backing store, letting guest code read and modify host memory.
- vm2: NodeVM custom resolution bypasses external path boundaries Guest code in a NodeVM requires a sibling directory whose path only shares a string prefix with an allowlisted module, reaching host modules outside the boundary.
- vm2: Sandbox Escape (NodeVM) Overwriting the prototype chain reachable through console streams lets sandboxed code call host process methods and run code outside the VM.
- vm2: `allowAsync: false` can be bypassed through Promise thenable assimilation in VM and NodeVM Promise static methods such as resolve and all still adopt attacker thenables, so their then callbacks run after the host returns, bypassing allowAsync and timeout.
- vm2: Sandboxed code can read and write host-realm memory via Node's shared Buffer pool Small Buffer allocations come from a pool shared with the host, so sandboxed code can read leftover host memory.
- vm2: Host-returned Promise rejection can bypass vm2's unhandled-rejection hardening and terminate the host process Sandboxed code can trigger an unhandled host Promise rejection that the bridge leaves unhandled, crashing the Node.js host process.
- vm2: NodeVM `require.external` without an explicit `require.root` grants unrestricted host filesystem access and full RCE Default vm2 path settings let sandboxed code load the library through host require, then create an unrestricted instance that runs host OS commands.
- vm2: util.getCallSites() bypasses GHSA-v27g-jcqj-v8rw host-frame redaction, leaks host call stack Sandboxed code reaches the host util module's getCallSites, exposing host file paths and stack frames that an earlier redaction fix was meant to hide.
- vm2: timeout Option Bypass via FinalizationRegistry Cleanup Callback (Unbounded Host Event-Loop Block) Sandboxed code registers a FinalizationRegistry callback that runs during garbage collection, outside the timeout meant to bound execution, blocking the host event loop.
- vm2 sandbox escape via WebAssembly.compileStreaming Promise species bypass On Node 26, the streaming WebAssembly APIs return a host-realm Promise whose species can be manipulated to obtain the host process object.
- vm2 leaks absolute host filesystem paths to sandbox code via error stack formatting Sandboxed code triggers a host-side syntax error whose stack trace reaches it unredacted, revealing absolute host filesystem paths.
- vm2 sandbox escape to host RCE via revisited host-wrapped AggregateError bypassing Error sanitization cycle short-circuit A host-wrapped AggregateError revisited during one traversal escapes error sanitisation, so sandboxed code receives a live host object and runs commands on the host.
- vm2 sandbox escape on Node.js 26 through a stale PromiseThenLookupChain protector On Node.js 26, a stale V8 protector lets a Promise species hook reach the host realm and expose the host process object outside the vm2 sandbox.
- vm2 crypto builtin loads attacker native code through setEngine Exposing the host crypto builtin to vm2 lets sandboxed code call setEngine to load an attacker's native library into the host process.
- vm2: vm.freeze()/vm.readonly() bypass via accessor descriptor Sandboxed code reads a host accessor's setter via property descriptors and calls it directly, mutating an object the host had frozen as read-only.
- vm2: GHSA-m283-3h24-438v fix bypass leads to host RCE via call/apply indirection Calling Promise rejection handlers through call or apply indirection skips the sanitiser, letting a host error carrying a host object reach the sandbox and run commands.
- vm2: NodeVM builtin denylist bypass via fs/promises despite -fs, allowing host filesystem writes A wildcard builtin policy with a negative entry for fs still exposes fs/promises, letting sandboxed code write files on the host.
- vm2 allows a sandboxed plugin to execute native code through `node:sqlite` A sandboxed plugin can open an in-memory SQLite database, enable extension loading, and load a bundled native library into the Node host process.
- vm2: External module allowlist uses a raw prefix test, so a prefix-sharing sibling package is treated as allowlisted A string-prefix check treats a sibling package whose name starts with an allowlisted name as part of it, so sandboxed code can require it.
- vm2: NodeVM node:-prefixed negative builtin deny bypass exposes child_process A deny entry written with the node: prefix fails to block the bare module name, so sandboxed code can load child_process and run commands.
- vm2: NodeVM nesting guard accepts array-shaped require and permits host RCE An array passed as the require option slips past the nesting guard, leaving only the vm2 loader, which sandboxed code uses to build an unrestricted inner VM.
- vm2 NodeVM can replace the host process TLS trust store Sandboxed NodeVM code reaches the host tls module through an allowed builtin and replaces the default CA list, affecting host TLS clients.
- vm2 Custom Module Resolver Can Bypass the External Package Allowlist by Loading a Colliding Host Package The sandbox allowlist uses substring matching, so a package whose name merely contains an allowed name is loaded from the host and escapes the module restriction.
- vm2 exposes host HTTPS credentials and TLS traffic through globalAgent A sandboxed script reaches the host's shared HTTPS agent, reads host request tokens and TLS traffic, and uses them against a private service.
- vm2: Incomplete nodejs.* symbol filtering lets sandbox override host WebStream state checks The symbol filter in vm2 uses a fixed list, so sandboxed code can obtain Node.js stream symbols from host prototypes and change host object state.
- vm2 CLI provides no sandbox isolation - host-realm require() is reachable from sandboxed scripts The CLI runs scripts with external require enabled, so a script can require itself in the host realm and reach fs and child_process.
- vm2: NodeVM builtin allowlist bypass via node:test.run() execArgv allows sandbox escape Sandboxed code reaches the host node:test module through a scheme-prefixed require and starts an unsandboxed process using execArgv eval.
- vm2: Sandbox Breakout Using Dangerous Host Proto Mutators Calling a blocked host mutator through an indirect call form evades a prior fix, letting sandboxed code reach host objects and run commands.
- vm2's bufferAllocLimit cap bypassed by Buffer.concat and Buffer.from arrayLike Sandboxed code can allocate unlimited host memory through Buffer.concat and array-like Buffer.from, skipping the configured allocation cap.
- VM2 has Missing Error.cause Sanitization that Enables Sandbox Escape to RCE Host error objects keep a cause property that the sandbox sanitizer never cleans, so sandboxed code can reach host objects like process and run commands.
- vm2: NodeVM `builtin: ['*']` exposes `os` and `dns` — process-wide observability reads AND writes that hijack the host (sibling class of GHSA-9g8x-92q2-p28f) Enabling all builtins in the NodeVM sandbox exposes the os and dns modules, letting sandboxed code read host details and change process-wide DNS servers.
- vm2 has Memory Exhaustion DoS via bufferAllocLimit Bypass Allocating memory through ArrayBuffer and typed arrays skips the Buffer size cap added by an earlier fix, letting sandboxed code exhaust host memory.
- vm2 sandbox escape via JSPI-backed Promise `.finally()` species bypass A JavaScript sandbox escape where a host-originated rejection from a WebAssembly promising path reaches host constructors through Promise finally species logic.
- vm2 is Vulnerable to Sandbox Breakout Through Promise Species A custom Promise subclass's species getter supplies a crafted rejection handler, leaking a raw host error object that gives access to the host process.
- NodeVM observability builtins leak host process and HTTP request data Sandboxed NodeVM code can load non-denylisted Node observability modules and read host HTTP request data and async context.
- vm2's Bridge Proxy set trap ignores receiver parameter, enabling host object property injection via prototype chain Setting a property through an inheriting object writes to the host target instead of the receiver, letting sandboxed code modify host objects.
- vm2 has a CVE-2023-37903 patch bypass: nesting:true without explicit require still allows full RCE Omitting the require option makes the nesting guard's strict comparison fail, so an inner sandbox gets the disallowed configuration and can spawn processes.
- vm2 has a sandbox escape via unblocked cross-realm Symbol.for keys + missing bridge write-trap symbol checks Sandboxed code obtains real Node.js internal symbols that the Symbol.for override fails to block, then writes them to host objects to control host behaviour.
- vm2 setup-sandbox.js violates Defense Invariant #11 in stack-trace formatter The host stack-trace formatter appends to an array in a way that calls sandbox-installed index setters, letting sandboxed code intercept bridge-internal values.
- NodeVM network builtin exclusions bypass via internal _http_client and _http_server Excluding public network modules from a Node VM leaves underscored internal HTTP builtins reachable, letting sandboxed code send requests and open listeners.
- NodeVM builtin denylist bypass via process and inspector/promises allows host code execution Sandboxed code loads process or inspector/promises, which were missing from the builtin denylist, to reach child_process or host-side evaluation.
- vm2 has a Sandbox Escape issue Combining Buffer prototype accessors with a Node error object lets sandboxed code reach the host's Function constructor and run commands outside the VM.
- vm2 Has a Sandbox Breakout Using Async Generator Exceptions thrown from a host object's then method inside an async generator's yield* are delivered back into the sandbox, letting code reach host constructors and run commands.
- vm2 has access to `VM2_INTERNAL_STATE_DO_NOT_USE_OR_PROGRAM_WILL_FAIL` Sandbox code can read a protected internal state variable through the global object, because an earlier fix left that access path open.
- vm2 has sandbox breakout via `neutralizeArraySpeciesBatch` Newly added internal code exposes host-side objects to sandboxed scripts through array prototype accessors, letting them reach the host Function and run commands.
- vm2 has Sandbox Breakout Through Null Proto Exception A null-prototype object thrown and caught inside the vm2 sandbox is proxied unsafely, letting attacker code reach the host Function constructor.
- vm2 Access to Host Object Enables Sandbox Escape An incomplete earlier fix still exposes the host Object through symbols, letting sandboxed code reach the host realm and run child processes.