On 17 November, Oracle and OpenJDK released fixes for CVE-2026-114938, a memory-corruption vulnerability in Java's built-in Base64 decoder. Calif, the research firm that reported it, demonstrated unauthenticated remote code execution against Jira, Confluence, Jenkins, Keycloak, JFrog Artifactory, and PingFederate; they named it Java4Shell. The vulnerable code has been in OpenJDK since version 17.0.6, released in January 2023, and is present in every later release through Java 27.
Until every affected runtime is patched, security teams need answers to 2 questions: which systems an attacker can actually exploit, and how they would see an attack in progress. Kai Labs, Kai's own security research team, worked on both. The sections below cover where Java4Shell is exploitable, including a map of affected Azure virtual machine (VM) families, how to remediate, and the attack signals. Kai Labs has built detections for these signals, included in this blog, which teams can use with their own tools to hunt for malicious activity.
To speed up Base64 decoding, OpenJDK includes hand-written assembly that runs on x86-64 processors supporting AVX-512 VBMI, a set of vector instructions available on recent Intel and AMD server processors. That routine miscalculates the output length for certain malformed inputs. A string of 64 A characters followed by a single = (128 characters on older Java 17 builds) causes it to write 62 bytes past the end of its output buffer. Java rejects the input afterward, but the adjacent memory has already been overwritten.

The Java Virtual Machine (JVM) uses this routine only after its just-in-time (JIT) compiler has compiled the decoder. Since a busy service does this compilation routinely, an attacker can trigger it by sending valid requests first. The researchers' write-up shows how the overwrite can be used to read heap memory and then to achieve remote code execution (RCE). They also report authenticated code execution against Apache Kafka brokers, Apache Solr, Elasticsearch, Gerrit, and Spinnaker. They rate the vulnerability 9.2 under the Common Vulnerability Scoring System (CVSS) 4.0; Oracle rates it 8.1 under CVSS 3.1.
Kai Labs' analysis found that a service is exploitable only when 4 conditions hold:
Base64.getDecoder() or Base64.getUrlDecoder(). Most services do, because HTTP Basic authentication headers, tokens, and file uploads carry Base64, often before a user logs in.
A Java version scan checks only part of the first condition. It does not check the processor, and a scan of the operating system's Java packages misses runtimes bundled inside products. Every Elasticsearch distribution includes its own OpenJDK, and the Jira and Confluence installers bundle a Java runtime. Those runtimes are fixed through the product vendor's update, not an operating system update.
.png)
The exposure is not limited to servers. The researchers report that a Java program that opens a TLS connection to a malicious server can be compromised, even if it runs no service of its own.
Because the processor decides exposure, Kai Labs mapped Azure VM families to the processors Microsoft documents for each, as part of its security context research into what organizations run and where. These families run on processors that support AVX-512 VBMI:

Some older series run on a mix of affected and unaffected processors. Microsoft lists the Dv4 and Dsv4 series on Intel Cascade Lake, which does not have AVX-512 VBMI, and also on Ice Lake, Sapphire Rapids, and Emerald Rapids, which do. The Dasv5 series runs on either AMD Milan, which is not affected, or AMD Genoa, which is. In those series, 2 VMs of the same size can run on different processors, so one can be exposed while the other is not. Azure Cobalt 100 VMs, such as the Dpsv6 and Epsv6 series, use ARM processors and are not affected.
A VM's series shows which processors it can run on, not which one a given VM has. To confirm, check inside the VM, because the hypervisor decides which processor features a guest can use. On Linux, a VM is in scope when /proc/cpuinfo lists all 4 of these flags: avx512f, avx512bw, avx512vbmi, and bmi2.

Begin with an inventory of running JVMs rather than installed packages. The two often differ for bundled and containerized runtimes.

