Back to Intelligence

CVE-2026-114938: Critical Java4Shell Vulnerability in Oracle JDK — Immediate Detection and Remediation Guide

SA
Security Arsenal Team
November 17, 2026
14 min read

On November 17, 2026, CISA issued an emergency alert regarding CVE-2026-114938, dubbed "Java4Shell" — a critical memory-corruption vulnerability residing in the Base64 decoder of the x86-64 HotSpot Java Virtual Machine (JVM), which is distributed as part of Oracle's Java Development Kit (JDK).

This vulnerability enables unauthenticated remote code execution (RCE) simply by supplying specially crafted Base64-encoded input to an application that decodes it. Given the ubiquity of Java in enterprise environments — from application servers and microservices to CI/CD build agents and embedded appliances — the blast radius is significant. CISA has strongly urged organizations to patch immediately, emphasizing that JDKs and Java runtimes may not appear as separate entries in standard software inventories, particularly when bundled with third-party applications, container images, or appliances.

For defenders, this is not a theoretical risk. Memory corruption in a core runtime component like the JVM is a preferred target for nation-state actors and ransomware groups alike. The window between disclosure and active exploitation for a vulnerability of this severity is typically measured in days, not weeks.

Technical Analysis

Affected Component and Attack Chain

CVE-2026-114938 affects the Base64 decoder implementation within the x86-64 build of Oracle's HotSpot JVM. HotSpot is the default JVM implementation shipped with Oracle JDK and is also the reference implementation underlying OpenJDK distributions. The vulnerability is triggered when the JVM's native Base64 decoding routines process attacker-controlled input containing a malformed payload.

From a defender's perspective, the attack chain is straightforward and dangerous:

  1. Entry Point: An attacker submits a crafted Base64 string to any application endpoint, API, message queue, or data processing pipeline that performs Base64 decoding using the vulnerable JVM native methods.
  2. Memory Corruption: The malformed input triggers a memory-corruption condition within the JVM's native x86-64 Base64 decoder routines, corrupting adjacent memory structures.
  3. Code Execution: The corruption can be leveraged to hijack execution flow, resulting in arbitrary code execution in the context of the JVM process — typically with the privileges of the service account running the Java application.
  4. JVM Crash as Fallback: Even if full code execution is not achieved, the vulnerability reliably crashes the JVM, resulting in denial of service.

Why This Is Critical

The vulnerability is unauthenticated and requires only that the target application decode Base64 input — an operation performed routinely by web APIs, authentication handlers, data import pipelines, email parsers, and countless other application functions. There is no requirement for the attacker to have valid credentials, session tokens, or prior access.

Affected Versions

Organizations must identify all installations of Oracle JDK and OpenJDK that include the vulnerable x86-64 HotSpot Base64 decoder. This includes:

  • Standalone JDK installations on servers, workstations, and build agents
  • Java runtimes bundled with third-party applications (application servers, management consoles, middleware)
  • Container images that include a JDK or JRE layer
  • Appliances and virtual appliances that embed Java runtimes
  • CI/CD pipeline agents running Java-based build tools

CISA has specifically noted that Java runtimes bundled within other products may not appear as separate entries in software inventory tools, making manual verification essential.

Exploitation Status

CISA's decision to issue a standalone emergency alert — rather than a routine advisory — indicates high confidence in the severity and exploitability of this vulnerability. Organizations should treat this as an actively targeted vulnerability and assume that exploitation attempts will begin (or have already begun) in the wild. CISA has directed organizations to patch immediately.

Detection & Response

Detecting exploitation of CVE-2026-114938 requires monitoring for behavioral indicators consistent with JVM compromise. Since the vulnerability is triggered through Base64 decoding, defenders should focus on identifying anomalous process behavior originating from Java processes, JVM crashes correlated with unusual input patterns, and post-exploitation activity spawning from Java service accounts.

SIGMA Rules

The following Sigma rules target the most probable observable behaviors associated with Java4Shell exploitation: anomalous child processes spawned by the JVM, and suspicious command execution from Java service accounts.

YAML
---
title: Suspicious Child Process Spawned by Java JVM
description: Detects Java processes spawning unexpected child processes such as shells, script interpreters, or system utilities — a strong indicator of JVM compromise via memory corruption or code execution.
references:
  - https://www.cisa.gov/news-events/alerts/2026/11/17/critical-java-vulnerability-requires-immediate-patching
