On 17 November 2026, Oracle and the OpenJDK project shipped fixes for CVE-2026-114938, a memory corruption bug in the Base64 decoder built into the Java runtime. Calif, who found it and named it Java4Shell, reports unauthenticated RCE against Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate in their default configurations. Calif scores it 9.2 on CVSS v4.0. Oracle scores it 8.1 on v3.1, with attack complexity high.
What matters:
If you are a Pentera customer, you’re already covered and can validate Java4Shell (CVE-2026-114938) exposures in your environment.
- This is RCE. Calif demonstrated it against named products and is holding the exploit chains back for now. There is no single exploit: by Calif’s own account, every target needs its own chain.
- There are three outcomes, in rising order of effort: crash the JVM, read its heap, run code. The first takes a 65-character string. Plan for the third.
- Four conditions have to hold at once: OpenJDK 17.0.6 or later, an x86-64 CPU with AVX-512 VBMI, AVX-512 left on in the JVM, and a stranger’s Base64 reaching the JDK’s decoder. ARM64 is not affected. Standard Java 8 and 11 are not affected either.
- The CPU condition means the same container image can be exposed on one host and immune on the next. No version string or SBOM records that.
- No exploitation in the wild has been reported, and the CVE is not in CISA’s KEV catalog, as of 18 November. CISA issued an alert on 17 November telling organizations to patch immediately.
Security teams: move to your vendor’s fixed build (Oracle’s are 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1), rebuild images, and restart every JVM. If you cannot patch today, start affected JVMs with -XX:-UseBASE64Intrinsics. Then check the running process, not the java on your path.
An equals sign, alone
Java’s selling point is memory safety, and the Java code here is fine. The bug sits one layer down. This section leans on Calif’s write-up and Datadog’s analysis, which agree on the mechanism.
When a method runs hot, HotSpot’s C2 compiler can swap it for an intrinsic: hand-written machine code that uses whatever the CPU offers. For Base64 decoding on a CPU with AVX-512 VBMI, that is a routine which turns 64 input characters into 48 output bytes per step, plus a separate handler for whatever is left over at the end.
The handler works out how many bytes the leftover should produce, then builds a mask so that the final 64-byte store writes only that many. Hand it a leftover that is nothing but padding and the arithmetic goes like this:
leftover "=" 1 character, after 64 valid ones
output bytes (1 / 4) * 3 = 0
minus padding 0 - 1 = -1
mask width low byte of -1 = 255
mask 255 >= 64, so all 64 bits stay set
A mask for minus one bytes should not exist. The instruction that builds it treats any width of 64 or more as “keep everything”, so the store that should have written nothing writes all 64 bytes. Java had sized the output array for the valid data: 50 bytes for this input, 48 of them already used. The store starts at offset 48 and runs 62 bytes past the end, into whatever the heap placed after the array.
The attacker does not choose those 62 bytes. They are residue from the decoder’s own padding, a fixed pattern. What the attacker can influence is where they land.
And Java does notice. The decoder throws IllegalArgumentException for the malformed input, the application handles it like any other bad request, and everybody moves on. By then the write has happened. Catching the exception, as Datadog points out, leaves the damage where it is.
The whole trigger is 64 A characters and one =. On OpenJDK 17 it is 128 and one.
Crash, leak, shell
What a fixed 62-byte overwrite is worth depends on how much work the attacker puts in. There are three outcomes.
Crash. Send the string, hit something the JVM cares about, and the process dies. In Datadog’s standalone test the write clobbered a neighboring array’s header and the JVM fell over later, during garbage collection, nowhere near the decoder call. This one costs nothing. And when the decoder is reachable before login on an identity provider or a build server, “only a denial of service” is not a comforting sentence.
Leak. Calif’s chain aims the write at the length field of a neighboring array. An array with an inflated length will hand back memory that belongs to something else, and if the application returns that array in a response, the attacker is reading the Java heap: keys, tokens, session data. Calif calls this stage JavaBleed. It comes before code execution in the chain, so it takes less work, and so far it has had far less coverage.
Shell. From there the chain repairs what it broke, widens the write, and works its way to memory the JVM will execute. Calif reports this before authentication on the six products above, after authentication on Kafka, Solr, Elasticsearch, Gerrit and Spinnaker, and on sample applications built with Struts and Spring Boot.
The fine print is Calif’s own. There is no universal payload. Each target needs its own route to the decoder, its own heap layout and its own way of reading results back. The heap grooming is spray and retry until the layout lands. Timing mattered enough that they rented a VM in the same cloud region as the target. A miss can kill the JVM, although often the attacker simply tries again.
It is still RCE, built one application at a time. The product list is Calif’s claim, shown on video, with the chains withheld until people have had time to patch. I take it at face value. The write-up is specific enough to check, and on the same day Kevin Breen of Immersive reported a working exploit of his own, with the same caveat: it has to be adapted to each application.
Three hours, under $200
Oracle’s score says attack complexity is high. Calif’s says critical. They are describing the same per-application work and disagreeing about how much it should reassure you.
Here is Calif’s account of that work. Finding the bug took about an hour, most of it spent steering an AI coding agent past false leads. The first working exploit took two more. The token bill was under $200. They built the pipelines and heap tooling for the first targets by hand, and say agents then produced most of the later chains almost on their own.
Last month we wrote that “too hard to exploit” has an expiry date. Last week, that “no public exploit” has one too. “Attack complexity: high” is the same kind of statement. It measures effort, and effort is the thing that got cheap. An exploit that has to be rebuilt for every application used to slow mass exploitation down. Once the rebuilding can be handed to agents, it is a queue.
Two caveats, so this is not oversold. That is Calif’s bill, for a team that knew where to look and built its own tooling first. Someone else’s will be different. And so far it is quiet: as of 18 November nobody has reported an attack. Calif says it will publish the per-product chains later. Read that as a schedule.
“Everywhere” has four conditions
Calif’s tagline is “Write once, RCE everywhere”. The RCE part holds. “Everywhere” needs four things to be true at the same time, and Red Hat’s bulletin lists them.
- The runtime. OpenJDK 17.0.6 or later, across the Java 17, 21, 25 and 27 release lines, in any distribution built from it: Temurin, Corretto, Zulu, Microsoft, Liberica, SapMachine, Red Hat, Oracle. OpenJDK 8 and 11 do not contain the code. One exception: Oracle lists its Java 8 Enterprise Performance Pack as affected. The Java 8 that is safe is the one nobody paid to make faster.
- The CPU. An x86-64 CPU with AVX-512 VBMI, which means Intel Xeon from Ice Lake onward and AMD from Zen 4 onward. ARM64 is not affected. Red Hat names the cloud families most likely to qualify, among them AWS C6i, M6i, R6i and C7i, GCP C3 and C4, and Azure’s D-series v5 to v7.
- The flags. AVX-512 and the Base64 intrinsic are enabled in the JVM. That is the default.
- The route. A stranger’s Base64 reaches java.util.Base64. In the build Datadog tested, the basic and URL-safe decoders take the vulnerable path and the MIME decoder does not. A library that ships its own decoder, or rejects bad padding first, never reaches it.
Conditions 1 and 4 can at least be reasoned about from an inventory and some code reading. Condition 2 cannot. A CPU feature belongs to the host, so the same image, with the same JDK and the same SBOM, is exposed on one node and immune on the next. Change an instance type or add a node pool, and the answer flips while nothing a scanner reads has changed. Last week’s post was about the gap between “affected” and “exposed”. This week that gap runs through the scheduler.
Two assumptions that do not hold.
“It doesn’t listen on anything” is not an exemption. Calif says the researcher samczsun shared a client-side exploit with them, in which a Java program is compromised by opening a TLS connection to a malicious server. Outbound-only Java, meaning agents, batch jobs and integrations, belongs in scope.
A buffering proxy is not an exemption either. Default request buffering in nginx breaks the chains that feed a request in pieces, but Calif’s Elasticsearch chain runs from one complete request, and a buffered request still gets decoded, so the crash arrives regardless.
What to do, and what not to trust
Patch. It is the only complete fix.
| Where your Java comes from | Fixed in |
|---|---|
| Oracle Java SE 17 | 17.0.21.1 |
| Oracle Java SE 21 | 21.0.13.1 |
| Oracle Java SE 25 | 25.0.5.1 |
| Oracle Java SE 27 | 27.0.1.1 |
| Oracle Java SE 8 Enterprise Performance Pack | 8u513-perf |
| Amazon Corretto | 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2, 27.0.1.1.4 |
| Red Hat (RHEL 8, 9, 10 and Red Hat build of OpenJDK) | Errata pending as of 18 November |
| Temurin, Microsoft, Zulu, Liberica, SapMachine | Check the vendor’s advisory |
Oracle’s fixed builds differ from the vulnerable ones by a trailing .1, so 17.0.21 is not the answer to “are we on the fixed version”. After updating, rebuild container images on the new base, redeploy, and restart every JVM. Patched on disk is still not patched in memory.
If you cannot patch yet, two startup flags keep the vulnerable code from running:
- -XX:-UseBASE64Intrinsics switches off the Base64 intrinsic and nothing else. This is the narrow one.
- -XX:UseAVX=2 switches off AVX-512 for the whole JVM. Red Hat recommends it as the interim measure. It costs more performance, and it is x86-64 only: an ARM64 JVM does not recognize it and refuses to start, so keep it out of shared startup config.
Calif lists both and Datadog tested both. According to Tenable, neither Oracle’s advisory nor OpenJDK’s mentions them. Treat them as temporary and take them out once the fixed build is in.
Whichever you choose, confirm it on the process, not on the host:
jcmd <PID> VM.version
jcmd <PID> VM.flags -all
What not to trust:
- java -version in your shell. It reports the JDK on your path. The one that matters is inside the product, the image or the appliance.
- A clean result from Calif’s public reproducer. It tells you whether one JDK on one CPU has the bug. It says nothing about whether an application on that host passes a stranger’s Base64 to it, and nothing about the next node.
- A CPU flag check run from the wrong place. Hypervisors can hide features from guests, so ask inside the VM or container that runs the JVM.
- Detection advice with a signature in it. I have seen no published indicators of compromise. JVM crashes during garbage collection on hosts that meet the four conditions are worth a look, because that is the failure the public testing produces. That is an inference from the bug, not a signature.
What stays with me
Calif closes its write-up by asking why everyone carries an optimization that few asked for. It is a fair question. The AVX-512 decoder exists for workloads that push bulk data through Base64. On the right CPU it can also end up decoding the Authorization header on a login page. In Java 17 it arrived in an update release, 17.0.6. Nobody running an identity provider chose that trade, and nobody was asked.
The other thing is where the bug lives. “Memory-safe” describes the language. Underneath it is a runtime written in C++ and, in places, assembly by hand, and it is as safe as its last review. PHP2Shell was in the engine, not in anyone’s PHP. This one is in what the JIT emits, not in anyone’s Java. Both times, the layer everyone audits was fine.
Neither of those is yours to fix. Your part is the answer to “are we exposed?”, and this time neither the version string nor the image will give it to you. Ask the running process, on the host it is actually running on.
References
- Calif: Java4Shell
- Red Hat: RHSB-2026-018
- Datadog Security Labs: Java4Shell
- Tenable: Java4Shell FAQ
- SOCRadar: Java4Shell, What You Need to Know (status as of 18 November, downstream fixed builds)
- Pentera: PHP2Shell, the expiry date on “too hard to exploit”
- Pentera: CVE-2026-119618, the gap between “affected” and “exposed”