/

CVE-2026-34044

Severity:

HIGH RISK

(7.7)

Insecure Direct Object Reference (CWE-639) in Coolify Logs

CVE-2026-34044

Deferred

Vulnerability type

Category:

Broken Access Control / IDOR

CWE:

CWE-639

Impact:

Cross-tenant Data Exposure

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

Coolify's logging component previously resolved resources by UUID without restricting the lookup to the currently authenticated team.

An authenticated user who knows or can guess another team's resource UUID could access logs for applications they do not own, exposing sensitive operational data.

Affected context

This vulnerability appears in Coolify deployments where multiple teams share the same Coolify instance and resources are identified by UUIDs.

The Logs::mount() component performs lookups based solely on a provided UUID and does not consistently enforce team scoping when resolving which logs to display.

As a result, tenant isolation assumptions can break down when users can control or manipulate the UUID parameter used for log retrieval.

Exploit preconditions

  • Attack surface: Authenticated web interface or API endpoints that invoke Logs::mount()
  • Required access: A valid Coolify user account in any team on the instance
  • Trigger point: Supplying a UUID of a resource (such as an application) that belongs to another team when requesting logs
  • Why exploitation is possible: The authorization logic checks only that the UUID corresponds to an existing resource and does not consistently verify that the resource's owning team matches the requester's team

Why this happens

The core issue is an insecure direct object reference (IDOR) where authorization is tied to an identifier (UUID) that the client can influence.

The Logs::mount() component trusts the provided UUID to decide which resource's logs to show but does not consistently assert that the current user's team is the owner of that resource.

This aligns with CWE-639: Authorization Bypass Through User-Controlled Key, where access control is incorrectly enforced by assuming that possession of an identifier implies permission to access the referenced object.

Potential impact

  • Unauthorized viewing of application logs belonging to other teams
  • Exposure of sensitive information such as stack traces, internal URLs, access tokens, API keys, or credentials inadvertently logged
  • Leakage of deployment patterns, infrastructure details, and operational metadata across tenants
  • Increased ability for an attacker to perform targeted attacks using insights learned from another team's logs

General mitigation guidance

Effective mitigation focuses on enforcing authorization at the object level and binding access checks to tenant or ownership context.

Common defensive patterns include:

  • Scoping all resource lookups by both identifier and owner, such as WHERE uuid = ? AND team_id = ?, so that cross-team access fails by default
  • Centralizing authorization checks in a reusable layer or policy that must be satisfied before any logs or resource data are returned
  • Treating all client-supplied identifiers as untrusted and verifying that each resolved object is associated with the current user's team or permissions
  • Designing multi-tenant boundaries so that tenant context is derived from the authenticated session rather than from user-supplied parameters
  • Applying the principle of least privilege for application roles, ensuring users can access only logs strictly required for their responsibilities

How teams detect issues like this

Organizations can detect and prevent similar issues using a combination of review and automated checks:

  • Static analysis: Look for code paths where objects (e.g., applications, logs, resources) are fetched by identifiers without an accompanying ownership or tenant constraint
  • Code review: Pay special attention to multi-tenant logic, verifying that every resource query includes team, tenant, or ownership checks and that these checks cannot be bypassed with crafted identifiers
  • Access control policies: Enforce consistent authorization rules at the controller or middleware level, ensuring log access is always bound to the authenticated user's team
  • Logging and monitoring: Monitor for unusual access patterns, such as a single account requesting logs for many different UUIDs or cross-team resource access attempts
  • Automated tools: Use application security testing tools capable of detecting IDOR and broken access control by fuzzing identifiers and verifying isolation boundaries

Sources

SourceLink
github.comgithub.com/coollabsio/coolify/commit/6fbb5e626a82c576ae7a1a08b4e1d16aee2e82ed
github.comgithub.com/coollabsio/coolify/releases/tag/v4.0.0-beta.466
github.comgithub.com/coollabsio/coolify/security/advisories/GHSA-565g-9j4m-wqmr

Frequently asked

questions

Yes, but only by authenticated users. An attacker must have a valid Coolify account on the instance to exploit the issue.

No elevated privileges are strictly required. A regular user in any team can potentially access another team's logs if they know or can obtain the target resource's UUID.

The safest pattern is to ensure that every lookup of logs or resources is scoped by both the identifier and the owning team or tenant, enforcing authorization checks in a centralized, reusable layer rather than per-call ad hoc logic.

Adopt a consistent access control model where tenant context comes from the authenticated session, treat all client-supplied identifiers as untrusted, require explicit ownership checks for every object access, and validate these patterns through regular security-focused code reviews and automated testing.

Find out what's already
exploitable in your codebase.