/

CVE-2026-55672

Severity:

HIGH RISK

(7.4)

OAuth Client Confusion (CWE-287) in ZITADEL Flows

CVE-2026-55672

Deferred

Vulnerability type

Category:

Authentication and Authorization Logic Flaw

CWE:

CWE-287, CWE-863

Impact:

Unauthorized Access to OAuth-Protected Resources

Severity:

HIGH RISK

(7.4)

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

ZITADEL's OAuth2 and OIDC token flows fail to consistently verify that the client exchanging an authorization code or refresh token is the same client that initiated the authorization.

Under these conditions, intercepted grants or refresh tokens can be replayed and successfully exchanged under a different client, potentially enabling unauthorized access to protected resources.

Affected context

This vulnerability appears in ZITADEL's OAuth2 and OIDC implementations where authorization codes, refresh tokens, and device tokens are exchanged for access tokens.

It is relevant in deployments that:

  • Support authorization code, refresh token, or device flows
  • Rely on client identifiers and secrets for token exchange
  • Operate in environments where network interception, logging, or proxying of tokens is possible

The risk manifests when the server does not strictly bind a grant or token to the originating client during the exchange step.

Exploit preconditions

  • Attack surface: OAuth2/OIDC token endpoints handling CodeExchange, RefreshToken, or device token flows
  • Required access: Ability to obtain or intercept valid authorization codes, refresh tokens, or device tokens issued to some client
  • Trigger point: Submitting the intercepted grant or token to the token endpoint from a different, attacker-controlled client
  • Why exploitation is possible: The server does not fully enforce that the client performing the token exchange is the same client that initiated the original authorization, allowing cross-client token reuse.

Why this happens

The underlying issue is an authentication and authorization logic flaw in client binding during OAuth2/OIDC token exchanges.

Instead of strictly validating that the client identifier (and associated credentials) match the client recorded for the original authorization request, the implementation allows grants or refresh tokens to be redeemed by a different client.

This maps to:

  • CWE-287: Improper Authentication, because the platform fails to robustly authenticate the client as the rightful owner of the grant.
  • CWE-863: Improper Authorization, since a client is permitted to access functionality (token redemption) using tokens it was not originally authorized to use.

Conceptually, the bug represents missing or incomplete correlation between the session state of the authorization flow and the client identity at the exchange step.

Potential impact

  • Attackers may obtain access tokens tied to another client's authorization flows.
  • Unauthorized clients could access user data or APIs protected by ZITADEL-issued tokens.
  • Compromise of confidentiality for resources scoped to the misused tokens.
  • Potential lateral movement if tokens grant broad permissions or administrative access.
  • Erosion of trust in the identity platform's token isolation and client boundary guarantees.

General mitigation guidance

Effective mitigation typically focuses on hardening client binding and authorization logic within OAuth2/OIDC flows.

Common defensive patterns include:

  • Strictly associating authorization codes, refresh tokens, and device tokens with the originating client and persisting this binding in server-side state.
  • Enforcing verification at the token endpoint that the requesting client identifier (and credentials, where applicable) match the client recorded for the grant.
  • Designing flows to minimize token exposure (e.g., limiting where tokens are logged, stored, or transmitted) and reducing opportunities for interception.
  • Applying least-privilege principles to scopes and token lifetimes so that misuse of a single token yields limited access.
  • Implementing secure-by-default behaviors in OAuth/OIDC libraries and abstractions, making correct client binding and validation automatic rather than optional.

How teams detect issues like this

Detection approaches can combine protocol-aware analysis with code-level review:

  • Code review signals: Examine token exchange handlers to confirm that client identifiers are consistently validated against stored authorization session data; look for flows where the client from the original authorization is not explicitly checked.
  • Static analysis patterns: Flag endpoints that process authorization codes, refresh tokens, or device tokens without correlating them to a bound client ID, or that rely solely on token contents without server-side state verification.
  • Policy enforcement: Define security requirements for OAuth/OIDC flows (e.g., "all grants must be bound to a single client and checked at redemption time") and enforce them via architectural reviews and CI checks.
  • Runtime monitoring: Analyze token issuance and redemption logs for anomalous patterns, such as grants created under one client but redeemed under another, even if the platform currently permits it.

Some automated security testing tools with protocol support can help simulate cross-client token redemption attempts and highlight missing validation.

Sources

SourceLink
github.comgithub.com/zitadel/zitadel/commit/562403079a98cf2059cdac11865a45e2f285be71
github.comgithub.com/zitadel/zitadel/commit/5b1708e0e650398f0ebc3341714f0798b0118917
github.comgithub.com/zitadel/zitadel/releases/tag/v3.4.12
github.comgithub.com/zitadel/zitadel/releases/tag/v4.15.2
github.comgithub.com/zitadel/zitadel/security/advisories/GHSA-xqxv-4jc2-x56x

Frequently asked

questions

Exploitability depends on an attacker's ability to obtain or intercept valid authorization codes, refresh tokens, or device tokens. In environments with strict transport security and limited token exposure, the practical risk is reduced, but any mechanism that exposes tokens (logging, debugging, proxies) can expand the attack surface.

The attacker needs access to valid grants or refresh tokens originally issued to some client. They do not necessarily need control of that client, but they do need a way to redeem the token through a different client under their control, typically by interacting with the token endpoint.

The robust fix pattern is to tightly bind every authorization code, refresh token, and device token to the originating client and enforce this binding at every redemption step. The server must verify that the client exchanging the token matches the stored client identity associated with the grant, rejecting any cross-client use.

Organizations can adopt secure-by-default OAuth/OIDC libraries that enforce proper client binding, codify security requirements for token flows, and subject identity-related endpoints to targeted security reviews. Additionally, they should minimize token exposure, apply least privilege to scopes and lifetimes, and integrate protocol-focused testing or security tooling that checks for token misbinding vulnerabilities.

Find out what's already
exploitable in your codebase.