CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-88001

CVE-2026-88001: Server-Side Request Forgery via Redirect Bypass in Open WebUI

Alon Barad
Alon Barad
Software Engineer

Sep 10, 2026·7 min read·23 visits

Executive Summary (TL;DR)

An SSRF vulnerability in Open WebUI allows authenticated attackers to bypass network access controls and fetch internal resources or cloud metadata via crafted redirects and direct IP literals.

Server-Side Request Forgery (SSRF) vulnerability in Open WebUI (v0.9.5 to v0.11.1) allows authenticated users to bypass private IP and host filter lists by abusing HTTP redirect handling or using IP literals with the aiohttp client.

Vulnerability Overview

Open WebUI is an extensible, self-hosted user interface designed to interact with Large Language Models (LLMs). The platform offers features that require outbound network communication, including Retrieval-Augmented Generation (RAG), web scraping, web search integration, and processing of user-supplied URLs. These actions expose an attack surface where the application acts as an HTTP client executing server-side requests based on user input.

To manage this risk, the application integrates validation controls that inspect outbound request destinations. These validation mechanisms check target hostnames and IPs against blocklists and look up destination addresses to block loopback (e.g., 127.0.0.1, [::1]) and private (RFC 1918) IP networks. If these checks are bypassed, the server can be forced to communicate with internal resources.

This vulnerability, tracked as CVE-2026-88001, is a Server-Side Request Forgery (SSRF) classified under CWE-918. In versions ranging from v0.9.5 up to v0.11.1, authenticated users can exploit validation logic gaps to bypass both host filtering (WEB_FETCH_FILTER_LIST) and private network restrictions. The security control failure occurs because the backend does not re-validate destination targets when following HTTP redirects and fails to intercept IP-literal connections in the aiohttp library.

Root Cause Analysis

The vulnerability stems from two independent flaws in the network fetch layer. The first flaw is the lack of redirect verification. The validation function validate_url() is applied only to the initial URL provided by the user. Once the initial check succeeds, the application passes the URL to the HTTP client (requests or aiohttp) with redirect-following enabled. When an external host responds with a 302 Found status and a Location header pointing to an internal resource, the client follows the redirect without applying validation checks on the subsequent target.

The second flaw is specific to the aiohttp client. Open WebUI attempted to block private IP addresses by defining a custom DNS resolver class named _SSRFSafeResolver. This resolver intercepted host name lookups and validated the returned IP addresses. However, modern HTTP clients contain optimizations that identify direct IP literals, such as 127.0.0.1 or 169.254.169.254, and skip standard DNS resolution entirely.

Because the DNS resolution process is bypassed when resolving IP literals, the custom _SSRFSafeResolver is never executed for these targets. Consequently, an attacker can supply a redirect pointing directly to an IP address literal, allowing the client to establish a TCP connection to the loopback or private network without triggering any of the safety checks.

Code Analysis

The patch in commit e3e4bd87df6fc629e7e22081d980d55a7632b8b7 remediates both gaps by moving the validation checks from the pre-flight parser and DNS resolver down to the socket connection and transport layer.

For aiohttp, the validation logic is refactored out of the resolver and placed within a custom TCPConnector subclass named _SSRFSafeConnector. This class overrides the connect and _resolve_host methods:

class _SSRFSafeConnector(aiohttp.TCPConnector):
    """Rejects filter-listed request targets, and non-global IPs on each new connection."""
 
    async def connect(self, req, traces, timeout):
        # Check host before connection is established
        _assert_host_allowed(req.url.host)
        return await super().connect(req, traces, timeout)
 
    async def _resolve_host(self, host, port, traces=None):
        # Capture IP literals that bypass DNS resolvers
        results = await super()._resolve_host(host, port, traces=traces)
        _assert_addresses_allowed([entry['host'] for entry in results])
        return results

For the synchronous requests library, the patch introduces a transport adapter (_SSRFSafeAdapter) that hooks into HTTPAdapter. The send method is executed for every redirection step in the request lifecycle, ensuring each redirect target is validated:

class _SSRFSafeAdapter(HTTPAdapter):
    """requests adapter that rejects filter-listed request targets and non-global IPs at connect time."""
 
    def init_poolmanager(self, *args, **kwargs):
        super().init_poolmanager(*args, **kwargs)
        self.poolmanager.pool_classes_by_scheme = {
            'http': _SafeHTTPPool,
            'https': _SafeHTTPSPool,
        }
 
    def send(self, request, *args, **kwargs):
        # Validate host for initial request and all redirect hops
        _assert_host_allowed(urllib.parse.urlparse(request.url).hostname)
        return super().send(request, *args, **kwargs)

