Bypasses / SSRF protection
SSRF protection
68 cases that got past this protection.
- 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.
- PraisonAI: Crawl4AI/Chromium backend is also affected by the `web_crawl` SSRF validation bypass The crawl4ai browser backend re-resolves DNS and follows redirects without the per-connection SSRF guard, letting requests reach 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.
- MCP Atlassian: SSRF via DNS Rebinding in Header-Based Authentication Flow The header-based auth flow validates a Jira URL's DNS result, then the later request resolves again, so a rebinding host reaches internal addresses.
- mcp-atlassian has an incomplete SSRF remediation The MCP middleware accepts Jira and Confluence base URLs from request headers without validation, so the server fetches attacker-chosen internal hosts.
- MCP Atlassian: SSRF redirect protection missing for basic-auth and OAuth authentication branches The SSRF redirect check is attached only to the header token auth branch, so basic-auth and OAuth requests follow redirects to internal addresses such as cloud metadata.
- MCP Atlassian: SSRF Protection Bypass A backslash-based userinfo trick makes the URL validator check a harmless hostname while the actual request goes to a loopback or internal address.
- MCP Atlassian: Incomplete fix for GHSA-7r34-79r5-rcc9: redirect-based SSRF via unhooked requests session in Jira user-permission lookup A public base URL passes the initial internal-address check, then a redirect to an internal host is followed by a request path that skips the redirect validation hook.
- 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.
- 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 web_crawl vulnerable to SSRF via redirect-following The agent's web crawl tool checks only the initial URL, then follows attacker-supplied redirects to internal addresses and returns their contents to the model.
- praisonaiagents has a `web_crawl` SSRF protection bypass via unchecked redirect targets The crawler checks only the first URL, then follows redirects unchecked, letting a public address send requests to internal or metadata endpoints.
- praisonaiagents vulnerable to SSRF in web_crawl tool via redirect-following and DNS rebinding (validate-then-fetch gap) The crawl tool checks only the first hostname resolution, then the HTTP client follows redirects and re-resolves DNS, letting requests reach 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.
- 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.
- 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.
- n8n: SSRF Protection Bypass via MCP Client Node The MCP Client node sends requests to user-supplied endpoints without applying SSRF checks or pinning resolved addresses, letting workflow users reach internal hosts.
- crewai-tools SSRF redirect bypass exposes internal services A URL that redirects or rebinds its DNS after the single validation lookup can reach internal hosts, because the check runs once and the original address is used.
- MCP Atlassian: DNS-rebinding TOCTOU bypass of the SSRF fix (CVE-2026-27826) The MCP server validates a header-supplied host's DNS result but later re-resolves it at connect time, so a rebinding name reaches internal addresses.
- 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.
- 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.
- PraisonAI: SpiderTools redirect-target SSRF protection bypass Redirects are followed without validating the target, so a public URL can redirect the scraper to internal or metadata addresses.
- 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.
- 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.
- 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 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 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.