By clicking “Accept”, you agree to the storing of cookies on your device to enhance site navigation, analyze site usage, and assist in our marketing efforts. View our Privacy Policy for more information.
18px_cookie
e-remove
Blog

Java4Shell (CVE-2026-114938): Pre-Auth Heap Overflow in OpenJDK

Java4Shell (CVE-2026-114938) lets attackers corrupt memory in Java servers with a single malformed message, no login required. Researchers say it can lead to full takeover of Jenkins, Jira and Keycloak. A fix is out.

Written by
Peyton Kennedy
Peyton Kennedy
Published on
November 17, 2026
Updated on
November 18, 2026

TL;DR

Java4Shell (CVE-2026-114938) is a critical vulnerability in OpenJDK, the open source software that runs most Java applications. Security firm Calif, which found and reported the flaw, published details on November 17 after the vulnerability leaked before its planned disclosure. An attacker who sends a specially crafted piece of encoded data to an affected Java application can make it write past the end of a block of memory it set aside. On its own, that usually crashes the application.

By combining the flaw with the way a specific application uses memory, an attacker can take control of the server without logging in. The vulnerability is rated 9.2 out of 10 on CVSS 4.0, the industry's standard severity scale, which places it in the critical range. That score describes the worst case. Real exposure depends on the Java version (17.0.6 and later), the server's processor (recent Intel and AMD server chips that support a feature called AVX-512 VBMI, which covers much of current cloud capacity) and the application running on it. ARM-based servers, such as AWS Graviton, are not affected. No attacks in the wild have been reported as of November 17.

OpenJDK has published a fix, but each Java vendor will ship its fixed build on its own schedule. Organizations should install their vendor's update as soon as it is available. Until then, a JVM setting turns off the vulnerable code.

Introduction

ava4Shell (CVE-2026-114938) is a heap buffer overflow in the AVX-512 Base64 decoder of OpenJDK's HotSpot JVM on x86-64. Crafted Base64 that a vulnerable JVM decodes makes it write 62 or 63 bytes past the end of a heap array. The bytes written are a fixed value, so on its own the bug corrupts memory or crashes the JVM. Calif, which found and reported it, says that combined with a target application's own memory behavior it escalates to pre-authentication remote code execution, and names six products where it demonstrated this in default configurations.

The fix is four lines under JDK-8393212, titled "Base64 optimization improvements." It is in OpenJDK 27.0.1.1 and in mainline. As of November 17, the public jdk17u, jdk21u and jdk25u update repositories did not yet carry it.

If you run Java 17.0.6 or later, or any release from 18 on, on x86-64 hosts with AVX-512 VBMI, patch now. Where you cannot patch yet, the JVM flags in the mitigation section turn off the vulnerable code path.

Affected versions

Every HotSpot release from 17.0.6 on carries the vulnerable decoder, so exposure is wider than Java 17. Whether a given JVM can reach it depends on the CPU.

Condition Status
OpenJDK 17.0.6 and later, and every release from 18 up (including 21, 25 and 27), on x86-64 with AVX-512 VBMI Affected
OpenJDK 17.0.0 to 17.0.5 Not affected. No x86 decode stub exists before 17.0.6
Java 8 and 11 Not affected. Neither has the x86 decode stub
x86-64 without AVX-512 VBMI, such as Skylake-SP, Cascade Lake, or AMD before Zen 4 Not affected. The vulnerable tail logic is in the VBMI vector path
ARM64, including AWS Graviton and Apple silicon Not affected. The x86 stub is never generated
java.util.Base64 MIME decoder, or any Base64 library that does not call java.util.Base64 Not affected. MIME input takes the scalar path, and other libraries do not reach the intrinsic
Product / Java line Affected Fixed upstream build Sources
Java 17 up to 17.0.21.0.3 (from 17.0.6, per Calif and Red Hat) 17.0.21.1 [2] [3] [1] [4] [5] [6]
Java 21 up to 21.0.13.0.3 21.0.13.1 [2] [3] [7]
Java 25 up to 25.0.5.0.3 25.0.5.1 [2] [3] [8]
Java 27 up to 27.0.1.0.3 27.0.1.1 [2] [3] [9]
Java 22, 23, 24, 26 (end of life) not listed by Oracle or OpenJDK; Amazon Linux 2023 marks its Corretto packages "No Fix Planned" none; move to a supported line [10] [11]
Oracle Java SE 8 -perf build 8u511b33-perf see Oracle's advisory [2]
Oracle GraalVM for JDK 17.0.21.0.3, 21.0.13.0.3 17.0.21.1, 21.0.13.1 [2] [12] [13]
Oracle GraalVM Enterprise Edition 21.3.20.0.3 21.3.20.1 [2] [14]
Java 8 and 11 (standard builds) not listed as affected n/a [3] [15]

