Summary
Coolify's web UI components accept server and destination identifiers from URL parameters without enforcing team ownership checks.
Under these conditions, a user from one team can deploy resources to infrastructure owned by another team, leading to cross-team resource manipulation and potential compromise of shared environments.
Affected context
This vulnerability arises in Coolify deployments that use the Livewire-based web UI for managing servers and deployments.
While API controllers enforce team-based ownership via Server::whereTeamId($teamId), certain Livewire components rely on server_id and destination_uuid passed through URL query parameters without equivalent checks.
In multi-team or multi-tenant setups where different teams manage their own infrastructure, this missing validation can expose one team's servers and destinations to actions initiated by another authenticated team user.
Exploit preconditions
- Attack surface: Coolify Livewire-powered web UI endpoints that accept
server_idanddestination_uuidvia query parameters. - Required access: Authenticated access to Coolify with membership in any team; no direct access to the victim team is required.
- Trigger point: Visiting or crafting URLs that embed the identifiers of servers or destinations belonging to another team and initiating deployment or management actions.
- Why exploitation is possible: The Livewire components trust the
server_idanddestination_uuidvalues from the URL without re-validating ownership against the current user's team, resulting in missing authorization checks (CWE-639, CWE-862).
Why this happens
The core issue is a mismatch in authorization enforcement between Coolify's API layer and its Livewire UI components.
API controllers correctly constrain operations to resources owned by the requester's team using constructs like Server::whereTeamId($teamId), but some Livewire components skip equivalent team ownership checks and operate directly on identifiers supplied via query parameters.
This pattern maps to CWE-639: Insecure Direct Object Reference and CWE-862: Missing Authorization, where user-controlled resource IDs are used to perform actions without confirming that the caller is entitled to access those resources.
Potential impact
- Cross-team deployment of applications to another team's servers or destinations.
- Modification or disruption of another team's infrastructure configuration.
- Unauthorized consumption of compute, storage, or network resources in a victim team's environment.
- Potential service outages or data exposure depending on what is deployed or reconfigured.
- Erosion of tenant isolation and trust in multi-team instances of Coolify.
General mitigation guidance
Effective mitigation focuses on enforcing consistent authorization checks across all interaction surfaces.
Recommended patterns include:
- Centralizing resource authorization logic so that both API controllers and UI components must validate team or tenant ownership before performing operations.
- Treating any user-supplied identifiers (e.g.,
server_id,destination_uuidin URLs or forms) as untrusted and resolving them through ownership-constrained queries tied to the authenticated user's team. - Implementing a clear multi-tenant isolation model where each resource is always accessed in the context of a team or tenant, not solely by raw IDs.
- Designing UI flows so that selectable resources are derived from the current team context rather than free-form query parameters.
- Applying least privilege principles to actions that modify infrastructure, reducing the blast radius of any authorization gap.
How teams detect issues like this
Organizations can detect similar access control flaws by:
- Performing targeted code reviews that trace how resource IDs and ownership checks propagate from controllers to UI components, ensuring consistency in authorization logic.
- Using static analysis rules or linters flags for patterns where controller or component code operates on user-supplied identifiers without verifying tenant or team boundaries.
- Implementing security unit and integration tests that attempt cross-team access to servers, destinations, and other resources, validating that isolation is enforced.
- Enforcing policy checks in CI pipelines that require explicit authorization calls or middleware on all routes and interactive components, including Livewire or other reactive UI layers.
- Periodically instrumenting and analyzing logs for suspicious cross-team access patterns, such as one team consistently interacting with resource IDs belonging to another.

