Security
Java4Shell (CVE-2026-114938): OpenJDK Base64 Intrinsics Flaw Enables Pre-Auth RCE on AVX-512 Servers
Disclosed by Calif and patched by Oracle on November 17, 2026, Java4Shell (CVE-2026-114938) is a heap memory corruption bug in OpenJDK's AVX-512 VBMI Base64 decoder affecting Java 17.0.6 through 27. Learn why ARM64 and OpenJ9 are unaffected, how researchers demonstrated pre-auth RCE against Jenkins, Jira, and Keycloak, and how to deploy -XX:-UseBASE64Intrinsics while upgrading.
8 min read
Java4Shell (CVE-2026-114938): OpenJDK Base64 Intrinsics Flaw Enables Pre-Auth RCE on AVX-512 Servers
Executive Summary
Java4Shell (CVE-2026-114938) is a memory-corruption vulnerability in the HotSpot Java Virtual Machine (JVM) hardware-accelerated Base64 decoder affecting OpenJDK 17.0.6 and later, including Java 21, 25, and 27, across downstream distributions such as Oracle Java SE, Eclipse Temurin, Red Hat OpenJDK, Amazon Corretto, and Azul Zulu. Disclosed by Calif and patched by Oracle on November 17, 2026, the flaw allows an unauthenticated remote attacker to send crafted Base64 input—common in HTTP Authorization: Basic headers, JWTs, cookies, and API payloads—to corrupt Java heap memory, leak sensitive secrets, crash the JVM, or achieve remote code execution (RCE).
Severity assessments vary across vendors: Calif assigns CVSS v4.0 9.2 (Critical), Red Hat rates it CVSS v3.0 9.8 (Critical), and Oracle scores it CVSS v3.1 8.1 (High). Crucially, CrowdStrike, Quarkus, and Calif emphasize that exploitation requires three simultaneous conditions: (1) an unpatched OpenJDK 17.0.6+ to 27 build, (2) an x86-64 processor supporting AVX-512 VBMI (Intel Xeon Ice Lake through Granite Rapids, or AMD EPYC Zen 4 and newer), and (3) an application that decodes attacker-controlled Base64 data. ARM64 servers, older x86-64 CPUs without AVX-512 VBMI, Java 8, Java 11, and IBM Semeru (which uses OpenJ9 rather than HotSpot) are not affected.
CISA has issued an alert urging immediate patching, and GreyNoise reported initial exploitation attempts as of November 18, 2026 (without confirming successful compromise on its sensors). Keycloak shipped patched 26.8 container images on November 19, 2026, while Microsoft Azure WAF published HTTP-layer detection rules on November 18, 2026. Fixed OpenJDK releases are 17.0.21.1, 21.0.13.1, 25.0.5.1, and 27.0.1.1. Where immediate patching is blocked, adding -XX:-UseBASE64Intrinsics to JVM startup flags disables the vulnerable intrinsic.
| Attribute | Verified Value | Source |
|---|---|---|
| CVE Identifier | CVE-2026-114938 ("Java4Shell") | Oracle / Red Hat / Calif |
| Severity Scores | CVSS 4.0: 9.2 (Calif); CVSS 3.0: 9.8 (Red Hat); CVSS 3.1: 8.1 (Oracle) | Calif / Red Hat / CrowdStrike |
| Affected Runtimes | Unpatched OpenJDK 17.0.6+, 21, 25, 27 (HotSpot JVM) |
Quarkus / Microsoft / OX Security |
| Unaffected Runtimes | Java 8, Java 11, IBM Semeru (OpenJ9), ARM64 systems |
OX Security / Quarkus |
| Hardware Scope | x86-64 CPUs with AVX-512 VBMI (Intel Ice Lake+, AMD Zen 4+) | Qualys / Quarkus / CrowdStrike |
| Fixed OpenJDK Versions | 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1 |
OX Security (Nov 18, 2026) |
| Interim JVM Mitigation | -XX:-UseBASE64Intrinsics (portable across x86-64 & ARM64) |
Keycloak / Tenable |
| Exploitation Status | GreyNoise saw attempts; VulnCheck & Immersive built exploits; no confirmed wild compromise | Tenable / OX Security |
Technical Mechanics and Architecture
How the AVX-512 VBMI Base64 Intrinsic Corrupts Heap Memory
To accelerate Base64 decoding on modern server CPUs, the HotSpot JVM replaces pure-Java decoding loops with a CPU-specific intrinsic that leverages AVX-512 Vector Byte Manipulation Instructions (VBMI). When an application invokes java.util.Base64.Decoder on incoming network data—such as HTTP Basic authentication headers, JWT tokens, SAML assertions, cookies, or multipart uploads—the JVM dispatches the byte buffer to this vectorized native routine.
When the AVX-512 VBMI intrinsic encounters a specially crafted malformed Base64 string, it writes past the bounds of its destination buffer before Java's validation logic rejects the malformed input. That out-of-bounds write corrupts adjacent JVM heap memory. Depending on heap layout and application behavior, an attacker can:
- Crash the JVM reliably with a short burst of malformed Base64 requests (Denial of Service).
- Leak adjacent heap memory containing session tokens, credentials, or private keys.
- Achieve pre-authentication RCE by chaining the heap overwrite with application-specific object layouts—as Calif demonstrated against default installations of Atlassian Jira, Atlassian Confluence, Jenkins, Keycloak, JFrog Artifactory, and PingFederate (and authenticated RCE against Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, and Spinnaker).
Three-Condition Exposure & Containment Architecture
+-------------------------------------------------------------------------+
| INCOMING HTTP / API REQUEST |
| - Basic Auth Header / JWT / Cookie / Base64 Payload |
+------------------------------------+------------------------------------+
|
v
+-------------------------------------------------------------------------+
| GATE 1: Application Decodes Untrusted Base64 Before Auth? |
| - Yes (Jira, Jenkins, Keycloak, Confluence, Artifactory, PingFederate) |
+------------------------------------+------------------------------------+
|
v
+-------------------------------------------------------------------------+
| GATE 2: HotSpot JVM 17.0.6+ through 27 (Pre-Nov 17 Patch)? |
| - Excluded: Java 8, Java 11, IBM Semeru (OpenJ9) |
+------------------------------------+------------------------------------+
|
v
+-------------------------------------------------------------------------+
| GATE 3: x86-64 CPU with AVX-512 VBMI + Base64 Intrinsics Enabled? |
| - /proc/cpuinfo has: avx512f, avx512bw, avx512vbmi, bmi2 |
| - Excluded: ARM64, older x86-64, or -XX:-UseBASE64Intrinsics |
+------------------------------------+------------------------------------+
|
v
[ VULNERABLE: Heap Corruption -> Crash / Leak / RCE ]
Defensive Verification and JVM Flag Mitigation
Before restarting production workloads, engineers can run a safe, read-only host audit to check all three exposure gates (CPU flags, Java vendor/version, and active JVM flags):
#!/usr/bin/env bash
# Read-only Java4Shell (CVE-2026-114938) host exposure audit
set -euo pipefail
echo "=== 1. Architecture & AVX-512 VBMI CPU Check ==="
ARCH=$(uname -m)
echo "Architecture: $ARCH"
if [[ "$ARCH" == "x86_64" ]]; then
if grep -qE 'avx512vbmi' /proc/cpuinfo 2>/dev/null; then
echo "CPU Flag: avx512vbmi PRESENT (Hardware condition met)"
else
echo "CPU Flag: avx512vbmi NOT present (Not affected via this vector)"
fi
else
echo "Non-x86_64 architecture (Not affected)"
fi
echo "=== 2. Java Runtime Version Check ==="
if command -v java >/dev/null 2>&1; then
java -version 2>&1
else
echo "java binary not found in PATH"
fi
echo "=== 3. Running JVM Processes & Base64 Intrinsics Flag ==="
ps -ef | grep '[j]ava' | awk '{print $2, $0}' | while read -r pid cmd; do
if echo "$cmd" | grep -q -- '-XX:-UseBASE64Intrinsics'; then
echo "PID $pid: MITIGATED (-XX:-UseBASE64Intrinsics set)"
else
echo "PID $pid: CHECK JAVA VERSION (Base64 intrinsics enabled by default)"
fi
done
For Keycloak or general Java services where an immediate JDK upgrade is not possible, add -XX:-UseBASE64Intrinsics to JAVA_OPTS_APPEND (or your systemd unit / Kubernetes env:):
# Example Kubernetes Deployment snippet for interim Java4Shell mitigation
# Prefer upgrading to patched JDKs (17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1)
env:
- name: JAVA_OPTS_APPEND
value: "-XX:-UseBASE64Intrinsics"
Note on -XX:UseAVX=2: While -XX:UseAVX=2 also disables AVX-512 instructions on x86-64, Tenable and Calif note that Java on ARM64 processors fails to start if -XX:UseAVX=2 is passed. Prefer -XX:-UseBASE64Intrinsics, which is safe across architectures, and remember that neither flag is mentioned as a substitute for patching in Oracle's advisory.
Evidence & Operational Impact
Global Exposure Estimates vs. Practical Risk
- OX Research Exposure Telemetry (November 18, 2026): OX Research estimates that less than 0.12% of JVM instances worldwide meet all conditions for remote code execution, while approximately 0.8% are exposed to JVM crashes from the Base64 decoder bug.
- Why RCE Requires Target-Specific Engineering: Calif and CrowdStrike note that there is no single universal RCE exploit for Java4Shell; each target application requires a tailored payload aligned with its heap layout and Base64 decoding path. However, Tenable reported on November 18 that VulnCheck already has a working exploit for customers, Kevin Breen (Immersive) reported building one, and GreyNoise observed active exploitation attempts against its sensors.
- Discrepancies in Scoring & Benchmarks:
- CVSS Divergence: Red Hat scores CVE-2026-114938 at 9.8 (Critical) (CVSS 3.0), Calif scores it 9.2 (Critical) (CVSS 4.0), and Oracle scores it 8.1 (High) (CVSS 3.1), reflecting differing assumptions about attack complexity (
AC:Lvs.AC:H). - Performance Benchmarks: Quantitative throughput benchmarks measuring the CPU overhead of
-XX:-UseBASE64Intrinsicsin production workloads are unavailable in the fetched vendor advisories.
- CVSS Divergence: Red Hat scores CVE-2026-114938 at 9.8 (Critical) (CVSS 3.0), Calif scores it 9.2 (Critical) (CVSS 4.0), and Oracle scores it 8.1 (High) (CVSS 3.1), reflecting differing assumptions about attack complexity (
Hardening Playbook
Prioritize Internet-Facing Identity, CI/CD, and Collaboration Apps
- Audit Keycloak, Jenkins, Atlassian Jira, Confluence, JFrog Artifactory, and PingFederate instances first—especially those running on Intel Xeon Ice Lake+ or AMD EPYC Zen 4+ cloud VMs (check
/proc/cpuinfoforavx512vbmi).
- Audit Keycloak, Jenkins, Atlassian Jira, Confluence, JFrog Artifactory, and PingFederate instances first—especially those running on Intel Xeon Ice Lake+ or AMD EPYC Zen 4+ cloud VMs (check
Upgrade OpenJDK & Vendor Container Images
- Update OpenJDK builds to 17.0.21.1, 21.0.13.1, 25.0.5.1, or 27.0.1.1 (or your vendor's equivalent advisory build).
- For Keycloak, pull the updated
26.8container tags (latest,26.8,26.8.2, or26.8.2-3) shipped on November 19, 2026, which include Red Hat OpenJDK21.0.13.1(replacing vulnerable26.8.2-1and26.8.2-2x86-64 images).
Deploy
-XX:-UseBASE64IntrinsicsWhere Patching Must Wait- Add
-XX:-UseBASE64Intrinsicsto JVM startup arguments and restart the service. Verify the active flag viajcmd <PID> VM.flagsorps -ef | grep java.
- Add
Monitor for JVM Crashes and Post-Exploitation Activity
- Alert on unexpected JVM
SIGSEGV/hs_err_pid*.logcrashes, anomalous outbound connections, or unexpected shell/child processes spawned by thejavaprocess (such assh,bash,curl, orpython).
Example SIEM detection query (Splunk/SPL-style) for suspicious child processes spawned by Java:
index=edr OR index=sysmon parent_process_name="java" process_name IN ("sh", "bash", "dash", "curl", "wget", "python3", "nc") | stats count values(command_line) as cmds by host, user, process_name, _time span=15m- Alert on unexpected JVM
Rollback & Change-Control Notes
- Flag Rollback: If
-XX:-UseBASE64Intrinsicscauses unacceptable Base64 decoding latency in a high-throughput service, prioritize an immediate upgrade to a patched JDK (17.0.21.1+) rather than removing the flag on an unpatched runtime. - JDK Upgrade Rollback: Keep the previous JDK container tag or package tarball staged during rollout so you can revert if an application encounters an unrelated minor-patch regression—while keeping
-XX:-UseBASE64Intrinsicsactive if you must temporarily roll back.
- Flag Rollback: If
Frequently Asked Questions (FAQ)
1. Are Java 8, Java 11, or ARM64 servers vulnerable to Java4Shell (CVE-2026-114938)? No. According to OX Security, Quarkus, and Red Hat, Java 8, Java 11, IBM Semeru (OpenJ9), and ARM64 processors are not affected. Only OpenJDK 17.0.6 and later (through 27) running on x86-64 CPUs with AVX-512 VBMI are in scope.
2. How can I quickly check if my Linux server has an AVX-512 VBMI CPU?
Run grep -o 'avx512vbmi' /proc/cpuinfo | head -n 1. If it outputs avx512vbmi, the hardware condition is met and you should check your Java version and patch or apply -XX:-UseBASE64Intrinsics.
3. Is -XX:-UseBASE64Intrinsics safe to use in mixed x86-64 and ARM64 Kubernetes clusters?
Yes. Unlike -XX:UseAVX=2 (which causes Java to fail on startup on ARM64), -XX:-UseBASE64Intrinsics is recognized across architectures and disables only the Base64 intrinsic.
4. Why do Oracle, Red Hat, and Calif list different CVSS scores for CVE-2026-114938? Oracle scored it 8.1 (High, CVSS 3.1), Calif scored it 9.2 (Critical, CVSS 4.0), and Red Hat scored it 9.8 (Critical, CVSS 3.0) based on differing evaluations of attack complexity and environmental prerequisites.
5. Is CVE-2026-114938 being actively exploited in the wild? As of November 18, 2026, GreyNoise reported scanning/exploitation attempts against its sensors without confirming successful exploitation, while VulnCheck and Immersive reported building working exploits.
Sources
- Red Hat Customer Portal — CVE-2026-114938 (Java4Shell). Published: November 18, 2026. URL: https://access.redhat.com/security/cve/cve-2026-114938
- Keycloak Official Security Advisory — Java4Shell: What Keycloak admins need to do (CVE-2026-114938). Published: November 18, 2026 (Updated: November 19, 2026, 08:00 UTC). URL: https://www.keycloak.org/2026/11/java4shell-vulnerability-cve-2026-114938
- Quarkus Official Blog — Java4Shell (CVE-2026-114938): Status and mitigation for Quarkus users. Published: November 19, 2026. URL: https://quarkus.io/blog/java4shell/
- Tenable Blog — Java4Shell (CVE-2026-114938): OpenJDK RCE Vulnerability FAQ. Published: November 18, 2026. URL: https://www.tenable.com/blog/java4shell-cve-2026-114938-frequently-asked-questions-about-openjdk-rce-vulnerability
- OX Security — Java4Shell (CVE-2026-114938): RCE Risk and Exposure Analysis. Published: November 18, 2026. URL: https://www.ox.security/blog/java4shell-cve-2026-114938-rce-risk/
- Calif Research — Java4Shell: Write once, RCE everywhere. Published: November 20, 2026. URL: https://calif.io/java4shell