On November 17, 2026, the security company Calif highlighted a vulnerability designated as Java4Shell (CVE-2026-114938). This critical memory corruption flaw resides in the Base64 decoder of OpenJDK, the most widely used runtime environment for Java. According to the CVSS 4.0 system, the vulnerability received a rating of 9.2 out of 10, categorizing it as a critical threat. On the same day, at 21:00 UTC, OpenJDK issued a security advisory, and Oracle released patched versions as part of its November critical update.
The vulnerability allows a remote attacker, without requiring authentication, to send specially crafted Base64 data to a Java application, leading to memory overwrites adjacent to the decoded output. The Calif team demonstrated how this overwrite can be exploited for heap memory leakage, similar to the Heartbleed vulnerability, and subsequently for remote code execution. Their demonstration included pre-authentication remote code execution on applications such as Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, and PingFederate in their default configurations, and post-authentication remote code execution on Apache Kafka, Apache Solr, Elasticsearch, Gerrit, and Spinnaker.
In response to this threat, new rule sets for Web Application Firewalls (WAFs) have been released, designed to detect malformed Base64 input patterns associated with this vulnerability. These rules are typically available for paid plans and are enabled by default in logging mode. The reason is that some legitimate token formats or erroneous input might resemble exploitation attempts, and blocking could disrupt legitimate traffic. Customers can analyze matching requests in security events and change the rule action to block once they confirm it does not affect legitimate operations.
It is crucial to emphasize that WAFs represent only an additional layer of defense, not a substitute for applying security patches. The Java4Shell vulnerability can also be reached through paths that WAFs cannot see, such as via outbound TLS responses, and the only complete solution is to update the Java runtime environment. Security analysts continue to monitor attack activity and will update rules as new techniques and variants emerge. Rule changes can be tracked in the relevant WAF change logs.
Base64 is a common method for representing binary data as text. Java applications decode Base64, for example, when processing authentication headers, tokens, file uploads, and many network messages. For faster decoding, OpenJDK replaces frequently used code with specialized machine code, known as intrinsics. On supported x86-64 processors, the Base64 intrinsic utilizes AVX-512 instructions to process 64 bytes at once.
The flaw lies in hand-written assembly code that handles trailing input characters. When the end of the input contains padding characters (=) at a position where valid Base64 never places them, the routine calculates a negative output length. This invalid length then wraps around to a full 64-byte write. For a 65-character input, consisting of 64 characters followed by a single =, OpenJDK allocates a 50-byte output array and then writes 62 bytes past its end.
Java eventually rejects the input as invalid and throws an exception. However, by that time, adjacent memory has already been overwritten. Application-specific input validation does not help, as the corruption occurs within the decoder before the application can reject the data. The simplest trigger is 64 'A' characters followed by =. On OpenJDK 17, 128 characters followed by = are required to trigger the bug, as the fast-path code threshold is higher.
Exploiting the vulnerability is not straightforward. The overwritten bytes mostly have fixed values, and the attacker only controls the write location. To create a working exploit, the Calif team arranged the Java heap so that the overflow expanded an adjacent array, first allowing them to read heap memory and then to write selected bytes. Each target application requires its own exploit chain. Calif reported developing their first functional local exploit in approximately three hours, suggesting that other attackers can also quickly craft their own exploit chains.

