Blog

Java4Shell: Patch Java, But Check the Processor First

A heap overflow in Java’s Base64 decoder gives unauthenticated attackers code execution in Jira, Confluence and Keycloak, but only on servers whose processors support a specific set of vector instructions. Patch every affected Java runtime, and use the processor to decide which ones go first.

On November 17, 2026, the research firm Calif disclosed Java4Shell, CVE-2026-114938. It is a heap buffer overflow in the Base64 decoder that the HotSpot Java Virtual Machine (JVM) compiles for x86-64 processors. Calif researcher Quang Luong, with exploit improvements by Jenish Rakholiya, demonstrated unauthenticated remote code execution against default installs of Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins and PingFederate. 

Calif published a self-contained proof of concept that triggers the bug and is holding back the per-product exploit chains. Oracle’s CVSS 3.1 score for CVE-2026-114938 is 8.1 (High), and Calif scores it Critical, CVSS 4.0 9.2. CISA issued an alert the same day urging immediate patching. As of November 18, 2026, the vulnerability is not in CISA’s Known Exploited Vulnerabilities (KEV) catalog, and Calif reports no exploitation in the wild.

Patching Java fixes it. The vulnerable code exists only on processors that report four specific instruction-set features, so the same Java build is exploitable on an Ice Lake Xeon but not on the older server in the next rack. Use the processor to decide which systems to patch first. Internet-facing services running the affected Java version on a processor with all four features should be patched first. A workload’s processor can change underneath it when a virtual machine (VM) migrates to a newer host or a cloud instance changes type, so a server that is not vulnerable today can be vulnerable next week. Every affected Java runtime still needs the update.

Send the Java inventory and patching question to the application owners or platform engineering team. Ask for every Java runtime, its version, and patch status, including runtimes bundled inside applications and container images. Send the processor question to the infrastructure and virtualization team, and ask which hosts and VM configurations expose the four features. Ask detection engineering to alert on unexpected Java crashes on internet-facing services.

Why the processor decides if the bug is reachable

The JVM does not run every library method as ordinary Java code. For hot paths such as Base64 decoding, HotSpot substitutes hand-written machine code, called an intrinsic, and picks the version that matches the processor it finds at startup. On x86-64 processors that support Advanced Vector Extensions 512 (AVX-512) with the Vector Byte Manipulation Instructions (VBMI) extension, HotSpot decodes Base64 with a 512-bit path. Calif traced the overflow to that path, which “miscalculated the padded tail’s store mask, causing an out-of-bounds write.” On a processor without those features, HotSpot uses a different decoder, and the bug is not reachable.

Calif’s advisory lists four processor features that must all be present. Each is a bit the processor reports through the CPUID instruction, which is what the JVM reads at startup.

Feature flagWhat it isCPUID leaf 7 bit
bmi2Bit Manipulation Instruction Set 2 (BMI2)EBX bit 8
avx512fAVX-512 FoundationEBX bit 16
avx512bwAVX-512 Byte and Word instructionsEBX bit 30
avx512vbmiAVX-512 VBMIECX bit 1

Calif declared Intel Xeon processors from the Ice Lake, Sapphire Rapids, Emerald Rapids, and Granite Rapids generations, and AMD EPYC and Ryzen processors from Zen 4 onward as vulnerable. ARM64 servers are not affected, because the flaw is in the x86-64 code.

“Has AVX-512” is not the same condition. A Linux server in our lab with an Intel Xeon Platinum 8168, a Skylake-generation part, reports avx512f, avx512bw, and bmi2 but not avx512vbmi, so it does not meet the condition. An inventory that only records AVX-512 support would put that server on the patch-first list by mistake.

Which Java builds are affected

Calif reports OpenJDK 17.0.6 and later as affected, along with the distributions built from it, including Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Red Hat OpenJDK, Oracle OpenJDK, Oracle Java SE, and many more (The NVD record carries Oracle’s own list of affected builds as well).

Fixed builds come from the OpenJDK vulnerability advisory of November 17, 2026, Oracle’s November 2026 Critical Patch Update, and each distributor’s own release. Check the distributor that built your runtime, since their version numbers differ.

The Java runtime can be elusive and may not match the one reported by the operating system. CISA’s alert points out that Java runtimes bundled with third-party applications, container images, and appliances may not appear as separate entries in a software inventory. A package-manager query on the host misses a runtime that ships inside an application directory or a container, so the inventory has to look in those places too.

Checking the processor, and a trap in /proc/cpuinfo

On Linux, Calif suggests checking the flags line of /proc/cpuinfo, and the output must include all four names:

grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'

That works on current kernels. On older kernels, it can report a feature as missing when the processor has it, because the kernel prints only the flag names it knows. We measured this in our lab. Systems running on an Intel Xeon Silver 4316 (Ice Lake) host left avx512vbmi out of /proc/cpuinfo, while the CPUID (typically accessed via the “cpuid” command) inside the same VMs reported the feature as present. The JVM reads CPUID, not /proc/cpuinfo, so on those systems the command above says “not affected” for a processor that meets the condition. On an older guest, read CPUID directly with a tool such as the cpuid package before ruling a system out.

