Memory Safety

Java4Shell (CVE-2026-114938): how dangerous the JVM Base64 flaw is and how to patch now

TL;DR

Java4Shell (CVE-2026-114938) is a 62-byte heap overflow in HotSpot's AVX-512 Base64 decoding path, affecting JDK 17.0.6+, 21, 25 and 27 on x86-64 CPUs with AVX-512 VBMI. Oracle and OpenJDK patched it on 17 Nov 2026 and CISA and Canada issued urgent alerts. Crashing the JVM is easy; remote code execution is harder but has been demonstrated on Jira, Jenkins, Keycloak and more.

Watch on Facebook
On this page

On 17 November 2026, Oracle and the OpenJDK project shipped fixes for CVE-2026-114938, a flaw the security community has named Java4Shell. The same day, the US agency CISA issued an alert urging immediate patching. The Canadian Centre for Cyber Security contributed to that alert and published its own advisory, AL26-029, the next day. What makes it alarming is where the bug lives: not in some obscure library, but in the Java virtual machine's own Base64 decoder, which almost every Java web application calls before a user has even logged in.

This post uses animated diagrams to explain where the bug is, how a short string can corrupt JVM memory, how dangerous it really is, and the concrete steps to check and patch. It is current as of 19 November 2026. Patch status changes daily for each distribution, so always check your vendor's official advisory.

At a glance

ItemDetails
Faulty componentThe java.util.Base64 decoder: an AVX-512 optimized path in the HotSpot JVM on x86-64
Affected versionsOpenJDK 17.0.6 and later, the 21, 25 and 27 lines, plus Oracle Java 8 Performance Pack. Standard Java 8 and 11 are not affected
Hardware conditionx86-64 CPUs with AVX-512 VBMI (Intel Ice Lake and later, AMD Zen 4 and later). ARM64 is not affected
SeverityOracle: CVSS 3.1 = 8.1 (High). Calif, the finder: CVSS 4.0 = 9.2 (Critical)
ImpactCrashing the JVM (easy); unauthenticated remote code execution (hard, but demonstrated)
Exploitation in the wildAs of 18 Nov: GreyNoise saw exploitation attempts, no confirmed successful attacks; not in CISA's KEV catalog

Where is the bug?

Base64 turns binary data into text so it can travel over HTTP. It is everywhere: Authorization: Basic headers, JWTs, SAML, cookies, CSRF tokens, MIME email. Because it is called so often, the JVM does not run the decoder as ordinary Java code. When the CPU supports it, HotSpot swaps in hand-written machine code (an intrinsic) that uses AVX-512 instructions to decode 64 bytes at a time.

The bug is in how that code handles the tail of the string. According to Calif and several security vendors, a malformed Base64 string ending in a stray = makes the code compute a negative length. Instead of writing a few bytes, it writes a full 64-byte block, spilling 62 bytes past the end of the output array and over whatever object sits next to it on the heap. Only afterwards does Java notice the bad input and throw IllegalArgumentException. By then the memory is already corrupted.

HTTP requestAuthorization: Basic AAAA…A=Tomcat / Spring / java-jwtdecodes BEFORE authenticationBase64.getDecoder().decode(input)CPU has AVX-512 VBMI?x86-64 + JDK 17.0.6+AVX-512 fast pathhand-written machine codeYes62-byte overflowheap corrupted → crash / RCENormal decoding pathrejects input, safeNo
Animated: a malicious Base64 string travels from an HTTP header to the faulty AVX-512 code. CPUs without AVX-512 VBMI take the normal decoding path and are not affected.
Heap overflowoutput arraya few valid bytesneighbouring objectheader, pointersneighbouring objectheader, pointersneighbouring objectarray length, dataneighbouring objectarray length, dataintended write62 bytes written too far → other objects overwrittenOnly then does Java throw IllegalArgumentException: memory is already corrupted
Animated: a 62-byte write past the output array overwrites the neighbouring object on the heap (not to scale).

Here is the irony: teams pick Java because it is memory-safe, but that safety net only covers Java code. The native code inside the JVM itself can still make the classic C/C++ mistakes. Calif also describes a read-side variant that could leak memory contents, much like Heartbleed did in 2014.

How dangerous is it?

In Calif's tests with default configurations, these applications were exploitable:

LevelProducts (per Calif)
Unauthenticated RCEKeycloak, Atlassian Jira, Confluence, JFrog Artifactory, Jenkins, PingFederate
Post-authentication RCEApache Kafka, Apache Solr, Elasticsearch, Gerrit, Spinnaker
Client sideA Java program connecting over TLS to an attacker-controlled server

The list is not exhaustive. Typical pre-login entry points are Basic auth in Tomcat, Jetty and Spring Security, and the java-jwt library, all of which decode Base64 before checking the password. These are the systems holding source code, single sign-on accounts and CI/CD pipelines. Owning them means owning the keys to the whole organisation.

Turning the bug into code execution is not easy, though. That is why Oracle scores it 8.1 with “high attack complexity”:

