/

CVE-2026-25534

Severity:

CRITICAL RISK

(9.1)

SSRF in Spinnaker Clouddriver and Orca

CVE-2026-25534

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Server-Side Request Forgery that can reach internal network resources and sensitive endpoints

Severity:

CRITICAL RISK

(9.1)

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's URL validation logic in Clouddriver and Orca can be bypassed using specially crafted URLs that abuse how Java's URL parser treats underscores.

In environments where user-controlled URLs are used to fetch artifacts or remote resources, this bypass can enable server-side request forgery (SSRF) against internal services and metadata endpoints.

Affected context

This vulnerability appears in Spinnaker components that accept user-supplied URLs and rely on Java's URL parsing for validation, including:

  • Clouddriver URL validation for artifact and remote resource handling
  • Orca fromUrl expression handling for pipeline configuration

It becomes relevant when:

  • Users or automated systems can configure or influence URLs that Spinnaker will later fetch, and
  • Those URLs are intended to be constrained to specific hosts, protocols, or network locations, but the constraints are enforced using Java URL parsing that mishandles underscores.

Exploit preconditions

  • Attack surface: HTTP(S) APIs or configuration interfaces where a user can provide or influence URLs used by Clouddriver and Orca.
  • Required access: Ability to create or modify pipeline definitions, artifacts, or expressions that reference URLs (e.g., authenticated Spinnaker user with pipeline or artifact configuration permissions).
  • Trigger point: Spinnaker evaluates or fetches the supplied URL (for example, resolving an artifact or evaluating a fromUrl expression) using the flawed validation logic.
  • Why exploitation is possible: The validation relies on Java URL objects which do not correctly handle underscores in hostnames; attackers can craft URLs whose parsed representation passes validation while the actual network request targets a restricted or internal endpoint, bypassing prior protections added for CVE-2025-61916.

Why this happens

The core issue is reliance on Java's URL parsing for security decisions instead of using stricter, specification-compliant URL and hostname validation.

When underscores appear in host components, Java's URL handling can interpret or normalize them in ways that diverge from the intended security policy.

This mismatch lets an attacker supply a URL that:

  • Appears safe after parsing and validation, but
  • Ultimately results in a network call to an unintended or restricted target.

This maps to CWE-918: Server-Side Request Forgery (SSRF), where inadequate validation of user-provided URLs allows the server to initiate arbitrary network requests on behalf of the attacker.

Potential impact

  • SSRF to internal HTTP services not directly exposed to the internet
  • Access to cloud instance metadata services, which may reveal credentials or tokens
  • Interaction with internal APIs leading to data exposure or state changes
  • Potential pivoting within the internal network, depending on network topology and trust boundaries
  • Assistance in chaining with other vulnerabilities (e.g., hitting internal admin panels or debug endpoints)

General mitigation guidance

Effective mitigation focuses on hardening URL validation and constraining outbound requests:

  • Use strict URL and hostname validation independent of generic Java URL parsing, enforcing allowed schemes, host patterns, and ports explicitly.
  • Implement an allowlist of acceptable destinations (domains, CIDR blocks, or service endpoints) for artifact and fromUrl requests.
  • Block requests to link-local, loopback, and internal-only IP ranges unless explicitly required and carefully controlled.
  • Normalize and validate hostnames and IP addresses before making outbound requests, rejecting any malformed or ambiguous inputs (including those with underscores where not permitted).
  • Segregate network access for components that resolve user-supplied URLs, using egress filtering and firewall rules so they cannot reach sensitive services such as metadata endpoints.
  • Apply least-privilege principles to credentials available to services that can perform outbound HTTP requests, limiting blast radius if SSRF occurs.

How teams detect issues like this

Detection generally combines code-centric and runtime approaches:

  • Static analysis and code review:
  • Flag usages where user-controlled URL strings are passed directly into Java URL/URI constructors and then used for security-sensitive routing or validation.
  • Look for validation that checks only string patterns or Java URL fields without independent hostname/IP verification or network-level allowlists.
  • Identify expression handlers (e.g., fromUrl) or artifact resolvers that accept remote URLs without enforcing destination constraints.
  • Configuration and policy enforcement:
  • Enforce policies in CI/CD pipelines requiring explicit allowlists for outbound requests originating from artifact resolution and expression evaluation components.
  • Use automated review tools or security linters to ensure SSRF-safe HTTP client wrappers are used instead of raw URL-based network calls.
  • Operational monitoring:
  • Monitor outbound HTTP traffic from Spinnaker components for connections to unusual or internal-only destinations.
  • Add logging when URL validation fails and alert on suspicious URL patterns (such as unexpected underscores in hostnames or attempts to reach metadata IP ranges).

Sources

SourceLink
github.comgithub.com/spinnaker/spinnaker/commit/7c4737906239a958a468e843239c6785b03d0eda
github.comgithub.com/spinnaker/spinnaker/security/advisories/GHSA-8r8j-gfhg-fw38
github.comgithub.com/spinnaker/spinnaker/security/advisories/GHSA-vrjc-q2fh-6x9h

Frequently asked

questions

Yes, in typical deployments it can be exploited remotely by any attacker who can authenticate and provide or modify URLs in Spinnaker pipeline or artifact configuration. The actual network requests, however, originate from the internal Spinnaker infrastructure, not from the attacker's machine.

The attacker usually needs sufficient permissions to create or edit pipelines, artifacts, or expressions that reference URLs (for example, a compromised user account or API token with those privileges). Public unauthenticated exploitation is unlikely unless such configuration interfaces are exposed without access control.

The safest pattern is to decouple security decisions from generic Java URL parsing, instead enforcing strict, explicit validation and allowlists for destination hosts and networks, combined with network-layer egress controls so that components handling user-supplied URLs cannot reach sensitive internal services.

Future features should treat any user-controlled URL as untrusted input, route all outbound requests through hardened, SSRF-aware HTTP clients, enforce allowlists and IP range restrictions, and incorporate SSRF checks into design reviews, threat modeling, and automated security testing pipelines.

Find out what's already
exploitable in your codebase.