/

CVE-2026-34047

Severity:

CRITICAL RISK

(9.9)

Authorization Bypass (CWE-863) in Coolify Terminal WebSocket

CVE-2026-34047

Deferred

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Privilege Escalation and Remote Command Execution

Severity:

CRITICAL RISK

(9.9)

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 authorization bypass in Coolify's terminal WebSocket bootstrap routes allows authenticated users to access terminal sessions for resources beyond their permitted scope.

Under certain conditions, this can enable execution of commands on servers, applications, or databases that the user should not be able to control, significantly expanding the blast radius of any compromised account.

Affected context

This vulnerability arises in deployments of Coolify where terminal access is exposed via WebSocket routes to manage servers, applications, or databases.

It manifests when the terminal bootstrap routes are reachable within an authenticated session but are not consistently guarded by the same authorization middleware used elsewhere.

The issue primarily affects environments where multiple users or tenants share infrastructure and where role-based or resource-scoped permissions are expected to protect terminal functionality.

Exploit preconditions

  • Attack surface: Coolify web interface and associated terminal WebSocket endpoints.
  • Required access: An authenticated Coolify user account with any level of access to the application.
  • Trigger point: Initiating or hijacking a terminal session through the vulnerable WebSocket bootstrap routes that lack proper authorization checks.
  • Why exploitation is possible: The authorization middleware is not correctly enforced on specific terminal-related routes, allowing session context alone to open terminal access to resources outside the user's permitted scope.

Why this happens

The underlying bug class is an authorization control failure where access control checks are missing or inconsistently applied to sensitive endpoints.

In this case, terminal WebSocket bootstrap routes handling command execution on managed resources do not enforce the expected middleware that validates whether a user is permitted to interact with a specific server, application, or database.

This aligns with CWE-863: Incorrect Authorization, where a system verifies that a request is authenticated but does not ensure that the requester is authorized to perform the requested action on the targeted resource.

Potential impact

  • An authenticated user may execute arbitrary commands on servers, applications, or databases they are not explicitly authorized to manage.
  • Tenant isolation and project-level segregation can be undermined, enabling cross-tenant resource access.
  • Attackers can pivot from a low-privileged account to broader infrastructure control.
  • Configuration data, application code, and stored secrets may be read, modified, or deleted.
  • Operational disruption through service downtime, data corruption, or destructive commands can occur.

General mitigation guidance

Effective mitigation focuses on applying consistent, centralized authorization controls around all sensitive terminal and management endpoints.

Recommended patterns include:

  • Ensuring that every route enabling terminal or command execution is protected by a shared authorization middleware that enforces resource-level permissions.
  • Designing route handlers so that resource identifiers (e.g., server, application, database IDs) are always resolved against the authenticated user's allowed scope before establishing terminal sessions.
  • Adopting a default-deny approach: treat terminal functionality as highly privileged, requiring explicit checks and minimal roles to access.
  • Implementing clear separation of duties between read-only management views and terminal/command capabilities, with distinct permission flags.
  • Applying least privilege principles on underlying infrastructure so that terminal sessions have constrained access even if misrouted.

How teams detect issues like this

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

  • Static analysis or manual code review focused on identifying sensitive WebSocket or API routes that bypass or duplicate authorization logic instead of using centralized middleware.
  • Verification that route definitions for terminal and command execution paths reference standardized access-control mechanisms and resource-scoping helpers.
  • Logging and monitoring of terminal session creation events, including user identity and targeted resource, to flag anomalies such as users opening sessions on unfamiliar or unauthorized projects.
  • Periodic access control audits that reconcile configured permissions with observed actions, using automated security testing or policy-enforcement tools to validate that only expected roles can trigger terminal endpoints.

Sources

SourceLink
github.comgithub.com/coollabsio/coolify/commit/bc91b41f92f1bbb53886a5d7a60335cbf1621cd5
github.comgithub.com/coollabsio/coolify/pull/9169
github.comgithub.com/coollabsio/coolify/releases/tag/v4.0.0-beta.471
github.comgithub.com/coollabsio/coolify/security/advisories/GHSA-652w-qv22-2r7c

Frequently asked

questions

The issue is exploitable by any authenticated user in affected versions who can reach the terminal WebSocket bootstrap routes. They do not need elevated privileges if authorization checks are missing, making the impact potentially broad in multi-user or multi-tenant environments.

The attacker must have valid credentials for a Coolify account, even at a low privilege level. Once logged in, they can leverage the vulnerable terminal routes to interact with resources outside their intended authorization scope.

The safest fix pattern is to centralize authorization logic and ensure that all terminal and command-related routes consistently enforce role- and resource-based permission checks. Routes should fail closed if authorization data is missing or validation cannot be completed.

Preventive strategies include enforcing a security pattern where all sensitive endpoints are registered through a shared access-control layer, performing regular authorization-focused code reviews, implementing automated tests for role and resource boundaries, and treating terminal functionality as a critical capability requiring explicit permission design and validation.

Find out what's already
exploitable in your codebase.