Skip to main content

Open WebUI EUVDEUVD-2026-52887

| CVE-2026-70482 HIGH
Improper Authentication (CWE-287)
2026-08-04 https://github.com/open-webui/open-webui GHSA-rq84-p6rr-vf89
8.1
CVSS 3.1 · Vendor: https://github.com/open-webui/open-webui
Share

Severity by source

Vendor (https://github.com/open-webui/open-webui) PRIMARY
8.1 HIGH
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:N
vuln.today AI
8.1 HIGH

Network-accessible endpoint needs no Open WebUI privileges (PR:N), but victim must actively authenticate to attacker's OAuth app (UI:R); full account takeover drives C:H and I:H with no availability impact described.

3.1 AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:N
4.0 AV:N/AC:L/AT:P/PR:N/UI:A/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (https://github.com/open-webui/open-webui).

CVSS VectorVendor: https://github.com/open-webui/open-webui

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
Required
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
None

Lifecycle Timeline

3
Source Code Evidence Fetched
Aug 04, 2026 - 20:17 vuln.today
Analysis Generated
Aug 04, 2026 - 20:17 vuln.today
CVE Published
Aug 04, 2026 - 19:52 github-advisory
HIGH 8.1

DescriptionCVE.org

Summary

The OAuth token exchange endpoint accepts a raw provider access token and validates it by calling the provider's userinfo endpoint. A userinfo endpoint reports only that a token is valid, never which OAuth client it was issued to, and the endpoint performed no audience or client check of its own. Anyone holding an access token minted for any client registered with the same provider could exchange it for an Open WebUI session as that token's user, including applications the operator does not control and has never authorised.

Preconditions

  • ENABLE_OAUTH_TOKEN_EXCHANGE=True. Disabled by default, so a stock deployment is not affected.
  • The victim already has an Open WebUI account. The endpoint does not create users.
  • The attacker can obtain a provider access token for the victim, typically by having them sign in to an unrelated OAuth application on the same provider. On public providers, registering that application is self-service.
  • The subject identifier the attacker's client observes matches the one stored on the victim's account. Google, GitHub, Okta and self-hosted OIDC servers in default configuration issue a subject that is stable across all clients and are directly affected. Microsoft Entra ID issues per-application subjects, so the match fails there unless OAUTH_MERGE_ACCOUNTS_BY_EMAIL is enabled or OAUTH_SUB_CLAIM points at a globally stable claim such as oid.
  • OAUTH_ALLOWED_DOMAINS is enforced on this endpoint but does not constrain the attack, because the impersonated user is a legitimate member of an allowed domain.

Impact

Full account takeover of any user whose provider access token the attacker can obtain. The endpoint applies no role gating, so the issued session carries the target account's role, and a targeted administrator yields an administrator session. The victim never interacts with Open WebUI and has no opportunity to notice.

The standard OAuth callback is not affected. It obtains its token through an authorization-code exchange authenticated with the client secret, so the token is inherently bound to Open WebUI's own client, and the ID token's audience is validated.

Fix

Fixed in 0.11.0. The endpoint now resolves which OAuth client a presented token was issued to through RFC 7662 token introspection, and rejects tokens minted for any client not named in OAUTH_TOKEN_EXCHANGE_TRUSTED_CLIENT_IDS. Only the introspected client_id is honoured; the aud field is ignored, because it names intended resource servers rather than the issuing client and several providers let any client place another client's identifier there.

Upgrading alone is not sufficient. The check is opt-in: with OAUTH_TOKEN_EXCHANGE_TRUSTED_CLIENT_IDS unset the endpoint behaves as it did before, so any deployment running with ENABLE_OAUTH_TOKEN_EXCHANGE=True must also set that list. It is a deploy-time environment variable and cannot be changed from the admin interface, so a compromised administrator session cannot widen the trust boundary at runtime.

Providers that do not implement RFC 7662 introspection, including Google, Microsoft Entra ID, GitHub and Feishu, cannot be restricted this way at all. On those, token exchange has no safe configuration and should be left disabled.

Root cause

  • backend/open_webui/routers/auths.py, token_exchange (POST /api/v1/auths/oauth/{provider}/token/exchange)

Token exchange skips the authorization-code step entirely and trusts a token supplied by the caller. The only validation performed was a userinfo lookup, which answers whether a token is valid rather than who issued it, so the endpoint had no way to distinguish a token minted for Open WebUI from one minted for an unrelated application.

Proof of concept

Reproduced against a mock OIDC provider serving two tokens for the same end user, minted for two different clients, with OAUTH_ALLOWED_DOMAINS=corp.example actively enforced.

CaseTokenResult
Controlnot recognised by the provider400 rejected
Outsider's own account, non-allowed domainminted for attacker-evil-app403 blocked by domain allowlist
Victim's account, foreign clientminted for attacker-evil-app200, session issued for victim@corp.example

The issued session token was confirmed usable: GET /api/v1/auths/ returned 200 authenticated as the victim. The provider log recorded the token as minted for client_id='attacker-evil-app', while Open WebUI's own client is openwebui-client-id.

Credits

Reported by @Classic298.

AnalysisAI

OAuth token exchange in Open WebUI 0.8.0-0.10.x enables full, silent account takeover when ENABLE_OAUTH_TOKEN_EXCHANGE=True because the endpoint accepted provider access tokens minted for any OAuth client without verifying the issuing client identity. The endpoint validated tokens exclusively via the provider's userinfo endpoint, which confirms token validity but never returns the client a token was issued to, allowing an attacker who captures a victim's token from any co-registered application to exchange it for a valid Open WebUI session - including administrator sessions with no role gating. A proof-of-concept is confirmed by the upstream advisory; no active exploitation is recorded in CISA KEV, and the CVSS 8.1 score reflects high confidentiality and integrity impact tempered by a required victim interaction step.

Technical ContextAI

The flaw resides in backend/open_webui/routers/auths.py within the token_exchange function at POST /api/v1/auths/oauth/{provider}/token/exchange, confirmed by commit diffs reviewed in GHSA-rq84-p6rr-vf89. The affected package is pkg:pip/open-webui versions 0.8.0 through 0.10.x. The root cause is CWE-287 (Improper Authentication): the OAuth token exchange flow deviated from the security model of the standard authorization-code flow, which binds tokens to Open WebUI's own client via client-secret-authenticated code exchange and ID token audience validation. The exchange endpoint instead trusted a caller-supplied access token based solely on a userinfo lookup - a call that answers only whether the token is currently valid, not which OAuth client it was issued to. RFC 7662 token introspection, the standards-defined mechanism for resolving the client_id a token was minted for, was entirely absent before 0.11.0. Identity providers issuing stable subject identifiers (sub claims) across all clients - Google, GitHub, Okta, and self-hosted OIDC in default configuration - are directly exploitable because the subject any client observes matches the subject stored in the victim's Open WebUI account. Microsoft Entra ID issues per-application subjects by default and resists the attack unless OAUTH_MERGE_ACCOUNTS_BY_EMAIL=True or OAUTH_SUB_CLAIM is pointed at a globally stable claim such as oid.

RemediationAI

Upgrade to Open WebUI 0.11.0 using the patched commits b190dcf3caa00dc8b7b9c7312828298d9143f60d and c4332be71e6e9c314e8a13b9d2819a6932561630 (https://github.com/open-webui/open-webui/releases/tag/v0.11.0); however, upgrading alone is insufficient. Any deployment running with ENABLE_OAUTH_TOKEN_EXCHANGE=True must also set the OAUTH_TOKEN_EXCHANGE_TRUSTED_CLIENT_IDS environment variable to the explicit list of OAuth client IDs authorized to exchange tokens - without this list, 0.11.0 behaves identically to the vulnerable versions. This variable is deploy-time only and cannot be set from the admin interface, which means a compromised administrator session cannot widen the trust boundary at runtime. Critically, providers that do not implement RFC 7662 token introspection - confirmed to include Google, GitHub, Microsoft Entra ID, and Feishu - cannot be restricted via OAUTH_TOKEN_EXCHANGE_TRUSTED_CLIENT_IDS at all; for those providers the only safe remediation is ENABLE_OAUTH_TOKEN_EXCHANGE=False. If immediate upgrade is not possible, disabling the token exchange feature via ENABLE_OAUTH_TOKEN_EXCHANGE=False eliminates all exposure with zero impact on the standard OAuth authorization-code callback flow, which is architecturally unaffected.

Share

EUVD-2026-52887 vulnerability details – vuln.today

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy