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.

