Vulnerability

Java4Shell (CVE-2026-114938): OpenJDK AVX-512 Base64 Flaw Enables Unauthenticated RCE

Java4Shell (CVE-2026-114938) is a critical memory-corruption flaw in OpenJDK's AVX-512 Base64 decoder affecting Java 17.0.6+, 21, 25, and 27 on x86-64 CPUs. Learn how the 64-byte heap overwrite works, which builds are patched, and how to hunt or mitigate it.

By 0xScorPionSon

9 min read

Java4Shell (CVE-2026-114938): OpenJDK AVX-512 Base64 Flaw Enables Unauthenticated RCE

Java4Shell CVE-2026-114938 OpenJDK AVX-512 RCE infographic

Executive Summary

On November 17, 2026, security researchers at Calif disclosed Java4Shell (CVE-2026-114938), a memory-corruption vulnerability in OpenJDK's hardware-accelerated java.util.Base64.Decoder that enables unauthenticated remote code execution (RCE) on x86-64 servers equipped with AVX-512 VBMI instructions. Coordinated patches shipped the same day in Oracle's November 2026 Critical Security Patch Update and the OpenJDK Vulnerability Advisory (2026/11/17).

Under CVSS 4.0, Calif and South Korea's National Cyber Security Center (as cited in ThreatDefence's advisory) rate CVE-2026-114938 at 9.2 Critical. On NVD, Oracle's CVSS 3.1 Base Score is 8.1 High (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H), reflecting high attack complexity because reliable exploitation requires target-specific heap grooming rather than a universal payload.

Because the flaw resides inside the HotSpot JVM runtime rather than an application-level .jar dependency, Software Composition Analysis (SCA) tools that only parse pom.xml or build.gradle manifests will miss it. As of November 18, 2026, no exploitation in the wild or public weaponized exploit code has been reported, and CVE-2026-114938 is not in the CISA KEV catalog.

Confidence Level: High. Core version boundaries, CVSS 3.1/4.0 scoring, CPU hardware prerequisites, and patch baselines are corroborated across primary advisories from Oracle, NVD, OpenJDK, and Calif, alongside independent defensive analyses from SentinelOne, Cycode/Security Boulevard, and ThreatDefence.

Technical Mechanics & Architecture

Java's memory safety guarantees protect application bytecode, but the HotSpot JVM itself relies on native C, C++, and hand-written assembly intrinsics for performance-critical primitives. In OpenJDK 17.0.6 (via JDK-8296735, backported from JDK 18 in November 2022), OpenJDK enabled an x86-64 AVX-512 VBMI assembly intrinsic for java.util.Base64.Decoder.

Root Cause: Negative Output Length in AVX-512 Padding Handling

Per Calif's technical disclosure, the bug sits in the hand-rolled AVX-512 VBMI assembly routine that processes the trailing characters of a Base64-encoded input:

  1. Buffer Allocation: When decoding a malformed 65-character Base64 string (such as 64 * "A" + "="), OpenJDK allocates a 50-byte destination array on the Java heap.
  2. Tail Calculation Underflow: After the vector loop decodes the first 64 characters, the trailing handler miscalculates the remaining output length when encountering the stray = padding byte, producing a negative length.
  3. Out-of-Bounds Heap Overwrite: The invalid length triggers a full 64-byte write starting at offset 48, sending 62 bytes past the end of the 50-byte array (with bytes 48–63 writing a fixed 0x9a pattern).
  4. Pre-Validation Corruption: Although Base64.Decoder subsequently throws an exception and rejects the malformed input, neighboring objects on the G1/JVM heap have already been corrupted before application-level validation executes.
+-----------------------------------------------------------------------+
|                UNTRUSTED NETWORK INPUT (HTTP / SAML / TLS)            |
|  HTTP Basic Auth | JWT | SAML Artifact | CSRF Token | API JSON Field  |
+-----------------------------------+-----------------------------------+
                                    |
                                    v
+-----------------------------------------------------------------------+
|                    JVM: java.util.Base64.Decoder                      |
|  [ Allocates 50-byte heap array for 65-char malformed Base64 input ]  |
+-----------------------------------+-----------------------------------+
                                    |
          +-------------------------+-------------------------+
          | (AVX-512 VBMI + UseBASE64Intrinsics=true)         | (-XX:-UseBASE64Intrinsics
          v                                                   |  or -XX:UseAVX=2 / ARM64)
