Back to Intelligence

CVE-2026-114938 (Java4Shell): Oracle Java Out-of-Bounds Write — Detection and Remediation Guide

SA
Security Arsenal Team
November 18, 2026
12 min read

The U.S. Cybersecurity and Infrastructure Security Agency (CISA) has issued an urgent advisory directing organizations to immediately patch a newly disclosed critical vulnerability in Oracle Java. Tracked as CVE-2026-114938 and colloquially dubbed Java4Shell, the flaw carries a CVSS score of 8.1 and is described as an out-of-bounds write memory-corruption condition that can produce denial-of-service (DoS) or, under certain conditions, unauthenticated remote code execution.

If your organization runs Java-backed services — application servers, middleware, integration platforms, build infrastructure, or any internet-facing Java workload — treat this as a priority-one patching event. Java's ubiquity is exactly what makes this dangerous: the JRE is embedded in everything from enterprise ERP stacks to network appliances to OT management consoles, and most organizations have a far larger Java footprint than their asset inventory admits. When CISA publicly urges immediate action on a memory-corruption flaw in a runtime this pervasive, defenders should assume adversaries are already reverse-engineering the patch to build a working exploit.

Technical Analysis

What We Know

  • CVE: CVE-2026-114938
  • CVSS: 8.1 (High, bordering Critical)
  • Class: Out-of-bounds write (CWE-787) — memory corruption
  • Impact: Denial-of-service; under certain conditions, unauthenticated code execution
  • Vendor: Oracle (Java / JRE / JDK and products embedding the affected runtime)
  • Exploitation status: CISA's public urging of immediate patching indicates elevated concern. As of publication, no public PoC has been confirmed, but out-of-bounds write primitives in widely deployed runtimes historically attract rapid weaponization — especially once the patched diff is available for analysis.

Why an Out-of-Bounds Write Is Serious

An out-of-bounds write occurs when a process writes data beyond the bounds of an allocated memory region. In a managed runtime like Java, a memory-corruption primitive at the JVM or native-library layer is far more severe than a typical application-level bug: it can undermine the memory-safety guarantees the runtime is supposed to enforce. Depending on what attacker-controlled input reaches the vulnerable code path, the result ranges from a JVM crash (DoS) to controlled corruption of adjacent memory structures — the classic stepping stone toward arbitrary code execution.

The phrase "unauthenticated code execution under certain conditions" in CISA's language is the part that should keep you up at night. It implies the vulnerable code path can be reached over the network without credentials — most likely via a Java-based service that parses attacker-supplied input (deserialization endpoints, protocol handlers, embedded HTTP/IIOP/RMI listeners, or application-server request processing). The "certain conditions" qualifier usually maps to specific JVM versions, configurations, or enabled features — which means your exposure depends on how Java is deployed, not just whether it exists.

