Browse / AI Framework and Platform Flaws / Server-side request forgery
Server-side request forgery
103 records in AI Framework and Platform Flaws.
- QuantumNous/new-api has an SSRF Filter Bypass via 0.0.0.0 Using 0.0.0.0 as the host in multimodal image URLs slips past new-api's private IP filter, so the server fetches localhost.
- PraisonAI has an SSRF bypass The URL validator checks the host that urlparse extracts, but requests connects to a different host for crafted backslash and at-sign URLs, reaching internal addresses.
- 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 Image URLs are validated for private addresses and then fetched separately, so DNS rebinding lets the fetch reach internal hosts despite the check.
- 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.
- Flowise Execute Flow function has an SSRF vulnerability The Execute Flow node's base URL is not checked by the deny-list validator, so the server issues requests to internal addresses.
- Flowise: SSRF Protection Bypass via Direct node-fetch / axios Usage (Patch Enforcement Failure) Several tools call raw HTTP clients directly instead of the centralised SSRF wrapper, so requests to internal addresses still succeed.
- Flowise: SSRF Protection Bypass via Unprotected Built-in HTTP Modules in Custom Function Sandbox Custom function code can load built-in http, https or net modules that bypass the SSRF deny list, reaching internal services such as cloud metadata endpoints.
- MetaGPT affected by server-side request forgery in metagpt/utils/common.py The decode_image helper fetches attacker-supplied URLs without restriction, letting callers make the server request internal or arbitrary addresses.
- PraisonAI Vulnerable to Server-Side Request Forgery via Unvalidated webhook_url in Jobs API The jobs API posts completion results to any caller-supplied webhook URL without validation, letting the server reach internal and cloud metadata endpoints.
- vLLM: Server-Side Request Forgery (SSRF) in `download_bytes_from_url ` The batch runner fetches any URL supplied in batch input JSON without validation, letting callers reach internal hosts and metadata endpoints.
- PraisonAI: SSRF via Unvalidated api_base in passthrough() Fallback The passthrough fallback joins a caller-supplied base URL to the endpoint and sends the request with no host validation, reaching internal services.
- Flowise affected by Server-Side Request Forgery (SSRF) in HTTP Node Leading to Internal Network Access The HTTP node in Flowise sends server-side requests to user-supplied URLs with no default restriction on private, loopback or metadata addresses.
- vLLM has SSRF Protection Bypass vLLM's URL check parses backslash-containing URLs differently from the aiohttp client that fetches them, letting a request reach an attacker host.
- Gradio has SSRF via Malicious `proxy_url` Injection in `gr.load()` Config Processing A malicious remote Space config adds its own proxy host to the allowlist, letting the victim's server reach internal addresses.
- LangChain Community: redirect chaining can lead to SSRF bypass via RecursiveUrlLoader The URL check in RecursiveUrlLoader runs only on the starting address, so automatic redirects can send the crawler to internal or metadata endpoints.
- MindsDB affected by a SSRF vulnerability A filename-cleaning function in the file upload path mishandles input, letting an attacker make the server issue requests to arbitrary destinations.
- LangChain affected by SSRF via image_url token counting in ChatOpenAI.get_num_tokens_from_messages Token counting for chat messages fetches any image_url in the input, so a crafted URL makes the server issue requests to arbitrary hosts.
- @langchain/community affected by SSRF Bypass in RecursiveUrlLoader via insufficient URL origin validation Crawled pages can link to hosts whose names merely start with the base domain or to private and metadata addresses, which the crawler fetches without validation.
- LangSmith Client SDK Affected by Server-Side Request Forgery via Tracing Header Injection A crafted baggage header makes the LangSmith tracing SDK accept an attacker-chosen endpoint, so run data is sent to that server.
- Pydantic AI has Server-Side Request Forgery (SSRF) in URL Download Handling The URL download helper fetches URLs from supplied message history without rejecting internal or metadata addresses.
- vLLM vulnerable to Server-Side Request Forgery (SSRF) through MediaConnector Host restrictions in the media loader parse backslashes differently in two libraries, so a crafted URL can reach internal hosts.
- Chainlit contain a server-side request forgery (SSRF) vulnerability An authenticated user can supply an element URL that the server fetches, letting it reach internal services and cloud metadata endpoints.
- Langflow vulnerable to Server-Side Request Forgery The API Request node fetches any user-supplied URL without blocking internal or metadata addresses and returns the response to a caller holding only an API key.
- Open WebUI vulnerable to Server-Side Request Forgery (SSRF) via Arbitrary URL Processing in /api/v1/retrieval/process/web An authenticated user can make the retrieval web-processing endpoint fetch any URL because the submitted address is not validated.
- new-api is vulnerable to SSRF Bypass A redirect from an allowed external URL points the server at internal addresses, because the SSRF check only validates the first request.
- Lobe Chat vulnerable to Server-Side Request Forgery with native web fetch module The crawlPages endpoint fetches client-supplied URLs server-side without filtering internal or metadata addresses, letting callers reach internal services.
- vLLM is vulnerable to Server-Side Request Forgery (SSRF) through `MediaConnector` class The media loader fetches any http, https or file URL supplied in a multimodal request without host restrictions, so the server can be made to reach internal addresses.
- FlowiseAI/Flowise has Server-Side Request Forgery (SSRF) vulnerability The link-extraction endpoint fetches any caller-supplied URL without validation, so callers can make the server request internal hosts and parse the responses.
- BentoML SSRF Vulnerability in File Upload Processing The framework automatically downloads URLs supplied in multipart or JSON file fields without checking internal addresses, so callers can make the server request internal services.
- MLFlow SSRF via gateway_proxy_handler The gateway proxy handler forwards requests with an unvalidated path, letting callers make the server reach arbitrary internal URLs.
- FastChat Server-Side Request Forgery vulnerability The web server lets requests reach internal addresses, so attackers can fetch internal resources such as cloud metadata credentials.
- FastChat Server-Side Request Forgery vulnerability Insufficient validation of a path parameter on the queue join endpoint lets requests be forwarded to internal hosts and cloud metadata services.
- Label Studio allows Server-Side Request Forgery in the S3 Storage Endpoint A user-supplied S3 endpoint is passed unvalidated to the AWS SDK, so the server sends requests to internal hosts and echoes their responses in errors.
- @lobehub/chat Server Side Request Forgery vulnerability An unauthenticated chat endpoint accepts a user-supplied proxy address and sends requests to it, letting attackers reach internal services and echo responses back.
- gradio Server Side Request Forgery vulnerability The save_url_to_cache function fetches any supplied URL without restriction, letting an attacker make the server download local or internal resources.
- Gradio vulnerable to SSRF in the path parameter of /queue/join The queue join endpoint makes the server fetch attacker-supplied URLs and cache the results, reaching internal hosts.
- lobe-chat implemented an insufficient fix for GHSA-mxhq-xw3g-rphc (CVE-2024-32964) The proxy's SSRF check validates only the initial URL and ignores redirects, so an external URL can redirect the server to private or loopback addresses.
- LiteLLM Server-Side Request Forgery (SSRF) vulnerability A user-supplied api_base on the chat completions route makes the server send requests to attacker hosts, carrying the stored OpenAI key with them.
- MindsDB Vulnerable to Bypass of SSRF Protection with DNS Rebinding The private-address check resolves the hostname once, so a DNS record that later returns an internal address redirects the real request to internal services.
- NextChat has full-read SSRF and XSS vulnerability in /api/cors endpoint An open CORS proxy endpoint fetches arbitrary URLs with any HTTP method and returns the content, reaching internal services and enabling script injection.
- Server-Side Request Forgery in gradio Gradio's queue endpoint fetches attacker-supplied URLs server-side through a cache helper without validation, reaching internal hosts and cloud metadata services.
- lobe-chat `/api/proxy` endpoint Server-Side Request Forgery vulnerability An unauthenticated proxy endpoint forwards attacker-supplied requests to arbitrary destinations, so internal services can be reached and their responses returned.
- gradio Server-Side Request Forgery vulnerability A file parameter in a GET request makes the server contact internal addresses, so the responses reveal which internal ports are open.
- gradio Server-Side Request Forgery vulnerability An X-Direct-Url header adds attacker-chosen addresses to the replica list used by the proxy route, so requests are forwarded to internal endpoints.
- Label Studio SSRF on Import Bypassing `SSRF_PROTECTION_ENABLED` Protections The URL import validates the target with one DNS lookup, so redirects or DNS rebinding let requests reach internal hosts despite the SSRF setting.
- MLflow Server-Side Request Forgery (SSRF) Crafted requests make the MLflow server fetch attacker-chosen internal HTTP endpoints, which could lead to code execution on cloud hosts.
- Server-Side Request Forgery in mindsdb The file upload endpoint fetches a user-supplied URL without validation, letting requests reach internal hosts.