+---------------------------------------------------+         v
|  VULNERABLE ASSEMBLY INTRINSIC (x86-64 AVX-512)   |  [ Safe Scalar / AVX2 Path ]
|  1. Decodes first 64 bytes cleanly                |  (Rejects padding cleanly;
|  2. Stray '=' causes negative output length       |   no out-of-bounds write)
|  3. 64-byte write -> 62 bytes OOB past array end  |
+-------------------------+-------------------------+
                          |
                          v
+-----------------------------------------------------------------------+
|             CORRUPTED ADJACENT JVM HEAP OBJECTS (G1GC)                |
|  [ Heap Leak / Type Confusion -> Bespoke Target RCE Chain ]           |
+-----------------------------------------------------------------------+

Hardware and Runtime Prerequisites

For a workload to be exposed to CVE-2026-114938, all three conditions reported by SentinelOne and Cycode must hold simultaneously:

  • Vulnerable HotSpot Runtime: OpenJDK 17.0.6 through 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3, 27.0.1.0.3, or Oracle Java SE 8u511b33-perf (Enterprise Performance Pack) and GraalVM equivalents prior to the November 17, 2026 patch. Standard Java 8 and Java 11 are not affected by Java4Shell.
  • x86-64 CPU with AVX-512 VBMI: Specifically processors exposing avx512f, avx512bw, avx512vbmi, and bmi2 flags—such as Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids, and Granite Rapids, or AMD EPYC/Ryzen Zen 4 and newer. ARM64 hosts (including AWS Graviton and Apple Silicon) are unaffected.
  • Attacker-Controlled Base64 Reachability: Any unauthenticated or authenticated endpoint passing untrusted input to java.util.Base64.Decoder (basic or URL decoder), including HTTP Basic Authorization headers, SAML assertions, JWTs, CSRF tokens, MIME encoded words, or file upload fields.

Safe Local Verification (Read-Only Host & CPU Audit)

Defenders can verify whether a Linux host or container meets the vulnerable hardware and JVM flag criteria without running any exploit payload:

# 1. Check the active Java version
java -version 2>&1

# 2. Verify whether the x86-64 CPU exposes AVX-512 VBMI flags
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'

# 3. Inspect live JVM flags on running Java processes (more reliable than PATH)
jcmd -l
jcmd <pid> VM.flags | tr ' ' '\n' | grep -E 'UseAVX|UseBASE64Intrinsics'

A host matches the vulnerable runtime profile if all four CPU flags are present, the Java version falls in the affected OpenJDK 17.0.6+ / 21 / 25 / 27 range prior to the November 17 fix, UseAVX is 3 (or higher), and UseBASE64Intrinsics is enabled.

Evidence & Ecosystem Impact

Demonstrated Application Reach

In its November 17 disclosure, Calif demonstrated pre-authentication RCE against default configurations of several widely deployed enterprise Java platforms, alongside post-authentication RCE and a client-side TLS vector shared by researcher samczsun:

  • Pre-Authentication Server Targets (Default Configs): Apache Kafka Broker, Atlassian Confluence, Atlassian Jira, JFrog Artifactory, Jenkins, Keycloak, Gerrit, PingFederate, and sample Spring Boot / Apache Struts applications.
  • Post-Authentication Server Target: Elasticsearch.
  • Client-Side Vector: A vulnerable Java client opening a TLS connection to a malicious server can be compromised even if it exposes no listening network service.

Crucially, Calif notes there is no universal "point-and-shoot" exploit. Each application requires a bespoke heap-grooming profile (writer/reader object pairs, TLAB/outside-TLAB allocation timing, and low-jitter network conditions). Additionally, reverse proxies like nginx that buffer complete request bodies by default disrupt partial-body heap grooming for some chains, though single-request chains (such as Elasticsearch) and post-upgrade WebSocket tunnels bypass request-body buffering.

Affected & Patched Oracle / OpenJDK Version Matrix

