On Tuesday, November 17, Oracle released fixes for Java4Shell (CVE-2026-114938), a critical flaw in the Java runtime that underpins a large share of enterprise software. Researchers at Calif showed that, on affected servers, an attacker with no account could take control of default installations of Atlassian Jira and Confluence, Jenkins, Keycloak, JFrog Artifactory, and PingFederate, and could also read sensitive data such as session tokens and private keys from memory. CISA is strongly urging organisations to patch immediately.
The flaw is not in any of those applications. It is in Java itself, so updating Jira or Jenkins does not fix it; the Java runtime underneath them has to be updated and every Java service restarted. That makes this a broad inventory exercise rather than a single patch, because Java is often bundled quietly inside third-party products, appliances, and container images. No attacks have been reported yet and there is no universal exploit, but researchers expect tailored attacks against high-value targets, and the systems most at risk are exactly the ones organisations depend on for identity, source code, and collaboration.
The name is a deliberate nod to Log4Shell, though the two are different in an important way: Log4Shell lived in a library that could be swapped out, while Java4Shell lives in the engine that runs the code.
Who is affected
Java versions
The flaw affects OpenJDK 17.0.6 and later, and every distribution built from that code. Oracle lists these affected builds:
- Oracle Java SE 17: 17.0.21.0.3
- Oracle Java SE 21: 21.0.13.0.3
- Oracle Java SE 25: 25.0.5.0.3
- Oracle Java SE 27: 27.0.1.0.3
- Java 8 Enterprise Performance Pack: 8u511b33-perf
- Oracle GraalVM for JDK 17 and 21, and GraalVM Enterprise Edition 21.3.20.0.3
BleepingComputer reports that distributions built from the affected code include Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, and Red Hat OpenJDK. At the time of writing, public reporting does not confirm fixed builds for those distributions, so check each vendor's advisory directly.
Standard Java 8 and Java 11 are not named as affected by Java4Shell, though Oracle's November update does include fixes for them covering other flaws, so they should still be updated.
Hardware
This is the unusual part. The vulnerable code only runs on x86-64 processors that support AVX-512 VBMI, a set of advanced instructions found in some Intel Xeon and newer AMD processors. Systems on ARM64, including AWS Graviton and Apple Silicon, are not affected through this code path, and neither are older x86-64 processors without that feature.
In practice, that is less reassuring than it sounds. Many current-generation servers and cloud instances support AVX-512 VBMI, and in virtualised and containerised environments the same workload can move between hosts with different processors. A container that is safe on one node may be exposed on the next. Treat every affected Java version on x86-64 as vulnerable unless you have confirmed the processor underneath it.
Applications
Calif demonstrated exploitation against the following in their default configurations:
| Access required | Applications |
|---|---|
| None (unauthenticated remote code execution) | Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, PingFederate |
| Valid login (authenticated remote code execution) | Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, Spinnaker |
| Sample applications | Apps built on Apache Struts and Spring Boot |
| Client side | A Java program compromised after connecting over TLS to a malicious server |
These results describe Calif's test setups, not every installation, and the list is not exhaustive. Any Java application that decodes Base64 data supplied by a user or a remote system could be reachable. Base64 is everywhere in modern software, appearing in login tokens, API payloads, file uploads, certificates, and authentication headers.
The client-side result deserves attention. It means a Java process does not need to be a server to be at risk; one that connects out to an attacker-controlled system, such as a build agent or integration service, could also be targeted.
How the flaw works
Base64 is a standard way of turning binary data into plain text so it can travel safely through web requests, emails, and configuration files. Java decodes it constantly.
To make that faster, the HotSpot virtual machine, which runs Java code in most OpenJDK distributions, replaces the normal Base64 decoding routine with a hand-optimised version (an "intrinsic") on processors that support AVX-512 VBMI. That optimised version processes many bytes at once. Calif found that, given specially crafted input, it can write past the end of the memory buffer it was given before Java gets a chance to reject the input as malformed.
By the time Java throws its error, the damage is done. Rejecting the input does not undo the memory corruption. Depending on what sits next to that buffer, the result can be:
- Remote code execution, if the attacker can shape memory in a way that redirects the program
- A crash of the Java virtual machine, taking the application down
- Memory disclosure, which the researchers compared to Heartbleed, potentially exposing session tokens, private keys, and other secrets
Because the flaw sits in the runtime, it does not matter how carefully an application validates its own data after decoding. The corruption happens inside Java's own decoder.
Why the severity scores differ
Calif rates the flaw 9.2 (Critical) under CVSS 4.0. Oracle rates it 8.1 (High) under CVSS 3.1 and describes it as a "difficult-to-exploit vulnerability." The two scores use different scoring standards, and the gap reflects a real trade-off: exploitation is not trivial, but when it works, it requires no account and gives full control.
Oracle notes that the flaw can only be exploited by supplying data to APIs in the affected component, for example through a web service. That matches Calif's position that there is no universal exploit. An attacker needs to find, for each application, a path that carries their Base64 data to the vulnerable decoder, and must account for the specific processor and Java build. watchTowr expects attacks to be tailored accordingly.
That should not be read as a reason to wait. Calif has already done that work for six widely deployed applications, and those are exactly the systems attackers prioritise.
Exploitation status
- No exploitation in the wild has been reported as of November 17.
- Calif has published a proof of concept for the memory corruption and a trigger pattern, but has not released its weaponised exploits.
- CISA issued an alert on November 17 strongly urging organisations to patch immediately.
- Rapid7 says it is actively monitoring and will update its guidance as new information arrives.
How the flaw was found is also worth noting. According to BleepingComputer, Calif researcher Quang Luong found it in about an hour while auditing OpenJDK internals with OpenAI's Codex coding assistant, then built a working exploit in roughly two more hours, at a total AI cost of under $200. Calif was also behind the recent PHP2Shell disclosures. The time and cost needed to find and weaponise deep, low-level bugs like this are falling quickly, and organisations should assume that others can reproduce this work now that the flaw is public.
Timeline
| When | What happened |
|---|---|
| September 10 | Oracle's Java update plan names November 17 as the next monthly release |
| Before November 17 | Reports of a 9.2-rated OpenJDK flaw circulate; the CVE record is reserved with no public description |
| November 17 | Calif publicly discloses Java4Shell |
| November 17 | Oracle releases fixes as part of its November Critical Security Patch Update, covering 655 vulnerabilities across its products |
| November 17 | CISA urges immediate patching |
What you should do
1. Find every Java runtime you run
This is the hardest step and the most important. Look beyond the obvious:
- Servers and virtual machines: check installed JDKs and JREs, and note that more than one version is often present.
- Bundled runtimes: many commercial products, including Atlassian Data Center, Jenkins distributions, identity platforms, and vendor appliances, ship their own Java runtime. Updating the system Java does not update these.
- Container images: base images and application images often pin a specific JDK. Scan your registries, not only your running clusters.
- Build and CI infrastructure: build agents, artifact repositories, and code review tools are high-value targets and frequently run Java.
For each running service, confirm the version used by the running process, not the host's default java command. On Linux, jcmd <pid> VM.version reports the version of a live JVM.
2. Prioritise by exposure and processor
Patch in this order:
- Internet-facing Java services, especially Keycloak, Jira, Confluence, Jenkins, Artifactory, and PingFederate, and any administrative interfaces
- Internal services that accept data from users or other systems, including Kafka, Solr, Elasticsearch, Gerrit, and Spinnaker
- Everything else
To check whether a Linux host's processor is in scope, look for avx512vbmi in /proc/cpuinfo. In mixed or autoscaling fleets, assume workloads can land on affected hardware.
3. Patch and restart
Install the fixed builds:
| Product | Fixed build |
|---|---|
| Oracle Java SE 17 | 17.0.21.1 |
| Oracle Java SE 21 | 21.0.13.1 |
| Oracle Java SE 25 | 25.0.5.1 |
| Oracle Java SE 27 | 27.0.1.1 |
| Java 8 Enterprise Performance Pack | November 17 update; confirm the build in Oracle's advisory |
| Oracle GraalVM for JDK 17, JDK 21, and Enterprise Edition | November 17 update for each |
| Corretto, Temurin, Microsoft, Zulu, Red Hat, and others | Check each vendor's advisory |
Then:
- Restart every Java process. The old, vulnerable code stays in memory until the process is restarted.
- Rebuild and redeploy container images rather than patching running containers.
- Ask your software vendors for updated builds of any product that bundles its own Java runtime, and for their guidance on interim mitigations.
- Re-check the running version afterwards to confirm the update took effect.
4. If you cannot patch immediately
These are temporary measures only. Remove them once you have patched.
- Disable the vulnerable routine by starting affected JVMs with
-XX:-UseBASE64Intrinsics. This turns off the optimised decoder and falls back to the standard, unaffected code. Expect a modest performance cost in Base64-heavy workloads. - On x86-64 only,
-XX:UseAVX=2disables AVX-512 entirely. Do not use this flag on ARM systems, where it can prevent Java from starting. - Restrict access to internet-facing Java services with firewalls, VPNs, or access controls until a fix is in place. watchTowr recommends this wherever patching is not possible.
- Limit input size and, where your application allows it, validate Base64 input before it reaches the decoder.
For bundled products, check with the vendor before adding JVM flags, as the place to set them varies, and some products manage their own startup options.
5. Watch for signs of attack
No indicators of compromise have been published beyond the CVE itself and the researchers' trigger pattern. CISA's guidance focuses on behaviour:
- Unexpected JVM crashes, particularly on exposed, unpatched systems. Crash files named
hs_err_pid*.logare worth reviewing. A crash alone does not prove exploitation, but an unexplained one on an exposed system warrants investigation. - Suspicious child processes spawned by Java services, such as shells or download tools.
- Unapproved or unexpected Java runtimes appearing in your environment.
The published trigger pattern is a long run of A characters followed by = in Base64 input, with older OpenJDK 17 builds needing a longer run. Unusually long, repetitive Base64 values in request logs, headers, or tokens are worth flagging, though attackers will vary their payloads, so do not rely on this pattern alone.
If a vulnerable, exposed system shows any of these signs, treat it as potentially compromised. Given the risk of memory disclosure, that includes rotating secrets held by the service, such as signing keys, session secrets, and API tokens, and invalidating active sessions.
A note on the pattern
Java4Shell is a reminder that the most serious risks often sit below the layer most organisations track. Application inventories, vulnerability scanners, and software bills of materials are usually built around the software a team chose to install. The runtime underneath, and the copies of it bundled inside other products, are easy to miss.
It also reflects a shift in how these flaws are found. A bug deep in a performance optimisation, affecting only certain processors, is exactly the kind of issue that once took specialist researchers weeks to find and exploit. Here it took hours, with an AI assistant, for a few hundred dollars. Defenders should expect more disclosures like this, and should expect the window between disclosure and exploitation to keep shrinking.
The practical lesson is the same as it was for Log4Shell: know where Java runs in your environment, know which version each process is actually using, and be able to update and restart all of it quickly. If finding the answer depends on a scramble every time a flaw like this appears, that capability is worth building now.
Summary
| Name | Java4Shell |
| CVE | CVE-2026-114938 |
| Component | HotSpot JVM hardware-accelerated Base64 decoder (intrinsic) |
| Flaw type | Memory corruption (out-of-bounds write) |
| Severity | 9.2 Critical (CVSS 4.0, Calif); 8.1 High (CVSS 3.1, Oracle) |
| Affected Java | OpenJDK 17.0.6 and later, including Oracle Java SE 17, 21, 25, 27; Java 8 Enterprise Performance Pack; Oracle GraalVM; and distributions built from affected code (Corretto, Temurin, Microsoft, Zulu, Red Hat) |
| Affected hardware | x86-64 processors with AVX-512 VBMI; ARM64 not affected |
| Impact | Remote code execution, JVM crash, memory disclosure |
| Demonstrated targets | Unauthenticated: Keycloak, Jira, Confluence, Artifactory, Jenkins, PingFederate. Authenticated: Kafka, Solr, Elasticsearch, Gerrit, Spinnaker |
| Exploitation | Not reported in the wild; memory corruption proof of concept public; weaponised exploits not released |
| Fixed builds (Oracle) | 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1; November 17 updates for Java 8 EPP and GraalVM |
| Workarounds | -XX:-UseBASE64Intrinsics; -XX:UseAVX=2 (x86-64 only); restrict network access |
| Discovered by | Quang Luong, Calif |
| Government guidance | CISA urges immediate patching |
Java4Shell does not need a flaw in your applications to reach them; it only needs them to run on an affected Java runtime on the right processor. Find every Java runtime you operate, patch and restart the exposed ones first, and apply the temporary workarounds wherever an update has to wait.
If you need help building a Java runtime inventory, prioritising exposed services, or investigating unexplained crashes on vulnerable systems, get in touch.