/

CVE-2026-34599

Severity:

HIGH RISK

(8.8)

Command Injection (CWE-78) in Coolify GetLogs Component

CVE-2026-34599

Deferred

Vulnerability type

Category:

Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution as root on managed servers

Severity:

HIGH RISK

(8.8)

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

An authenticated command injection vulnerability in Coolify's GetLogs Livewire component allows low-privilege team members to influence shell commands used to retrieve container logs.

By controlling a Livewire public property that is interpolated into docker log commands without sanitization, an attacker can execute arbitrary commands as root on managed servers when log retrieval functionality is invoked.

Affected context

This vulnerability appears in Coolify instances that expose the GetLogs Livewire component to authenticated users with team membership, including the lowest privilege member role.

It is relevant when the application issues shell commands (such as docker logs and docker service logs) on managed servers and directly interpolates user-controlled data into those command strings.

The risk arises specifically when the $container Livewire public property can be modified over the wire protocol and is subsequently used without validation or escaping in command construction, under a context where those commands execute with root-level privileges.

Exploit preconditions

  • Attack surface: Web interface and Livewire wire protocol used by Coolify to manage logs on connected servers.
  • Required access: Authenticated access as a team member, including the lowest privilege role, with the ability to invoke the GetLogs component.
  • Trigger point: Any operation that causes the GetLogs Livewire component to run shell commands (e.g., viewing container or service logs) while $container holds attacker-controlled content.
  • Why exploitation is possible: The $container public property is not locked and is therefore modifiable by the client via Livewire; its value is interpolated directly into shell command strings without sanitization, validation, or proper escaping, enabling injection of additional shell syntax and arbitrary command execution.

Why this happens

The underlying bug class maps to CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection').

Application logic constructs shell commands by concatenating or interpolating a Livewire public property ($container) directly into command strings (docker logs, docker service logs), assuming it is safe.

Because this property is both client-controllable through the Livewire wire protocol and not constrained or locked, input containing shell metacharacters or additional command sequences is treated as part of the command itself.

This pattern—building commands from untrusted input without normalization, whitelisting, parameterization, or escaping—creates an injection channel where the OS command interpreter executes unintended operations under the same privileges as the service.

Potential impact

  • Attackers may execute arbitrary commands as root on managed servers.
  • Attackers could access or modify sensitive data and configuration files on those servers.
  • Attackers can install backdoors, miners, or other persistent malware on managed infrastructure.
  • Attackers could disrupt running applications and databases, causing downtime or data loss.
  • Attackers may pivot from managed servers to other network assets, depending on connectivity and trust relationships.

General mitigation guidance

Effective mitigation focuses on removing direct interpolation of untrusted data into shell commands and constraining the trust boundary around management operations.

Common defensive patterns include:

  • Avoiding shell command construction from user-controlled values; use higher-level APIs or SDKs (e.g., Docker client libraries) that accept structured parameters instead of raw command lines.
  • Enforcing strict validation on identifiers such as container names by whitelisting allowed character sets and rejecting any content with shell metacharacters or unexpected syntax.
  • Treating Livewire public properties as untrusted inputs and applying locking or equivalent mechanisms to prevent arbitrary client-side modification where appropriate.
  • Running management agents and command execution components with least-privilege accounts rather than root, limiting damage if a command path is abused.
  • Centralizing command execution logic behind a well-reviewed abstraction layer that applies canonical sanitization rules and prohibits direct command-line concatenation.

How teams detect issues like this

Organizations can identify similar command injection issues through:

  • Static analysis rules that flag string concatenation or interpolation into command execution APIs (e.g., exec, shell_exec, process spawning calls) where data originates from HTTP requests, WebSocket messages, or Livewire properties.
  • Code review practices that focus on any layer which interacts with OS commands, looking for dynamic command construction and verifying that only validated, constrained inputs are used.
  • Security policies requiring parameterized execution via APIs or libraries for infrastructure management tasks instead of constructing shell commands manually.
  • Automated application security testing (DAST) that sends payloads containing shell metacharacters through log-related or management interfaces and monitors for anomalous behavior on target servers.

Sources

SourceLink
github.comgithub.com/coollabsio/coolify/commit/f267a28cb2badc7e712c4592af4d79d090fe5063
github.comgithub.com/coollabsio/coolify/pull/9229
github.comgithub.com/coollabsio/coolify/releases/tag/v4.0.0-beta.471
github.comgithub.com/coollabsio/coolify/security/advisories/GHSA-q9j6-xcvx-px63

Frequently asked

questions

Exploitation is limited to authenticated users with team membership in the affected Coolify instance, but even the lowest-privilege member role can trigger it. Within that scope, any user who can reach the GetLogs component and control the relevant property may execute commands on managed servers.

The attacker needs valid credentials for a team account and the ability to interact with the Livewire-based user interface that exposes the GetLogs component. No additional server-level or administrative permissions are required, making it accessible to ordinary team members.

The most robust fix is to eliminate command-line concatenation with untrusted data by using structured APIs (such as Docker client libraries) and restricting all identifiers to validated, minimal character sets. Additionally, treat framework-managed properties as untrusted inputs, lock them where appropriate, and ensure any remaining command execution runs under non-root accounts.

Future prevention involves adopting secure coding guidelines for command execution, including prohibiting direct use of untrusted input in shell commands, mandating centralized command-abstraction utilities, applying continuous static analysis for injection patterns, and enforcing privilege minimization on services that execute system-level operations.

Find out what's already
exploitable in your codebase.