TL;DR
Java4Shell (CVE-2026-114938) is a critical vulnerability in OpenJDK, the open source software that runs most Java applications. Security firm Calif, which found and reported the flaw, published details on November 17 after the vulnerability leaked before its planned disclosure. An attacker who sends a specially crafted piece of encoded data to an affected Java application can make it write past the end of a block of memory it set aside. On its own, that usually crashes the application.
By combining the flaw with the way a specific application uses memory, an attacker can take control of the server without logging in. The vulnerability is rated 9.2 out of 10 on CVSS 4.0, the industry's standard severity scale, which places it in the critical range. That score describes the worst case. Real exposure depends on the Java version (17.0.6 and later), the server's processor (recent Intel and AMD server chips that support a feature called AVX-512 VBMI, which covers much of current cloud capacity) and the application running on it. ARM-based servers, such as AWS Graviton, are not affected. No attacks in the wild have been reported as of November 17.
OpenJDK has published a fix, but each Java vendor will ship its fixed build on its own schedule. Organizations should install their vendor's update as soon as it is available. Until then, a JVM setting turns off the vulnerable code.
Introduction
ava4Shell (CVE-2026-114938) is a heap buffer overflow in the AVX-512 Base64 decoder of OpenJDK's HotSpot JVM on x86-64. Crafted Base64 that a vulnerable JVM decodes makes it write 62 or 63 bytes past the end of a heap array. The bytes written are a fixed value, so on its own the bug corrupts memory or crashes the JVM. Calif, which found and reported it, says that combined with a target application's own memory behavior it escalates to pre-authentication remote code execution, and names six products where it demonstrated this in default configurations.
The fix is four lines under JDK-8393212, titled "Base64 optimization improvements." It is in OpenJDK 27.0.1.1 and in mainline. As of November 17, the public jdk17u, jdk21u and jdk25u update repositories did not yet carry it.
If you run Java 17.0.6 or later, or any release from 18 on, on x86-64 hosts with AVX-512 VBMI, patch now. Where you cannot patch yet, the JVM flags in the mitigation section turn off the vulnerable code path.
Affected versions
Every HotSpot release from 17.0.6 on carries the vulnerable decoder, so exposure is wider than Java 17. Whether a given JVM can reach it depends on the CPU.
AVX-512 VBMI is present on Intel Ice Lake and later server parts (Sapphire Rapids, Emerald Rapids, Granite Rapids) and on AMD Zen 4 and later, which covers much of current cloud capacity. Check each host with the same JDK and JVM options the service uses:
If the first command prints avx512vbmi, UseAVX is above 2, and UseBASE64Intrinsics is true, the vulnerable path is live on that JVM.
Fixed builds
Oracle's November CSPU lists the builds below across all 11 of its Java SE fixes. That list is not a per-CVE scope.
Eclipse Temurin, Amazon Corretto, Azul Zulu, Microsoft Build of OpenJDK, Red Hat build of OpenJDK and the distro openjdk-17 packages ship on their own schedules and version labels. Read each vendor's fixed build from its own advisory. Do not infer it from Oracle's numbering.
What's happening
Calif published its writeup on November 17, and the fix is now visible in public OpenJDK source. The table separates what has been verified from what the reporter claims.
Timeline
Root cause
The bug is in the final step of HotSpot's AVX-512 Base64 decoder, which C2 uses in place of the Java implementation once Base64.Decoder is hot. Calif describes it as a miscalculated store mask for a padded tail. When the input ends in a padded fragment shorter than one four-character block, the output-size computation underflows, the store mask covers a full 64-byte write, and the decoder writes 62 bytes past the end of its output array, or 63 for a == tail. Java then rejects the input with IllegalArgumentException, after the write has happened.
The fix adds a guard at L_finalBit in stubGenerator_x86_64.cpp that sends that short tail to the scalar path before the size computation runs:
The commit title, "Base64 optimization improvements," gives no hint that it is a security fix.
The vector path only runs on inputs above a length threshold, which sets the shortest trigger. On Java 17 the threshold is 128 bytes, so the shortest trigger is 129 characters. On 21, 25 and 27 the threshold is 31 bytes, and the shortest trigger is 65 characters: one full 64-byte block plus a short padded tail.
The overflow content is a constant. In our reproduction, two inputs that differed only in their data characters left byte-identical out-of-bounds regions. The attacker controls where the write lands, and nothing about what it writes. The write destroys the next object's header, and the usual result is a SIGSEGV inside garbage collection. Upwind reports that no valid Base64 string overflowed across 300,000 runs.
How exploitation works
Because the decoder writes a fixed pattern, it corrupts memory or crashes the JVM by itself. Calif's escalation to code execution depends on the target application. Calif describes five stages:
- Corrupt one array's length, so the application's own writes into that array run out of bounds with attacker-chosen bytes.
- Corrupt a second array whose contents the application returns in a response, which leaks heap memory. Calif calls this JavaBleed.
- Repair the damaged object headers so the JVM keeps running.
- Groom the heap remotely so the overflow lands on a chosen object.
- Direct the resulting writes at the JVM's Code Cache.
Calif states there is no universal exploit. Each target needs its own decoder route, a writable buffer, a readable feedback channel, a usable heap layout and an application action. That is why the claimed impact is product-specific. Calif's public page shows no shell and withholds the weaponized chains but has a demonstration video with multiple popular applications like Jira, Confluence, Keycloak, and more being exploited with planted webshells.
Severity in context
Calif scores Java4Shell 9.2 under CVSS 4.0. Oracle scores Java SE under CVSS 3.1, and its highest Java SE score in the November CSPU is 8.1. No vector string has been published for this CVE.
One score covers a wide range of real outcomes. On its own the overflow crashes the JVM, which is a pre-auth denial of service on any reachable vulnerable service. Code execution, per Calif, needs the per-target conditions described above. The hosts to fix first are internet-facing AVX-512 VBMI machines running the six products Calif names as pre-auth targets.
For context, last month's PHP2Shell, another leaked runtime RCE scored 9.2 under CVSS 4.0, has since been added to CISA KEV.
Detection
The highest-fidelity signal is the input itself. Flag any Base64 field that ends in = or == and whose length is not a multiple of 4. Well-formed encoders never produce padded Base64 of that shape. On Java 21, 25 and 27 the trigger can be as short as 65 characters. On Java 17 it is 129 characters or more. Use 65 as the lower bound if you run mixed trains.
Behavioral signals that fit the exploitation model:
- High-rate Base64 decode traffic from one source, with deliberate pacing or fragmentation. Remote heap grooming needs many precisely placed requests.
- Bursts of IllegalArgumentException from java.util.Base64 in request-handling code. Every trigger throws after the write.
- Oversized or binary-looking responses from endpoints that normally echo decoded input. That is the shape of the heap-leak feedback channel.
- Repeated hs_err crashes with a SIGSEGV in a garbage-collection copy routine and a compiled Base64$Decoder.decode0 frame, especially clustered by source. Failed placement crashes the JVM, and the attacker retries.
Mitigation
- Find the JVM each service actually runs. java -version reports whatever is on the shell's path, and products such as Jenkins, Jira, Confluence, Keycloak and Elasticsearch often bundle their own runtime. Check the live process instead:
Run jcmd as the same user as the target process. For containers, check the base image in every Dockerfile and pipeline so the next deploy does not reintroduce an old JDK.
- Check whether the vulnerable path is live. Run the CPU and flag check from the affected-versions section on each host. ARM64 hosts and x86 hosts without AVX-512 VBMI can wait for the normal patch cycle.
- Patch. Install your vendor's November 2026 build that carries JDK-8393212. If you build from OpenJDK LTS source, confirm your tree contains JDK-8393212 first. As of November 17 the public jdk17u, jdk21u and jdk25u repositories did not carry it, even though Oracle's matching builds are in the CSPU. An LTS build whose version number matches a "fixed" column can still run the vulnerable code. Rebuild and redeploy container images, restart every Java process, and confirm the running build with jcmd.
- If you cannot patch yet, turn off the vulnerable path. Add one of these JVM options, in order of preference:
- -XX:+UnlockDiagnosticVMOptions -XX:DisableIntrinsic=_base64_decodeBlock turns off only the decode intrinsic. This is the narrowest option.
- -XX:-UseBASE64Intrinsics turns off the Base64 encode and decode intrinsics.
- -XX:UseAVX=2 turns off all AVX-512 code and can slow other work. Use it only if the first two are not available.
Confirm the setting took effect with -XX:+PrintFlagsFinal, and remove it after patching.
- Prioritize by exposure. Patch internet-facing AVX-512 VBMI hosts running Keycloak, Jira, Confluence, Artifactory, Jenkins or PingFederate first.
Actions for Endor Labs customers
Java4Shell sits in the Java runtime. Your pom.xml or build.gradle does not declare the JDK, so dependency scanning of application manifests will not surface it.
Use container scanning to find images that carry OpenJDK packages from 17.0.6 on, including 21, 25 and 27. Container reachability adds evidence about whether the affected OS package is used at runtime. That helps order the work. It does not see the host CPU or whether attacker input reaches the decoder, so we recommend upgrading affected Java runtimes regardless of reachability status.
When the JDK comes from a base image, base image remediation compares your current image with a refreshed build, the next version and the latest version. Once your JDK vendor publishes its fixed build, confirm the candidate image includes it, then rebuild, redeploy and rescan.
Resources
- Java4Shell: Write once, RCE everywhere (Calif)
- Calif's disclosure post on X (Calif)
- Fix diff, jdk-27.0.1-ga to jdk-27.0.1.1-ga (OpenJDK)
- OpenJDK Vulnerability Advisory, November 17, 2026 (OpenJDK, for the CVE mapping)
- Oracle Critical Security Patch Update, November 2026 (Oracle)
- Java4Shell: What We Know Now and What Comes Next (Upwind)
- CVE-2026-114938: Pre-auth heap overflow in Java 17, 21, and 25 (Equixly)
- Critical Java Flaw Found After PHP, Putting Korean Systems on Alert (Seoul Economic Daily)
- PHP2Shell: Critical vulnerabilities in PHP (Endor Labs)
What's next?
When you're ready to take the next step in securing your software supply chain, here are 3 ways Endor Labs can help:








