Coolify
CVE-2025-64424
CRITICAL
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain low-privileged member account
-
DeliveryCreate/edit resource git source field
-
ExploitInject shell metacharacters into input
-
ExecutionCoolify executes command as root
-
ImpactFull host and managed-infrastructure 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 | Exploitation requires an authenticated low-privileged 'member' account on the target Coolify instance (PR:L) and the ability to create or edit a resource, then supply a malicious value in the resource's git source input field where shell metacharacters are not neutralized. No user interaction and no admin rights are needed; the injected command runs as root. Limiting factors: the attacker must first hold a valid member account (not fully unauthenticated), and the affected feature is the git source configuration of a resource - but no non-default configuration is required, making any multi-tenant or team-shared Coolify deployment through v4.0.0-beta.434 exposed. Patch availability was unconfirmed at publication, so no fixed version can be relied upon as mitigation. |
| Impact | This is a genuine high-priority issue, not a CVSS-inflated one. The CVSS 4.0 base score of 9.4 is corroborated by concrete signals: the vector is network-reachable (AV:N), low-complexity (AC:L), needs no user interaction (UI:N), and requires only low privileges (PR:L) - a 'member', the lowest authenticated tier in Coolify. The impact spans full confidentiality, integrity, and availability of both the vulnerable system and subsequent systems (VC/VI/VA:H, SC/SI/SA:H) because command execution lands as root on the Coolify host, which itself manages other servers, applications, and databases. A public exploit exists (referenced GitHub Security Advisory GHSA-qx24-jhwj-8w6x plus a Google Drive proof-of-concept), so weaponization barriers are low. Countervailing signals: EPSS is only 0.47% (64th percentile) and the CVE is not in CISA KEV, indicating no confirmed mass exploitation yet - consistent with a product that is popular but not internet-ubiquitous, and a bug that still requires a valid member account. Net: publicly available exploit code exists, low attacker skill needed, and the payoff is root - organizations running Coolify with any non-trusted members should treat this as urgent despite the modest EPSS. |
| Exploit ScenarioDerived | A low-privileged Coolify member (e.g. a developer invited to a team) creates or edits a resource and injects shell metacharacters into a git source input field; when Coolify processes that field it executes the attacker's commands as root on the host. Because a public proof-of-concept and GitHub advisory exist, the barrier to reproduction is minimal. The attacker gains full control of the Coolify instance and, by extension, every server, application, and database it orchestrates. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Sep 30, 2026
Command injection in Coolify up to and including v4.0.0-beta.434 lets any authenticated low-privileged 'member' execute arbitrary system commands as root on the Coolify instance by supplying shell metacharacters in a resource's git source input field. Remote exploitation requires no admin rights and no user interaction, so any team-shared or multi-tenant deployment that lets members create or edit resources is exposed, and this is a genuine high-priority issue rather than a CVSS-inflated one. Publicly available exploit code exists (NVD exploit references including a GitHub security advisory and an accompanying demonstration file), while the EPSS score remains low at 0.47% (64th percentile) and no fixed version was confirmed at the time of publication.
Earlier versions of this analysis (1)
Coolify is an open-source and self-hostable tool for managing servers, applications, and databases. [CVSS 8.8 HIGH]
RemediationAI
No vendor-released patch was identified at time of analysis - the Coolify advisory GHSA-qx24-jhwj-8w6x stated that patch availability was unclear at publication - so mitigation must initially rely on compensating controls, and administrators should watch that advisory plus the project's release notes for a fixed version (anything at or below v4.0.0-beta.434 should be treated as vulnerable until a patched build is explicitly published, and the exact fix version should not be assumed). The most effective immediate control is to eliminate the PR:L precondition: audit Coolify accounts and remove or downgrade every 'member' who does not strictly need resource-creation or editing rights, restricting resource and git-source configuration changes to trusted administrators, accepting the trade-off that this breaks normal team collaboration workflows. Second, place network-level restrictions in front of the Coolify management UI/API so only trusted administrative networks or VPN addresses can reach it, which blocks remote exploitation (AV:N) from the internet at the cost of losing convenient remote dashboard access. Third, treat any instance that had untrusted member accounts as potentially compromised: because injected commands run as root, rotate all credentials and secrets held by the instance, review Docker/host configuration for persistence or unauthorized containers, and rebuild the host from a trusted image rather than attempting in-place cleanup. Finally, add detection by monitoring Coolify and system logs for shell metacharacters or unexpected command sequences in git source fields and for unexpected root-level processes spawned by the Coolify application.
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-77 (Improper Neutralization of Special Elements used in a Command, i.e. command injection): user-controlled values entered into a resource's git source configuration fields are passed into a command construction path without neutralizing shell metacharacters, so injected characters cause the underlying shell to execute attacker-supplied commands. Coolify is an open-source, self-hostable platform-as-a-service control plane that manages servers, applications and databases, and its privileged backend operations run as root; consequently an injection that reaches this layer crosses a privilege/scope boundary, which is consistent with the independent assessment's scope-changed rating (S:C) and high confidentiality, integrity and availability impact across the instance and host. The affected CPE data maps to coollabs:coolify with a wildcard range (cpe:2.3:a:coollabs:coolify:*:*:*:*:*:*:*:*) plus explicit builds for 4.0.0 beta100 through beta108, reflecting the beta release cadence leading up to v4.0.0-beta.434. The assessed CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H) matches NVD's high 9.4 CVSS 4.0 score, and the preconditions are authentication as a low-privileged member plus the ability to create or edit a resource - no non-default configuration is required and the injected command executes with root privileges.
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-privileged member (PR:L) injects commands with no interaction; execution as root from an app-level account crosses a security boundary (S:C) with full CIA 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. In Coolify versions up to and including v4.0.0-beta.434, a command injection vulnerability exists in the git source input fields of a resource, allowing a low privileged user (member) to execute system commands as root on the Coolify instance. As of time of publication, it is unclear if a patch is available.
Executive ViewAI
Coolify, a self-hosted deployment and infrastructure management platform, contains a critical command-injection flaw (CVE-2025-64424, CVSS 9.4) that allows any account with member-level resource permissions to run arbitrary commands as root on the Coolify host; publicly available exploit code exists, though no vendor patch has been identified at time of analysis. Organizations running team-shared or multi-tenant Coolify instances are most exposed, because a single low-privilege team member - or an attacker holding compromised member credentials - could take full control of the platform and, by extension, every application, secret, and server it manages. Leadership should treat this as a priority risk to the delivery pipeline and to any customer workloads hosted on affected instances, and should assume that CISA KEV-style mass exploitation is not required for impact given the low skill bar to exploit.
No vendor-released patch identified at time of analysis. Interim mitigations: revoke create/edit resource permissions and member-level access for untrusted users; remove affected Coolify instances from direct internet exposure and restrict access via VPN or authenticated proxy; sanitize/allowlist git source URL inputs and audit existing resource configurations for shell metacharacters; run Coolify under a hardened, rootless, least-privileged container/VM with network egress restrictions; move secrets, tokens, and deploy keys out of Coolify into an external secrets manager and rotate exposed credentials; enable detailed logging and alerting on Coolify host command execution and resource changes; and treat all member accounts as potentially hostile pending remediation.
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)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
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
Command injection in Coolify's Git Repository field during project creation allows an authenticated member account to ru
Exploit-DB