Additionally, the patch addresses complex IP parsing evasions. Attackers often attempt to bypass validation filters using IPv6-mapped IPv4 addresses (e.g., [::ffff:127.0.0.1]). The patch implements an active un-mapping function _embedded_ipv4 to extract the underlying IPv4 address from various transition encodings (SIIT, 6to4, Teredo, and NAT64) and match them against the restricted private IP ranges.

Exploitation Methodology

An exploit scenario begins with an authenticated attacker setting up an external HTTP server that acts as a redirect agent. The attacker configures this external server to respond with a redirect to the target local address or cloud metadata endpoint, such as http://169.254.169.254/computeMetadata/v1/.

The attacker then uses an authorized feature within Open WebUI, such as adding a new web page source to the document ingestion pipeline or triggering an automated web search. The input provided to the application is the URL of the attacker's external server.

Because the destination check passes on attacker.com during the pre-flight phase, Open WebUI proceeds to execute the HTTP request. Upon receiving the 302 Found response, the underlying client automatically requests the location specified in the header. The application does not check the redirect destination, allowing the client to fetch data from the internal network and return the payload to the attacker's interface.

Impact Assessment

The primary impact of this SSRF is unauthorized information disclosure from the server's local environment. An attacker with standard user credentials can map internal networks, scan local ports, and discover active services. If Open WebUI is hosted on a cloud instance, the vulnerability allows the retrieval of cloud metadata, which frequently contains highly sensitive information such as access tokens, IAM credentials, and instance configurations.

The CVSS v3.1 base score is 5.0, reflecting a Medium severity impact. The attack requires low privileges, has low complexity, and does not require user interaction. The Scope metric is set to Changed ('C') because the vulnerability allows an attacker to pivot from the Open WebUI web application container into the secondary system of the internal host or metadata services.

While there is no integrity or availability impact, the confidentiality impact is significant when deployed in multi-tenant environments or cloud infrastructure where local endpoints contain operational keys or configuration details. This makes the vulnerability an attractive tool for initial reconnaissance and cloud-pivoting strategies.

Remediation and Architectural Defense

The complete remediation of this issue requires upgrading Open WebUI to version v0.11.1 or above. This release integrates socket-level and connection-level safety adaptors, ensuring every destination in a redirection chain is inspected before data is transferred.

However, a critical architectural dependency exists for deployments running behind a forward proxy. When Open WebUI is configured to route all outbound requests through an upstream forward proxy (such as Squid or an enterprise egress gateway), the connection-level socket checks in _SSRFSafeConnector and _SSRFSafeAdapter will only observe the IP address of the proxy server.

Because the destination IP lookups are delegated to the proxy, the internal connection-level validation cannot verify the actual target destination. In such environments, administrators must implement egress firewall rules and host filters directly on the forward proxy server. This defense-in-depth approach ensures that the proxy rejects requests targeting local IP networks, loopback interfaces, or restricted cloud endpoints.

Technical Appendix

CVSS Score
5.0/ 10
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:N/A:N

Affected Systems

Open WebUI v0.9.5 through v0.11.0 deployments

Affected Versions Detail

Product
Affected Versions
Fixed Version
open-webui
open-webui
>= 0.9.5, < 0.11.1v0.11.1
AttributeDetail
CWE IDCWE-918
Attack VectorNetwork (AV:N)
CVSS Score5.0
ImpactLow Confidentiality / Information Disclosure
Exploit StatusProof of Concept (PoC)
CISA KEV StatusNot Listed
Ransomware UseNo Known Association

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1005Data from Local System
Collection
CWE-918
Server-Side Request Forgery (SSRF)

The web application receives a URL or similar vector from an upstream source and retrieves the contents of this URL without verifying the destination belongs to an allowed host or IP range.

Vulnerability Timeline

Core fix committed and merged in Pull Request #27823
2026-08-25
GitHub Security Advisory GHSA-5x7x-4c3c-qf5w published
2026-09-09
CVE-2026-88001 assigned and published
2026-09-09
Open WebUI v0.11.1 containing the security patch released
2026-09-09

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•34 minutes ago•CVE-2026-62683
3.1

CVE-2026-62683: Incorrect Authorization via Stale Public Shares in File Browser

File Browser versions prior to 2.63.17 contain an authorization and state-management flaw in the BoltDB storage backend. When an authenticated user deletes a shared directory via an HTTP request with a trailing slash (e.g., DELETE /api/resources/a/), the share cleanup routine queries the database index using the unnormalized path before stripping the trailing slash. Because canonical share paths are stored without trailing slashes (e.g., /a), the database prefix query fails to match the parent directory share record. If a directory with the same name is later recreated, the dormant public share hash automatically reactivates and exposes the new directory contents to unauthenticated users.

