/

CVE-2026-34592

Severity:

HIGH RISK

(7.7)

Improper Access Control (CWE-639) in Coolify Teams

CVE-2026-34592

Deferred

Vulnerability type

Category:

Broken Access Control / Horizontal Privilege Escalation

CWE:

CWE-639

Impact:

Unauthorized Cross-Team Resource Access

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

An improper access control issue in Coolify allows authenticated users to access servers and projects belonging to other teams by directly specifying their IDs.

When team scoping is not enforced on lookups, any logged-in user may retrieve or interact with resources outside their own team, exposing sensitive infrastructure details and management capabilities.

Affected context

This vulnerability arises in multi-team Coolify deployments where:

  • Multiple teams share the same Coolify instance
  • Server and project records are referenced by ID in API or UI interactions
  • Authorization checks do not consistently enforce that the requested resource belongs to the current team

Under these conditions, authenticated users can query or operate on resources they do not own by guessing or enumerating identifiers.

Exploit preconditions

  • Attack surface: Coolify web interface and associated API endpoints that fetch or operate on server and project entities.
  • Required access: Any authenticated Coolify account; no elevated or admin role is strictly required.
  • Trigger point: Supplying the ID of a server or project belonging to another team in requests (e.g., URL parameters, API payloads).
  • Why exploitation is possible: Authorization logic validates that the user is logged in but does not enforce resource ownership or team membership, enabling horizontal privilege escalation via ID-based lookups.

Why this happens

The core issue is a missing or incomplete authorization check when resolving resources by identifier.

Instead of verifying that the requested server or project is associated with the current user's team, the system trusts the provided ID and returns the matching entity if it exists.

This pattern maps to CWE-639: Authorization Bypass Through User-Controlled Key, where user-provided identifiers are used to select sensitive objects without validating that the requester is allowed to access them.

Potential impact

  • Unauthorized viewing of other teams' servers, applications, and database configurations
  • Access to deployment metadata, environment variables, and operational details that may contain secrets
  • Potential manipulation of other teams' projects, including start/stop, redeploy, or configuration changes, depending on exposed operations
  • Facilitation of broader compromise if infrastructure details or credentials are reused across environments

General mitigation guidance

Mitigation focuses on enforcing object-level authorization and constraining resource selection to the caller's security context.

Recommended design patterns include:

  • Always scoping queries by team or owner context (e.g., WHERE team_id = current_team_id) rather than trusting raw IDs.
  • Applying centralized authorization checks that verify resource-to-team relationships before returning or mutating objects.
  • Using opaque, non-guessable identifiers and avoiding direct numeric ID exposure where practical, while still enforcing ownership checks.
  • Designing API endpoints to derive accessible resources from the authenticated context, instead of accepting arbitrary IDs from the client.
  • Restricting sensitive operations (e.g., server management, deployment changes) with least privilege roles and explicit capability checks.

How teams detect issues like this

Detection typically involves a combination of code-level and behavioral analysis:

  • Static analysis or manual review to flag controller, route, or service methods that load resources by ID without verifying ownership or team membership.
  • Security-focused code review checklists that require explicit authorization checks on every object retrieval and mutation path.
  • Logging and monitoring of access patterns to detect cross-team resource requests or unexpected relationships between caller identity and target resource.
  • Automated tests or security regression suites that attempt horizontal privilege escalation by using resources created under one account from another.

Sources

SourceLink
github.comgithub.com/coollabsio/coolify/security/advisories/GHSA-qfcc-2fm3-9q42

Frequently asked

questions

Any authenticated user on a shared Coolify instance can potentially access other teams' servers and projects if they can obtain or guess the relevant identifiers, making it broadly exploitable in multi-tenant setups.

Only a valid Coolify login is required. The attacker does not need administrative privileges but must be able to issue requests that include server or project IDs.

Implement strict object-level authorization checks that ensure each requested server or project is validated against the current user's team context, and centralize this logic to avoid omissions.

Adopt security-by-design practices such as always scoping queries by tenant, using standardized authorization middleware, writing tests for horizontal access control, and including access-control reviews in code review and CI pipelines.

Find out what's already
exploitable in your codebase.