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
fromUrlexpression 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
fromUrlexpression) 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
fromUrlrequests. - 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).

