This is a developing story. We will update this post as JDK vendors ship fixed builds and as exploitation details change. Last updated November 19, 2026, 12:30 UTC.
TL;DR
- Java 17.0.6 and later is exposed on x86-64 CPUs with AVX-512 VBMI (Intel Ice Lake, AMD Zen 4 and newer). ARM64, older x86-64 CPUs and OpenJDK 8 and 11 are not known to be affected.
- Calif, which found the bug, reports pre-authentication code execution in default Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate.
- Attackers are already sending Java4Shell-shaped requests. GreyNoise has not seen a successful intrusion yet.
- Oracle fixed 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1. Amazon Corretto, Eclipse Temurin and Ubuntu have shipped fixed builds, while Debian stable and RHEL packages are still waiting. Java 18 to 20, 22 to 24 and 26 will never get a fix.
- Shodan sees about 954,700 internet-facing hosts running Java, 38% of them on AWS.
On November 17 at 21:00 UTC, Oracle and the OpenJDK project shipped fixes for CVE-2026-114938. Thirteen minutes later Calif published its write-up and named the bug Java4Shell. The flaw sits in hand-tuned machine code that OpenJDK uses to decode Base64 quickly, and that code has shipped in every Java release since 17.0.6, which came out in January 2023.
Calif researcher Quang Luong found the bug with AI assistance in about an hour and had a working exploit two hours later, for under $200 in model costs. Calif used the same human-plus-AI approach for PHP2Shell a month earlier, and is holding back its product-specific exploits for now.
Two things make Java4Shell different from the usual Java CVE. Java is supposed to be memory safe, and this is a memory-corruption bug inside the standard library. And whether a server is exploitable depends on the CPU it runs on, which almost no inventory records. This post explains how the bug works, how far it reaches, what attackers are doing with it, and how to find and fix every exposed JVM.
Java4Shell status: what is confirmed
Confirmed
- CVE-2026-114938 (Oracle as CNA, CVSS 3.1 8.1) is memory corruption in the OpenJDK Base64 decoder that lets an unauthenticated remote attacker run code on Java 17.0.6 and later. Per Red Hat it needs an x86-64 CPU with AVX-512 VBMI (Intel Ice Lake or AMD Zen 4 and newer); ARM64 and older x86-64 CPUs are not known to be affected, and OpenJDK 8 and 11 are not affected. (source)
- Red Hat reports that pre-authentication remote code execution has been demonstrated against widely deployed Java applications in default configurations. (source)
- CISA published an alert on November 17, 2026 that strongly urges organizations to immediately patch CVE-2026-114938 (Java4Shell). (source)
- Amazon Linux shipped fixed Corretto 17, 21, 25 and 27 packages for Amazon Linux 2023 on November 17 (ALAS2023-2026-3478 to 3481), plus Corretto 17 for Amazon Linux 2. Corretto 22, 23, 24 and 26 are marked No Fix Planned, and Corretto 8 and 11 Not Affected. (source)
Reported
- Oracle's first fixed releases are 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1, per Datadog's reading of Oracle's advisory. (source)
The ratings disagree. Oracle, the CNA, scores the bug 8.1 under CVSS 3.1 and calls it difficult to exploit. Calif scores it 9.2 under CVSS 4.0, Red Hat rates it Critical with a CVSS 3 score of 9.8, and Amazon rates it Important.
As of catalog version 2026.11.18, CISA had not added CVE-2026-114938 to the Known Exploited Vulnerabilities list.
How the Java4Shell bug works