readlink -f /proc/<PID>/exe and jcmd <PID> VM.version report it. Include runtimes inside containers and vendor products./proc/cpuinfo check inside the host. Then check the flags each JVM is actually running with, using the same java binary and options as the service: java -XX:+PrintFlagsFinal -version | grep -E 'UseBASE64Intrinsics|UseAVX'. UseBASE64Intrinsics set to true with UseAVX set to 3 on an AVX-512 VBMI processor is the exposed configuration. A product's bundled JVM can answer differently from the one on the system path.Where patching is not yet possible, the researchers identify 2 JVM startup options as temporary mitigations. Both take effect only after a restart, and both reduce performance. -XX:-UseBASE64Intrinsics disables the accelerated Base64 routine and can be used on any processor. -XX:UseAVX=2 disables AVX-512 on x86-64 processors.
Apply -XX:UseAVX=2 only to x86-64 hosts. OpenJDK on ARM does not recognize the option and will fail to start. ARM hosts are not affected and need no mitigation, so the risk lies in deploying the option broadly, for example through a shared base image, the JAVA_TOOL_OPTIONS environment variable, or a configuration management role that spans both architectures. For products with a bundled runtime, add the option to the product's JVM configuration file. Test either option on a single host, confirm it with jcmd <PID> VM.flags, and schedule its removal once the patch is applied. Request buffering at a reverse proxy is not a substitute, since the researchers' Elasticsearch exploit works from a single complete request.
To find hosts that have neither the patch nor a workaround, list the Java processes started without either flag, check which of them run an unpatched build, and compare that list with the processor check. Kai Labs' exposure check does this in Splunk Enterprise Security. Flags set through JAVA_TOOL_OPTIONS, JDK_JAVA_OPTIONS, or option files do not appear on the command line, so confirm on the host with the PrintFlagsFinal check.
Kai Labs' offensive learning research studies how an attack works and turns each stage into a detection, and its method requires measuring the results before publishing them: scope, attack, evaluate, iterate, and publish. For Java4Shell, Kai Labs had detections aimed specifically at the vulnerability 8.75 hours after the CVE was published. At that point, no public detection content in Sigma, Splunk ESCU, Elastic, or Suricata named it.
Kai Labs built 5 Splunk Enterprise Security correlation searches and 1 exposure check over the standard Common Information Model (CIM) data models. It ran them on a live Splunk Enterprise Security instance against 34 synthesized attack and benign test cases, and it declined 5 other detection ideas because the public evidence could not support them.
The searches look for 3 signals that any team can hunt for in its own security information and event management (SIEM) or endpoint detection and response (EDR) tools:
A characters ending in Base64 padding (=, or %3D when URL-encoded). The trigger usually travels in a request body or Authorization header, which standard web logs do not record, so this signal depends on a web application firewall (WAF) or proxy that inspects bodies and headers.hs_err_pid or replay_pid). The researchers report that failed attempts crash the JVM and get retried, so several crash files in a short window on a JVM that normally stays up deserve investigation.sh, bash, curl, wget, cmd.exe, PowerShell, certutil, mshta, useradd, or net.exe, or running a binary from a temporary folder. Build servers such as Jenkins start shells as part of normal work, so compare against each host's own history.If any of these signals appears, preserve crash, request, and container logs before restarting or redeploying anything, because redeploying a container discards its filesystem. Reading heap memory needs no new process or outbound connection, since the leaked data returns in the application's own response. If an attempt against a service cannot be ruled out, rotate the secrets its JVM held, including TLS private keys, token-signing keys, service credentials, and active sessions.
On 17 November, the Cybersecurity and Infrastructure Security Agency (CISA) issued an alert urging organizations to patch immediately. As of 06:21 UTC on 18 November, Kai Labs found no public evidence of exploitation: the vulnerability was not in CISA's Known Exploited Vulnerabilities (KEV) catalog, its Exploit Prediction Scoring System (EPSS) score was 0, and GreyNoise had seen 1 IP address targeting it. The researchers are withholding their product-specific exploits to give organizations time to upgrade. For comparison, PHP2Shell, the previous vulnerability Calif disclosed, was added to the KEV catalog 5 days after PHP released a fix.

The organizations that close Java4Shell quickly will be the ones that already know which Java runtimes are present, on which hardware, and who owns each one.
The Kai Autonomous Defense Platform finds the risk in your environment, proves what is actually exploitable, and drives the fix to completion inside a boundary your team sets. For Java4Shell, Kai checks each flagged asset for reachability and exploitability, closes findings that cannot be exploited with a written reason, and routes the remainder to the responsible owner with the fix staged. To request a scoped Java4Shell exposure review, contact Kai.
To follow more research from Kai, go to Kai Labs.