/

CVE-2025-61916

Severity:

HIGH RISK

(7.9)

SSRF in Spinnaker Artifact Providers

CVE-2025-61916

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-20, CWE-523, CWE-918

Impact:

Internal network access and potential credential exposure via server-side requests

Severity:

HIGH RISK

(7.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 artifact providers prior to specific fixed releases contain a server-side request forgery (SSRF) flaw that lets users supply arbitrary URLs which Spinnaker then fetches on their behalf.

When combined with components that consume artifact output, this can be abused to reach internal services, access cloud metadata or internal Spinnaker APIs, and potentially exfiltrate credentials and authentication tokens into pipelines or remote endpoints.

Affected context

The vulnerability affects Spinnaker deployments that:

  • Enable artifact types that accept user-controlled URLs, such as HTTP artifacts, GitHub file artifacts, BitBucket, GitLab, or similar providers.
  • Use downstream systems (e.g., Rosco, Helm integrations, Kubernetes manifest accounts) that consume the fetched artifact data within pipelines.
  • Allow users to define or modify pipelines that reference these artifact sources.

In such configurations, artifact resolution can cause the Spinnaker services to issue HTTP requests to attacker-specified locations, including internal endpoints not otherwise exposed to the user.

Exploit preconditions

  • Attack surface: Spinnaker API and UI functionality that lets users define artifacts or pipeline stages with user-supplied URLs.
  • Required access: Ability to configure or influence pipeline definitions or artifact configurations (typically authenticated Spinnaker users with pipeline editing permissions).
  • Trigger point: Artifact resolution or pipeline execution that causes Spinnaker to fetch resources from the configured URL.
  • Why exploitation is possible: The artifact providers trust user-supplied URLs without sufficient validation, network-level restrictions, or clear separation of internal versus external targets, enabling requests to internal services or metadata endpoints.

Why this happens

The core issue is unvalidated and over-trusted user input in URL fields used by artifact providers.

When a pipeline or artifact configuration accepts a URL from the user, the system performs server-side HTTP requests without robust validation of the target, network egress controls, or clear scoping to allowed domains.

This aligns with CWE-918: Server-Side Request Forgery (SSRF), and is compounded by insufficient input validation (CWE-20) and potential exposure of sensitive authentication data in transit or in responses (CWE-523).

Conceptually, the bug class is: "backend services making arbitrary network calls dictated by user-controlled parameters, then reusing that data in privileged contexts."

Potential impact

  • Access to internal Spinnaker APIs via GET or similar endpoints that are not directly exposed to users.
  • Retrieval of cloud metadata (e.g., AWS link-local metadata) through unauthenticated HTTP artifact providers.
  • Injection of sensitive configuration or authentication data (such as IDMSv1 auth data) into pipelines, Helm values, or manifests.
  • Exposure of credentials or auth headers (e.g., GitHub or other service tokens) to attacker-controlled endpoints in some artifact workflows.
  • Use of internal network reachability to map services or pivot toward more impactful attacks depending on deployment architecture.

General mitigation guidance

Effective mitigation focuses on constraining where server-side HTTP requests may go and reducing trust in user-supplied URLs:

  • Prefer artifact types that require preconfigured, vetted URLs or repositories instead of arbitrary user input.
  • Enforce strict allowlists or patterns for artifact URLs, limiting requests to known domains or paths under organizational control.
  • Introduce network-level egress controls for Spinnaker components so they cannot reach link-local metadata services or sensitive internal networks by default.
  • Separate credentials and authentication headers from user-controlled destinations, ensuring tokens are only attached to known, trusted endpoints.
  • Apply least-privilege principles to artifact-consuming systems (e.g., Rosco, Kubernetes accounts) so that even if unexpected data is injected, the blast radius is minimized.
  • Use policy engines (such as OPA-based solutions) to prevent saving or executing pipelines that reference unapproved or unsafe URLs.

How teams detect issues like this

Organizations can detect and monitor SSRF-style behavior in Spinnaker through:

  • Static or configuration analysis that flags artifact providers or pipeline stages allowing free-form URLs, especially those pointing to internal IP ranges, link-local addresses, or metadata endpoints.
  • Code and configuration reviews that look for patterns where user-supplied URLs are fetched server-side without domain restrictions or network segmentation.
  • Runtime monitoring of outbound HTTP requests from Spinnaker components, with alerts for access to internal address ranges (e.g., 169.254.169.254, RFC1918 networks) or unusual external endpoints.
  • Policy enforcement in CI/CD (e.g., OPA or similar tools) to block or require approval for pipelines that include HTTP artifacts or other URL-based inputs outside of approved scopes.
  • Periodic security testing, including internal SSRF checks, to validate that network controls and URL validation rules operate as expected.

Sources

SourceLink
github.comgithub.com/spinnaker/spinnaker/security/advisories/GHSA-vrjc-q2fh-6x9h

Frequently asked

questions

It is typically exploitable by authenticated users who can create or modify Spinnaker pipelines or artifact configurations. External attackers would generally need an account or another way to influence these configurations.

The attacker usually needs permissions to define or edit pipelines that use vulnerable artifact providers, or to otherwise supply URLs that Spinnaker will fetch. The exact scope depends on how access control is configured within the Spinnaker deployment.

Restrict artifact providers so they cannot fetch from arbitrary user-supplied URLs, enforce domain/URL allowlists, and ensure that server-side requests are only made to trusted destinations. Additionally, decouple sensitive authentication data from any flow that involves user-controlled URLs.

Design pipeline and artifact features with the assumption that URL inputs are untrusted: validate and constrain destinations, apply network egress controls, and enforce policies that block unsafe configurations before they are saved. Regular security reviews of CI/CD configurations and automated checks for SSRF patterns further reduce the risk of recurrence.

Find out what's already
exploitable in your codebase.