Java4Shell (CVE-2026-114938) is a critical memory corruption flaw in OpenJDK's Base64 decoder, scored 9.2 on CVSS 4.0. An unauthenticated remote attacker can send crafted Base64 text, overwrite heap memory, leak secrets in the style of Heartbleed, and reach remote code execution. Calif, the firm that found it, demonstrated pre-authentication RCE against default installs of Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate. It affects OpenJDK 17.0.6 and later on x86-64 CPUs with AVX-512, and fixed builds are available now.
What is Java4Shell?
Java is memory-safe by design, which is why a heap overflow in the standard library is such a surprise. But parts of the runtime are hand-written in assembly for speed, and that is where this bug lives. To decode Base64 quickly, OpenJDK's HotSpot JIT uses an x86-64 intrinsic built on AVX-512 VBMI instructions that process 64 bytes at a time.
According to Calif's write-up, the intrinsic miscalculates the write mask for the final, padded chunk of input. When the trailing bytes form padding such as a lone =, the decoder computes an output length of zero, then subtracts one for the padding, producing a negative value. The mask derived from that value ends up with every bit set, so the routine writes a full 64 bytes where it should have written almost none.
On OpenJDK 21/25 builds, 64 A characters followed by a single = is enough to trigger the vulnerability:
That input makes OpenJDK allocate a buffer, then write past it, spilling attacker controlled data past the end and corrupting whatever Java objects sit next to it on the heap. Java then rejects the input with an IllegalArgumentException, by which point the damage is already done. On OpenJDK 17, the trigger is 128 A characters plus =, because the vulnerable fast path is reached at a higher length.
The decoder must also be JIT-compiled to its fast tier for the bug to fire, which happens automatically once an application has decoded Base64 enough times, as any busy server does.
From a fixed write to remote code execution
The overwrite looks weak at first: it writes mostly fixed bytes, and the attacker controls only where it lands, not its content. Calif turned that into full code execution with heap grooming. By spraying buffers so that a length field sits just after the corrupted object, they extended the fixed write into a controlled, chosen-value write (the "writer"), then into an out-of-bounds read that returns heap memory in responses (the "reader"). That read alone is a Heartbleed-class leak of heap contents, which Calif calls JavaBleed, exposing PII, private keys and session tokens before any code runs. From there they escalated to arbitrary writes into the JIT code cache and reached remote code execution.
Calif reports working exploits, in default configurations, in widely deployed Java software such as Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, PingFederate where they found this bug to be exploitable pre-authentication and Apache Kafka, Apache Solr, Elasticsearch, Gerrit, Netflix Spinnaker post-authentication.
The lists are explicitly non-exhaustive. Calif also demonstrated RCE in sample apps on Apache Struts and Spring Boot, and notes a client-side variant shared by samczsun: a Java client that opens a TLS connection to a malicious server can be compromised even if it exposes no service of its own. Everyday features such as login and file upload are enough to route attacker input into the vulnerable decoder.
Two caveats temper the severity. There is no universal, point-and-shoot exploit: each target needs a bespoke heap profile, and the attack is sensitive to network timing. Calif is holding back the weaponised per-product chains until organisations have had time to patch, and has published only a safe, self-contained trigger.
Which versions and hardware are affected?
Java4Shell affects OpenJDK 17.0.6 and later. Because they are built from OpenJDK, the mainstream distributions are affected too: Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat OpenJDK, Oracle OpenJDK, Oracle Java SE and Oracle GraalVM for JDK.
Oracle confirmed the following Oracle Java SE builds as vulnerable, ahead of publication: 8u511b33-perf, 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3 and 27.0.1.0.3.
The bug is in x86-specific assembly, so exposure also depends on the CPU. A host is affected only when it runs an affected build on an x86-64 processor with AVX-512 VBMI support, which covers Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids, and AMD EPYC and Ryzen Zen 4 or newer. ARM64 CPUs are not affected.
On Linux, this command shows whether a host's CPU meets the requirement. For a host to be vulnerable all four flags must appear:
What should you do?
Fixed builds exist, so the priority is to patch, not just mitigate.
- Find every Java runtime you run, including JDKs bundled inside products and container base images. Record the vendor and exact build with jcmd <PID> VM.version, since the java on the path may not be the one a service uses.
- Apply your vendor's fixed build now. Oracle shipped its fixes at on 17 November, and OpenJDK has published an advisory. Other distributions are releasing on their own schedules.
- Restart every Java process and rebuild container images after updating. Replacing files on disk does not fix a running JVM, and images pinned to old digests stay vulnerable.
- Confirm the running build reports the fixed version with jcmd.
Where you cannot patch immediately, start the JVM with one of the flags Calif documents (-XX:-UseBASE64Intrinsics or -XX:UseAVX=2 for x86-64 hosts) and restart the process.
Treat these as temporary. Prioritise internet-facing services that decode Base64 before authentication, such as HTTP Basic credentials and JWTs, and confirm a setting took effect with:
How Ethiack helps
Java4Shell turns on one question: which of your reachable services run an affected Java build and decode attacker-supplied Base64 before authentication? Ethiack's continuous testing maps your external attack surface and identifies exposed Java services, so you can find and rank them while you roll out the patch.
Our research team is analysing CVE-2026-114938 and will add exploitability validation to the platform.
Frequently asked questions
What is Java4Shell? Java4Shell is the name for CVE-2026-114938, a heap buffer overflow in OpenJDK's AVX-512 Base64 decoder. An unauthenticated attacker can trigger it with crafted Base64 input and escalate to remote code execution.
Which Java versions are affected by CVE-2026-114938? OpenJDK 17.0.6 and later, across all distributions built from it, including Oracle Java SE, Temurin, Corretto, Zulu, Liberica, SapMachine and Red Hat OpenJDK. Standard Java 8/11 builds lack the vulnerable code and are not affected. However, Oracle lists a -perf 8u build that backported it.
Is Java4Shell remote code execution? Yes. Calif demonstrated pre-authentication RCE in default installs of Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate, and a heap leak it calls JavaBleed.
Is there a patch? Yes. Oracle released fixed builds on 17 November 2026, and OpenJDK published a security advisory. Update immediately.
Is my server affected if it runs Java 17? Only if it also runs on an x86-64 CPU with AVX-512 VBMI (Intel Ice Lake or later, AMD Zen 4 or later) and decodes attacker-controlled Base64. ARM64 hosts are not affected.
How can I mitigate it without patching? Start the JVM with -XX:-UseBASE64Intrinsics or, on x86-64 only, -XX:UseAVX=2, then restart the process. These are stopgaps until you patch.
Is it being exploited in the wild? No public exploitation has been reported. Calif has released a safe trigger but is holding back weaponised per-product exploits to give organisations time to patch.
