/

CVE-2026-28677

Severity:

HIGH RISK

(8.2)

SSRF in OpenSift URL Ingestion Pipeline

CVE-2026-28677

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized Network Access via SSRF

Severity:

HIGH RISK

(8.2)

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's URL ingestion pipeline previously allowed user-supplied URLs to be fetched by the server with incomplete restrictions on where outbound requests could go.

In non-localhost deployments, gaps around credentialed URLs, non-standard ports, and cross-host redirects could be abused to make the server initiate unintended network requests, creating SSRF-style exposure to internal or protected services.

Affected context

The vulnerability occurs in OpenSift deployments where the application ingests data from user-provided remote URLs as part of its semantic search and AI processing pipeline.

While some checks existed to block access to localhost-style addresses, the protections did not fully cover:

  • URLs containing embedded credentials
  • Requests to non-standard ports
  • Redirect chains that could change the final destination host

In environments where OpenSift can reach internal services or metadata endpoints, this incomplete restriction may expose internal network resources to indirect user control.

Exploit preconditions

  • Attack surface: OpenSift's URL ingest endpoint or any feature that allows users to submit remote URLs for processing.
  • Required access: Ability to supply or influence a URL that the server will fetch (e.g., via web UI, API, or integration).
  • Trigger point: The backend component that fetches the URL as part of the ingest pipeline, following redirects and connection parameters.
  • Why exploitation is possible: Outbound request filtering focused mainly on localhost checks and did not robustly account for credential-bearing URLs, non-standard ports, or cross-host redirects, allowing crafted URLs to bypass intended destination restrictions.

Why this happens

This issue stems from incomplete validation and normalization of user-controlled URLs before the server performs outbound HTTP requests.

The implementation appears to rely on host-based checks (e.g., blocking localhost) without fully addressing:

  • Scheme and authority parsing quirks (including embedded credentials)
  • Restrictions on allowed ports and protocols
  • Enforcing that all redirects remain within an approved destination set

Conceptually, this maps to CWE-918: Server-Side Request Forgery (SSRF), where an attacker controls a server-side HTTP client to access internal or otherwise restricted network locations.

The underlying insecure pattern is treating user-supplied URLs as trusted destinations with only partial, host-focused filtering rather than a holistic allowlist and strict redirect/control flow.

Potential impact

  • Attackers may coerce the server into making requests to internal network services not directly exposed to the internet.
  • The application could be used to probe internal hosts and ports, aiding reconnaissance of internal infrastructure.
  • Sensitive metadata or configuration endpoints (e.g., cloud instance metadata, internal APIs) could potentially be accessed and their responses relayed.
  • Outbound requests with embedded credentials may be abused to reach protected services with the application's own privileges.
  • Under certain architectures, SSRF-driven requests might be chained with other weaknesses to escalate to data exfiltration or remote code execution on downstream services.

General mitigation guidance

Effective mitigation focuses on robustly constraining server-initiated HTTP requests triggered by user input:

  • Prefer an explicit allowlist of reachable domains, IP ranges, and ports for any URL-fetching functionality instead of only blocking localhost/private ranges.
  • Normalize and strictly parse URLs before use, rejecting or stripping:
  • Embedded credentials in the authority component
  • Unsupported schemes and non-HTTP(S) protocols
  • Non-standard or unapproved ports
  • Enforce redirect policies that:
  • Limit the number of redirects
  • Re-validate each redirect target against the same allowlist
  • Disallow cross-host or cross-scheme redirects unless explicitly required and safe
  • Run network calls through a restricted egress layer (e.g., firewall rules, proxy with enforced policies) so application bugs cannot reach sensitive internal services.
  • Apply least privilege to network permissions: segregate the URL ingestion component from internal networks wherever practical.
  • Treat URL ingestion as untrusted input in design reviews, and document its threat model so that SSRF considerations are built into future changes.

How teams detect issues like this

To detect and monitor similar issues:

  • Use static analysis and linting rules to flag generic HTTP client calls that accept user-derived URLs without passing through a central validation/allowlist module.
  • In code review, look for:
  • Direct use of user input to construct URLs or HTTP client requests
  • Inconsistent or ad hoc hostname/port checks across different call sites
  • Lack of redirect handling policies or missing validation after redirects
  • Implement centralized URL validation helpers and enforce their use via code ownership rules or architectural guidelines.
  • Deploy network-level monitoring (e.g., proxy logs, egress firewall logs) to detect unusual outbound patterns, such as requests to internal IP ranges from public-facing components.
  • Security testing (including DAST and manual penetration tests) can specifically attempt SSRF-style payloads, covering credentialed URLs, non-standard ports, and redirect chains to validate protections.

Sources

SourceLink
github.comgithub.com/OpenSift/OpenSift/commit/1126e0a503876056a68a434e19f64158a5a4840b
github.comgithub.com/OpenSift/OpenSift/commit/de99b9c
github.comgithub.com/OpenSift/OpenSift/pull/67
github.comgithub.com/OpenSift/OpenSift/releases/tag/v1.6.3-alpha
github.comgithub.com/OpenSift/OpenSift/security/advisories/GHSA-5jfc-p787-2mf9

Frequently asked

questions

Yes, if an attacker can submit or control URLs processed by OpenSift's URL ingestion pipeline from a remote interface, they can attempt to direct the server's outbound requests to unintended destinations.

The attacker needs the ability to provide a URL that the application will fetch—typically through an authenticated user action or an exposed API endpoint. They do not need direct network access to internal services; the application's network position is leveraged instead.

The safest general pattern is to centralize URL handling behind a strict allowlist-based policy: only permit outbound requests to explicitly approved domains/ports, normalize and validate URLs before use, enforce safe redirect behavior, and ensure the egress path itself is constrained by network controls.

Treat any server-side HTTP client functionality as a high-risk surface by default. During design and code review, require:

  • Use of shared URL validation utilities and allowlists
  • Clear documentation of expected destinations and ports
  • Tests and security checks that cover redirects, credentialed URLs, and edge cases

Combining disciplined coding practices with network-layer egress restrictions helps prevent SSRF-style bugs from becoming exploitable.

Find out what's already
exploitable in your codebase.