Java applications are often treated as memory-safe because the JVM manages object allocation and checks ordinary Java array access. That protection does not mean every optimized runtime component is written in Java.
Java4Shell, CVE-2026-114938, is a memory-corruption issue in the OpenJDK HotSpot Base64 decoder. The public disclosure and Eclipse Temurin advisory describe an affected path in the x86-64 implementation that uses AVX-512 VBMI instructions. On affected builds and hardware, malformed Base64 input can cause an out-of-bounds heap write. Under specific application conditions, the researchers report that this can be escalated to remote code execution.
This is a patch-and-inventory article, not an exploit guide. Do not reproduce public proof-of-concept payloads against systems you do not own or have explicit permission to test.
What is affected?
The important conditions are not just “the server runs Java.”
The Temurin advisory says the issue affects OpenJDK 17 and later on x64 systems whose CPU supports AVX-512 VBMI. Qualys' November 17 analysis says all four flags in the CPU check below must be present, and attacker-controlled data must reach the vulnerable Base64 decoding path in the application.
Temurin's guidance lists these fixed builds:
| Temurin line | Fixed build |
|---|---|
| JDK 27 | 27.0.1.1+4 |
| JDK 25 | 25.0.5.1+2 |
| JDK 21 | 21.0.13.1+2 |
| JDK 17 | 17.0.21.1+2 |
| JDK 11 and standard JDK 8 | Not affected according to the Temurin advisory |
There is an important exception: Qualys lists Oracle Java SE 8 Enterprise Performance Pack build 8u511b33-perf as affected. Other vendors publish their own builds and version strings. Do not assume a Temurin build number applies to Corretto, Zulu, Liberica, Microsoft Build of OpenJDK, Oracle JDK, or a vendor-maintained container image. Check the advisory for the exact distribution you run.
Credit: Qualys research article screenshot showing a software-inventory query; this is a Qualys product UI, not an OpenJDK tool.
Why a Base64 decoder can corrupt memory
The issue sits in a low-level optimized implementation used to accelerate Base64 decoding on supported x86-64 CPUs. The public technical disclosure explains that the decoder's handling of a padded tail can produce an incorrect write mask. The resulting store can write beyond the allocated output buffer before the Java layer rejects the malformed input.
The engineering lesson is broader than this one CVE: a managed runtime can still contain native code, JIT intrinsics, assembly routines, and hardware-specific optimizations. Those components deserve the same patch discipline as a native library.
The researchers report demonstrations in several Java applications. Treat those as tests of particular configurations, not as a guarantee that every deployment of those products is exploitable. Qualys also notes that there is no universal exploit chain: application-specific conditions still matter. Its November 17 report said public in-the-wild exploitation had not been confirmed at that time; that dated observation is not a reason to delay patching.
Credit: Qualys research article screenshot showing container-image inventory.
Check the runtime and CPU
Start with the Java executable used by the service, not only the default Java in your interactive shell.
java -XshowSettings:properties -version 2>&1 | grep -E 'java.vendor|java.runtime.version|java.vm.name' On Linux, this command checks for the four CPU flags described in the Qualys analysis:
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$' This is a hardware inventory check, not a complete vulnerability test. It does not prove that a particular JVM build is affected or that an application exposes the vulnerable code path.
Also look for runtimes bundled inside application servers, build tools, desktop applications, sidecars, and containers. A machine can have a patched system JDK while an application image still ships an older private runtime.
For a first-pass Linux inventory of common installation locations:
find /usr/lib/jvm /opt /usr/local /app -type f -name java -perm -111 2>/dev/null Run the version check against each relevant executable and record the vendor, runtime version, image, service, and owner. Extend the search to your actual installation paths and container registry; this command is not a universal filesystem scanner.
Patch first, then verify the running process
The recommended fix is to install the patched build from your Java vendor and restart every process using the old runtime.
A practical response sequence:
- Inventory JDKs and JREs on hosts, build agents, application servers, and container images.
- Match each runtime to its vendor's November 2026 advisory.
- Upgrade to the vendor's fixed build.
- Rebuild and redeploy containers instead of only patching the host.
- Restart long-running JVM processes so they load the updated runtime.
- Verify the version from inside the running container or service environment.
- Record the image digest and runtime version in your deployment inventory.
Eclipse Temurin documents an interim mitigation for systems that cannot upgrade immediately: start the JVM with -XX:-UseBASE64Intrinsics to disable the affected Base64 intrinsic. Treat this as temporary risk reduction, not a substitute for a vendor patch. Test the flag with your workload, document the performance impact, and remove it after the fixed runtime is deployed.
Do not assume a reverse proxy or request-body limit is a universal mitigation. Qualys notes that the malformed input can be short, so size limits alone do not remove the vulnerable code path.
What should teams prioritize?
Prioritize internet-facing services that accept attacker-controlled Base64 data, identity and authentication services, CI systems, artifact platforms, and applications that bundle their own JRE. Then expand to internal services and build infrastructure.
The strongest long-term control is runtime inventory. Record the Java vendor and exact version in your software bill of materials, scan container images, and make JDK updates part of the same patch process used for native dependencies.
Related video
An independent technical walkthrough published on November 19 explains the affected Base64 decoding path, hardware conditions, patching, and temporary mitigation. It is not an official vendor advisory; use the primary advisories linked above for authoritative patch status.
Sources and further reading
- Eclipse Temurin guidance for CVE-2026-114938
- OpenJDK security advisory, November 17, 2026
- Calif's Java4Shell technical disclosure
- Oracle November 2026 Critical Patch Update
- Qualys Java4Shell inventory analysis
I found a public exploit demonstration linked from the disclosure, but omitted it from the article because it is not necessary for the defensive patching workflow.
Have you inventoried the JDKs bundled inside your production containers, or are you relying only on the host's java -version output?



