CVE-2026-75888

Executive Summary

CVE-2026-75888 is a Server-Side Request Forgery (SSRF) vulnerability in the OpenShift console. An authenticated console user can supply a specially crafted Helm chart URL that is not properly validated, causing the console pod to issue requests to arbitrary URLs on the user's behalf. Successful exploitation can disclose sensitive information via error messages and enable blind port scanning of services reachable from the console pod, with a CVSS base score of 7.7 (High).

Technical Analysis

The vulnerability resides in the OpenShift console's handling of user-supplied Helm chart URLs. According to the NVD description, the console accepts a Helm chart URL from an authenticated user and processes it without adequate validation of the destination. Because the request is performed server-side by the console pod, the attacker does not need direct network reachability to the target — the console pod acts as a proxy for the attacker's request.

The root cause maps to CWE-918 (Server-Side Request Forgery). The defining characteristic of this class is that an application fetches a remote resource based on attacker-controlled input, and the trust boundary between the attacker and the internal network is bypassed because the fetch originates from a privileged or internally-positioned component. In this case, the privileged component is the OpenShift console pod, which typically runs inside the cluster and therefore has network reachability to internal services, the Kubernetes API, cloud metadata endpoints, and other cluster-internal or infrastructure endpoints that an external or low-privilege user could not reach directly.

Two impact channels are explicitly described:

1. Information disclosure through error messages. When the console pod fetches an attacker-specified URL, responses — including error responses — may be surfaced back to the requesting user. Malformed or partial responses, connection errors, and HTTP status differences can leak information about the internal service being probed. This is the classic SSRF information-leak primitive: differences between "connection refused," "timeout," "HTTP 200," and "HTTP 403" disclose whether a service exists, whether it is listening, and something about its behavior.

2. Blind port scanning. Because the attacker controls the destination host and port embedded in the Helm chart URL, and because the console reports success or failure back to the user, the attacker can use the console pod as a port-scanning relay against the internal network. This is "blind" scanning because content is not necessarily returned — only the side channel of success/failure/timing.

The CVSS vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N is instructive:

• AV:N (Network) — the attack is launched over the network against the console.
• AC:L (Low) — no special conditions or race windows are required.
• PR:L (Low) — the attacker must be an authenticated console user. This is a significant barrier that limits the attacker population to legitimate account holders.
• UI:N (None) — no victim interaction is required; the attacker triggers the fetch themselves.
• S:C (Changed) — the exploited component (console pod) fetches resources in a security scope beyond the attacker's own. This is the key indicator of SSRF impact: the vulnerable component grants the attacker a different privilege/network context.
• C:H (High Confidentiality) — the leak channel can expose sensitive information from internal services.
• I:N / A:N — no integrity or availability impact is described.

The critical distinguishing factor of this CVE is the S:C (Scope Changed) rating. SSRF vulnerabilities that only reach the server's own context score lower; this one reaches beyond the vulnerable component's scope into the cluster network, elevating severity to 7.7.

No public proof-of-concept, Nuclei template, or exploit code exists for this CVE. The attack mechanism is inferred from the vulnerability class (SSRF via unvalidated Helm chart URL) and the NVD description. No specific function names, API parameters, or file paths are provided in the source data, so this report deliberately avoids naming implementation specifics that cannot be verified.

Exploitation Scenarios

No public PoC is available; the attack chain below is inferred from the vulnerability class and the NVD description. All steps use only concepts explicitly present in the description.

1) Reconnaissance / target identification. The attacker requires an authenticated account on the OpenShift console. With that access, they identify the console's Helm chart deployment workflow — the feature that accepts a Helm chart URL as user input. The attacker does not need network proximity to internal targets; the console pod provides that positioning.

2) Triggering the flaw class. The attacker supplies a Helm chart URL pointing at a destination of their choosing, rather than a legitimate chart repository. Because the URL is not properly validated server-side, the console pod initiates an outbound request to the attacker-controlled destination on the attacker's behalf. This is the SSRF trigger — user-controlled input becomes a server-side request.

3) Probing / payload method (vulnerability-class level). To perform blind port scanning, the attacker iterates over internal host/port combinations embedded in the Helm chart URL, observing whether the console reports a successful fetch, an error, or a timeout. Differences in these outcomes allow inference about whether a port is open and a service is listening. To attempt information disclosure, the attacker points the URL at internal services or metadata-style endpoints and inspects any error messages or response fragments returned to the console UI. No specific payload strings, internal hostnames, or endpoint paths are specified in the source data and none are fabricated here.

4) Post-exploitation impact. The attacker gains: (a) a map of internal network services reachable from the console pod (reconnaissance value for follow-on attacks), and (b) potentially sensitive information leaked through error messages, which could reveal configuration details, internal hostnames, service versions, or credentials embedded in responses. The impact is confidentiality-focused; no integrity or availability impact is described.

Impact Assessment

