TL;DR
- Java4Shell (CVE-2026-114938): the vulnerability corrupts heap memory through the OpenJDK base64 decoder on x86-64 AVX-512 VBMI hosts running 17.0.6 or later, patched Nov. 17, 2026.
- Pre-auth RCE on Jira, Jenkins, and Keycloak: these critical services store keys, tokens, and personal data.
- Secrets can leak before code runs: The heap read can leak keys, tokens, and personal data from a Java service's memory, so a failed RCE attempt can still expose credentials.
- Fixed in 17.0.21.1, 21.0.13.1, and 25.0.5.1: Install Oracle's fixed builds or your vendor's equivalent, or set
-XX:-UseBASE64Intrinsics, then revoke every credential contained in the application and its environment on each exposed Java service.
What is Java4Shell and how does it work?
Java4Shell is a bug in the hand-written x86-64 assembly that OpenJDK's C2 JIT substitutes for the base64 decoder, using AVX-512 VBMI instructions. The routine decodes the input in 256-byte blocks, or 64-byte blocks if the input is shorter, and finishes the tail with the evmovdqub instruction. That instruction takes a 64-bit mask that selects which bytes reach memory. The mask is built from the output length. For a tail of 1 to 3 base64 characters ending with padding, the output length is zero; however, the padding handler still decrements it, so it underflows to -1 or -2. bzhiq(-1, output_len) instruction leaves every bit set when the length is 64 or more, so output_mask becomes all ones and all 64 bytes are written.
Considering an example payload of 64 A tailed by =, Java allocates a 50-byte result array, and the store starts at offset 48, so 62 bytes land past its end. The stub then returns early, and the Java code throws IllegalArgumentException. By then, the neighboring objects are already damaged. Calif turns that overwrite into a heap leak and code execution.
Which deployments are exploitable
As of today, Nov 18, 2026, Calif has shown they could successfully compromise 6 critical applications before authentication: Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate, and 5 more after authentication: Kafka Broker, Solr, Elasticsearch, Gerrit and Spinnaker.
Calif demonstration of the exploitation of pre-authentication vulnerabilities in several of the above-mentioned applications.
The prerequisites for this vulnerability are low:
- The system must run an unpatched OpenJDK-based runtime from 17.0.6 onward, meaning Java 17, 21, 25 or 27, from any vendor. Java 8 and 11 do not contain the vulnerable code, except for Oracle's Java 8 Performance Pack.
- The CPU must support AVX-512 VBMI. This mainly concerns server-class x86-64 CPUs.
- Finally, the application must decode base64 data controlled by the attacker.
To get remote code execution, an attacker has to:
- Line up the memory first: The bug only overwrites a small, fixed amount of data, so the attacker must arrange the server's memory remotely so that this overwrite hits the right spot. This means warming up the decoder and sending requests in a carefully timed order, retrying after misses, and needing a stable network connection.
- Turn that small overwrite into full control: Once it lands, the attacker uses it to read the server's memory and write chosen data into it.
Why Java4Shell is a secrets theft vector
Calif's pre-auth list reads like an inventory of the places where teams leave secrets, whether on purpose or by accident.
Jenkins runs build and deploy jobs, so it holds credentials for source control, cloud accounts, and production servers, plus environment variables and build logs that often contain tokens.
Artifactory stores build artifacts and the credentials used to publish and pull them. Jira and Confluence are where people paste passwords, API keys, config files, and screenshots into tickets and wiki pages. Keycloak and PingFederate hold the identity layer, meaning user accounts, sessions, tokens, and signing keys. These secrets outlive the vulnerability. An attacker can still use it long after the patch is applied. The response has to cover everything the host had access to, not just the host.
Java4Shell incident response: six immediate actions
If you confirm or suspect Java4Shell exploitation on a host, assume every secret it could read has been taken, and work through these six steps:
- Isolate the host: take it off the network.
- Patch or mitigate the rest of the fleet: Oracle's fixed builds are 8u513-perf, 17.0.21.1, 21.0.13.1, 25.0.5.1, and 27.0.1.1. Other vendors ship on their own schedules. Until then, start the JVM with
-XX:-UseBASE64Intrinsics. Check bundled runtimes too: Keycloak's official images ship a vulnerable JDK. - Sweep other Java hosts: Java version alone isn't enough. On Linux, check for the
avx512f,avx512bw,avx512vbmi, andbmi2CPU flags. Treat unexplained JVM crashes since Nov. 17 as possible exploit attempts, since failed attempts can crash the application. - Inventory and revoke secrets: list every credential the JVM loaded, from configuration files, environment variables, keystores, and credential stores. Then, rotate them.
- Audit downstream access: check the logs of the systems those credentials open, for example CloudTrail for AWS keys or Kubernetes audit logs.
- Hunt for payload execution: look for unexpected child processes of the JVM, outbound connections from the application server, and new files in its directories.
Step four is where teams lose time. A Jenkins instance that has run for years holds credentials nobody remembers adding. Rotation depends on knowing what to rotate. If you first have to find the secrets, the attacker keeps the head start.
How GitGuardian helps you to prepare for the next breach
A secrets inventory is best built before an incident, but GitGuardian can also build it during the response, which is faster than running homemade scripts. To reduce exposure before the next incident and detect intrusion when it happens:
- NHI Governance builds it: it discovers the service accounts, API keys, and tokens in use across the dev ecosystem, attributes each one to an owner, scores its criticality, and flags the ones overdue for rotation under the policy you configured. The three blocks of the playbook above (perimeter, impact, dependencies, and authorities) come out of that inventory instead of a spreadsheet, and a credential that has not been rotated since the host was built shows up as overdue before anyone exploits java4shell.
- Developer Endpoint Protection feeds the same inventory from the other end of the chain. The
.envthat ends up on the host starts on a developer laptop, next to~/.aws, shell history, and MCP configuration files. ggshield runs on schedule on those machines, with no continuous agent, and reports the secrets found by machine and severity. - Honeytokens detect intrusion. Placed in a
.envon the host, they fire an alert when used. An attacker who reads the configuration after Java4Shell will try them.
FAQ
What is the Java4Shell vulnerability?
Java4Shell (CVE-2026-114938) is a bug in the hand-written x86-64 assembly that OpenJDK's C2 JIT uses for the base64 decoder. OpenJDK and Oracle fixed it on Nov. 17, 2026. For a short tail ending with padding, the output length underflows, the write mask becomes all ones, and 64 bytes are written at once, 62 of them past the end of a heap array. Calif turned that overwrite into a heap leak and code execution.
Which systems are vulnerable to Java4Shell?
Three conditions must all be true: an unpatched OpenJDK-based runtime from 17.0.6 onward (Java 17, 21, 25, or 27, from any vendor), a CPU that supports AVX-512 VBMI, which mainly means server-class x86-64 CPUs, and an application that decodes base64 data controlled by the attacker. Java 8 and 11 don't contain the vulnerable code, except for Oracle's Java 8 Performance Pack.
Which applications can Java4Shell compromise?
Calif demonstrated their ability to compromise six applications before authentication: Keycloak, Jira, Confluence, Artifactory, Jenkins, and PingFederate. After authentication, they are able to compromise five more: Kafka Broker, Solr, Elasticsearch, Gerrit, and Spinnaker.
Is Java4Shell being exploited in the wild?
As of Nov. 18, 2026, GreyNoise had recorded 53 Java4Shell-shaped requests from three IP addresses, with no confirmed success. Calif has published a bounded proof of concept and is holding back its product exploit chains.
How do I fix or mitigate Java4Shell?
Install Oracle's fixed builds (8u513-perf, 17.0.21.1, 21.0.13.1, 25.0.5.1, and 27.0.1.1) or your vendor's equivalent, since other vendors ship fixes on their own schedules. Until then, start the JVM with -XX:-UseBASE64Intrinsics. Check bundled runtimes too: Keycloak's official images ship a vulnerable JDK.
Why is Java4Shell a secrets theft risk?
The applications Calif compromised hold secrets. Jenkins holds credentials for source control, cloud accounts, and production servers. Jira and Confluence collect pasted passwords and API keys. Keycloak and PingFederate hold tokens and signing keys. The heap corruption and read can expose keys, tokens, and personal data before any code execution is attempted, so a failed RCE attempt can still leak credentials.
What should I do if Java4Shell was exploited on my server?
Isolate the host, patch or mitigate the rest of the fleet, and sweep other Java hosts for the CPU flags and unexplained JVM crashes since Nov. 17. Then list and revoke every credential the JVM loaded, check the logs of the systems those credentials open, and look for signs that a payload ran.
Is Java4Shell related to Log4Shell?
No. Log4Shell (CVE-2021-44228) was a flaw in the Log4j logging library. Java4Shell is a flaw in the OpenJDK runtime itself, so it affects Java applications whether or not they use Log4j.





