CVE-2026-75052

Executive Summary

CVE-2026-75052 is a command injection vulnerability (CWE-77) affecting JetBrains IntelliJ IDEA versions prior to 2026.2.1. An attacker who can deliver a crafted Markdown file to a developer can achieve operating-system command execution when the file is rendered in the IDE's Markdown preview pane — but only within projects the developer has marked as trusted. The vulnerability carries a CVSS base score of 3.6 (Low), reflecting the local attack vector, high complexity, required user interaction, and limited confidentiality/integrity impact. No public proof-of-concept, in-the-wild exploitation, or CISA KEV listing has been reported as of this writing; patch evidence from tracked sources is currently rated 0/4 (unpatched), although the NVD description implies a fix landed in version 2026.2.1.

Technical Analysis

The flaw belongs to the command injection class (CWE-77). IntelliJ IDEA ships a Markdown preview renderer that processes .md files inside the IDE's built-in preview panel. The NVD description discloses that command execution via crafted Markdown preview content was possible in trusted projects — i.e., in projects that the user explicitly trusted through the IDE's project-trust confirmation dialog.

Attack mechanics at the class level:

• The Markdown preview pipeline parses Markdown and translates it into rendered HTML or invokes related processing steps (link handling, embedded code fences, HTML passthrough, or preview refresh logic).
• A crafted document can inject content that the preview pipeline interprets as a command to be passed to the operating system, rather than inert text. Given the CWE-77 classification, the injection is executed through a shell command-builder context rather than purely client-side script execution.
• The project-trust gate is a key precondition. IntelliJ's trust model is designed to suppress dangerous operations in untrusted projects; this vulnerability demonstrates that once a project is trusted, the Markdown preview path does not sanitize or isolate the content, allowing command execution with the privileges of the IDE process (i.e., the logged-in developer user).
• The attack surface is the local IDE, not a network service. The crafted content can arrive via a cloned Git repository, a pull-request diff with an attached .md file, a zipped project archive, a documentation bundle, or any other channel that places a Markdown file on the developer's workstation.

Insufficient technical detail is available in the public description to name the specific parser function, internal API, or preview component involved. The analysis above is derived strictly from the vulnerability class and the disclosed trigger conditions.

Exploitation Scenarios

No public PoC exists; the chain below is inferred from the vulnerability class and the NVD description.

1. Reconnaissance / target identification. The attacker identifies a developer who uses IntelliJ IDEA versions below 2026.2.1 and who regularly handles Markdown content (documentation, README.md, knowledge-base files, Jekyll/Docusaurus sources). Developer identities and tooling are often observable from commit metadata, public profiles, or contribution activity.

2. Delivery of the malicious document. The attacker delivers a crafted Markdown file through a channel that is natural for the victim: a contribution to a repository the developer subsequently clones, a pull request the developer reviews in the IDE, a shared project archive, or an embedded documentation file in a dependency. Because the target is a file preview feature, no network-facing service is exploited and no inbound connection to the developer's machine is required.

