Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse varius enim in eros elementum tristique. Duis cursus, mi quis viverra ornare, eros dolor interdum nulla, ut commodo diam libero vitae erat. Aenean faucibus nibh et justo cursus id rutrum lorem imperdiet. Nunc ut sem vitae risus tristique posuere.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse varius enim in eros elementum tristique. Duis cursus, mi quis viverra ornare, eros dolor interdum nulla, ut commodo diam libero vitae erat. Aenean faucibus nibh et justo cursus id rutrum lorem imperdiet. Nunc ut sem vitae risus tristique posuere.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse varius enim in eros elementum tristique. Duis cursus, mi quis viverra ornare, eros dolor interdum nulla, ut commodo diam libero vitae erat. Aenean faucibus nibh et justo cursus id rutrum lorem imperdiet. Nunc ut sem vitae risus tristique posuere.
On November 17, 2026, the OpenJDK Vulnerability Group and Oracle disclosed Java4Shell (CVE-2026-114938), a heap overflow in HotSpot's Base64 decoder that can be reached without authentication. It is rated CVSS 3.1 8.1. But a Java service is only exposed when four things are true at once: it runs a HotSpot JVM on an affected Java line, on an x86-64 CPU with AVX-512 VBMI, and untrusted Base64 reaches the decoder. A repository can show you the first of those. It can't prove the other three.
So the first question isn't "do we run Java?" It's "which of our Java services can we actually confirm are exposed, and which ones can't we see yet?"
Java4Shell is a memory-safety bug in the x86-64 code HotSpot uses to speed up java.util.Base64 decoding. Calif, whose researcher Quang Luong is credited in Oracle's advisory, explains that the hardware-accelerated decoder miscalculates the output length when malformed input ends in = padding. The length goes negative, and a 64-byte masked write runs about 62 bytes past the end of the output array.
The input that triggers it is short. Calif says a run of A characters followed by a stray = is enough. That means request-size limits won't protect you.
Here is what's confirmed as of November 18, 2026:
hotspot/compiler with a CVSS 3.1 base score of 8.1. Oracle rates it network-reachable, no privileges, no user interaction, high attack complexity.Each condition comes from the advisories and Calif's writeup. Each one also lives in a different place.
| Condition | What has to be true | Where the evidence lives |
|---|---|---|
| JVM | HotSpot with the Base64 intrinsic enabled | The running JVM's build and flags |
| Java line | OpenJDK 17.0.6 and later, and 21, 25 and 27, per Calif and the OpenJDK risk matrix (OpenJDK lists 8 and 11 as unaffected) | Images, hosts, and partly the repository |
| CPU | x86-64 with AVX-512 VBMI (Linux flags avx512f, avx512bw, avx512vbmi, bmi2). ARM64 is not affected. | The host the JVM is scheduled on |
| Input | Untrusted Base64 reaches java.util.Base64's decoder | The code path, at runtime |
Miss any one of those and the bug doesn't fire. Can't see one of them and you don't know.
We reviewed every repository in 18 customer organizations: 15,477 of 15,478 repositories, default branches, archived repositories included. We combined that with container image scans and cloud inventory.
The goal wasn't a list of everywhere Java appears. It was a list of the places where runtime verification is needed, sorted by how strong the evidence is:
Notice that "hardware we can't see" lands in likely exposed, not in a third, safer bucket. That's deliberate.
Our Java4Shell response combines repository, container and cloud evidence to identify where runtime verification is needed. Repository evidence alone cannot confirm the deployed JVM, CPU capabilities or whether untrusted input reaches the affected decoder.
Missing runtime evidence means unknown, not cleared.
A repository tells you a lot about Java. It tells you very little about the JVM that runs it.
pom.xml or build.gradle sets the language level you compile against. It doesn't fix the runtime. A service built for Java 17 can run on a 21 image, and a FROM eclipse-temurin:21 tag moves every time the image is rebuilt.JAVA_TOOL_OPTIONS variable outside the repository.Authorization: Basic headers is a strong signal, but whether it ends up in the affected decoder depends on the library and the request path. A static match is a lead, not a verdict.That's why we keep "likely exposed" and "to confirm" separate. One means the evidence points at exposure. The other means the evidence doesn't rule it in or out. Neither means safe.
Run these on the host or inside the running container, not on a build machine.
``bash java -version `` Look for HotSpot (or a HotSpot-based distribution) and a version on the 17.0.6+, 21, 25 or 27 lines.
``bash grep -o -w -E 'avx512f|avx512bw|avx512vbmi|bmi2' /proc/cpuinfo | sort -u `` All four flags means the vulnerable code path can run. On ARM64 (for example AWS Graviton), the vulnerable x86 code doesn't run.
``bash java -XX:+UnlockDiagnosticVMOptions -XX:+PrintFlagsFinal -version | grep -E 'UseBASE64Intrinsics|UseAVX ' ``
Authorization: Basic headers, file uploads or message payloads.OpenJDK says the issue is fixed in its November 17 release, and Oracle has shipped its Critical Security Patch Update. We aren't naming fixed builds here. Each distribution (Eclipse Temurin, Amazon Corretto, Azul Zulu, Red Hat and others) ships on its own schedule, so confirm the fixed build in your vendor's own advisory before you call a service patched.
Until then, Calif and VulnCheck describe two JVM-flag workarounds that VulnCheck says stopped the overflow in its tests on OpenJDK 17, 21 and 25:
-XX:+UnlockDiagnosticVMOptions -XX:-UseBASE64Intrinsics.-XX:UseAVX=2. Calif warns that ARM builds of OpenJDK won't start with this flag, so only set it on x86-64 hosts.Either flag changes performance characteristics, so roll it out like any other JVM change. After you patch, restart: a new JDK on disk does nothing for a JVM that's already running.
For a runtime-level bug, the work is getting from "we run Java" to a short list of services, owners and the exact evidence that's still missing. That's what triage and remediation does: it joins repository, container and cloud evidence, ranks the services where exposure is most likely first, and says plainly where it can't see.
What it can't do is read a CPU flag on a host it has no access to, or watch a live request reach the decoder. Those checks stay with the team that runs the service. We'd rather hand you an honest "unknown" than a confident "clear."
Java4Shell is the name for CVE-2026-114938, a heap overflow in HotSpot's hardware-accelerated java.util.Base64 decoder on x86-64 CPUs with AVX-512 VBMI. OpenJDK and Oracle disclosed it on November 17, 2026, with a CVSS 3.1 score of 8.1. It can be triggered without authentication.
OpenJDK lists Java 17, 21, 25 and 27 as affected, and Calif says the vulnerable code arrived in 17.0.6. OpenJDK lists Java 8 and 11 as unaffected. The bug also needs an x86-64 CPU with AVX-512 VBMI, so ARM64 hosts are not affected.
VulnCheck said it isn't known to be exploited in the wild as of November 17, 2026, and CISA hadn't added it to the KEV catalog as of November 18. A public proof of concept triggers the overflow, so treat internet-facing exposure as urgent anyway.
Only partly. A repository shows which services use Java and roughly which version. It can't confirm the deployed JVM, the CPU it's scheduled on, or whether untrusted Base64 reaches the decoder. Treat services you can't verify at runtime as unknown, not cleared.
Calif and VulnCheck describe two JVM flags: disabling the Base64 intrinsic with -XX:-UseBASE64Intrinsics, or disabling AVX-512 with -XX:UseAVX=2 on x86-64 only. Confirm the fixed build for your Java distribution in its own advisory, then patch and restart.