Coolify
CVE-2025-66210
CRITICAL
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate with app/service management role
-
DeliverySet database name with shell metacharacters
-
ExploitTrigger database import/backup job
-
ExecutionUnsanitized name injected into docker exec shell command
-
ImpactExecute arbitrary commands as root on managed server
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 | Attacker must hold an authenticated Coolify account with application/service management permissions on the target instance (PR:L) - anonymous/unauthenticated access does not work. The specific vulnerable path is the Database Import/backup functionality, where a user-controlled database name is passed directly into docker exec dump commands (mongodump/pg_dump/mysqldump/mariadb-dump) without sanitization in versions prior to 4.0.0-beta.451. No user interaction by a second party is required (UI:N) and no non-default configuration is needed - the default backup/import code path is vulnerable. Limiting factors: requires a valid management-capable account (realistic in multi-user, multi-tenant, or credential-compromise scenarios) and an affected version (< 4.0.0-beta.451); patched instances enforce validateShellSafePath and escapeshellarg. |
| Impact | Signals are largely consistent and point to a genuine high-severity issue, but one that is privilege-gated rather than mass-exploitable. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N) describes a low-complexity, network-reachable attack with high impact to both the vulnerable system and subsequent systems (VC/VI/VA:H, SC/SI/SA:H), reflecting that injected commands run as root on managed servers - hence the 9.4 critical rating. Exploitation status is 'publicly available exploit code exists' (POC referenced, no CISA KEV listing). The tension in the signals is between severity and reach: EPSS is only 0.41% (61st percentile), which is modest and consistent with PR:L - exploitation requires an already-authenticated user holding application/service management permissions, so this is not an unauthenticated internet-wide worm candidate but an insider, compromised-credential, or multi-tenant privilege-escalation-to-RCE scenario. The low EPSS alongside a public POC and no KEV suggests opportunistic/targeted abuse rather than widespread automated exploitation at this time. Net: a real priority for any Coolify instance with multiple or semi-trusted users, because PR:L plus AC:L plus root-level impact makes post-authentication compromise trivial once an account exists. |
| Exploit ScenarioDerived | An authenticated Coolify user who holds application/service management permissions creates or edits a database and supplies a database name containing shell metacharacters (e.g. backticks or $(...)). When a backup/import job runs, the name is interpolated unsanitized into a docker exec dump command, so the injected payload executes as root on the managed server. Public exploit code is referenced for this Coolify command-injection class, lowering the bar for a would-be attacker with a valid low-privilege account. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Oct 19, 2026
Coolify versions prior to 4.0.0-beta.451 pass user-supplied database names unsanitized into shell commands executed via docker exec on managed servers, allowing an authenticated user with application/service management permissions to run arbitrary commands as root. Exploitation is remote but requires a valid management-capable account (PR:L), so the realistic exposure is multi-user, multi-tenant, or credential-compromise scenarios rather than anonymous mass exploitation. Publicly available exploit code exists and EPSS is modest at 0.41% (61st percentile); no confirmed active exploitation (CISA KEV) at time of analysis.
Earlier versions of this analysis (1)
A command injection vulnerability in Coolify's Database Import functionality allows authenticated users with application/service management permissions to execute arbitrary system commands as root on managed servers. The vulnerability stems from unsanitized database names being passed directly to shell commands, enabling full remote code execution. A public proof-of-concept exploit is available, and with an EPSS score of 0.41% (61st percentile), this represents a moderate real-world exploitation risk for organizations using vulnerable Coolify versions.
RemediationAI
Upgrade Coolify to 4.0.0-beta.451 or later, which adds validateShellSafePath() validation and escapeshellarg() escaping across the dump commands and the databasesToBackup field (PR https://github.com/coollabsio/coolify/pull/7375, release https://github.com/coollabsio/coolify/releases/tag/v4.0.0-beta.451, advisory https://github.com/coollabsio/coolify/security/advisories/GHSA-q33h-22xm-4cgh). If immediate upgrade is not possible, treat Coolify's management interface as a root-equivalent surface: restrict access to the UI/API to trusted networks or a VPN, enforce unique per-user accounts and remove application/service management permission from anyone who does not need it, rotate credentials for any account with management rights, and audit existing backup/import configurations for database name fields containing shell metacharacters. Rotating Coolify API tokens and reviewing shell history and container logs on managed Docker hosts for unexpected root commands provides detection coverage. Note that network restriction is only a partial control because a permitted-but-malicious or compromised management user still reaches the vulnerable code path.
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 root cause is CWE-78 (OS Command Injection) in Coolify's database backup/import workflows. In app/Jobs/DatabaseBackupJob.php, database names were concatenated directly into shell strings built for mongodump, pg_dump, mysqldump, and mariadb-dump invocations wrapped in docker exec, e.g. "--db $databaseName" or "pg_dump ... $database > $this->backup_location", with no quoting. A second injection point existed in app/Livewire/Project/Database/BackupEdit.php, where the comma-separated databasesToBackup field was exploded and passed straight through, and a third in app/Livewire/Project/Database/Postgresql/General.php where an init-script filename was interpolated into an rm -f command. Because these commands are dispatched to the managed server's Docker host context, injected metacharacters run as root on that server. The upstream fix (PR 7375) introduces a validateShellSafePath() allowlist-style validator and wraps values with escapeshellarg(), plus per-entry validation of the databasesToBackup list so malformed names are rejected at edit time. Coolify is a PHP/Laravel application, and this class of bug is a recurring hazard wherever Laravel shell helpers or process wrappers are fed user input.
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
Web-triggered by a low-privilege management account (PR:L, AV:N, AC:L, UI:N); injected commands run as root on the managed server, crossing from app to host, so S:C with full C/I/A impact.
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.451, an authenticated command injection vulnerability in the Database Import functionality allows users with application/service management permissions to execute arbitrary commands as root on managed servers. Database names used in import operations are passed directly to shell commands without sanitization, enabling full remote code execution. Version 4.0.0-beta.451 fixes the issue.
Executive ViewAI
Coolify deployments running versions prior to 4.0.0-beta.451 are exposed to a critical command-execution vulnerability that allows a user with application or service management permissions to run arbitrary commands as root on managed servers. The primary exposure is to multi-user, multi-tenant, or credential-compromised environments rather than anonymous mass exploitation, so leadership should focus on who holds management access and how broadly a compromised account could reach production infrastructure. With publicly available exploit code and no vendor patch yet identified, affected instances warrant prioritized access review and containment.
No vendor-released patch identified at time of analysis; interim mitigations include restricting Coolify management access to trusted networks, enforcing MFA, minimizing accounts with application/service management permissions, auditing docker exec activity, and segmenting managed servers to limit blast radius.
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
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
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