Java Line Affected Oracle Build Patched Oracle Build (Nov 17, 2026) Affected OpenJDK Advisory Range
Java 27 27.0.1 (27.0.1.0.3) 27.0.1.1 27.0.1.0.3 and earlier
Java 25 25.0.5 (25.0.5.0.3) 25.0.5.1 25.0.5.0.3 and earlier
Java 21 21.0.13 (21.0.13.0.3) 21.0.13.1 21.0.13.0.3 and earlier
Java 17 17.0.21 (17.0.21.0.3) 17.0.21.1 17.0.6 through 17.0.21.0.3
Java 8 (Perf Pack) 8u511b33-perf 8u513 Standard Java 8 / 11 unaffected by Java4Shell

Oracle GraalVM for JDK (17.0.21.0.3, 21.0.13.0.3) and GraalVM Enterprise Edition (21.3.20.0.3) are also affected. Downstream OpenJDK distributions—including Eclipse Temurin, Amazon Corretto, Azul Zulu, BellSoft Liberica, SAP SapMachine, Microsoft Build of OpenJDK, and Red Hat OpenJDK—inherit the fix from the November 17 OpenJDK advisory on their respective release schedules.

Hardening & Remediation Playbook

Because CVE-2026-114938 sits in the runtime and affects bundled JDKs inside vendor appliances and container images, defenders should execute the following controls in priority order.

1. Inventory All Java Runtimes (Including Bundled & Container JDKs)

OS package managers miss JDKs bundled inside third-party software (such as Atlassian, Jenkins, or JFrog installers) and container images. Audit both host filesystems and container images:

# Locate all standalone and bundled JDK release manifests on Linux hosts
find / -xdev -type f -name release -path '*j*' 2>/dev/null | xargs grep -H '^JAVA_VERSION=' 2>/dev/null

# Check the exact Java version inside a container image
docker run --rm --entrypoint java <image_name>:<tag> -version

2. Apply Vendor Patches and Restart Every JVM

Upgrade Oracle JDK workloads to 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1, or 8u513, and apply your OpenJDK vendor's November 17, 2026 security release for Eclipse Temurin, Corretto, Zulu, or distro packages. Restart every running JVM process and rebuild/redeploy container images—a running process retains the unpatched libjvm in memory until restarted.

3. Deploy Emergency JVM Flag Mitigation (Where Patching Is Delayed)

If an appliance bundles an unpatched JDK and cannot be upgraded immediately, disable the vulnerable AVX-512 Base64 intrinsic via JAVA_TOOL_OPTIONS or service unit arguments:

# Recommended cross-architecture mitigation (disables Base64 hardware intrinsic)
export JAVA_TOOL_OPTIONS="-XX:-UseBASE64Intrinsics"

# Alternative x86-64-only mitigation (caps AVX level to AVX2; DO NOT use on ARM64)
export JAVA_TOOL_OPTIONS="-XX:UseAVX=2"

Verify the flag took effect on the running PID using jcmd <pid> VM.flags. Note that -XX:UseAVX=2 is valid only on x86-64—ARM64 OpenJDK builds do not recognize it and will fail to start.

4. Hunt WAF Logs and EDR Telemetry

Monitor perimeter WAFs, reverse proxies, and EDR logs for both malformed Base64 probes and post-exploitation behaviors:

  • WAF / Proxy Base64 Anomaly Rule (per SentinelOne): Flag decoded or extracted Base64 values (HTTP Basic Authorization, SAML, CSRF tokens) where total length $L \ge 65$, $L \pmod{64} \in {1, 2, 3}$, and the string ends with one or two = padding characters (not exceeding $L \pmod{64}$).
  • Microsoft Defender / Sentinel KQL — JVM Crash (hs_err_pid) & Shell Spawn Hunts (adapted from ThreatDefence):
// Hunt 1: Detect JVM fatal error logs (failed heap grooming often crashes the JVM)
DeviceFileEvents
| where Timestamp > ago(14d)
| where ActionType == "FileCreated" and FileName startswith "hs_err_pid"
| summarize Crashes=count(), FirstSeen=min(Timestamp), LastSeen=max(Timestamp),
    Folders=make_set(FolderPath, 10) by DeviceName
| order by Crashes desc

// Hunt 2: Detect Java processes spawning shells or download utilities
DeviceProcessEvents
| where Timestamp > ago(14d)
| where InitiatingProcessFileName in~ ("java", "java.exe", "javaw.exe")
| where FileName in~ ("sh", "bash", "dash", "zsh", "cmd.exe", "powershell.exe", "pwsh.exe", "curl", "wget", "python3")
| project Timestamp, DeviceName, AccountName, InitiatingProcessCommandLine, FileName, ProcessCommandLine
| order by Timestamp desc