AVX-512 VBMI is present on Intel Ice Lake and later server parts (Sapphire Rapids, Emerald Rapids, Granite Rapids) and on AMD Zen 4 and later, which covers much of current cloud capacity. Check each host with the same JDK and JVM options the service uses:

grep -o -w -m1 'avx512vbmi' /proc/cpuinfo
java -XX:+PrintFlagsFinal -version | grep -E ' (UseAVX|UseBASE64Intrinsics) '

If the first command prints avx512vbmi, UseAVX is above 2, and UseBASE64Intrinsics is true, the vulnerable path is live on that JVM.

Fixed builds

Oracle's November CSPU lists the builds below across all 11 of its Java SE fixes. That list is not a per-CVE scope.

Distribution Fixed builds Status
OpenJDK / Oracle Java SE 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1 released 17 Nov [6] [7] [8] [9] [5]
Amazon Corretto 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2, 27.0.1.1.4 released 17 Nov; Amazon Linux 2023 packages for 22, 23, 24 and 26: no fix planned [10] [17] [18] [19]
Azul Zulu builds based on 17.0.21.1+2, 21.0.13.1+2, 25.0.5.1+2, 27.0.1.1+4 released 17 Nov [20]
Eclipse Temurin 27.0.1.1+4 17, 21 and 25 pending [21] [22] [23] [24]
Debian 17.0.21.1+2-1, 21.0.13.1+2-1, 25.0.5.1+2-1, 27.0.1.1+4-1 fixed in unstable (sid) only; stable releases still vulnerable [25]
Red Hat none yet RHEL 8, 9 and 10 and Red Hat build of OpenJDK 17, 21 and 25 confirmed affected; fixes in preparation [15]
Ubuntu none yet no fixed packages yet; status varies by release [26]
Microsoft Build of OpenJDK none found upgrade and Azure WAF mitigation guidance published 17 Nov [27]
BellSoft Liberica, IBM Semeru, SAP SapMachine none found no public advisory found

Eclipse Temurin, Amazon Corretto, Azul Zulu, Microsoft Build of OpenJDK, Red Hat build of OpenJDK and the distro openjdk-17 packages ship on their own schedules and version labels. Read each vendor's fixed build from its own advisory. Do not infer it from Oracle's numbering.

What's happening

Calif published its writeup on November 17, and the fix is now visible in public OpenJDK source. The table separates what has been verified from what the reporter claims.

Claim Status Basis
Heap overflow in the x86-64 AVX-512 Base64 decode intrinsic Verified Calif's writeup and the fix diff in openjdk/jdk27u
Fix is JDK-8393212 Verified Diff between tags jdk-27.0.1-ga and jdk-27.0.1.1-ga
Overflow is 62 bytes for a = tail, 63 for == Verified by reproduction Our reproduction under an AVX-512 emulator on Temurin 17.0.10 and 17.0.12. Upwind reports the 62-byte case on real hardware
Overflow bytes are a fixed value, independent of the input's data Verified by reproduction Our content differential. Upwind reports the same
CVE-2026-114938 is the CVE for JDK-8393212 Not confirmed The mechanism matches Calif's writeup exactly. I could not retrieve the OpenJDK advisory that would state the mapping
Pre-auth RCE in Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate Claimed by Calif Default configurations, per Calif. No public proof-of-concept shell
Post-auth RCE in Kafka, Solr, Elasticsearch, Gerrit and Spinnaker Claimed by Calif No public proof of concept
CVSS 4.0 score of 9.2 Stated by Calif No vector string has been published
Exploited in the wild None reported Not in CISA KEV as of November 17

