/

CVE-2026-27170

Severity:

HIGH RISK

(7.1)

Server-Side Request Forgery (SSRF) in OpenSift URL Ingest

CVE-2026-27170

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-20, CWE-918

Impact:

Unauthorized network access via back-end HTTP requests

Severity:

HIGH RISK

(7.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

OpenSift versions 1.1.2-alpha and below contain a server-side request forgery (SSRF) issue in the URL ingest feature, where the backend can be tricked into fetching attacker-controlled destinations.

When a malicious user submits crafted URLs, the OpenSift host process may unintentionally access or probe internal or private network resources that are not otherwise exposed.

Affected context

The vulnerability exists in OpenSift deployments that expose the URL ingest capability and perform server-side fetching of user-supplied URLs.

It becomes relevant when:

  • Users can submit arbitrary URLs for ingestion or analysis
  • The OpenSift host has network visibility into internal services, private IP ranges, or metadata endpoints
  • There is no strict validation or allowlisting of outbound targets from the ingest component

In such setups, OpenSift may inadvertently act as a network proxy to resources that are not intended to be reachable from the public interface.

Exploit preconditions

  • Attack surface: The URL ingest endpoint or feature that accepts user-provided URLs.
  • Required access: Ability to submit or control URLs processed by OpenSift (e.g., via UI, API, or integrated workflow).
  • Trigger point: Initiation of a server-side fetch when OpenSift ingests the supplied URL.
  • Why exploitation is possible: The URL handling logic performs inadequate validation of destinations and allows requests to private or internal addresses, allowing an attacker to pivot through the OpenSift host's network context.

Why this happens

The underlying issue is insufficient input validation and trust in user-supplied URLs that are used for server-side HTTP requests.

This maps to:

  • CWE-918: Server-Side Request Forgery (SSRF), where an attacker influences a server to make arbitrary network requests.
  • CWE-20: Improper Input Validation, as the application does not robustly restrict or canonicalize the URL before use.

By treating external URLs as inherently safe destinations and not enforcing strict network-level or application-level allowlists, the backend can be coerced into connecting to unintended targets such as 127.0.0.1, RFC1918 addresses, or cloud metadata services.

Potential impact

  • Discovery or probing of internal network services (port scanning or service enumeration) from the OpenSift host.
  • Access to sensitive internal HTTP endpoints, dashboards, or APIs that are not exposed to the internet.
  • Retrieval of cloud instance metadata or credentials if the host can reach metadata services.
  • Use of OpenSift as a stepping stone for lateral movement within a private network, depending on surrounding controls.
  • Potential data exfiltration from internal endpoints that respond with sensitive content.

General mitigation guidance

Mitigation centers on tightening how URLs are accepted and where outbound requests are allowed to go:

  • Enforce strict network allowlists or explicit target domains/IP ranges for URL ingest rather than blocking only known-bad patterns.
  • Reject or isolate requests to private, loopback, link-local, or metadata address ranges by default, treating them as untrusted targets.
  • Normalize and parse URLs using battle-tested libraries, then validate host, scheme, and port against policy before making any request.
  • Separate the URL-fetching component into a constrained network segment or sandbox with minimal visibility into internal services.
  • Apply the principle of least privilege to outbound connectivity from OpenSift, restricting egress to only what is operationally required.
  • When using configuration flags such as OPENSIFT_ALLOW_PRIVATE_URLS, treat them as high-risk overrides and pair them with tight firewall rules and access control.

How teams detect issues like this

Detection typically combines code-level checks with runtime monitoring:

  • Static analysis and code review:
  • Look for HTTP client calls that directly consume user-supplied URLs without centralized validation.
  • Flag patterns that allow arbitrary schemes, ports, or raw host headers.
  • Ensure URL validation logic is centralized and consistently applied before any outbound request.
  • Configuration and policy enforcement:
  • Use security policies or linters that require allowlist-based egress rules for server-side fetch functionality.
  • Integrate checks in CI to prevent introduction of new code paths that make unguarded network requests.
  • Runtime monitoring:
  • Monitor outbound traffic from OpenSift hosts for unexpected destinations, especially private ranges and metadata endpoints.
  • Use network-level controls (firewalls, service meshes, or egress proxies) with logging to catch anomalous SSRF-like patterns.

Sources

SourceLink
github.comgithub.com/OpenSift/OpenSift/releases/tag/v1.1.3-alpha
github.comgithub.com/OpenSift/OpenSift/security/advisories/GHSA-3w2r-hj5p-h6pp

Frequently asked

questions

Yes, if the URL ingest feature is exposed to remote users and they can submit arbitrary URLs, a remote attacker can attempt SSRF against the OpenSift host's accessible network targets.

It depends on how OpenSift is deployed. If URL ingest is available to unauthenticated users, no additional privileges are required. If it is restricted, any user or integration that can control ingest URLs may be able to attempt exploitation.

The safest pattern is to implement strict allowlist-based validation of outbound destinations, disallow access to private and loopback ranges by default, and route all URL ingestion traffic through controlled egress points or proxies with enforced policies.

Treat all user-controlled URLs as untrusted input, centralize URL validation logic, apply the principle of least privilege to outbound network access, and include SSRF-focused reviews and automated checks in your development and deployment pipelines.

Find out what's already
exploitable in your codebase.