Need a hand with your website or app?
Get in touch and I will reply within 24 hours with a proposal for the next step.
A system is vulnerable only if all of the following conditions are met: the Java runtime environment is OpenJDK 17.0.6 or newer, including distributions built on OpenJDK (e.g., 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). It is also necessary that the processor is 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 by this vulnerability. The last condition is that the application decodes attacker-controlled Base64 data using the standard Java decoder. Many applications include their own Java runtime environment, and container images are shipped with a fixed Java Development Kit (JDK) set. Therefore, updating the system Java package may not update these copies and will not replace an already running Java Virtual Machine (JVM). Each updated service requires a restart.
If you cannot perform an immediate update, there are two JVM startup flags that eliminate the vulnerable code path. The flag -XX:-UseBASE64Intrinsics disables hardware-accelerated Base64 encoding and decoding. The flag -XX:UseAVX=2 disables AVX-512. Apply this flag only on x86-64 hosts; OpenJDK on ARM will not recognize it and will fail to start. Both flags require a restart and may reduce performance for workloads that decode large amounts of Base64 data. They provide time to implement a fix but are not a substitute for a complete update.
Applying patches to every Java runtime environment can take time, especially if JDKs are bundled within applications and container images. A Web Application Firewall (WAF) can reduce your exposure during the patching window. New managed rules that detect malformed Base64 input triggering Java4Shell are typically available for paid plans and are enabled by default in logging mode. For enterprise customers, the WAF attack scoring system, utilizing machine learning, can add a layer that scores each request for remote code execution payloads, helping to catch variants and bypass attempts that signature-based rules might miss.
While managed rules provide the primary means of blocking malformed Base64 triggers at the network edge, WAF attack scoring functionality (especially its remote code execution sub-score, available for advanced plans) can offer an additional, complementary layer of protection. Because CVE-2026-114938 (Java4Shell) is a binary heap memory corruption vulnerability, an attacker rarely achieves full, reliable remote code execution with just a single 65-byte (or 129-byte) trigger string. At the network level, this initial trigger appears as an opaque, malformed Base64 string containing heap corruption bytes rather than traditional web-layer injection syntax. Consequently, machine learning models trained on application-layer injection patterns will not flag the raw Base64 trigger in isolation.
Instead, transforming a limited JVM heap overflow into remote code execution over HTTP almost always requires a multi-stage or multi-parameter exploit chain, which creates more fingerprints that the WAF Attack Score can inspect and flag. This includes, for example, heap spraying and attack priming, where attackers often send repeated parameters or headers alongside the malformed Base64 payload to shape memory layout before triggering the out-of-bounds write. Furthermore, it includes second-stage payloads. Once heap corruption grants an attacker control over execution flow or object references, the exploit still needs commands, scripts, or Java gadgets to execute. If the exploit chain pairs the initial heap corruption trigger with a second-stage payload, such as shell execution primitives (/bin/sh -c, cmd.exe, reverse shell strings) or Java class loading gadgets (java.lang.Runtime, ProcessBuilder, serialized object streams) tucked into another header, query parameter, or request body, the attack scoring system can detect and flag this secondary payload as malicious. Lastly, there is post-exploitation activity. Even if the initial heap read or corruption request passes the network edge, subsequent HTTP requests attempting to interact with an in-memory webshell or pass operating system commands to the compromised JVM remain directly visible to the WAF Attack Score.
Given that sophisticated in-memory exploits can still execute raw shellcode or manipulate bytecode without sending plaintext shell commands over HTTP, the WAF attack scoring system should be used in conjunction with explicit Base64 rules and JVM patching. For deploying protection, it is recommended to set the rule for CVE-2026-114938 in the WAF managed ruleset (available for paid plans) to block. Since it is enabled by default in logging mode, first check its matches in security events. Furthermore, it is advisable to layer machine-learning-based Remote Code Execution (RCE) attack scoring: create a custom rule blocking or challenging requests with a low RCE attack score (e.g., cf.waf.score.rce le 20 on advanced plans, or cf.waf.score.class eq "attack" on business plans) to catch multi-stage exploit chains and post-exploitation command traffic. Most importantly, runtime-level remediation is crucial: update to patched OpenJDK versions (or, as a temporary workaround, set -XX:+UnlockDiagnosticVMOptions -XX:-UseBASE64Intrinsics) to completely remove the vulnerable AVX-512 code path. Monitor OpenJDK advisories and Oracle's critical update, and install the patched version from your Java vendor as soon as possible.
Organizations running Java applications immediately reviewed their systems after the vulnerability's disclosure. The vulnerability can only be triggered in specific hardware configurations, specifically on an x86-64 processor with AVX-512 VBMI support, so a system is only exposed if both conditions are met. It was found that most Java workloads were not scheduled on vulnerable systems, and immediate measures were taken to protect the remainder. Approximately an hour after the patches were released, deployment of a JVM startup option was initiated to disable the accelerated Base64 routine containing the bug on all Java workloads, thereby reverting decoding to the standard implementation. For security reasons, the patched configuration is being preventatively deployed to all machines regardless of hardware. To date, no indications of Java4Shell exploitation have been detected on monitored infrastructures.
Java4Shell turns a performance optimization in the Java runtime into a remote code execution path, and with technical details now public, we anticipate rapid exploitation attempts. The solution is to update every Java runtime environment and restart services that use it. During patching, check for matches of the new managed rules and switch them to blocking if you are on a paid plan and utilize the attack scoring system to catch remote code execution payloads that signatures might miss. WAF security analysts will continue to update protections as new techniques emerge.
