/

CVE-2026-32131

Severity:

HIGH RISK

(7.7)

Broken Access Control / Insecure Direct Object Reference

CVE-2026-32131

Analyzed

Vulnerability type

Category:

Broken Access Control / Insecure Direct Object Reference

CWE:

CWE-639, CWE-862

Impact:

Cross-Tenant Information Disclosure

Severity:

HIGH RISK

(7.7)

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 logic flaw in the ZITADEL Management API allowed authenticated but low-privileged users to access management-plane information belonging to other organizations by supplying foreign project, grant, or application identifiers.

When a caller with read-only project- or app-level tokens specified IDs from another tenant, the API returned cross-tenant data instead of enforcing strict ownership checks, resulting in unauthorized information disclosure across organizations.

Affected context

This vulnerability manifests in ZITADEL deployments that expose the Management API to users or services holding low-privilege tokens such as:

  • project.read
  • project.grant.read
  • project.app.read

It affects environments where:

  • Multiple organizations (tenants) are hosted within the same ZITADEL instance, and
  • API consumers can directly supply project_id, grant_id, or app_id values.

Under these conditions, insufficient tenant/ownership checks on these identifiers allowed retrieval of management-plane information for resources belonging to other organizations.

Exploit preconditions

  • Attack surface: ZITADEL Management API endpoints that accept project_id, grant_id, or app_id parameters.
  • Required access: A valid authenticated session or token with low-privilege read scopes (for example, project.read, project.grant.read, or project.app.read).
  • Trigger point: Issuing Management API calls while providing identifiers (project_id, grant_id, app_id) associated with a different organization than the caller's own tenant.
  • Why exploitation is possible: The API trusted caller-supplied resource IDs and validated that the token had sufficient scope type (e.g., project read) but did not reliably verify that the referenced resource belonged to the caller's organization or tenant. This missing tenant/ownership constraint allowed cross-organization data access.

Why this happens

The underlying issue is a broken access control pattern where authorization is tied primarily to generic scopes or roles but not to the specific resource and tenant boundaries referenced in the request.

Concretely, the Management API endpoints accepted direct identifiers (project_id, grant_id, app_id) and performed permission checks that confirmed the caller had some level of project- or app-related access, yet failed to enforce that the targeted resource is owned by—or scoped to—the caller's organization. This aligns with:

  • CWE-639: Insecure Direct Object Reference (IDOR) — relying on user-controlled identifiers without robust access checks.
  • CWE-862: Missing Authorization — incomplete enforcement of authorization rules for referenced objects.

In abstract form, the bug occurs when:

  1. The system exposes stable, guessable or discoverable resource identifiers.
  2. Authorization logic verifies only that "this user can read some project or app," rather than "this user can read this specific project or app within their tenant."
  3. There is no consistent tenant isolation layer to prevent cross-organization access once a valid ID is supplied.

Potential impact

  • Unauthorized retrieval of management-plane information for projects, grants, or applications belonging to other organizations.
  • Exposure of cross-tenant metadata such as project structure, application identifiers, and granted relationships.
  • Increased reconnaissance capabilities for an attacker to map other tenants' configurations and relationships.
  • Potential assistance in chaining with other vulnerabilities or misconfigurations to escalate privileges or pivot across tenants.

General mitigation guidance

Effective mitigation focuses on enforcing strict, context-aware authorization for every resource access:

  • Enforce tenant and ownership checks: Ensure that every Management API endpoint verifies that the referenced project_id, grant_id, or app_id belongs to the caller's organization or tenant before returning any data, regardless of the user's generic scope.
  • Centralize authorization logic: Use a single, reusable authorization layer or service that consistently applies tenant isolation and resource-level checks instead of ad hoc validations scattered throughout handlers.
  • Bind tokens to tenancy context: Where possible, associate access tokens with a specific organization/tenant context and reject operations where the supplied resource identifiers do not match this context.
  • Avoid trusting client-supplied identifiers alone: Treat all object IDs in requests as untrusted input; always derive permissible resources from server-side relationships first, then intersect with client-supplied parameters.
  • Apply least privilege and scoped APIs: Design read scopes and API operations so that tokens provide access only to resources explicitly bound to the caller's organization, minimizing broad cross-resource read capabilities.

How teams detect issues like this

Organizations can detect and prevent similar issues by combining code-level and behavioral checks:

  • Static analysis and code review:
  • Flag API endpoints that accept direct object identifiers (project_id, grant_id, app_id, etc.) and verify that each call path includes explicit tenant/ownership checks.
  • Look for authorization logic that validates only roles/scopes without referencing the resource's organization or tenant fields.
  • Review data-access functions (e.g., repository or ORM methods) to ensure they always filter by tenant/organization as part of the primary query.
  • Unit and integration tests:
  • Add test cases where a user from one organization attempts to access resources belonging to another using valid but foreign IDs; assert that access is denied.
  • Include multi-tenant regression tests whenever new endpoints or scopes are introduced.
  • Runtime monitoring and logging:
  • Log Management API calls along with the caller's organization and the target resource's organization; detect mismatches as potential policy violations.
  • Use anomaly detection or SIEM rules to alert on repeated cross-tenant access attempts.
  • Automated policy enforcement:
  • Employ policy-as-code (e.g., OPA, custom authorization middleware) to define and enforce tenant isolation rules, ensuring every request passes through a consistent authorization decision point.

Sources

SourceLink
github.comgithub.com/zitadel/zitadel/releases/tag/v3.4.8
github.comgithub.com/zitadel/zitadel/releases/tag/v4.12.2
github.comgithub.com/zitadel/zitadel/security/advisories/GHSA-wr6r-59xg-4pj2

Frequently asked

questions

Exploitation is limited to authenticated users or services that already hold low-privilege read tokens for the Management API. Within that constraint, any such caller who can supply arbitrary project_id, grant_id, or app_id values could potentially retrieve information about resources owned by other organizations.

No. The issue can be triggered with low-privilege read scopes such as project.read, project.grant.read, or project.app.read. The core problem is not the strength of the scopes, but the missing verification that the referenced resources belong to the caller's organization.

Implement strict, centralized resource-level authorization that always checks both the caller's identity/tenant and the target resource's tenant or ownership before returning any data. All data-access operations should be constrained by tenant and ownership filters as part of their primary queries.

Design the system around explicit multi-tenant boundaries: bind tokens to a tenant context, enforce tenant filters in every query, treat all object IDs as untrusted, and adopt policy-as-code or centralized authorization services. Complement this with automated tests that exercise cross-tenant scenarios and code review guidelines that flag endpoints lacking explicit tenant and ownership checks.

Find out what's already
exploitable in your codebase.