Back blackpointcyber.com Java4shell Cve 2026 114938 Java Base64 Decoder Flaw
Following initial reports of Java4Shell (CVE-2026-114938), Blackpoint Cyber’s Adversary Pursuit Group (APG) investigated the vulnerability to better understand its underlying cause and potential impact.
The vulnerability affects an optimized Base64 decoding routine in Java’s HotSpot runtime, where malformed input can cause an AVX-512 routine to write 62 or 63 bytes beyond the allocated output array.
APG reproduced JVM crashes under normal runtime configurations, including through repeated unauthenticated HTTP requests against a local Spring Boot application using Spring Security.
Further testing confirmed corruption of nearby Java objects and live application data. APG also reproduced a local heap disclosure technique described by Calif, demonstrating how the initial memory corruption can expose adjacent data under controlled conditions.
Security firm Calif reports achieving remote code execution (RCE) by exploiting the corrupted memory to manipulate Java array lengths and gain additional control over memory. APG did not independently reproduce remote RCE.
Organizations should prioritize applying vendor security updates, identify potentially exposed Java deployments, and evaluate temporary JVM mitigations where immediate patching is not possible.
On November 17, 2026, reports began circulating a critical vulnerability affecting Java, tracked as CVE-2026-114938 and commonly referred to as Java4Shell. The vulnerability, originally discovered and reported by security firm Calif, was described as allowing unauthenticated remote code execution (RCE) in affected Java applications. Calif assigned the vulnerability a CVSS 4.0 score of 9.2 (Critical), while the OpenJDK security advisory lists a CVSS 3.1 score of 8.1 (High). Following these reports, Blackpoint Cyber’s Adversary Pursuit Group (APG) began investigating the vulnerability to better understand how it worked, identify the underlying cause, and assess its potential impact.
The investigation focused on Java’s built-in Base64 decoder, specifically an optimized routine within the HotSpot runtime that uses AVX-512 instructions on supported processors. Analysis revealed that certain malformed Base64 inputs could cause the decoder to write beyond its allocated output buffer, corrupting adjacent Java heap memory before rejecting the invalid data. APG reproduced this behavior on an Intel Xeon system and successfully triggered JVM crashes using the standard java.util.Base64 API without special runtime configurations or application privileges.
Further testing demonstrated that the vulnerability could be reached through a local Spring Boot application using Spring Security. In this environment, approximately 28,000 unauthenticated HTTP requests carrying a malformed Base64 authentication value caused the JVM to terminate after roughly 20 seconds of sustained requests. Additional testing confirmed corruption of nearby Java objects and changes to live application data without necessarily causing an immediate crash.
Across extensive testing, APG found that the initial overflow consistently wrote a fixed byte pattern rather than attacker controlled data. Following Calif’s technical disclosure, APG also reproduced their writer and reader memory disclosure technique under controlled local conditions, successfully recovering data from adjacent Java heap memory. While this confirmed that the initial corruption could be leveraged to disclose memory contents, APG did not independently reproduce memory disclosure or code execution through a remote application. Calif’s research extends significantly beyond these findings, detailing how manipulation of Java array lengths can provide greater control over memory and reporting successful RCE against several widely deployed Java applications.
Connecting the Research
Calif’s research provides a detailed examination of Java4Shell, including the underlying vulnerability and an exploitation strategy that Calif reports using to achieve remote code execution against several widely deployed Java applications. Rather than repeating that work, this article focuses on APG’s investigation following the initial public reports, including its analysis of the vulnerable decoder, reproduction of memory corruption, and testing of the potential impact on Java applications.
Following Calif’s technical disclosure, APG also reproduced the memory disclosure technique described in their research under controlled local conditions. While this testing demonstrated how corruption of adjacent Java arrays could expose memory contents, APG did not independently reproduce a remote exploitation chain. Calif’s original research provides a much more comprehensive examination of the techniques required to achieve RCE and is referenced at the end of this article.
Tracing the Vulnerability to the Base64 Decoder
Following the initial reports, APG began reviewing the OpenJDK releases identified in public coverage to better understand the underlying vulnerability. Comparing Java 17.0.5 and 17.0.6 revealed that the latter introduced an optimized Base64 decoding routine that uses native AVX-512 instructions to process encoded data more efficiently. This helped narrow the investigation to an optimization within Java’s HotSpot runtime and provided a starting point for examining the conditions that could lead to memory corruption.
The relevant routine is StubGenerator::generate_base64_decodeBlock() , implemented in src/hotspot/cpu/x86/stubGenerator_x86_64.cpp . HotSpot can select it when an application uses the public Base64 API and the runtime has compiled the relevant call path. Developers do not need to invoke native code, use Java Native Interface (JNI), or enable special diagnostic features to reach the affected implementation.
APG tested the vulnerability on an Intel Xeon 6985P-C supporting AVX-512 VBMI, reproducing the memory corruption in Java 17.0.6 and later Java 17 builds, as well as Java 21. Java 17.0.5 did not exhibit the same behavior and served as a clean comparison. The vulnerable routine is selected based on the processor capabilities available to the JVM and whether the just in time (JIT) compiler activates the optimized decoder. As a result, running an affected Java version does not necessarily mean the vulnerable code path will be used in every environment.
How Malformed Padding Corrupts Memory
The failure occurs when the decoder encounters certain incomplete Base64 tails containing padding characters. The optimized routine calculates how many output bytes remain, then adjusts that value to account for the padding. In the affected path, the initial output length can be zero before the padding adjustment, causing the value to become negative.
That negative value is passed to the bzhiq instruction to construct the mask for a 64 byte vector store. Instead of restricting the write to the remaining decoded output, the resulting mask permits all 64 bytes to be stored. In the principal cases APG examined, the store extends 62 or 63 bytes beyond the allocated array . The Java layer eventually rejects the malformed data with IllegalArgumentException , but the unintended write has already happened.
The bytes written outside the intended result are also distinctive. APG varied encoded prefixes, padding arrangements, and Base64 content across approximately 47,000 triggering decodes . The additional bytes consistently followed an internal filler pattern rather than copying attacker selected decoded data. Source review connected that pattern to an internal register used by the decoder. This finding describes the initial overflow only. It does not establish that the resulting corruption is harmless or that later writes cannot be controlled.
APG also examined a separate issue affecting how older Java builds handled source offsets during Base64 decoding. When decoding from a partially consumed buffer, the routine could incorrectly inspect padding bytes without accounting for the starting position within the input. This behavior affected Java 17.0.6 through 17.0.10 and Java 21.0.0 through 21.0.2, potentially causing a 64-byte overflow or silently discarding one or two bytes of valid decoded data. The additional overflow was examined through a restricted decoder path and was not demonstrated through an ordinary HTTP request. These findings are distinct from the primary 62 or 63-byte overflow.
Reproducing JVM Crashes and Data Corruption
To understand the impact under normal runtime conditions, APG developed a minimal Java test program using only the public java.util.Base64 API. The program did not require reflection, Unsafe, elevated privileges, or diagnostic JVM options. Testing across affected Java 17 and Java 21 builds successfully reproduced JVM crashes using malformed Base64 inputs. These results confirmed that memory corruption could cause the entire JVM to terminate without requiring an application to use native code or other unsafe functionality.
The likelihood of a crash depended heavily on how the JVM allocated memory and which garbage collector was in use. During testing with the default G1 collector, APG reproduced crashes using malformed Base64 inputs containing 4,097 characters. In configurations where the JVM was limited to a single effective processor, HotSpot selected the Serial collector, allowing some inputs as short as 129 to 131 characters to trigger crashes. These results demonstrate that relatively small inputs can cause significant memory corruption, although the exact conditions depend on object placement, garbage collection, and whether the optimized decoder has been activated.
Analysis of JVM crash logs revealed that the overflow could damage the metadata of neighboring Java objects, including object headers and references used by the runtime. When the JVM subsequently attempted to access the corrupted objects during allocation, garbage collection, or normal execution, it could encounter invalid memory addresses and terminate. Additional testing demonstrated that the corruption could also modify live application data without immediately crashing the process. In one controlled experiment, a boolean field named admin , originally set to false , was subsequently read as true . While this demonstrates the potential integrity impact of the vulnerability, APG did not establish an authorization bypass in a real application.
Several control tests helped isolate the behavior to the optimized Base64 decoder. APG did not reproduce the same corruption when disabling Base64 intrinsics with -XX:-UseBASE64Intrinsics or restricting AVX-512 through -XX:UseAVX=2 . The issue also did not reproduce when the standalone test program used Java’s MIME decoder instead of the affected standard decoding path. Although these results support the effectiveness of the JVM configuration changes, APG did not complete an equivalent controlled comparison within the Spring Boot application.
From an HTTP Request to a JVM Crash
An important question was whether an attacker could reach the decoder before logging in. HTTP Basic authentication is a useful example because the server may need to decode an Authorization value before it can determine whether the credentials are valid. A malformed Base64 value can therefore reach a decoder during authentication handling rather than after an authenticated session has been established.
APG tested this behavior in a local application running Spring Boot 4.1.2, Spring Security 7.1.2, and Tomcat 11.0.27, with HTTP Basic authentication explicitly enabled. On Java 17.0.6 without special JVM flags, approximately 28,300 unauthenticated requests carrying a malformed 7,937-character Authorization: Basic value were sent across three connections over roughly 20 seconds. Although the application rejected the requests with HTTP 401 responses, the JVM ultimately crashed after approximately 24.5 seconds of total uptime. Two additional test runs produced similar results after approximately 12,500 and 23,700 requests. The malformed value also fit within a commonly used 8 KB header limit, demonstrating why ordinary request size restrictions cannot be relied upon to prevent this condition.
APG also examined Spring Security’s Cross Site Request Forgery (CSRF) protection, which is enabled by default and can process submitted tokens before successful authentication, including on publicly accessible routes. In a separate local test, a large malformed CSRF token submitted through a form field caused the JVM to crash when the Serial garbage collector was selected using -XX:ActiveProcessorCount=1 . Unlike the HTTP Basic authentication example, this input was supplied through the request body rather than a header, allowing it to be governed by different size limits. These findings demonstrate another potential route through which untrusted Base64 data can reach the vulnerable decoder without requiring an authenticated session.
These results demonstrate a practical unauthenticated denial of service scenario, but they do not establish that every Spring Boot deployment is vulnerable through the same request path. In a separate test using Java 21.0.13 with the default G1 garbage collector, APG did not observe a crash after 30,000 malformed HTTP Basic authentication requests. This does not indicate that Java 21 is unaffected, as separate testing confirmed the underlying memory corruption and JVM crashes on that version. Rather, the results illustrate how garbage collection, memory allocation, application configuration, and the decoding path can influence whether a particular request sequence causes the JVM to terminate.
Understanding the RCE Impact
APG’s initial testing confirmed that the vulnerable Base64 routine could corrupt adjacent Java heap memory, causing JVM crashes and changes to live application data. Although the original overflow consistently wrote fixed bytes rather than attacker controlled values, Calif’s research demonstrated how this corruption could be developed into more powerful exploitation capabilities. Following their disclosure, APG reproduced Calif’s writer and reader memory disclosure technique using a local test program that allocated Java arrays consecutively within a single process. Testing successfully recovered an adjacent secret in all 30 runs, including 10 each on Temurin 17.0.21, Ubuntu 21.0.13, and Temurin 21.0.13. While this confirmed that the initial corruption could be leveraged to disclose neighboring heap contents, APG did not independently reproduce the remote heap manipulation or exploitation techniques described by Calif.
Calif’s research explains how the initial memory corruption can be leveraged to gain greater control over Java heap memory. Through careful manipulation of heap allocations, their researchers demonstrated how the overflow could corrupt the length of a neighboring Java array, allowing subsequent operations to write beyond its original boundaries with attacker controlled data. Calif refers to this array as the writer . The same technique can then be used to corrupt a second array, known as the reader , allowing additional memory contents to be exposed through application responses. Calif named this memory disclosure capability JavaBleed , demonstrating how an otherwise limited overwrite could be developed into a means of accessing sensitive information within the JVM.
Building on these capabilities, Calif describes additional techniques for repairing corrupted objects, manipulating application state, and ultimately reaching JVM execution structures to achieve code execution. The firm reports successfully demonstrating unauthenticated RCE against several widely deployed applications, including Keycloak, Jira, Confluence, JFrog Artifactory, Jenkins, and PingFederate. Additional exploitation scenarios were reported against applications requiring authentication. Calif has not publicly released the individual application exploits, and APG did not independently reproduce these remote exploitation chains.
An important distinction in Calif’s research is that Java4Shell does not have a universal RCE exploit. Successful exploitation depends on how an application processes Base64 data, the availability of suitable objects in memory, and the attacker’s ability to influence their placement. Some of Calif’s exploitation techniques also rely on precise request timing and network conditions, while others do not. Although request buffering and input validation may interfere with certain exploitation paths, these controls should not be considered reliable substitutes for updating affected Java runtimes.
Affected Systems and Mitigations
Java4Shell affects vulnerable OpenJDK releases beginning with Java 17.0.6, with affected builds also identified across Java 21, 25, and 27. According to information provided to Calif by Oracle, vulnerable Oracle Java SE builds include 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3, and 27.0.1.0.3, alongside a specific Java 8 performance build, 8u511b33-perf. This does not mean all Java 8 releases are affected. Because several major Java distributions are based on OpenJDK, the vulnerability also affects distributions from Amazon Corretto, Eclipse Temurin, Microsoft, Azul, Red Hat, and others. Organizations should consult their Java distributor’s security guidance to identify affected builds and apply the appropriate updates.
Exploitation requires an x86-64 processor supporting AVX-512 VBMI. Calif identifies affected hardware families including Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids, and Granite Rapids, along with AMD EPYC and Ryzen processors based on Zen 4 or newer architectures. The vulnerable implementation requires the avx512f , avx512bw , avx512vbmi , and bmi2 CPU features to be available to the JVM. Not every processor within these broader families supports the required instructions, and virtualization may restrict which features are exposed. ARM64 systems are not affected by this specific implementation.
Following the November 17, 2026 security disclosures, Calif recommends immediately updating affected Java runtimes. Where patching is not immediately possible, organizations can disable the affected Base64 optimization using -XX:-UseBASE64Intrinsics or disable AVX-512 more broadly using -XX:UseAVX=2 . The latter should only be used on x86-64 systems, as it is not supported by OpenJDK on ARM. APG independently confirmed that both options prevented the observed memory corruption in standalone testing, although the mitigations were not fully validated against the Spring Boot application.
APG’s investigation into Java4Shell demonstrated how malformed Base64 input could lead to memory corruption within the Java runtime, even when applications rely on standard Java APIs. Through source analysis and controlled testing, APG reproduced JVM crashes, corruption of live application data, and denial of service through repeated unauthenticated requests against a Spring Boot application. Following Calif’s disclosure, APG also reproduced their memory disclosure technique under controlled local conditions, further demonstrating the potential impact of the vulnerability beyond JVM crashes.
While APG did not independently reproduce remote code execution, Calif’s research provides a detailed explanation of how the initial corruption can be developed into more powerful exploitation capabilities. The firm reports a path from a small Java heap overflow to memory disclosure and code execution, including successful RCE against several widely deployed Java applications. Organizations should prioritize identifying affected Java deployments, applying the latest security updates, and implementing temporary mitigations where immediate patching is not possible.
Update Java runtimes. Apply the latest security updates addressing CVE-2026-114938 from the relevant Java distributor. Include bundled runtimes and applications that ship with their own JVM.
Identify vulnerable systems. Prioritize affected Java deployments running on x86-64 processors supporting AVX-512 VBMI, including supported Intel and AMD processors.
Apply temporary mitigations where necessary. If immediate patching is not possible, disable the affected Base64 optimization using -XX:-UseBASE64Intrinsics or disable AVX-512 using -XX:UseAVX=2 . The latter should only be applied to x86-64 systems, as it can prevent Java from starting on ARM systems.
How Blackpoint Reduces Exposure
Blackpoint’s Security Operations Center (SOC) monitors suspicious activity and service disruptions across managed environments, including unexpected application failures and activity that may indicate attempted exploitation. APG supports these efforts through vulnerability analysis, independent testing, threat research, and technical guidance that informs detection engineering and incident response. These capabilities help organizations prioritize remediation while the broader security community continues to assess exposure and exploitation.
Acknowledgment and Further Reading
A hat tip to Calif for discovering and reporting Java4Shell, and to Quang Luong and Jenish Rakholiya for the published exploitation research. Their detailed write-up explains how the initial fixed overwrite can be developed into an array length corruption primitive, Java heap disclosure, and ultimately remote code execution. It is well worth reading for anyone interested in the mechanics beyond the behavior APG reproduced.
Calif Research: Java4Shell: Write once, RCE everywhere
Oracle Java 17 November 17, 2026 release notes: Oracle JDK 17.0.21.1 release notes
What Identity Attacks Cost the MSP Stolen credentials don't trip alarms. Once an attacker is authenticated, they look like anyone else, and most tools aren't watching what happens . Learn what closing the identity response gap looks like: how identity attacks happen, where response slows down, and the questions to ask any ITDR vendor. *Identity-based techniques play a role in nearly 90% of incident investigations
The full story
This article is one source in a clustered incident — the cluster page carries the summary, timeline and every other outlet covering it.
