/

CVE-2026-44795

Severity:

HIGH RISK

(8.8)

Unsafe YAML Deserialization (CWE-502) in Spinnaker

CVE-2026-44795

Analyzed

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-470, CWE-502

Impact:

Remote Code Execution in deployment pipelines

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

Unsafe YAML processing in Spinnaker's CloudFormation and CloudFoundry workflows allows arbitrary Java class loading when configuration templates are parsed with non-safe constructors.

If an attacker can influence these YAML inputs, they may achieve remote code execution within the continuous delivery environment during deployment or baking operations.

Affected context

This vulnerability appears in Spinnaker installations that rely on YAML-based configuration for CloudFormation deployments or CloudFoundry baking operations.

It manifests when YAML templates are processed with constructors that allow unrestricted Java type loading instead of safe, data-only deserialization.

Environments where template contents can be modified by external systems, shared repositories, or partially trusted users are more exposed, especially when these templates are parsed automatically as part of CI/CD workflows.

Exploit preconditions

  • Attack surface: YAML templates and configuration files used by CloudFormation deployments or CloudFoundry baking flows.
  • Required access: Ability to create, modify, or inject YAML content consumed by the affected Spinnaker components (e.g., via SCM repos, pipeline configuration, or artifact sources).
  • Trigger point: Execution occurs when Spinnaker parses the YAML templates using a non-safe constructor during deployment or baking.
  • Why exploitation is possible: The YAML processor permits arbitrary Java class instantiation, so attacker-controlled documents can cause code execution during deserialization.

Why this happens

The core flaw is the use of a YAML deserialization mechanism that treats input as executable structure rather than inert data.

By allowing non-safe constructors, the parser can instantiate arbitrary Java classes based on type metadata embedded in the YAML, aligning with CWE-502: Unsafe Deserialization.

Because class loading and initialization logic can have side effects, this behavior also maps to CWE-470: Use of Externally-Controlled Input to Select Classes or Code, where attacker-controlled input influences which code paths are invoked.

In abstract terms, the bug class is trusting configuration formats that support object graphs and type tags without constraining what can be instantiated or how those instances are executed.

Potential impact

  • Remote code execution within Spinnaker services handling deployments or baking.
  • Compromise of CI/CD pipelines and orchestration logic.
  • Unauthorized modification or deployment of application artifacts.
  • Lateral movement into cloud accounts or infrastructure managed by Spinnaker.
  • Data exposure or tampering in deployment configuration and secrets if accessible from the compromised runtime.

General mitigation guidance

Effective mitigation focuses on treating YAML configuration as data-only, not as a source of object graphs.

Recommended patterns include:

  • Using safe YAML parsers or constructors that disable type tags and arbitrary class instantiation.
  • Constraining deserialization to whitelisted, simple data structures with explicit schemas.
  • Separating untrusted or externally supplied templates from privileged processing paths and applying strict validation before use.
  • Running deployment and baking services with minimal privileges so that, even if parsing is abused, the blast radius is reduced.
  • Adopting a defense-in-depth approach where configuration repositories and artifact sources are tightly controlled and monitored for unexpected changes.

How teams detect issues like this

Teams can detect similar unsafe deserialization issues by:

  • Applying static analysis rules that flag YAML parsers configured with permissive or non-safe constructors.
  • Reviewing deployment and baking code paths for instances where configuration formats can influence class loading or reflection.
  • Enforcing secure coding guidelines that require data-only parsing for configuration files and prohibit dynamic type resolution from external inputs.
  • Using CI policies or automated review tools to block introduction of high-risk deserialization APIs and to highlight changes to configuration parsing logic.
  • Monitoring runtime logs and security telemetry for unusual class loading activity or deserialization-related exceptions during pipeline execution.

Sources

SourceLink
github.comgithub.com/spinnaker/spinnaker/commit/4cbe1d5fea9df573aadfd8b093fb4b594b354ee5
github.comgithub.com/spinnaker/spinnaker/commit/e57c0db4584b398473a7bbb19402ce6c1e89b627
github.comgithub.com/spinnaker/spinnaker/commit/f69d7b534d068ed74d0d3a1fbf17e2c945d36e5e
github.comgithub.com/spinnaker/spinnaker/security/advisories/GHSA-c8q4-9h32-2ww8

Frequently asked

questions

It can be, if attackers can remotely influence the YAML templates or configuration artifacts that Spinnaker consumes via repositories, artifact stores, or pipeline inputs. Direct network access to Spinnaker is not always required if they can control upstream configuration sources.

The attacker must be able to create or modify YAML content parsed in CloudFormation or CloudFoundry baking workflows. This may involve access to source control, artifact repositories, or pipeline configuration interfaces, depending on how the environment is set up.

The strongest fix is to switch to data-only deserialization by using safe YAML parsers that disable type tags and arbitrary object construction, combined with strict schema validation and avoidance of any configuration-driven class loading.

Future designs should assume configuration files are untrusted input, use parsers that treat them as plain data, avoid dynamic class selection based on configuration contents, and integrate automated checks in the development pipeline to detect and block unsafe deserialization patterns early.

Find out what's already
exploitable in your codebase.