CVE-2026-75054

Executive Summary

CVE-2026-75054 is a server-side request forgery (SSRF) vulnerability in JetBrains IntelliJ IDEA affecting versions before 2026.2.1. The flaw is reachable through the IDE's OpenAPI preview proxy when a developer opens an untrusted project, allowing crafted content in that project to induce outbound HTTP requests from the victim's host to attacker-selected or internal destinations. Exploitation requires user interaction (opening a malicious project) but no privileges, and the vulnerable component's scope change (S:C) means the resulting request can cross a security boundary — reaching internal services or metadata endpoints — with high confidentiality impact and no direct integrity or availability impact, yielding a CVSS 3.1 base score of 6.3.

Technical Analysis

The vulnerability class is server-side request forgery, mapped to CWE-918. According to the available NVD description, the affected component is the OpenAPI preview proxy within IntelliJ IDEA. This proxy is part of the IDE's tooling for previewing OpenAPI/Swagger specifications, and by design it must issue HTTP requests on the user's behalf to render those previews. The security-relevant property is that these requests originate from the developer's workstation (or the IDE process) and therefore inherit that host's network position and credentials — a classic SSRF trust-boundary problem.

The trigger condition stated by the vendor is explicit: SSRF "was possible via the OpenAPI preview proxy in untrusted projects." IntelliJ IDEA distinguishes between trusted and untrusted projects, and untrusted projects are expected to run with restricted capabilities precisely because their contents are not vetted. This CVE indicates that the OpenAPI preview path did not uphold that expectation: content supplied by an untrusted project could cause the IDE to make requests that should have been blocked or gated behind user confirmation. No function names, class names, URL endpoints, parameters, or file paths are provided in the CVE description, so the exact request-construction code path cannot be named without speculation.

From the CVSS vector, the relevant properties are: attack vector Local (AV:L) — the attacker must get the victim to open a crafted project on their machine; attack complexity Low (AC:L); no privileges required (PR:N); user interaction required (UI:R) — the victim must open the project and reach the preview surface; scope Changed (S:C) — exploitation affects resources beyond the vulnerable component's own security authority, which is consistent with SSRF reaching external or internal hosts; confidentiality High (C:H) — data reachable by the outbound request can be read; integrity None (I:N) and availability None (A:N) — no direct modification or denial of service is attributed.

The combination of S:C/C:H with AV:L reflects the practical reality of IDE SSRF: the impact is not mass-exploitable over the internet, but when it does fire, it can read responses and relay them back to attacker-controlled infrastructure. Notably absent from the source data is any confirmed PoC, nuclei template, or exploit code; EPSS is 0.00120 (2.1st percentile), and the CVE is not in CISA KEV, indicating no observed exploitation in the wild at the time of writing.

Exploitation Scenarios

No public PoC is available; the attack chain below is inferred from the vulnerability class (SSRF via a preview proxy in untrusted projects) and must not be treated as a verified exploit recipe.

1. Reconnaissance and target identification. The attacker does not need to scan the victim's network first. Instead, the attacker identifies a target developer or team that uses IntelliJ IDEA for API development and distributes a project (repository, archive, or shared bundle) containing an OpenAPI specification crafted to reference attacker-controlled or internal destinations, along with whatever preview configuration is needed to reach the vulnerable proxy path. The distribution vector is social or supply-chain in nature: a public repo, a pull request, a "sample project" download, or a shared workspace.

2. Triggering the flaw class. When the victim opens the project, IntelliJ IDEA evaluates it as untrusted. Per the CVE description, the OpenAPI preview proxy in this state could still be induced to perform a request driven by project-controlled content. The victim must interact with the preview feature (UI:R) for the request to occur. Because the vulnerable component's handling of untrusted project content fails to enforce the expected restriction, the request is issued from the victim's environment rather than being blocked.

3. Payload and execution at the class level. The SSRF payload is the destination specified in the project-supplied OpenAPI content: the attacker points the proxy at an internal address (RFC1918 ranges, loopback, or link-local/cloud metadata endpoints) or at an attacker-controlled HTTP server. In a blind SSRF variant, the attacker relies on outbound callbacks to their own listener to confirm execution; in a non-blind variant, the response body rendered in the preview could expose internal data. Because the description does not enumerate request parameters or endpoints, no specific parameter names or URLs are asserted here.

