/

CVE-2026-54008

Severity:

HIGH RISK

(8.5)

Server-Side Request Forgery (CWE-918) in Open WebUI

CVE-2026-54008

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal network access and data exposure via SSRF

Severity:

HIGH RISK

(8.5)

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 server-side request forgery (SSRF) flaw in Open WebUI's OAuth profile image handling lets an authenticated attacker supply a URL that is validated only before redirects.

Because the backend follows HTTP 3xx redirects automatically, an attacker's URL can pivot to internal endpoints, and the response body is exposed back via the profile_image_url field, risking disclosure of internal services or metadata.

Affected context

This vulnerability appears in Open WebUI deployments that use OAuth identity providers and accept remote profile image URLs.

The backend validates the original picture URL but then performs HTTP GET requests that follow redirects by default.

In environments where Open WebUI can reach internal services (such as private APIs, cloud metadata endpoints, or admin interfaces), the redirected requests may unintentionally expose internal response data back to the attacker-controlled profile metadata.

Exploit preconditions

  • Attack surface: OAuth integration endpoint handling user profile images (picture_url).
  • Required access: A valid OAuth identity provider account that can set or influence the profile image URL.
  • Trigger point: Submission of a public URL that returns an HTTP 3xx redirect to an internal or otherwise sensitive address.
  • Why exploitation is possible: The application validates only the initial URL and then uses aiohttp with redirect-following enabled, allowing internal requests to be made and their response bodies to be reflected back to the attacker.

Why this happens

The root cause maps to CWE-918: Server-Side Request Forgery (SSRF), where a server-side HTTP client is influenced by user-controlled input.

In this case, validate_url() is applied to the initial picture URL, but the HTTP client (aiohttp.ClientSession.get) uses its default allow_redirects=True behavior, enabling attacker-controlled redirects without additional validation.

Because the redirected targets are not constrained to safe, external domains or schemes, the backend can be coerced into issuing requests to internal network resources and returning those responses to the attacker via the profile_image_url handling logic.

Potential impact

  • An attacker could read responses from internal HTTP services reachable by the Open WebUI backend.
  • An attacker may discover internal service endpoints, API paths, and configuration details.
  • An attacker could potentially obtain cloud or host metadata where such endpoints are exposed over HTTP.
  • An attacker can use SSRF as a stepping stone for further attacks, such as credential harvesting or service reconnaissance.

General mitigation guidance

Effective mitigation focuses on constraining outbound requests and eliminating trust in user-controlled URLs for server-side fetching.

Common defensive patterns include:

  • Validating both the initial URL and all redirect targets against an allowlist of trusted domains or IP ranges.
  • Disabling automatic redirects for user-controlled URLs, and enforcing explicit, policy-aware redirect handling.
  • Isolating or proxying outbound HTTP requests through a component that enforces network egress rules and blocks access to internal-only addresses.
  • Reducing or removing the need for the server to fetch user-provided URLs directly; where necessary, prefer client-side fetching or sanitized media proxy endpoints.
  • Running the backend with least-privilege network access, limiting which internal services it can reach.

How teams detect issues like this

Detection usually involves a combination of code-level analysis and runtime monitoring:

  • Static analysis or code review to identify HTTP client usage where URLs originate from user input and redirects are followed by default.
  • Security review patterns that flag any server-side URL fetching that does not enforce domain allowlists or egress controls.
  • Logging and monitoring outbound HTTP requests from the application, watching for unexpected internal targets or unusual redirect chains.
  • Use of automated security testing tools (including dynamic SSRF scanners) against OAuth and profile-related endpoints to identify misconfigurations.

Sources

SourceLink
github.comgithub.com/open-webui/open-webui/security/advisories/GHSA-226f-f24g-524w

Frequently asked

questions

Yes. Any attacker with a valid OAuth identity provider account and the ability to control their profile image URL can exploit the vulnerability remotely, provided the Open WebUI backend has network access to internal or sensitive endpoints.

No elevated in-app privileges are strictly required; normal authenticated users through OAuth are sufficient.

The key requirement is the ability to configure or influence the profile image URL that the backend fetches.

The safest pattern is to avoid unrestricted server-side fetching of user-controlled URLs.

Where fetching is required, enforce strict allowlists, disable automatic redirects, validate all redirect locations, and isolate outbound requests so they cannot reach internal-only resources.

Treat any user-influenced URL as untrusted, apply domain and IP allowlists, disable or tightly control redirects, and review all outbound HTTP client usage.

Complement these controls with network segmentation and egress filtering so that application servers cannot freely access internal services or cloud metadata endpoints.

Find out what's already
exploitable in your codebase.