Skip to content
Threat landscape

Java4Shell: the CPU decides whether Java is vulnerable

Java4Shell (CVE-2026-114938) hits OpenJDK 17.0.6 and later only on x86 servers with AVX-512 VBMI. Which JDKs have a fix, and what helps until then.

  • by blacklens.io Team
  • Published
  • 6 min read
Diagram: below a processor symbol, a write runs past the end of a green buffer into red neighbouring cells

Since the evening of 17 November 2026 there have been updates for Java4Shell, a flaw that has been in OpenJDK since release 17.0.6. Even so, only some systems are vulnerable. The same application on the same JDK can be attacked on one server and not on the next, because the faulty code runs only on certain processors. Whether an affected system can be patched today depends in turn on who supplies its JDK.

What is Java4Shell?

Java4Shell is the name under which the security company Calif.io published CVE-2026-114938 on 17 November 2026: an out-of-bounds write in the Base64 decoder of OpenJDK's HotSpot JVM. For processors with AVX-512, HotSpot ships a hand-written assembly routine, and that is where the bug sits. If an input ends in an incomplete block with the padding character =, the routine calculates a negative remaining length and writes a full block of 64 bytes, in Calif's example 62 of them past the end of the buffer. Java then rejects the input as invalid. By that point neighbouring objects in memory have already been overwritten.

According to Calif, 64 times A followed by one = is enough to trigger it; on OpenJDK 17 it takes 128 times A. Those involved do not agree on severity. Oracle rates the flaw in the CVE record at CVSS 8.1 under version 3.1 and calls it "difficult to exploit". Calif arrives at 9.2 under version 4.0, and Red Hat provisionally at 9.8.

Three conditions: version, processor, decoder

A JVM is vulnerable only when three conditions hold at once:

  • The version: OpenJDK 17.0.6 and later in the 17, 21, 25 and 27 lines, whoever the vendor. The standard builds of Java 8 and 11 do not contain the routine. The one exception in the CVE record is Oracle's Java 8 Enterprise Performance Pack 8u511b33-perf.
  • The processor: x86-64 with the AVX-512 VBMI instruction set extension, which mainly means Intel Xeon from the Ice Lake generation onwards and AMD EPYC and Ryzen from Zen 4 onwards. On ARM64 and on older x86 processors the JVM takes a different code path that does not contain the bug.
  • The decoder: the application has to pass untrusted data to Base64.getDecoder() or Base64.getUrlDecoder(). Before authentication this happens, according to Upwind, in HTTP Basic auth in Spring Security, Tomcat and Jetty 12, and in the java-jwt library.

The second condition changes the stocktake: a list of Java versions no longer answers the question of exposure on its own. In the cloud, Red Hat names the AWS families C6i, M6i and C7i, Google's C3 and N4 and Azure's D-series v5 to v7 among those most likely to be affected; ARM instances such as Graviton are not. When a workload moves to a different instance type, the answer changes. The routine also becomes active only once the JVM has compiled the decoder after frequent use, so a single test call does not trigger the bug.

Processor and JVM can both be checked on the system itself:

grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
java -XX:+PrintFlagsFinal -version | grep -E 'UseAVX|UseBASE64Intrinsics'

If the first command prints all four flags, the processor meets the condition. If UseAVX is also above 2 and UseBASE64Intrinsics is true, the faulty path is live in that JVM.

How far the attack goes

What has been shown publicly so far is a JVM crash; Calif and a few other researchers report code execution without publishing their exploits. Calif says it executed code without authentication in the default configurations of Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate, and after authentication in Kafka, Solr, Elasticsearch, Gerrit and Spinnaker. By its account there is no universal exploit: every target needs its own preparation of the heap, and a failed attempt can crash the JVM.

Other labs confirm the bug and are more cautious about its consequences. VulnCheck reproduced it on Ice Lake hardware and calls the crash "trivial" once an input reaches the decoder; code execution, it says, requires non-trivial heap grooming and a target-specific memory leak. At the same time VulnCheck says it already offers its customers a full exploit.