Virtual machines see the processor features the hypervisor exposes to them. In our lab, VMs configured to pass the host processor through report all four features, including a Windows 11 VM. A VM configured with an older virtual processor model does not. The infrastructure team can answer this per host and per VM configuration.

Checking what the JVM decided

You can ask a JVM which code paths it chose on the processor it is running on:

java -XX:+PrintFlagsFinal -version | grep -E ' (UseAVX|UseBASE64Intrinsics) '

UseAVX is the highest vector instruction level HotSpot will use; 3 means AVX-512, and UseBASE64Intrinsics indicates whether the hand-written Base64 decoder is enabled at all. On a workstation with an AMD Ryzen Threadripper 3960X, a Zen 2 processor without AVX-512, OpenJDK 27 reports UseAVX = 2 and UseBASE64Intrinsics = true. The intrinsic is on, but it is not the AVX-512 version, so UseBASE64Intrinsics = true alone does not mean a system is exposed. Run the command with the same Java binary and options the application uses, since a bundled runtime can behave differently from the one on the PATH.

Mitigating where the patch cannot land today

Calif documents two JVM options that remove the vulnerable code path. -XX:-UseBASE64Intrinsics turns off the hand-written Base64 code, so the JVM decodes Base64 with ordinary compiled Java. -XX:UseAVX=2 stops HotSpot from using AVX-512 at all, and belongs only on x86-64, because Calif notes that a JVM on ARM does not recognize the option and fails to start.

Add the option to the application’s own JVM options, or to the JAVA_TOOL_OPTIONS environment variable for the service account, then run the PrintFlagsFinal command above with the same settings to confirm that UseBASE64Intrinsics reads false or UseAVX reads 2. We have not measured the performance cost of either option, so test it on a busy service before rolling it out widely. CISA’s alert also recommends compensating controls at the application boundary, including validating Base64 input, enforcing input-size limits and limiting unauthenticated access.

Watching for exploitation attempts

CISA’s alert says crafted Base64 input could crash the JVM and recommends monitoring for unexpected JVM crashes, rogue runtimes, and suspicious Java processes. When HotSpot crashes, it writes a fatal error log named hs_err_pid<pid>.log, by default in the process’s working directory. Detection engineering should collect those files, or the service manager’s crash events, for internet-facing Java services and alert on new ones. An unexpected crash since November 17 on an internet-facing service that runs an affected build on a processor with all four features is a reason to open an incident and review that host, not something to clear with a restart.

How Eclypsium helps

The Eclypsium Infrastructure Assurance Platform already records each scanned system’s CPUID feature registers, from endpoint and server scans and from network-device and Linux-server scans where the scanned device has Python. For Intel processors, the platform decodes those registers, so the four flags appear in each asset’s processor details and through the platform’s application programming interface for assets. That gives teams a list of Intel systems that meet the processor condition today. We are also shipping a new detection rule in the next content update that indicates which assets have the CPU flags that the Java vulnerability requires:

What to do now

OwnerActionUseful result
Application owners or platform engineeringFind every Java runtime, including those bundled in applications and container images, and patch to the fixed build from your distributor. Start with internet-facing Jira, Confluence, Keycloak, Artifactory, Jenkins, and PingFederate.Runtime inventory with version and patch status
Infrastructure and virtualizationIdentify hosts and VM configurations that expose all four processor features, including VMs that can migrate onto such hosts.List of hosts and VM processor models, mapped to the Java services on them
Application owners, where a patch cannot land todayApply -XX:-UseBASE64Intrinsics or -XX:UseAVX=2 on x86-64 and confirm it with PrintFlagsFinal.Services running with the mitigation, verified
Detection engineeringCollect hs_err_pid<pid>.log files or crash events from internet-facing Java services and alert on new ones.Crash alerting in place, with any gaps named
Incident responseInvestigate unexpected crashes since November 17, 2026 on affected, internet-facing services.A decision on each host: no evidence of compromise, or an open incident
Vendor managementAsk software and appliance vendors whether their products ship OpenJDK 17.0.6 or later on x86-64, including virtual appliances.Vendor answers and fix dates

No. The bug is in HotSpot’s Java code generation, and the fix is a Java update. The processor only decides whether HotSpot uses the vulnerable AVX-512 path.

Only if the processor reports all four features, including avx512vbmi. Skylake-generation Xeons, such as the Platinum 8168 in our lab, support AVX-512 without VBMI.

No. A VM can migrate to a newer host, and a cloud instance can change type, which changes the processor a JVM sees. Patch it on your normal schedule after the systems that meet the condition.

As of November 18, 2026, Calif reports no exploitation in the wild, and CVE-2026-114938 is not in CISA’s KEV catalog. A proof of concept is public.

Calif lists OpenJDK 17.0.6 and later. Oracle’s affected list also includes the Java 8 Enterprise Performance Pack build 8u511b33-perf. For other builds, check your distributor’s advisory.

No. The flaw is in the x86-64 decoder.

Sources