/

CVE-2026-34048

Severity:

CRITICAL RISK

(9.9)

Authorization Bypass (CWE-285) in Coolify Terminal

CVE-2026-34048

Deferred

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-285, CWE-862

Impact:

Unauthorized 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

Coolify's terminal WebSocket bootstrap routes previously authenticated users but did not verify whether they were authorized to access specific terminals.

Under these conditions, a low-privileged team member could open terminal sessions and execute commands on team servers they should not control.

Affected context

This vulnerability arises in Coolify deployments where multiple team members share access to the same Coolify instance and terminals are exposed through WebSocket-based routes.

The affected context is the terminal bootstrap endpoints, which verified that a user was logged in but did not enforce per-terminal or per-server authorization.

Environments with shared or delegated access, such as teams managing many servers or applications, are particularly exposed if role boundaries are expected to limit who can run commands on which servers.

Exploit preconditions

  • Attack surface: Coolify terminal WebSocket endpoints exposed via the web interface or API
  • Required access: Valid but low-privileged Coolify account within a team
  • Trigger point: Initiating a WebSocket connection to terminal bootstrap routes and attaching to terminals not intended for the user
  • Why exploitation is possible: The server only checked that the user was authenticated, not whether they were authorized for the target terminal session, creating a privilege escalation path

Why this happens

The core issue is an authorization control weakness where access control checks stop at authentication.

The terminal WebSocket bootstrap logic confirms that a user is logged in but does not perform fine-grained checks to ensure that the user is permitted to create or attach to a given terminal session.

This pattern maps to CWE-285: Improper Authorization and is closely related to CWE-862: Missing Authorization, where business logic assumes that authenticated users are inherently allowed to access sensitive functionality without additional verification of role, ownership, or resource-level permissions.

Potential impact

  • A low-privileged team member could execute arbitrary shell commands on servers managed by Coolify.
  • Attackers could modify, delete, or exfiltrate application data and configuration from affected servers.
  • Compromised servers could be used as a pivot point for broader network intrusion or lateral movement.
  • Service downtime, data corruption, or deployment pipeline sabotage could occur through misuse of terminal access.

General mitigation guidance

Mitigation generally focuses on enforcing resource-level authorization for all interactive and high-impact operations.

Recommended defensive patterns include:

  • Applying consistent role-based or attribute-based access checks on terminal endpoints, ensuring that only permitted users can start or attach to sessions for a given server.
  • Treating authenticated identity and authorization as separate steps, explicitly checking ownership or team permissions for each terminal action.
  • Centralizing authorization logic so that new routes (such as WebSocket handlers) inherit the same access policies as REST endpoints.
  • Minimizing the privileges available to default or low-level roles and limiting which users can gain interactive shell access to production servers.
  • Logging and monitoring all terminal session creation and command activity to support detection and incident response.

How teams detect issues like this

Detection strategies can center on both code-level and operational indicators:

  • Static and code review: Look for WebSocket or terminal-related routes that validate authentication but lack explicit authorization checks tied to resource identifiers (server, project, or team).
  • Access control policies: Enforce patterns where every sensitive route requires permission checks based on user role and resource ownership; deviations should be flagged in reviews.
  • Automated analysis: Configure linters or security scanners to flag endpoints that expose shell, deployment, or administrative functionality without a corresponding authorization check.
  • Runtime monitoring: Analyze audit logs for unexpected terminal sessions initiated by low-privileged users, unusual access patterns across projects, or commands executed from atypical accounts.

Sources

SourceLink
github.comgithub.com/coollabsio/coolify/commit/847166a3f89b7c80972fa0d2e5c754976f95b6ad
github.comgithub.com/coollabsio/coolify/releases/tag/v4.0.0-beta.471
github.comgithub.com/coollabsio/coolify/security/advisories/GHSA-mw6q-2hmg-mhxv

Frequently asked

questions

Any team member with a valid but low-privileged account could potentially exploit the missing terminal authorization to attach to and use terminals on servers they are not supposed to control.

No. The attacker only needs a Coolify account in the affected team; from there, they can leverage the authorization flaw in the terminal WebSocket routes to run commands on servers via Coolify.

The most robust fix is to enforce consistent, fine-grained authorization checks for each terminal session, ensuring that only users with explicit rights to a given server or project can create or attach to its terminal endpoints.

Implement a centralized authorization layer, apply least-privilege role design, require explicit permission checks for all sensitive routes (including WebSockets and background jobs), and integrate security-focused code review or automated policy enforcement into the development workflow.

Find out what's already
exploitable in your codebase.