The blast radius is the set of network endpoints reachable from the OpenShift console pod. Because the console pod typically resides inside the cluster, this can include the Kubernetes API server, etcd-adjacent endpoints, internal service endpoints, other pods and services, and potentially cloud instance metadata endpoints where the console runs on cloud infrastructure. This is precisely why the CVSS vector assigns S:C (Scope Changed) — the attacker exploits a component whose network vantage point extends beyond their own.

CVSS subscores:

• Confidentiality: High (C:H) — sensitive information disclosure is a described outcome. Error-message leakage can expose internal service details, and in the worst case, reachable metadata services could disclose credentials or tokens.
• Integrity: None (I:N) — the description does not indicate data can be modified.
• Availability: None (A:N) — the description does not indicate a denial-of-service outcome.
• Attack Vector: Network (AV:N), Complexity: Low (AC:L), Privileges Required: Low (PR:L), User Interaction: None (UI:N).

Business impact: In multi-tenant OpenShift environments, an authenticated tenant user with ordinary console access could probe cluster-internal services belonging to other tenants or to the platform itself. This undermines the isolation assumptions of a shared cluster and can serve as a reconnaissance stage that precedes more severe attacks (for example, using discovered internal endpoints to target the API server or internal services). The requirement for authentication (PR:L) limits the attacker population to legitimate account holders, but in environments where many users hold console accounts — or where accounts are shared, weak, or obtainable — the practical exposure is broader.

The EPSS score is not yet assigned by FIRST.org; no exploitation-in-the-wild evidence exists; the CVE is not in CISA KEV. As of this writing, exploitation is opportunistic-to-conditional (requires an authenticated account) rather than mass-exploited.

Detection Guidance

Sigma Rule

title: OpenShift Console SSRF Attempt via Helm Chart URL
id: 8f3c1a72-6b4e-4c9d-9f21-2e7a5d0b4c11
status: experimental
description: Detects requests to the OpenShift console Helm chart workflow where the supplied chart URL targets internal RFC1918, loopback, link-local, or cloud metadata destinations, consistent with SSRF (CVE-2026-75888).
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-75888
author: Threat Intelligence
date: 2026/01/01
logsource:
  product: kubernetes
  service: audit
detection:
  selection_verb:
    verb:
      - create
      - update
    objectRef.resource:
      - helmchartrepositories
      - helmcharts
  selection_url:
    requestObject.url|contains:
      - '127.0.0.1'
      - 'localhost'
      - '169.254.169.254'
      - '10.'
      - '192.168.'
      - '172.16.'
      - '172.17.'
      - '172.18.'
      - '172.19.'
      - '172.2'
      - '172.30.'
      - '172.31.'
  condition: selection_verb and selection_url
falsepositives:
  - Legitimate administrators deploying charts from internal repositories using RFC1918 addresses.
level: medium
tags:
  - attack.t1190
  - cve.2026.75888

YARA Rule

rule CVE_2026_75888_OpenShift_Console_SSRF_HelmURL
{
    meta:
        description = "Detects HTTP request artifacts referencing OpenShift console Helm chart URL processing with internal-target SSRF indicators (CVE-2026-75888)"
        author = "Threat Intelligence"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-75888"
        date = "2026-01-01"
        severity = "high"

    strings:
        $helm1 = "helm" ascii nocase
        $helm2 = "chartUrl" ascii nocase
        $helm3 = "chart_url" ascii nocase
        $ssrf_meta = "169.254.169.254" ascii
        $ssrf_loop = "127.0.0.1" ascii
        $ssrf_rfc1918a = "192.168." ascii
        $ssrf_rfc1918b = "172.16." ascii
        $ssrf_rfc1918c = "10.0." ascii

    condition:
        (uint16(0) == 0x4854 or uint16(0) == 0x4f50) and
        any of ($helm*) and 1 of ($ssrf_*)
}

Suricata IDS Rule

alert http any any -> any any (msg:"CVE-2026-75888 OpenShift Console SSRF - Helm chart URL to internal target"; flow:established,to_server; http.method; content:"POST"; http.uri; content:"helm"; nocase; content:"169.254.169.254"; http.request_body; content:"169.254.169.254"; nocase; reference:cve,2026-75888; classtype:attempted-recon; sid:202675888; rev:1;)
alert http any any -> any any (msg:"CVE-2026-75888 OpenShift Console SSRF - Helm chart URL to RFC1918 target"; flow:established,to_server; http.method; content:"POST"; http.uri; content:"helm"; nocase; http.request_body; pcre:"/(127\.0\.0\.1|localhost|192\.168\.|10\.[0-9]+\.|172\.(1[6-9]|2[0-9]|3[01])\.)/i"; reference:cve,2026-75888; classtype:attempted-recon; sid:202675889; rev:1;)

Elastic Detection

