Threat Reports

CVE-2026-114938 Affects Multiple OpenJDK Versions Through a Base64 Decoder Flaw

Threat Reports

Published on

Read time

4 min

Share this insight

Summary:

Oracle released a security update on November 17, 2026 for CVE-2026-114938, nicknamed Java4Shell, a critical out-of-bounds heap write (CVSS 4.0 score 9.2) in OpenJDK's optimized Base64 decoder that can be reached through unauthenticated input and can potentially lead to remote code execution. The flaw affects OpenJDK 17.0.6 and later, including 21, 25, and 27, on x86-64 processors with AVX-512 VBMI support, and the write occurs before the application can reject the malformed input. Security firm Calif discovered the flaw, a public proof of concept exists, and details reportedly leaked before the patch. No exploitation in the wild had been confirmed as of November 17, 2026. Organizations should patch immediately or disable the vulnerable intrinsic.

Technical Description:

CVE-2026-114938 is an integer underflow that leads to an out-of-bounds heap write in the HotSpot AVX-512 Base64 decode intrinsic, a hand-written assembly routine that the JIT compiler substitutes for java.util.Base64.Decoder to speed up decoding once a code path becomes hot. The padding handler decrements a decoded-size counter without a lower bound, so a crafted input longer than 128 bytes that ends in a short padded tail with = drives the counter below zero and corrupts the destination pointer and store mask. This produces an overflow of about 62 bytes past the output buffer. Java later rejects the malformed input, but neighboring heap memory has already been corrupted.

The flaw sits in the Java runtime itself, so no application or library needs to be at fault; any application that passes attacker-controlled data to the decoders returned by Base64.getDecoder() or Base64.getUrlDecoder() may be exposed. The MIME decoder returned by Base64.getMimeDecoder() does not take the affected path. The write happens before application code can validate the input or catch the exception, and corrupting a neighboring object can damage information the JVM uses later, including during garbage collection. Calif reported that the flaw can leak heap memory and lead to pre-authentication remote code execution, and VulnCheck found that crashing a vulnerable JVM requires no special exploitation techniques once a vulnerable decode path is reachable.

Exposure requires an unpatched OpenJDK-based build from 17.0.6 onward, from any vendor, running on x86-64 processors with AVX-512 VBMI, such as Intel Xeon from Ice Lake and AMD EPYC from Zen 4, with the C2 compiler and the Base64 intrinsic enabled, which is the default on server JVMs. Standard Java 8 and Java 11 builds are not affected because the intrinsic was never added to those lines, although Oracle's patch release lists them for other vulnerabilities. Oracle's update addresses the flaw, and where updates cannot be deployed immediately, disabling the intrinsic stops the overflow.

| CVE | CVSS | Vulnerability Type | Affected Product | Patch Version |

| CVE-2026-114938 | 9.2 (Critical) | Out-of-Bounds Write (Base64 Decoder) | OpenJDK (17.0.6 and later) | Oracle November 2026 Update |

Exploitation Demonstration:

  • An attacker identifies a Java application or service running an affected OpenJDK build on an AVX-512 capable x86-64 host that processes input through java.util.Base64, such as Base64.getDecoder() or Base64.getUrlDecoder().
  • The attacker repeatedly sends valid Base64 data so that the decode path becomes hot and the JIT compiler substitutes the vulnerable optimized decoder.
  • The attacker then sends a crafted input longer than 128 bytes that ends in a short padded tail, causing the decoder's size counter to underflow and a write of about 62 bytes past the output buffer.
  • The corrupted neighboring heap data can be used to leak memory or manipulate object metadata, potentially leading to code execution, even though Java rejects the input afterwards.
  • Public research shows that crashing the JVM takes little effort and that Calif has demonstrated remote code execution.

Ease of Exploitation:

The trigger is a short malformed Base64 string, the root cause is public, and a public write-up includes a reproducer, which lowers the barrier to exploitation. Exploitation requires a reachable code path that decodes attacker-controlled Base64 and an AVX-512 VBMI capable processor. Triggering a JVM crash is reported to be trivial, while reliable code execution depends on the memory next to the buffer; Calif has demonstrated pre-authentication remote code execution. No exploitation in the wild had been confirmed as of November 17, 2026.

Conclusion:

CVE-2026-114938 represents a significant security risk to organizations running Java services on modern x86-64 server hardware because the flaw lies in the runtime itself, can be reached through ordinary Base64 handling, and has public technical details and a reproducer. Organizations should apply vendor updates immediately and use the JVM flag mitigation where patching must wait.

Impact:

Successful exploitation could lead to JVM crashes and denial of service, leakage of heap memory, and potentially pre-authentication remote code execution on affected Java servers, allowing attackers to execute code in the application's context, access sensitive data, and move laterally. Many internet-facing Java systems could be exposed until patched.

IOC and Context Details:

| Topics | Details |

| Tactic Name | Initial Access, Execution |

| Technique Name | Exploit Public-Facing Application |

| Sub Technique Name | NA |

| Attack Type | Vulnerability |

| Targeted Applications | OpenJDK-based Java runtimes 17.0.6 and later, including Oracle Java SE and GraalVM, on AVX-512 VBMI x86-64 hosts; applications using java.util.Base64 |

| Region Impacted | Global |

| Industry Impacted | All industries running Java applications and services |

| IOC’s | JVM crashes with hs_err_pid log files or core dumps faulting in the Base64 intrinsic or vectorised decoder; unexpected IllegalArgumentException for malformed Base64 padding in application logs; Base64 inputs longer than 128 bytes ending in a short = padded tail |

| CVE | CVE-2026-114938 |

Recommended Actions:

  • Apply Oracle's November 17, 2026 update and the equivalent OpenJDK vendor updates for Java 17, 21, 25, and 27 builds, and restart services so the patched runtime is loaded.
  • Inventory Java workloads, including containers, application servers, and embedded runtimes, and identify runtimes from 17.0.6 onward running on AVX-512 VBMI capable hosts, prioritizing internet-facing services.
  • If patching must wait, disable the Base64 intrinsic with -XX:-UseBASE64Intrinsics, adding -XX:+UnlockDiagnosticVMOptions where the JVM requires it, and test the performance impact on applications that decode large volumes of Base64.
  • As an alternative on x86-64, start the JVM with -XX:UseAVX=2 to disable the AVX-512 path, and avoid -XX:DisableIntrinsic=_base64_decodeBlock on its own, which can prevent the JVM from starting.
  • Do not rely on application-level input validation as a mitigation, since the memory write occurs inside the decoder before application code can reject the input.
  • Monitor for JVM crashes, including hs_err_pid log files and core dumps with faults in the Base64 intrinsic or vectorised decoder, and for unexpected restarts of Java services.
  • Review web application firewall and API gateway logs for unusually long Base64 values ending in malformed = padding, particularly from untrusted clients.
  • Track vendor advisories and the CISA Known Exploited Vulnerabilities catalog for any change in exploitation status; if compromise is suspected, preserve memory and logs, isolate the host, and rotate secrets accessible to the JVM.

Reference:
https://securitylabs.datadoghq.com/articles/java4shell-remote-code-execution-in-openjdk-cve-2026-114938/