author: Security Arsenal
date: 2026/11/17
status: experimental
tags:
  - attack.execution
  - attack.t1059
  - attack.t1203
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith:
      - '\java.exe'
      - '\javaw.exe'
      - '\java.dll'
  selection_child:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\mshta.exe'
      - '\rundll32.exe'
      - '\regsvr32.exe'
      - '\certutil.exe'
      - '\bitsadmin.exe'
      - '\curl.exe'
      - '\wget.exe'
      - '\nc.exe'
      - '\netcat.exe'
      - '\whoami.exe'
      - '\net.exe'
      - '\net1.exe'
      - '\ipconfig.exe'
      - '\systeminfo.exe'
  condition: selection_parent and selection_child
falsepositives:
  - Java-based build tools (Maven, Gradle) invoking compilers or scripts
  - Application servers executing system commands for management functions
  - Jenkins or CI agents executing build steps
level: high
---
title: JVM Crash Followed by Suspicious Process Execution
description: Detects a pattern where a Java process terminates abnormally and is followed by execution of reconnaissance or payload delivery commands, potentially indicating successful exploitation of a JVM memory corruption vulnerability.
references:
  - https://www.cisa.gov/news-events/alerts/2026/11/17/critical-java-vulnerability-requires-immediate-patching
author: Security Arsenal
date: 2026/11/17
status: experimental
tags:
  - attack.execution
  - attack.t1059
  - attack.t1203
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentImage|endswith:
      - '/java'
      - '/javaw'
  selection_child:
    Image|endswith:
      - '/bin/sh'
      - '/bin/bash'
      - '/bin/dash'
      - '/usr/bin/curl'
      - '/usr/bin/wget'
      - '/usr/bin/nc'
      - '/usr/bin/ncat'
      - '/usr/bin/python'
      - '/usr/bin/python3'
      - '/usr/bin/perl'
      - '/usr/bin/whoami'
      - '/usr/bin/id'
      - '/usr/bin/uname'
      - '/bin/cat'
      - '/usr/bin/base64'
  condition: selection_parent and selection_child
falsepositives:
  - Java management agents performing health checks
  - Application startup scripts invoking shell commands
  - Monitoring agents running as Java subprocesses
level: high
---
title: Java Process Writing Executable to Temporary or World-Writable Directory
description: Detects Java processes writing executable files to temporary directories or world-writable paths, consistent with post-exploitation payload staging following JVM compromise.
references:
  - https://www.cisa.gov/news-events/alerts/2026/11/17/critical-java-vulnerability-requires-immediate-patching
author: Security Arsenal
date: 2026/11/17
status: experimental
tags:
  - attack.defense_evasion
  - attack.t1027
  - attack.t1105
logsource:
  category: file_event
  product: windows
detection:
  selection_source:
    Image|endswith:
      - '\java.exe'
      - '\javaw.exe'
  selection_target:
    TargetFilename|contains:
      - '\Temp\'
      - '\tmp\'
      - '\AppData\Local\Temp\'
      - '\Windows\Temp\'
      - '\Public\'
      - '\ProgramData\'
  selection_extension:
    TargetFilename|endswith:
      - '.exe'
      - '.dll'
      - '.bat'
      - '.ps1'
      - '.sh'
      - '.jar'
      - '.class'
  condition: selection_source and selection_target and selection_extension
falsepositives:
  - Java applications extracting bundled libraries to temp directories
  - Application server deployment mechanisms
  - Java Web Start caching behavior
level: medium

KQL (Microsoft Sentinel / Defender)

The following KQL query hunts for suspicious child processes spawned by Java processes across Windows and Linux endpoints ingested into Microsoft Sentinel or Defender. It correlates process creation events with known post-exploitation tools.

KQL — Microsoft Sentinel / Defender
// Hunt for suspicious child processes spawned by Java JVM processes
// Targets post-exploitation behavior consistent with Java4Shell (CVE-2026-114938)
let SuspiciousChildren = dynamic([
    "cmd.exe", "powershell.exe", "pwsh.exe", "wscript.exe", "cscript.exe",
    "mshta.exe", "rundll32.exe", "regsvr32.exe", "certutil.exe", "bitsadmin.exe",
    "curl.exe", "wget.exe", "nc.exe", "whoami.exe", "net.exe", "net1.exe",
    "/bin/sh", "/bin/bash", "/bin/dash", "/usr/bin/curl", "/usr/bin/wget",
    "/usr/bin/nc", "/usr/bin/ncat", "/usr/bin/python", "/usr/bin/python3",
    "/usr/bin/perl", "/usr/bin/whoami", "/usr/bin/id", "/usr/bin/uname"
]);
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where InitiatingProcessFileName in~ ("java.exe", "javaw.exe", "java")
| where FileName in~ (SuspiciousChildren)
| project
    TimeGenerated,
    DeviceName,
    InitiatingProcessFileName,
    InitiatingProcessCommandLine,
    FileName,
    ProcessCommandLine,
    AccountName,
    InitiatingProcessParentFileName,
    SHA256,
    ReportId
| order by TimeGenerated desc

For environments ingesting Syslog data from Linux servers running Java applications, the following query identifies anomalous process execution patterns:

KQL — Microsoft Sentinel / Defender
// Hunt for Java process anomalies via Syslog on Linux servers
Syslog
| where TimeGenerated > ago(7d)
| where ProcessName contains "java" or SyslogMessage contains "java"
| where SyslogMessage has_any ("SEGV", "SIGSEGV", "core dump", "segmentation fault",
    "hs_err_pid", "fatal error", "Base64")
| project TimeGenerated, Computer, ProcessName, SyslogMessage, SeverityLevel
| order by TimeGenerated desc

Velociraptor VQL

The following VQL artifact hunts for suspicious child processes spawned by Java across the endpoint fleet, and identifies JVM crash dump files (hs_err_pid) that may indicate exploitation attempts:

VQL — Velociraptor
-- Hunt for Java4Shell (CVE-2026-114938) exploitation indicators
-- Identifies suspicious child processes of Java JVM and JVM crash artifacts

SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE
    -- Identify suspicious children of Java processes
    (
        Ppid IN (
            SELECT Pid FROM pslist()
            WHERE Name =~ '(?i)java(w)?(\.exe)?$'
        )
        AND
        (
            Name =~ '(?i)(cmd|powershell|pwsh|sh|bash|dash|curl|wget|nc|ncat|python|perl|whoami|certutil|mshta|rundll32|regsvr32)'
            OR CommandLine =~ '(?i)(whoami|id |uname|ifconfig|ipconfig|net user|net group|base64)'
        )
    )
VQL — Velociraptor
-- Hunt for JVM fatal error log files (hs_err_pid) indicating crashes
-- These files are generated when the JVM encounters a fatal error including memory corruption

SELECT
    FullPath,
    Size,
    Mtime,
    Ctime
FROM glob(globs=[
    'C:/Users/*/hs_err_pid*.log',
    'C:/Windows/Temp/hs_err_pid*.log',
    'C:/Temp/hs_err_pid*.log',
    '/tmp/hs_err_pid*.log',
    '/var/tmp/hs_err_pid*.log',
    '/opt/*/hs_err_pid*.log',
    '/home/*/hs_err_pid*.log',
    '/usr/local/*/hs_err_pid*.log'
])
WHERE Mtime > ago(7 * 24 * 3600)
ORDER BY Mtime DESC

Remediation Script

Use the following Bash script to inventory Java installations on Linux systems, identify potentially vulnerable versions, and flag installations for remediation. Adapt paths and package manager commands for your specific environment.

Bash / Shell
#!/bin/bash
# CVE-2026-114938 (Java4Shell) — Java Installation Inventory and Assessment Script
# Run with appropriate privileges to enumerate all Java installations

echo "=============================================="
echo "CVE-2026-114938 Java4Shell Assessment"
echo "Date: $(date)"
echo "Hostname: $(hostname)"
echo "=============================================="

echo ""
echo "[+] Identifying all java binaries on the system..."
find / -name "java" -type f 2>/dev/null | while read -r jpath; do
    version=$("$jpath" -version 2>&1 | head -1)
    echo "  FOUND: $jpath"
    echo "  VERSION: $version"
    echo "  ---"
done

echo ""
echo "[+] Identifying all javac binaries (JDK installations)..."
find / -name "javac" -type f 2>/dev/null | while read -r jpath; do
    version=$("$jpath" -version 2>&1)
    echo "  FOUND: $jpath"
    echo "  VERSION: $version"
    echo "  ---"
done

echo ""
echo "[+] Checking package manager for installed Java packages..."
if command -v dpkg &>/dev/null; then
    echo "  [dpkg] Installed Java-related packages:"
    dpkg -l 2>/dev/null | grep -iE 'jdk|jre|openjdk|oracle-java' || echo "    None found"
elif command -v rpm &>/dev/null; then
    echo "  [rpm] Installed Java-related packages:"
    rpm -qa 2>/dev/null | grep -iE 'jdk|jre|openjdk|oracle-java' || echo "    None found"
fi

echo ""
echo "[+] Checking for Java processes currently running..."
ps aux | grep -E '[j]ava' | awk '{print "  PID: "$2" | USER: "$1" | CMD: "$11" "$12}'

echo ""
echo "[+] Checking for JVM crash dump files (hs_err_pid)..."
find /tmp /var/tmp /opt /home /usr/local -maxdepth 3 -name "hs_err_pid*.log" -mtime -7 2>/dev/null | while read -r f; do
    echo "  CRASH DUMP: $f ($(stat -c '%y' "$f" 2>/dev/null))"
done

echo ""
echo "[+] Checking Docker images containing Java..."
if command -v docker &>/dev/null; then
    docker images --format '{{.Repository}}:{{.Tag}}' 2>/dev/null | while read -r img; do
        if docker run --rm --entrypoint java "$img" -version 2>&1 | grep -qi "version"; then
            echo "  CONTAINER IMAGE WITH JAVA: $img"
        fi
    done
else
    echo "  Docker not available — manually inspect container images"
fi

echo ""
echo "=============================================="
echo "ACTION REQUIRED:"
echo "1. Cross-reference all identified Java versions against the Oracle"
echo "   security advisory for CVE-2026-114938"
echo "2. Patch all affected installations IMMEDIATELY"
echo "3. Review JVM crash dumps for signs of exploitation"
echo "4. Investigate any suspicious child processes of Java identified"
echo "   by the detection rules"
echo "=============================================="

For Windows environments, use the following PowerShell script to inventory Java installations and identify running Java processes:

PowerShell
# CVE-2026-114938 (Java4Shell) — Windows Java Installation Inventory
# Run as Administrator for comprehensive results

Write-Host "==============================================" -ForegroundColor Red
Write-Host "CVE-2026-114938 Java4Shell Assessment" -ForegroundColor Red
Write-Host "Date: $(Get-Date)" -ForegroundColor Yellow
Write-Host "Hostname: $env:COMPUTERNAME" -ForegroundColor Yellow
Write-Host "==============================================" -ForegroundColor Red

# Find all java.exe and javaw.exe installations
Write-Host "`n[+] Searching for Java binaries..." -ForegroundColor Cyan
$javaPaths = @(
    "C:\Program Files\Java",
    "C:\Program Files (x86)\Java",
    "C:\Program Files\Eclipse Adoptium",
    "C:\Program Files\Amazon Corretto",
    "C:\Program Files\Microsoft",
    "C:\Program Files\Zulu",
    "C:\Program Files\BellSoft",
    "C:\Program Files\SapMachine"
)

foreach ($basePath in $javaPaths) {
    if (Test-Path $basePath) {
        Get-ChildItem -Path $basePath -Recurse -Filter "java.exe" -ErrorAction SilentlyContinue |
        ForEach-Object {
            $version = (& $_.FullName -version 2>&1 | Select-Object -First 1)
            Write-Host "  FOUND: $($_.FullName)" -ForegroundColor Yellow
            Write-Host "  VERSION: $version" -ForegroundColor Yellow
        }
    }
}

# Check for Java in non-standard locations via WMI
Write-Host "`n[+] Checking for Java processes currently running..." -ForegroundColor Cyan
Get-Process | Where-Object { $_.ProcessName -match 'java|javaw' } |
ForEach-Object {
    Write-Host "  RUNNING: PID=$($_.Id) | Name=$($_.ProcessName) | Path=$($_.Path)" -ForegroundColor Yellow
}

# Check for JVM crash dumps
Write-Host "`n[+] Checking for JVM crash dump files (hs_err_pid)..." -ForegroundColor Cyan
$crashPaths = @("C:\Users", "C:\Windows\Temp", "C:\Temp", "C:\ProgramData")
foreach ($cp in $crashPaths) {
    if (Test-Path $cp) {
        Get-ChildItem -Path $cp -Recurse -Filter "hs_err_pid*.log" -ErrorAction SilentlyContinue |
        Where-Object { $_.LastWriteTime -gt (Get-Date).AddDays(-7) } |
        ForEach-Object {
            Write-Host "  CRASH DUMP: $($_.FullName) | Modified: $($_.LastWriteTime)" -ForegroundColor Red
        }
    }
}

