After PHP2Shell and HTTP2Shell, only Java was missing to complete the set. Well, here it is: Java4Shell (CVE-2026-114938), published yesterday by the same team, Calif, in a very detailed report. Oracle and OpenJDK released the patches at the same time, so this time there’s no need to juggle mitigations while waiting for the fix… although the mitigation is worth knowing anyway.
Where the bug is
The curious thing about this bug is where it lives. It isn’t in the Java code of java.util.Base64, which is perfectly correct, but in an optimisation: HotSpot has an intrinsic, a piece of hand-written x86-64 assembly, that the C2 JIT compiler uses instead of the Java code to decode Base64 much faster with AVX-512 instructions.
That assembly gets certain malformed inputs ending in = wrong: it computes a negative output length and writes 64 bytes where it should write fewer, trampling whatever objects sit next to it on the heap. Java then rejects the input as invalid, but the damage is already done. It’s like the security guard telling you that you can’t come in… when you’re already inside.
For it to happen, three things are needed:
- An x86-64 processor with AVX-512 VBMI: Intel Ice Lake, Sapphire Rapids or later, or AMD Zen 4 onwards. In other words, a good share of modern cloud servers. ARM is not affected.
- The decoder has to be JIT-compiled, which the attacker easily achieves by sending lots of valid requests before the real one.
- The application has to decode Base64 that comes from the attacker. And here’s the serious part: Base64 is everywhere. Authentication headers, tokens, uploaded files, network messages…
Which applications
Calif demonstrates unauthenticated remote code execution in Keycloak, Jira, Confluence, JFrog Artifactory, Jenkins and PingFederate, and authenticated RCE in Kafka, Solr, Elasticsearch, Gerrit and Spinnaker. Also in sample applications built with Struts and Spring Boot, and there’s a client-side variant: a Java program opening a TLS connection to a malicious server can also be compromised.
There are some reassuring nuances: there’s no universal exploit, because each application needs its own heap preparation, and Calif won’t publish the product-specific attack chains until people have had time to update. But the list above is almost an inventory of what runs in any medium-sized company.
Which versions
According to Calif, the bug affects OpenJDK from 17.0.6 onwards, and with it every distribution built from OpenJDK: Temurin, Corretto, Zulu, Liberica, Microsoft, Red Hat, SapMachine, GraalVM… The OpenJDK advisory flags it in four release trains, and Oracle’s patch came out the same day. These are the last vulnerable versions listed in the advisory, so you need to be on a later one:
| Train | Vulnerable up to |
|---|---|
| 17 | 17.0.21.0.3 |
| 21 | 21.0.13.0.3 |
| 25 | 25.0.5.0.3 |
| 27 | 27.0.1.0.3 |
Each distribution publishes its own versions with its own numbering, so the practical thing is to check the advisory of the one you use. As for severity, Calif gives it 9.2 on CVSS 4.0 and OpenJDK 8.1 on CVSS 3.1.
If you can’t update yet
The first thing is to find out whether the processor has the required instructions. On Linux, if this command returns all four, the machine is a candidate:
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
And the mitigation is to disable the intrinsic when starting the JVM, so the normal Java code is used (slower, but correct):
java -XX:-UseBASE64Intrinsics -jar application.jar
The other option they give is -XX:UseAVX=2, which disables AVX-512 entirely, but it affects much more than Base64 and on ARM the JVM won’t even start with it. If you use containers, watch where you put the option: JAVA_TOOL_OPTIONS is usually the most convenient, because the JVM reads it without touching the start command. And in the cloud, the fact that today’s machine doesn’t have AVX-512 doesn’t mean tomorrow’s won’t.
The AI part
As with PHP2Shell, Calif used AI to find the bug and to exploit it. Quang Luong, who led the research, says he asked Codex to review the sensitive parts of HotSpot “like any serious security researcher in 2026”. Most of the early results were false positives, but by insisting this one showed up. One hour to find it, two more to have the first working exploit, and less than 200 dollars in tokens. The later chains against specific applications, they say, were built “almost autonomously”.
This is the figure that makes me think the most. Hand-written assembly to speed up specific operations is about the hardest code there is to review, and precisely for that reason it’s where the fewest eyes have looked. That it can now be audited for 200 dollars is good news for defenders, who can do the same with their own code, and bad news for everything that has gone years without anyone looking at it. Which is, to be honest, most of the code we use.
So if you have Java in production (and almost everyone has some Jenkins, Keycloak or Elasticsearch lying around), it’s time to update the JDK, check that the Docker images really ship the new version, and meanwhile add -XX:-UseBASE64Intrinsics to whatever can’t be touched today.