Java checks every array access, which is why Java code rarely has memory-corruption bugs. The JVM itself is a different story. HotSpot carries hand-written machine code for some hot library methods and picks the version that fits the CPU it finds. For java.util.Base64.Decoder on x86-64 CPUs with AVX-512 VBMI, it picks a vector routine that decodes many bytes at once.
Calif found that this routine mishandles a stray padding character. It computes a negative output length and then writes a full block past the end of the output array, corrupting the objects next to it. Java rejects the input afterwards, but the damage is already done. Calif turns that overwrite into a Heartbleed-style memory leak and then into remote code execution.
On ARM64 and on older x86-64 CPUs, the JVM runs a different routine and never touches the vulnerable code. No setting turns the AVX-512 path on, so Red Hat calls affected systems vulnerable out of the box.
Who is exposed to Java4Shell
A server is exposed when three things line up: an affected Java build, a CPU with AVX-512 VBMI, and an application that decodes Base64 an attacker controls. The third condition is easier to meet than it sounds. Red Hat lists HTTP Basic credentials and SAML messages, which services decode before authentication completes, and Calif adds file uploads. Datadog found that in its tests the plain and URL-safe decoders hit the vulnerable path while the MIME decoder did not, so the exact call matters.
Servers are not the only target. Calif reports a client-side exploit, shared by samczsun, that compromises a Java program when it opens a TLS connection to a malicious server, even if the program listens on no port.
How deep Java4Shell goes
Calif's list of products with code execution in their default configurations reads like a map of enterprise infrastructure: Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate before authentication, plus Kafka, Solr, Elasticsearch, Gerrit and Spinnaker once an attacker has a login. Calif also reached sample Struts and Spring Boot applications and calls its lists non-exhaustive. Every product that runs on an affected JVM inherits the bug, whether or not its own code changed.
The internet-facing footprint is large. On November 18, Shodan fingerprinted about 954,700 hosts as running Java, led by Jetty, Tomcat and Jenkins.

The cloud is where the CPU question bites. Of those Java hosts, 364,810 (38%) run on AWS, followed by Azure, Linode, Google Cloud and Oracle Cloud. Intel Ice Lake and AMD Zen 4 and every generation after them have AVX-512 VBMI, so the newer the instance type, the more likely the JVM on it takes the vulnerable path. Containers blur the picture further: an image has no CPU until the scheduler places it on a node.

The version map makes the fix lines plain. Four Java lines get fixed builds, and every end-of-life release since 17.0.6 carries the bug with no fix coming.

