/

CVE-2026-33340

Severity:

CRITICAL RISK

(9.1)

SSRF in LoLLMs WEBUI Proxy Endpoint

CVE-2026-33340

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-306, CWE-918

Impact:

Network pivoting and sensitive data exposure via server-initiated requests

Severity:

CRITICAL RISK

(9.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A critical Server-Side Request Forgery (SSRF) vulnerability in LoLLMs WEBUI allows unauthenticated users to abuse the /api/proxy endpoint to make arbitrary outbound GET requests from the server.

When exposed, this can be used to reach internal services, probe private networks, or retrieve sensitive cloud metadata such as AWS or GCP IAM tokens.

Affected context

The vulnerability arises in LoLLMs WEBUI deployments that expose the HTTP API, particularly the @router.post("/api/proxy") endpoint, to users or the public internet.

It is most relevant when the server has network visibility into internal services (e.g., private VPC subnets, databases, internal APIs) or is running in a cloud environment where instance metadata services are reachable.

The risk increases when there is no upstream authentication or network segmentation restricting who can call the proxy endpoint.

Exploit preconditions

  • Attack surface: HTTP API endpoint /api/proxy on the LoLLMs WEBUI server.
  • Required access: Network-level ability to send HTTP requests to the WEBUI instance; no authentication is required by the vulnerable endpoint itself.
  • Trigger point: Attacker sends crafted POST requests to /api/proxy that specify arbitrary target URLs for the server to fetch via GET.
  • Why exploitation is possible:
  • The proxy endpoint accepts user-controlled URLs and forwards requests from the server's network context.
  • There is insufficient or no validation of target addresses (e.g., private IP ranges, link-local metadata endpoints).
  • The endpoint lacks proper authentication and authorization checks, mapping to CWE-306 (Missing Authentication for Critical Function).

Why this happens

The core issue is an insecure proxy design where user input directly controls outbound requests made by the backend server.

The @router.post("/api/proxy") handler functions as an open proxy: it trusts client-supplied URLs and forwards them without enforcing strict allowlists, IP/hostname filtering, or scheme restrictions.

Because the server often has access to internal networks and cloud metadata services that the attacker cannot reach directly, this design maps to CWE-918: Server-Side Request Forgery (SSRF).

The lack of authentication and authorization on this critical proxy endpoint further reflects CWE-306: Missing Authentication for Critical Function, enabling anyone who can reach the service to trigger SSRF behavior.

Potential impact

  • Access to internal HTTP services that are not exposed to the public internet (e.g., admin panels, internal APIs, service meshes).
  • Network reconnaissance and port scanning of internal IP ranges from the server's vantage point.
  • Retrieval of cloud instance metadata, including IAM credentials or tokens from AWS, GCP, or similar platforms.
  • Leveraging discovered internal services for further exploitation, such as exploiting additional vulnerabilities behind the perimeter.
  • Exfiltration of configuration files or service responses containing secrets, API keys, or sensitive operational data.
  • Potential lateral movement within the hosting environment or cloud account, depending on the power of stolen credentials.

General mitigation guidance

While specific version-level fixes are not covered here, several defensive patterns can significantly reduce risk from SSRF-prone proxy endpoints:

  • Require strong authentication and authorization for any proxy-like endpoints; avoid exposing them anonymously or broadly.
  • Implement strict allowlists of permitted outbound destinations (domains or services) and reject all others by default.
  • Block access to internal and link-local addresses, including RFC1918 ranges, 127.0.0.0/8, 169.254.169.254 (cloud metadata), and similar sensitive IP spaces.
  • Constrain acceptable URL schemes to https and http as appropriate, excluding file, gopher, ftp, and other non-HTTP schemes.
  • Use network-level controls such as firewalls, security groups, or service meshes to restrict the server's ability to reach metadata services and sensitive internal endpoints.
  • Isolate the application runtime in a network segment with minimal privileges, limiting what can be reached even if SSRF is triggered.
  • Avoid generic proxy functionality unless it is strictly necessary; where needed, design narrowly-scoped, task-specific fetch endpoints rather than open proxies.

How teams detect issues like this

Potential approaches to detecting and monitoring this class of vulnerability include:

  • Static analysis and code review:
  • Flag endpoints that forward requests based on user-supplied URLs or hostnames.
  • Look for HTTP client calls (e.g., requests.get, httpx, fetch) that receive URL input directly from request bodies or query parameters without validation.
  • Identify critical endpoints that lack authentication decorators or middleware (relevant to CWE-306).
  • Security testing and dynamic analysis:
  • Include SSRF test cases in API security testing, attempting to access internal IPs and metadata endpoints via proxy routes.
  • Use API fuzzers or specialized scanners configured with SSRF payloads and internal IP targets.
  • Runtime monitoring:
  • Log outbound HTTP requests with destination URLs and IPs, and alert on requests to internal or metadata IP ranges.
  • Deploy network-level monitoring to detect unexpected calls from the application server to sensitive infrastructure endpoints.
  • Policy and CI integration:
  • Enforce internal coding standards that forbid open-proxy designs and require allowlisting for outbound calls.
  • Integrate automated code review or SAST tools into CI to surface SSRF-prone patterns early in development.

Sources

SourceLink
github.comgithub.com/ParisNeo/lollms-webui/blob/8c5dcef63d847bb3d027ec74915d8fe4afd3014e/lollms/server/endpoints/lollms_apps.py#L443-L450
github.comgithub.com/ParisNeo/lollms-webui/security/advisories/GHSA-mcwr-5469-pxj4

Frequently asked

questions

Exploitability is broad whenever the LoLLMs WEBUI instance is reachable over the network, especially if the /api/proxy endpoint is exposed to the internet. Because the vulnerable route is unauthenticated, any external user who can send HTTP requests to the service can attempt SSRF.

No. The described behavior indicates that the proxy endpoint lacks authentication, so exploitation generally does not require credentials or a registered account. Network access to the WEBUI host and knowledge of the /api/proxy path are sufficient.

The safest pattern is to either remove generic proxy functionality entirely or implement a tightly controlled fetch mechanism that is authenticated, authorized, and restricted to a small, explicit allowlist of destinations. In addition, enforce IP and scheme restrictions and block access to internal and metadata address ranges.

Prevention involves architectural and coding practices: avoid designing endpoints that forward arbitrary URLs, require authentication for any functionality that makes server-side network calls on behalf of users, validate and constrain outbound targets, and complement these controls with network segmentation and egress filtering. Regular security reviews focused on outbound call sites and standardized SSRF-safe patterns also help avoid regressions.

Find out what's already
exploitable in your codebase.