3. Triggering the flaw. The victim opens the project in IntelliJ IDEA and confirms it as a trusted project (the IDE's standard prompt). The victim then opens the .md file, which renders in the Markdown preview pane. The malicious content embedded in the Markdown is processed by the preview pipeline and reaches the command-execution sink (CWE-77), causing the IDE process — running with the developer's user privileges — to execute an operating-system command.

4. Post-exploitation impact. The injected command runs in the context of the logged-in user. A typical payload could drop a beacon, exfiltrate SSH keys and cloud credentials from ~/.ssh and credential managers, steal JetBrains saved credentials and IDE configuration (including tokens for Git hosts and CI systems), or stage a backdoor for lateral movement inside the developer's workstation and the internal network reachable from it. Because the execution occurs during normal developer activity, it blends into legitimate IDE child-process activity (builds, terminal, version control).

Impact Assessment

The CVSS vector (CVSS:3.1/AV:L/AC:H/PR:N/UI:R/S:U/C:L/I:L/A:N) breaks down as follows:

• Attack Vector: Local (L) — exploitation requires the attacker to place a file on the victim's machine; there is no remote network exposure of the IDE.
• Attack Complexity: High (H) — the attacker must craft a Markdown payload that survives the preview pipeline and reaches the injection point, and the victim must cooperate by opening the file in a trusted project.
• Privileges Required: None (N) — no credentials or privileges are needed to craft the malicious document.
• User Interaction: Required (R) — the victim must render the document in the Markdown preview.
• Scope: Unchanged (U) — the compromise is confined to the affected component's security context.
• Confidentiality / Integrity: Low (L) — the attacker can read or modify data accessible to the IDE process, but not fully take over the host or pivot the scope.
• Availability: None (N) — no direct denial-of-service impact is scored.

Business impact is nonetheless significant in software supply-chain contexts. Developer workstations routinely hold source code, signing keys, VPN credentials, and CI/CD tokens. A single successful injection can compromise the integrity of the codebase a developer is working on, abuse their Git identity for malicious commits, or escalate to broader network access. The "trusted project" precondition makes the flaw more dangerous, not less: organizations commonly instruct developers to trust all internal repositories, which effectively disables the protective trust boundary for every project in the company. Affected systems are JetBrains IntelliJ IDEA instances below 2026.2.1 on Windows, macOS, and Linux, as well as downstream products that share the same Markdown preview implementation (unconfirmed from public data).

Detection Guidance

The rules below are generic detections for the vulnerability class. Because no specific payload or trigger artifact has been published, these rules target (a) suspicious child processes spawned from the IDE process, and (b) Markdown files carrying command-injection primitives. Tune baselines carefully, as IDEs legitimately spawn shells for builds and terminals.

Sigma Rule

title: Suspicious Child Process Spawned by JetBrains IntelliJ IDEA
id: 6c5c3b0e-7505-2a26-9c2e-8f0a0d4e77a1
status: experimental
description: >
  Detects command interpreters spawned from IntelliJ IDEA (idea64.exe / idea.exe)
  with arguments typical of command execution, potentially indicative of
  CVE-2026-75052 exploitation via crafted Markdown preview content.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-75052
author: valtersit.com
date: 2026/02/01
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith:
      - '\idea64.exe'
      - '\idea.exe'
  selection_child:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\bash.exe'
      - '\wsl.exe'
      - '\cscript.exe'
      - '\wscript.exe'
  selection_suspicious_args:
    CommandLine|contains:
      - ' -enc '
      - ' -e '
      - ' iex'
      - ' Invoke-Expression'
      - ' certutil'
      - ' -nop '
      - ' /c '
      - ' -c '
  condition: all of selection_*
falsepositives:
  - Legitimate IDE build steps (Maven, Gradle, npm) executed from the IDE UI
  - Embedded terminal usage by the developer
  - Third-party plugins invoking shells
level: medium

YARA Rule

rule JetBrains_Markdown_Preview_Exec_Indicators
{
    meta:
        author = "valtersit.com"
        description = "Detects Markdown files containing embedded HTML/script/command patterns relevant to CVE-2026-75052 (crafted Markdown preview command execution)"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-75052"
        date = "2026-02-01"
        cve = "CVE-2026-75052"
    strings:
        $s_script = /<script[\s>]/i
        $s_iframe = /<iframe[\s>]/i
        $s_onerr  = /onerror\s*=/i
        $s_onload = /onload\s*=/i
        $s_jsproto = /[\]\)]\(\s*javascript:/i
        $s_ps     = /powershell(\s|\.exe)/i
        $s_cmd    = /cmd(\s|\.exe)|cmd\/c/i
        $s_curl   = /curl(\s|\.exe)/i
        $s_wget   = /wget(\s|\.exe)/i
        $s_dollar = /`[^`]*\$\s*\(/i
        $s_env    = /\$\{IFS\}|%COMSPEC%/i
    condition:
        (filesize < 2MB) and (extension == "md" or extension == "markdown") and 2 of them
}

Suricata IDS Rule

alert http any any -> any any (msg:"CVE-2026-75052 JetBrains IntelliJ IDEA Markdown Preview Command Injection Attempt"; flow:established,to_server; content:".md"; http.uri; pcre:"/<script[\s>]|javascript:|onerror\s*=|powershell|cmd\.exe|Invoke-Expression/i"; classtype:attempted-user; sid:202675052; rev:1; metadata:created_at 2026_02_01, cve CVE-2026-75052, severity low;)

