Java SE and GraalVM — Critical Base64 Decoder Overflow Flaw Enables Pre-Auth RCE (CVE-2026-114938)

Publication date: November 18, 2026
Category: Vulnerability / Software Security

Introduction

A critical security vulnerability designated as Java4Shell and tracked officially as CVE-2026-114938 impacts Oracle and OpenJDK Java runtime environments. Disclosed by security research firm Calif, this flaw allows unauthenticated attackers to achieve remote code execution (RCE) across widely deployed enterprise platforms, including Atlassian Jira, Jenkins, Keycloak, Atlassian Confluence, JFrog Artifactory, and PingFederate. The bug resides within a hardware-accelerated optimization designed to speed up string processing using advanced vector instructions.

What is Java4Shell? (General Analysis)

Java4Shell is a heap-based buffer overflow vulnerability officially classified under CWE-122 (Heap-based Buffer Overflow). The affected component resides within the compilation and optimization subsystem of Java SE and GraalVM, specifically inside the accelerated implementation of the Base64 decoder.

This optimized routine is triggered automatically on x86-64 processors supporting specific vector instruction extensions. Because servers frequently process Base64-encoded strings—such as HTTP Basic authentication headers, SAML artifacts, and CSRF tokens—before checking user authentication status, an attacker can transmit malformed requests that reach the vulnerable routine without requiring a valid user account.

Official data recorded in the National Vulnerability Database (NVD) establishes a CVSS v3.1 vector of CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H with a base score of 8.1 (High), emphasizing that while exploitation requires specific timing and architecture conditions, the potential impact entails complete compromise of confidentiality, integrity, and availability.

How Does It Work? (Technical Analysis)

The exploitation mechanism relies on several architectural and memory manipulation factors:

  • Entry Flow and Vector Activation: The flaw stems from Java’s optimized Base64 decoder, which executes on processors supporting AVX-512 VBMI (Vector Byte Manipulation Instructions) extensions. The Java runtime switches to this high-speed routine via JIT compilation after detecting frequent decoding operations.
  • Overflow Mechanism: By supplying a malformed string ending with an extra padding character (=), the decoder writes 62 to 63 bytes past the end of its allocated heap output buffer. Although the Java engine subsequently rejects the string due to invalid formatting, the out-of-bounds write has already executed.
  • Exploitation Technique (JavaBleed): Because the bytes written past the boundary are static, the attacker does not control the immediate contents of the write, only its destination. By carefully arranging server memory, researchers managed to expand an adjacent memory array, first using it to write arbitrary data and subsequently to read sensitive information stored in neighboring regions (a technique dubbed JavaBleed). From this stage, the control flow reaches internal Java components capable of invoking code execution.
  • Environmental Constraints: Exploitation is neither trivial nor universal; it requires precise timing and specific processor architecture. A failed exploitation attempt may cause the Java Virtual Machine (JVM) process to crash, though the service typically restarts, allowing attackers to retry.

Affected Systems / Environments

The vulnerability does not impact all Java installations, affecting only those meeting strict software version and hardware architecture criteria:

  • Affected Java Versions:
    • Java SE 17 line: Versions 17.0.6 through 17.0.21.0.3.
    • Java SE 21 line: Versions 21.0.13.0.3 and earlier.
    • Java SE 25 line: Versions 25.0.5.0.3 and earlier.
    • Java SE 27 line: Versions 27.0.1.0.3 and earlier.
    • Java SE 8: Exclusively the Java SE 8 Performance Pack build 8u511b33-perf.
    • GraalVM: Versions 17.0.21.0.3, 21.0.13.0.3, and GraalVM Enterprise Edition 21.3.20.0.3.
  • Hardware Architectures Prone to the Flaw: The vulnerable code executes exclusively on x86-64 processors supporting AVX-512 VBMI (such as Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids, and AMD Zen 4 or newer processors). ARM64-based environments are unaffected.
  • Linux System Verification: Administrators can verify whether a server possesses the required hardware instruction set using the following terminal command:
    bash
    grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
CVE Category (CWE) Impact CVSS Vector (Summary)
CVE-2026-114938 CWE-122 (Heap-based Buffer Overflow) System Takeover (RCE) 8.1 (High) AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H

Mitigation and Detection

Remediation

System administrators and operations teams must apply official security updates released by Java vendors:

  • Oracle Java SE: Upgrade to the respective .1 releases (Java 17.0.21.1, 21.0.13.1, 25.0.5.1, and 27.0.1.1).
  • Amazon Corretto: Upgrade to patched builds (such as 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2, and 27.0.1.1.4).
  • Azul Zulu: Apply the November 2026 updates (versions 17.70.201, 21.54.201, 25.38.201, 27.30.201).
  • Temporary Workarounds: If immediate patching is not feasible, start the JVM with configuration flags to disable the vulnerable intrinsic instructions while preserving other hardware speedups:
    • -XX:-UseBASE64Intrinsics (Disables only the accelerated Base64 code).
    • -XX:UseAVX=2 (Disables AVX-512 entirely; use strictly on x86-64 servers).

Detection

Incident response teams and security analysts should monitor production environments for the following indicators and anomalies:

Early detection of Java4Shell exploitation attempts requires monitoring anomalous Base64 decoding patterns within HTTP authorization headers and repetitive illegal argument exceptions in Java logs.

  • Base64 tokens exceeding 32 characters that end with = and whose length is not a multiple of 4, particularly within Authorization headers.
  • Sudden and massive bursts of IllegalArgumentException errors originating from java.util.Base64$Decoder.
  • Unexplained daemon crash logs (hs_err_pid) or intermittent JVM process restarts.

Wrapping Up

The Java4Shell vulnerability (CVE-2026-114938) underscores the inherent risks associated with low-level optimizations in core software components when interacting with advanced processor architectures. Although exploitation requires complex timing conditions and specific hardware, the potential impact of remote code execution across critical enterprise platforms necessitates a coordinated and immediate response from system administrators through official patches or JVM mitigation flags.

References