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.readproject.grant.readproject.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, orapp_idvalues.
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, orapp_idparameters. - Required access: A valid authenticated session or token with low-privilege read scopes (for example,
project.read,project.grant.read, orproject.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:
- The system exposes stable, guessable or discoverable resource identifiers.
- 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."
- 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, orapp_idbelongs 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.