Timeline

Date Event
Nov 17, 2026 OpenJDK tag jdk-27.0.1.1-ga carries JDK-8393212
Nov 17, 2026 Calif publishes its Java4Shell writeup, withholding its weaponized chains
Nov 17, 2026 Calif posts that it discovered and reported Java4Shell and that the bug leaked
Nov 17, 2026 Oracle's November CSPU: 11 Java SE fixes, all described as remotely exploitable without authentication, highest CVSS 3.1 score 8.1
Nov 16 to 17, 2026 NCSC advisory to Korean public institutions flags an unauthenticated Java RCE
Oct 14, 2026 JDK-8393212 committed under embargo as "Base64 optimization improvements"
Jan 2023 OpenJDK 17.0.6 ships with the AVX-512 Base64 decoder backported from JDK 18

Root cause

The bug is in the final step of HotSpot's AVX-512 Base64 decoder, which C2 uses in place of the Java implementation once Base64.Decoder is hot. Calif describes it as a miscalculated store mask for a padded tail. When the input ends in a padded fragment shorter than one four-character block, the output-size computation underflows, the store mask covers a full 64-byte write, and the decoder writes 62 bytes past the end of its output array, or 63 for a == tail. Java then rejects the input with IllegalArgumentException, after the write has happened.

The fix adds a guard at L_finalBit in stubGenerator_x86_64.cpp that sends that short tail to the scalar path before the size computation runs:

+    // A padded Base64 tail shorter than one complete block is handled by Java.
+    __ cmpl(length, 4);
+    __ jcc(Assembler::less, L_bruteForce);

The commit title, "Base64 optimization improvements," gives no hint that it is a security fix.

The vector path only runs on inputs above a length threshold, which sets the shortest trigger. On Java 17 the threshold is 128 bytes, so the shortest trigger is 129 characters. On 21, 25 and 27 the threshold is 31 bytes, and the shortest trigger is 65 characters: one full 64-byte block plus a short padded tail.

The overflow content is a constant. In our reproduction, two inputs that differed only in their data characters left byte-identical out-of-bounds regions. The attacker controls where the write lands, and nothing about what it writes. The write destroys the next object's header, and the usual result is a SIGSEGV inside garbage collection. Upwind reports that no valid Base64 string overflowed across 300,000 runs.

How exploitation works

Because the decoder writes a fixed pattern, it corrupts memory or crashes the JVM by itself. Calif's escalation to code execution depends on the target application. Calif describes five stages:

  1. Corrupt one array's length, so the application's own writes into that array run out of bounds with attacker-chosen bytes.
  2. Corrupt a second array whose contents the application returns in a response, which leaks heap memory. Calif calls this JavaBleed.
  3. Repair the damaged object headers so the JVM keeps running.
  4. Groom the heap remotely so the overflow lands on a chosen object.
  5. Direct the resulting writes at the JVM's Code Cache.

Calif states there is no universal exploit. Each target needs its own decoder route, a writable buffer, a readable feedback channel, a usable heap layout and an application action. That is why the claimed impact is product-specific. Calif's public page shows no shell and withholds the weaponized chains but has a demonstration video with multiple popular applications like Jira, Confluence, Keycloak, and more being exploited with planted webshells.

Severity in context

Calif scores Java4Shell 9.2 under CVSS 4.0. Oracle scores Java SE under CVSS 3.1, and its highest Java SE score in the November CSPU is 8.1. No vector string has been published for this CVE.

