/

CVE-2026-29193

Severity:

HIGH RISK

(8.2)

Authentication Bypass in ZITADEL Login V2 UI

CVE-2026-29193

Analyzed

Vulnerability type

Category:

Authentication Bypass

CWE:

CWE-287

Impact:

Policy Bypass and Unauthorized Account Creation

Severity:

HIGH RISK

(8.2)

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 flaw in ZITADEL's Login V2 user interface allowed users to bypass organization-level login behavior and security policies.

Under certain conditions, users could self-register new accounts or authenticate with a password even when these options were explicitly disabled by configuration.

Affected context

This vulnerability affects ZITADEL instances using the Login V2 UI where organizations rely on centrally configured login behavior and security policies to control how users authenticate and onboard.

The issue manifests when UI-driven flows are not fully bound to backend-enforced policies, allowing the front-end login experience to expose functionality (such as password login or self-registration) that an organization believes to be disabled.

The risk is most pronounced in multi-tenant or tightly regulated environments where strict policy enforcement around account creation and allowed authentication methods is critical.

Exploit preconditions

  • Attack surface: Public-facing ZITADEL Login V2 UI exposed to end users or the internet.
  • Required access: No prior authentication is required; any unauthenticated user interacting with the login UI may attempt to exploit the behavior.
  • Trigger point: Interaction with the login or registration flows in the Login V2 interface, where UI logic fails to honor disabled features such as self-registration or password-based login.
  • Why exploitation is possible: The enforcement of account creation and authentication method policies is not consistently applied across the UI flow and backend, allowing UI-triggered operations that contradict organization configuration.

Why this happens

The underlying issue maps to CWE-287: Improper Authentication, specifically around incomplete enforcement of authentication and onboarding policies.

Instead of treating organization policies as authoritative at every decision point, the system allowed certain login or registration actions to proceed based on UI flow behaviors that did not fully re-check or respect those policies.

This pattern reflects a classic trust-in-UI or partial server-side validation problem: the backend did not strictly gate account creation or password login against the configured policy in all code paths, enabling bypass of intended security controls.

Potential impact

  • Users may create new accounts in organizations that intended to fully disable self-registration.
  • Users may authenticate using password-based login even when the organization requires stronger or alternative authentication methods.
  • Organizations may experience unauthorized or unexpected user onboarding, increasing account sprawl and regulatory exposure.
  • Security policies around authentication may be undermined, weakening assurance around how users gain access to protected resources.
  • In multi-tenant setups, tenants could unknowingly permit access methods they explicitly configured to be prohibited.

General mitigation guidance

Mitigation centers on making policy enforcement authoritative on the server side and ensuring that all login and registration flows are consistently guarded by the same rules.

Recommended secure patterns include:

  • Enforcing organization authentication and registration policies in a central backend layer that every login/registration path must pass through, regardless of UI behavior.
  • Treating UI configuration as cosmetic only; all effective decisions about whether a login method or self-registration is allowed should be validated server-side.
  • Implementing clear separation between feature toggles and policy enforcement, ensuring that disabling a feature in configuration reliably blocks it across all flows.
  • Designing authentication endpoints so that they require explicit confirmation that an organization policy permits the requested operation (e.g., password login or self-registration) before proceeding.
  • Applying least-privilege principles to onboarding: default to denying new account creation unless an explicit policy allows it.

How teams detect issues like this

Detection of similar issues typically involves a combination of code, configuration, and behavioral analysis:

  • Static analysis and code review: Look for authentication and registration flows where policy checks are performed in the UI or in only some backend routes, and ensure there is a single source of truth for policy enforcement.
  • Policy consistency checks: Implement automated tests that verify organization-level settings (e.g., "disable self-registration", "disable password login") are honored across all public authentication endpoints.
  • Security regression tests: Add test cases that simulate disabled features and confirm that no UI or API path allows them to be used.
  • Logging and monitoring: Monitor logs for events that should be impossible under the current configuration, such as account creation events when self-registration is disabled or password logins when those methods are configured off.
  • Automated tooling: Integrate CI/CD checks or automated review tools that scan for multiple authentication entry points and verify they all rely on the same central policy-evaluation mechanisms.

Sources

SourceLink
github.comgithub.com/zitadel/zitadel/security/advisories/GHSA-25rw-g6ff-fmg8

Frequently asked

questions

The vulnerability is highly exploitable in environments using the Login V2 UI, as it can be triggered by any user interacting with the public login page where misaligned UI and backend policy enforcement exist.

No prior account or special privileges are required. An unauthenticated user can attempt to register or sign in with password through the affected login UI flows.

Make organization policies the single source of truth enforced at the backend for every authentication and registration action, and treat front-end controls as non-authoritative hints rather than security gates.

Adopt a design where all security-sensitive operations are validated server-side against centralized policy, add automated tests around disabled authentication features, and routinely review new UI flows to ensure they cannot introduce alternate, unguarded paths into authentication and onboarding logic.

Find out what's already
exploitable in your codebase.