Java4Shell: OpenJDK's Critical Flaw (CVE-2026-114938) Is Now Patched
OpenJDK's hardware-accelerated Base64 decoder had a critical flaw nicknamed Java4Shell. Oracle scores it 8.1; its discoverers score it 9.2. Here's what's affected and how to patch it.
Oracle and the OpenJDK project patched a critical Java vulnerability on November 17, 2026, that security researchers are calling "Java4Shell." Tracked as CVE-2026-114938, the flaw sits in the Base64 decoder inside HotSpot's just-in-time compiler and carries an official CVSS 3.1 score of 8.1 from Oracle, while the researchers who found it score it 9.2 under the newer CVSS 4.0 scale. It affects OpenJDK 17, 21, 25, and 27 on x86-64 systems with AVX-512 VBMI support, and fixes are already available — here's what it is, who's affected, and how to patch it.
Java4Shell at a glance
- CVE ID: CVE-2026-114938
- Component: HotSpot compiler (Base64 decoder intrinsic)
- Severity: 8.1 (CVSS 3.1, Oracle) / 9.2 (CVSS 4.0, Calif.io)
- Affected: OpenJDK/Oracle Java SE 17, 21, 25, 27 on AVX-512 VBMI–capable x86-64 CPUs. Java 8 and 11 are not affected by this specific CVE.
- Patched: November 17, 2026, in Oracle's November Critical Security Patch Update and the matching OpenJDK advisory
- Found by: Albert Yang and Quang Luong of Calif.io, credited jointly by Oracle
What is Java4Shell?
Java4Shell is the nickname given to CVE-2026-114938 by Calif, the security research firm that disclosed it in detail on November 17, 2026. The name echoes Log4Shell, the 2021 Apache Log4j flaw, because both involve a widely embedded Java component that can be reached remotely. In this case, the vulnerable code is HotSpot's hardware-accelerated Base64 decoder — the routine the JVM uses to decode Base64-encoded data in network requests, tokens, and file uploads.
According to Calif's writeup, the bug lives specifically in the AVX-512 VBMI code path of StubGenerator::generate_base64_decodeBlock(). When a Base64 input's final block has fewer than four leftover bytes before padding, the decoder can compute a negative output length. That negative value is then used to build a write mask that, instead of restricting the write to a few bytes, expands it to the full 64-byte vector register — corrupting adjacent heap memory. Calif says the bug reproduces with a trigger as simple as 64 "A" characters followed by an equals sign, once the JVM has warmed the method up to its C2 JIT compilation tier.
How severe is it, really?
Severity ratings differ depending on who's scoring it, and it's worth citing both rather than picking one. Oracle's own security advisory and the OpenJDK vulnerability advisory both list CVE-2026-114938 at 8.1 (CVSS 3.1), with the vector AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H — network-exploitable, high attack complexity, no privileges or user interaction needed, with high impact to confidentiality, integrity, and availability. Calif, using the newer CVSS 4.0 standard, scores it higher at 9.2, reflecting that framework's different weighting of exploitability factors.
Security vendor OX Security has separately cautioned that the "shell" nickname overstates how easy this is to exploit in practice: triggering it reliably requires heap grooming that's application-specific, sensitive to network conditions, and — per Calif's own disclosure — has "no universal exploit." That matches Oracle's own "high" attack-complexity rating. The bug is real and worth patching promptly, but it is not a drop-in, point-and-shoot exploit the way some headlines might imply.
Which Java versions are affected?
Per the OpenJDK project's own vulnerability advisory, published alongside the fix, CVE-2026-114938 affects the HotSpot compiler in the 17, 21, 25, and 27 release lines. Notably, that advisory's risk matrix does not mark Java 8 or 11 as affected by this particular CVE — though it's worth noting Oracle's broader November Critical Security Patch Update separately lists an 8u511b33-perf "perf pack" build among the versions it patched across its full set of fixes that month, so administrators running performance-pack builds of Java 8 should still check Oracle's advisory directly for their exact build.
| Branch | Last vulnerable build (per OpenJDK advisory) | Fix available since |
|---|---|---|
| Java 17 | 17.0.21.0.3 and earlier | Nov 17, 2026 |
| Java 21 | 21.0.13.0.3 and earlier | Nov 17, 2026 |
| Java 25 | 25.0.5.0.3 and earlier | Nov 17, 2026 |
| Java 27 | 27.0.1.0.3 and earlier | Nov 17, 2026 |
| Java 8 / 11 | Not listed as affected by this CVE in the OpenJDK advisory | — |
Calif's writeup states the fixed releases are 17.0.21.1, 21.0.13.1, 25.0.5.1, and 27.0.1.1 — check your distribution's own release notes to confirm the exact patched build number you need, since Oracle, Eclipse Temurin, Amazon Corretto, Azul Zulu, Red Hat, BellSoft Liberica, and Microsoft Build of OpenJDK each ship their own build numbering on top of the upstream version.
There's a hardware catch: AVX-512 VBMI
This bug can only trigger on x86-64 processors that support the AVX-512 VBMI instruction set — Calif names Intel's Ice Lake, Sapphire Rapids, Emerald Rapids, and Granite Rapids server chips, plus AMD EPYC and Ryzen parts based on Zen 4 or newer. ARM64 systems are not affected at all, since they don't use this code path. You can check whether a Linux host has the required instruction flags with:
| Check | Command |
|---|---|
| Required CPU flags | grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$' |
If all four flags are present, the host's CPU can execute the vulnerable path; if any are missing, that machine isn't affected by this particular bug regardless of its Java version.
Is Java4Shell being actively exploited?
As of November 20, 2026, CVE-2026-114938 does not appear on CISA's Known Exploited Vulnerabilities catalog, which tracks vulnerabilities confirmed to be under active attack. That's a meaningful signal that, so far, this is a disclosed-and-patched flaw rather than one being exploited in the wild.
That said, Calif's own disclosure describes proof-of-concept exploit chains it built in default configurations of several widely deployed products — including pre-authentication chains against Keycloak and Jenkins, and post-authentication chains against Apache Kafka Broker, Apache Solr, and Elasticsearch — to demonstrate real-world impact to Oracle during coordinated disclosure. Those were researcher-built demonstrations shared privately with vendors, not reports of attacks against live systems. If you run any Java-based identity, CI/CD, search, or messaging infrastructure on affected hardware, treat patching as time-sensitive regardless. See our guide to how zero-day vulnerabilities get discovered and disclosed for background on this kind of coordinated-disclosure process.
How to patch Java4Shell now
The straightforward fix is to update to a patched build from whichever JDK distribution you run — Oracle Java SE, Eclipse Temurin, Amazon Corretto, Azul Zulu, Red Hat OpenJDK, BellSoft Liberica, SAP SapMachine, and Microsoft Build of OpenJDK were all named by Calif as downstream builds carrying the vulnerable code, since they all derive from the same OpenJDK HotSpot source.
If you can't patch immediately, Calif's disclosure lists two JVM startup-flag mitigations:
-XX:-UseBASE64Intrinsics— disables the hardware-accelerated Base64 decoder path entirely, forcing the JVM back to its safe, non-vectorized implementation.-XX:UseAVX=2— caps the JVM's instruction set usage below AVX-512, which also avoids the vulnerable path. This flag should only be applied on x86-64 hosts; ARM builds of OpenJDK don't recognize it and will fail to start.
Neither flag is a substitute for patching — they're stopgaps while you schedule an update. Teams that recently dealt with the Synology DSM flaw added to CISA's KEV catalog or last week's Patch Tuesday fix for an Outlook zero-day will recognize the pattern: patch first, mitigate only as a bridge.
How Java4Shell was found and disclosed
The bug has a long tail. According to Calif's published timeline, a developer using the handle "sundarms" first hit the crash in June 2026 and filed a public Adoptium bug report; by September, another contributor had identified the root cause and proposed a fix in the open-source OpenJDK repository, though that particular patch was later closed without being merged. Calif's own researcher, Quang Luong, independently rediscovered the bug in late October using an AI coding assistant during unrelated security research, built working proof-of-concept exploits, and reported it to Oracle on October 24. Oracle and Calif coordinated over the following three weeks, notifying government agencies and industry partners shortly before Oracle shipped the fix on November 17 and Calif published its full technical writeup.
Is Java4Shell another Log4Shell?
The nickname invites the comparison, but the two bugs are different in important ways. Log4Shell (CVE-2021-44228) lived in a third-party logging library, Apache Log4j, that countless applications pulled in as a dependency — meaning exposure depended on which libraries a given app happened to use, and it was trivially easy to trigger with a single crafted string in almost any log-able input. Java4Shell instead lives inside the JDK itself, in a hardware-accelerated intrinsic that ships with the runtime rather than an optional library, which is why Calif and Oracle describe the exposure in terms of CPU architecture (AVX-512 VBMI) rather than which third-party jars an application bundles.
That cuts both ways. On one hand, every application running on an affected JDK build is a candidate, regardless of what frameworks it uses — there's no equivalent of "just remove the vulnerable dependency." On the other hand, Oracle's "high" attack-complexity rating and Calif's own admission that there's "no universal exploit" suggest Java4Shell requires considerably more per-target engineering than Log4Shell did, where a single JNDI payload worked broadly. Treat the nickname as a signal of how seriously researchers are taking the bug, not as proof it is equally easy to weaponize at scale.
Who actually needs to act on this
If you're an everyday user of a website, app, or game, there is nothing to install yourself — this is a server-side and infrastructure issue, not a consumer patch like a phone update. The people who need to act are the ones running Java workloads: platform engineers, DevOps and SRE teams, and anyone managing self-hosted software written in Java.
Practically, that means checking:
- Any self-hosted identity or access-management software (Keycloak-style deployments), since Calif specifically demonstrated pre-authentication proof-of-concept chains against products in that category.
- CI/CD systems and build servers (Jenkins and similar), which are frequently internet-reachable and run on long-lived JVMs that may already be warmed to the vulnerable JIT tier.
- Search and data infrastructure such as Elasticsearch, Apache Solr, and Kafka brokers, where Calif demonstrated post-authentication exploitation.
- Any container images that bundle an affected OpenJDK build — rebuilding from an updated base image is often faster than patching a running JVM in place.
How to check which JDK build you're running
Before deciding whether you're exposed, confirm your actual runtime version — not just what your package manager says you installed, since containers and bundled runtimes can drift. From a shell with Java on the path:
| Goal | Command |
|---|---|
| Print the exact JDK build | java -version |
| Check a Docker image's bundled JDK | docker run --rm <image> java -version |
| Confirm AVX-512 VBMI support (Linux host) | grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$' |
If java -version reports a build at or below the last-vulnerable numbers in the table above, and your host CPU returns all four flags in the hardware check, treat that service as exposed until you've applied the vendor update or one of the two JVM mitigation flags.
What to do next
If you administer Java infrastructure — application servers, CI/CD systems, identity providers, or anything else running on OpenJDK 17, 21, 25, or 27 — check your JDK build version today, apply your vendor's November 2026 security update, and only fall back to the JVM flag mitigations if a patch window isn't immediately available. Keep an eye on CISA's KEV catalog and your JDK vendor's advisory page in case the status changes from "patched, not yet exploited" to something more urgent.
Frequently asked questions
What is Java4Shell?
Java4Shell is the nickname for CVE-2026-114938, a critical vulnerability in OpenJDK's hardware-accelerated Base64 decoder that can cause heap memory corruption and, in some demonstrated configurations, remote code execution. It was disclosed and patched on November 17, 2026.
Which Java versions are affected by CVE-2026-114938?
Per the OpenJDK project's own advisory, the flaw affects Java (OpenJDK) 17, 21, 25, and 27 on x86-64 CPUs with AVX-512 VBMI support. Java 8 and 11 are not listed as affected by this specific CVE, though Oracle's broader patch update separately covers a Java 8 performance-pack build.
Is Java4Shell being actively exploited right now?
As of November 20, 2026, CVE-2026-114938 is not listed on CISA's Known Exploited Vulnerabilities catalog, which tracks confirmed active attacks. The researchers who found it built proof-of-concept exploits against specific products during private, coordinated disclosure, but no in-the-wild exploitation has been publicly confirmed.
How do I patch Java4Shell?
Update to a patched build from your JDK vendor (Oracle, Eclipse Temurin, Amazon Corretto, Azul Zulu, Red Hat, BellSoft Liberica, SAP SapMachine, or Microsoft Build of OpenJDK). If you can't patch immediately, the discovering researchers list two JVM mitigation flags: -XX:-UseBASE64Intrinsics and -XX:UseAVX=2.
Why is CVE-2026-114938 scored differently by different sources?
Oracle and the OpenJDK advisory use CVSS 3.1 and score it 8.1. Calif, the firm that discovered and disclosed the bug, scored it 9.2 using the newer CVSS 4.0 standard, which weighs exploitability factors differently. Both figures come from primary sources, so it's worth knowing which scale you're looking at.
Does my CPU matter for this vulnerability?
Yes. The flaw only triggers on x86-64 processors with AVX-512 VBMI support, such as recent Intel Xeon and AMD EPYC/Ryzen chips. ARM64 systems don't use the vulnerable code path and aren't affected regardless of Java version.
Sources
Sana Qureshi runs the security and privacy desk. She reports on actively exploited vulnerabilities, vendor patches and data breaches, and covers the password managers, VPNs and authentication tools readers use to protect themselves. Her alerts cite vendor advisories, CISA and the CVE record directly.

