Java4Shell (CVE-2026-114938): what Java teams need to check and patch
Java4Shell is a memory-corruption flaw in the Java runtime itself, not in a library. A JVM is exposed only when both its Java version and its CPU match, so two quick checks tell you where you stand. Here is what the flaw is, how to check your servers, and what to do about it.
What Java4Shell is
On November 17, 2026, OpenJDK and Oracle disclosed CVE-2026-114938, a heap-based buffer overflow in the hardware-accelerated Base64 decoder built into the HotSpot JVM. The researchers at Calif who found it named it Java4Shell.
When the final group of a Base64 string is malformed, the accelerated decoder miscalculates how much output is left and writes past the end of its destination buffer on the Java heap. The write corrupts neighboring memory.
Base64 decoding of untrusted input is everywhere in server applications. An HTTP Basic Authorization header, for example, is decoded before the server knows who is calling. That is why an unauthenticated attacker with network access can often reach the vulnerable code.
Why newer CPUs use a different decoder
Base64 decoding repeats two steps: look up the 6-bit value of each character, then pack four of those values into three bytes. Plain Java code does this one character at a time.
AVX-512 VBMI (Vector Byte Manipulation Instructions) adds instructions that look up and rearrange individual bytes across a full 512-bit register. One of them, VPERMT2B, performs a 128-entry table lookup on 64 bytes at once, which is exactly what translating Base64 characters needs: a single instruction translates 64 characters. Older instruction sets, including AVX-512 on CPUs without VBMI, have no single-instruction equivalent.
HotSpot takes advantage of this. Its decoder is based on the algorithm that Wojciech Muła and Daniel Lemire published in Base64 encoding and decoding at almost the speed of a memory copy, which turns 64 characters into 48 bytes per step with a handful of instructions. When the JVM starts, it detects the CPU's features. If AVX-512 VBMI is present, it generates this vectorized routine, and the JIT compiler uses it in place of the regular Java loop. This substitution is called an intrinsic.
That is why the same Java version is exposed on one machine and not on another. Working in 64-byte blocks means the routine needs separate code, with its own length arithmetic, for the input left over at the end. The flaw is in that arithmetic, so it exists only where the vectorized routine runs. It is also why the -XX:-UseBASE64Intrinsics flag described below works: it tells the JVM to keep using the regular Java loop.
How serious it is
Calif reports achieving unauthenticated remote code execution in several widely deployed Java applications. Those exploit chains are not public. The published proof of concept only demonstrates the memory overwrite.
As of November 18, 2026, the advisories we reviewed do not report exploitation in the wild. CISA has still issued an alert urging immediate patching, with priority on internet-facing systems.
The published scores differ because each source weighs attack complexity differently:
| Source | Score | Rating |
|---|---|---|
| Oracle | 8.1 (CVSS 3.1) | High |
| Red Hat | 9.8 (CVSS 3, preliminary) | Critical |
| Calif | 9.2 (CVSS 4.0) | Critical |
Who is affected
A JVM is exposed only when both of these conditions are true:
| Condition | Affected |
|---|---|
| Java runtime | OpenJDK 17.0.6 and later, 21, 25, and 27, including distributions built from OpenJDK such as Oracle JDK, Eclipse Temurin, and Amazon Corretto |
| CPU | x86-64 with AVX-512 VBMI: Intel Xeon Ice Lake and later, AMD Zen 4 and later |
ARM64 systems and x86-64 CPUs without AVX-512 VBMI are not known to be affected. Oracle also lists Java SE 8 Performance Edition 8u511b33-perf as affected.
Because the flaw lives in the runtime, tools that only scan your application's dependencies do not see it. Inventory the JDKs themselves, including the ones bundled inside third-party applications, container images, and appliances.
Check your servers
A JVM is exposed only when both the Java version and the CPU match, so check both on the machine where the JVM runs.
Check the Java version
java -version
The output shows the release line and build. Compare it with the affected versions above and the fixed builds below.
Check the CPU for AVX-512 VBMI
AVX-512 VBMI is a feature of the individual processor, so the server model or cloud instance name is not a reliable guide. Ask the machine directly.
On Linux, list the CPU flags that the vulnerable decoder depends on:
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
The CPU matches when the output includes all four flags: avx512f, avx512bw, avx512vbmi, and bmi2. If avx512vbmi is missing, the CPU does not match. A flag named avx512_vbmi2 is a different feature and does not count.
On any operating system, ask the JVM which CPU features it detected:
java -Xlog:os+cpu -version
Find the line that starts with CPU: total and look for avx512_vbmi in the list that follows. This is the JVM's own view of the processor, which is what decides whether it uses the accelerated decoder. On Linux and macOS, this filter prints avx512_vbmi only when the feature is present:
java -Xlog:os+cpu -version | grep -ow avx512_vbmi
Repeat the check for every production host or instance type, because the CPU can differ across a fleet. Run it inside the environment where the JVM actually runs: a container sees the CPU of its host, and a virtual machine sees only the features its hypervisor exposes. For containers, also check the JDK inside the image, not the one on the host.
What to do
1. Patch the JDK
The fix is in OpenJDK 17.0.21.1, 21.0.13.1, 25.0.5.1, and 27.0.1.1. As of November 19, 2026, these vendors have published fixed builds:
| Distribution | Fixed builds |
|---|---|
| Oracle Java SE | 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1 |
| Oracle GraalVM for JDK | 17.0.21.1, 21.0.13.1 |
| Eclipse Temurin | 17.0.21.1+2, 21.0.13.1+2, 25.0.5.1+2, 27.0.1.1+4 |
| Amazon Corretto | 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2, 27.0.1.1.4 |
| Azul Zulu | 17.70.201 (JDK 17.0.21.1), 21.54.201 (21.0.13.1), 25.38.201 (25.0.5.1), 27.30.201 (27.0.1.1) |
| Microsoft Build of OpenJDK | 17.0.21.1, 21.0.13.1, 25.0.5.1 |
| SapMachine | 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1 |
If your distribution is not listed, for example the OpenJDK package that ships with your Linux distribution, check your vendor's advisory for its fixed build.
After you install the fixed build, restart every JVM and rebuild your container images, because a running process keeps using the old runtime.
2. Disable the vulnerable decoder until you can patch
Start the JVM with this flag:
-XX:-UseBASE64Intrinsics
The flag turns off hardware acceleration for Base64 only. Decoding still produces correct results, slightly slower, and the other CPU optimizations stay on. Setting it through the JAVA_TOOL_OPTIONS environment variable applies it without changing your start scripts:
export JAVA_TOOL_OPTIONS="-XX:-UseBASE64Intrinsics"
Confirm that a JVM started in that environment picks it up. The value must be false:
java -XX:+PrintFlagsFinal -version | grep UseBASE64Intrinsics
WaveMaker applications
Applications you build with WaveMaker have a Java backend that runs on the JDK and hardware of your deployment environment. Treat them like any other Java workload:
- Run the two checks on every environment where your application runs.
- Move to your JDK vendor's patched build, and rebuild any container image that packages the JDK.
- Use
-XX:-UseBASE64Intrinsicsuntil the patched build is in place.
The JDK versions each WaveMaker release is built and tested with are listed on the tech stack page.