Exploitation Requirements (Defender's View)

For planning purposes, assume the attack chain looks like this:

  1. Reconnaissance: Internet-wide scanning for Java-based services and common application-server ports (7001, 8009, 8080, 8443, 9080, 4848, 1099/JRMP).
  2. Delivery: Crafted input sent to the vulnerable parsing or protocol-handling code path — no authentication required.
  3. Corruption: Out-of-bounds write corrupts adjacent memory; uncontrolled attempts crash the JVM (observable as repeated service restarts), controlled attempts pivot to code execution within the JVM process context.
  4. Post-exploitation: The JVM process spawns a shell or interpreter (cmd.exe, powershell.exe, /bin/sh, /bin/bash), or writes and loads a web shell / in-memory payload. All follow-on activity runs with the privileges of the Java service account — frequently SYSTEM, root, or a privileged service account in real-world deployments.

That fourth stage is where defenders get their best detection opportunity. Memory corruption in the JVM is hard to catch on the wire without vendor signatures, but a java.exe / java process spawning an interactive shell or scripting interpreter is a high-fidelity behavioral signal in almost every environment.

Detection & Response

The detections below target the post-exploitation behaviors that are most reliable and least noisy: child-process spawning from Java runtimes, anomalous JVM crash/restart patterns consistent with failed exploitation attempts, and Java processes making unexpected outbound network connections.

Sigma Rules

YAML
---
title: Java Process Spawning Shell or Scripting Interpreter (Potential CVE-2026-114938 Exploitation)
id: 9f2c7a41-3b6e-4d8a-a512-7e1b0c4d5f6a
status: experimental
description: Detects java.exe, javaw.exe, or common Java service wrapper processes spawning command shells or scripting interpreters. This is a high-fidelity indicator of successful remote code execution against a Java-based service, consistent with post-exploitation of memory-corruption flaws such as CVE-2026-114938 (Java4Shell).
references:
  - https://thehackernews.com/2026/11/cisa-urges-immediate-patching-of.html
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/11/15
tags:
  - attack.execution
  - attack.t1059
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith:
      - '\java.exe'
      - '\javaw.exe'
      - '\javaws.exe'
      - '\tomcat.exe'
      - '\commons-daemon.exe'
      - '\wrapper.exe'
  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'
      - '\whoami.exe'
      - '\net.exe'
      - '\nltest.exe'
  condition: selection_parent and selection_child
falsepositives:
  - Legitimate Java-based build or deployment tools invoking scripts (Jenkins agents, Maven/Gradle wrappers) - tune by parent process path and service account
  - Application server management consoles executing administrative scripts
level: high
---
title: Linux Java Process Spawning Interactive Shell (Potential CVE-2026-114938 Exploitation)
id: 4d8e1b92-6c3a-4f75-b921-2a7d9e0f3c8b
status: experimental
description: Detects the Java runtime on Linux spawning interactive shells or common post-exploitation tooling. Successful exploitation of memory-corruption vulnerabilities such as CVE-2026-114938 in Java services typically results in command execution under the JVM process context.
references:
  - https://thehackernews.com/2026/11/cisa-urges-immediate-patching-of.html
  - https://attack.mitre.org/techniques/T1059/004/
author: Security Arsenal
date: 2026/11/15
tags:
  - attack.execution
  - attack.t1059.004
logsource:
  category: process_creation
  product: linux
detection:
  selection_parent:
    ParentImage|endswith:
      - '/java'
      - '/java8'
      - '/java11'
      - '/java17'
      - '/java21'
  selection_child:
    Image|endswith:
      - '/sh'
      - '/bash'
      - '/dash'
      - '/zsh'
      - '/python'
      - '/python3'
      - '/perl'
      - '/curl'
      - '/wget'
      - '/nc'
      - '/ncat'
      - '/netcat'
      - '/base64'
      - '/id'
      - '/whoami'
  condition: selection_parent and selection_child
falsepositives:
  - Java-based CI/CD agents legitimately invoking shell commands - tune by host role and parent command line
level: high
---
title: Web Shell or Unexpected File Write by Java Process in Web Root
id: 6b1f3d58-8e2c-4a94-c735-5d9a2b7e1f04
status: experimental
description: Detects Java runtime processes writing executable script files (JSP, ASPX, PHP) into web-accessible directories, a common post-exploitation action following remote code execution against Java application servers such as exploitation of CVE-2026-114938.
references:
  - https://thehackernews.com/2026/11/cisa-urges-immediate-patching-of.html
  - https://attack.mitre.org/techniques/T1505/003/
author: Security Arsenal
date: 2026/11/15
tags:
  - attack.persistence
  - attack.t1505.003
logsource:
  category: file_event
  product: windows
detection:
  selection_image:
    Image|endswith:
      - '\java.exe'
      - '\javaw.exe'
  selection_target:
    TargetFilename|endswith:
      - '.jsp'
      - '.jspx'
      - '.aspx'
      - '.ashx'
      - '.php'
  filter_deploy:
    TargetFilename|contains:
      - '\webapps\'
      - '\deployments\'
  condition: selection_image and selection_target and not filter_deploy
falsepositives:
  - Application redeployments and CI/CD pipelines writing JSP artifacts - correlate with change windows
level: high

KQL — Microsoft Sentinel / Defender

The following hunt query surfaces Java runtime processes spawning shells or reconnaissance tooling across both Windows and Linux endpoints via Defender and Syslog ingestion:

KQL — Microsoft Sentinel / Defender
let javaParents = dynamic(["java.exe", "javaw.exe", "javaws.exe", "tomcat.exe", "java", "java11", "java17", "java21"]);
let suspiciousChildren = dynamic([
  "cmd.exe", "powershell.exe", "pwsh.exe", "mshta.exe", "rundll32.exe",
  "regsvr32.exe", "certutil.exe", "wscript.exe", "cscript.exe",
  "whoami.exe", "net.exe", "nltest.exe", "curl.exe", "wget.exe",
  "sh", "bash", "dash", "zsh", "python", "python3", "perl",
  "nc", "ncat", "netcat", "base64", "id", "whoami", "curl", "wget"
]);
let defenderData =
  DeviceProcessEvents
  | where InitiatingProcessFileName in~ (javaParents)
  | where FileName in~ (suspiciousChildren)
  | project TimeGenerated, DeviceName, InitiatingProcessFileName, InitiatingProcessCommandLine,
            FileName, ProcessCommandLine, AccountName, ReportId, Source = "Defender";
let syslogData =
  Syslog
  | where SyslogMessage has_any (javaParents)
  | where SyslogMessage has_any (suspiciousChildren)
  | project TimeGenerated, DeviceName = Computer, InitiatingProcessFileName = "java",
            InitiatingProcessCommandLine = "", FileName = ProcessName,
            ProcessCommandLine = SyslogMessage, AccountName = "", ReportId = "", Source = "Syslog";
union defenderData, syslogData
| sort by TimeGenerated desc
| summarize FirstSeen = min(TimeGenerated), LastSeen = max(TimeGenerated),
            Commands = make_set(ProcessCommandLine, 10)
  by DeviceName, InitiatingProcessFileName, FileName, AccountName, Source;

A second hunt worth running during the triage window: look for JVM crash/restart loops on Java services, which can indicate failed exploitation attempts of the out-of-bounds write — attackers rarely get memory corruption right on the first try, and the crashes are your early warning before a working exploit lands.

KQL — Microsoft Sentinel / Defender
// JVM crash and restart loop detection - possible failed exploitation attempts
let crashEvents =
  union
    (SecurityEvent
      | where EventID == 4688
      | where Process has_any ("java.exe", "javaw.exe")
      | summarize StartCount = count() by Computer, bin(TimeGenerated, 10m)),
    (Syslog
      | where SyslogMessage has_any ("OutOfMemoryError", "SIGSEGV", "hs_err_pid", "fatal error", "core dumped")
      | summarize StartCount = count() by Computer, bin(TimeGenerated, 10m));
crashEvents
| where StartCount >= 3
| sort by StartCount desc;

Velociraptor VQL

Use this hunt artifact to sweep your fleet for Java processes with suspicious child processes or unexpected outbound network connections — the two strongest post-exploitation signals for this threat:

VQL — Velociraptor
-- Hunt for Java runtime processes with suspicious children or outbound connections
-- Targets post-exploitation behavior consistent with CVE-2026-114938 (Java4Shell)
LET java_procs = SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE Name =~ '(?i)java(w|ws)?(\.exe)?$' OR Exe =~ '(?i)(jre|jdk|openjdk)'

LET suspicious_children = SELECT Pid, Ppid, Name, CommandLine, Username, CreateTime
FROM pslist()
WHERE Ppid IN (SELECT Pid FROM java_procs)
  AND Name =~ '(?i)(cmd|powershell|pwsh|sh|bash|dash|zsh|python|perl|nc|ncat|curl|wget|whoami|netstat|ipconfig|ifconfig)(\.exe)?$'

LET java_conns = SELECT Pid, Name, RemoteIP, RemotePort, Status
FROM netstat()
WHERE Name =~ '(?i)java'
  AND Status = 'ESTABLISHED'
  AND NOT RemoteIP =~ '^(10\.|172\.(1[6-9]|2[0-9]|3[0-1])\.|192\.168\.|127\.)'

SELECT * FROM suspicious_children
UNION ALL
SELECT Pid, Ppid, Name, format(format='REMOTE: %v:%v', args=[RemoteIP, RemotePort]) AS CommandLine,
       'netstat' AS Username, NULL AS CreateTime
FROM java_conns

Verification and Remediation Script

Use this PowerShell script on Windows hosts to inventory installed Java runtimes, identify versions exposed to CVE-2026-114938, and flag running Java services for immediate patch scheduling. A Bash equivalent follows for Linux fleets.

PowerShell
# CVE-2026-114938 (Java4Shell) - Java runtime inventory and exposure check
# Run elevated. Produces a report of installed Java versions and running Java processes.

$report = @()

# 1. Inventory installed Java from registry (both hives, 32/64-bit)
$uninstallPaths = @(
  'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*',
  'HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*'
)
$installedJava = Get-ItemProperty $uninstallPaths -ErrorAction SilentlyContinue |
  Where-Object { $_.DisplayName -match 'Java|JDK|JRE|OpenJDK|Oracle.*SE' } |
  Select-Object DisplayName, DisplayVersion, Publisher, InstallLocation

foreach ($j in $installedJava) {
  $report += [PSCustomObject]@{
    Type     = 'Installed'
    Name     = $j.DisplayName
    Version  = $j.DisplayVersion
    Vendor   = $j.Publisher
    Path     = $j.InstallLocation
    Status   = 'REVIEW - confirm against Oracle advisory for CVE-2026-114938'
  }
}

# 2. Enumerate running Java processes and their service accounts
$javaProcs = Get-CimInstance Win32_Process -Filter "Name LIKE 'java%'" -ErrorAction SilentlyContinue
foreach ($p in $javaProcs) {
  $owner = (Invoke-CimMethod -InputObject $p -MethodName GetOwner).User
  $report += [PSCustomObject]@{
    Type     = 'RunningProcess'
    Name     = $p.Name
    Version  = ($p.CommandLine -split ' ')[0]
    Vendor   = ''
    Path     = $p.ExecutablePath
    Status   = "RUNNING as $owner - privileged if SYSTEM; patch and restart required"
  }
}

# 3. Find stray java.exe instances outside standard install dirs
$strayJava = Get-ChildItem -Path 'C:\' -Filter 'java.exe' -Recurse -ErrorAction SilentlyContinue -Depth 5 |
  Where-Object { $_.FullName -notmatch 'Program Files' }
foreach ($s in $strayJava) {
  $report += [PSCustomObject]@{
    Type     = 'StrayBinary'
    Name     = 'java.exe'
    Version  = $s.VersionInfo.ProductVersion
    Vendor   = $s.VersionInfo.CompanyName
    Path     = $s.FullName
    Status   = 'UNMANAGED RUNTIME - likely bundled with an app; check vendor patch status'
  }
}

$report | Format-Table -AutoSize
$report | Export-Csv -Path "$env:TEMP\java4shell_exposure_$(Get-Date -Format 'yyyyMMdd').csv" -NoTypeInformation
Write-Output "Report exported to $env:TEMP\java4shell_exposure_$(Get-Date -Format 'yyyyMMdd').csv"
Bash / Shell
#!/usr/bin/env bash
# CVE-2026-114938 (Java4Shell) - Linux Java runtime inventory and exposure check
# Run as root or with sudo. Reports installed JREs/JDKs, running JVMs, and bundled runtimes.

echo "=== Installed Java packages ==="
if command -v dpkg &>/dev/null; then
  dpkg -l | grep -Ei 'openjdk|oracle-java|jre|jdk' | awk '{print $2, $3}'
elif command -v rpm &>/dev/null; then
  rpm -qa | grep -Ei 'openjdk|java|jre|jdk'
fi

echo ""
echo "=== java -version (default runtime) ==="
java -version 2>&1 || echo "No default java on PATH"

echo ""
echo "=== Running JVMs (PID, user, command) ==="
ps -eo pid,user,comm,args | grep -E '[j]ava' || echo "No running JVMs found"

echo ""
echo "=== Privileged JVMs (root) - highest risk ==="
ps -eo pid,user,args | awk '$2=="root" && $3 ~ /java/ {print}'

echo ""
echo "=== JVMs listening on network ports ==="
ss -tlnp 2>/dev/null | grep -i java || netstat -tlnp 2>/dev/null | grep -i java || echo "No listening Java sockets"

echo ""
echo "=== Bundled/unmanaged JREs outside standard paths ==="
find / -name 'java' -type f -executable 2>/dev/null | grep -vE '^/usr/(lib/jvm|bin|share)' | head -50

echo ""
echo "=== Recent JVM crash logs (possible failed exploitation of CVE-2026-114938) ==="
find / -name 'hs_err_pid*.log' -mtime -7 2>/dev/null | head -20
journalctl --since "7 days ago" 2>/dev/null | grep -Ei 'SIGSEGV|OutOfMemoryError|core dumped' | grep -i java | tail -20

echo ""
echo "ACTION: Cross-reference all discovered versions against the Oracle CPU advisory for CVE-2026-114938 and patch immediately."

Remediation

  1. Patch immediately. Apply Oracle's security update addressing CVE-2026-114938 per the official advisory at https://www.oracle.com/security-alerts/ and the CISA guidance at https://www.cisa.gov/. Prioritize any Java runtime reachable from the network — internet-facing first, then internal services processing untrusted input. CISA's language ("immediate patching") should be treated as an emergency-change directive, not a standard patch-cycle item.

  2. Inventory before you patch. The most dangerous Java instances are the ones you don't manage: JREs bundled with third-party applications, appliances, backup agents, monitoring tools, and OT/management consoles. Run the inventory scripts above across the fleet. For every bundled runtime, open a ticket with the application vendor demanding their patched build — a vulnerable JRE shipped inside a "supported" appliance is still your breach.

  3. Restart after patching. Java patches do not take effect on running JVMs. Every patched runtime requires a service restart to load the fixed libraries. Track restarts explicitly — "patched but not restarted" is functionally unpatched.

  4. Reduce exposure where patching lags. Until patches are fully deployed: restrict network access to Java service ports (8080/8443/7001/8009/1099 and similar) to known management and application tiers via firewall and segmentation rules; place internet-facing Java services behind a WAF/reverse proxy; and disable unused Java service endpoints, protocol handlers, and management listeners.

  5. Hunt now, not after the PoC drops. Deploy the Sigma and KQL detections above before exploitation goes mainstream. Pay special attention to JVM crash artifacts (hs_err_pid*.log, SIGSEGV entries) — clusters of JVM crashes on a network-reachable service in the days before a public exploit are often the earliest observable indicator that someone is fuzzing the vulnerable code path.

  6. Constrain blast radius. Java services should never run as root or SYSTEM. Where they do today, remediate to a dedicated least-privilege service account as part of this response. This single change dramatically reduces what an unauthenticated RCE can do to the host and the network segment.

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.