Browse / AI Framework and Platform Flaws / Information exposure
Information exposure
78 records in AI Framework and Platform Flaws.
- Kubeflow Pipelines: Run-log endpoint permits unauthorized access to pod logs The run-log endpoint returns pod logs without authorising the caller against the run, and accepts arbitrary pod names, exposing logs from unrelated workloads.
- vLLM: Permissive default CORS origins allow cross-origin requests to the vLLM HTTP server The server defaults to a wildcard CORS origin and has no auth unless an API key is set, so any web page can read responses from a reachable instance.
- 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: 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.
- 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: 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: 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 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.
- vLLM: Cross-User Data Leak Vulnerability An integer overflow in an activation kernel's index arithmetic makes some batched requests read and return another user's inference output.
- vLLM: Unauthenticated Internal Path and Username Disclosure via Validation Error Messages Malformed API requests trigger validation errors whose text includes server file paths, line numbers and handler names, which unauthenticated callers can read.
- New API: User List API Leaks Root User Access Token Leading to Privilege Escalation The admin user list API serialises each user's access token, so an admin can read the root account's bearer token and act as root.
- Pydantic AI: Unvalidated UploadedFile references in UI adapters allow server-side file access using the application's credentials Client-supplied file references in message history skip URL validation and reach the provider, which reads them with the server's own credentials.
- LangGraph: Namespace prefix matching crosses segment boundaries in Postgres and SQLite stores Postgres and SQLite stores match flattened namespaces with LIKE prefixes, so scoped reads return items from sibling namespaces such as foo and foobar.
- Open WebUI: Tool source code disclosed to read-only users via the tool list and get endpoints Read endpoints for shared tools return the full Python source to non-writer users, exposing any credentials or internal URLs embedded in the code.
- Flowise: RBAC Bypass Leading to Unauthorized Workspace Variables Disclosure A user denied variables view permission can run custom JavaScript that receives all workspace variables, including server environment values, because $vars is injected unconditionally.
- Flowise: Unauthenticated OAuth2 token refresh endpoint returns access tokens — enables token theft for any connected service An unauthenticated route returns freshly refreshed OAuth access tokens, so anyone holding a credential ID can take them and use the victim's connected services.
- Flowise: Incomplete Credential Redaction Exposes Secrets via API The credential endpoint redacts only password-typed fields, so secrets stored in string fields such as URLs and keys are returned in plaintext.
- Open WebUI: Cross-user model-list exposure via static cache key in get_all_models (aiocache key= vs key_builder= misuse) A misused cache key stores per-user permission-filtered model lists under one shared key, so a different user can receive them within the TTL.
- Open WebUI: Private channel messages can be disclosed through cross-channel thread parent_id binding A low-privilege user requests a thread in an accessible channel and supplies a message id from a private channel as the root, so the parent message is returned without a channel membership check.
- Open WebUI: Account enumeration via observable login timing discrepancy Login responses are slower for registered emails because password hashing runs only for existing accounts, revealing which addresses are registered.
- n8n: External Secrets Accessible via Workflow Expressions Outside Credentials Workflow node expressions resolve external secrets, letting project editors read their plaintext values without holding secrets permissions.
- n8n: External Secrets Permission Bypass via Expression Parser Mismatch Expression parsing misses some secret-reference forms, so a user can embed secrets they lack permission to read into credentials.
- @anthropic-ai/claude-code has an Insecure Temporary File in /copy Command that Enables Response Disclosure and Symlink-Based File Write The copy command writes responses to a predictable, world-readable temp path, so local users can read them or redirect the write through a planted symlink.
- BerriAI litellm: UI User Enumeration leads to System-Wide Information Disclosure A user listing endpoint returns all accounts without proper authorization, and an earlier incomplete fix left it exposed.
- Open WebUI: Any authenticated user can read other users' private notes via Socket.IO A Socket.IO join handler skips its ownership check when a note's document ID uses an underscore instead of a colon, and the storage layer maps both forms to the same document.
- Open WebUI: Cross-user file disclosure via /api/chat/completions image_url field An authenticated user passes another user's file ID as an image URL, and the server reads that file without an ownership check and sends its contents to the model.
- vLLM: GGUF dequantize kernel int truncation exposes uninitialized GPU memory in multi-tenant serving Integer truncation in GGUF dequantization leaves part of a newly allocated GPU buffer unwritten, exposing residual memory from earlier requests.
- vLLM: incomplete CVE-2026-22778 fix leaks PIL repr addresses via Anthropic router Malformed image bytes make the Anthropic-compatible router echo an unsanitised exception containing a heap address, because a later endpoint skipped the earlier fix.
- n8n: Merge Node SQL Mode Prototype Pollution A workflow author pollutes a cached sandbox prototype used by the Merge node SQL mode, and the polluted state carries over to other users' later executions, exposing their data.
- 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.
- 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.
- 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.
- 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.
- 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.
- Claude SDK for TypeScript has Insecure Default File Permissions in Local Filesystem Memory Tool The local filesystem memory tool creates agent memory files with permissive default modes, so other local users can read them and in containers may modify them.
- n8n has Public API Variables IDOR that Allows Cross-Project Secret Disclosure An API key scoped to variable listing passes an arbitrary project id, and the handler returns variables without checking project membership.
- Langflow: Cleartext Storage of Authentication Settings in Project Creation Endpoint The project creation endpoint stores authentication settings in cleartext on disk instead of encrypting them.
- Flowise: Unauthenticated Information Disclosure of OAuth Secrets (Cleartext) via GET Request An unauthenticated endpoint returns an organisation's SSO provider configuration, including client secrets in plain JSON, to any caller.
- Flowise: Password Reset Link Sent Over Unsecured HTTP Password reset emails contain plain HTTP links, so a network attacker on the path can capture the token and take over accounts.
- LangChain has incomplete f-string validation in prompt templates Template validation misses attribute access and nested format-spec fields, so attacker-supplied f-string templates can evaluate expressions that expose object attributes during formatting.
- PraisonAI Has Unauthenticated SSE Event Stream that Exposes All Agent Activity in A2U Server Agent event streaming endpoints have no authentication, so anyone can open a subscription and receive live responses, reasoning and tool call arguments.
- Open WebUI has Broken Access Control in Tool Valves A regular member reads tool valve configuration, including third-party API keys, through an endpoint that does not restrict read access to admin-only values.
- Open WebUI vulnerable to Path Traversal in `POST /api/v1/audio/transcriptions` A crafted multipart filename makes the extension include slashes, so the write fails and the error response leaks the server's absolute data directory path.
- n8n's Source Control SSH Configuration Uses StrictHostKeyChecking=no Source control SSH disables host key verification, which lets a network attacker impersonate the Git server and intercept repository data.
- n8n has In-Process Memory Disclosure in its Task Runner An authenticated user can allocate uninitialised buffers in the task runner, exposing leftover in-process memory such as tokens and secrets.
- Flowise Vulnerable to PII Disclosure on Unauthenticated Forgot Password Endpoint The forgot-password endpoint returns the full user record, including email and identifiers, to unauthenticated callers, which reveals whether accounts exist.
- Flowise has Insufficient Password Salt Rounds A default bcrypt cost of 5 makes stored password hashes cheap to brute-force if the database is leaked.
- n8n's Unsafe Buffer Allocation Allows In-Process Memory Disclosure in Task Runner Untrusted task runner code can call unsafe buffer allocation and receive uninitialized memory that may hold residual data from the same process.
- LangChain Vulnerable to Template Injection via Attribute Access in Prompt Templates Untrusted template strings let attackers traverse object attributes and dictionary keys in prompt templates, reaching secrets such as environment variables.
- Agno session state overwrites between different sessions/users A race condition under concurrent load can save one session's state into another session, exposing a user's data to a different user.