/

CVE-2026-54322

Severity:

HIGH RISK

(7.7)

Authorization Bypass (CWE-639) in Daytona Org Roles

CVE-2026-54322

Deferred

Vulnerability type

Category:

Authorization Bypass / Insecure Direct Object Reference

CWE:

CWE-639, CWE-862

Impact:

Cross-organization privilege modification and role deletion

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

Daytona's organization role management endpoints allowed authenticated organization owners to update or delete roles across organizational boundaries by referencing role IDs directly.

If an attacker knows or can guess a role identifier from another organization, they can modify that role's permissions or delete it, leading to unauthorized privilege changes.

Affected context

This vulnerability occurs in Daytona's multi-tenant organization and role management API, where roles are globally addressable by identifier and role mutations are performed using that identifier alone.

It is relevant when:

  • Organizations are self-service and users can become owners of at least one organization.
  • Role update/delete endpoints trust the caller's ownership of the organization in the request path, but do not verify that the referenced role ID belongs to that organization.
  • Role identifiers are discoverable, guessable, or exposed through other parts of the system.

Exploit preconditions

  • Attack surface: Organization role update and delete API endpoints.
  • Required access: Authenticated user account that owns at least one organization in Daytona.
  • Target knowledge: The attacker must know or obtain the identifier of a role belonging to a different organization.
  • Trigger point: Sending update or delete requests that specify an organization in the path but a role ID that actually belongs to another organization.
  • Why exploitation is possible: The authorization check validates that the caller owns the organization named in the path, but the subsequent role lookup and mutation are performed solely by role ID, without confirming that the role is scoped to that organization.

Why this happens

The underlying bug is an access control flaw where object-level authorization is performed against one resource (the organization) while the actual mutation targets a different resource (the role) that is not properly constrained to the organization.

This maps to CWE-639: Insecure Direct Object Reference, because the API accepts a direct role identifier from the client and operates on that object without ensuring it belongs to the organization tied to the caller's permissions.

It is closely related to CWE-862: Missing Authorization, since the system does not perform a dedicated authorization check for the specific role object being modified or deleted.

Abstractly, this pattern arises whenever multi-tenant resources are globally referenceable and the authorization logic validates only the container context, not the relationship between the referenced ID and that container.

Potential impact

  • An attacker may modify permissions associated with roles in other organizations.
  • An attacker could delete roles in a victim organization, disrupting access control configurations.
  • Privilege escalation may occur if an attacker elevates capabilities on roles they do not own.
  • Organizations can experience loss of role integrity, leading to misconfigured or overly permissive access policies.
  • Cross-tenant impact can arise in shared deployments, undermining isolation between organizations.

General mitigation guidance

Mitigation typically focuses on enforcing strict object-to-tenant binding and validating authorization against the specific resource being changed, not just its container.

Recommended design and coding patterns include:

  • Scope all role identifiers to their owning organization and avoid globally addressable IDs for tenant-scoped objects.
  • When handling update or delete requests, verify that the role belongs to the organization indicated in the path or token claims before performing any mutation.
  • Implement a consistent authorization layer that checks both the actor's permissions and the resource's tenancy, avoiding ad hoc checks per endpoint.
  • Minimize exposure of internal identifiers and avoid predictable ID schemes where possible.
  • Apply least-privilege principles to organization owners, ensuring that role management operations are explicitly constrained to their own organization.

How teams detect issues like this

High-level detection approaches for this class of vulnerability include:

  • Static analysis rules and security linters that flag direct use of client-supplied object IDs (e.g., role_id) without accompanying tenant or ownership checks.
  • Code review practices that require verifying resource-tenant associations in all multi-tenant CRUD endpoints and discouraging global lookups by ID alone.
  • Authorization policy engines (e.g., centralized access control services) that express rules in terms of both subject and resource tenancy, and can be tested with negative cases.
  • Automated tests that exercise cross-tenant scenarios, attempting to operate on resources from other organizations using valid credentials for a different tenant.
  • Logging and anomaly detection around role management operations, highlighting attempts to modify or delete roles outside the caller's own organization.

Sources

SourceLink
github.comgithub.com/daytonaio/daytona/security/advisories/GHSA-qxvm-pcfm-qc39

Frequently asked

questions

Exploitation is limited to authenticated users who own at least one organization and can obtain role identifiers from other organizations. However, within that scope it enables cross-tenant manipulation of access control, which can be severe in shared deployments.

The attacker must be an authenticated Daytona user with ownership rights over at least one organization. They also need knowledge of a target role's identifier from another organization, which might be obtained through API responses, logs, or guessable ID patterns.

The safest approach is to enforce object-level authorization that validates both the caller's permissions and the specific role's association with the organization. Role lookups should be performed in the context of the organization, and operations should fail if the role does not belong to that organization.

Future prevention relies on adopting a consistent authorization model for multi-tenant resources, including:

  • Designing APIs so that resource identifiers are always resolved in a tenant-scoped context.
  • Using centralized policy enforcement that encodes tenant boundaries and object relationships.
  • Incorporating cross-tenant negative tests and automated security checks into CI pipelines to catch missing or mis-scoped authorization early in development.
Find out what's already
exploitable in your codebase.