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
- Weaviate has an Improper Authorization issue A crafted static API key value passes config validation and bypasses authentication on the Weaviate API.
- milvus: RBAC grantee-id uses truncated MD5 (64-bit), enabling privilege-binding collisions and cross-role privilege forgery Milvus derives RBAC grantee identifiers from a truncated 64-bit MD5, so a local attacker can craft colliding names to inherit another role's privileges.
- GPTCache: File and image cache keys collide because BufferedReader.peek() only reads the buffered prefix Cache keys for file and image inputs use a weak hash over only the buffered prefix, so different files can collide and return each other's cached results.
- Gradio: Audio cache key ignores metadata when saving numpy audio outputs Gradio builds the audio cache key with a weak hash that ignores metadata, so colliding inputs can receive each other's cached audio.
- SGLang is Vulnerable to DoS via the data_hash Function Crafted input to the cache's data hashing routine degrades or halts the cache handler.
- Docling: Potential Path Traversal via LaTeX \includegraphics and \input Commands The LaTeX converter follows include and graphics paths without checking they stay inside the document directory, so traversal reads files outside it.
- Docling: Unsafe Zip Extraction in EasyOCR Model Download Model archive extraction does not check member paths, so a crafted zip from a compromised download source can write files anywhere the process can write.
- Docling: Unsafe XML Entity Expansion in USPTO Patent Backend A crafted USPTO patent XML with external entity references lets an attacker read server files, reach internal URLs, or exhaust resources.
- Docling: Unsafe Playwright-based HTML Rendering When browser rendering was enabled, untrusted HTML could run scripts and make internal network requests from the rendering browser.
- Docling: Unsafe URI and Path Handling in HTML Backend Crafted HTML can reference local files through file URIs or traversal sequences, and internal network addresses, because resource paths and redirects were not validated.
- Docling: Unsafe Archive Extraction and XML Parsing in METS-GBS Backend The METS-GBS backend parsed XML with external entities enabled and extracted archives without limits, allowing local file reads and resource exhaustion from crafted input.
- FoundationAgents MetaGPT: Deserialization through flawed argument mapping via Message.check_instruct_content() Manipulated argument mapping in Message.check_instruct_content leads to unsafe deserialisation of attacker-controlled data during local execution.
- MLflow: Any authenticated user can enumerate all gateway secrets, endpoints, and model definitions Any authenticated user can call three gateway list endpoints that lack authorization handlers, retrieving all gateway secrets, endpoints and model definitions.
- SGLang: Reachable Assertion via lora_path in LoRAManager enables remote Denial of Dervice A malformed lora_path value in an inference request trips an unhandled assertion in the LoRA manager, crashing the serving process.
- Aider has an SSRF vulnerability through its AWS EC2 Metadata Endpoint A documentation-fetching function requests user-supplied URLs without restriction, so it can reach the cloud instance metadata endpoint.
- COEMPT Quality Assurance Engineers Allegedly Violated Indian CBSE Student Data Privacy Rights by Processing It with Google Gemini Vulnerabilities in CBSE's OnMark exam-marking portal reportedly exposed student answer-sheet images and data, and contractor scripts sent personal information to Google Gemini.
- PraisonAI spider_tools SSRF protection bypass via alternate loopback host encodings Alternate spellings of loopback hosts such as 127.1 or 0x7f000001 pass the exact-match blocklist, letting a crawler tool reach loopback-only services.
- PraisonAI `deploy --type api` emits a Flask server with authentication disabled by default A code generator emits a Flask API server with authentication off by default, leaving agent endpoints open to any client that can reach it.
- PraisonAI call server exposes unauthenticated agent listing, invocation, and deletion when CALL_SERVER_TOKEN is unset When the token variable is unset, the auth dependency returns success, leaving agent list, invoke and delete endpoints open to anyone who can reach them.
- 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 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 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.
- Gradio contains a cookie injection vulnerability A proxy's shared HTTP client stores and replays a parent-domain cookie set by an attacker's Space into other users' requests.
- MLflow allows unauthorized access to multipart upload endpoints when the `--serve-artifacts` mode is enabled Multipart upload endpoints for artifacts skip per-resource permission checks, letting users overwrite other users' artifacts, which can later be loaded as poisoned models.
- vllm has Improper Resource Shutdown or Release Requests to vLLM's OpenAI-compatible serving path trigger a resource release flaw that remote attackers can use to take the server down.
- LiteLLM allows an authenticated internal_user to create API keys with access to routes that their role does not permit API keys can be issued with routes outside the creator's role, and the gateway then honours them for admin endpoints.
- LiteLLM allows a user to modify their own user_role via the /user/update endpoint The user update endpoint checks account ownership but not which fields change, so a user can set their own role to proxy admin.
- MLflow authenticated users can enumerate any registered model versions due to lack of per-model permissions checks The model version search endpoint and GraphQL field skip per-model permission checks, so any authenticated user can list all versions and metadata.
- Pydantic AI: SSRF cloud-metadata blocklist bypass via IPv4-mapped IPv6 (Incomplete fix of CVE-2026-25580) IPv6 transition encodings of cloud metadata addresses slip past the blocklist, letting fetches reach the underlying IPv4 metadata endpoint.
- Flowise: Mass Assignment in PUT /api/v1/user Allows Authenticated Users to Override Password Hash and Bypass Password Change Verification The user update endpoint forwards the whole request body to the service, so a logged-in user can overwrite their stored password hash and skip the old-password check.
- Flowise: Cross-Workspace Chatflow Disclosure via chatflows/apikey Endpoint Returns All Unprotected Chatflows The chatflow-by-API-key route returns every unassigned chatflow in the whole system, so a key from one workspace reads configurations from other workspaces.
- Flowise: Hardcoded CORS wildcard on TTS endpoint enables cross-origin credential abuse from any webpage A hardcoded wildcard CORS header on the TTS endpoint lets any website make cross-origin requests that use stored credentials.
- n8n: Legacy ExecuteWorkflow Node Bypassed File Path Restrictions An authenticated user submits an arbitrary file path through the REST API to a legacy node option that skips the file-access restriction, letting them probe or load server files.
- 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.
- SGLanG: Multimodal scheduler deserializes untrusted pickle data on 0.0.0.0 ROUTER socket The scheduler's socket listens on all interfaces and unpickles incoming messages, so a remote sender can execute code.
- SGLang's multimodal generation runtime has an unauthenticated path traversal vulnerability Unauthenticated upload requests with dot-dot segments in the filename let callers write files to arbitrary locations the server process can reach.
- MLflow: unauthenticated access to certain FastAPI routes Authentication is enforced only on gateway paths, so unauthenticated requests reach job and trace ingestion FastAPI routes under uvicorn.
- Open WebUI Vulnerable to SSRF via OAuth Profile Picture URL in _process_picture_url (oauth.py) The OAuth profile picture fetch requests attacker-supplied URLs without validation, letting the server reach internal resources and return their contents.
- Open WebUI: shared-chat branch ignores access_type, allowing unauthorized file deletion The file access check grants access to any file referenced by any shared chat without checking the requesting user or the operation, so any user can delete others' files.
- Open WebUI has XSS via SVG in /api/v1/channels/webhooks/{webhook_id}/profile/image A webhook profile image URL accepts an SVG data URI that is served unsanitised as image/svg+xml, so embedded script handlers run in the app origin.
- Open WebUI vulnerable to stored XSS via OAuth picture claim stored as SVG data URI in profile_image_url The OAuth login path stores a remote picture as an SVG data URI that skips the image validator and is served inline, so its script runs on the app origin.
- Open WebUI: Jupyter code execution works despite `ENABLE_CODE_EXECUTION=false` — feature gate bypassed The Open WebUI code execution endpoint forwards Python to Jupyter without checking the ENABLE_CODE_EXECUTION setting, so any verified user can run code.
- Open WebUI Vulnerable to IDOR: Retrieval API Bypasses Knowledge Base Access Controls The collection access check skips knowledge base UUIDs, so any logged-in user who knows one can read or write that private knowledge base through retrieval endpoints.