Summary
CVE-2026-114938, tracked as Java4Shell, is a heap out-of-bounds write in the AVX-512 VBMI-accelerated Base64 decoder built into OpenJDK's HotSpot JVM [1][3][5]. Security firm Calif disclosed the flaw and published a safe reproducer on November 17, 2026, the same day Oracle and OpenJDK shipped fixed builds [1][7][11]. Calif reported achieving pre-authentication remote code execution against default configurations of Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, and PingFederate, and post-authentication RCE against Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, and Spinnaker [1][4][9]. Each application requires a tailored exploit chain; no universal exploit exists [4][11].
As of November 19, 2026, GreyNoise recorded over 150 (later updated to 187) requests matching Java4Shell attack signatures from five IP addresses, with no confirmed successful intrusions against its sensors [13][14]. WatchTowr reported seeing attackers spray the internet with requests carrying java4shell-recon User-Agent strings, alongside blind exploitation attempts using correctly shaped requests [12][13]. CISA published an alert on November 17 urging immediate patching but has not added the CVE to its Known Exploited Vulnerabilities catalog [11][12][14]. The Canadian Centre for Cyber Security published advisory AL26-029 [11].
Background
Calif researcher Quang Luong discovered the vulnerability using human-directed AI research, finding the bug in roughly an hour and producing a working exploit two hours later for under $200 in model costs [14]. Oracle's advisory also credits Albert Yang (albertnetymk), who independently identified the root cause and proposed a fix in the public OpenJDK repository [1][11].
The disclosure timeline, reconstructed from Calif's write-up [1]:
- June 9, 2026: A developer named sundarms encountered the bug in the wild and opened an Adoptium issue.
- September 8: sundarms posted a proof-of-concept reproducing the crash; albertnetymk identified the root cause the same day.
- September 9: albertnetymk proposed a fix in
openjdk/jdk#32781. - October 24: Quang Luong of Calif independently discovered the bug with AI assistance and reported it to Oracle with a PoC demonstrating post-auth RCE in Elasticsearch.
- November 9: Bruce Dang of Calif urged Oracle to begin disclosure coordination, noting the bug was effectively public even though its security implications were not widely understood [1].
- November 12: Fix JDK-8393212 committed to the public jdk17u repository [18].
- November 13: Oracle notified Calif of the fix, to be released November 17 at 1:00 PM PT.
- November 16: Calif and Oracle met to discuss severity.
- November 17: Oracle released the fix in its November 2026 Critical Security Patch Update; Calif published its write-up thirteen minutes later [1][14].
Calif used the same human-plus-AI methodology it previously applied to PHP2Shell a month earlier [14]. The firm is withholding its product-specific exploit chains to give organizations time to patch [9][10].
The Vulnerable Code Path
The flaw resides in hand-written x86-64 assembly that OpenJDK's C2 JIT compiler substitutes for java.util.Base64.Decoder when the host CPU supports AVX-512 VBMI instructions [1][3][6]. This intrinsic processes Base64 input in 256-byte blocks (or 64-byte blocks for shorter inputs) and handles the tail with the evmovdqub instruction, which uses a 64-bit mask to select which bytes reach memory [6].
The mask is derived from the output length. For a tail of 1 to 3 Base64 characters ending with padding, the calculated output length is zero. The padding handler then decrements it, causing an underflow to -1 or -2. The bzhiq(-1, output_len) instruction leaves every bit set when the length reads as 64 or more, so the output mask becomes all ones and all 64 bytes are written [6].
The Overflow
For a payload of 64 A characters followed by =, Java allocates a 50-byte result array. The store begins at offset 48, so 62 bytes land past the end of the array before the Java code throws IllegalArgumentException [1][6][9]. On OpenJDK 17 builds earlier in the affected range, the trigger input is 128 A characters followed by = due to a higher length threshold to reach the vulnerable code path [1].
The bytes written are fixed in value (not attacker-controlled content), so the attacker controls placement but not the specific data written [3][4]. Despite this constraint, Calif demonstrated that overwriting adjacent JVM object metadata on the heap is sufficient to chain into a Heartbleed-style memory read (which Calif calls "JavaBleed") that leaks keys, tokens, and personal data, and ultimately into code execution [1][6][8].
Why Standard Operation Rarely Triggers It
Calif's write-up addresses why the bug persisted since January 2023 without widespread crashes: legitimate Base64 input virtually never produces the specific malformed padding pattern required [1]. The JVM's garbage collector can also move objects before corruption becomes visible. The flaw was present in every affected Java release since 17.0.6 [8].
The Fix
The upstream fix is tracked as JDK-8393212, titled "Base64 optimization improvements." It consists of a three-to-four line guard on the input length that prevents the underflow [3][18]. Fixed releases shipped November 17, 2026 [3][7].
Affected Versions and Hardware
All three of the following conditions must be true for RCE exposure [17]:
- Java runtime: OpenJDK 17.0.6 or later (branches 17, 21, 25, and 27), or any downstream distribution built from affected source. Affected distributions: Oracle Java SE, Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat OpenJDK, and Oracle GraalVM for JDK [2][17]. Oracle's Java 8 Enterprise Performance Pack (
8u511b33-perf) is also affected [17]. Standard Java 8 and 11 builds are not affected. OpenJ9-based runtimes (including IBM Semeru) are not affected because they lack the HotSpot intrinsic [16][17].
- Hardware: x86-64 with AVX-512 VBMI support. Intel Xeon Ice Lake and newer (Sapphire Rapids, Emerald Rapids, Granite Rapids) and AMD EPYC/Ryzen Zen 4 and newer qualify [7][10][17]. ARM64 hosts (AWS Graviton, Apple Silicon) are not affected [2][7][9].
- Application behavior: The application passes attacker-controlled Base64 data to
java.util.Base64.Decoder(viaBase64.getDecoder()orgetUrlDecoder()) [8]. Common vectors include HTTP Basic authentication headers, JWTs, SAML artifacts, CSRF tokens, session cookies, and file uploads [6][10]. This decoding frequently occurs before any authentication check [1][4].
Absence of any single condition eliminates RCE feasibility at that host. End-of-life branches (Java 18 through 20, 22 through 24, and 26) are affected but will not receive patches; organizations on those versions must move to a supported line [7][14][17].
Cloud security firm Upwind reproduced Java4Shell on an AWS c6i instance (Intel Ice Lake), confirming that standard cloud infrastructure meets the hardware prerequisite [9]. Zest Security reported Shodan observes approximately 954,700 internet-facing hosts running Java, with 38% on AWS [14].
Fixed Releases
| Java Branch | Fixed Version | Release Date | Notes |
|---|---|---|---|
| Java 17 | 17.0.21.1 |
November 17, 2026 | [3][7] |
| Java 21 | 21.0.13.1 |
November 17, 2026 | [3][7] |
| Java 25 | 25.0.5.1 |
November 17, 2026 | [3][7] |
| Java 27 | 27.0.1.1 |
November 17, 2026 | [3][7] |
| Java 8 EPP | 8u513-perf |
November 17, 2026 | [17] |
Vendor-specific status as of November 19, 2026:
- Amazon Corretto: Fixed in Corretto 17.0.21.1.2 and 21.0.13.1.2, released November 17 [5].
- Eclipse Temurin: Fixes confirmed available (17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1) [7]. Eclipse Adoptium confirmed November 18 that November releases of Temurin fix the flaw [15]. However, as of November 19, the
eclipse-temurin:21Docker Hub tags still carried Java 21.0.13 (within the affected range), so rebuilding on the latest tag may not pick up the fix [14]. - Red Hat: Advisory RHSA-2026:100573 issued November 18 covers OpenJDK 25.0.5.1 portable Linux build; Red Hat's CVE page lists
java-17,java-21, andjava-25packages on supported RHEL releases as affected with no RHEL-specific errata yet [2]. Red Hat issued security bulletin RHSB-2026-018 on November 19 [15]. - Microsoft Build of OpenJDK: No fixed build found as of November 17; upgrade and Azure WAF mitigation guidance published same day [3].
- Keycloak: Container images 26.8, 26.8.2, and 26.8.2-3 contain fixes. The Keycloak team warned that earlier images 26.8.2-1 and 26.8.2-2 bundled a vulnerable OpenJDK 21 build [12][13].
- Quarkus: The framework itself is not affected; native executables built with Mandrel are not affected. Builder images (Mandrel and GraalVM CE) were patched with a workaround [16].
Exploitation Status
As of November 19, 2026:
- Scanning activity confirmed. GreyNoise recorded 187 Java4Shell-shaped requests from 5 IPs since November 17, with zero successful intrusions observed on its sensors [14]. GreyNoise notes exploits must be tailored per application, which slows mass exploitation until someone publishes exploit code for a popular product [14].
- Honeypot hits. WatchTowr's head of threat intelligence, Jake Knott, reported attackers spraying the internet with requests decorated in
java4shell-reconUser-Agent strings, alongside blind exploitation attempts using correctly shaped requests [12][13]. - Additional sensor data. Threat intelligence firm Previdian logged nine exploitation attempts from six IPs on November 18 and 19, but cautioned sensor data cannot confirm whether targets were compromised [13].
- Commercial exploit availability. VulnCheck said it had a full RCE exploit available to its customers [2][4]. Calif's public PoC demonstrates memory corruption only; product-specific exploit chains are being withheld [4][9][10].
- No confirmed compromises. No vendor, government agency, or security firm has reported confirmed in-the-wild exploitation resulting in compromise [7][9][10][15][16].
- CISA KEV status. Not listed as of catalog version 2026.11.18 [7][14].
Cisco's product security team says it is aware of PoC exploit code but has no knowledge of malicious use [13].
MITRE ATT&CK Mapping
| Technique ID | Technique Name | Relevance |
|---|---|---|
| T1190 | Exploit Public-Facing Application | Pre-auth RCE via malformed Base64 in HTTP requests to network-facing Java services [1][4] |
| T1210 | Exploitation of Remote Services | Post-auth exploitation where authenticated user input triggers the Base64 decoder on internal-facing Java services [1][4] |
Application Log Indicators
The vulnerable code path throws IllegalArgumentException from java.util.Base64$Decoder after the heap corruption has already occurred [8]. Bursts of these exceptions in application logs on affected hosts should be treated as a primary detection signal [8]. Correlate with:
- Unexpected JVM process crashes producing
hs_err_pid*.logfiles on x86-64 hosts running affected Java versions. - HTTP request logs showing Base64-encoded payloads with abnormal padding, particularly strings ending in a single
=after a long sequence of characters inAuthorization,SAMLResponse,Cookie, or similar headers [1].
Network-Level Detection
Watch for requests containing the java4shell-recon User-Agent string, which WatchTowr observed in active scanning campaigns [12][13]. This is a low-sophistication indicator that attackers are not trying to hide.
More broadly, look for HTTP requests containing Base64 strings matching the trigger pattern: 64 or 128 A characters (or other valid Base64 characters) followed by a single = [1]. This pattern is unusual in legitimate traffic.
Host-Level Hunting
- Identify running JVM versions on x86-64 hosts using
java -version,rpm -qa java\,dpkg -l 'jdk*', or container image inspection. Standard SCA tools scanningpom.xmlorbuild.gradlewill not detect this because the flaw is in the runtime, not application dependencies [17]. - Check CPU feature flags:
grep avx512vbmi /proc/cpuinfoon Linux. Hosts without this flag are not vulnerable to RCE via this path. - Hunt for unusual child processes spawned by Java service accounts, which could indicate post-exploitation.
- Look for new or modified files written by Java service account users following a crash-and-recover cycle.
Sigma Rule
title: Java4Shell JVM Crash Indicator on x86-64 AVX-512 Host
id: f8c3a1d2-7e45-4b9a-a312-6d8e0f2c71b5
status: experimental
description: Detects creation of HotSpot crash log files that may indicate Java4Shell exploitation attempts on affected hosts
author: RedSheepSec
date: 2026/11/20
logsource:
category: file_event
product: linux
detection:
selection:
TargetFilename|endswith: '.log'
TargetFilename|contains: 'hs_err_pid'
condition: selection
falsepositives:
- Legitimate JVM crashes from other causes
level: medium
tags:
- attack.initial_access
- attack.t1190
- cve.2026.114938
title: Java4Shell Recon User-Agent in Web Logs
id: a4b2c8e1-3f67-49d2-b815-9c4a7e3d05f8
status: experimental
description: Detects HTTP requests with java4shell-recon User-Agent string observed in scanning campaigns
author: RedSheepSec
date: 2026/11/20
logsource:
category: webserver
product: apache
detection:
selection:
cs-User-Agent|contains: 'java4shell-recon'
condition: selection
falsepositives:
- Security researchers scanning your infrastructure
level: high
tags:
- attack.initial_access
- attack.t1190
- cve.2026.114938
Interim Mitigation
Calif, GitGuardian, Quarkus, and others reference the JVM flag -XX:-UseBASE64Intrinsics as a workaround that disables the vulnerable intrinsic and falls back to the pure-Java decoder [6][16]. This carries a performance cost for applications that decode large volumes of Base64 [7]. Aikido also references -XX:UseAVX=2 (capping the AVX level below AVX-512) as another way to avoid the vulnerable code path [7]. Neither workaround replaces patching.
CISA recommends that organizations unable to patch immediately should restrict and validate Base64 input at the application boundary, enforce input-size limits, and limit unauthenticated access [12].
CrowdSec released a free virtual patch: crowdsecurity/vpatch-CVE-2026-114938 [8].
GitGuardian's guidance adds an important post-patch step: revoke every credential contained in the application and its environment on each exposed Java service, because the JavaBleed memory-read primitive can leak secrets even from failed RCE attempts [6].
Analysis
Java 17 and 21 are the two most widely deployed LTS versions, and both fall within the affected range [4][14]. The hardware constraint (AVX-512 VBMI on x86-64) is a meaningful filter, but Intel Ice Lake shipped in 2019 and AMD Zen 4 in 2022; a large share of current server and cloud infrastructure meets this requirement. Upwind's reproduction on a standard AWS c6i instance confirms the cloud exposure [9].
The gap between the reported CVSS score of 9.2 and real-world exploitability is explained by the multi-factor requirement and the application-specific nature of exploitation chains. Calif demonstrated RCE against eleven specific products but explicitly stated there is no universal exploit [4][11]. Each chain must account for the target application's heap layout and object adjacency. Failed attempts tend to crash the JVM, which creates a noisy signal for defenders but also causes denial of service [8].
The memory-read primitive (JavaBleed) deserves separate attention. Even exploitation attempts that fail to achieve code execution may succeed in leaking sensitive heap contents: cryptographic keys, session tokens, and personal data stored in JVM memory [6][8]. This makes credential rotation a necessary part of the response, not just patching.
The scanning activity observed by GreyNoise and WatchTowr within 48 hours of disclosure follows the expected pattern for high-profile Java vulnerabilities [13][14]. The 187 requests from 5 IPs recorded by GreyNoise suggest early-stage reconnaissance rather than targeted exploitation [14]. WatchTowr's observation of "correctly shaped requests" alongside labeled recon suggests some actors are already past the scanning phase and testing blind exploitation [12][13].
VulnCheck's claim of having a full RCE exploit available to customers [2][4] indicates that weaponized code exists in private channels. The gap between private exploit availability and public release has historically been short for vulnerabilities of this profile.
A complicating factor for container-based deployments: the Docker Hub eclipse-temurin:21 tags were still carrying the vulnerable build as of November 19 [14]. Organizations rebuilding container images using floating tags may unknowingly redeploy vulnerable runtimes. Keycloak's experience illustrates this: two of its container image releases (26.8.2-1 and 26.8.2-2) bundled a vulnerable OpenJDK 21 build before the corrected 26.8.2-3 was published [13].
Red Sheep Assessment
Assessment: The combination of private exploit availability (VulnCheck), active scanning (GreyNoise, WatchTowr, Previdian), and the application-specific but demonstrably achievable RCE chain (Calif's eleven confirmed targets) places this vulnerability on a trajectory toward confirmed exploitation within days to weeks, likely not months. The 0.12% RCE exposure figure cited by some analysts describes a population-level statistic that understates the risk to any specific organization running Keycloak, Jira, Confluence, Jenkins, Artifactory, or PingFederate on modern x86-64 hardware with Java 17.0.6+. Those six products represent pre-auth attack surfaces and are common in enterprise identity, CI/CD, collaboration, and artifact management infrastructure.
The JavaBleed memory-read primitive is an underappreciated dimension. Organizations focused solely on RCE prevention may miss that failed exploitation attempts can still extract credentials and keys from JVM heap memory. This makes the vulnerability a potential secret-theft vector even before reliable public exploits circulate.
An alternative interpretation: the fixed-value nature of the out-of-bounds write, the application-specific chaining requirement, and the tendency for failed attempts to crash the JVM could slow weaponization for all but the most skilled adversaries. Mass exploitation comparable to Log4Shell (CVE-2021-44228) is unlikely because each target application needs bespoke work. Targeted exploitation against high-value instances of the confirmed-vulnerable applications is the more probable scenario.
The AI-assisted discovery methodology (Quang Luong found the bug with AI in roughly one hour for under $200 [14]) is worth tracking as a capability trend. Calif used the same approach for PHP2Shell one month earlier [14]. This suggests a compression of the timeline between vulnerability classes being theoretically discoverable and actually discovered.
Confidence: Moderate. Full exploit methodology has not been publicly released, and no confirmed compromise has been reported as of November 19, 2026. The assessment is based on vendor-confirmed technical details, Calif's disclosed demonstrations, observed scanning activity from multiple independent sensor networks, and VulnCheck's statement of private exploit availability.
Defender's Checklist
- ▢[ ] Inventory affected runtimes. Query host-level package managers (
rpm -qa java\,dpkg -l 'jdk*') and running process versions (java -version) across all x86-64 hosts. Do not rely on SCA tools scanning application dependencies. Cross-reference with CPU feature flags (grep avx512vbmi /proc/cpuinfoon Linux) to identify hosts meeting all three exposure conditions.
- ▢[ ] Patch to fixed builds. Install vendor-specific fixed releases (17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1 or equivalent) and restart every Java process. Verify container base images actually contain the patched JDK before redeploying; check the
eclipse-temurinDocker Hub tag version carefully [14].
- ▢[ ] Apply interim mitigation on unpatched hosts. Add
-XX:-UseBASE64Intrinsicsto JVM startup flags and restart the service. This disables the vulnerable intrinsic at a performance cost [6][16]. Monitor forIllegalArgumentExceptionbursts fromjava.util.Base64$Decoderin application logs as a detection signal [8].
- ▢[ ] Hunt for exploitation indicators. Search web access logs for
java4shell-reconUser-Agent strings [12][13]. Search for HTTP requests containing Base64 strings of 64 or 128 repeated characters followed by=in authentication and token-related headers. Check forhs_err_pid*.logfiles on affected hosts.
- ▢[ ] Rotate credentials on exposed services. For any Java service that was running an affected build on AVX-512 VBMI hardware and processing external Base64 input, treat stored secrets (API keys, database credentials, signing keys, session tokens) as potentially compromised via JavaBleed memory disclosure and rotate them [6].
References
[1] https://calif.io/java4shell
[2] https://censys.com/advisory/cve-2026-114938/
[3] https://www.endorlabs.com/learn/java4shell-unauthenticated-rce-reported-in-openjdk-17-cve-2026-114938
[4] https://www.bitsight.com/blog/critical-vulnerability-alert-cve-2026-114938-java4shell-openjdk-base64-decoder-flaw
[5] https://www.circl.lu/pub/tr-104/
[6] https://blog.gitguardian.com/java4shell-vulnerability-secrets/
[7] https://www.aikido.dev/blog/java-17-rce-vulnerability-cve-2026-114938
[8] https://www.precursorsecurity.com/blog/java4shell-critical-openjdk-rce-vulnerability
[9] https://www.cyberkendra.com/2026/11/cve-2026-114938-pre-auth-rce-flaw-in-java-17-puts-servers-at-risk.html
[10] https://www.levelblue.com/blogs/spiderlabs-blog/critical-vulnerability-in-java-java4shell-cve-2026-114938
[11] https://www.tenable.com/blog/java4shell-cve-2026-114938-frequently-asked-questions-about-openjdk-rce-vulnerability
[12] https://thehackernews.com/2026/11/cisa-urges-immediate-patching-of.html
[13] https://www.securityweek.com/java4shell-exploitation-attempts-begin-as-vendors-rush-out-advisories/
[14] https://www.zestsecurity.io/resources/content/java4shell-cve-2026-114938
[15] https://www.igorslab.de/en/java4shell-critical-openjdk-vulnerability-cve-2026-114938-code-execution-intel-amd-systems/
[16] https://quarkus.io/blog/java4shell/
[17] https://research.jfrog.com/post/java4shell-vulnerability/
[18] https://pentest-tools.com/blog/java4shell-cve-2026-114938
Event Timeline
Timeline
Entity Relationships
Entity Graph (9 entities, 3 relationships)
Diamond Model
Diamond Model
Hunt Guide: CVE-2026-114938 Java4Shell OpenJDK Base64 Heap Overflow Exploitation
Attribution: Rules adapted, ported, or quoted from a public source retain that source's author (e.g. SigmaHQ / Florian Roth, Elastic, Emerging Threats, Abuse.ch, or the cited vendor/researcher) and carry an attribution credit. Rules without a credit were authored in-house by RedSheepSec. If you reuse a rule, preserve its stated attribution.
Hypothesis: If threat actors are exploiting CVE-2026-114938 (Java4Shell) against our environment, we expect to observe HTTP requests containing anomalous Base64 payloads (64 or 128 repeated characters followed by a single '=') in web server and proxy logs, java4shell-recon User-Agent strings in HTTP traffic, bursts of IllegalArgumentException from java.util.Base64$Decoder in application logs, HotSpot crash log files (hs_err_pid*.log) on x86-64 hosts running affected Java versions, and anomalous child processes spawned by Java service accounts.
Intelligence Summary: CVE-2026-114938 is a heap out-of-bounds write in OpenJDK's AVX-512 VBMI-accelerated Base64 decoder affecting Java 17.0.6 and later on x86-64 hardware with AVX-512 VBMI support. Security firm Calif demonstrated pre-authentication RCE against Keycloak, Jira, Confluence, Artifactory, Jenkins, and PingFederate, and post-authentication RCE against Kafka, Solr, Elasticsearch, Gerrit, and Spinnaker. As of November 19, 2026, GreyNoise recorded 187 scanning requests from 5 IPs, WatchTowr observed blind exploitation attempts, and VulnCheck stated it has a full RCE exploit available to customers, though no confirmed compromises have been reported.
Confidence: Moderate | Priority: Critical
Scope
- Networks: All network segments hosting Java-based services, with priority on DMZ and internet-facing segments running Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, or PingFederate. Secondary scope includes internal segments running Apache Kafka, Apache Solr, Elasticsearch, Gerrit, or Spinnaker.
- Timeframe: November 17, 2026 onward (public disclosure date). Extend retrospective hunting to January 2023 (when the vulnerable code was first introduced in Java 17.0.6) for environments with long-term log retention, particularly for hs_err_pid crash log correlation.
- Priority Systems: 1) Internet-facing Keycloak, Jira, Confluence, Artifactory, Jenkins, PingFederate instances on x86-64 with AVX-512 VBMI (Intel Ice Lake+, AMD Zen 4+). 2) Internal Elasticsearch, Kafka, Solr, Gerrit, Spinnaker instances. 3) Any Java service running OpenJDK 17.0.6-17.0.21, 21.x-21.0.13, 25.x-25.0.5, or 27.x-27.0.1 on qualifying hardware. 4) Container-based deployments using eclipse-temurin Docker Hub images.
MITRE ATT&CK Techniques
T1190: Exploit Public-Facing Application (Initial Access) [P1]
Pre-authentication RCE via malformed Base64 input in HTTP request headers (Authorization, SAMLResponse, Cookie, CSRF tokens, JWTs) targeting Java services running on AVX-512 VBMI hardware with affected OpenJDK versions. Calif demonstrated pre-auth exploitation against Keycloak, Jira, Confluence, Artifactory, Jenkins, and PingFederate. The trigger payload consists of 64 or 128 valid Base64 characters followed by a single '=' padding character, causing a heap overflow in the JIT-compiled Base64 decoder.
Splunk SPL:
index=corelight sourcetype=corelight_http
| eval ua_lower=lower(user_agent)
| where like(ua_lower, "%java4shell%") OR like(ua_lower, "%java4shell-recon%")
| stats count earliest(_time) as first_seen latest(_time) as last_seen values(id.orig_h) as src_ips values(id.resp_h) as dst_ips values(host) as target_hosts by user_agent
| sort -count
Elastic KQL:
http.request.headers.user-agent:*java4shell* OR user_agent.original:*java4shell-recon*
Sigma Rule:
title: Java4Shell Recon User-Agent in HTTP Traffic
id: a4b2c8e1-3f67-49d2-b815-9c4a7e3d05f8
status: experimental
description: Detects HTTP requests with java4shell-recon User-Agent string observed in scanning campaigns targeting CVE-2026-114938
author: RedSheepSec
date: 2026/11/20
references:
- https://thehackernews.com/2026/11/cisa-urges-immediate-patching-of.html
- https://www.securityweek.com/java4shell-exploitation-attempts-begin-as-vendors-rush-out-advisories/
logsource:
category: webserver
detection:
selection:
cs-User-Agent|contains: 'java4shell-recon'
condition: selection
falsepositives:
- Security researchers scanning infrastructure
level: high
tags:
- attack.initial_access
- attack.t1190
- cve.2026.114938
The java4shell-recon User-Agent is a low-sophistication indicator. Skilled attackers will not use this string. Absence of this UA does not indicate absence of exploitation. Tune for security researcher scanning by whitelisting known pen-test source IPs.
T1190: Exploit Public-Facing Application (Initial Access) [P1]
Detection of the actual exploit payload pattern in HTTP traffic: Base64 strings consisting of 64 or 128 repeated characters followed by a single '=' padding character in authentication and token-related HTTP headers. This pattern is the trigger for the heap overflow in the AVX-512 VBMI Base64 decoder.
Splunk SPL:
index=corelight sourcetype=corelight_http
| rex field=_raw "(?:Authorization|Cookie|SAMLResponse|X-CSRF-Token)\s*[:=]\s*(?:Basic\s+)?(?<b64payload>[A-Za-z0-9+/]{64,256}={1})"
| where isnotnull(b64payload)
| eval payload_len=len(b64payload)-1
| where payload_len=64 OR payload_len=128 OR payload_len=192 OR payload_len=256
| eval repeated_check=if(match(b64payload, "^(.)\1{63,}"), "repeated_chars", "mixed")
| stats count earliest(_time) as first_seen latest(_time) as last_seen values(id.orig_h) as src_ips values(id.resp_h) as dst_ips by repeated_check
| sort -count
Elastic KQL:
http.request.headers:(*QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQQ* OR *AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=*)
Sigma Rule:
title: Java4Shell Exploit Payload Pattern in HTTP Headers
id: c7d4e2f9-8a16-4c3b-b927-1e5f0d3a82c6
status: experimental
description: Detects HTTP requests containing Base64 strings of 64 or 128 repeated characters followed by a single equals sign, matching the CVE-2026-114938 trigger pattern
author: RedSheepSec
date: 2026/11/20
references:
- https://calif.io/java4shell
- https://blog.gitguardian.com/java4shell-vulnerability-secrets/
logsource:
category: webserver
detection:
selection_header:
cs-uri-query|contains:
- 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA='
selection_auth:
cs-Authorization|contains:
- 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA='
condition: selection_header or selection_auth
falsepositives:
- Extremely unlikely in legitimate traffic
level: critical
tags:
- attack.initial_access
- attack.t1190
- cve.2026.114938
The example uses 64 'A' characters but any valid Base64 character repeated 64 or 128 times followed by a single '=' triggers the flaw. Regex-based detection should account for all valid Base64 alphabet characters. The KQL query uses the Base64 encoding of 64 'A' bytes as a known example. Tune the regex pattern to match varied character repeats. High false positive ratio is unlikely; this padding pattern does not appear in legitimate Base64 data.
T1190: Exploit Public-Facing Application (Initial Access) [P2]
Detection of JVM crash logs (hs_err_pid*.log) on x86-64 hosts, which are created when the HotSpot JVM encounters a fatal error. The Java4Shell overflow causes JVM crashes on failed exploitation attempts, producing these files. On hosts running affected Java versions with AVX-512 VBMI hardware, these crash logs are a primary exploitation indicator.
Splunk SPL:
index=sysmon sourcetype=XmlWinEventLog EventCode=11 TargetFilename="*hs_err_pid*"
| stats count earliest(_time) as first_seen latest(_time) as last_seen by Computer, TargetFilename, Image
| sort -count
Elastic KQL:
event.code:"11" AND file.path:*hs_err_pid*
Sigma Rule:
title: Java4Shell JVM Crash Indicator - HotSpot Error Log Creation
id: f8c3a1d2-7e45-4b9a-a312-6d8e0f2c71b5
status: experimental
description: Detects creation of HotSpot crash log files (hs_err_pid*.log) that may indicate Java4Shell exploitation attempts on affected hosts running OpenJDK on AVX-512 VBMI hardware
author: RedSheepSec
date: 2026/11/20
references:
- https://calif.io/java4shell
- https://www.precursorsecurity.com/blog/java4shell-critical-openjdk-rce-vulnerability
logsource:
category: file_event
product: windows
detection:
selection:
TargetFilename|contains: 'hs_err_pid'
TargetFilename|endswith: '.log'
condition: selection
falsepositives:
- Legitimate JVM crashes from other causes such as memory exhaustion or application bugs
level: medium
tags:
- attack.initial_access
- attack.t1190
- cve.2026.114938
JVM crash logs occur for many reasons. Correlate with the host running an affected Java version (17.0.6 through 17.0.21, 21.x through 21.0.13, 25.x through 25.0.5, 27.x through 27.0.1) on x86-64 with AVX-512 VBMI. Inspect the crash log content for references to Base64 decoding, java.util.Base64$Decoder, or the C2 JIT compiler. A burst of crash logs from a single Java service is higher confidence than isolated events.
T1190: Exploit Public-Facing Application (Initial Access) [P2]
Linux host-level detection of hs_err_pid crash logs using audit or file integrity monitoring on Linux servers running Java services.
Splunk SPL:
index=linux-server (sourcetype=linux:audit OR sourcetype=audit OR sourcetype=auditd)
| search "hs_err_pid"
| stats count earliest(_time) as first_seen latest(_time) as last_seen by host, comm, exe
| sort -count
Elastic KQL:
host.os.family:"linux" AND (file.path:*hs_err_pid* OR process.args:*hs_err_pid*)
For Linux hosts, also run 'find / -name "hs_err_pid" -mtime -7' to identify recent crash logs that may predate centralized logging. Correlate the PID in the filename with Java process information.*
T1210: Exploitation of Remote Services (Lateral Movement) [P2]
Post-authentication exploitation where authenticated user input triggers the Base64 decoder on internal-facing Java services. Calif demonstrated post-auth RCE against Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, and Spinnaker. This technique applies to internal lateral movement scenarios where an attacker with valid credentials targets internal Java services.
Splunk SPL:
index=sysmon sourcetype=XmlWinEventLog EventCode=1
| where match(ParentImage, "(?i)(java|javaw|jdk|jre)\.exe$")
| where NOT match(Image, "(?i)(java|javaw|jdk|jre|javac)\.exe$")
| eval suspicious=if(match(Image, "(?i)(cmd|powershell|pwsh|bash|sh|curl|wget|certutil|bitsadmin|mshta|wscript|cscript|rundll32|regsvr32)"), "high", "medium")
| stats count earliest(_time) as first_seen latest(_time) as last_seen values(CommandLine) as commands by Computer, ParentImage, Image, suspicious
| where suspicious="high" OR count > 3
| sort -count
Elastic KQL:
process.parent.executable:(*java* OR *jdk* OR *jre*) AND NOT process.executable:(*java* OR *javac* OR *javadoc*) AND process.executable:(cmd.exe OR powershell.exe OR pwsh.exe OR bash OR sh OR curl OR wget OR certutil.exe OR bitsadmin.exe)
Sigma Rule:
title: Suspicious Child Process Spawned by Java Service
id: d5e6f7a8-9b01-4c2d-e3f4-5a6b7c8d9e0f
status: experimental
description: Detects suspicious child processes spawned by Java runtime processes, which may indicate post-exploitation following Java4Shell or similar JVM vulnerabilities
author: RedSheepSec
date: 2026/11/20
references:
- https://calif.io/java4shell
logsource:
category: process_creation
product: windows
detection:
selection_parent:
ParentImage|endswith:
- '\java.exe'
- '\javaw.exe'
selection_child:
Image|endswith:
- '\cmd.exe'
- '\powershell.exe'
- '\pwsh.exe'
- '\certutil.exe'
- '\bitsadmin.exe'
- '\mshta.exe'
- '\wscript.exe'
- '\cscript.exe'
- '\rundll32.exe'
- '\regsvr32.exe'
condition: selection_parent and selection_child
falsepositives:
- Java-based build tools or CI/CD agents legitimately invoking system commands
- Application servers with legitimate shell-out functionality
level: high
tags:
- attack.lateral_movement
- attack.t1210
- attack.execution
- cve.2026.114938
Java services legitimately spawn child processes in some configurations (build servers, CI/CD tools like Jenkins). Baseline normal Java child process behavior per host before deploying as an alert. Focus on hosts running confirmed-vulnerable applications: Keycloak, Jira, Confluence, Artifactory, Jenkins, PingFederate, Kafka, Solr, Elasticsearch, Gerrit, Spinnaker.
T1210: Exploitation of Remote Services (Lateral Movement) [P2]
Linux-side detection of suspicious child processes spawned by Java on internal-facing services after post-authentication exploitation.
Splunk SPL:
index=linux-server (sourcetype=linux:audit OR sourcetype=linux_audit OR sourcetype=auditd) type=EXECVE
| search a0="*java*" OR exe="*java*" OR comm="java"
| rex field=_raw "a0=\"?(?<parent_cmd>[^\"\s]+)"
| rex field=_raw "a1=\"?(?<child_cmd>[^\"\s]+)"
| where match(child_cmd, "(bash|sh|curl|wget|python|perl|nc|ncat|socat|chmod|chown)")
| stats count earliest(_time) as first_seen latest(_time) as last_seen values(child_cmd) as child_commands by host
| sort -count
Elastic KQL:
process.parent.name:"java" AND process.name:(bash OR sh OR curl OR wget OR python* OR perl OR nc OR ncat OR socat)
Linux Java services may legitimately fork subprocesses. Correlate with application type and expected behavior. Focus investigation on hosts running affected products on AVX-512 VBMI hardware.
YARA Rules
Java4Shell_Exploit_Payload_Pattern: Detects the Java4Shell CVE-2026-114938 trigger payload pattern in network captures, files, or memory: 64 or 128 repeated Base64 characters followed by a single '=' padding character. This pattern is specific to the heap overflow trigger in the AVX-512 VBMI Base64 decoder.
rule Java4Shell_Exploit_Payload_Pattern
{
meta:
author = "RedSheepSec"
description = "Detects CVE-2026-114938 Java4Shell trigger payload: 64 or 128 repeated Base64 characters followed by single = padding"
date = "2026-11-20"
reference = "https://calif.io/java4shell"
severity = "critical"
strings:
$trigger_64A = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=" ascii wide
$trigger_128A = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=" ascii wide
$recon_ua = "java4shell-recon" ascii wide nocase
$base64_decoder_ref = "java.util.Base64$Decoder" ascii wide
$hs_err = "hs_err_pid" ascii wide
condition:
any of ($trigger_64A, $trigger_128A) or ($recon_ua and ($base64_decoder_ref or $hs_err))
}
Suricata Rules
SID 2026001: Detects java4shell-recon User-Agent string in HTTP traffic, observed by WatchTowr in active scanning campaigns targeting CVE-2026-114938
alert http any any -> $HOME_NET any (msg:"ET EXPLOIT Java4Shell Recon User-Agent Detected (CVE-2026-114938)"; flow:to_server,established; http.user_agent; content:"java4shell-recon"; nocase; classtype:web-application-attack; sid:2026001; rev:1; metadata:created_at 2026_11_20, updated_at 2026_11_20; reference:url,calif.io/java4shell; reference:cve,2026-114938;)
SID 2026002: Detects potential Java4Shell exploit payload in HTTP Authorization header containing 64 repeated 'A' characters followed by '=' padding, targeting CVE-2026-114938
alert http any any -> $HOME_NET any (msg:"ET EXPLOIT Java4Shell Base64 Trigger Payload in Authorization Header (CVE-2026-114938)"; flow:to_server,established; http.header; content:"Authorization"; content:"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="; fast_pattern; classtype:web-application-attack; sid:2026002; rev:1; metadata:created_at 2026_11_20, updated_at 2026_11_20; reference:url,calif.io/java4shell; reference:cve,2026-114938;)
SID 2026003: Detects potential Java4Shell exploit payload with 128 repeated 'A' characters followed by '=' in HTTP traffic, targeting Java 17 builds with higher length threshold for CVE-2026-114938
alert http any any -> $HOME_NET any (msg:"ET EXPLOIT Java4Shell 128-char Base64 Trigger Payload (CVE-2026-114938)"; flow:to_server,established; http.header; content:"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="; fast_pattern; classtype:web-application-attack; sid:2026003; rev:1; metadata:created_at 2026_11_20, updated_at 2026_11_20; reference:url,calif.io/java4shell; reference:cve,2026-114938;)
Data Source Requirements
| Source | Required For | Notes |
|---|---|---|
| Corelight HTTP logs (index=corelight, sourcetype=corelight_http) | T1190 | Required for detecting exploit payloads and recon User-Agent strings in HTTP traffic. Ensure full header logging is enabled, particularly Authorization, Cookie, SAMLResponse, and User-Agent fields. |
| Web server access logs (index=webserver or index=apache) | T1190 | IIS, Apache, and Tomcat access logs capture User-Agent strings and request URIs. Verify that request headers including Authorization are logged. |
| Sysmon EventID 11 - FileCreate (index=sysmon, sourcetype=XmlWinEventLog) | T1190 | Required for detecting hs_err_pid.log file creation on Windows hosts running Java services. Ensure Sysmon configuration includes file creation monitoring for .log files. |
| Sysmon EventID 1 - Process Create (index=sysmon, sourcetype=XmlWinEventLog) | T1210 | Required for detecting suspicious child processes spawned by Java service accounts post-exploitation. Ensure full command line logging is enabled. |
| Linux audit logs (index=linux-server, sourcetype=linux:audit or auditd) | T1190, T1210 | Required for file creation events (hs_err_pid logs) and process execution events on Linux hosts. Configure auditd to monitor EXECVE events and file writes in Java service directories. |
| CrowdStrike EDR (index=crowdstrike) | T1190, T1210 | CrowdStrike process and file events can detect both crash log creation and post-exploitation process spawning. CrowdSec released virtual patch crowdsecurity/vpatch-CVE-2026-114938. |
| PAN Firewall threat logs (index=firewall-pan, sourcetype=pan:threat) | T1190 | Palo Alto threat signatures may detect exploit payloads at the network perimeter. Check for updated threat content covering CVE-2026-114938. |
| DNS logs (index=corelight, sourcetype=corelight_dns or index=dns) | T1190 | Post-exploitation callback detection. Monitor for unusual DNS queries from Java service hosts following crash events. |
| Application logs (Java application-specific) | T1190 | IllegalArgumentException bursts from java.util.Base64$Decoder are a primary detection signal per the source report. These logs may reside in application-specific indexes or in custom indexes depending on deployment. Check index=webserver for Tomcat/JBoss logs and index=custom for application-specific sources. |
Recommendations
- Patch all OpenJDK runtimes to fixed versions (17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1, or vendor-specific equivalents) and restart every Java process. Verify the actual JDK version inside container images before redeploying, as floating Docker Hub tags (e.g., eclipse-temurin:21) may still reference vulnerable builds.
- On hosts that cannot be immediately patched, apply the JVM startup flag -XX:-UseBASE64Intrinsics to disable the vulnerable AVX-512 VBMI Base64 decoder intrinsic. Alternatively, use -XX:UseAVX=2 to cap AVX instruction level below AVX-512. Neither replaces patching.
- Deploy the Suricata rules (SIDs 2026001-2026003) at network perimeter and internal segmentation points to detect java4shell-recon scanning and exploit payload patterns in HTTP traffic.
- Deploy Splunk searches for java4shell-recon User-Agent strings across corelight_http, web server, and firewall logs as scheduled saved searches with alerting enabled.
- Deploy the hs_err_pid file creation detection across all Sysmon and Linux audit log sources. Correlate any hits with the host's Java version and CPU feature flags.
- Inventory all x86-64 hosts for AVX-512 VBMI capability (grep avx512vbmi /proc/cpuinfo on Linux) and cross-reference with Java version to build a prioritized patching list. Standard SCA tools scanning pom.xml or build.gradle will not detect this flaw because it is in the runtime, not application dependencies.
- Rotate all credentials (API keys, database passwords, signing keys, session tokens) on any Java service that was exposed to external Base64 input while running an affected build on AVX-512 VBMI hardware. The JavaBleed memory-read primitive can leak secrets from JVM heap even from failed exploitation attempts.
- Verify that Keycloak container images are version 26.8.2-3 or later; images 26.8.2-1 and 26.8.2-2 bundled a vulnerable OpenJDK 21 build.
- Coordinate with CrowdSec to deploy the virtual patch crowdsecurity/vpatch-CVE-2026-114938 on WAF or reverse proxy infrastructure protecting unpatched services.
- Monitor CISA KEV catalog for addition of CVE-2026-114938, which would trigger BOD 22-01 remediation timelines for federal systems.
Sources
- Calif - Java4Shell Technical Write-up
- Censys Advisory - CVE-2026-114938
- Endor Labs - Java4Shell Unauthenticated RCE in OpenJDK 17
- BitSight - Critical Vulnerability Alert CVE-2026-114938
- CIRCL - TR-104
- GitGuardian - Java4Shell Vulnerability and Secrets
- Aikido - Java 17 RCE Vulnerability CVE-2026-114938
- Precursor Security - Java4Shell Critical OpenJDK RCE Vulnerability
- CyberKendra - CVE-2026-114938 Pre-Auth RCE Flaw
- LevelBlue - Critical Vulnerability in Java Java4Shell
- Tenable - Java4Shell CVE-2026-114938 FAQ
- The Hacker News - CISA Urges Immediate Patching
- SecurityWeek - Java4Shell Exploitation Attempts Begin
- Zest Security - Java4Shell CVE-2026-114938
- Igor's Lab - Java4Shell Critical OpenJDK Vulnerability
- Quarkus - Java4Shell Advisory
- JFrog Research - Java4Shell Vulnerability
- Pentest Tools - Java4Shell CVE-2026-114938