Bypasses / Sandbox or allowlist
Sandbox or allowlist
139 cases that got past this protection.
- n8n: computer-use Shell Sandbox Not Enforced on Linux and Windows The shell tool's sandbox was only applied on macOS, so on Linux and Windows commands ran with unrestricted host filesystem and network access.
- n8n: GraphQL Node Bypasses "Allowed HTTP Request Domains" Restriction The GraphQL node skips the allowed-domains restriction for HTTP credentials, so a workflow author can send stored credentials to an attacker-controlled host.
- 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: "Allowed HTTP Request Domains" Restriction Bypass via AI Agents MCP Connector The agent's MCP tool path ignores the allowed-domain restriction on shared credentials, so a member can send a secret to an attacker-chosen URL.
- n8n: Prototype Pollution via VM Expression Engine Sandbox Escape Leads to Denial of Service An authenticated user's expression escapes the VM engine through array access, reaches a host built-in and pollutes its prototype, causing denial of service in the main process.
- Open WebUI vulnerable to Stored XSS via iFrame embeds in response messages Editing chat history to add arbitrary embeds causes them to render in an iframe with script and same-origin access, so the payload runs in shared chats.
- Open WebUI vulnerable to Stored XSS via iFrame in citations model A manually edited chat history sets an html field on citation metadata, making the preview iframe render attacker HTML with scripts and same-origin access.
- PraisonAI SandlockSandbox falls back to unrestricted subprocess execution when Landlock is unavailable When Landlock is unavailable, the sandbox silently runs submitted code through an unrestricted subprocess, ignoring file and network limits.
- PraisonAI: execute_code sandbox bypass: str.format C-level attribute access reads every blocklisted dunder Runtime-assembled dunder names and str.format attribute lookups bypass the execute_code AST and builtins restrictions, giving reads of blocked attributes and escape from the sandbox.
- vLLM: Security Check Bypass via assert Statement in Activation Function Loading Allows Arbitrary Code Execution The only check on which activation function a model config may load is an assert, which Python strips in optimised mode, so a malicious config runs arbitrary code.
- 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.
- n8n: SecurityScorecard Node Leaks API Token to User-Controlled Host A workflow author points the SecurityScorecard report download at an attacker host, and the node sends the stored API token there despite the configured domain limits.
- n8n: Same-Origin XSS in Respond to Webhook Node A binary response path serves attacker-chosen content types without the sandbox header, so a public webhook runs scripts in the application origin.
- PraisonAI vulnerable to sandbox escape via `print.__self__` builtins module leak in `execute_code` (subprocess mode) The AST filter for agent Python execution misses an attribute on built-in functions, letting code reach the builtins module and run OS commands.
- 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 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.
- n8n: Credential exfiltration via Allowed HTTP Request Domains Bypass An authenticated user makes the dynamic options endpoint send HTTP requests to hosts outside the credential's allowed domains, carrying the credential along.
- Open WebUI has stored XSS via the HTML renedering view Model-generated HTML is rendered in an iframe whose sandbox permits scripts and same-origin access, so injected script can read the session token.
- FlowiseAI: Authenticated Host RCE via POST /api/v1/node-custom-function and NodeVM Sandbox Escape A signed-in user posts JavaScript to a custom function endpoint with no route permission check, then escapes the NodeVM sandbox to reach host child_process.
- 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 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 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 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 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.
- n8n has a Python Task Runner Sandbox Escape Vulnerability An authenticated workflow author can break out of the Python task runner sandbox used by a Code node and run commands on the runner container.
- Gemini CLI: Remote Code Execution via workspace trust and tool allowlisting bypasses Headless Gemini CLI auto-trusted untrusted workspace folders, so malicious local .gemini settings could supply environment variables that lead to command execution, and tool allowlisting could be bypassed.
- Claude Code: Sandbox Escape via Symlink Following Allows Arbitrary File Write Outside Workspace A sandboxed process creates symlinks to outside locations and the unsandboxed process later writes through them, with untrusted content in context able to trigger this.
- PraisonAI Vulnerable to Code Injection and Protection Mechanism Failure Calling type.__getattribute__ with string attribute names evades the AST filter that blocks dangerous dunder attributes, letting agent-run code escape the sandbox.
- PraisonAI has sandbox escape via exception frame traversal in `execute_code` (subprocess mode) The subprocess sandbox's AST blocklist omits frame-traversal attributes, so code run through the agent's execute tool can reach builtins and call exec.
- PraisonAI Has Sandbox Escape via shell=True and Bypassable Blocklist in SubprocessSandbox Sandbox commands run in shell mode with a string blocklist that omits sh and bash, so wrapping a command in sh -c escapes STRICT restrictions.