Conditions for exploitation1. JDK 17.0.6+ / 21 / 25 / 27 (standard Java 8 and 11 are safe)2. x86-64 CPU with AVX-512 VBMI (Ice Lake+, Zen 4+)3. External Base64 reaches the decoder (often before login)4. Heap grooming + a leak to beat ASLR, per-app exploitCrash the JVM (DoS)easy, repeatableRemote code executionhard, but exploits exist
Condition funnel: fewer systems qualify at each level, but crashing the JVM is far easier than running code.
  • Crashing the JVM is easy and can be repeated at will, which makes it a denial-of-service attack.
  • Remote code execution requires heap grooming plus a separate memory leak to defeat ASLR. Each application needs its own exploit.
  • Calif has only published a PoC that checks whether a given JDK and CPU combination reproduces the bug, and is holding back product-specific chains. VulnCheck says it has a working code-execution exploit for its customers. A researcher at Immersive has also built one.
  • Calif says it found the bug in about an hour with AI assistance and had a first working exploit about two hours later. The gap between disclosure and mass exploitation keeps shrinking.

Compared with Log4Shell in 2021: Log4Shell was a logic bug in a library, exploitable with a single string on any machine. Java4Shell is a memory bug in the JVM itself, with a wider surface (no specific library needed), but limited by CPU type and much harder to exploit.

Check your systems

checking a server for Java4Shell# 1) Does the CPU have all 4 flags?$ grep -o -w -E 'avx512f|avx512bw|avx512vbmi|bmi2' /proc/cpuinfo | sort -uavx512bw · avx512f · avx512vbmi · bmi2 (4 lines = condition met)# 2) Find every JVM, including JREs bundled with apps$ find / -name libjvm.so 2>/dev/null/usr/lib/jvm/java-21-openjdk/lib/server/libjvm.so/opt/atlassian/jira/jre/lib/server/libjvm.so ← JRE bundled with Jira# 3) Check the version$ /opt/atlassian/jira/jre/bin/java -versionopenjdk version "21.0.13"⚠ all 4 CPU flags + unpatched JDK 21 → PATCH NOWIllustrative · paths are examples
Three checks on a Linux server (illustrative; paths are examples).
# 1. Does the CPU have all 4 flags? (4 lines = hardware condition met)
grep -o -w -E 'avx512f|avx512bw|avx512vbmi|bmi2' /proc/cpuinfo | sort -u

# 2. Find EVERY JVM on the machine, including JREs bundled with Jira, Jenkins...
find / -name libjvm.so 2>/dev/null

# 3. Check the version of each JVM found
/opt/app/jre/bin/java -version

Step 2 matters: many products ship their own JRE, which apt upgrade never touches. The same goes for containers, so check every image.

Patching and mitigation

DistributionFixed builds (status on 18 Nov 2026)
Oracle JDK17.0.21.1 · 21.0.13.1 · 25.0.5.1 · 27.0.1.1 · Java 8 Performance Pack 8u513-perf
Oracle GraalVM17.0.21.1 · 21.0.13.1 · Enterprise 21.3.20.1
Amazon CorrettoAvailable, e.g. 17.0.21.1.2
Azul ZuluFixed builds released
Eclipse TemurinRolling out 17.0.21.1 · 21.0.13.1 · 25.0.5.1 · 27.0.1.1
Red Hat, Ubuntu, Debian, Microsoft, SapMachine, LibericaNot yet, or incomplete. Follow each vendor's advisory

If you cannot upgrade yet, Calif and security vendors suggest temporary JVM flags. Note that Oracle and OpenJDK have not published any official workaround.

# Disable the optimized Base64 path (needs a JVM restart; test performance first)
java -XX:-UseBASE64Intrinsics -jar app.jar

# Heavier option: disable AVX-512. x86-64 ONLY,
# a JVM on ARM will refuse to start with this flag
java -XX:UseAVX=2 -jar app.jar
  • Per CISA: restrict and validate Base64 input at the application boundary, enforce input-size limits, and limit unauthenticated access to affected systems.
  • Don't rely on a reverse proxy: Qualys and Upwind both say proxies and request buffering do not reliably block it. The malicious string is very short, so size limits alone are not enough either.
  • Watch for signs: unexpected JVM crashes (hs_err_pid*.log files), bursts of IllegalArgumentException from java.util.Base64$Decoder, Java processes restarting repeatedly, and rogue JVMs missing from your inventory.

What should you do?

  • Dev: check the JDK version in your Dockerfiles and base images. Move to a fixed build and rebuild. Don't just change a tag and forget to rebuild the images that depend on it.
  • Tech Lead / DevOps: inventory every JVM, including JREs bundled in purchased products, and prioritise internet-facing systems on AVX-512 hardware: SSO (Keycloak, PingFederate), Jira/Confluence, Jenkins, Artifactory. Where you cannot patch yet, enable -XX:-UseBASE64Intrinsics after testing, and alert on JVM crashes.
  • PM: treat this as an incident to plan this week, not next sprint's backlog. Ask your software vendors (Atlassian, JFrog, Ping…) for their patch timelines. Prepare customer communication in case login systems need maintenance.

Sources & references

  1. Critical Java Vulnerability Requires Immediate Patching — CISA
  2. OpenJDK Vulnerability Advisory: 2026/11/17 — OpenJDK Vulnerability Group
  3. Oracle Critical Security Patch Update – November 2026 — Oracle
  4. Java4Shell — Calif
  5. AL26-029 – Critical vulnerability impacting Oracle Java (CVE-2026-114938) — Canadian Centre for Cyber Security
  6. Java4Shell (CVE-2026-114938): Frequently Asked Questions — Tenable
  7. Java4Shell OpenJDK flaw: Exploitation is tricky and hinges on specific CPUs — Help Net Security
  8. Java4Shell: What We Know Now and What Comes Next — Upwind
  9. How to Find, Mitigate, and Patch the Critical Java4Shell Flaw — Qualys