Creuto is now an OpenAI Select Partner Read More
Java4Shell needs three things at once: JDK 17.0.6+, an x86 CPU with AVX-512 VBMI, and untrusted Base64 input. Sort your fleet into patch, flag or skip.

Most of your Java fleet is probably not exposed to Java4Shell, and three checks are enough to show which part is. Java4Shell (CVE-2026-114938) only becomes reachable when three conditions hold on the same JVM: an affected JDK build, an x86-64 CPU with AVX-512 VBMI, and attacker-controlled input reaching java.util.Base64. By the end of this post you will know how to sort every service into patch now, flag now or not affected, and which of those answers can change without anyone touching a deploy.
Calif disclosed the bug on 17 November 2026, the same day OpenJDK published an advisory and Oracle shipped its patch. CISA issued an alert the same day asking organisations to inventory Java installations and patch internet-facing systems first.
| Fact | Detail (as of 18 November 2026) |
|---|---|
| CVE | CVE-2026-114938, a memory-corruption bug in the HotSpot x86-64 Base64 decoder intrinsic |
| Severity | 9.2 under CVSS 4.0 (Calif); 8.1 under CVSS 3.1 with high attack complexity (Oracle) |
| Affected lines | OpenJDK 17.0.6 and newer, 21, 25, 27; Oracle Java SE 8u511b33-perf only |
| Hardware | x86-64 with AVX-512 VBMI; ARM64 not affected |
| Exploited in the wild | No reports as of 17 November; not in CISA KEV |
Java4Shell is an out-of-bounds write in a hand-tuned assembly fast path that HotSpot substitutes for the Base64 decoder once the method is hot. According to Calif's write-up, the intrinsic miscalculates its store mask on certain padding patterns, so for a 65-byte input the decoder allocates a 50-byte buffer and writes 62 bytes past its end. The trigger on current builds is 64 A characters followed by a single =.
That is why the version of Java alone does not answer the question. The vulnerable code only runs when the CPU offers the instructions the intrinsic uses and when the JIT has compiled the decoder into that fast path. Each of the three checks below removes a large slice of a typical fleet.
OpenJDK 17.0.6 and newer, plus the 21, 25 and 27 release lines, carry the vulnerable code. OX Security states that standard Java 8 and Java 11 builds, and Java 17.0.0 to 17.0.5, do not contain it. The one Java 8 exception is Oracle's Enterprise Performance Pack build 8u511b33-perf, which Tenable notes is the only Java 8 build Oracle lists.
Downstream builds count too. Calif names Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat OpenJDK and Oracle GraalVM among the distributions built on affected code. Fixed version numbers differ by vendor; our sibling post on patched builds covers them, and so far our sources confirm only Oracle's and Corretto's.
Check the running process, not the package list. Qualys warns that many products and container images bundle their own JDK, which OS updates never touch, and CISA adds that such runtimes may not appear as separate inventory entries. Jenkins, Jira or Keycloak running from a vendor image is a Java service even if nobody on your team writes Java.
Exposure requires an x86-64 processor with AVX-512 VBMI. Calif names Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids, and AMD Zen 4 or newer. On Linux, this command from Calif's advisory must print all four flags for the host to qualify:
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
If you run on AWS or Google Cloud, the instance family tells you most of the answer before you log in. The table maps the processors each provider documents against Calif's list.
| Instance family | Documented processor | Java4Shell CPU condition |
|---|---|---|
| AWS M6i | Intel Xeon Ice Lake | Met |
| AWS M7i | Intel Xeon Sapphire Rapids | Met |
| AWS M8i, GCP C4, GCP N4 | Intel Granite Rapids | Met |
| AWS M7a, GCP C3D | AMD EPYC 4th generation (Genoa) | Likely met; confirm with the flag check |
| GCP N2 | Cascade Lake or Ice Lake | Depends on the host you land on |
| GCP N2D, C2D | AMD Milan (3rd generation) | Not met |
| AWS M6g, M7g, M8g; GCP T2A, C4A | Graviton, Ampere Altra, Axion (ARM64) | Not met |
Processor names come from the AWS general-purpose instance specifications and Google's CPU platforms page. AWS describes M7a as running 4th Generation AMD EPYC processors, code-named Genoa, with AVX-512 support, but AVX-512 alone is not VBMI, so run the flag check rather than trust the table.
The N2 row is the trap. Google documents that N2 machines with fewer than 96 vCPUs can run on Cascade Lake or Ice Lake depending on the zone default and any minimum CPU platform you set. Qualys makes the general point: a workload on an unaffected CPU today can land on an affected one after a resize or a hardware move. Treat a failed CPU check as a reason to patch later, not a reason to close the ticket.
The vulnerable path is the basic and URL decoders in java.util.Base64. OX's analysis excludes the MIME decoder and third-party Base64 libraries, and lists Basic auth, JWT, SAML and uploads as the typical carriers of untrusted input. Tenable reports that Kevin Breen of Immersive named Tomcat Basic authentication and the java-jwt library as paths that allow exploitation before login.
This check is the hardest to close by inspection, because the decode often happens inside a framework or library rather than your own code. Calif demonstrated pre-auth remote code execution in default configurations of Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate, and post-auth RCE in Kafka, Solr, Elasticsearch, Gerrit and Spinnaker. If a service accepts an Authorization header or a token, assume this condition is met unless you can show otherwise.
Combine the three answers and the queue sorts itself. Internet-facing order comes from CISA's guidance; the rest follows from which conditions hold.
-XX:-UseBASE64Intrinsics, disables the fast path and needs a restart; our sibling post on the JVM flag workaround covers the trade-offs.This kind of triage, where a vulnerability needs several conditions at once, is the same shape as the OpenSSH Alpine password bypass and its four conditions. Writing the conditions down per service is also what keeps vulnerability alert fatigue from turning a critical CVE into noise.
CISA's compensating controls include restricting and validating Base64 input at the application boundary and enforcing input-size limits. Qualys is blunter: input validation and size limits alone will not stop the bug, because the malformed input is very short. Calif's trigger is 65 bytes, so any size cap loose enough to admit normal tokens and headers admits it too. Use CISA's controls to reduce exposure while you patch, not as the fix.
The two scores are both legitimate. Oracle rates the flaw 8.1 under CVSS 3.1 with high attack complexity, a rating consistent with the hardware and JIT preconditions; Calif's 9.2 under CVSS 4.0 reflects what happens once those hold. OX estimates that of every 10,000 Java instances, about 2,200 run vulnerable code on affected hardware and roughly 12 are realistic RCE targets. Most of OX's gates are its own estimates, so read the figures as a reason to triage rather than a reason to wait.
As of 17 November, Tenable was not aware of exploitation reports, and the CVE is not in CISA's Known Exploited Vulnerabilities catalogue. That window is narrow. Breen says he has a working exploit that has not been released, and Calif is withholding its product-specific exploit chains only until users have had a chance to upgrade.
If you run Oracle JDK 21 rather than an OpenJDK build, read our note on the Oracle JDK 21 license change from 21.0.13 before you pull the fixed 21.0.13.1 build into production.
The checks are simple; the hard part is running them across every account, cluster and vendor image, including the JVMs nobody lists as Java. If you need the version, CPU and input-path answers collected per service, with patched runtimes rolled out through your pipelines and instance families pinned so the answer stays true, our DevOps and cloud engineering team can run that Java4Shell sweep with you, so your engineers stay on the patches themselves.
Java4Shell is CVE-2026-114938, a memory-corruption bug in the OpenJDK HotSpot Base64 decoder intrinsic on x86-64. Malformed Base64 padding makes the decoder write past its output buffer, which Calif showed can crash the JVM or lead to remote code execution in products such as Keycloak, Jira and Jenkins.
Java4Shell affects OpenJDK 17.0.6 and newer plus the 21, 25 and 27 release lines, including downstream builds such as Corretto and Temurin. Standard Java 8, Java 11 and Java 17.0.0 to 17.0.5 do not contain the vulnerable code; the only Java 8 exception is Oracle's 8u511b33-perf build.
Java4Shell does not affect ARM64 servers, including AWS Graviton, Ampere Altra and Google Axion, because the vulnerable code is an x86-64 intrinsic that needs AVX-512 VBMI. You should still patch ARM hosts on your normal cycle, since a workload can move to an affected x86 instance type later.
A Linux host meets the Java4Shell CPU condition only if /proc/cpuinfo lists all four flags avx512f, avx512bw, avx512vbmi and bmi2. Intel Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids, and AMD Zen 4 or newer, qualify; Cascade Lake, Zen 2 and Zen 3 do not.
As of 17 November 2026, Tenable reported no known in-the-wild exploitation of Java4Shell, and CVE-2026-114938 was not in the CISA Known Exploited Vulnerabilities catalogue. A researcher has claimed a working unreleased exploit, and Calif plans to publish its product exploit chains later, so that status may change quickly.
Java4Shell carries 9.2 under CVSS 4.0 from Calif and 8.1 under CVSS 3.1 from Oracle. Oracle rates attack complexity as high, which fits the hardware and JIT preconditions, while Calif's score reflects the impact once those conditions hold. Both point to patching internet-facing services first.
Ready to take the first step towards unlocking opportunities, realizing goals, and embracing innovation? We're here and eager to connect.