Products / vm2
vm2
78 records.
- vm2 contains a sandbox escape vulnerability
- 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
- 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
- vm2: Sandboxed code can read and write host-realm memory via Node's shared Buffer pool
- vm2: Host-returned Promise rejection can bypass vm2's unhandled-rejection hardening and terminate the host process
- vm2: NodeVM `require.external` without an explicit `require.root` grants unrestricted host filesystem access and full RCE
- vm2: util.getCallSites() bypasses GHSA-v27g-jcqj-v8rw host-frame redaction, leaks host call stack
- vm2: timeout Option Bypass via FinalizationRegistry Cleanup Callback (Unbounded Host Event-Loop Block)
- vm2 sandbox escape via WebAssembly.compileStreaming Promise species bypass
- vm2 leaks absolute host filesystem paths to sandbox code via error stack formatting
- vm2 sandbox escape to host RCE via revisited host-wrapped AggregateError bypassing Error sanitization cycle short-circuit
- 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
- vm2: Incomplete nodejs.* symbol filtering lets sandbox override host WebStream state checks
- vm2 CLI provides no sandbox isolation - host-realm require() is reachable from sandboxed scripts
- vm2: NodeVM builtin allowlist bypass via node:test.run() execArgv allows sandbox escape
- 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
- VM2 has Missing Error.cause Sanitization that Enables Sandbox Escape to RCE
- vm2: NodeVM `builtin: ['*']` exposes `os` and `dns` — process-wide observability reads AND writes that hijack the host (sibling class of GHSA-9g8x-92q2-p28f)
- vm2 has Memory Exhaustion DoS via bufferAllocLimit Bypass
- 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
- vm2 has a sandbox escape via unblocked cross-realm Symbol.for keys + missing bridge write-trap symbol checks
- vm2 setup-sandbox.js violates Defense Invariant #11 in stack-trace formatter
- NodeVM network builtin exclusions bypass via internal _http_client and _http_server
- NodeVM builtin denylist bypass via process and inspector/promises allows host code execution
- vm2 has a Sandbox Escape issue
- 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.