Calif disclosed Java4Shell (CVE-2026-114938) on November 17, 2026: a memory-corruption flaw in the Base64 decoder of OpenJDK, the most widely deployed Java runtime. CVSS 4.0 scores it 9.2 out of 10 (Critical). OpenJDK published a security advisory, and Oracle shipped fixed builds in its November 2026 Critical Patch Update the same day at 21:00 UTC.

Root cause: the Base64 tail routine

Java applications decode Base64 constantly — authentication headers, tokens, file uploads and network messages all pass through it. OpenJDK accelerates this with intrinsics, replacing hot code with specialized machine code; on supported x86-64 processors the Base64 intrinsic uses AVX-512 to process 64 bytes at a time.

The defect lives in the handwritten assembly that handles the last characters of the input. If padding characters (=) appear where valid Base64 never puts them, the routine computes a negative output length, and that invalid value becomes a full 64-byte write. With a 65-character input — 64 characters plus one = — OpenJDK allocates a 50-byte output array and writes 62 bytes past the end. The decoder then rejects the input and throws, but the adjacent memory has already been overwritten. Application-level validation is useless here, because the corruption occurs inside the decoder before any application code can reject the data.

The minimal trigger is 64 A characters followed by =. On OpenJDK 17 the fast path has a higher threshold, so the trigger must be 128 characters followed by =.

Exploitability and affected targets

The primitive is not point-and-shoot: the overwritten bytes are largely fixed, and the attacker controls only the write destination. Calif nevertheless turned the overflow into a heap memory leak (comparable to Heartbleed) and into code execution by arranging the JVM heap so the overflow enlarged neighboring arrays, yielding first an out-of-bounds read and then a write of chosen bytes. Every application needs its own exploit chain. Calif built its first working local exploit in roughly three hours with help from AI agents — a strong signal that other attackers will assemble chains quickly.

Calif demonstrated pre-authentication RCE in default configurations of Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins and PingFederate, and post-authentication RCE against Apache Kafka, Apache Solr, Elasticsearch, Gerrit and Spinnaker.

Condition

Details

Java runtime

OpenJDK 17.0.6 or newer, including distributions built from OpenJDK: 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.

Check Oracle's advisory for the exact list of affected Oracle builds.

Processor

x86-64 with AVX-512 VBMI support, such as Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids, or AMD EPYC and Ryzen Zen 4 or newer. ARM64 processors are not affected.

Input

The application decodes attacker-controlled Base64 data with the standard Java decoder.

Patch, or disable the vulnerable path

Many applications bundle their own Java runtime and container images pin a fixed JDK, so upgrading the system Java package updates neither those copies nor a running JVM. Every patched service needs a restart.

Where immediate updates are impossible, Calif documents two JVM startup flags that eliminate the vulnerable code path:

  • -XX:-UseBASE64Intrinsics disables the hardware-accelerated Base64 encoder and decoder.
  • -XX:UseAVX=2 disables AVX-512. Use this only on x86-64 hosts; OpenJDK on ARM does not recognize the flag and will not start.

Both require a restart, both can slow workloads that decode large volumes of Base64, and neither substitutes for patching — they buy time.

Cloudflare WAF coverage

Cloudflare has published rules in the Cloudflare Managed Ruleset (Ruleset ID efb7b8c949ac4650a09736fc376e9aee) that detect the malformed Base64 patterns associated with the flaw. They are available on Pro, Business and Enterprise plans and ship enabled with the Log action by default, since malformed input and some benign application-specific token formats can resemble exploitation attempts — a default block could disrupt legitimate traffic. Review matches in Security Events, then change the action to Block once you confirm no legitimate traffic is caught.

A rule for the Cloudflare Free Managed Ruleset is in progress.

On the WAF's limits: it can only block the exploit when the malformed Base64 arrives in an HTTP request that traverses Cloudflare. It will not stop encoded or nested data unpacked by the application before decoding, non-HTTP protocols (the Apache Kafka broker, for instance), outbound connections (Calif also published a client-side exploit against a Java program that merely opens a TLS connection to a malicious server), or traffic that bypasses Cloudflare, including internal service-to-service flows.

