Coolify
CVE-2025-59157
HIGH
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate as regular member
-
DeliveryCreate project with malicious Git Repository field
-
ExploitInjected shell command runs during deploy workflow
-
ExecutionExecute arbitrary commands on host
-
ImpactFull compromise of Coolify 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 | Requires an authenticated regular MEMBER account on the target Coolify instance (PR:L) - not admin, but not anonymous either, so the instance must have multiple/less-trusted users or allow member registration. The attacker must be able to create a project and populate the Git Repository field, and the injected commands only fire when the deployment workflow for that project runs (self-triggerable by the attacker, no separate victim interaction, UI:N). Affected: all Coolify versions prior to 4.0.0-beta.420.7. Limiting factors: single-operator/self-only instances with no untrusted members have effectively no exposure, since every member already controls deployments. |
| Impact | Multiple signals converge on a genuine but access-gated priority. The vendor CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 8.8 High) is well-founded: command injection in the Git Repository field yields full CIA impact via shell execution on the Coolify host during the deployment workflow. The critical limiting signal is PR:L - the advisory explicitly states a 'regular member user' can exploit it, so this is NOT unauthenticated internet-facing RCE; an attacker needs a valid member account on the Coolify instance first. POC/exploit code is publicly available (referenced in the GHSA advisory), which raises practical exploitability, but this must NOT be conflated with active exploitation - there is no CISA KEV listing. EPSS is modest at 0.26% (49th percentile), consistent with a vulnerability that has public detail but no evidence of mass exploitation, pointing to targeted (insider/tenant-abuse) rather than widespread opportunistic use. Net: a real priority for any multi-tenant or team-shared Coolify deployment where member accounts are not fully trusted, but the authentication barrier meaningfully lowers real-world risk versus the raw 8.8. |
| Exploit ScenarioDerived | An attacker holding a regular member account on a shared Coolify instance creates a project and enters a malicious payload in the Git Repository field; because the input is passed unsanitized into a shell command during deployment, injected commands execute on the underlying host as the Coolify service context, yielding RCE. Public exploit code referenced in the GHSA advisory lowers the skill required, and with AC:L the injection is reliably triggered once the deploy workflow runs. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv3 – Sep 30, 2026
Command injection in Coolify's Git Repository field during project creation allows an authenticated member account to run arbitrary shell commands on the self-hosted Coolify server when the project's deployment workflow executes. All releases prior to 4.0.0-beta.420.7 are affected, and publicly available exploit code exists, so member-restricted instances that permit untrusted or self-registered users carry real risk. Exploitation is access-gated rather than anonymous: the CVSS vector (PR:L, AV:N, UI:N) confirms a low-privileged authenticated attacker is required, and the EPSS score of 0.26% (49th percentile) indicates low observed exploitation activity with no CISA KEV listing at time of analysis.
Earlier versions of this analysis (2)
Command injection in the Git Repository field used during project creation in Coolify allows any authenticated member-level user to execute arbitrary shell commands on the underlying host as the deployment workflow processes the unsanitized input. All Coolify installations prior to version 4.0.0-beta.420.7 are affected, and although exploitation requires a valid non-admin account with project-creation access (PR:L), the resulting impact is full compromise of confidentiality, integrity, and availability (CVSS 8.8). Publicly available exploit code exists, while EPSS remains low at 0.26% (49th percentile), suggesting the flaw is real and trivially reachable but not yet seeing broad opportunistic scanning; instances that hand out member accounts to semi-trusted or untrusted users, such as multi-tenant or team deployments, carry the greatest practical risk.
Coolify allows command injection via the Git Repository field during project creation, enabling authenticated users to execute commands as root.
RemediationAI
Upgrade Coolify to 4.0.0-beta.420.7 or later - this is the vendor-released patch version and the only complete fix; see the GitHub security advisory at https://github.com/coollabsio/coolify/security/advisories/GHSA-5cg9-38qj-8mc3. Where an immediate upgrade is not possible, the most effective compensating control is to remove the vulnerable privilege path: disable member self-registration and restrict project-creation rights so only fully trusted administrators can supply a Git Repository value, since the injection requires an authenticated member account and fires on that member's own deployment. Operators of single-user or single-operator instances have effectively no exposure and can schedule the upgrade normally. Additional hardening with trade-offs: run the Coolify control plane in an isolated network segment or container host separate from production workloads so an injected command does not inherit reach to managed servers, and audit/rotate the SSH keys and deployment credentials Coolify holds, acknowledging that restricting or downgrading those credentials will break automated deployments. Because exploitation is confirmed feasible by publicly available exploit code, member accounts and their deployment logs should be reviewed for unexpected shell activity until the patch is applied.
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 vulnerability is a classic OS command injection (CWE-78) in Coolify, an open-source, self-hostable control plane that manages servers, applications, and databases and whose deployment workflow shells out to Git and other system tooling. When a user creates a project, the Git Repository field is passed into a shell-invoked deployment/checkout routine without adequate sanitization or argument escaping, so shell metacharacters or command separators embedded in the repository string are interpreted by the shell rather than treated as literal data. Because Coolify orchestrates deployments over SSH and runs with credentials capable of managing target hosts, the injection executes with the Coolify server process's privileges rather than being confined to a sandboxed build step. CPE data (cpe:2.3:a:coollabs:coolify:*:*:*:*:*:*:*:* and explicit 4.0.0 beta100 through beta108 builds) confirms the entire pre-4.0.0-beta.420.7 release line, including the early 4.0.0 beta channel, is in scope.
Severity by source
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
Network-reachable web UI with low-complexity injection needing only a regular member account (PR:L), no user interaction, and host command execution yielding full CIA (C:H/I:H/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.420.7, the Git Repository field during project creation is vulnerable to command injection. User input is not properly sanitized, allowing attackers to inject arbitrary shell commands that execute on the underlying server during the deployment workflow. A regular member user can exploit this vulnerability. Version 4.0.0-beta.420.7 contains a patch for the issue.
Executive ViewAI
Coolify self-hosted deployments running releases prior to 4.0.0-beta.420.7 are affected by a high-severity command injection flaw that lets a low-privileged authenticated member execute arbitrary shell commands on the Coolify server during project deployment. This creates organizational risk of infrastructure compromise, credential theft, and supply-chain tampering, particularly where self-registration or untrusted member accounts are permitted. Leadership should prioritize remediation because publicly available exploit code exists, no vendor-released patch was identified at time of analysis, and the blast radius extends to any secrets or downstream systems managed by the Coolify server.
No vendor patch is available; restrict project creation and Git repository edits to trusted administrators, disable self-registration and untrusted member accounts, enforce least privilege, isolate Coolify servers via network segmentation, rotate secrets, monitor deployment workflows for anomalous command execution, and consider temporary read-only or approval-based deployment controls.
Threat Intelligence Overview
NVD
CVE.org
EPSS
GitHub
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
Exploit-DB