Are attackers exploiting Java4Shell?
Attackers are already trying. GreyNoise tracks requests whose Authorization header carries the shape of the Java4Shell trigger.
GreyNoise has recorded 187 Java4Shell-shaped requests from 5 IPs since November 17 and 0 successful intrusions (updated November 19, 11:48 UTC). GreyNoise notes that exploits must be tailored to each application, which slows mass exploitation until someone publishes exploit code for a popular product. No vendor has named a threat actor or a campaign yet.
The exploit side is moving fast. Calif built its first exploit in about two hours with AI assistance and is withholding the product-specific chains, and Wiz reports building its own. Expect product exploits to follow, and patch before they do.
How to check your Java services
Find the Java version each service runs. Run this inside the container or on the host:
java -version 2>&1 | head -1Java 17.0.6 and later is affected up to the last builds the OpenJDK advisory lists: 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3 and 27.0.1.0.3. Every build of Java 18, 19, 20, 22, 23, 24 and 26 is affected too. When we checked the OpenJDK source, the vulnerable decoder first appears in 17.0.6 and is present in each of those releases. OpenJDK 8 and 11 are not affected, but Oracle lists its Java SE 8 Performance Pack as affected.
Then check the CPU the JVM runs on. On Linux:
grep -qw avx512vbmi /proc/cpuinfo && echo "CPU has AVX-512 VBMI: exposed" || echo "No AVX-512 VBMI on this CPU"Run it on the node or VM, not only in your build pipeline. In Kubernetes, a container sees its node's CPU, so the result covers the pods on that node today and says nothing about the next node a pod lands on.
How to fix Java4Shell
Upgrade to your JDK vendor's first fixed build, then restart every Java process and rebuild every image that bundles a JDK. A running JVM keeps the old code until it restarts. Oracle's fixed releases are 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1. Where the main sources stand on November 19:
- Amazon Linux 2023: install the fixed Corretto packages from ALAS.
- Eclipse Temurin: fixed 17.0.21.1, 21.0.13.1 and 25.0.5.1 builds are out.
- Ubuntu: fixed openjdk-17, openjdk-21 and openjdk-25 packages are out for every release that ships them (tracker).
- Debian: fixed only in unstable. Bookworm, trixie and forky are still listed as vulnerable (tracker).
- Red Hat: fixed portable builds of 17, 21 and 25 and Windows builds of 17 and 21 are out, but the RHEL 8, 9 and 10 packages are still listed as affected (CVE page).
Container images lag behind the JDK builds. On November 19 the eclipse-temurin:21 tags on Docker Hub still carried Java 21.0.13, which is inside the affected range, so rebuilding on the latest tag may not pick up the fix yet. Check the version inside the rebuilt image before you ship it. Move services on Java 18, 19, 20, 22, 23, 24 or 26 to Java 21, 25 or 27.
Patch in this order:
- Internet-facing Java services on x86-64 hosts with AVX-512 VBMI, starting with the products Calif names.
- Internet-facing containers on clusters whose nodes you have not checked.
- Everything else on an affected build, including hosts on older CPUs. A resize or a node pool upgrade can move them onto exposed hardware later.
Workaround if you cannot upgrade yet
Red Hat's preferred interim mitigation is to start the JVM with -XX:-UseBASE64Intrinsics, which turns off the accelerated Base64 path and leaves other AVX-512 optimizations in place. Red Hat also offers -XX:UseAVX=2, but ARM64 JVMs do not recognize that flag and fail to start, which makes it risky for multi-architecture images. In our tests, an ARM64 JVM started normally with -XX:-UseBASE64Intrinsics.
The simplest way to set it everywhere is the JAVA_TOOL_OPTIONS environment variable, which the JVM reads at startup. This line keeps any options you already set:
export JAVA_TOOL_OPTIONS="${JAVA_TOOL_OPTIONS:+$JAVA_TOOL_OPTIONS }-XX:-UseBASE64Intrinsics"In Kubernetes, set it on the container. If the container already sets JAVA_TOOL_OPTIONS, add the flag to that value instead:
env:
- name: JAVA_TOOL_OPTIONS
value: "-XX:-UseBASE64Intrinsics"The JVM prints Picked up JAVA_TOOL_OPTIONS: -XX:-UseBASE64Intrinsics to stderr at startup. To check a JVM that is already running, pass its process id to jcmd, which prints the flag only when the process started with it:
jcmd <pid> VM.flags | tr ' ' '\n' | grep -w -e -XX:-UseBASE64IntrinsicsRestart the process for the flag to take effect, and keep it only until you install the fixed build.
How ZEST handles Java4Shell
ZEST matched every Java install its integrations report against the affected ranges, per branch, and marked distribution builds as waiting on the distribution and end-of-life lines as having no fix. For hosts it could reach, it read the live instance type and validated which ones have a CPU that can trigger the bug. Affected systems that no scanner reported yet got vulnerabilities of their own, flagged as a zero-day, and each customer gets a link to every affected system in ZEST. We ran the same playbook for HTTP2Shell and PHP2Shell.
Java4Shell FAQ
Is Java 8 or Java 11 affected?
OpenJDK 8 and 11 are not: Red Hat says they do not contain the vulnerable code path. The exception is Oracle's Java SE 8 Performance Pack (8u511b33-perf), which Oracle lists as affected.
Are ARM64 servers such as AWS Graviton affected?
They are not known to be affected. Patch them anyway: the fixed build is the same, and a multi-architecture image can run on x86-64 tomorrow.
Does the workaround replace the patch?
No. -XX:-UseBASE64Intrinsics removes the vulnerable code path only in JVMs that start with it, and one JVM started without the flag is still exposed.
Is Java4Shell exploited in the wild?
Attackers are sending Java4Shell-shaped requests, and Red Hat says pre-authentication code execution has been demonstrated against default configurations. Treat internet-facing services as exposed and patch them first.
Sources
About The Author
.jpg)




