/

CVE-2026-57498

Severity:

CRITICAL RISK

(9.6)

Broken Access Control (CWE-639) in Coolify Livewire UI

CVE-2026-57498

Deferred

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-639, CWE-862

Impact:

Cross-Tenant Resource Manipulation

Severity:

CRITICAL RISK

(9.6)

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 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_id and destination_uuid via 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_id and destination_uuid values 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_uuid in 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.

Sources

SourceLink
github.comgithub.com/coollabsio/coolify/security/advisories/GHSA-725v-f5gh-22q9

Frequently asked

questions

It primarily affects actions exposed through the vulnerable Livewire components, such as deployments or management operations that accept server_id and destination_uuid via query parameters. Any functionality wired through these components without ownership checks can be impacted.

An attacker must have a valid Coolify account and belong to at least one team, but does not need direct access to the victim team. They only need to know or discover identifiers for resources belonging to another team.

The most robust approach is to centralize authorization logic and ensure that every resource access—whether via API or UI—resolves through team- or tenant-scoped queries. User-controlled IDs should never be used directly; instead, they must be validated against the current user's authorized scopes.

Teams can prevent recurrence by standardizing on a shared authorization layer, enforcing mandatory checks on all routes and components, adding automated tests for cross-tenant isolation, and including access control verification as a regular part of code review and security testing workflows.

Find out what's already
exploitable in your codebase.