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

