Bypasses / Input filter or sanitiser
Input filter or sanitiser
59 cases that got past this protection.
- vLLM: Out-of-vocabulary prompt token id passes input validation and triggers a CUDA device-side assert (engine crash / DoS) A pre-tokenized prompt with an id one past the embedding range passes input validation and crashes the inference engine's CUDA context.
- LiteLLM: internal_user_viewer arbitrary local file read via `vertex_ai_credentials` An authenticated viewer sends an alias of a credentials field that the request blocklist misses, so a local file is read and sent out.
- LangGraph: Namespace labels containing `.` reach other namespaces in Postgres and SQLite stores Namespace label validation runs only on writes, so dotted labels in reads, deletes and batches reach other namespaces' stored data.
- unstructured: Stored XSS via unescaped HTML generation Unstructured emits document-supplied HTML attributes such as event handlers and javascript: links without escaping, so scripts run in viewers' browsers.
- Flowise Prompt Injection to RCE and SSRF via CSV/Airtable Agent Python Validator Bypass Prompt-injected LLM output in CSV and Airtable agents supplies Python that evades a regex blocklist and uses pandas URL readers to send data to attacker hosts.
- n8n: Prototype Pollution via Workflow Structure Summary Can Lead to Denial of Service Posting a workflow with a reserved key such as __proto__ directly to the REST API pollutes Object.prototype, because the editor's client-side name check is skipped.
- vLLM: Incomplete CVE-2025-62164 remediation can be bypassed by concurrent prompt parts Two concurrent prompt-embedding parts race on a process-wide sparse-check flag, letting a malformed sparse tensor reach dense conversion unchecked.
- NLTK: JVM argument injection bypass via per-call options in the NLTK Stanford wrappers (incomplete fix of CVE-2026-12841) Per-call Java options skip the validator added for an earlier fix, letting callers pass agent flags that run code inside the JVM.
- 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.
- Flowise: RCE via CSVAgent csvFile data URI base64 segment is interpolated into Python source without validation Unvalidated CSV file data is spliced into Python code run by an agent sandbox, so a crafted value escapes into Node and runs commands.
- Flowise: Pyodide validator Unicode homoglyph bypass leads to RCE A regex blacklist on generated Python misses Unicode homoglyph identifiers that Python normalises to dunder names, so forbidden access to builtins runs in the sandbox.
- Flowise: Remote Code Execution Vulnerability in CSVAgent The CSV agent runs user-supplied Python through a denylist that misses pandas read_pickle, letting a pickle payload execute code.
- n8n: DOM-Based XSS via Unsandboxed iframe srcdoc in HTML Preview Execution output is rendered into an iframe without a sandbox, so a sanitizer bypass lets injected script run with the editor's session.
- n8n: Legacy Expression Evaluator Sanitizer Bypass Leads to Authenticated Code Execution An authenticated workflow editor can get past the legacy expression evaluator's member-access sanitizer and run code as the server process.
- vLLM: Speech-to-text upload size limit is enforced after full UploadFile read The speech-to-text upload handlers read the whole file before the documented size limit is checked, so oversized uploads consume memory first.
- mcp-server-kubernetes argument injection can expose Kubernetes cluster credentials Leading-dash arguments evade the dangerous-flag check in kubectl tools, letting an attacker redirect kubectl to their server and receive the bearer token.
- Open WebUI vulnerable to stored XSS via unescaped markdown token in MarkdownTokens.svelte leading to full account takeover and RCE via functions Chat messages containing an iframe-like tag pass a loose string check and are rendered as raw HTML, running attacker script in viewers' sessions.
- Keras: DiskIOStore permits path traversal through crafted layer names A crafted layer name containing parent-directory sequences escapes the temporary save directory when a model is saved or loaded, since only slashes are filtered.
- LangSmith SDK TracingMiddleware: Arbitrary server-side file read Header-supplied fields inject file attachments, and a broken type check fails to stop the tracing thread reading any server file the attacker names.
- vLLM: temperature=NaN and temperature=Infinity bypass validation and propagate to GPU kernels Temperature checks use comparisons that let NaN and positive infinity through, so these values reach GPU sampling kernels and crash the inference worker.
- 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 vulnerable to blind server side request forgery (SSRF) via the PDF generate function HTML in the PDF export title is embedded without stripping image tags, so an img tag makes the server fetch an attacker-chosen URL.
- Open WebUI has stored XSS via attacker-controlled file extension in /api/v1/audio/transcriptions A polyglot WAV/HTML file uploaded with an HTML extension is served as text/html from the cache route, so embedded scripts run in the app origin.
- Flowise has an MCP Security Bypass that Enables RCE A custom MCP server config running docker build with a remote URL slips past a flag blocklist that omits build, so a remote Dockerfile executes commands.
- Open WebUI has Stored XSS in Banner Component via Improper Sanitization Order Banner content is sanitised before Markdown conversion, so a link produced afterwards carries a javascript: URL that is rendered unescaped.
- 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.
- 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.
- H2O-3 is Vulnerable to Code Injection A parameter blocklist meant for MySQL JDBC is avoided by switching to the PostgreSQL driver, whose socket factory options run attacker-supplied code.
- Flowise: Authenticated RCE Via MCP Adapters The MCP stdio configuration accepts any command and only filters some patterns, so an allowed runner like npx can be given code-execution flags.
- Flowise: Parameter Override Bypass Remote Command Execution A substring check meant for file inputs accepts the keyword anywhere in a request, letting unauthenticated users override protected config such as NODE_OPTIONS and run commands.
- Flowise: File Upload Validation Bypass in createAttachment Adding a JavaScript MIME type to chatflow upload settings lets an attacker store a Node web shell that then runs on the server.
- PraisonAI Vulnerable to Stored XSS via Unsanitized Agent Output in HTML Rendering (nh3 Not a Required Dependency) Agent output is converted to HTML and embedded unescaped, and the optional sanitizer returns it unchanged when missing, so injected scripts run for viewers.
- 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.
- vLLM: Denial of Service via Unbounded Frame Count in video/jpeg Base64 Processing The base64 video/jpeg path splits frames without applying the frame limit, so one request with thousands of frames exhausts server memory.
- PraisonAI: Shell Injection in run_python() via Unescaped $() Substitution Code passed to a Python runner is placed inside a shell command with only backslash and quote escaping, so command substitutions run before Python starts.
- n8n has XSS in Chat Trigger Node through Custom CSS Custom CSS in the Chat Trigger node is stored after a misconfigured sanitize-html pass, allowing script to run on the public chat page.
- n8n has a Stored XSS Vulnerability in its Form Trigger A flaw in CSS sanitisation of Form Trigger nodes lets a stored payload run in every visitor's browser of the published form.
- n8n Vulnerable to LDAP Filter Injection in LDAP Node Unescaped LDAP metacharacters in user input reach the search filter of the n8n LDAP node, letting attackers alter queries and bypass workflow checks.
- Improper handling of null Unicode character when parsing JSON in github.com/modelcontextprotocol/go-sdk Trailing null characters on JSON keys are treated as equal to base names, so duplicate-key messages can override fields and evade inspection by proxies.
- JSONPath Injection in Spring AI Vector Stores FilterExpressionConverter Unescaped user values in metadata filter expressions are spliced into JSONPath queries, letting attackers alter the filter and retrieve documents they should not see.
- Flowise has Arbitrary File Upload via MIME Spoofing The unauthenticated upload endpoint trusts the client-supplied Content-Type, so attackers can store active files such as scripts by spoofing an allowed type.
- MCP Go SDK Vulnerable to Improper Handling of Case Sensitivity The Go MCP SDK accepted case-variant JSON keys, so an intermediary matching exact field names could be evaded by a malicious peer's messages.
- Vercel’s AI SDK's filetype whitelists can be bypassed when uploading files The AI SDK's file upload type allowlist can be circumvented, letting files of disallowed types be accepted.
- vLLM: Resource-Exhaustion (DoS) through Malicious Jinja Template in OpenAI-Compatible Server Malicious Jinja templates, or keyword arguments that overwrite the template key, exhaust CPU and memory during rendering, bypassing the chat_template restriction.
- H2O affected by a deserialization vulnerability JDBC connection parameter handling can be tricked past regex checks using double URL encoding, enabling file reads and code execution.
- MCP Inspector is Vulnerable to Potential Command Execution via XSS When Connecting to an Untrusted MCP Server The inspector renders a redirect URL from an untrusted MCP server without sanitising it, allowing script injection that reaches the local proxy.
- Transformers's Improper Input Validation vulnerability can be exploited through username injection A prefix-based URL check can be fooled by placing a fake YouTube host in the username part of the URL, so malicious domains pass validation.
- Open WebUI stored cross-site scripting (XSS) vulnerability The model description set through the add model endpoint is stored with insufficient sanitising and later runs as script when rendered in chat.
- Lollms vulnerable to Cross-site Scripting The SVG sanitiser removes only script tags and on-event attributes, so other SVG vectors survive and run script when a victim opens the file.