A memory corruption vulnerability in OpenJDK's Base64 decoder, CVE-2026-114938, has been shown to enable unauthenticated remote code execution in six products, including Jenkins, Jira, and Confluence. Oracle released a patch on November 17.
Key points
- What happened: CVE-2026-114938, a flaw that causes memory corruption in OpenJDK's fast Base64 decoding path with a 65-byte input, was found and demonstrated to enable unauthenticated remote code execution in six products, including Jenkins, Jira, and Confluence
- Who is affected: Environments running OpenJDK 17.0.6 or later on x86-64 CPUs with AVX-512 VBMI support are affected, extending to all major distributions including Amazon Corretto and Eclipse Temurin. ARM64 is not affected
- How to protect against it: Applying the patch Oracle released on November 17 is the top priority. If an immediate update is not possible, the JVM startup option -XX:-UseBASE64Intrinsics can bypass the vulnerable code path
- What to watch: One month after PHP2Shell, Calif has reached deep into Java. AI-assisted vulnerability discovery that took one hour and cost less than $200 is pushing the speed of shared-infrastructure audits to an unprecedented level
65 bytes can corrupt Java memory
Java4Shell (CVE-2026-114938), a vulnerability disclosed on November 17 U.S. time by security company Calif, exploits a memory corruption flaw in OpenJDK's Base64 decoder.
Base64 is an encoding scheme that converts binary data, such as the strings of zeros and ones that make up images and files, into text characters. It is used routinely across Java applications for authentication tokens, file uploads, network communications, and much more. To accelerate Base64 decoding, OpenJDK includes optimized code that uses the AVX-512 VBMI instruction set on x86-64 processors, an extension that lets CPUs process large amounts of data at once.
The flaw was in this optimized code: hand-written assembly, a low-level program close to machine code. When processing the padding character (=) at the end of Base64 data, the code miscalculates the destination write mask and overwrites 62 bytes beyond the allocated memory region.
The triggering input is remarkably simple: 64 "A" characters followed by a single "=", for a total of 65 bytes. Older releases of OpenJDK 17 require 128 "A" characters followed by "=". According to Calif's analysis, OpenJDK allocates a 50-byte output buffer for the 65-byte input, but the incorrect mask calculation causes a 64-byte write, with 62 bytes extending past the end of the buffer. Java throws an exception because the input is invalid, but the memory has already been corrupted by that point.
By controlling this overwrite, Calif demonstrated two attacks. One is an information leak similar to Heartbleed, the 2014 vulnerability in OpenSSL's encrypted-communications library that exposed server memory: an attacker can read personal information, private keys, and authentication tokens from the Java heap. The other is remote code execution (RCE), achieved by manipulating the arrangement of in-memory objects so an attacker can run arbitrary programs on the computer.
Why memory corruption can happen in Java
One of Java's major selling points is "memory safety." It manages memory on developers' behalf and checks access boundaries, protecting applications from the memory corruption bugs common in C and C++.
Java itself, however—the JVM, or Java Virtual Machine—is written in low-level languages such as C and C++, and in this case assembly. The foundation of the memory-safe world is built in languages that are not memory-safe. Java's memory-management protections do not extend to assembly code that directly invokes specialized CPU instructions to accelerate Base64 decoding.
Calif calls this situation the "tragedy of shared infrastructure." AVX-512-based Base64 optimization benefits applications that decode large amounts of data, but the same code is bundled with applications that process only a few hundred bytes. A feature they do not use created risk for everyone.
Affected products and conditions
Applications vulnerable to unauthenticated RCE
Calif demonstrated unauthenticated remote code execution under default settings in six products: Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, and PingFederate. All are authentication-management, project-management, or CI/CD tools—used to automate building, testing, and deployment—that are widely deployed in enterprise IT infrastructure.
Calif also confirmed code execution after authentication in Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, and Spinnaker, and successfully reproduced the issue in sample applications built on Apache Struts and Spring Boot.
Hardware and software requirements
Two conditions must be met for the vulnerability to trigger.
On the software side, the system must be using OpenJDK 17.0.6 or later, specifically versions 17, 21, 25, or 27. OpenJDK 8 and 11 are not affected. Java distributions based on OpenJDK, including Oracle Java SE, Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, and Red Hat OpenJDK, are affected in the same way.
On the hardware side, the system must run on an x86-64 processor that supports AVX-512 VBMI instructions. Affected processors include Intel Xeon models from Ice Lake onward—Sapphire Rapids, Emerald Rapids, and Granite Rapids—and AMD EPYC and Ryzen processors based on Zen 4 or later. ARM64 processors are not affected. Cloud virtual machines may also be affected if the host CPU meets these conditions.
On Linux, the following command can check whether a CPU meets the requirements.
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
If all four flags—avx512f, avx512bw, avx512vbmi, and bmi2—appear, the CPU is affected.
No generic exploit exists
An important point is that no universal exploit exists for Java4Shell. Calif explains that because the path through which Base64 data reaches the decoder and the memory layout differ by application, each target requires its own attack procedure. Successfully exploiting an application requires combining its Base64 decoding call path, a way to manipulate memory layout, data that can be extracted from the response, and application-specific operations.
Some attack patterns also require splitting an HTTP request across multiple transmissions. Because nginx buffers the entire request by default, exploitation is more difficult in environments that use nginx as a reverse proxy. This restriction is not universal, however: Elasticsearch can be attacked with a single complete request, and buffering does not apply to WebSocket connections.
Calif has published proof-of-concept code that reproduces the memory corruption, but it is withholding weaponized exploits for individual applications to give users time to apply patches.
Calif also received details of a client-side attack path from independent researcher samczsun. A Java program that opens a TLS connection to a malicious server could be compromised even if it does not expose a service to the internet.
AI found it in one hour for $200
Java4Shell was discovered by Calif researcher Quang Luong. Luong used OpenAI Codex, an AI coding assistant, to focus audits on OpenJDK's JIT compiler, intrinsics, cryptographic processing, and related areas.
As any competent security researcher would in 2026, I told Codex to look at those areas.
According to Calif, the discovery took about one hour, followed by another two hours to develop the first exploit. The AI usage cost was less than $200.
Calif also used AI to discover and demonstrate PHP2Shell (in Japanese), which it disclosed last month, and Java4Shell follows that work. Calif said, "After we published PHP2Shell, we realized that many people did not know PHP. Next, we decided to target something a little more familiar: Java."
With PHP2Shell, AI demonstrated that a flaw hidden in PHP's memory management for more than a decade was exploitable, forcing emergency service shutdowns around the world, including in Japan. With Java4Shell, AI is being used not only to find the vulnerability but also to develop exploit chains for individual applications.
Patches and mitigations
OpenJDK published a security advisory, and Oracle distributed a patch on November 17 at 1:00 p.m. PST. Oracle's November Critical Security Patch Update includes 655 security fixes, including Java4Shell.
The severity ratings differ: Calif assigned a 9.2 (Critical) under CVSS 4.0, while Oracle assigned an 8.1 (High) under CVSS 3.1. The scores cannot be compared directly because they use different CVSS versions, but Oracle's rating appears to account for the complexity of the attack conditions.
All Java users should update to the latest release of the distribution they use.
There are two temporary mitigations for users who cannot update immediately. Both are specified as JVM startup options.
Adding -XX:-UseBASE64Intrinsics disables Base64 hardware acceleration and bypasses the vulnerable code path. The other option is -XX:UseAVX=2, which disables AVX-512 instructions entirely. The latter is only for x86-64 environments; ARM environments do not recognize it and the JVM will fail to start, so caution is required.
Neither is a permanent fix. The runtime ultimately must be updated.
Java supports a broad range of critical infrastructure, including banking, telecommunications, aviation, and government. Its runtime, long trusted as a memory-safe language, was breached from a different layer by a bug in assembly code that directly invokes CPU acceleration instructions. Less than a month after PHP2Shell, Calif has once again dug deeper into the foundation—with AI.
Originally published on Joho no Todai. The Japanese original is here.
Top comments (0)