Inspect any hs_err_pid*.log on internet-facing hosts: frames referencing Base64 or StubRoutines indicate a potential exploitation attempt.

5. Rollback & Evidence Preservation Notes

If -XX:-UseBASE64Intrinsics introduces unacceptable Base64 throughput regression on a non-exposed internal service, remove the flag from JAVA_TOOL_OPTIONS and restart the JVM after patching. If compromise is suspected on an internet-facing host, preserve hs_err_pid logs, application access logs, and a JVM memory dump before restarting or isolating the host, and rotate all credentials accessible to the service account.

Frequently Asked Questions

Is Java4Shell (CVE-2026-114938) as easy to exploit as Log4Shell? Not currently. While both sit in ubiquitous Java components, Log4Shell was trivial to exploit with a single JNDI string. Java4Shell is a memory-corruption bug requiring processor-specific AVX-512 VBMI support and target-specific heap grooming, and no universal exploit exists.

Will updating Maven or Gradle dependencies protect my application? No. CVE-2026-114938 is in the HotSpot JVM runtime (java.util.Base64.Decoder intrinsic), not a third-party library. You must update the JDK/JRE runtime itself and restart the service or rebuild container images.

Are AWS Graviton, Apple Silicon, or other ARM64 servers vulnerable? No. The vulnerable assembly routine is x86-64 AVX-512 VBMI-specific. ARM64 JVMs do not execute this code path. Note that -XX:UseAVX=2 will cause ARM64 JVMs to fail on startup, so use -XX:-UseBASE64Intrinsics if applying a cross-platform flag.

Are Java 8 and Java 11 affected by Java4Shell? Standard OpenJDK 8 and 11 are not affected by Java4Shell because the AVX-512 Base64 intrinsic was introduced in JDK 18 and backported to 17.0.6. However, Oracle's 8u511b33-perf (Enterprise Performance Pack) is listed as affected, and Oracle's November 17 update patches other unauthenticated remote flaws in Java 8 and 11.

Is CVE-2026-114938 being actively exploited in the wild? As of November 18, 2026, no active exploitation in the wild or public weaponized exploit chains have been reported, and the CVE is not in CISA's KEV catalog. However, Calif demonstrated working RCE across major enterprise Java servers, so patching internet-facing workloads immediately is critical.

Sources

  1. Oracle — Oracle Critical Security Patch Update Advisory - November 2026 (November 17, 2026)
  2. NIST NVD — CVE-2026-114938 Detail (Published November 17, 2026)
  3. OpenJDK Vulnerability Group — OpenJDK Vulnerability Advisory: 2026/11/17 (November 17, 2026)
  4. Calif — Java4Shell: Write once, RCE everywhere (November 17–18, 2026)
  5. SentinelOne — Defending Against Java4Shell: Vulnerability in OpenJDK Enables RCE on AVX-512 CPUs (November 17, 2026)
  6. ThreatDefence — Java4Shell CVE-2026-114938: Java 17 RCE Checks and Hunting (November 18, 2026)
  7. Cycode / Security Boulevard — Java4Shell (CVE-2026-114938): unauthenticated remote code execution in Java 17, 21, 25 and 27 (November 17, 2026)

More on Vulnerability

Vulnerability

CVE-2026-114938 (Java4Shell): OpenJDK AVX-512 Base64 Heap Overflow & Mitigation Guide

CVE-2026-114938 (Java4Shell) is a memory-corruption vulnerability in OpenJDK's HotSpot AVX-512 VBMI Base64 decoder affecting OpenJDK 17.0.6+ through 27 (plus Oracle Java SE 8u511b33-perf) on x86-64 CPUs with AVX-512 VBMI. Malformed Base64 input triggers a 62–63 byte out-of-bounds heap write before validation, enabling pre-authentication RCE on Keycloak, Jira, Confluence, Artifactory, Jenkins, and PingFederate. Patch immediately or apply -XX:-UseBASE64Intrinsics.

9 min read

Tell us what is not working

A thirty-minute call, no deck and no obligation. You will leave with a straight answer about whether this is worth building - including if that answer is no.

Start a project

Direct line

hello@codebumble.net
Dhaka, Bangladesh  :   local timeCalls in English or Bangla