/

CVE-2026-52831

Severity:

HIGH RISK

(8.0)

OS Command Injection (CWE-78) in Nuclio CronJob Containers

CVE-2026-52831

Deferred

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Arbitrary Command Execution

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 cron triggers may be vulnerable to OS command injection because event header names and event body content flow into a shell command without adequate sanitization. An attacker who can influence these trigger fields may cause arbitrary commands to run in the Kubernetes CronJob container when the scheduled trigger executes.

Affected context

The vulnerability occurs in Nuclio deployments that use cron triggers and generate Kubernetes CronJobs for event processing. The controller constructs a curl command and passes it to /bin/sh -c; values derived from event header keys and the event body may therefore become part of a shell-interpreted command. Risk depends on whether an attacker can influence trigger input or configuration and on the permissions available to the CronJob container.

Exploit preconditions

  • Attack surface: Nuclio cron-trigger processing and the resulting Kubernetes CronJob container
  • Required access: The ability to influence event header names, event body content, or another upstream source that controls those values
  • Trigger point: Execution of the generated shell command by /bin/sh -c during a scheduled CronJob run
  • Why exploitation is possible: User-influenced values are incorporated into a command string without sufficient shell metacharacter handling or command separation

Why this happens

The underlying flaw is command construction from untrusted or insufficiently trusted data. Nuclio builds a curl invocation as a string and executes it through a shell, while event header keys and the event body can flow into that string without adequate sanitization. This behavior maps to CWE-78: Improper Neutralization of Special Elements used in an OS Command, because shell syntax embedded in data may alter the intended command structure.

Potential impact

  • An attacker may execute arbitrary operating-system commands in the CronJob container.
  • The workload may be used to access application data, credentials, or mounted resources.
  • The attacker could alter or disrupt event-processing behavior.
  • The compromise could enable lateral movement, depending on service-account permissions and network access.

General mitigation guidance

Mitigation generally focuses on removing shell interpretation from data-driven command execution and reducing the trust placed in trigger inputs.

Common defensive patterns include:

  • Invoke HTTP clients directly with structured argument arrays rather than passing concatenated commands to /bin/sh -c.
  • Treat event header names and bodies as data, using APIs that preserve argument boundaries.
  • Apply strict allowlists and schema validation to trigger fields before command construction.
  • Avoid accepting attacker-controlled header names where they are not required.
  • Run CronJob containers with least-privilege service accounts, restricted capabilities, and minimal filesystem and network access.
  • Use read-only filesystems and isolated execution contexts where compatible with the workload.

How teams detect issues like this

Organizations can look for this vulnerability class through:

  • Static analysis rules identifying shell execution with concatenated or interpolated values.
  • Code review checks for /bin/sh -c, command-string assembly, and unsanitized event data reaching process execution.
  • Repository searches for curl or other command-line utilities constructed from trigger fields.
  • Policy enforcement requiring structured process APIs and prohibiting shell evaluation for untrusted input.
  • Runtime monitoring for unexpected child processes, shell activity, outbound connections, or command execution from CronJob containers.

Automated security review tools may help identify command construction and tainted-data flows during development.

Sources

SourceLink
github.comgithub.com/nuclio/nuclio/commit/3356b86a8bfab3f960aa420310ebff765df9dede
github.comgithub.com/nuclio/nuclio/releases/tag/1.16.4
github.comgithub.com/nuclio/nuclio/security/advisories/GHSA-v5px-423j-pf7p

Frequently asked

questions

It can be exploitable through a remote event path when an attacker can influence the relevant cron-trigger headers or body and cause the scheduled job to process them. Exploitability depends on the deployment's event sources and access controls.

Authentication may not be required if an exposed or weakly protected event source allows control of the affected fields. In other deployments, authenticated access to the trigger or an upstream event producer may be necessary.

Avoid passing constructed command strings through a shell. Use a structured process-execution interface with fixed commands and separately bounded arguments, combined with strict validation of event data.

Treat event content as untrusted, prohibit shell-based command construction in security-sensitive paths, apply least privilege to CronJob workloads, and use static analysis and code-review policies to detect tainted data reaching process execution.

Find out what's already
exploitable in your codebase.