Bypasses / Sandbox or allowlist
Sandbox or allowlist
139 cases that got past this protection.
- AG2: Newline injection in SandboxShellTool bypasses allowed=[...] and readonly=True, enabling arbitrary command execution An embedded newline lets a command pass the allowlist and read-only checks, because the shell runs the second line as a separate command.
- PraisonAI vulnerable to Remote Code Execution via Broken AST Sandbox An inline Python step in a YAML workflow passes the AST and module checks, letting it import os and run shell commands.
- MLflow: SSRF on unauthenticated MLflow servers via third-party scorer kwargs in the scorer invoke, register, and GenAI evaluate endpoints An unauthenticated endpoint instantiates a class named in JSON whose module allowlist does not constrain the class or its arguments, forcing outbound requests to attacker-chosen hosts.
- PraisonAI: SecurityPolicy command/path/import restrictions are completely unenforced by the default SubprocessSandbox backend The default subprocess sandbox ignores configured command, path and import restrictions, so model-driven code runs commands and reads protected files as root.
- PraisonAI: Shell command allowlist bypass via find -exec built-in action The find command is allowlisted, and its -exec action runs arbitrary programs without shell metacharacters, bypassing the command filter.
- PraisonAI: CodeAgent Executes LLM-Generated Code Without Sandboxing and Leaks All Environment Secrets An agent runs model-generated Python in a subprocess with the full environment and no validation, so injected instructions can run code and read secrets even when sandboxing is enabled.
- PraisonAI: Unsafe Dynamic Module Loading Leads to Arbitrary Code Execution via tools.py in AgentFlow A workflow directory containing a malicious tools.py is imported and executed without sandboxing when a step resolves a structured output type, ignoring the tool allow setting.
- Docling imports plugin entry points before the allow_external_plugins check Docling imports every installed plugin module before applying the external-plugin restriction, so third-party import-time code runs even when external plugins are disabled.
- 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.
- Langflow: PythonREPLComponent executes unsandboxed Python code, enabling authenticated RCE and privilege escalation The Python interpreter components run user or model code in-process without effective sandboxing, so builtins give attackers full host and privilege access.
- Langflow: Title Authenticated Remote Code Execution in validate_code via Malicious Decorators Description The code validator executes function definitions, but attacker-supplied decorators run at definition time, giving any logged-in user code execution.
- 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: 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: 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 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.
- MCP Atlassian: JIRA_PROJECTS_FILTER / CONFLUENCE_SPACES_FILTER allow forbidden-project content exfiltration (one LIVE-proven on Atlassian Cloud) Substring matching on JQL and CQL project filters lets crafted queries, including those from prompt-injected agents, read content from projects outside the allowlist.
- Open WebUI: Same-origin XSS to account takeover via terminal port-preview iframe hardcoding allow-same-origin A terminal port preview iframe keeps same-origin access, so script served from a previewed port runs in the app origin and steals sessions.
- 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.
- n8n: Expression Sandbox Escape via Class-Field Sanitizer Rebinding Can Lead to Code Execution A class field named __sanitize rebinds the expression sanitizer's this, reaching the Function constructor and running arbitrary JavaScript in n8n.
- Chainlit has command injection via MCP stdio transport that allows unauthenticated remote code execution The MCP stdio allowlist checks only the executable name, so an allowed launcher like npx can run arbitrary shell commands through its arguments.
- 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.
- Open WebUI: Same-origin XSS to account takeover via terminal file-preview iframe hardcoding allow-same-origin Terminal-served HTML previews run in an iframe that grants same-origin access, so scripts in the file run in the app origin and can read the session token.
- 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: CSV Agent Prompt Injection Remote Code Execution Vulnerability A prompt sent to a CSV agent chatflow makes the model emit Python that evades the blocklist and runs in the server's Pyodide-based sandbox.
- Flowise: CSV Agent Remote Code Execution via Pyodide Code Injection — Root Shell Verified Unsanitised CSV agent input is inserted into Python code run in Pyodide, and the JS bridge lets that code reach the host Node process to run OS 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.
- Natural Language Toolkit (NLTK): Path Traversal in NKJPCorpusReader leads to Arbitrary File Read and bypasses the nltk.pathsec sandbox (ENFORCE=True) The corpus reader joins attacker-supplied file IDs to the root without containment checks, reading files outside the corpus while skipping the library's path validation.
- Claude Code: Sandbox Escape via Git Worktree Path Confusion Allows Unsandboxed Code Execution A malicious repository's worktree layout and symlinks let git's fsmonitor hook run outside the sandbox and overwrite a shell startup file in the home directory.
- LiteLLM: Custom Code Guardrails production endpoints bypass code safety checks Production create and update routes for custom guardrail code skip the sandbox used by the test endpoint, so submitted Python runs inside the proxy.
- n8n: Bypass "Allowed HTTP Request Domains" Credential Restriction in Multiple AI and LLM Nodes A workflow editor with use-only access to a shared AI credential points an LLM node at an attacker host, causing the credential secret to be sent there.