Java has been around for more than 30 years, running everything from enterprise authentication systems to build servers, application platforms, and infrastructure that most organizations can’t operate without. You would think that after three decades, something as basic as decoding Base64 would be pretty well understood. Apparently, there are still a few surprises left.
Security researchers at Calif have discovered Java4Shell (CVE-2026-114938), a critical memory-corruption vulnerability in OpenJDK's Base64 decoder. A specially-crafted Base64 input can trigger remote code execution in vulnerable Java applications, which has resulted in a critical CVSS 4.0 score of 9.2. This isn't a problem with some obscure third-party library that nobody remembers installing. The vulnerability exists in Java's standard library, which means the potential exposure extends across a substantial portion of the enterprise software ecosystem.
The Problem Is Deeper Than the Application
Base64 encoding is an almost universally-used encoding technique for turning binary data into text. If you’re building any kind of system that’s transferring data, you’ll be using Base64, even if it’s buried in a library somewhere. HTTP authentication headers use it, SAML implementations use it, and applications rely on it for tokens, attachments, and various other data formats. Java provides a built-in decoder through java.util.Base64.Decoder, so developers generally have little reason to implement their own.
Normally, this is exactly what you want. Using the standard library is preferable to reinventing functionality that has already been tested and maintained. But when the standard library itself contains a vulnerability, the consequences can extend well beyond any individual application.
According to Calif's research, malformed Base64 input can trigger memory corruption in certain OpenJDK implementations, potentially leading to remote code execution. More concerning, the researchers report demonstrating pre-authentication exploitation against several widely deployed Java applications running in their default configurations.
That means an attacker may not need valid credentials to exploit an affected system, making this considerably more urgent than a vulnerability that requires an authenticated user. But there is a slight catch when it comes to who is actually vulnerable.
Who Is Vulnerable?
The vulnerability affects OpenJDK Java 17.0.6 and later (that’s every OpenJDK since 2021!) across distributions including Oracle OpenJDK, Oracle Java SE (such as versions 8u511b33-perf, 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3, and 27.0.1.0.3), Oracle GraalVM for JDK, Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, and Red Hat OpenJDK. However, there's an important qualification: the system must be running on an x86-64 processor with AVX-512 VBMI support, whereas native ARM64 JVMs are not affected. That hardware requirement narrows the affected population, although not nearly as much as you might hope.
Modern Intel Xeon and AMD EPYC processors are common throughout enterprise data centers and cloud infrastructure. Many AWS, Azure, and Google Cloud instance families use processors from the affected families, meaning that any organizations running Java workload in the cloud are just as likely to be affected as on-prem.
This means that two organizations running the same Java application and Java version might have different exposure depending on the underlying hardware. Native ARM64 JVMs are not affected, but for organizations running x86-64 infrastructure, identifying vulnerable systems requires more than simply searching for a particular Java version. They need to understand the relationship between the Java runtime, processor architecture, and application processing the input, which is a level of visibility many organizations don't currently maintain.
If you have shell access, you can get this information using various command line tools. For Linux: lscpu | grep -i avx512 and grep -o avx512 /proc/cpuinfo | head -n 1. On Windows you can install coreinfo from Microsoft and run coreinfo.exe -f. For Kubernetes, you can look for feature.node.kubernetes.io/cpu-cpuid.AVX512VBMI: "true" in your node selection. For docker, AVX isn’t explicitly declared, and we recommend using the Linux command above. Our advice if you are using an affected version is simply to update it, regardless of CPU architecture, as it is difficult to know if you are affected.
The Application List Should Get Your Attention
Calif's initial testing demonstrated remote code execution against several recognizable enterprise applications and we confirmed an out-of-bounds heap write from the code. The affected applications include pre-authentication exploitation of Atlassian Confluence and Jira, JFrog Artifactory, Jenkins, Keycloak, PingFederate, and certain Spring Boot applications. The researchers also reported post-authentication exploitation against Apache Kafka Broker, Elasticsearch, and Gerrit.
These aren't obscure applications sitting in forgotten corners of the network. They're central components of development pipelines, identity infrastructure, artifact management, and enterprise operations. Consider Jenkins or Artifactory, where a compromise could potentially provide access to source code, build infrastructure, credentials, and software distribution systems. Keycloak and PingFederate are equally concerning, because identity services often occupy privileged positions within an organization's architecture and are publicly accessible.
A vulnerability that begins with malformed Base64 input could become a much larger incident if the compromised application has access to sensitive resources. It's also worth emphasizing that Calif's list is not exhaustive, and the researchers expect additional Java applications running on affected hardware to be vulnerable.
That doesn't mean every deployment of these applications is automatically exploitable. Runtime versions, hardware capabilities, application configuration, and reachable input paths all matter when determining actual exposure.
What Defenders Should Do Right Now
For Semgrep customers we have updated our existing Detect-2Shell workflow to easily check if your repositories may be vulnerable. See Run Agentic Workflows for instructions in the docs.
Java results are the issues whose titles start with Java runtime exposure candidate. To see only those, filter Detect-2shell issues by that title. You can do this on the Workflows page, via the MCP, or with the Issues API’s titleQuery filter.
For those running agentic security programs, we have produced a runbook-style prompt for use with your preferred harness. You will need to grant an agent at least read-only infrastructure access, but this will produce an in-depth report which should allow you to quickly determine exposure.