sequence by process.entity_id with maxspan=5m
  [ network where process.name : "openshift-console*" and
      destination.address : ("127.0.0.1", "169.254.169.254", "10.*", "192.168.*", "172.16.*", "172.17.*", "172.18.*", "172.19.*", "172.2*.*", "172.30.*", "172.31.*") ]
  [ network where process.name : "openshift-console*" and
      destination.port : (22, 2379, 3306, 5432, 6443, 8080, 9200, 11211, 27017) ]

Splunk SPL Query

index=openshift sourcetype="kube:apiserver:audit"
| search verb=create objectRef.resource IN ("helmchartrepositories","helmcharts")
| where match(requestObject.url, "(?i)(127\.0\.0\.1|localhost|169\.254\.169\.254|192\.168\.|10\.[0-9]+\.|172\.(1[6-9]|2[0-9]|3[01])\.|:22|:2379|:3306|:5432|:6443|:9200|:27017)")
| stats count values(requestObject.url) as target_urls by user.username, sourceIPs, objectRef.resource
| where count >= 5
| sort - count

Wazuh OSSEC Rule

<group name="openshift,ssrf,">
  <rule id="2026758" level="10">
    <decoded_as>json</decoded_as>
    <field name="verb">create|update</field>
    <field name="objectRef.resource">helmchartrepositories|helmcharts</field>
    <regex type="pcre2" field="requestObject.url">(?i)(127\.0\.0\.1|localhost|169\.254\.169\.254|192\.168\.|10\.[0-9]+\.|172\.(1[6-9]|2[0-9]|3[01])\.)</regex>
    <description>CVE-2026-75888: OpenShift console Helm chart URL references internal target - possible SSRF via authenticated console user</description>
    <mitre>
      <id>T1190</id>
    </mitre>
  </rule>

  <rule id="2026759" level="12">
    <if_sid>2026758</if_sid>
    <field name="objectRef.resource">helmchartrepositories|helmcharts</field>
    <description>CVE-2026-75888: Repeated OpenShift console SSRF to internal port (possible blind port scan)</description>
    <mitre>
      <id>T1190</id>
    </mitre>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 (UNPATCHED — no patch evidence from any tracked source). No vendor fix version, no workarounds, and no affected version ranges have been published in the provided data. The following are risk-reduction measures, not vendor-confirmed remediations.

1) Immediate mitigations

• Restrict the population of users holding OpenShift console accounts; treat console access as a privileged entitlement and apply least-privilege RBAC so that only personnel who require Helm chart deployment capability can invoke the workflow.
• Apply network policy (Kubernetes NetworkPolicy or equivalent) to constrain egress from the console pod namespace. Deny egress to loopback, link-local (169.254.0.0/16, including 169.254.169.254), RFC1918 internal ranges, and the cluster API/etcd endpoints unless explicitly required. This directly attacks the SSRF primitive by removing reachability regardless of input validation.
• Block access to cloud instance metadata endpoints from the console pod via the platform's metadata service configuration (e.g., IMDSv2 enforcement and hop-limit restrictions on cloud nodes).
• Monitor and alert on the detection rules above; treat authenticated use of the Helm chart URL feature against internal addresses as suspicious by default.

2) Patch / upgrade steps

• No patch is currently available from tracked sources. Monitor the Red Hat OpenShift errata and security advisory channels and the NVD entry (CVE-2026-75888) for an official fix version. Until a fix is published, do not rely on upgrade as a control.
• When vendor guidance becomes available, validate that the update introduces server-side URL validation (blocklist/allowlist of destination hosts, SSRF-safe HTTP client, and redirect handling) before deployment.

3) Long-term hardening

• Implement an egress allowlist model for internal cluster components: any component that performs user-influenced outbound fetches should only be permitted to reach known, required destinations.
• Require SSRF-safe HTTP client behavior in any in-house or upstream code that fetches user-supplied URLs, including blocking redirects to non-approved hosts and rejecting non-HTTP(S) schemes.
• Enforce managed identity / workload identity patterns so that even if internal endpoints are reached, no reusable long-lived credentials are exposed in responses.
• Log and retain console audit events with the requesting user identity and full destination URL to support retrospective analysis of any prior SSRF abuse.

References

• NVD — CVE-2026-75888: https://nvd.nist.gov/vuln/detail/CVE-2026-75888
• MITRE CWE-918 — Server-Side Request Forgery (SSRF): https://cwe.mitre.org/data/definitions/918.html
• MITRE ATT&CK T1190 — Exploit Public-Facing Application: https://attack.mitre.org/techniques/T1190/
• OWASP — Server-Side Request Forgery Prevention Cheat Sheet: https://cheatsheetseries.owasp.org/cheatsheets/Server_Side_Request_Forgery_Prevention_Cheat_Sheet.html
• Red Hat OpenShift Security Advisories (monitor for CVE-2026-75888 fix): https://access.redhat.com/security/security-updates/

No known threat actor campaigns or exploit-in-the-wild evidence exist for this CVE. No public PoC, Nuclei template, or exploit code is available. The CVE is not in CISA KEV, and no EPSS score has been assigned by FIRST.org.