/

CVE-2026-44671

Severity:

HIGH RISK

(7.5)

LDAP Injection in ZITADEL LDAP Identity Provider

CVE-2026-44671

Analyzed

Vulnerability type

Category:

LDAP Injection

CWE:

CWE-90

Impact:

Information Disclosure and Account Enumeration

Severity:

HIGH RISK

(7.5)

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 LDAP identity provider contained an LDAP filter injection flaw where user-supplied usernames were inserted into LDAP search filters without proper escaping.

During login, an unauthenticated attacker could abuse LDAP metacharacters to perform blind LDAP injection, enabling systematic enumeration of valid usernames and extraction of sensitive directory attributes without fully bypassing authentication.

Affected context

The vulnerability affects ZITADEL deployments that:

  • Use the LDAP identity provider integration for user authentication
  • Construct LDAP search filters from raw user-supplied usernames
  • Rely on LDAP search results and error conditions to drive login flow behavior

It primarily manifests during the login process when ZITADEL queries the connected LDAP directory to resolve the provided username.

Exploit preconditions

  • Attack surface: Public-facing authentication endpoints that invoke the LDAP identity provider.
  • Required access: No prior authentication; attacker only needs network access to the login interface.
  • Trigger point: Submission of crafted usernames containing LDAP filter metacharacters (e.g., *, (, )) during the login flow.
  • Why exploitation is possible: The username is concatenated directly into the LDAP search filter string without proper escaping or encoding, allowing an attacker to alter the structure and logic of the underlying LDAP query and infer data through response differences.

Why this happens

The root cause is improper neutralization of special elements used in an LDAP query, consistent with CWE-90: Improper Neutralization of Special Elements used in an LDAP Query ('LDAP Injection').

Instead of treating the username strictly as data, the implementation interpolates it directly into an LDAP filter expression, enabling user input to influence the query's control syntax.

This pattern is analogous to other injection classes: untrusted input is mixed with query logic, without using parameterization or context-appropriate escaping routines for LDAP filters.

Potential impact

  • Enumeration of valid usernames in the connected LDAP directory via blind behavior differences.
  • Disclosure of sensitive LDAP attributes (e.g., email addresses, department, group memberships) that can be inferred or queried through crafted filters.
  • Facilitation of targeted password guessing or credential stuffing attacks using enumerated accounts.
  • Support for follow-on attacks such as social engineering or spear-phishing, based on exposed identity data.

General mitigation guidance

Effective mitigation focuses on treating all user-controlled input as untrusted and ensuring it cannot modify LDAP query structure:

  • Use vetted LDAP APIs or helper functions that safely escape or encode user values for use in filter contexts.
  • Avoid manual string concatenation when building LDAP filters; instead, use parameterized or builder-style abstractions that keep data separate from filter logic.
  • Apply strict input validation for username fields, rejecting or normalizing unexpected control characters and metacharacters where feasible.
  • Limit the LDAP attributes returned to the minimum necessary for authentication and authorization decisions, and avoid exposing detailed error messages that leak query behavior.
  • Enforce the principle of least privilege on the LDAP bind account used by ZITADEL so that even if injection occurs, accessible data is minimized.

How teams detect issues like this

Detection typically involves both proactive code analysis and runtime observation:

  • Static analysis: Configure SAST tools or custom rules to flag LDAP filter construction that concatenates raw user input, especially around login and identity provider modules.
  • Code review signals: Look for string-based LDAP filter creation (e.g., "(&(objectClass=user)(uid=" + username + "))") and verify use of appropriate escaping utilities for each interpolated value.
  • Security testing: Perform targeted LDAP injection tests against authentication endpoints using crafted username payloads with metacharacters, observing for behavioral differences, unexpected errors, or increased response variance.
  • Logging and monitoring: Monitor authentication logs for anomalous username patterns containing LDAP metacharacters and high-frequency, low-success login attempts indicative of systematic enumeration.

Sources

SourceLink
github.comgithub.com/zitadel/zitadel/releases/tag/v3.4.10
github.comgithub.com/zitadel/zitadel/releases/tag/v4.15.0
github.comgithub.com/zitadel/zitadel/security/advisories/GHSA-rxvx-hhpj-q6px

Frequently asked

questions

No. The described issue does not in itself grant a full authentication bypass. It enables LDAP filter manipulation for information gathering and account enumeration, which can support other attacks but does not equate to direct login without valid credentials.

An attacker only needs network access to the ZITADEL login interface that uses the LDAP identity provider. No prior authentication or special privileges are required, as exploitation occurs through the public username input field.

The safest pattern is to stop building LDAP queries via string concatenation and instead use APIs that strictly separate data from query logic. All user inputs that enter LDAP filters should be passed through robust, context-appropriate escaping or parameterization routines provided by LDAP libraries.

Establish secure coding guidelines for directory integrations: always treat user input as data, use library-provided escaping functions, enforce minimal and validated inputs for identifiers such as usernames, and incorporate static analysis plus security testing focused on injection patterns into your development and CI pipelines.

Find out what's already
exploitable in your codebase.