A comprehensive deep dive into Java4Shell (CVE-2026-114938)
- Updated at
If the words “Java” and “4Shell” in the same sentence just sent you back to December 2021 and a long weekend of Log4Shell tickets, you’re not alone.
CVE-2026-114938, a.k.a. Java4Shell, is a heap out-of-bounds write in the hardware-accelerated Base64 decoder built into OpenJDK. Calif, the team that found it, has shown it can lead to pre-authentication remote code execution in Keycloak, Jira, Confluence, Artifactory, Jenkins, and PingFederate, in their default configurations (Calif).
Unlike Log4Shell, it doesn’t hit every Java server. It needs a specific combination of Java version, CPU, and input path, and that’s exactly what makes it tricky to triage. The same container image can be exposed on one node and safe on the next, depending on the processor underneath it (Upwind).
For you, as a penetration tester or security engineer, this raises very practical questions:
Which of my Java services actually meet all the conditions?
How do I check exposure when the Java version and the CPU are invisible from the outside?
What do we know for sure about exploitation, and which claims are unproven?
This article walks you through those answers from a practitioner’s angle:
A clear map of affected and fixed builds across Oracle, Corretto, Zulu, GraalVM, and other OpenJDK distributions.
The four conditions that decide whether a host is exposed.
How the bug works, and why there’s no universal exploit (yet).
Practical detection and mitigation steps, including two pieces of advice going around that will hurt you.
Let’s get into it.
Java4Shell - what CVE-2026-114938 is and why it matters
On November 17, 2026, Oracle and the OpenJDK project released fixes for CVE-2026-114938, and Calif published its write-up the same day. Details had already leaked before the patch (Qualys).
Key facts:
Type: heap out-of-bounds write (integer underflow) in HotSpot’s AVX-512 VBMI Base64 decoding intrinsic.
Impact: heap memory disclosure and, according to Calif, pre-authentication remote code execution.
CVSS: 8.1 under CVSS 3.1 (Oracle, which assigned the CVE) and 9.2 under CVSS 4.0 (Calif).
Scope: Java 17, 21, 25, and 27, in every OpenJDK-based distribution, on x86-64 CPUs with AVX-512 VBMI.
Fix: OpenJDK’s JDK-8393212, a three-line guard on the input length.
KEV: not listed in CISA’s Known Exploited Vulnerabilities catalog as of November 18, 2026. CISA did send a public alert on November 17, urging immediate patching (CISA).
What’s confirmed and what’s only claimed
Java4Shell moved fast, and a lot of the coverage mixes the two. Here’s where things stand as of November 18, 2026:
Confirmed: the flaw, its scope, and its root cause, by Oracle and the OpenJDK fix (pentestit).
Claimed, not independently verified: remote code execution in real products. Calif holds back its product exploits until organizations have had time to upgrade (Qualys).
Claimed, not released: a working exploit by Kevin Breen of Immersive, which he says has to be adapted to each application (Tenable).
Not reported: exploitation in the wild.
Does Java4Shell affect my targets?
A host is exposed only when all four conditions hold at the same time:
An affected JVM, including Java runtimes bundled inside products and container images.
An x86-64 CPU with AVX-512 VBMI: Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids, and Granite Rapids, or AMD Zen 4 and newer. ARM isn’t affected.
Untrusted Base64 that reaches Base64.getDecoder() or getUrlDecoder(), usually through authentication headers, tokens, file uploads, and network messages.
A JIT-compiled decoder, which any busy service has.
Source: Upwind.
Affected and fixed Java versions
Oracle Java SE 17: 17.0.6 to 17.0.21.0.3 → fixed in 17.0.21.1
Oracle Java SE 21: 21.0.13.0.3 and earlier → fixed in 21.0.13.1
Oracle Java SE 25: 25.0.5.0.3 and earlier → fixed in 25.0.5.1
Oracle Java SE 27: 27.0.1.0.3 and earlier → fixed in 27.0.1.1
Oracle Java SE 8 Performance Pack: 8u511b33-perf → fixed in 8u513-perf
Oracle GraalVM: fixed in GraalVM for JDK 17.0.21.1 and 21.0.13.1, and Enterprise Edition 21.3.20.1
Amazon Corretto: fixed in 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2, and 27.0.1.1.4
Azul Zulu (free builds): fixed in 17.70.201, 21.54.201, 25.38.201, and 27.30.201
Red Hat build of OpenJDK and RHEL packages: fix pending as of November 18, 2026
Eclipse Temurin, Microsoft Build of OpenJDK, BellSoft Liberica, SAP SapMachine: affected; fixes ship on each vendor’s schedule
Sources: The Hacker News, SOCRadar.
Not affected
If your runtimes are any of these, you’re outside this vulnerability’s scope (lucky you):
standard Java 8 and Java 11
Java 17.0.0 through 17.0.5
ARM64 hosts, and x86-64 CPUs without AVX-512 VBMI
Which applications are in the line of fire
Calif demonstrated pre-auth RCE in Keycloak, Jira, Confluence, Artifactory, Jenkins, and PingFederate, and post-auth RCE in Kafka Broker, Solr, Elasticsearch, Gerrit, and Spinnaker. It also reports a client-side exploit against a Java program that connects to a malicious TLS server (Upwind).
Kevin Breen adds two pre-login paths worth checking in your own apps: Apache Tomcat’s Basic authentication and the java-jwt library (Tenable).
Why nobody can count exposed servers (yet)
For most critical CVEs, a quick Shodan or Censys search gives you a rough count of exposed targets. Java4Shell doesn’t work that way.
Two of the four conditions are invisible from the outside: Java runtimes don’t advertise their version over the network, and nothing a remote scan sees reveals whether the CPU supports AVX-512 VBMI. You can count internet-facing Jira, Confluence, or Keycloak instances, but that number overstates the real exposure, since many of them run patched or unaffected Java versions, ARM hosts, or older CPUs.
That’s why, for Java4Shell, exposure mapping starts inside your environment, not on the internet. The inventory steps below show you where to look.
Java4Shell root cause and technical details
To speed up Base64 decoding, HotSpot replaces the Java code with a hand-written assembly routine on CPUs that support AVX-512 VBMI. That routine has an edge case nobody guarded.
A malformed 65-byte input, 64 valid characters followed by a stray “=”, makes the routine compute an output length of -1. The BZHI instruction that builds the write mask only looks at the low byte of that value (0xFF), so no bits get cleared. The result is a full 64-byte mask, and the VMOVDQU8 instruction writes 62 bytes past the end of the output buffer (ikow/java4shell-poc).
Java then rejects the input as invalid, but by that point, the neighboring objects on the heap are already corrupted.
The fix, JDK-8393212, adds a three-line check that sends inputs shorter than four bytes down the safe path.
One detail explains the leak: the fix was committed to the public jdk17u repository on November 12, five days before the release that shipped it (pentestit).
How Java4Shell exploitation works (and why it isn’t one-size-fits-all)
According to Calif, a remote attacker with no credentials can corrupt heap memory, read it back in the style of Heartbleed, and reach code execution (Fenko).
But Calif itself says there’s no universal exploit. Each target needs its own decoder route, a writable buffer, a feedback channel, and the right heap layout (DEV Community).
That puts Java4Shell in a very different category from Log4Shell or React2Shell:
Memory corruption, not a logic bug: heap layout matters, so exploits are less reliable and more target-specific.
Hardware-dependent: the CPU decides whether the vulnerable code path even runs.
Cheap to find: Calif reports finding the bug with AI assistance in about an hour, with a first working exploit two hours later, for under $200 in AI tokens (Qualys). That’s their timeline, not an independently checked one.
Java4Shell exploitation status - what we know so far
Timeline
November 12, 2026: fix JDK-8393212 committed to the public jdk17u repository.
November 17, 2026: Oracle and OpenJDK release fixed builds; Calif publishes its write-up and a safe reproducer; CISA urges immediate patching; Kevin Breen reports a working, per-application exploit.
November 18, 2026: a lab-grade reproduction of the memory write appears publicly; still no exploitation reported, and not in KEV.
A word of caution on public proof-of-concept code
The public code so far proves the write, not a product compromise (Fenko). Some repositories that show up for “Java4Shell PoC” are only local version checkers (Cyber Kendra). Treat any PoC for this bug as untrusted code, and run it only in an isolated lab.
Detection strategies for security teams
Inventory and exposure mapping
Find every Java runtime, including the ones bundled inside products and container base images (Temurin, Corretto, Zulu, Microsoft, Red Hat).
Check the version on each host (java -version) against the affected ranges above.
Check the CPU: on Linux, look for the avx512vbmi flag in /proc/cpuinfo. Remember that autoscaling groups can mix CPU generations.
Map which services decode untrusted Base64 before authentication: SSO and identity providers, Basic auth endpoints, JWT handling, file uploads.
Network-level detection
Public detection rules for Suricata, Sigma, and ModSecurity already exist (ikow/java4shell-poc). They look for short, malformed Base64 values that end in a stray “=” in authentication headers, tokens, and upload fields.
Keep in mind what these rules can and can’t do. They’re reactive indicators: they flag exploitation attempts against your services, but they can’t tell you whether a host is vulnerable in the first place. Use them to spot someone probing your environment, and rely on the inventory steps above to find what needs patching.
Business impact - the attack scenarios that actually matter
Identity provider takeover
Keycloak and PingFederate sit in front of everything else. A pre-auth RCE on the identity provider means an attacker can mint sessions for any application that trusts it.
CI/CD and artifact supply chain compromise
Jenkins and Artifactory hold build credentials, signing keys, and the artifacts other teams deploy. A foothold there turns one bug into a supply chain incident.
Collaboration data and internal recon
Jira and Confluence hold architecture docs, incident notes, and sometimes credentials pasted in tickets: a map of the rest of the environment.
Compliance and incident response pain
If a compromise leads to a personal data breach, GDPR gives you 72 hours to notify, and NIS2 asks for an early warning within 24 hours.
Patching and mitigating Java4Shell - your next steps
Patch the JVM. Install your vendor’s fixed build (versions above). Updating the Java runtime is the only complete fix (Qualys). Start with internet-facing services that decode untrusted input before login.
Can’t patch today? Turn off the Base64 intrinsic with -XX:-UseBASE64Intrinsics. It stopped the overflow on every affected version Upwind tested (Upwind). Test the performance impact on a staging host first.
Don’t use -XX:DisableIntrinsic=_base64_decodeBlock on its own. It stops the JVM from starting, and pushed through JAVA_TOOL_OPTIONS, it causes a fleet-wide outage (Upwind).
Ignore “fixed in 17.0.11 and 21.0.3”. That’s JDK-8321599, an older bug in the same decoder, not Java4Shell (Upwind).
Rebuild container images on patched base images, and check vendor appliances that bundle their own Java runtime.
Java4Shell is a good reminder that “which version do we run?” isn’t always enough to answer “are we exposed?”. This time, the hardware gets a vote too.
The sooner you map all four conditions that bring about this vulnerability across your estate, the faster you can turn this from an emergency CVE into a closed ticket.
Until then, we have your back!






