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,542 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
- Real-world incidents 10
- Cross-site request forgery 8
- Unsafe deserialisation 8
- Data exfiltration 6
- MLflow Has a Server-Side Request Forgery (SSRF) Vulnerability MLflow's webhook creation accepts an arbitrary URL that the backend then posts to, letting an authenticated user reach internal services and metadata endpoints.
- Open WebUI has a CORS misconfiguration and session validation issue Permissive cross-origin rules and weak session validation let a malicious page take a logged-in admin's session and reach remote code execution with one click.
- Open WebUI has inconsistent authorization controls within memories API Memory endpoints do not consistently enforce ownership, letting any user query, view, delete and restore memories that belong to other users.
- Open WebUI Arbitrary File Write, Delete via Path Traversal Uploaded filenames containing dot-segments are not sanitised, so attackers can write files to arbitrary locations and then have them deleted.
- Open WebUI's Improper Authorization in Standard Channels Allows Message Updates with Read Permission Message update in standard channels checks only read permission, so any user with read access can edit messages written by other users.
- Open WebUI's Insecure Message Access Breaks Authorization Channel message update and delete endpoints check channel access but not message ownership, letting users change other users' messages by calling the API directly.
- PraisonAI ships and generates a legacy API server with authentication disabled by default, allowing unauthenticated workflow execution The legacy server ships with authentication disabled, so anyone who can reach it can trigger the configured agent workflow without a token.
- PraisonAI's symlink-extraction bypass of `_safe_extractall` writes outside `dest_dir` A tar member symlink points outside the destination and later members write through it, escaping the extraction directory.
- Open WebUI has an LDAP Empty Password Authentication Bypass An LDAP login with an empty password succeeds on servers that accept unauthenticated simple bind, issuing a session for the target user.
- Open WebUI: Redis Cache Keys tool_servers and terminal_servers Missing Instance Prefix Enable Cross-Instance Cache Poisoning Redis keys for tool and terminal server configuration lack an instance prefix, so separate deployments sharing Redis overwrite each other's config.
- Open WebUI: Stale Admin Role in Socket.IO Session Pool Enables Post-Demotion Cross-User Note Access Socket.IO sessions keep the admin role captured at connect time, so a demoted user can still join and save restricted collaborative documents.
- Open WebUI has Improper Authorization Control Users pending approval can call the API directly because the role check exists only in the client interface, not on the server.
- Open WebUI's Channel Access Grants Bypass filter_allowed_access_grants Channel create and update endpoints store access grants without the permission filter other resources apply, so users can set public wildcard grants.
- Open WebUI Vulnerable to Arbitrary File Upload and Path Traversal Uploaded attachment filenames with dot-segments are not sanitised, letting an uploader write files to arbitrary locations on the server.
- Open WebUI's Base Model Routing Bypasses Access Control via Model Chaining Composed models can point base_model_id at a restricted model, and the chained base model's access is never checked at request time or creation.
- Open WebUI Missing Access Check on Channel Members Endpoint for Standard Channels The channel member listing skips the access check for standard channels, letting any logged-in user enumerate members of a private channel given its ID.
- Open WebUI has Stored XSS in Pending User Overlay via Incorrect DOMPurify Application Order Running the sanitiser before Markdown parsing lets javascript: links created during parsing reach the page unfiltered, enabling stored script execution.
- open-webui Vulnerable to Stored XSS via Model Description A javascript: link in a model description survives sanitisation, becomes an anchor only after sanitising, and then runs when other users view the model.
- Open WebUI: Deactivated Channel Members Retain Full Access to Group/DM Channels The channel membership check does not look at the active flag, so users removed from a group or DM channel can still read and post via direct API calls.
- Open WebUI's responses passthrough endpoint lacks access control authorization The responses proxy only checks that a user is logged in, not per-model access rules, so any authenticated user can call models that were restricted to others.
- Open WebUI's Mass Assignment via Pydantic extra='allow' Allows Creating Folders in Other Users' Accounts Folder creation copies client-supplied fields over the server-assigned owner, letting a user set another account as the folder owner.
- Open WebUI has stored XSS in Excel file preview A crafted spreadsheet's HTML preview is inserted into the page without sanitising, so embedded script runs when the user opens the preview.
- Open WebUI's Model Import Overwrites Any Model Without Ownership Check The model import route overwrites existing models by ID without any ownership or access grant check, so a permitted user can replace models they do not own.
- Open WebUI's Ollama Model Access Control Bypass via /api/generate, /api/embed, /api/embeddings, and /api/show Ollama proxy routes forward any model name after only a login check, skipping the model access grant enforced on the chat route.
- Read-Only Open WebUI Users Can Modify Collaborative Documents via Socket.IO The Socket.IO update handler checks only room membership, not write permission, so read-only collaborators can change the live shared document.
- Cline Kanban Server has a Cross-Origin WebSocket Hijacking Vulnerability Local WebSocket endpoints skip Origin validation, so any visited website can read agent data and inject input into running agent terminals.
- 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.
- BentoML has Information Disclosure in `bentoml build` via symlink traversal in the build context A symlink in an untrusted build context makes bentoml build copy the linked file's contents from outside the project into the artifact.
- 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 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 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 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's Transformer Fast-Path Bypass Exposes Internal State Variable A regex fast path skips AST checks for code without certain keywords, letting sandboxed code reach an internal state object with privileged functions.
- QuantumNous/new-api has an SSRF Filter Bypass via 0.0.0.0 Using 0.0.0.0 as the host in multimodal image URLs slips past new-api's private IP filter, so the server fetches localhost.
- PraisonAI has an SSRF bypass The URL validator checks the host that urlparse extracts, but requests connects to a different host for crafted backslash and at-sign URLs, reaching internal addresses.
- vLLM: extract_hidden_states speculative decoding crashes server on any request with penalty parameters A speculative decoding proposer returns a wrongly shaped tensor after the first step, so any request with penalty settings crashes the engine process.
- Langflow Knowledge Bases API is Vulnerable to Path Traversal Bulk delete builds knowledge base paths from user-supplied names without containment checks, letting traversal sequences delete directories outside the user folder.
- 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 Promise Species A previous sandbox fix can be undone by overwriting built-ins used in its reset logic, letting sandboxed code reach 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.
- MindsDB has an Improper Access Control Issue A missing access control in the BYOM handler's exec wrapper lets remote callers upload files to the server without restriction.