/

CVE-2026-79755

Severity:

HIGH RISK

(8.0)

OS Command Injection (CWE-78) in Nuclio Docker Platform

CVE-2026-79755

Deferred

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution and Potential Host Compromise

Severity:

HIGH RISK

(8.0)

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

Nuclio's local Docker platform constructs a shell command using an unvalidated function namespace, allowing shell metacharacters to alter command execution. When the default unauthenticated access mode is exposed, a remote attacker may execute operating-system commands as root inside the dashboard container and potentially reach the host through the Docker socket.

Affected context

The vulnerability occurs in Nuclio deployments using the local Docker platform when a function namespace is incorporated into a double-quoted docker ps --filter command and passed to the host shell. Risk is higher when the dashboard is reachable without authentication and its container has access to the Docker socket.

Exploit preconditions

  • Attack surface: Nuclio dashboard or function-management interface on the local Docker platform
  • Required access: Ability to submit or influence a function namespace; authentication may not be required when the default nop authentication mode is used
  • Trigger point: Processing the namespace while constructing and executing the Docker command
  • Why exploitation is possible: Unvalidated input is interpolated into a shell command, allowing command syntax to be interpreted by /bin/sh -c
  • Privilege context: Commands execute as root inside the dashboard container, with additional risk when the Docker socket is mounted

Why this happens

The underlying bug is shell command injection caused by combining untrusted application data with a command string and executing that string through a host shell. The function namespace is treated as command text rather than as a data-only argument, so shell metacharacters can change the command's meaning. This behavior maps to CWE-78: Improper Neutralization of Special Elements used in an OS Command.

Potential impact

  • An attacker may execute arbitrary operating-system commands in the dashboard container
  • Commands could run with root privileges within the container
  • An attacker could access or manipulate data available to the container
  • Docker socket access could enable container creation, modification, or host-level compromise
  • The compromise could support lateral movement or disruption of event-processing workloads

General mitigation guidance

Mitigation generally focuses on removing shell interpretation from command execution and reducing the trust placed in user-controlled namespaces.

Common defensive patterns include:

  • Use structured process-execution APIs that pass arguments separately instead of invoking a shell
  • Validate namespaces against a strict allowlist of permitted characters, length, and format
  • Treat identifiers as data and apply context-appropriate escaping when an external command is unavoidable
  • Disable unauthenticated dashboard access and enforce strong authentication and authorization
  • Avoid exposing the Docker socket to application containers where possible
  • Run dashboard components with non-root identities and minimal container capabilities
  • Apply filesystem, network, and container isolation to limit the consequences of command execution

How teams detect issues like this

Detection can combine source review, automated analysis, and runtime controls:

  • Use static analysis rules to identify shell invocation APIs such as /bin/sh -c, subprocess calls with shell execution enabled, and string interpolation in command arguments
  • Review code paths where HTTP, API, or event data reaches process execution without strict validation
  • Flag construction of commands through concatenation, formatting, or template interpolation
  • Enforce policies that prohibit shell execution for operations that can use structured APIs
  • Monitor dashboard requests and container process creation for unexpected shell commands or access to Docker-related interfaces
  • Use automated code-review or application-security tools to identify command-injection patterns during development

Sources

SourceLink
github.comgithub.com/nuclio/nuclio/commit/24582ac354d04951ec6786b3fe6ccf3b32652e9f
github.comgithub.com/nuclio/nuclio/pull/4220
github.comgithub.com/nuclio/nuclio/releases/tag/1.17.4
github.comgithub.com/nuclio/nuclio/security/advisories/GHSA-2893-rq73-w22x

Frequently asked

questions

It can be remotely exploitable when the Nuclio dashboard is reachable and an attacker can influence a function namespace, particularly when unauthenticated access is enabled.

The attacker needs access to an API or workflow that accepts or processes the namespace. Under the default nop authentication configuration, this may not require valid credentials.

Avoid invoking a shell for Docker operations and pass validated arguments through a structured execution interface. Strictly validate identifiers and remove unnecessary Docker socket exposure.

Use secure process APIs, enforce authentication and authorization, apply least privilege, scan for shell-interpolation patterns, and test externally influenced inputs across all command-execution paths.

Find out what's already
exploitable in your codebase.