Nullify

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.

Java4Shell: Why Finding Java Doesn't Confirm Exposure

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?"

What is Java4Shell?

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:

  • Advisories: OpenJDK lists CVE-2026-114938 under 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.
  • Exploitation: VulnCheck says it isn't known to be exploited in the wild. Calif published a proof of concept that triggers the overflow and is holding back its full exploit chains. VulnCheck reports that denial of service is easy, and that remote code execution needs heap grooming plus a memory leak.
  • CISA KEV: not listed as of November 18.

What has to be true for a JVM to be exposed?

Each condition comes from the advisories and Calif's writeup. Each one also lives in a different place.

ConditionWhat has to be trueWhere the evidence lives
JVMHotSpot with the Base64 intrinsic enabledThe running JVM's build and flags
Java lineOpenJDK 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
CPUx86-64 with AVX-512 VBMI (Linux flags avx512f, avx512bw, avx512vbmi, bmi2). ARM64 is not affected.The host the JVM is scheduled on
InputUntrusted Base64 reaches java.util.Base64's decoderThe 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.

What we found across customer environments

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:

  • Likely exposed: a Java 17+ runtime that serves traffic, on x86 hardware that is AVX-512 VBMI capable or that we can't see, and that is internet-facing or handles tokens or HTTP Basic auth.
  • To confirm: the same runtime and hardware conditions, but with no evidence of internet exposure or auth handling.

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.

Why the repository can't answer the question

A repository tells you a lot about Java. It tells you very little about the JVM that runs it.

  • The Java line is a hint, not a fact. A 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.
  • The CPU isn't in the image at all. A container image carries the JVM, not the processor. The same image is exposed on an Ice Lake node and safe on an ARM64 node. If a node pool mixes instance families, the same service can be both at once.
  • The JVM vendor and flags are set at deploy time. HotSpot vs. another VM, and whether the Base64 intrinsic is switched off, often live in an entrypoint script, a Helm value or a JAVA_TOOL_OPTIONS variable outside the repository.
  • Reachability is a runtime property. Code that parses tokens or 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.

How to check your own exposure

Run these on the host or inside the running container, not on a build machine.

  1. Confirm the JVM and version.

``bash java -version `` Look for HotSpot (or a HotSpot-based distribution) and a version on the 17.0.6+, 21, 25 or 27 lines.

  1. Confirm the CPU. On Linux:

``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.

  1. Check whether the intrinsic is on.

``bash java -XX:+UnlockDiagnosticVMOptions -XX:+PrintFlagsFinal -version | grep -E 'UseBASE64Intrinsics|UseAVX ' ``

  1. Find where untrusted Base64 is decoded. Start with internet-facing services, then anything that parses bearer tokens, Authorization: Basic headers, file uploads or message payloads.
  2. Record what you couldn't see. If a service runs on a node pool you can't inspect, mark it unknown and keep it in the queue.

What to do while fixed builds are confirmed

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:

  • Disable the Base64 intrinsic: -XX:+UnlockDiagnosticVMOptions -XX:-UseBASE64Intrinsics.
  • Disable AVX-512: -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.

How Nullify helps

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."

FAQ

What is Java4Shell?

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.

Which Java versions are affected by Java4Shell?

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.

Is Java4Shell being exploited in the wild?

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.

Can a dependency or repository scan tell me if I'm exposed to Java4Shell?

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.

How do I mitigate Java4Shell before patching?

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.

References