Browse / AI Framework and Platform Flaws
AI Framework and Platform Flaws
Classic software bugs in the libraries and platforms that run AI: memory corruption, traversal, SSRF, auth. 1,532 records. Reference: CWE.
- Denial of service 377
- Authentication and access control 256
- Path traversal and file access 192
- Memory corruption 159
- Code and command execution 133
- Server-side request forgery 103
- Information exposure 78
- Sandbox escape 76
- Cross-site scripting 68
- Other weaknesses 46
- SQL and query injection 22
- Cross-site request forgery 8
- Unsafe deserialisation 8
- Data exfiltration 6
- Docling: `enable_local_fetch` is not enforced in HTML browser-rendering mode In browser render mode a crafted HTML page embeds local file URLs that were allowed unconditionally, so local file contents appear in the rendered page image.
- Langflow: SSRF in URL-taking components (protection disabled by default / warn-only, not applied to RSS, SearXNG, Web Search, Home Assistant, Glean, Docling) Flow components fetch author-supplied URLs without enforcing the private-address guard, so the server can reach internal endpoints and return responses.
- vLLM: Mirrored multimodal IPC caches desync after a rejected request — a later request reusing the same media hash trips a receiver assertion in the engine core A rejected request leaves the frontend cache believing media is stored in the engine, so a later request reusing that media hash triggers a fatal assertion.
- Docling: Arbitrary local file read via draw:image xlink:href in the OpenDocument backend A crafted ODF file makes the backend read an absolute path named in an image reference, embedding the file contents in the converted output.
- Langflow: Unauthenticated Flow Execution via Webhook Authentication Bypass When a config flag is off, webhook calls skip API key checks, so anyone who knows a flow UUID can run that flow as its owner.
- Langflow: Weak Fernet Key via random.seed() Seeding Python's non-cryptographic random generator with short secrets makes the Fernet key derivable, so stored credentials can be decrypted offline.
- 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.
- vLLM: Flash late-interaction scoring caches query embeddings under a caller-controlled request id — cross-request integrity break and induced errors on `/score` and `/rerank` A caller-chosen request ID lets a second request overwrite the cached query embedding, so documents are scored against the attacker's query.
- vLLM: Structured-output request errors escape the request boundary and terminate the shared EngineCore — engine-fatal denial of service (3 sites) Malformed structured-output requests raise an uncaught error in the engine loop, which kills the shared engine and blocks all other requests.
- vLLM: Scale-out disaggregated multimodal transport trusts caller-supplied features The generate endpoint accepts internal multimodal fields from callers as if they came from the trusted renderer, so forged values can crash the shared engine process.
- 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.
- LiteLLM: Authenticated SSRF and provider-credential exfiltration via unvalidated request-body routing parameters A denylist on request-body routing fields misses nested or uncovered parameters, letting an authenticated user redirect provider calls and receive the proxy's stored credentials.
- khoj has an unauthenticated path traversal in /home/ endpoint that allows file read from server filesystem An unauthenticated request to the home static-file route uses ../ sequences in the path, which are joined to the base directory and resolve to arbitrary server files.
- Cline: Cross-Origin WebSocket Hijacking in Cline Hub Dashboard (`/browser` endpoint) A malicious website opens a cross-origin WebSocket to the local dashboard, which accepts it without an Origin check and issues commands that auto-approved tools execute.
- LiteLLM Proxy has server-side request forgery via the `user_config` request parameter Nesting an api_base inside user_config slips past a check that only inspects top-level keys, so the proxy sends requests to hosts the caller chooses.
- Open WebUI: Non-admin users can delete admin-owned external knowledge connections via knowledge base deletion Deleting a knowledge base also deletes its shared admin-owned vector connection without checking the caller's role or other dependent bases.
- Open WebUI: Any authenticated user can reach the Azure platform channel via server-side web fetch The internal-address screen treats the Azure platform channel address as public, so authenticated users can reach it through URL fetches.
- Open WebUI: Unauthenticated requests can stall the server via uncached OIDC fetches in back-channel logout An unauthenticated back-channel logout request triggers uncached, blocking OIDC discovery and key fetches on the event loop, so repeated requests stall the server.
- Open WebUI: Any authenticated user can inject chats into another user's folder via chat completions The chat-completions endpoint saves new chats into a folder named in the request without checking the caller's write permission on that folder.
- Open WebUI: Users denied by the OAuth domain allowlist or role policy can still sign in via token exchange The token exchange endpoint skips the email domain allowlist, so users removed from allowed domains still receive working sessions.
- Open WebUI: SSRF into internal services via DNS rebinding in the Playwright web loader The URL check resolves the hostname once but the Playwright browser resolves it again, so a DNS answer that changes between lookups reaches internal addresses.
- Open WebUI: Any authenticated user can start a non-terminating request via a folder parent cycle Re-parenting a folder beneath its own descendant creates a cycle, and the tree walk never tracks visited nodes, so the request never terminates.