Coolify
CVE-2025-64419
HIGH
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPublish malicious repo with crafted docker-compose.yaml
-
DeliveryLure victim to deploy it via 'docker compose' build pack
-
ExploitCoolify interpolates unsanitized param into shell command
-
ExecutionCommand injection executes as root on host
-
ImpactFull host compromise
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Command injection prevention
MITRE ATT&CK
1 technique 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 | Requires that the Coolify instance permits the 'docker compose' build pack and that a victim user creates/deploys an application sourced from an attacker-controlled Git repository containing a malicious docker-compose.yaml. Exploitation is limited by the mandatory user interaction (a legitimate user must initiate the build from the attacker's repo) - there is no purely remote, no-interaction path. Affected: all Coolify versions prior to 4.0.0-beta.445; fixed in 4.0.0-beta.445. Installations that only build trusted, internally-controlled repositories are not realistically exposed. |
| Impact | This is a genuine high-severity issue but one whose real-world exploitation is gated by social engineering rather than direct remote access. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, 8.8) reflects an unauthenticated network attacker achieving full CIA impact as root, but the UI:R flag is doing heavy lifting: a legitimate Coolify user must voluntarily create an application from an attacker-controlled repository using the 'docker compose' build pack. The EPSS score of 0.09% (26th percentile) is low and aligns with this - mass, indiscriminate exploitation is unlikely because each compromise requires a targeted victim action. POC availability is limited to the GitHub Security Advisory (GHSA-234r-xrrg-m8f3), which is a weak signal: it documents the flaw but is not a weaponized standalone exploit, so 'publicly available exploit code exists' should not be conflated with active exploitation. Not in CISA KEV. The signals are internally consistent - high technical impact (root RCE) but low probability of widespread exploitation - so this is a real priority for defenders who let untrusted users trigger builds, but a lower priority for closed/single-tenant Coolify installs. No data conflicts; the CVSS vector matches the description well. |
| Exploit ScenarioDerived | An attacker publishes a Git repository containing a crafted docker-compose.yaml with shell metacharacters embedded in a parameter that Coolify passes unsanitized into a docker compose command. They socially engineer a Coolify user into deploying that repository with the 'docker compose' build pack. When Coolify builds the application, the injected command executes on the Coolify host as root. A proof-of-concept is described in the vendor GitHub Security Advisory, though no weaponized standalone exploit is published. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Sep 30, 2026
Command injection in Coolify instances running versions prior to 4.0.0-beta.445 lets an attacker who controls the Git repository used to create an application execute arbitrary commands as root on the Coolify host. The flaw is triggered when a victim user creates or deploys an application using the 'docker compose' build pack from an attacker-supplied repository whose docker-compose.yaml supplies unsanitized parameters that are later interpolated into shell commands executed by Coolify. Publicly available exploit code exists, and the CVSS vector (AV:N/AC:L/PR:N/UI:R) confirms a remote, unauthenticated attack path that nevertheless requires the victim to initiate the build, so real-world exploitation is gated by social engineering rather than direct remote access; EPSS is low at roughly 0.09% (26th percentile). A vendor patch is available in version 4.0.0-beta.445.
Earlier versions of this analysis (1)
Coolify docker-compose parameters are unsanitized, enabling attacker-controlled repositories to achieve root RCE on the Coolify host.
RemediationAI
Upgrade Coolify to version 4.0.0-beta.445 or later - the exact release that resolves this issue - and redeploy the Coolify control plane so the patched image is in use; the upstream fix is the commit at https://github.com/coollabsio/coolify/commit/f86ccfaa9af572a5487da8ea46b0a125a4854cf6, and the vendor advisory at https://github.com/coollabsio/coolify/security/advisories/GHSA-234r-xrrg-m8f3 should be consulted for the supported upgrade path. Where upgrading immediately is not possible, the most effective compensating control is to stop using the 'docker compose' build pack for any repository that is not fully trusted - switch such applications to the Nixpacks or Dockerfile build packs, which do not interpolate compose-file parameters into host shell commands (trade-off: some compose-based projects will need a Dockerfile or a different deployment topology). Operators who must retain the docker compose build pack should restrict application creation and deployment permissions to a small set of trusted users, avoid pointing Coolify at third-party or fork repositories, and treat any newly added external repository as untrusted code execution on the Coolify host; because the Coolify process runs with root-level access to the Docker socket, running untrusted compose builds on a segregated, low-privilege Coolify instance or in an isolated network namespace reduces the blast radius of a successful injection. After patching, review existing applications' custom build and start commands for unexpected -f/--env-file overrides, and audit Coolify logs for command execution originating from compose files.
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
The issue is a CWE-77 command injection rooted in how Coolify handles user-influenced parameters drawn from a project's docker-compose.yaml when constructing shell commands. Coolify is a self-hosted PaaS control plane that clones a Git repository, reads its compose definition, and runs docker compose build / up commands on the host - a context where the Coolify process typically holds root-equivalent privileges over the Docker daemon and server. Because the values derived from the compose file were not sanitized before being concatenated into those commands, an attacker-authored compose file can break out of the intended argument structure and inject additional shell operations that execute as root on the Coolify instance. The upstream fix (commit f86ccfaa9af572a5487da8ea46b0a125a4854cf6) introduces an injectDockerComposeFlags() helper in bootstrap/helpers/docker.php that deterministically appends the -f <compose file> and --env-file <env file> flags to custom docker compose build/start commands (using anchored regex checks such as /(?:^|\s)(?:-f(?:[=\s]|\S)|--file(?:=|\s))/ so an operator-supplied flag is not double-added), replacing the earlier behavior that relied on operator-supplied path strings and left the parameter surface open; the corresponding Livewire component and Blade view now render the fully-injected command as a read-only preview so operators can see exactly what will run. The CPE data maps the entire coollabs:coolify product line, including the 4.0.0 beta100-beta108 builds, to the vulnerable range.
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
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
Attacker is unauthenticated (PR:N) but a victim must deploy the attacker's repo (UI:R); injected commands run as root yielding full host CIA impact (C/I/A:H).
Primary rating from NVD.
CVSS VectorNVD
Lifecycle Timeline
6DescriptionNVD
Coolify is an open-source and self-hostable tool for managing servers, applications, and databases. Prior to version 4.0.0-beta.445, parameters coming from docker-compose.yaml are not sanitized when used in commands. If a victim user creates an application from an attacker repository (using build pack "docker compose"), the attacker can execute commands on the Coolify instance as root. Version 4.0.0-beta.445 fixes the issue.
Executive ViewAI
Coolify instances prior to 4.0.0-beta.445 are exposed to a high-severity command injection that can allow an attacker to run arbitrary commands as root on the Coolify host when a user deploys an application from an attacker-controlled Git repository. The attack requires the victim to initiate a build from an untrusted source, making this primarily a supply-chain and social-engineering risk for teams using Coolify to manage deployments. Leadership should prioritize remediation because a successful exploit could compromise the Coolify host and potentially all applications, credentials, and data it manages, even though public exploit code availability is tempered by the need for user interaction.
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.
Affected Products (CPE)NVD
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
Remote code execution on the host OS is possible through Coolify's application deployment workflow prior to version 4.0.
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
NVD
CVE.org
EPSS
GitHub
Exploit-DB