One score covers a wide range of real outcomes. On its own the overflow crashes the JVM, which is a pre-auth denial of service on any reachable vulnerable service. Code execution, per Calif, needs the per-target conditions described above. The hosts to fix first are internet-facing AVX-512 VBMI machines running the six products Calif names as pre-auth targets.

For context, last month's PHP2Shell, another leaked runtime RCE scored 9.2 under CVSS 4.0, has since been added to CISA KEV.

Detection

The highest-fidelity signal is the input itself. Flag any Base64 field that ends in = or == and whose length is not a multiple of 4. Well-formed encoders never produce padded Base64 of that shape. On Java 21, 25 and 27 the trigger can be as short as 65 characters. On Java 17 it is 129 characters or more. Use 65 as the lower bound if you run mixed trains.

Behavioral signals that fit the exploitation model:

  • High-rate Base64 decode traffic from one source, with deliberate pacing or fragmentation. Remote heap grooming needs many precisely placed requests.
  • Bursts of IllegalArgumentException from java.util.Base64 in request-handling code. Every trigger throws after the write.
  • Oversized or binary-looking responses from endpoints that normally echo decoded input. That is the shape of the heap-leak feedback channel.
  • Repeated hs_err crashes with a SIGSEGV in a garbage-collection copy routine and a compiled Base64$Decoder.decode0 frame, especially clustered by source. Failed placement crashes the JVM, and the attacker retries.

Mitigation

  1. Find the JVM each service actually runs. java -version reports whatever is on the shell's path, and products such as Jenkins, Jira, Confluence, Keycloak and Elasticsearch often bundle their own runtime. Check the live process instead:
ps -eo pid,args | grep '[j]ava'
readlink -f /proc//exe
jcmd  VM.version

Run jcmd as the same user as the target process. For containers, check the base image in every Dockerfile and pipeline so the next deploy does not reintroduce an old JDK.

  1. Check whether the vulnerable path is live. Run the CPU and flag check from the affected-versions section on each host. ARM64 hosts and x86 hosts without AVX-512 VBMI can wait for the normal patch cycle.
  2. Patch. Install your vendor's November 2026 build that carries JDK-8393212. If you build from OpenJDK LTS source, confirm your tree contains JDK-8393212 first. As of November 17 the public jdk17u, jdk21u and jdk25u repositories did not carry it, even though Oracle's matching builds are in the CSPU. An LTS build whose version number matches a "fixed" column can still run the vulnerable code. Rebuild and redeploy container images, restart every Java process, and confirm the running build with jcmd.
  3. If you cannot patch yet, turn off the vulnerable path. Add one of these JVM options, in order of preference:
  • -XX:+UnlockDiagnosticVMOptions -XX:DisableIntrinsic=_base64_decodeBlock turns off only the decode intrinsic. This is the narrowest option.
  • -XX:-UseBASE64Intrinsics turns off the Base64 encode and decode intrinsics.
  • -XX:UseAVX=2 turns off all AVX-512 code and can slow other work. Use it only if the first two are not available.

Confirm the setting took effect with -XX:+PrintFlagsFinal, and remove it after patching.

  1. Prioritize by exposure. Patch internet-facing AVX-512 VBMI hosts running Keycloak, Jira, Confluence, Artifactory, Jenkins or PingFederate first.

Actions for Endor Labs customers

Java4Shell sits in the Java runtime. Your pom.xml or build.gradle does not declare the JDK, so dependency scanning of application manifests will not surface it.

Use container scanning to find images that carry OpenJDK packages from 17.0.6 on, including 21, 25 and 27. Container reachability adds evidence about whether the affected OS package is used at runtime. That helps order the work. It does not see the host CPU or whether attacker input reaches the decoder, so we recommend upgrading affected Java runtimes regardless of reachability status.

When the JDK comes from a base image, base image remediation compares your current image with a refreshed build, the next version and the latest version. Once your JDK vendor publishes its fixed build, confirm the candidate image includes it, then rebuild, redeploy and rescan.

Resources