Java4Shell Turns an OpenJDK Base64 Decoder Into a Remote Code Execution Path

Calif disclosed Java4Shell as CVE-2026-114938 on 17 November 2026. The flaw sits in OpenJDK's accelerated Base64 decoder, and the demonstrated chains end in remote code execution.

"Netics card on Java4Shell, CVE-2026-114938, inside the OpenJDK Base64 decoder."
"Netics editorial visual on the OpenJDK Base64 decoder flaw disclosed on 17 November 2026."

TL;DR

  • Java4Shell is a memory-corruption vulnerability in the Base64 decoder of OpenJDK, the open-source Java runtime that most Java software runs on, and Base64 is the text encoding Java applications use to carry authentication headers, tokens and file uploads.
  • Calif disclosed it on 17 November 2026 as CVE-2026-114938 with a CVSS 4.0 score of 9.2 out of 10 (critical), and OpenJDK published its advisory while Oracle shipped patched builds in its November 2026 Critical Patch Update the same day at 21:00 UTC.
  • The trigger is 64 "A" characters followed by "=": the decoder computes a negative output length, turns it into a 64-byte write and lands 62 bytes past a 50-byte result array, and on OpenJDK 17 the same trigger needs 128 characters.
  • The vulnerable path exists on OpenJDK 17.0.6 or newer running on an x86-64 processor with AVX-512 VBMI, which covers Amazon Corretto, Eclipse Temurin, Azul Zulu, Microsoft Build of OpenJDK, Red Hat OpenJDK, SAP SapMachine, BellSoft Liberica and Oracle builds. Calif states that ARM64 CPUs are not affected.
  • Calif demonstrated pre-authentication remote code execution against Keycloak, Atlassian Jira, Confluence, JFrog Artifactory, Jenkins and PingFederate, and post-authentication execution against Apache Kafka, Solr, Elasticsearch, Gerrit and Spinnaker.
  • Cloudflare added six managed WAF rules that log matching requests by default, and two JVM startup flags remove the accelerated decoder as a stopgap.
  • The durable fix is an inventory of every Java runtime in the estate, because application bundles, container images and running JVMs each keep their own copy of the decoder.

The vulnerability exposes a boundary in Java's memory-safety promise. Java sells memory safety: the runtime manages allocations, checks bounds, and keeps the sort of bug that produced decades of C exploits away from application developers. Java4Shell arrives through the one layer where that promise has never applied, the hand-written machine code that the runtime substitutes for its own generic implementation when a processor offers a faster instruction. Calif found the flaw in that substitution, and the runtime's safety net arrived after the overwrite.

Cloudflare post header graphic showing the Java logo inside a magnifying glass, blog.cloudflare.com/java4shell-waf-protection
The header image of Cloudflare's Java4Shell post, which documents the flaw and the managed rules released in response. Source: blog.cloudflare.com/java4shell-waf-protection, retrieved 18 November 2026.

What the decoder does with a malformed padding sign

Base64 turns binary data into printable text so it can travel through protocols built for text: authentication headers, session tokens, uploads, message bodies. OpenJDK decodes it constantly, so the runtime carries an intrinsic, a block of specialised code that replaces the generic Java loop when the processor supports it. On x86-64 chips with AVX-512 VBMI, that intrinsic processes 64 bytes per instruction.

The bug lives in the assembly that handles the last few characters. When padding appears where valid Base64 never puts it, the routine computes a negative output length. That invalid length becomes a full 64-byte write, and for a 65-character input the decoder allocates a 50-byte array and writes 62 bytes past its end. Java rejects the input and throws an exception a moment later. The neighbouring objects have already been overwritten by then, which is why input validation in the application changes nothing: the corruption happens inside the decoder, before application code sees the data.

Netics card defining CVE-2026-114938, its 64-character trigger and the 62-byte overwrite
Netics visual, 18 November 2026: the definition of CVE-2026-114938 and the exact input that drives the out-of-bounds write.

Calif describes the exploitation as deliberate work. The overwritten bytes are mostly fixed values and the attacker controls where the write lands, so a working chain begins with heap grooming that turns the overflow into an enlarged neighbouring array. From there the chain reads heap memory and then writes chosen bytes. Each target application needed its own chain, and Calif reports about three hours to a first working local exploit with AI agents assisting, which sets the expectation for how quickly copycat chains appear now that the technical detail is public.

Which systems carry the vulnerable code path

Three conditions decide exposure, and all three have to hold at once. The runtime has to be OpenJDK 17.0.6 or newer, including distributions built from it: Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat OpenJDK, Oracle OpenJDK, Oracle Java SE and Oracle GraalVM for JDK. The processor has to be x86-64 with AVX-512 VBMI support, which covers Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids, and AMD EPYC or Ryzen from Zen 4 onward. The application has to decode attacker-controlled Base64 with the standard Java decoder.

Netics card comparing the three conditions that decide Java4Shell exposure
Netics visual, 18 November 2026: the runtime, processor and input conditions that place a system inside or outside the vulnerable path.

That third condition reaches further than the first two suggest. Authentication and file upload both decode Base64, so an ordinary feature can expose the decoder. The practical question for an operations team is narrower: which running JVMs are 17.0.6 or newer on hardware that supports AVX-512 VBMI, and where do those JVMs come from.

