/

CVE-2026-32604

Severity:

CRITICAL RISK

(9.9)

Improper Input Validation in Spinnaker Clouddriver GitRepo

CVE-2026-32604

Analyzed

Vulnerability type

Category:

Improper Input Validation

CWE:

CWE-20

Impact:

Remote Code Execution within CI/CD Orchestration Environment

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

Spinnaker clouddriver pods are vulnerable to arbitrary command execution when handling certain artifact types, allowing an attacker to run commands in the clouddriver container context.

When a bad actor can influence or control Git repository-based artifacts, they may be able to abuse insufficient input validation to execute arbitrary commands, potentially exposing credentials or manipulating deployed resources.

Affected context

This vulnerability affects Spinnaker deployments using vulnerable versions of clouddriver where Git repository (gitrepo) artifact types are enabled and actively used in pipelines.

It primarily arises when clouddriver processes external or semi-trusted artifact metadata and repository content as part of deployment operations, and not all parameters or paths are rigorously validated.

The issue is most relevant in environments where artifact definitions can be edited by multiple users or are sourced from external Git infrastructure that may be controlled or influenced by an attacker.

Exploit preconditions

  • Attack surface: Spinnaker clouddriver API and its processing of gitrepo artifact types within configured pipelines.
  • Required access: Ability to define, modify, or supply gitrepo artifacts or associated configuration (e.g., pipeline configuration, artifact definitions, or backing Git content).
  • Trigger point: Execution of a pipeline or operation that causes clouddriver to resolve and process the malicious gitrepo artifact.
  • Why exploitation is possible: Inputs controlling command parameters, repository handling, or execution flows are not sufficiently validated or constrained, allowing crafted values to be interpreted as commands or command arguments by underlying tooling.

Why this happens

The root cause aligns with CWE-20: Improper Input Validation, where clouddriver trusts artifact-related input more than it should.

Parameters derived from gitrepo artifact configuration and content are passed into command execution or tooling invocation with weak or missing validation and normalization.

Instead of restricting inputs to a safe, well-defined set of values and enforcing strict syntactic and semantic checks, the implementation allows attacker-controlled data to influence execution behavior, opening a path to arbitrary command execution in the clouddriver pod.

Potential impact

  • Exposure of sensitive credentials and secrets accessible from the clouddriver environment
  • Execution of arbitrary OS commands within clouddriver pods, potentially leading to container takeover
  • Deletion or modification of local files and configuration managed by clouddriver
  • Injection or manipulation of cloud resources (e.g., spinning up, altering, or tearing down infrastructure)
  • Lateral movement into connected services or build/deploy pipelines, depending on environment hardening

General mitigation guidance

Effective mitigation focuses on reducing trust in artifact inputs and constraining execution behavior:

  • Apply strict validation rules on artifact configuration fields, such as repository URLs, paths, and parameters, ensuring only expected formats and values are accepted.
  • Normalize and sanitize all values before they are passed to command-line tools, APIs, or interpreters, preventing control characters or unexpected flags from being introduced.
  • Isolate artifact-handling logic and disable support for artifact types that are not strictly required (for example, disabling gitrepo artifacts when not essential).
  • Apply least-privilege principles to clouddriver pods, limiting filesystem access, network egress, and credentials exposure so that even if commands are executed, their blast radius is reduced.
  • Use separate, locked-down service accounts and narrowly scoped roles for deployments triggered by Spinnaker to limit the impact of any abuse of its orchestration capabilities.

How teams detect issues like this

Organizations can look for this type of weakness using multiple complementary approaches:

  • Static analysis: Scan clouddriver-related code or custom extensions for places where artifact-derived values are passed directly into process execution APIs, shell commands, or external tools without robust validation or escaping.
  • Configuration review: Audit pipeline and artifact configurations for gitrepo artifacts, especially where untrusted or broadly writable repositories are used, and flag high-risk patterns (e.g., dynamic command parameters).
  • Runtime monitoring: Monitor clouddriver pods for unusual process invocations, command patterns, or file access anomalies, and alert on unexpected tooling being executed during pipeline runs.
  • Policy enforcement: Use policy-as-code systems to restrict which artifact types and repository locations are allowed in pipelines, coupled with automated checks in CI to prevent risky configurations from being merged.

Sources

SourceLink
github.comgithub.com/spinnaker/spinnaker/releases/tag/spinnaker-release-2025.3.2
github.comgithub.com/spinnaker/spinnaker/releases/tag/spinnaker-release-2025.4.2
github.comgithub.com/spinnaker/spinnaker/releases/tag/spinnaker-release-2026.0.1
github.comgithub.com/spinnaker/spinnaker/security/advisories/GHSA-x3j7-7pgj-h87r
zeropath.comzeropath.com/blog/spinnaker-rce-production-compromise

Frequently asked

questions

It can be, depending on how Spinnaker is exposed. If an attacker can access or manipulate pipeline or artifact configuration via the Spinnaker API or UI, especially over the network, they may be able to trigger remote code execution within clouddriver pods.

They generally need the ability to influence gitrepo artifact definitions or the Git content those artifacts reference. This can stem from having access to Spinnaker configuration (e.g., pipeline editing permissions) or to the underlying Git repositories used as artifacts.

The safest approach is to enforce strict input validation and sanitization on all artifact-driven parameters that can influence command execution or tooling behavior, combined with hardening the execution environment through least privilege and constrained runtime behavior.

Design artifact and pipeline handling with a clear trust model, avoid directly interpolating user or artifact data into commands, apply strong validation and whitelisting of allowed values, and complement this with policy enforcement and automated security testing in the development and deployment lifecycle.

Find out what's already
exploitable in your codebase.