CVE-2026-114938 | CVSS 8.1 (Oracle, v3.1) / 9.2 (Calif, v4.0) | Disclosed 17 November 2026 | No confirmed in-the-wild exploitation as of 18 November 2026 | Not in CISA KEV
Most vulnerabilities live in an application. A bad library, a missed input check, a misconfigured service. You patch the app, you move on. Java4Shell is different: the flaw sits in the Java runtime itself, in a piece of hand-written assembly that speeds up Base64 decoding on modern x86-64 servers. If your service runs on an affected JVM and an attacker can get a malformed Base64 string into it — and Base64 is decoded before authentication in most Java applications — the attacker does not need an account, a valid token, or a vulnerable dependency. They need 65 characters.
This is the deep-dive version of the story: what the bug is, why it reaches so far, how to tell whether you are exposed, and what to hunt for while the patches roll out.
The bug: one = too many
The vulnerable code is the AVX-512 VBMI intrinsic for java.util.Base64.Decoder inside HotSpot, the OpenJDK virtual machine. It was written as an optimisation (JDK-8268276, for JDK 18) and backported to the Java 17 line in update 17.0.6 (JDK-8296735, January 2023). On a processor that supports AVX-512 VBMI, the JVM substitutes this assembly routine for the plain-Java decoder. It is fast, and it has been wrong for nearly four years.
The failure is in the tail of the input. Take a string of 64 A characters followed by a single =. The routine computes the output length for the remaining tail as zero, then subtracts one byte for the padding. That subtraction underflows. Java allocates a 50-byte output array; the routine writes a full 64-byte block into it. Sixty-two bytes land past the end of the array, corrupting whatever sits next to it on the heap. A trailing == writes 63 bytes past the end. The write happens before Java rejects the input as invalid — the check that would have caught the malformed string runs after the damage is done.
That is the entire trigger. No authentication, no special endpoint, no crafted file upload. Anywhere attacker-controlled data reaches Base64.getDecoder().decode() — an Authorization: Basic header, a bearer token, a SAML assertion, a session cookie, a file upload — the decoder is in play.
Who is exposed: three conditions, all at once
A host is vulnerable only when all three of these are true:
- An unpatched runtime. OpenJDK 17.0.6 and later on the Java 17 line, plus the Java 21, 25, and 27 lines, from any vendor. Oracle also lists its Java 8 performance build, 8u511b33-perf. Standard Java 8 and Java 11 builds are not affected, and neither is the MIME decoder.
- The right silicon. An x86-64 processor with AVX-512 VBMI — Intel Xeon from Ice Lake through Granite Rapids, AMD EPYC from Zen 4 onward. ARM64 hosts are unaffected, as are older Xeons and pre-Zen-4 AMD chips.
- Attacker-controlled Base64 reaching the decoder. In practice, that is every internet-facing Java service that accepts credentials, tokens, or uploads.
The researchers at Calif, who found the flaw — Quang Luong is credited with the discovery, with Albert Yang also credited by Oracle — report pre-authentication remote code execution against default installations of Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, and PingFederate. They also report authenticated-path RCE against Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, and Netflix Spinnaker, and RCE in sample applications built on Spring Boot and Apache Struts. Their lists are explicitly incomplete.
Read that claim with the right calibration. Calif is withholding its product-specific exploit chains. Independent labs have reproduced JVM crashes and, in Blackpoint Cyber's case, the local heap-disclosure technique Calif described — but as of 18 November no independent team has publicly reproduced remote code execution. There is no universal exploit: each target needs its own decoder route, writable buffer, feedback channel, and heap layout. That slows mass exploitation. It does not protect a specific high-value target, and an identity provider like Keycloak is exactly the kind of target worth the effort.
The exploit chain, as Calif describes it
Calif's write-up lays out a five-stage chain, and it is worth understanding even if you never run it, because each stage tells you what to look for in your own logs:
- Corrupt an array length. The out-of-bounds write lands on a neighbouring Java array's length field, inflating it.
- Leak the heap. A second, oversized array is used as a reader to dump adjacent heap contents — object headers, pointers, and whatever secrets happen to sit nearby.
- Repair the damage. Object headers corrupted in stage one are rewritten so the JVM keeps running instead of crashing.
- Groom the heap remotely. Repeated requests shape the heap layout until a chosen object sits in a predictable place.
- Write into the code cache. The final write lands in the JVM's code cache, and the attacker's bytes execute.
Two things matter for defenders here. First, stages one through three are noisy in a useful way: they involve repeated malformed requests and JVM instability. Second, the whole chain depends on the attacker being able to observe the application's responses — a feedback channel — which is why internet-facing services with verbose error handling are the softest targets.
There is also an uncomfortable timeline detail. The triggering input was visible in public as early as 9 September 2026, and the fix was committed under embargo on 14 October. The patch and the disclosure both landed on 17 November. Whatever your patch window, assume the window for probing opened before the patch existed.
Lab walkthrough: find your exposure in an afternoon
You do not need a scanner to answer the first question — where do we run affected Java? — you need three commands and an inventory.
Step 1: find the runtimes. On each host, or via your configuration management tool, enumerate every JVM:
# Every java binary on the box, with its version
find / -name java -type f 2>/dev/null | while read j; do
echo "$j -> $($j -version 2>&1 | head -1)"
done
Flag anything on the 17, 21, 25, or 27 lines below the fixed builds: Oracle 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1, and 8u513-perf for the performance build. Other vendors shipped on their own schedules — Azul's November Zulu update and Amazon Corretto 17.0.21.1.2 are confirmed fixed; check your vendor's advisory for the rest, and treat Debian-packaged OpenJDK as still vulnerable until the tracker shows a fixed version.
Step 2: check the silicon. The vulnerable intrinsic only fires on AVX-512 VBMI hardware:
grep -o 'avx512_vbmi' /proc/cpuinfo | sort -u
No match, no exposure on that host — regardless of the Java version. A match means the host is in scope if its runtime is unpatched.
Step 3: confirm the intrinsic is actually active. The decoder path needs UseAVX at 3 or higher and UseBASE64Intrinsics set to true (both are defaults on supported hardware). You can verify on a running JVM with:
java -XX:+PrintFlagsFinal -version 2>/dev/null | grep -E 'UseAVX|UseBASE64Intrinsics'
Step 4: mitigate where patching has to wait. One JVM flag closes the exposure immediately, at the cost of the Base64 speedup:
-XX:-UseBASE64Intrinsics
Add it to the startup options of every affected service you cannot patch today. It is a restart, not a rebuild, and it is the single most useful sentence in this article. Patch internet-facing services first — Keycloak, Jira, Confluence, Jenkins, Artifactory, PingFederate — then work inward.
Hunting: what exploitation looks like in your logs
There is no public exploit signature to match against, and no confirmed in-the-wild exploitation as of 18 November. That is not the same as nothing to hunt for. Here is what to look for, in priority order.
JVM crashes are the canary. The most reproducible outcome of the trigger is a crash, not a shell. Blackpoint's team reproduced crashes with repeated unauthenticated HTTP requests against a local Spring Boot application behind Spring Security. A Java service that restarts itself, or that leaves hs_err_pid files behind, is telling you something. In Splunk, a starting point for crash hunting across the fleet:
index=os sourcetype="syslog" ("hs_err_pid" OR "SIGSEGV" OR "A fatal error has been detected by the Java Runtime Environment")
| stats count values(host) as hosts by _time span=1h
| where count > 0
Correlate any spike with the service's own access logs. A crash that follows a burst of requests carrying odd Authorization headers is not a coincidence you should shrug off.
Look for the trigger shape at the edge. The malformed input is distinctive: a Base64 string whose tail is a lone = or == after a block boundary. In a WAF or reverse-proxy log, look for requests to Java services where an Authorization, Cookie, or token parameter contains a Base64 value ending in a single = that does not decode cleanly. In KQL against web server logs shipped to Defender:
W3CIISLog
| where csUriStem contains "login" or csUriStem contains "auth" or csUriStem contains "sso"
| where csReferer == "" and scStatus in (500, 502, 503)
| summarize Crashes=count() by cIP, csUriStem, bin(TimeGenerated, 15m)
| where Crashes > 5
HTTP 500s clustering on authentication endpoints, from a single source, in 15-minute windows — that is the shape of someone learning the heap layout of your identity provider.
Watch what the JVM spawns. If the chain ever succeeds, the payload runs inside the Java process. A java process spawning a shell, curl, wget, or an unexpected child is the signal that matters most. In Splunk, with Sysmon or EDR process data:
index=edr ParentImage="*java*" Image IN ("*\\cmd.exe", "*\\powershell.exe", "*\\sh", "*curl*", "*wget*")
| table _time host ParentImage Image CommandLine
Check for heap-disclosure residue. The leak stage reads adjacent heap memory. If your Java services log unusually large responses to authentication endpoints, or if an identity provider starts returning error pages that contain fragments of other users' data, treat it as a possible disclosure event and preserve the logs before the next restart wipes them.
Triage posture. CISA's alert of 17 November urges immediate patching; the Canadian Centre for Cyber Security reported no known exploitation the same day. The honest framing is the one Qualys used: as of 17 November there is no public confirmation of exploitation in the wild — and you should not plan around that. The root cause is public, the trigger is public, the technique is public, and the fix is four lines. Probing will start soon; Talos expects it, and the history of the same research team's earlier PHP2Shell disclosure — exploited in under a week, KEV-listed — says the gap between disclosure and exploitation is measured in days, not months.
Defensive takeaways
- Patch the runtime, not just the app. Your vulnerability scanner probably inventories applications. Java4Shell lives one layer down. Inventory the JVMs, the versions, and the CPUs — that is the asset list that matters this week.
- The flag is your friend.
-XX:-UseBASE64Intrinsicsis a same-day mitigation for every service you cannot patch yet. Apply it, restart, verify the flag took, and move on to the next service. - Identity providers go first. Keycloak and PingFederate are the crown jewels on the pre-auth list: compromise the identity provider and every downstream application inherits the breach. Patch and mitigate those before Jenkins and Jira, not after.
- Crash logs are detection, not noise. A JVM that segfaults after a burst of malformed auth requests is a detection event. Keep
hs_err_pidfiles, ship them to your SIEM, and alert on them. - Assume the probing window already opened. The trigger leaked in September. If you find crash evidence from before 17 November, do not dismiss it as a stability bug — preserve it and review it as possible pre-disclosure probing.
Further reading
- CISA — Critical Java Vulnerability Requires Immediate Patching (17 November 2026): https://www.cisa.gov/news-events/alerts/2026/11/17/critical-java-vulnerability-requires-immediate-patching
- Qualys — How to Find, Mitigate, and Patch the Critical Java4Shell Flaw (CVE-2026-114938) Now: https://blog.qualys.com/vulnerabilities-threat-research/2026/11/17/how-to-find-mitigate-and-patch-the-critical-java4shell-flaw-cve-2026-114938-now
- CIRCL — TR-104: Critical Memory Corruption in OpenJDK Base64 Decoder (Java4Shell, CVE-2026-114938): https://www.circl.lu/pub/tr-104/
- Check Point — Java4Shell CVE-2026-114938: What You Need to Know: https://blog.checkpoint.com/security/java4shell-cve-2026-114938-check-your-java-services-now/
- Blackpoint Cyber — Java4Shell (CVE-2026-114938): Inside a Critical Flaw in Java's Base64 Decoder: https://blackpointcyber.com/blog/java4shell-cve-2026-114938-java-base64-decoder-flaw/
- The Hacker News — Java4Shell Flaw (CVE-2026-114938) Enables Pre-Auth RCE in Jira, Jenkins, Keycloak and More: https://thehackernews.com/2026/11/java4shell-cve-2026-114938-enables-pre.html
- Wiz — CVE-2026-114938 OpenJDK RCE (Java4Shell): Everything You Need to Know: https://www.wiz.io/blog/cve-2026-114938-rce-java4shell-openjdk