Alon Barad
Alon Barad
1 views•10 min read
•about 2 hours ago•CVE-2026-62297
7.5

CVE-2026-62297: Uncontrolled Memory Allocation and Denial of Service in ag-psd

An uncontrolled memory allocation vulnerability exists in ag-psd versions prior to 31.0.0. When parsing Adobe Photoshop Document (PSD) files, the readPsd() function reads image dimensions and color depth directly from the file header and allocates off-heap typed arrays without validating whether the requested memory size is proportional to the input stream or bounded by operational thresholds. An unauthenticated attacker can supply a crafted 52-byte PSD payload that triggers an immediate 3.35 GB memory allocation, resulting in process termination via the operating system Out-Of-Memory (OOM) killer.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 3 hours ago•CVE-2026-126297
7.5

CVE-2026-126297: Algorithmic Complexity Denial of Service in NLTK ConllCorpusReader

CVE-2026-126297 (GHSA-v8f3-6phw-6mh9) is an uncontrolled resource consumption and algorithmic complexity vulnerability in the Natural Language Toolkit (NLTK) prior to version 3.10.4. Located in the Semantic Role Labeling (SRL) parser within `nltk/corpus/reader/conll.py`, the flaw allows an attacker to trigger quadratic O(N^2) CPU processing overhead by providing crafted CoNLL-formatted corpus inputs containing decoy span columns or nested full-width verb spans. Applications parsing untrusted linguistic corpora can experience prolonged CPU exhaustion and application-level Denial of Service (DoS).

Amit Schendel
Amit Schendel
3 views•12 min read
•about 4 hours ago•CVE-2026-126298
7.5

CVE-2026-126298: Quadratic Algorithmic Complexity Denial of Service in NLTK Tree.chomsky_normal_form

CVE-2026-126298 (also tracked as GHSA-r53h-rw34-8h97) is an algorithmic complexity Denial of Service (DoS) vulnerability in the Natural Language Toolkit (NLTK) Python library affecting all versions prior to 3.10.4. The vulnerability resides in the nltk.tree.transforms.chomsky_normal_form function and its corresponding public method Tree.chomsky_normal_form(). When transforming a parse tree into Chomsky Normal Form using the default right-factoring strategy, the function repeatedly invokes list.pop(0) inside a loop iterating over all children of a node. In CPython, removing the initial element of a standard list requires an O(N) memory shift operation, causing the overall binarization algorithm to degrade to O(N^2) quadratic time complexity relative to the width of a node. Furthermore, converting horizontal node width into vertical tree depth bypasses initial parsing depth bounds, triggering subsequent stack exhaustion (RecursionError) when recursive methods traverse the mutated structure. Unauthenticated remote attackers who can submit bracketed tree strings to applications invoking this transformation can exhaust single-threaded CPU resources or induce unhandled application exceptions.

Alon Barad
Alon Barad
6 views•12 min read
•about 5 hours ago•CVE-2026-126299
7.5

CVE-2026-126299: Quadratic Algorithmic Complexity Denial of Service in NLTK CCG Lexicon Parser

An algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) before version 3.10.4 allows remote unauthenticated attackers to cause a denial of service via crafted Combinatory Categorial Grammar (CCG) lexicon strings. The parser in nltk.ccg.lexicon.fromstring performs repeated immutable string slicing, concatenation, and regex tail capturing, resulting in O(n^2) CPU consumption when processing wide, flat category definitions.

Alon Barad
Alon Barad
5 views•10 min read
•about 6 hours ago•CVE-2026-126295
7.1

CVE-2026-126295: Path Traversal and Unconfined File Access in NLTK BllipParser

CVE-2026-126295 (also tracked as GHSA-fg9w-wfp5-j933) is a path confinement bypass vulnerability in the Natural Language Toolkit (NLTK) affecting versions 3.10.0 prior to 3.10.4. The flaw resides in nltk/parse/bllip.py within the BllipParser class and its factory method BllipParser.from_unified_model_dir(). Unlike sibling tool wrappers in NLTK that enforce data-root confinement via the nltk.pathsec module, BllipParser passes caller-supplied filesystem paths directly into the third-party bllipparser native C extension without validation. When an application passes untrusted input as model paths or directories to BllipParser, an attacker can force the native extension to open arbitrary files on the local filesystem. This leads to information disclosure through parser diagnostic oracles, local model tampering via shared directories, and denial of service by hanging worker threads on blocking special files (such as FIFOs or device nodes) or exhausting memory via oversized files.

Amit Schendel
Amit Schendel
2 views•11 min read