Configuring the rules

To inspect the rule's matches, go to Security > Security Analytics > Events and filter by rule ID. To enforce, go to Security > Settings, edit the Cloudflare Managed Ruleset, search for CVE-2026-114938 and set the rule action to Block. The Zero Wire briefing links directly to a review of your configuration.

Business and Enterprise customers get a second layer from WAF attack score, which uses machine learning to score each request for remote code execution payloads. Attack score is complementary rather than a primary filter here: a lone 65-byte (or 129-byte) trigger resembles an opaque, malformed Base64 string, not application-layer injection syntax, so models trained on web injection patterns will not flag it in isolation. What they can catch is the chain around it.

  • Heap grooming. Repetitive parameters or headers sent alongside the malformed payload to shape the JVM heap layout before the out-of-bounds write.
  • Second-stage payloads. Commands, scripts or Java gadgets — /bin/sh -c, cmd.exe, reverse-shell strings, java.lang.Runtime, ProcessBuilder, serialized object streams — hidden in another header, query parameter or body. The RCE sub-score cf.waf.score.rce, available on Enterprise plans, scores these as malicious.
  • Post-exploitation traffic. Requests driving an in-memory webshell or passing OS commands to the compromised JVM remain visible to attack score.

Rule description

Rule ID

Java4Shell - Malformed Base64 Header - CVE-2026-114938

5de9b20a45ea45d3841919ab4d718bf4

Java4Shell - Malformed Base64 Query Value - CVE-2026-114938

46bb4172813e471ea62d31c02337b51d

Java4Shell - Malformed Base64 Body Value - CVE-2026-114938

d4dc3f71f1bc44a0811ae570e5e5836c

Java4Shell - Malformed Base64 Path Segment - CVE-2026-114938

0dceaf0684b54fd0b085fcfb6fd6f152

Java4Shell - Malformed Base64url JWT Component - CVE-2026-114938

0ddd0eb664a040779f2f19065a25d991

Java4Shell - Malformed Base64 WebAuthn Value - CVE-2026-114938

4fce1ea79a614c07a27348d167d74ebb

Suggested sequence: flip the CVE-2026-114938 rule in the Cloudflare Managed Ruleset to Block after reviewing Log-mode matches; layer attack score via a custom rule that blocks or challenges low RCE scores (for example cf.waf.score.rce le 20 on Enterprise, or cf.waf.score.class eq "attack" on Business) to catch multi-stage chains and post-exploitation commands; and remediate the runtime by installing fixed OpenJDK builds or your vendor's release per the OpenJDK advisory and Oracle CPU. Sophisticated in-memory exploits can run raw shellcode or manipulate bytecode without ever sending a plaintext shell command over HTTP, so attack score, explicit Base64 rules and patching are meant to be used together.

Cloudflare's own exposure

Cloudflare runs Java too, and checked its systems at disclosure. The bug is only reachable on a specific hardware configuration — an x86-64 processor supporting AVX-512 VBMI — so exposure requires both conditions. Investigation found most Java workloads were not scheduled on vulnerable systems, and the remainder were protected immediately. About an hour after patches appeared, Cloudflare began rolling out a JVM startup option disabling the accelerated Base64 routine on all Java workloads, falling back to the standard implementation, and is applying the configuration fleet-wide regardless of hardware as a precaution. There is no indication so far that Java4Shell was exploited on Cloudflare infrastructure.

Rule changes are tracked in the WAF changelog, and developments in the vulnerability are covered on the Cloudflare Zero Wire Java4Shell briefing.

Mitigation steps for Java4Shell

Java4Shell abuses a performance optimization inside the Java runtime and escalates it into remote code execution. Since the technical details are now public, exploitation attempts are expected to pick up quickly.

The primary fix is to update every Java runtime and restart any services that depend on it. Teams that are still patching should also review the matches generated by the new managed rule and move it to Block if they are on a paid plan. Attack score can help catch RCE payloads that signatures miss.

WAF analysts will keep revising protections as new techniques surface. Rule changes are published in the WAF changelog, and further detail on the vulnerability appears on the Java4Shell page on Cloudflare Zero Wire.