Browse / AI Framework and Platform Flaws / Sandbox escape
Sandbox escape
76 records in AI Framework and Platform Flaws.
- Flowise NodeVM sandbox escape via puppeteer allowlist - authenticated RCE and arbitrary file read via Chromium An authenticated user passes executable path and args to puppeteer.launch from the sandboxed custom function, spawning host commands outside the sandbox.
- 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: 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 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 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 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: 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.
- n8n: Expression Sandbox Escape via Shared Builtin Tampering and Code-Printer Injection Leads to Code Execution Replacing the global JSON.stringify changes the source generated by the legacy expression engine at runtime, so a crafted expression escapes the sandbox and executes code.
- 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 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.
- Flowise: RCE via NodeVM Sandbox Escape in executeJavaScriptCode() nodeVMOptions Override Caller-supplied VM options spread over secure defaults re-enable blocked built-in modules, letting an authenticated user escape the sandbox and run system commands.
- Flowise Sandbox Escape to RCE A JavaScript escape from the Flowise custom function sandbox lets user code reach the host process and run arbitrary commands.
- n8n: Expression sandbox escape via arrow-function bodies enabling command execution Crafted arrow-function bodies inside n8n expressions escape the expression sandbox and reach host system commands.
- n8n: Python sandbox escape Authenticated users with workflow edit rights can break out of the Python code node sandbox and run commands in the task runner container.
- n8n: Python Code Node AST Validator Bypass An authenticated user can bypass the AST check on Python code nodes to reach the task executor namespace and read environment variables.
- 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.
- 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 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.
- LiteLLM has a sandbox escape in custom-code guardrail Bytecode-level techniques break out of the hand-rolled Python sandbox behind the custom guardrail test endpoint, running code in the proxy process.
- 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.
- 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 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.