# Check installed programs for Java entries
Write-Host "`n[+] Checking installed programs for Java entries..." -ForegroundColor Cyan
$regPaths = @(
    "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*",
    "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*"
)
foreach ($rp in $regPaths) {
    Get-ItemProperty $rp -ErrorAction SilentlyContinue |
    Where-Object { $_.DisplayName -match 'Java|JDK|JRE|OpenJDK|Corretto|Temurin|Zulu' } |
    ForEach-Object {
        Write-Host "  INSTALLED: $($_.DisplayName) | Version: $($_.DisplayVersion)" -ForegroundColor Yellow
    }
}

Write-Host "`n==============================================" -ForegroundColor Red
Write-Host "ACTION REQUIRED:" -ForegroundColor Red
Write-Host "1. Cross-reference ALL identified versions against Oracle advisory" -ForegroundColor White
Write-Host "2. Patch affected installations IMMEDIATELY" -ForegroundColor White
Write-Host "3. Review crash dumps for exploitation indicators" -ForegroundColor White
Write-Host "4. Check third-party apps and containers for bundled Java" -ForegroundColor White
Write-Host "==============================================" -ForegroundColor Red

Remediation

Given the critical severity and CISA's urgent advisory, organizations must treat CVE-2026-114938 as an emergency patching priority. Follow these steps in order:

1. Inventory All Java Installations Immediately

CISA explicitly warns that JDKs and Java runtimes may not appear as separate entries in software inventory tools. You must:

  • Run the assessment scripts above across your entire fleet
  • Review third-party application documentation for bundled Java runtimes
  • Inspect container images for embedded JDK/JRE layers using tools like dive, syft, or trivy
  • Check appliances and network devices for embedded Java components
  • Audit CI/CD build agents and development workstations

2. Apply Vendor Patches

  • Oracle JDK: Apply the latest Critical Patch Update (CPU) from Oracle that addresses CVE-2026-114938. Download patches from the Oracle Security Alerts page.
  • OpenJDK: OpenJDK distributions (Eclipse Temurin, Amazon Corretto, Microsoft Build of OpenJDK, Azul Zulu, Red Hat OpenJDK) should have corresponding patched builds. Check with your distribution vendor for patched releases.
  • Third-party applications: Contact vendors for updated releases that bundle patched Java runtimes. Do not assume the vendor has shipped an update — verify explicitly.

3. Workarounds If Immediate Patching Is Not Possible

If you cannot patch immediately, implement compensating controls:

  • Network segmentation: Isolate Java-based services from direct internet exposure. Place them behind reverse proxies, WAFs, and API gateways.
  • Input validation: Deploy strict input validation at the application layer or WAF level to inspect and filter Base64-encoded payloads before they reach the JVM.
  • Restrict outbound connections: Apply egress filtering on servers running Java applications to limit the ability of a compromised JVM to establish command-and-control channels or download payloads.
  • Least privilege: Ensure Java services run with minimal privileges — never as root, SYSTEM, or domain administrator.
  • Application allowlisting: Use tools like Windows Defender Application Control (WDAC) or AppArmor to prevent Java processes from executing unexpected child processes.

4. Post-Patch Verification

After patching:

  • Verify the patched Java version by running java -version on every system
  • Re-run the assessment scripts to confirm no vulnerable installations remain
  • Review JVM crash dumps (hs_err_pid files) generated before patching for signs of exploitation attempts
  • Monitor the Sigma rules and KQL queries above for at least 30 days post-patch to detect any successful pre-patch compromise

5. CISA Deadline

CISA has urged immediate patching. Federal Civilian Executive Branch (FCEB) agencies are required to remediate in accordance with Binding Operational Directive (BOD) 22-01 timelines if this vulnerability is added to the Known Exploited Vulnerabilities (KEV) catalog. All organizations — public and private — should treat this as a patch-now emergency and not wait for a KEV listing.

For the official CISA alert and any updates, refer to: CISA Alert — Critical Java Vulnerability Requires Immediate Patching

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.