Note: network detection of this vulnerability is inherently limited. The primary execution path is a local file rendered inside a desktop GUI application, which produces no network request at trigger time. This rule may catch Markdown payloads exfiltrated over HTTP (e.g., downloaded from a malicious repo or uploaded to a code-review service). Endpoint-level detection is the recommended primary control.

Elastic Detection

process where process.parent.name in ("idea64.exe", "idea.exe") and
  process.name in ("cmd.exe", "powershell.exe", "pwsh.exe", "bash.exe", "sh", "zsh", "cscript.exe", "wscript.exe") and
  (
    process.command_line regex~ ".*(-enc|-nop|Invoke-Expression|iex|cmd\\s*/c|/c\\s+).*" or
    process.command_line regex~ ".*(certutil|curl|wget|powershell).*"
  )

Splunk SPL Query

index=endpoint
  (ParentImage="*idea64.exe" OR ParentImage="*idea.exe" OR (ParentImage="*java.exe" AND ParentImagePath="*JetBrains*"))
  (Image="*cmd.exe" OR Image="*powershell.exe" OR Image="*pwsh.exe" OR Image="*bash.exe" OR Image="*sh" OR Image="*zsh")
  (CommandLine="*-enc*" OR CommandLine="*Invoke-Expression*" OR CommandLine="*iex*" OR CommandLine="*cmd /c*" OR CommandLine="*/c*" OR CommandLine="*certutil*")
| stats count min(_time) as first_seen max(_time) as last_seen by host, user, ParentImage, Image, CommandLine, ParentCommandLine
| sort - count

Additional Splunk query for file-based delivery of malicious Markdown:

index=endpoint sourcetype=fschange OR sourcetype=sysmon
  (file_name="*.md" OR file_name="*.markdown")
  (file_content="<script" OR file_content="javascript:" OR file_content="onerror=" OR file_content="powershell" OR file_content="cmd /c")
| stats count by host, user, file_path, file_name

Wazuh OSSEC Rule

<group name="windows,sysmon,process_creation,">
  <rule id="100752" level="12" frequency="1">
    <if_sid>92050</if_sid>
    <field name="win.event.system.eventID">1</field>
    <field name="win.event.data.parentImage">\idea64.exe</field>
    <field name="win.event.data.image">powershell.exe</field>
    <description>JetBrains IntelliJ IDEA spawned PowerShell - potential CVE-2026-75052 Markdown preview command execution</description>
    <group>command_execution,</group>
  </rule>
</group>

Note: if_sid references should be adjusted to the rule that maps to Windows Sysmon EventID 1 (process creation) in your Wazuh baseline. For Linux endpoints, apply an equivalent audit/Osquery rule monitoring for bash, sh, or python children of java processes running IntelliJ.

Mitigation & Patch Guidance

Patch confidence: 0/4 — UNPATCHED. No vendor advisory, patch bulletin, or changelog entry was confirmed by any tracked source at the time of writing. The NVD description implies that the fix is included in IntelliJ IDEA 2026.2.1; however, this has not yet been independently corroborated, and affected-version data is incomplete.

1. Immediate mitigations

   • Keep all projects in untrusted state unless absolutely required; the flaw is only exploitable in trusted projects.
   • If Markdown previews are not essential, replace the default preview with a plain-text/editor view for .md files.
   • Instruct developers not to open Markdown files from untrusted repositories, pull requests, or archives.
   • Restrict IDE user accounts to least privilege; do not run IntelliJ IDEA with administrative/root rights.

2. Patch / upgrade steps

   • Monitor JetBrains security bulletins and the NVD entry for CVE-2026-75052.
   • Verify the availability of IntelliJ IDEA 2026.2.1 (or later) and roll it out via the organization's software management tooling once confirmed.
   • Validate the version on all developer endpoints (Help → About shows the build number).

3. Long-term hardening

   • Deploy EDR on developer workstations with visibility into parent/child process relationships and file-write events for documentation files.
   • Treat developer endpoints as high-value assets: apply credential hygiene, isolate CI/CD secrets in vaults, and require FIDO2 for Git/cloud access.
   • Enable Sysmon (or equivalent) and forward endpoint telemetry to a SIEM for the detection queries in this report.