Threat Hunt Plan: Oracle Java SE / OpenJDK Base64 Decoder Memory Corruption (Java4Shell) — Exploitation, RCE, and Availability Impact
Date: 2026-11-18 | Revision: 1.0
Hunt Objective and Scope
This hunt looks for exploitation of CVE-2026-114938 ("Java4Shell"), a heap memory-corruption flaw in the Base64 decoder of the x86-64 HotSpot JVM used by Oracle Java SE and OpenJDK. The objective is threefold: enumerate internet-facing and internal Java applications that are reachable with attacker-supplied Base64 input, detect post-exploitation code execution originating from a Java process, and detect the availability impact (JVM crashes and service restarts) that even an unreliable exploitation attempt produces. In scope are all Windows and Linux hosts running a Java runtime — including JVMs embedded inside third-party products such as Atlassian Jira, Atlassian Confluence, Jenkins, and Elasticsearch, and inside container images — plus OT/ICS hosts where a Java-based historian, HMI, or engineering workstation application is present.
Time window: the hunt window opens at 2026-11-17 (the disclosure and Oracle November 2026 Critical Patch Update date). There is no evidence of in-the-wild exploitation as of that date and the CVE is not in the CISA KEV catalog, so no earlier zero-day start date is established; if exploitation evidence later emerges, re-open the window to the earliest observed attempt. Event-based clauses (process spawns, network connections, JVM crashes) are bounded by the measured data floor. The question "which hosts currently run a vulnerable, unpatched Java build" is state-based and is re-queried as current state regardless of the floor.
Data-floor pre-flight (run FIRST, record the oldest retained event DATE per family — a time picker is not retention). The portion of the window older than the floor is Non-Conclusive for the event-based legs:
#event_simpleName=/^(ProcessRollup2|EndOfProcess|NetworkReceiveAcceptIP4|NetworkConnectIP4)$/
| groupBy([#event_simpleName], function=min(@timestamp, as=oldest), limit=max)
Hypotheses and Hunt Procedures
Hypothesis 1: an external actor can reach an internet-facing instance of an affected Java application (Jira, Confluence, Jenkins, Elasticsearch, or any custom Java web service), observable as an exposed service in passive internet-scan indices. Execute FIRST; its output scopes the internal hypotheses.
MITRE ATT&CK: Reconnaissance | T1595 — Active Scanning | passive discovery (defender-side) of the internet-facing Java services an actor would enumerate before sending a crafted Base64 payload. · Initial Access | T1133 — External Remote Services. · ICS | T0883 — Internet Accessible Device.
Collection Queries — passive external indices (STRICTLY passive; never probe target infrastructure). Author unscoped first (proves the filter matches the product), then scope to owned space. Reference API keys by environment-variable name only (SHODAN_API_KEY, CENSYS_API_SECRET, CENSYS_ORG_ID, NETLAS_API_KEY); a missing key is non-blocking — skip that engine and record the coverage gap.
Shodan:
product:"Atlassian Jira"
http.title:"Log In - Confluence"
product:"Jenkins"
http.title:"Dashboard [Jenkins]"
port:9200 "You Know, for Search"
// scope with exactly ONE ownership anchor per query — never AND two (a two-anchor AND is a structural false zero):
// net:<your_public_CIDR>
// org:"<Your Org Name>"
// asn:AS<your_ASN>
Censys (CenQL — host.services.* form; the legacy services.* form 403s on free plans and silently returns zero when crossed):
host.services.software.product: "Jira"
host.services.software.product: "Confluence"
host.services: (port = "8080" and software.product: "Jenkins")
host.services: (port = "9200" and software.product: "Elasticsearch")
// scope (OR the anchors, never AND):
// and (host.autonomous_system.asn = <your_ASN> or host.ip: "<your_public_CIDR>")
Netlas:
http.title:"Jenkins"
host:<your_public_CIDR> AND port:(8080 OR 8090 OR 9200 OR 7990 OR 8443)
→ Cross-reference every exposed service and version banner against the CISA Known Exploited Vulnerabilities catalog (https://www.cisa.gov/known-exploited-vulnerabilities-catalog) and CVE-2026-114938. No KEV entry exists for this CVE as of 2026-11-17; a future listing converts an exposed in-range instance to presumptive actor-associated initial-access risk.
→ Expected Positive shape: a host inside your declared public CIDR / ASN running one of the named Java applications on a reachable port, corroborated in at least two indices.
Analysis Queries:
- Attribute each hit with at least two independent ownership signals (PTR, ASN, certificate CN/SAN, RDAP/WHOIS, your own cloud asset inventory) before reporting. Shared hosting and CDN break attribution in both directions; an unattributable hit is Non-Conclusive, not a confirmed exposure.
- Version-triage each banner. Because the affected runtime is the JVM and not the application, a Jira/Jenkins/Elasticsearch version banner does NOT reveal the JVM build — treat every exposed instance as a prompt to verify the underlying Java build directly, never as evidence of safety.
- Record the index scan timestamp; a banner is stale in both directions. Corroborate in at least two of Shodan / Censys / Netlas before escalating. Absence from an index is evidence only that the index did not observe the host.
- Historical pivot: establish whether the exposure spans the disclosure window (continuous exposure since 2026-11-17 = presumptively enumerated). Feed every confirmed-owned in-range instance into Hypotheses 2–4 as a priority target and hunt it exhaustively.
Control — unscoped filter validation: run each product filter WITHOUT the ownership anchor first and confirm it returns the product population globally; only then apply the anchor. A scoped query that returns zero while the unscoped query also returns zero proves the filter is wrong, not that exposure is absent.
Verdict criteria: Positive — an owned, in-range Java application is exposed and corroborated in two indices; Negative — no owned instance is exposed AND the unscoped product filters returned non-zero (the filters work); Non-Conclusive — indices unreachable (missing API keys), attribution ambiguous, or the public IP/cloud inventory is incomplete; missing an authoritative owned-IP inventory prevents determining whether an exposed instance belongs to the organization.
Hypothesis 2: an attacker has exploited the Base64 decoder flaw against a reachable Java service and achieved code execution, observable as a Java process (java/javaw) spawning a command interpreter or network client in endpoint process telemetry.
MITRE ATT&CK: Initial Access | T1190 — Exploit Public-Facing Application | a crafted Base64 payload to a Java service triggers heap corruption and attacker-controlled execution. · Execution | T1059 — Command and Scripting Interpreter | the exploited JVM spawns a shell or scripting interpreter as its child.
Collection Queries:
CrowdStrike Falcon LogScale (CQL) — Windows: Java process spawning a command interpreter or LOLBin:
#event_simpleName=ProcessRollup2 event_platform=Win
| ParentBaseFileName=/^javaw?\.exe$/i
| FileName=/^(cmd\.exe|powershell\.exe|pwsh\.exe|wscript\.exe|cscript\.exe|mshta\.exe|certutil\.exe|bitsadmin\.exe|rundll32\.exe|regsvr32\.exe)$/i
| table([@timestamp, aid, ComputerName, ParentBaseFileName, FileName, CommandLine, UserName], limit=20000)
→ Expected Positive shape: a cmd.exe / powershell.exe child of javaw.exe on a server that hosts a Java application, with a command line pulling a remote payload or running reconnaissance.
CrowdStrike Falcon LogScale (CQL) — Linux: Java process spawning a shell or download tool:
#event_simpleName=ProcessRollup2 event_platform=Lin
| ParentBaseFileName=/^java$/i
| FileName=/^(sh|bash|dash|zsh|python3?|perl|nc|ncat|curl|wget)$/i
| table([@timestamp, aid, ComputerName, ParentBaseFileName, FileName, CommandLine, UserName], limit=20000)
→ Expected Positive shape: a /bin/sh or curl child of java on a Linux application host or container node, launched with no legitimate operational reason.
Datadog — Windows process creation (Sysmon EID 1 forwarded) and container fallback:
source:windows @EventID:1 @ParentImage:*\\javaw.exe (@Image:*\\cmd.exe OR @Image:*\\powershell.exe OR @Image:*\\pwsh.exe OR @Image:*\\bash.exe)
// time range: 2026-11-17T00:00Z to current
source:kubernetes @kubernetes.container_name:* message:"/bin/sh"
// time range: 2026-11-17T00:00Z to current; data-source gap: if container stdout does not capture child-process exec, this is a silent zero — fall back to the CQL Linux query above
Datadog Live Process Monitoring (Infrastructure > Processes — NOT a log source; requires process_config.process_collection.enabled: true):
command:java
// enumerate running Java processes and their owning user as the target population; parent/child lineage is not expressed here, so use the CQL/Sysmon legs for the spawn relationship
Windows Event IDs to collect:
- Sysmon Event ID 1 (Process Creation) — ParentImage ending in javaw.exe/java.exe; the authoritative source for the spawn relationship.
- Security Event ID 4688 (A new process has been created) — requires command-line auditing; NewProcessName the interpreter, ParentProcessName the Java binary.
Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-Sysmon/Operational'; Id=1; StartTime=(Get-Date '2026-11-17')} | Where-Object { $_.Message -match 'ParentImage:.*javaw?\.exe' -and $_.Message -match 'Image:.*\\(cmd|powershell|pwsh|wscript|cscript|mshta)\.exe' } | Select-Object TimeCreated, Message | Export-Csv -NoTypeInformation java4shell_sysmon_children.csv
Analysis Queries:
CrowdStrike Falcon LogScale (CQL) — rarity of child images under Java across the fleet:
#event_simpleName=ProcessRollup2 event_platform=Win ParentBaseFileName=/^javaw?\.exe$/i
| groupBy([FileName], function=count(as=cnt), limit=max)
| sort(cnt, order=asc, limit=50)
→ Expected Positive shape: a shell or LOLBin child image that is rare fleet-wide and newly appears under java on a specific host.
Datadog Log Analytics: Table view, group by @ParentImage and @Image; time range 2026-11-17 to current — counts interpreter children per Java parent to separate a one-off from a recurring pattern.
Datadog Monitor:
Type: Log Alert
Query: source:windows @EventID:1 @ParentImage:*\\javaw.exe (@Image:*\\cmd.exe OR @Image:*\\powershell.exe OR @Image:*\\pwsh.exe OR @Image:*\\bash.exe)
Evaluation window: last 5 minutes
Alert condition: count > 0
Message: "ALERT: Java process spawned a command interpreter — possible CVE-2026-114938 post-exploitation code execution @security-team-slack"
Prerequisites: Windows Sysmon EID 1 (ParentImage/Image) forwarded to Datadog, or Kubernetes container exec logging
YARA — process-memory scan of a suspect Java PID (classic YARA 4.5; PID is the positional target, there is no -p PID flag; YARA-X cannot scan process memory):
yara java4shell_mem.yar <suspect_java_pid> >> java4shell_mem_hits.txt
CrowdStrike Falcon Real Time Response (RTR) can stage java4shell_mem.yar and run it against the live Java PID on a remote host; a Custom IOA can flag the javaw.exe-to-interpreter spawn natively.
Control — Java process telemetry presence (field-presence control for the ParentBaseFileName filter; a family-presence control would not cover it):
#event_simpleName=ProcessRollup2 event_platform=Win
| ParentBaseFileName=/^javaw?\.exe$/i
| count(as=java_parent_events)
If this is 0, Java processes are not being observed on Windows in scope (sensor/coverage gap) and every negative from this leg is Non-Conclusive, not Negative.
Verdict criteria: Positive — a Java process spawned a command interpreter or network client with no legitimate operational explanation; Negative — no such child observed AND java_parent_events is non-zero (Java telemetry present); Non-Conclusive — java_parent_events is 0 or unrun, or Sysmon/4688 not forwarded; missing process-child telemetry prevents determining whether execution occurred.
Hypothesis 3: exploitation attempts (successful or not) against the Base64 decoder are crashing the JVM, observable as repeated Java fatal-error terminations and service restarts, and as abnormally long inbound Base64 payloads to Java service ports.
MITRE ATT&CK: Impact | T1499 — Endpoint Denial of Service | malformed oversized Base64 input corrupts the heap and crashes the JVM, taking the hosted service offline. · Initial Access | T1190 — Exploit Public-Facing Application | the same decoder path is the delivery vector.
Collection Queries:
CrowdStrike Falcon LogScale (CQL) — Java process start frequency per host (a crash-restart loop shows as many starts of a normally long-lived service; FileName is valid on ProcessRollup2 — do NOT filter image name on EndOfProcess, which does not carry it):
#event_simpleName=ProcessRollup2 event_platform=Win
| FileName=/^javaw?\.exe$/i
| groupBy([ComputerName], function=count(as=java_starts), limit=max)
| sort(java_starts, order=desc, limit=100)
→ Expected Positive shape: a host whose Java service shows a start count far above its baseline across the window — a crash-and-restart loop.
CrowdStrike Falcon LogScale (CQL) — inbound connections to Java service ports (NetworkReceiveAcceptIP4 is an inbound accept: LocalPort = the service reached, RemoteAddressIP4 = the connecting peer):
#event_simpleName=NetworkReceiveAcceptIP4 event_platform=Win
| in(LocalPort, values=["8080","8090","9200","9300","8443","7990","50000"])
| groupBy([ComputerName, LocalPort, RemoteAddressIP4], function=count(as=conns), limit=max)
| sort(conns, order=desc, limit=100)
→ Expected Positive shape: a burst of inbound connections to a Java service port from a single external peer immediately preceding a cluster of JVM restarts on that host.
BPF packet capture (tcpdump) — VLAN-aware two-branch form is required (in real OT/IT exports every frame carried an 802.1Q tag and an untagged filter matched zero); pair the scoped capture with an unscoped control:
tcpdump -i <iface> -n -s 0 -G 3600 -C 100 -w '/pcap/java4shell_%Y%m%d_%H%M%S.pcap' '(tcp port 8080 or tcp port 8090 or tcp port 9200 or tcp port 8443 or tcp port 7990) or (vlan and (tcp port 8080 or tcp port 8090 or tcp port 9200 or tcp port 8443 or tcp port 7990))'
tcpdump -i <iface> -n -s 0 -G 3600 -C 100 -w '/pcap/control_%Y%m%d_%H%M%S.pcap' '(tcp) or (vlan and tcp)'
Datadog — JVM fatal-error / crash logs and oversized request bodies (source is your Java application's log integration):
source:jvm ("hs_err_pid" OR "A fatal error has been detected by the Java Runtime Environment" OR "SIGSEGV" OR "EXCEPTION_ACCESS_VIOLATION")
// time range: 2026-11-17T00:00Z to current
source:nginx @http.request.content_length:>1000000 @http.url_details.path:*
// time range: 2026-11-17T00:00Z to current; prerequisite: the reverse proxy must forward request content_length as a parsed attribute, else this is a silent zero
Windows Event IDs to collect:
- Service Control Manager Event ID 7031 / 7034 — a service terminated unexpectedly (Java-hosted services such as Jira, Confluence, Jenkins, Elasticsearch, Tomcat).
- Application Error Event ID 1000 and Windows Error Reporting Event ID 1001 — faulting module and crash bucket for a javaw.exe fault.
Get-WinEvent -FilterHashtable @{LogName='System'; Id=7031,7034; StartTime=(Get-Date '2026-11-17')} | Where-Object { $_.Message -match '(?i)(jira|confluence|jenkins|elasticsearch|tomcat|java)' } | Select-Object TimeCreated, Id, Message | Export-Csv -NoTypeInformation java4shell_service_crashes.csv
Analysis Queries:
CrowdStrike Falcon LogScale (CQL) — correlate inbound bursts with restart counts by host (composite groupBy; LogScale aggregates render progressively, so only quote a result whose job status reads Done):
#event_simpleName=/^(ProcessRollup2|NetworkReceiveAcceptIP4)$/ event_platform=Win
| case { #event_simpleName=ProcessRollup2 | FileName=/^javaw?\.exe$/i | kind := "start"; #event_simpleName=NetworkReceiveAcceptIP4 | in(LocalPort, values=["8080","8090","9200","8443","7990"]) | kind := "inbound"; }
| groupBy([ComputerName], function=[count(kind, as=events), collect([kind])], limit=max)
| sort(events, order=desc, limit=100)
Wireshark display filters (HTTPS services expose URIs/bodies to the sensor only where TLS is terminated or keys are provided with -o tls.keylog_file:<file>):
http.request and frame.len > 2000
tshark -r java4shell.pcap -Y 'http.request and frame.len > 2000' -T fields -e ip.src -e http.host -e http.request.uri -e frame.len
Datadog Monitor:
Type: Log Alert
Query: source:jvm ("hs_err_pid" OR "A fatal error has been detected by the Java Runtime Environment" OR "SIGSEGV")
Evaluation window: last 10 minutes
Alert condition: count > 2
Message: "ALERT: repeated JVM fatal-error crashes — possible CVE-2026-114938 Base64 decoder denial of service @security-team-slack"
Prerequisites: JVM stdout and hs_err_pid files forwarded to Datadog from the Java application hosts
YARA — file-system scan for captured oversized Base64 payloads (request logs, temp files, heap/crash dumps):
yara -r java4shell_disk.yar /var/log /tmp /opt/atlassian /var/lib/jenkins >> java4shell_disk_hits.txt
Control — Java process telemetry presence (field-presence control for the FileName filter):
#event_simpleName=ProcessRollup2 event_platform=Win
| FileName=/^javaw?\.exe$/i
| count(as=java_proc_events)
If this is 0, there is no Java process telemetry in scope and a "no crash-loop" result is Non-Conclusive. Likewise, if no Java application log source is forwarded to Datadog, the crash-log leg reports Non-Conclusive, never clean.
Verdict criteria: Positive — repeated JVM fatal-error terminations / service restarts correlate with inbound bursts or oversized Base64 payloads on a Java service host; Negative — no abnormal crash frequency AND java_proc_events is non-zero; Non-Conclusive — java_proc_events is 0, no JVM log source forwarded, or capture not available; missing crash telemetry or request-body visibility prevents determining whether a DoS attempt occurred.
Hypothesis 4: a Java-based OT/ICS application (historian, HMI, or engineering workstation) has been crashed or restarted by an exploitation attempt, observable as unexpected device restarts, historian data gaps, and loss of operator view.
MITRE ATT&CK: ICS Impact | T0815 — Denial of View | a Java-based historian/HMI JVM crash removes operator visibility. · ICS Impact | T0816 — Device Restart/Shutdown | repeated crashes force host restarts. · Impact | T1499 — Endpoint Denial of Service.
Collection Queries:
OT Data Collection: Claroty xDome — in Device Inventory, scope tenant-wide (not site-scoped — a site-scoped absence is a false zero) to assets whose installed software or OS indicates a Java-based historian/HMI/EWS; export the device list as the H-4 population. Do NOT fence the population with Category = OT (a misclassified asset falls silently outside a Category-scoped clause); scope by network/VLAN instead.
OT Data Collection: Dragos Platform — in Assets, scope to Level 2/3 HMI, historian, and engineering-workstation assets by vendor/role; carry forward as the H-4 hunt population. Triage Notifications filtered to ICS Impact techniques across the window and pivot any hit to its asset and event PCAP.
OT Data Collection: Nozomi Guardian — open the Asset view for each candidate historian/HMI node and record its peer set, protocol mix, and open vulnerabilities; use the Variable view to flag any process-variable excursion outside the learned band with no corresponding operator action (an OT-integrity signal no IT tool produces).
OT Data Collection: Tenable OT — in Inventory > All Assets, filter AssetType in (OtServer, OtWorkstation, Eng) and vendor matching the affected historian/HMI software; export as the H-4 population (exclude TenableSensor / TenableIcp / TenableEm from any client-reported count).
OT Data Collection: Forescout eyeInspect — in Command Center > Asset Inventory, filter purdue_level in (2,3) and main_role matching historian/HMI/engineering; export the host changelog for the window and escalate any os_version or firmware_version transition with no maintenance work order.
OT Data Collection: Armis Centrix — enumerate OT application hosts and their service posture:
in:devices operatingSystem:Windows role:Server purdueLevel:2,3
SNMP polling — detect unexpected restarts of the historian/HMI host and device-facing switch port anomalies (treat any v1/v2c community access to OT assets as a finding in its own right; provision SNMPv3 credentials via snmp.conf rather than inline):
snmpwalk -v3 -l authPriv -u <user> -a SHA-256 -A <authpass> -x AES-256 -X <privpass> <historian_ip> system
snmpget -v2c -c <community> <switch_ip> IF-MIB::ifHCInOctets.<ifIndex> IF-MIB::ifHCOutOctets.<ifIndex> IF-MIB::ifInErrors.<ifIndex> IF-MIB::ifOutErrors.<ifIndex>
Collect SNMP traps from the receiver for the window and flag coldStart (1.3.6.1.6.3.1.1.5.1) and warmStart (1.3.6.1.6.3.1.1.5.2) from historian/HMI IP ranges — an unexpected restart of a Java-hosted OT application is the ICS-side signature of this flaw.
Analysis Queries:
Historian / SCADA alarm correlation: pull the historian tag-collection log and alarm journal for the window; a gap in continuous tag collection that aligns with a host coldStart/warmStart trap, with no scheduled maintenance, is the Denial-of-View signal. Correlate each gap against the OT platform's asset restart events.
OT protocol analysis (Wireshark / tshark on exported OT PCAP): confirm whether the Java-hosted OT host stopped originating its normal polling after the suspected crash:
tshark -r ot_historian.pcap -Y 'ip.addr == <historian_ip> and (modbus or s7comm or opcua or cip or dnp3)' -T fields -e frame.time -e ip.src -e ip.dst -e _ws.col.Protocol
Control — OT monitoring coverage: record any Nozomi/Dragos/Forescout sensor in an unhealthy state or any stopped capture module before any negative disposition. A clean result from an unhealthy sensor, or a historian whose collection simply was not monitored, is Non-Conclusive, not Negative. Confirm the device population is non-empty (xDome devices_count > 0 for the site) before trusting an absence.
Verdict criteria: Positive — a Java-based OT host restart or historian collection gap correlates with an exploitation indicator and has no maintenance explanation; Negative — no unexplained OT restart/gap AND OT monitoring coverage confirmed healthy and non-empty; Non-Conclusive — sensor unhealthy, SNMP traps unavailable, or historian logs not retained for the window; missing OT restart/historian telemetry prevents determining whether an availability impact occurred. A leg that only shows our own OT monitoring is incomplete reports a coverage gap, never a Positive.
Threat Actor Profile
No named threat actor, APT group, or malware family is attributed to CVE-2026-114938 as of 2026-11-17, and no in-the-wild exploitation has been reported. The realistic near-term threat profile is opportunistic rather than targeted. The pre-conditions that drive Java exploitation campaigns historically — a network-reachable, unauthenticated code path present in an enormous installed base — are all present here, which is the same pattern that produced mass scanning within days of disclosure for comparable Java and web-application flaws. The most probable first movers are commodity and ransomware-adjacent actors running internet-wide scans for the affected application banners, followed by access brokers. The elevated attack complexity in the CVSS v3.1 vector (AC:H) means reliable exploitation is not trivial, which tends to favour better-resourced actors for code execution while leaving the denial-of-service outcome within reach of low-skill attackers simply sending malformed input.
Attribution caveats carried forward: any future vendor cluster name is not a government attribution; aliases are overlaps, not identities; and hacktivist self-claims of exploitation warrant the harshest skepticism until corroborated. Where an edge or management appliance fronts a Java application, treat the appliance address as a potential pivot source and hunt authentications and connections originating FROM it into internal and OT segments.
Data Sources Required
Endpoint: CrowdStrike Falcon (ProcessRollup2, NetworkReceiveAcceptIP4, NetworkConnectIP4, EndOfProcess), Windows Sysmon (Event ID 1), Windows Security (4688), Windows System (SCM 7031/7034), Windows Application (1000) and Windows Error Reporting (1001). Application: JVM stdout and hs_err_pid crash files, Java application logs (Jira/Confluence/Jenkins/Elasticsearch/Tomcat), reverse-proxy request logs with parsed content_length. Network: full packet capture at the Java-service choke points, NetFlow, firewall logs, and IDS (Snort/Suricata) where TLS is terminated or keys are available. Cloud/container: Datadog (source:windows, source:kubernetes, source:jvm, source:nginx) and Live Process Monitoring. OT/ICS: historian tag-collection and alarm logs, SCADA alarms, SNMP trap receiver, and the OT monitoring platforms (Claroty xDome, Dragos, Nozomi, Tenable OT, Forescout, Armis) with their asset inventories and PCAP exports.
External attack surface: the passive internet-scan indices queried read-only (Shodan, Censys, Netlas), the CISA Known Exploited Vulnerabilities catalog, and the organization's authoritative public IP ranges and cloud asset inventory — the last of which is required for attribution and without which the exposure determination in Hypothesis 1 cannot be made.
Detection Signatures
SIGMA rule 1 — Java process spawning a command interpreter (Windows):
title: Java Process Spawning Command Interpreter (CVE-2026-114938 Java4Shell)
id: 7f3a1c2d-8b4e-4a6f-9c1d-2e5f7a9b0c3d
status: experimental
description: Detects a Java runtime (java.exe/javaw.exe) spawning a Windows command interpreter or LOLBin, consistent with post-exploitation of the Java4Shell Base64 decoder flaw.
references:
- https://www.cisa.gov/news-events/alerts/2026/11/17/critical-java-vulnerability-requires-immediate-patching
author: 1898 & Co.
date: 2026-11-18
logsource:
category: process_creation
product: windows
detection:
selection:
ParentImage|endswith:
- '\java.exe'
- '\javaw.exe'
Image|endswith:
- '\cmd.exe'
- '\powershell.exe'
- '\pwsh.exe'
- '\wscript.exe'
- '\cscript.exe'
- '\mshta.exe'
- '\certutil.exe'
- '\rundll32.exe'
condition: selection
falsepositives:
- Java build tooling or application scripts that legitimately shell out
level: high
SIGMA rule 2 — Java process spawning a shell or download tool (Linux):
title: Java Process Spawning Shell or Download Tool (CVE-2026-114938 Java4Shell)
id: 1b9c4d7e-3a2f-4e8d-b6c5-9f0a1d2e3b4c
status: experimental
description: Detects a Java runtime spawning an interactive shell or network download client on Linux, consistent with post-exploitation of the Java4Shell Base64 decoder flaw in containerized and server workloads.
references:
- https://www.cisa.gov/news-events/alerts/2026/11/17/critical-java-vulnerability-requires-immediate-patching
author: 1898 & Co.
date: 2026-11-18
logsource:
category: process_creation
product: linux
detection:
selection:
ParentImage|endswith: '/java'
Image|endswith:
- '/sh'
- '/bash'
- '/dash'
- '/nc'
- '/ncat'
- '/curl'
- '/wget'
- '/python3'
condition: selection
falsepositives:
- CI/CD Java build agents that legitimately invoke curl or shell steps
level: high
SIGMA rule 3 — unexpected outbound connection initiated by a Java process (network):
title: Outbound Network Connection From Java Process to External Host (CVE-2026-114938)
id: 2c8d5e9f-4b3a-4f1e-a7d6-0b1c2d3e4f5a
status: experimental
description: Detects a Java runtime initiating an outbound connection to a non-internal address, consistent with a reverse shell or payload retrieval after Java4Shell exploitation.
references:
- https://www.cisa.gov/news-events/alerts/2026/11/17/critical-java-vulnerability-requires-immediate-patching
author: 1898 & Co.
date: 2026-11-18
logsource:
category: network_connection
product: windows
detection:
selection:
Image|endswith:
- '\java.exe'
- '\javaw.exe'
Initiated: 'true'
internal:
DestinationIp|cidr:
- '10.0.0.0/8'
- '172.16.0.0/12'
- '192.168.0.0/16'
condition: selection and not internal
falsepositives:
- Java applications with legitimate external integrations (update checks, licensing, SaaS APIs)
level: medium
Snort/Suricata rule 1 — abnormally long Base64 run in an HTTP request body to a Java service (fires only where the sensor sees decrypted traffic; on an HTTPS service provide session keys or place the sensor behind TLS termination):
alert http any any -> $HOME_NET any (msg:"CVE-2026-114938 Java4Shell oversized Base64 blob in HTTP request body"; flow:established,to_server; http.request_body; pcre:"/[A-Za-z0-9+\/]{1024,}={0,2}/"; classtype:attempted-admin; sid:1000001; rev:1; reference:cve,2026-114938;)
Snort/Suricata rule 2 — interactive-shell command output in outbound traffic (reverse-shell callback after exploitation):
alert tcp $HOME_NET any -> $EXTERNAL_NET any (msg:"CVE-2026-114938 Java4Shell possible reverse shell - unix id command output"; flow:established,from_server; content:"uid="; content:"gid="; distance:0; within:64; pcre:"/uid=[0-9]+/"; classtype:successful-admin; sid:1000002; rev:1; reference:cve,2026-114938;)
YARA rule 1 (file/disk) — this rule flags an abnormally long contiguous Base64 run, the on-disk fingerprint of the oversized Base64 input the Java4Shell exploit feeds to the decoder when it is captured to a request log, temporary file, or JVM crash/heap dump. The condition anchors on a single bounded Base64 character run with a high lower bound (1024) so that ordinary Base64 tokens — session cookies, embedded images under a few hundred bytes, signed JWTs — fall below the threshold and do not match; the upper bound keeps the regex engine bounded on very large files.
rule Java4Shell_Oversized_Base64_Input_Artifact
{
meta:
description = "Abnormally long contiguous Base64 run characteristic of a CVE-2026-114938 oversized Base64 decoder payload captured to disk"
author = "1898 & Co."
date = "2026-11-18"
reference = "CVE-2026-114938"
strings:
$b64_run = /[A-Za-z0-9+\/]{1024,8192}={0,2}/
condition:
$b64_run
}
YARA rule 2 (process memory) — this rule targets the in-memory residue of a successful Java4Shell exploitation inside a live java/javaw process: an injected ELF image or Windows reverse-shell stub together with shell and socket indicators. The condition requires at least one execution stub (an ELF header or a PE "This program cannot be run in DOS mode" stub that would not normally sit inside managed JVM heap) AND at least one shell/socket string, so that benign Base64 data or ordinary class bytes in the heap do not trip it; the two-part AND is the false-positive control.
rule Java4Shell_InMemory_Exploit_Artifacts
{
meta:
description = "In-memory exploitation residue (injected native stub plus shell/socket indicators) in a java/javaw process after CVE-2026-114938 exploitation"
author = "1898 & Co."
date = "2026-11-18"
reference = "CVE-2026-114938"
strings:
$elf = { 7F 45 4C 46 } // ELF magic in heap (injected native payload)
$dos = "This program cannot be run in DOS mode" // PE stub in heap
$sh1 = "/bin/sh"
$sh2 = "cmd.exe /c"
$sock1 = "connect" nocase
$sock2 = "/dev/tcp/"
condition:
(1 of ($elf, $dos)) and (1 of ($sh1, $sh2, $sock1, $sock2))
}
Indicators of Compromise
Network: no published malicious IPs, domains, or C2 infrastructure exist for CVE-2026-114938 as of 2026-11-17. The actionable network pattern is behavioral — an abnormally long contiguous Base64 run (roughly 1 KB or more) in an inbound request body to a Java service port (8080, 8090, 8443, 9200, 7990, 50000, or any custom Java endpoint), optionally followed by an outbound connection initiated by the Java process itself.
Host: a Java process (java.exe/javaw.exe/java) spawning a command interpreter, scripting engine, or download tool; repeated JVM fatal-error terminations (hs_err_pid files, "A fatal error has been detected by the Java Runtime Environment", SIGSEGV, EXCEPTION_ACCESS_VIOLATION); Service Control Manager Event ID 7031/7034 for a Java-hosted service; and an injected native stub plus shell/socket strings in java process memory.
OT/operational: an unexpected coldStart/warmStart on a Java-based historian or HMI host with no maintenance work order; a gap in continuous historian tag collection aligned with such a restart; and a Java-hosted OT host ceasing its normal protocol polling after a suspected crash.
External exposure: an owned, internet-reachable instance of an affected Java application (Jira, Confluence, Jenkins, Elasticsearch, or a custom Java web service), corroborated across at least two passive scan indices and confirmed as organization-owned by at least two independent ownership signals.
False Positive Baseline
1. Java build and automation tooling (Maven, Gradle, Jenkins pipeline steps, Ant) that legitimately shells out to cmd.exe, powershell.exe, sh, or curl — scope these out by host role and by the specific pipeline command lines before escalating a Java-to-interpreter spawn.
2. Application-server management scripts and health checks that launch a shell from the JVM on a fixed schedule — baseline the recurring parent/child/command-line tuple.
3. Legitimate external integrations by Java applications (license checks, update polls, SaaS API calls) that produce outbound connections from java.exe to external addresses — allowlist the known destinations rather than the process.
4. Ordinary short Base64 tokens — session cookies, signed JWTs, small embedded images, SAML assertions — which sit well below the 1 KB run threshold and must not be treated as oversized payloads.
5. Planned maintenance restarts of Java-hosted services and OT historian/HMI hosts that produce SCM 7031/7034 or coldStart/warmStart traps — correlate every restart against the change-management record before calling it anomalous.
6. JVM crashes from unrelated causes (out-of-memory, a bad application deployment, a hardware fault) that generate hs_err_pid files without any inbound oversized-Base64 correlate.
Escalation Criteria
1. Any confirmed Java process spawning a command interpreter, scripting engine, or network download tool with no legitimate operational explanation — engage incident response immediately and isolate the host.
2. Any YARA hit on Java4Shell_Oversized_Base64_Input_Artifact against a request log, temporary file, or JVM crash/heap dump on a Java service host — collect the artifact and the surrounding request context.
3. Any YARA hit on Java4Shell_InMemory_Exploit_Artifacts against a live java/javaw process — capture a full memory image of the PID before remediation and engage IR.
4. Repeated JVM fatal-error crashes or SCM 7031/7034 service terminations on a Java host that correlate in time with inbound bursts or oversized Base64 payloads to that host's service port.
5. A two-index-corroborated, organization-owned, internet-facing instance of an affected Java application that has been continuously exposed since 2026-11-17, or any such instance that later matches a CISA KEV listing for CVE-2026-114938.
6. Any unexplained coldStart/warmStart or historian tag-collection gap on a Java-based OT historian/HMI host — escalate under the OT incident process and treat as potential Loss of View.
Hunt Completion Criteria and Reporting
The hunt is complete when every hypothesis has been executed against the full in-scope population for the window (bounded by the measured data floor), each control query has returned a non-zero result or its gap has been recorded, and Hypothesis 1 has been corroborated across at least two indices for every owned public range. The report must give a verdict per hypothesis using that hypothesis's Verdict criteria, and must not downgrade a primary verdict because a secondary leg carried a residual finding.
Reporting rules: make an absence claim only from a single-predicate filter (filter for the artifact and count it), never by reading a distribution table; quote only queries whose LogScale job status reads Done (a progressively rendered aggregate looks final before it is); and record every limitation with its direction — an IDS on an HTTPS service sees request bodies only where TLS is terminated or keys are supplied (inbound only), Live Process Monitoring does not express parent/child lineage, and Datadog captures only what is forwarded. Report every leg whose control was 0 or unrun as Non-Conclusive, naming the missing input, and report any leg that only measures our own collection or sensor health as a coverage gap, never as a Positive. Recommend that the Hypothesis 1 external-exposure sweep be made a recurring control, since exposure removal is one of only two mitigations available where a host cannot yet be patched.
Advisory IoC Reference
| IOC Type | IOC |
|---|---|
| CVE | CVE-2026-114938 | CVSS v3.1 8.1 | Oracle Java SE / OpenJDK 17, 21, 25, 27 (x86-64 HotSpot) | Base64 decoder heap memory corruption; unauthenticated, network-reachable denial of service and potential remote code execution (researcher-assigned CVSS v4.0 9.2). Fixed in Oracle Nov 2026 CPU (17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1) and Amazon Corretto 17.0.21.1.2. |
| Threat Actor | None attributed — no in-the-wild exploitation reported as of 2026-11-17; not in CISA KEV |
| Malware | None published in source material |
| Network IOC | None published in source material — monitor https://www.cisa.gov/known-exploited-vulnerabilities-catalog and Oracle/OpenJDK advisories |
| File IOC | None published in source material |
| Behavioral | Java process (java/javaw) spawning a command interpreter, scripting engine, or network download tool |
| Behavioral | Repeated JVM fatal-error terminations (hs_err_pid / SIGSEGV / EXCEPTION_ACCESS_VIOLATION) on a long-lived Java service |
| Behavioral | Abnormally long contiguous Base64 run (>=1 KB) in an inbound request to a Java service port (8080/8090/8443/9200/7990/50000) |
| Behavioral | Service Control Manager Event ID 7031/7034 service-terminated-unexpectedly for a Java-hosted service (Jira/Confluence/Jenkins/Elasticsearch/Tomcat) |
| Behavioral | Unexpected coldStart/warmStart SNMP trap or historian tag-collection gap on a Java-based OT historian/HMI host with no change record |