4. Post-exploitation impact. Successful SSRF enables internal network reconnaissance, access to services bound to localhost or the internal network that are otherwise unreachable from outside, and potential retrieval of cloud instance metadata credentials where a metadata service is reachable. The Changed scope and High confidentiality rating reflect data exposure across a trust boundary. No integrity or availability impact is attributed by the CVSS vector, so the primary post-exploitation outcome is information disclosure and lateral-movement groundwork rather than host compromise.

Impact Assessment

The affected system is the developer workstation running IntelliJ IDEA before 2026.2.1, and by extension any network segment, internal service, or cloud metadata endpoint that workstation can reach. The blast radius is bounded by AV:L (the attacker must land a project on the victim's machine) but amplified by S:C: the vulnerable IDE component can cause actions affecting resources outside itself. The High confidentiality subscore means internal data, API responses, or credentials exposed via reachable services could be read; the None integrity and None availability subscores indicate the flaw itself does not alter or crash targeted systems.

Business impact is most acute for engineering organizations where developers routinely open third-party or untrusted repositories, and for environments where developer hosts have broad network reach (flat internal networks, over-permissive cloud IAM on instance roles). A single successful SSRF against a cloud metadata service can translate into credential theft for the workload's IAM role, which is a high-severity downstream consequence even though the CVE's direct CVSS score is 6.3 (Medium). The Low EPSS (0.00120, ~2.1st percentile) and absence from CISA KEV indicate low current exploitation likelihood, making this a prioritized-but-not-emergency remediation item.

Detection Guidance

Sigma Rule

title: Potential IntelliJ IDEA OpenAPI Preview Proxy SSRF Activity
id: 9f4a1c2e-7b3d-4e8a-a1f2-jetbrains-ssrf-2026
status: experimental
description: Detects IntelliJ IDEA process making outbound HTTP connections to internal or metadata addresses, consistent with CVE-2026-75054 (SSRF via OpenAPI preview proxy in untrusted projects).
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-75054
author: valtersit.com
date: 2026/01/01
tags:
  - attack.t1190
  - cve.2026-75054
logsource:
  category: network_connection
  product: windows
detection:
  selection_process:
    Image|endswith:
      - '\idea64.exe'
      - '\idea.exe'
      - '\java.exe'
  selection_dest:
    DestinationIp|cidr:
      - '127.0.0.0/8'
      - '10.0.0.0/8'
      - '172.16.0.0/12'
      - '192.168.0.0/16'
      - '169.254.0.0/16'
  filter_update:
    DestinationHostname|contains:
      - 'jetbrains.com'
      - 'plugins.jetbrains.com'
  condition: selection_process and selection_dest and not filter_update
falsepositives:
  - Legitimate local API development servers contacted by the IDE
  - Plugin updates resolving to internal mirrors
level: medium

YARA Rule

rule CVE_2026_75054_IntelliJ_SSRF_OpenAPI_Project
{
    meta:
        description = "Detects IntelliJ IDEA project artifacts referencing internal or metadata hosts in OpenAPI specs, consistent with CVE-2026-75054 SSRF via the OpenAPI preview proxy"
        author = "valtersit.com"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-75054"
        date = "2026-01-01"
        severity = "medium"

    strings:
        $openapi1 = "openapi:" ascii nocase
        $swagger  = "swagger:" ascii nocase
        $meta1    = "169.254.169.254" ascii
        $meta2    = "metadata.google.internal" ascii nocase
        $local1   = "127.0.0.1" ascii
        $local2   = "localhost" ascii nocase
        $priv1    = "10." ascii
        $priv2    = "192.168." ascii
        $priv3    = "172.16." ascii

    condition:
        (uint32(0) == 0x04034b50 or uint32(0) == 0x504b0304 or true) and
        ($openapi1 or $swagger) and
        ($meta1 or $meta2 or $local1 or $local2 or $priv1 or $priv2 or $priv3)
}

Suricata IDS Rule

alert http $HOME_NET any -> $HOME_NET any (msg:"CVE-2026-75054 Possible IntelliJ IDEA OpenAPI Preview SSRF Attempt"; flow:to_server,established; http.user_agent; content:"IntelliJ"; http.header; content:"Host"; content:"169.254.169.254"; nocase; classtype:attempted-recon; reference:cve,2026-75054; reference:url,nvd.nist.gov/vuln/detail/CVE-2026-75054; sid:202675054; rev:1;)

Elastic Detection

network where process.name in ("idea64.exe", "idea.exe", "java.exe") and
  destination.ip in ("127.0.0.1", "169.254.169.254", "metadata.google.internal") and
  event.action == "connection_attempted"

Splunk SPL Query

index=network OR index=proxy
| search (process_name="idea64.exe" OR process_name="idea.exe" OR process_name="java.exe")
| search (dest_ip="169.254.169.254" OR dest_ip="127.0.0.1" OR cidrmatch("10.0.0.0/8", dest_ip) OR cidrmatch("192.168.0.0/16", dest_ip) OR cidrmatch("172.16.0.0/12", dest_ip))
| stats count min(_time) as first_seen max(_time) as last_seen values(dest_ip) as destinations by src_ip, process_name, user
| where count > 0
| sort - count

Wazuh OSSEC Rule

<group name="intellij,cve-2026-75054,ssrf">
  <rule id="2026750" level="10">
    <if_sid>0</if_sid>
    <field name="process.name">idea64.exe|idea.exe</field>
    <field name="destination.ip">169.254.169.254|127.0.0.1|10.0.0.0/8|192.168.0.0/16|172.16.0.0/12</field>
    <description>CVE-2026-75054: IntelliJ IDEA process made outbound connection to internal or metadata address, possible OpenAPI preview SSRF</description>
    <mitre>
      <id>T1190</id>
    </mitre>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence is 2/4 — CLAIMED. The NVD description states that the issue exists in IntelliJ IDEA "before 2026.2.1," implying that 2026.2.1 contains the fix, but this has not been independently confirmed against a vendor advisory or a diff. Treat the version boundary as the best available guidance and verify against JetBrains' official security bulletin before relying on it.

1. Immediate mitigations (no patch confirmed):

   • Train developers not to open untrusted projects with full trust; keep the untrusted-project restrictions enabled and do not manually elevate trust for unknown repositories.
   • Restrict developer workstation egress so that loopback, RFC1918, and link-local metadata addresses (169.254.169.254) are not reachable from IDE processes, or block these destinations at the host firewall/proxy.
   • Disable or avoid the OpenAPI preview feature when working with projects of unknown provenance.
   • Where developers run on cloud instances, enforce IMDSv2 and minimize instance-role permissions so that any SSRF-driven metadata access yields limited value.

2. Patch/upgrade steps:

   • Upgrade IntelliJ IDEA to 2026.2.1 or later once the vendor advisory confirms the fix. Use the IDE's built-in update mechanism or the official JetBrains download channel.
   • Verify the installed build number after upgrading and confirm the update was applied across all developer endpoints, including managed/offline installations.
   • Because patch confidence is only 2/4, cross-check the JetBrains security advisory and release notes for 2026.2.1 before closing the ticket.

3. Long-term hardening:

   • Enforce a trust model where unreviewed repositories are always opened as untrusted.
   • Segment developer networks so IDE hosts cannot freely reach sensitive internal services or cloud metadata endpoints.
   • Monitor IDE process network connections for anomalous internal destinations (see Detection Guidance) and alert on metadata-service access from developer hosts.
   • Maintain an inventory of developer tooling versions and subscribe to JetBrains security advisories for timely CVE notification.

References

• NVD — CVE-2026-75054: https://nvd.nist.gov/vuln/detail/CVE-2026-75054
• CWE-918 Server-Side Request Forgery: https://cwe.mitre.org/data/definitions/918.html
• JetBrains Security Bulletins / IntelliJ IDEA Release Notes (2026.2.1): https://www.jetbrains.com/privacy-security/issues/ and https://www.jetbrains.com/idea/download/
• FIRST EPSS (CVE-2026-75054, score 0.00120): https://api.first.org/data/v1/epss?cve=CVE-2026-75054
• CISA Known Exploited Vulnerabilities Catalog (not listed as of report date): https://www.cisa.gov/known-exploited-vulnerabilities-catalog

Note on exploitation evidence: No public PoC, nuclei template, or exploit code was identified for CVE-2026-75054, and the CVE is not present in CISA KEV. No threat actor campaigns have been associated with this CVE in the available data. Technical specifics not present in the NVD description (function names, endpoints, request parameters) have intentionally not been asserted.