Coolify
CVE-2025-59156
CRITICAL
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate as low-privileged member
-
DeliveryCreate/update project with malicious Compose directive
-
ExploitMount host filesystem into service
-
ExecutionTrigger deployment workflow
-
PersistExecute commands as root on host
-
ImpactFull host compromise across containers
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization OS command sanitization, avoid shell exec
MITRE ATT&CK
2 techniques across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires an authenticated low-privileged member/team account on a Coolify instance running a version prior to 4.0.0-beta.420.7 (PR:L). The concrete prerequisite is the ability to define or modify a service's Docker Compose configuration during project creation or update, where the deployment workflow does not neutralize attacker-supplied Compose directives - specifically volume/bind-mount directives that map the host filesystem into a container. No user interaction (UI:N) and no non-default feature toggle is required beyond normal deployment functionality. The primary limiting factor is that the attacker must already possess member-level access, so single-user or fully-trusted-team instances face lower practical risk than multi-tenant instances that grant project-creation rights to semi-trusted users. |
| Impact | This is a genuine high-priority issue, not merely a high-CVSS paper tiger. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N) describes network-reachable, low-complexity exploitation requiring only a low-privileged Coolify member account, and the full CIA impact on both the vulnerable system (VC:H/VI:H/VA:H) and subsequent systems (SC:H/SI:H/SA:H) reflects a container-to-host escape that yields root on the underlying host OS. The scope-changing subsequent-system impact is well justified because the attacker breaks out of container isolation onto the host. Critically, a POC/exploit is flagged as publicly available and the advisory itself is tagged as an exploit reference, which materially raises real-world risk. The main tempering signals are EPSS (0.42%, 62th percentile - modest, indicating no observed mass-exploitation yet) and the absence of a CISA KEV listing, so exploitation is 'publicly available exploit code exists' rather than 'confirmed actively exploited.' The one meaningful gate is PR:L: the attacker must already hold a low-privileged member account on a multi-tenant Coolify instance, so exposure concentrates on instances that hand out member/team access to semi-trusted users. No signals conflict; CVSS network vector, description, and CWE-78 are mutually consistent. |
| Exploit ScenarioDerived | A low-privileged member of a shared Coolify instance creates or edits a project and supplies a malicious Docker Compose definition that mounts the host filesystem (e.g. a bind mount of '/' or '/etc') into a service. When Coolify deploys the application, the attacker-controlled service executes commands against the mounted host paths, escaping container isolation to run commands as root on the host OS. A public POC/exploit is available per the GitHub Security Advisory, lowering the skill barrier for this low-complexity, network-reachable attack. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Sep 30, 2026
Remote code execution on the host OS is possible through Coolify's application deployment workflow prior to version 4.0.0-beta.420.7, where an authenticated member-level user can inject malicious Docker Compose directives-such as bind mounts of the host filesystem-during project creation or updates. This bypasses container isolation and yields root-level command execution on the Coolify host. Publicly available exploit code exists, and while the EPSS score is modest at 0.42% (62nd percentile), the severity is high because exploitation requires only a low-privileged team account and no user interaction; a vendor patch is available.
Earlier versions of this analysis (1)
Coolify is an open-source and self-hostable tool for managing servers, applications, and databases. Prior to version 4.0.0-beta.420.7, a Remote Code Execution (RCE)*vulnerability exists in Coolify's application deployment workflow. [CVSS 8.8 HIGH]
RemediationAI
Upgrade to Coolify 4.0.0-beta.420.7 or later; this version contains the patch per the GitHub security advisory GHSA-h5xw-7xvp-xrxr. If immediate upgrade is not possible, restrict the ability to create or modify projects and services to fully trusted administrators-this removes the member-level vector but reduces collaboration features. Administrative users should review existing Compose definitions for unexpected bind mounts of sensitive host paths (/, /etc, /var/run/docker.sock) and remove any unauthorized ones. Consider running Coolify's Docker daemon in rootless mode or applying AppArmor/SELinux profiles that deny containers access to host filesystem paths; these controls add operational complexity and may break legitimate workloads. Because exploitation requires an authenticated account, reducing the number of member accounts and enabling strong authentication limits exposure, but it does not replace patching.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Coolify (CoolLabs) is a self-hostable platform-as-a-service that orchestrates Docker containers on servers to deploy applications and databases. The flaw is rooted in CWE-78 (improper neutralization of special elements used in an OS command), because the deployment pipeline parses and executes user-supplied Docker Compose configuration without sanitizing directives. An attacker with member-level rights can supply a service definition containing a volumes directive that bind-mounts a host path (for example / or /var/run/docker.sock) into a container they control. Once the container runs, the attacker can read or write host files, modify systemd units or cron jobs, or interact with the Docker socket to launch privileged containers, resulting in root-level command execution on the host OS. The affected CPE entries identify Coolify 4.0.0 beta builds (beta100 through at least beta108) and unspecified earlier versions; the vendor fixed the issue in 4.0.0-beta.420.7. CVSS v4.0 rates the issue 9.4 with PR:L and scope changed, consistent with the independent CVSS 3.1 assessment of AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H.
Know when Coolify gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H
Network-reachable, low-complexity attack needing only a low-privileged member account (PR:L); container-to-host escape changes scope (S:C) yielding full CIA compromise of the host.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
5DescriptionCVE.org
Coolify is an open-source and self-hostable tool for managing servers, applications, and databases. Prior to version 4.0.0-beta.420.7, a Remote Code Execution (RCE)*vulnerability exists in Coolify's application deployment workflow. This flaw allows a low-privileged member to inject arbitrary Docker Compose directives during project creation or updates. By defining a malicious service that mounts the host filesystem, an attacker can achieve root-level command execution on the host OS, completely bypassing container isolation. Version 4.0.0-beta.420.7 contains a patch for the issue.
Executive ViewAI
Coolify installations running releases prior to 4.0.0-beta.420.7 are exposed to a critical remote code execution flaw that lets a low-privileged member account escape container isolation and obtain root control of the underlying host. Because Coolify typically sits on infrastructure hosting multiple applications, secrets, and deployment credentials, a successful compromise could cascade into broader environment and data exposure. Public exploit code is available, so any team running an affected release should treat this as an immediate operational risk rather than a theoretical one.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
OS command injection occurs when an application passes unsanitized user input directly into system shell commands.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Affected Products (CPE)CVE.org
Cross-team authorization bypass in Coolify (open-source self-hosted PaaS) before 4.0.0-beta.474 allows an authenticated,
Coolify versions prior to v4.0.0-beta.420.7 are vulnerable to a remote code execution vulnerability in the project deplo
Coolify versions prior to v4.0.0-beta.420.6 are vulnerable to a remote code execution vulnerability in the application d
Command injection in Coolify up to and including v4.0.0-beta.434 lets any authenticated low-privileged 'member' execute
Authenticated command injection in Coolify's PostgreSQL initialization-script filename handling allows users with applic
Coolify versions prior to 4.0.0-beta.451 pass user-supplied database names unsanitized into shell commands executed via
Authenticated Coolify users who hold application or service management permissions can execute arbitrary commands as roo
Authenticated command injection in Coolify before 4.0.0-beta.451 lets users with application or service management permi
Stored cross-site scripting in Coolify versions up to and including v4.0.0-beta.420.6 lets an authenticated low-privileg
Authenticated OS command injection in Coolify before 4.0.0-beta.471 lets any user holding destination management permiss
Authenticated remote code execution in Coolify (self-hosted PaaS) before 4.0.0-beta.470 lets a low-privileged authentica
Command injection in Coolify's Git Repository field during project creation allows an authenticated member account to ru
NVD
CVE.org
EPSS
GitHub
Exploit-DB