No attacks in the wild are known as of 18 November. The Canadian Centre for Cyber Security says in its alert of 17 November that it is not aware of active exploitation, and the flaw is not in the CISA KEV catalogue. CISA nevertheless urges immediate patching in an alert of its own.

Calif says it found the flaw with AI, as it did PHP2Shell in October: one hour to the finding, two more to the first working exploit, at a cost of under 200 US dollars. The effort per target, on which the cautious assessments rest, is therefore smaller than it used to be. That trend has been apparent since April.

Who already has a fix – and who does not

As of 18 November, Oracle, Amazon and Azul ship a fix; Eclipse Temurin, Red Hat and Debian have not yet published a corrected build.

JDKRelease with the fixStatus on 18 November
Oracle Java SE17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1, 8u513-perfsince 17 November
Amazon Corretto17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2, 27.0.1.1.4since 17 November
Azul Zulu17.70.201, 21.54.201, 25.38.201, 27.30.201since 17 November
Eclipse Temurinnone yetlatest releases 17.0.21+9, 21.0.13+9, 25.0.5+8
Red Hat (RHEL 8, 9, 10)none yeterrata announced, bulletin RHSB-2026-018
Debiannone yetopenjdk-17, -21, -25 and -27 listed as "vulnerable"

Two things are easily missed during the check. The corrected OpenJDK releases differ only in the fourth position: 17.0.21.1 contains the fix, 17.0.21 does not. And many Java applications bring their own runtime. According to CISA, JDKs inside third-party applications, container images and appliances often do not appear as separate entries in software inventories. Red Hat advises applying the start-up option or the update through the vendor there, rather than replacing the bundled JVM yourself.

What to do now

The order follows from the three conditions:

  • Inventory the runtimes, with vendor and full build number, including those inside applications, container images and appliances. Internet-facing services come first, login services above all.
  • Update where a fix exists, and restart the process. jcmd <PID> VM.version shows which release is actually running.
  • Otherwise switch off the code path. Red Hat recommends -XX:-UseBASE64Intrinsics; VulnCheck, Datadog and Upwind have tested that the overflow no longer occurs with it. -XX:UseAVX=2 turns off AVX-512 altogether and belongs on x86-64 only: a JVM on ARM will not start with it.
  • Test start-up options before rolling them out. -XX:DisableIntrinsic=_base64_decodeBlock, which is also circulating, stops the JVM from starting when set on its own, according to Upwind.
  • Watch for signals: bursts of IllegalArgumentException from java.util.Base64, unexplained hs_err_pid*.log files and restarts. None of these proves an attack.

What does not help: size limits on the reverse proxy. Depending on the version, the triggering input is only 65 or 129 characters long.

What helps – and why visibility decides

The question on the day of an update like this is not how to update Java, but where a JVM is running at all. Through Attack Surface Management, blacklens.io continuously discovers from the outside which services, web applications and technologies are reachable; internal systems are covered by the Sentry Agent. The Threat Center matches new CVEs such as CVE-2026-114938 against that inventory in real time and shows for each hit whether it rests on the exact version or only on the product.

With Java4Shell the limit is clear: which processor sits beneath a JVM, and which JDK an application bundles, is not something any service reveals from the outside. That check stays on the system. What can be narrowed down from the outside is where it is needed first.

Frequently asked questions

Java4Shell is the name for CVE-2026-114938, an out-of-bounds write in the Base64 decoder of OpenJDK's HotSpot JVM. The security company Calif.io published the flaw on 17 November 2026, and Oracle fixed it the same day. A crafted Base64 value makes the decoder write past the end of its output buffer. The result can be a JVM crash and, according to Calif, remote code execution without authentication. Oracle rates the flaw CVSS 8.1, Calif 9.2 under version 4.0.

Share

More articles

See your attack surface within 24 hours.

We set up your workspace and walk you through the first findings.

  • 14 days free, all features
  • No credit card required
  • We walk you through your first findings