Browse / AI Framework and Platform Flaws / Server-side request forgery
Server-side request forgery
96 records in AI Framework and Platform Flaws.
- Kubeflow Pipelines — API server fetches a caller-supplied pipelineURL without host validation The pipeline API server fetches a caller-supplied package URL without restricting destinations, letting authorised users make requests from its network position.
- MLflow: SSRF on unauthenticated MLflow servers via third-party scorer kwargs in the scorer invoke, register, and GenAI evaluate endpoints An unauthenticated endpoint instantiates a class named in JSON whose module allowlist does not constrain the class or its arguments, forcing outbound requests to attacker-chosen hosts.
- PraisonAI: Jobs API is unauthenticated by default and allows attacker-controlled webhook SSRF The jobs API is open unless a key variable is set, and the webhook URL is validated once then re-resolved at connection time, allowing rebinding to internal hosts.
- PraisonAI: DNS rebinding bypass in `web_crawl` SSRF protection allows internal response disclosure
- Docling has SSRF guard bypass in remote resource fetching (DNS rebinding / multi-record resolution; no IP validation in HTML render mode)
- Langflow: SSRF in URL-taking components (protection disabled by default / warn-only, not applied to RSS, SearXNG, Web Search, Home Assistant, Glean, Docling)
- 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.
- LiteLLM Proxy has server-side request forgery via the `user_config` request parameter
- 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: 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.
- n8n: Domain-Restriction Bypass via Unguarded Model-Search Endpoint in OpenAI Chat Model Node The model-search path skips the allowed-domains check, so a custom base URL sends the stored API credential to any host.
- n8n: Instance AI Credential Setup Accepts Unvalidated Probe URL from Fetched Content
- Open WebUI: Server-side fetches reach blocked and internal hosts via unvalidated HTTP redirect targets Redirect targets from server-side page fetches skip the blocked-host and private-address checks, so authenticated users can reach internal services.
- NLTK: pathsec SSRF protection can be bypassed when a proxy is configured When a proxy is configured, the NLTK URL check validates the hostname but the fetch goes through the proxy, reaching internal services the check was meant to block.
- vLLM: SSRF + arbitrary local file read in MiMoV2OmniMultiModalProcessor `_fetch_image` and audio loader bypass MediaConnector protections A multimodal processor fetches user-supplied image and audio URLs and local paths directly, skipping the media connector's SSRF and local path checks.
- unstructured: Server-Side Request Forgery in the URL-based partitioning The URL loader fetches caller-supplied addresses without host checks and returns the response body, letting requests reach internal and metadata services.
- NLTK: SSRF Fail-Open in validate_network_url() via DNS Resolution Failure When DNS resolution fails, validate_network_url returns without rejecting the URL, so urlopen fetches internal targets such as cloud metadata endpoints.
- PraisonAI vulnerable to Server-Side Request Forgery via DNS rebinding bypass in webhook_url validation
- PraisonAI: Webhook SSRF via DNS fail-open in `JobSubmitRequest.validate_webhook_url()` — bypass of CVE-2026-40114
- praisonaiagents has an SSRF protection bypass in `spider_tools._host_is_blocked()` via DNS-resolved hostnames (`127.0.0.1.nip.io`)
- MLflow: Unauthenticated full-read SSRF in webhook delivery: _validate_webhook_url bypassed via unvalidated HTTP redirects (and DNS rebinding) Webhook delivery validates the initial URL but follows redirects without re-checking the target, letting an unauthenticated caller reach internal addresses.
- Pydantic AI: Unvalidated UploadedFile references in UI adapters allow server-side file access using the application's credentials
- NLTK network URL validation permits SSRF to RFC 6598 shared-address-space hosts The private-address check misses the RFC 6598 shared range, so URLs pointing there pass validation and are fetched by the server.
- Open WebUI: Any authenticated user can reach internal services and cloud metadata via NAT64-encoded URLs A NAT64-wrapped IPv4 literal passes a globally-routable check that only inspects the IPv6 form, letting the server fetch internal and metadata endpoints.
- Flowise: SSRF Protection Bypass via IPv4-Mapped IPv6 Addresses Private IPv4 deny rules are skipped when an IPv4-mapped IPv6 address is used, so hostnames resolving to such addresses reach internal targets.
- n8n: Authenticated SSRF via Dynamic Node Parameters Endpoints Allows Internal Network Access Dynamic node parameter routes lack scope checks and accept absolute URLs that override the node base URL, letting users make the server call internal targets.
- crewai-tools SSRF redirect bypass exposes internal services
- New API: SSRF Protection Bypass via Unresolved Hostname in Notification URLs Notification URL hostnames are not resolved or checked against private IPs by default, so authenticated users can reach internal addresses.
- LocalAI POST /models/apply permits unauthenticated server-side request forgery through gallery URLs An unauthenticated model-apply endpoint fetches attacker-supplied gallery URLs, letting callers make the server request internal addresses and see partial responses in errors.
- Open WebUI has Blind Server Side Request Forgery in its Image Edit Functionality
- pydantic-ai: SSRF blocklist bypass via IPv4-compatible, SIIT/IVI, and local NAT64 IPv6 addresses (incomplete fix of CVE-2026-46678) IPv6 transition address forms evade the private-address blocklist during URL downloads, letting the library reach cloud metadata endpoints and expose credentials.
- praisonaiagents: SSRF guard validates literal IPs only and never resolves DNS
- Open WebUI: Redirect-Bypass SSRF in OAuth `_process_picture_url` (incomplete-fix sibling of CVE-2026-45401) The OAuth profile picture fetch validates only the initial URL and follows redirects, so a public URL can redirect the server to internal addresses.
- Open WebUI: SSRF Protection Bypass in Playwright Web Loader via HTTP Redirects
- Aider has an SSRF vulnerability through its AWS EC2 Metadata Endpoint
- PraisonAI spider_tools SSRF protection bypass via alternate loopback host encodings
- 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.
- 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 has a full SSRF Vulnerability in the RAG Web Search Feature The private-address check accepts every IPv6 address because a library call fails silently, and IPv4-mapped and reserved IPv4 ranges are not blocked either.
- Open WebUI has a Server-Side Request Forgery (SSRF) bypass in `validate_url` URL validation parses with one parser while requests uses another, so a backslash-containing URL passes the public-IP check yet connects to an internal address.
- 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 a SSRF Bypass via HTTP Redirect Following in Web-Fetch and Image-Load Endpoints (not addressed by CVE-2025-65958)
- 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.
- QuantumNous/new-api has an SSRF Filter Bypass via 0.0.0.0
- PraisonAI has an SSRF bypass
- AgentScope vulnerable to Server-Side Request Forgery The internal helper that downloads bytes from a web URL accepts attacker-chosen addresses, letting requests reach internal services.
- AgentScope vulnerable to Server-Side Request Forgery The audio block processor fetches a caller-supplied URL without restriction, so it can be made to request internal resources.
- langchain-openai: Image token counting SSRF protection can be bypassed via DNS rebinding
- LangChain Text Splitters: HTMLHeaderTextSplitter.split_text_from_url SSRF Redirect Bypass URL validation runs only on the first request, and redirects are then followed without revalidation, so an attacker can reach internal or metadata endpoints.
- Flowise: SSRF Protection Bypass (TOCTOU & Default Insecure) DNS rebinding exploits the gap between a validation lookup and the connection lookup, and the default empty deny list lets requests reach localhost.