Blog
11.18.26

Kai Labs: Exposure Analysis and Detections for Java4Shell (CVE-2026-114938)

Ian Hanley

TL;DR

Java4Shell (CVE-2026-114938) is a memory-corruption flaw in Java's built-in Base64 decoder, fixed by Oracle and OpenJDK on 17 November. Researchers demonstrated unauthenticated remote code execution on Jira, Confluence, Jenkins, Keycloak, JFrog Artifactory, and PingFederate. Only services where all 4 conditions hold: an affected JVM (OpenJDK 17.0.6 and later, or any release from Java 18 on), an x86-64 processor with AVX-512 VBMI (Intel Xeon Ice Lake or newer, AMD Zen 4 or newer), untrusted Base64 reaching the decoder, and neither workaround flag set. ARM and standard Java 8 and 11 builds are not affected. Note that version scans misjudge it - they don't check the processor, and they miss runtimes bundled inside products like Elasticsearch and the Jira and Confluence installers. Kai Labs mapped the Azure VM families that run on affected processors. What needs to be done now - Inventory running JVMs, check the processor under each, patch internet-facing services first, and restart. Until then, `-XX:-UseBASE64Intrinsics` or `-XX:UseAVX=2` closes the path; the second is for x86-64 only, because OpenJDK on ARM will not start with it. Kai Labs had Java4Shell-specific detections 8.75 hours after the CVE was published, before any public detection content named it. They look for the trigger pattern arriving, the crash files failed attempts leave, and Java starting shells or download tools.

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.

How the vulnerability works

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.

Where Java4Shell is exploitable

Kai Labs' analysis found that a service is exploitable only when 4 conditions hold:

  • It runs an affected JVM. That includes OpenJDK 17.0.6 and later, every release from Java 18 on, distributions built from OpenJDK, and Java runtimes bundled inside other products. Standard Java 8 and 11 builds are not affected, though Oracle lists its Java SE 8 Enterprise Performance Pack as affected.
  • The JVM runs on an x86-64 processor with AVX-512 VBMI: Intel Xeon Ice Lake or newer, or AMD Zen 4 or newer. ARM processors are not affected.
  • The service decodes untrusted Base64 through 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.
  • Neither workaround flag is set. The 2 JVM startup options under Remediation close the vulnerable path.

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.

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.

Affected Azure VM families

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.

Remediation

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

  1. Identify the binary each Java process is running. On Linux, readlink -f /proc/<PID>/exe and jcmd <PID> VM.version report it. Include runtimes inside containers and vendor products.
  2. Determine whether each host's processor supports AVX-512 VBMI, using the Azure table above or the /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.
  3. Patch in order of exposure. Start with internet-facing services on affected or unverified processors, beginning with the 6 products exploited without authentication. Then patch internal services on affected processors, followed by all remaining affected runtimes, since a cluster that mixes processor generations can reschedule a workload onto an affected processor.
    • Oracle's fixes are in the November 2026 Critical Security Patch Update: Java SE 17.0.21.1, 21.0.13.1, 25.0.5.1, and 27.0.1.1. The upstream OpenJDK fix is commit 5177a70b.
    • Amazon Corretto, Eclipse Temurin, Azul Zulu, Microsoft Build of OpenJDK, Red Hat, BellSoft Liberica, and SAP SapMachine release on their own schedules. Confirm that the release notes list CVE-2026-114938 before closing a ticket.
    • Java 18 to 20, 22 to 24, and 26 will not receive a fix. Services on those releases need to move to a supported version.
  4. Restart each JVM and verify the restart by comparing the process start time with the patch time. Updating the runtime on disk does not affect a process that is already running.

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.

Detecting exploitation attempts

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:

  • The attack arriving: requests that carry the published trigger pattern, a long run of 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.
  • A failed attempt: Java writing a crash file (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.
  • A successful compromise: Java starting a shell, script host, download tool, or account-management tool, such as 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.

Current exploitation status

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.

Sources

Calif, Java4Shell: Write once, RCE everywhere, 17 Nov 2026. Root cause, affected distributions and processors, pre-auth and post-auth product lists, workaround flags and the ARM warning. Oracle Critical Security Patch Update Advisory, November 2026, 17 Nov 2026. Its Java SE risk matrix scores the flaw 8.1 under CVSS 3.1 and lists the affected Java SE, GraalVM for JDK, and GraalVM Enterprise Edition builds. Oracle release notes for the fixed builds, all dated 17 Nov 2026: 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1. OpenJDK Vulnerability Group advisory, 17 Nov 2026. OpenJDK fix commit 5177a70b. OpenJDK advisory on oss-security, 17 Nov 2026. CISA, Critical Java Vulnerability Requires Immediate Patching, 17 Nov 2026. CIRCL Vulnerability-Lookup, CVE-2026-114938. The sighting, proof-of-concept, and patch records Kai Labs used to track evidence as it appeared. Kai Labs, research pillars and methodology. Cisco Talos, CVE-2026-114938: Critical vulnerability in OpenJDK Java, 17 Nov 2026. No exploitation observed in the wild. Microsoft Azure VM size documentation: D family, Dv4 and Dsv4, Dsv6, Dasv6, Bsv2, E family, Edsv6, Eadsv6, Fasv6, Fasv7, Lsv3, Lasv5 (Azure Updates AZ572630), M family, Mbsv3, DC family, DCesv6, HBv4, HBv5. Elastic, Installing Elasticsearch. Every distribution includes a bundled OpenJDK that Elastic maintains. Atlassian, Change the Java vendor or version Confluence uses. Installer-based Confluence runs on its bundled Java runtime. The Hacker News, CISA confirms active exploitation of PHP2Shell, 27 Oct 2026. PHP2Shell added to KEV on 26 October, 5 days after the 21 October fix. Companion posts: 11 PHP2Shell — You Can Patch and Still Be Exploitable; 13 PHP2Shell — The Detection Gap. Kai Labs, Java4Shell blog post content, detection status notes, research write-up, and detection pipeline scorecard, 17 to 18 Nov 2026 (internal)