Where the demonstrated chains landed

Calif published two lists, and the split between them matters for triage. Pre-authentication remote code execution was demonstrated in default configurations of Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins and PingFederate. Post-authentication execution was demonstrated against Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit and Spinnaker. Sample applications built on Apache Struts and Spring Boot were also compromised, and the researchers call both lists non-exhaustive.

Calif disclosure page for Java4Shell with the trigger input and affected product lists, calif.io/java4shell
The Calif disclosure page for Java4Shell, showing the 64-character trigger, the write past the result array and the products where exploitation was demonstrated. Source: calif.io/java4shell, captured 18 November 2026.

One detail on that page deserves attention from teams that think of themselves as clients. A Java program that opens a TLS connection to a malicious server can be compromised even when it exposes no service of its own, because the decoder runs on whatever arrives. Outbound-only integrations, batch clients and command-line tools therefore belong in the same inventory as public-facing applications.

What the managed rules cover, and what they never see

Cloudflare released six rules inside its Managed Ruleset, identified as efb7b8c949ac4650a09736fc376e9aee, covering malformed Base64 in a header, a query value, a body value, a path segment, a Base64url JWT component and a WebAuthn value. They ship enabled with the Log action on Pro, Business and Enterprise plans, because malformed input and some benign application token formats look alike, and blocking by default risks breaking legitimate traffic. The documented path is to review matches in Security Analytics, then switch the action to Block.

Cloudflare post on Java4Shell with the affected-systems table and rule IDs, blog.cloudflare.com/java4shell-waf-protection
Cloudflare's post on Java4Shell, including the affected-system table and the rule identifiers for the managed protections. Source: blog.cloudflare.com/java4shell-waf-protection, captured 18 November 2026.

The limits are stated plainly in the same post, and they are the part worth reading twice. A web application firewall inspects HTTP requests that pass through it. Encoded or compressed payloads unwrapped by the application, Kafka's own protocol, traffic between internal services and requests that never route through the edge all reach the decoder unexamined. Outbound TLS responses reach it too, which is the client-side case above.

Two flags that remove the fast path today

Calif documents two JVM startup options for teams that cannot patch immediately. -XX:-UseBASE64Intrinsics disables the hardware-accelerated Base64 encoder and decoder, and -XX:UseAVX=2 disables AVX-512. Calif warns that OpenJDK on ARM does not recognise the second option and will fail to start; its guidance limits that option to x86-64 hosts. Cloudflare's own instructions add -XX:+UnlockDiagnosticVMOptions in front of the first flag. Both options need a restart, both cost performance on workloads that decode large volumes of Base64, and both buy time while the real update lands.

Oracle's November 2026 Critical Patch Update is where the patched Java SE builds appear, and OpenJDK's advisory of 17 November 2026 lists the fixed versions: 27.0.1.0.3, 25.0.5.0.3, 21.0.13.0.3, 17.0.21.0.3, 11.0.33 and 8u512, with everything earlier affected for the corresponding line.

A runtime inventory is the actual remediation

Cloudflare ran the exercise on its own estate, and its account is a useful template. The company checked which Java workloads sat on hardware with AVX-512 VBMI, found that the majority did not, and protected the remainder. About an hour after the patches appeared it began rolling out a JVM startup option that turns off the accelerated Base64 routine everywhere, and it is extending the patched configuration to all machines as a precaution. No exploitation on its infrastructure has been reported.

The pattern generalises: exposure came down to a join between a software version and a hardware capability, and the fix was a fleet-wide configuration change plus a staged patch. Most organisations will find their Java runtimes scattered across three places that a package manager does not reach. Application servers bundle their own JDK. Container images ship a fixed base image that a host-level upgrade leaves untouched. Long-running JVMs keep the decoder they started with until the service restarts, so a patched disk and a patched process are different states.

An asset record that answers four questions covers the campaign: which JDK build and vendor each service runs, whether the host exposes AVX-512 VBMI, which container images carry their own runtime, and who restarts the service after the update. The same record feeds the alerting side, where infrastructure monitoring with plain-language alerts becomes useful once the inventory exists to alert on.

Oracle November 2026 Critical Patch Update affected products table, oracle.com/security-alerts/cspunov2026.html
Oracle's Critical Patch Update page for November 2026, published the same day as the disclosure and listing the affected product families. Source: oracle.com/security-alerts/cspunov2026.html, captured 18 November 2026.

Java4Shell will be remembered as a decoder bug. The operational lesson sits one level up: the fastest way to know whether a critical runtime flaw reaches you is a maintained list of the runtimes you actually run, with the hardware under them.

Sources

Source: "How Cloudflare WAF helps protect against Java4Shell (CVE-2026-114938)" — blog.cloudflare.com, 2026-11-18, https://blog.cloudflare.com/java4shell-waf-protection, retrieved 2026-11-18, with the Calif disclosure at https://calif.io/java4shell, the OpenJDK advisory of 2026-11-17 and Oracle's November 2026 Critical Patch Update page, all saved under sources/2026-11-19/java4shell/.