/

CVE-2026-72901

Severity:

CRITICAL RISK

(9.9)

OS Command Injection (CWE-78) in Dokploy Volume Backups

CVE-2026-72901

Received

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution and Control-Plane Compromise

Severity:

CRITICAL RISK

(9.9)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Dokploy contains an OS command injection vulnerability in its volume backup operations, where an authenticated low-privilege member can influence a value passed to a shell command.

When the affected backup functions process attacker-controlled input, commands may execute on the Dokploy control-plane host with privileges associated with its Docker access, potentially providing host- or root-equivalent control.

Affected context

The issue affects Dokploy deployments using the volume backup functionality before the security fix was introduced. It becomes risky when a low-privilege authenticated member can submit or influence the volumeName value accepted by volumeBackup.create or volumeBackup.runManually, and the application executes the resulting command through a shell on the control-plane host.

Docker socket access can significantly increase the impact because commands executed in the application environment may be able to control containers or reach host-level resources.

Exploit preconditions

  • Attack surface: Authenticated Dokploy volume backup functionality
  • Required access: A valid account with low-privilege member permissions sufficient to invoke the affected backup operations
  • Trigger point: Processing of the volumeName field by the volume backup implementation
  • Execution path: The value is interpolated into a command and executed through a shell-backed process execution API
  • Why exploitation is possible: Input is not safely separated from shell syntax before command execution, allowing data intended as a volume identifier to influence command interpretation

Why this happens

The vulnerability results from constructing a shell command by interpolating an externally influenced value without appropriate quoting or argument isolation.

Passing this constructed command to child_process.exec permits shell metacharacters and command syntax in the input to alter the command that is executed. This is CWE-78: Improper Neutralization of Special Elements used in an OS Command, commonly called OS command injection. Docker socket exposure further broadens the consequences of code execution within the control-plane environment.

Potential impact

  • An attacker may execute arbitrary commands on the Dokploy control-plane host
  • The attacker could gain control over managed containers and deployment resources
  • Sensitive application secrets, credentials, or configuration data may be exposed
  • The attacker may alter deployments, backup content, or hosted workloads
  • The vulnerability can enable lateral movement or broader infrastructure compromise

General mitigation guidance

Mitigation generally focuses on eliminating shell interpretation and reducing the trust placed in user-controlled identifiers.

Common defensive patterns include:

  • Prefer direct process-spawning APIs that pass arguments as structured arrays rather than invoking a shell
  • Validate volume names against a strict allowlist or expected identifier format
  • Apply context-appropriate argument escaping when shell execution cannot be avoided
  • Separate user-controlled values from command templates and avoid string-based command construction
  • Restrict access to volume backup operations according to least privilege
  • Limit Docker socket exposure and use narrowly scoped service identities where possible
  • Store credentials and deployment secrets outside attacker-reachable process environments
  • Use patched application releases through the organization's normal change-management process

How teams detect issues like this

Detection can combine source analysis, runtime monitoring, and authorization review.

  • Use static analysis rules to identify child_process.exec calls that incorporate request, form, API, or database values into command strings
  • Review code for string interpolation or concatenation in shell commands, especially around backup, deployment, and container-management features
  • Flag process-execution APIs that receive unsanitized identifiers or filenames
  • Monitor control-plane hosts for unexpected child processes, command interpreters, container-management actions, and changes to deployment resources
  • Audit which roles can invoke volume backup operations and whether those permissions exceed operational requirements
  • Enforce secure coding policies that require structured process arguments and strict validation of resource names
  • Automated code review and software composition analysis tools may help identify recurring command-construction patterns

Sources

SourceLink
github.comgithub.com/Dokploy/dokploy/commit/d629faebc6dcb9d4785f84bf30b2b285f9f59379
github.comgithub.com/Dokploy/dokploy/pull/4873
github.comgithub.com/Dokploy/dokploy/releases/tag/v0.29.13
github.comgithub.com/Dokploy/dokploy/security/advisories/GHSA-w223-vw9m-4f9c

Frequently asked

questions

It can be exploitable through the Dokploy application interface when the attacker can authenticate as a member and access the affected volume backup operations. Exploitation does not necessarily require direct shell access to the host.

The described attack requires a valid low-privilege Dokploy account with sufficient permission to invoke the affected backup functionality. The precise scope depends on role configuration and deployment-specific authorization controls.

The safest pattern is to avoid shell interpretation entirely by using a structured process API with fixed executable paths and separately supplied arguments. Strict allowlist validation should also be applied to volume identifiers.

Treat all API and form fields as untrusted, prohibit interpolated values in shell commands, apply least-privilege authorization, restrict Docker socket access, and include command-injection checks in code review and automated security testing.

Find out what's already
exploitable in your codebase.