Browse / AI Framework and Platform Flaws / Server-side request forgery
Server-side request forgery
103 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 The URL guard resolves hostnames only at check time while the fetcher resolves them again, so a rebinding domain returns internal content to the crawl tool.
- Pydantic AI: SSRF cloud-metadata blocklist bypass via IPv6 zone identifiers The cloud-metadata blocklist compares IPv6 addresses without considering zone identifiers, so a zone-scoped metadata address passes and reaches the endpoint.
- Docling has SSRF guard bypass in remote resource fetching (DNS rebinding / multi-record resolution; no IP validation in HTML render mode) Private-address checks resolve hosts differently from the HTTP client, so DNS rebinding or backslash parsing reaches internal addresses.
- Langflow: SSRF in URL-taking components (protection disabled by default / warn-only, not applied to RSS, SearXNG, Web Search, Home Assistant, Glean, Docling) Flow components fetch author-supplied URLs without enforcing the private-address guard, so the server can reach internal endpoints and return responses.
- 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 Nesting an api_base inside user_config slips past a check that only inspects top-level keys, so the proxy sends requests to hosts the caller chooses.
- 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.
- 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 The webhook URL check ignores DNS lookup failures and never rechecks the resolved address before the server posts to it, so a rebinding domain can reach internal hosts.
- PraisonAI: Webhook SSRF via DNS fail-open in `JobSubmitRequest.validate_webhook_url()` — bypass of CVE-2026-40114 Webhook URL validation accepts hostnames that fail DNS lookup, and the later delivery resolves them again, so a record can be repointed to internal addresses.
- praisonaiagents has an SSRF protection bypass in `spider_tools._host_is_blocked()` via DNS-resolved hostnames (`127.0.0.1.nip.io`) The spider tools blocklist checks only literal hostnames, so a name like 127.0.0.1.nip.io resolving to loopback reaches internal services.
- 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.
- 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.
- MLflow AI Gateway permits SSRF through an unvalidated api_base Gateway secrets accept an unvalidated base URL that the proxy later requests, letting any authenticated user reach internal addresses and metadata services.
- 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.
- Open WebUI: DNS Rebinding SSRF Bypass URL validation resolves a hostname once, but the HTTP client resolves it again at connect time, so attacker DNS can rebind requests to internal addresses.
- Open WebUI: SSRF into internal services via unvalidated sub-resource requests in the Playwright web loader Address validation runs only on the top-level page, so JavaScript in the loaded page can fetch internal addresses that are then returned to the user.
- 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.
- Flowise: Unauthenticated OAuth2 Refresh Enables Non-Blind SSRF and Secret Exfiltration The OAuth2 refresh route is whitelisted from auth and sends server-side requests to a credential-supplied token URL without SSRF checks, returning the remote response to the caller.
- Natural Language Toolkit (NLTK): DNS-rebinding SSRF filter bypass in nltk.pathsec.urlopen (nltk.download / nltk.data.load) defeats ENFORCE mode The SSRF check resolves a hostname separately from the actual connection, so DNS rebinding returns a public address for validation and an internal one for connecting.
- Open WebUI: `WEB_FETCH_FILTER_LIST` host allow/block filter bypassable via URL path and non-label-boundary matching The host allow and block filter matches full URL strings with endswith, so path suffixes and partial labels let authenticated users reach filtered hosts.
- 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.
- 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 The image edit endpoint fetches any user-supplied HTTP or HTTPS URL without restriction, letting the server reach internal addresses that can be probed by response differences.
- 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.
- PraisonAI: Jobs webhook SSRF protection bypass via DNS rebinding A webhook hostname passes validation at submission but later resolves to an internal address when the server sends the callback, evading the earlier check through DNS rebinding.
- praisonaiagents: SSRF guard validates literal IPs only and never resolves DNS The SSRF guard checks only literal IP forms of a URL host and never resolves DNS, so a hostname pointing to an internal address gets fetched.
- 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 The URL check runs only on the first address, so a page that redirects the headless browser to an internal host reaches blocked targets.
- 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.
- 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.
- 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.
- 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.
- 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) Redirects from allowed public URLs are followed without rechecking the target, reaching internal addresses through fetch and image-load paths.
- 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.