Java4Shell: a five-month-old Java bug, patched only after an exploit

The second "2Shell" in two months is the one running your identity provider, your build server and your artifact store. The interesting part is not how fast AI found it. It is how long everyone already knew.
Java4Shell, tracked as CVE-2026-114938, is a heap overflow in the Base64 decoder built into modern OpenJDK, and on an unpatched server it hands an anonymous attacker remote code execution in Keycloak, Atlassian Jira and Confluence, Jenkins, JFrog Artifactory and PingFederate, per Calif Research's technical write-up. Oracle shipped fixes at 1pm Pacific on November 17 in OpenJDK 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1, matching the OpenJDK vulnerability advisory. Calif scores it 9.2 under CVSS 4.0; Oracle scores the same flaw 8.1 under CVSS 3.1.
Why this one lands harder than the PHP bug that preceded it: Java is the third most popular programming language on the TIOBE index and, by IBM's count, runs inside 90% of Fortune 500 companies. The products where Calif demonstrated pre-authentication code execution are the ones that hold everybody else's keys. A compromised Keycloak or Jenkins is not one breached service; it is a path into the estate behind it. The same corruption also gives a Heartbleed-style read of the Java heap, which Calif calls JavaBleed. Private keys, session tokens, passwords and customer data can come back in the response.
What the bug actually is
OpenJDK decodes Base64 with hand-written assembly, using AVX-512 instructions to process 64 bytes at a time. The bug is in how that routine handles the tail of a malformed string. If the input ends in one or two padding characters, the code subtracts from an output length that is already zero, and the value wraps around. The mask that decides how many bytes get written comes out as all-ones, so a 64-byte vector store lands where only a couple of bytes were expected.
Calif's minimal trigger is 64 letter A's followed by a single equals sign: 65 bytes in, a 50-byte result buffer allocated, and 62 bytes written past the end of it. Java does reject the input with an exception. It does that after the write. On OpenJDK 17 the trigger is 128 A's plus the equals sign.
Turning that into code execution is not a one-liner. The overflow writes fixed bytes at a controllable position, so exploitation is heap grooming over the network: line up allocations so the write enlarges a neighbouring buffer's length, use that to build a read primitive, then escalate to the JIT code cache. Calif's point is that this is why there is no universal payload. Each target needs its own profile depending on how it uses Base64 and how its heap behaves.
Who is actually exposed
Headlines this week said every Java application is at risk. The real exposure is narrower, and that matters for the order in which you patch.
The vulnerable code path only exists on x86-64 processors with AVX-512 VBMI support: Intel's Ice Lake through Granite Rapids server parts, and AMD Zen 4 or newer. ARM64 machines are not affected, x86-64 chips without that instruction set are not affected, and OpenJDK 17.0.6 is the floor. Standard Java 8 and Java 11 are clear, with the exception of Oracle's Java SE 8 Enterprise Performance Pack. So the first question for most teams is hardware inventory, not panic.
The second question is which JDK you are actually running. The flaw is in OpenJDK, which means it inherits into Eclipse Temurin, Amazon Corretto, Azul Zulu, Microsoft's build, Red Hat's, SAP's SapMachine, BellSoft Liberica, Oracle's Java SE and GraalVM. It also ships inside the JDKs that products and container images bundle for themselves. Patching the host operating system does nothing for those copies, and they are exactly the copies nobody inventories — which is how a bug patched in November is still running in production in 2029.
The part that should worry you more than the bug
Calif's Quang Luong found Java4Shell on October 24 by pointing OpenAI's Codex at the JVM's intrinsics and cryptography code. The model found the flaw within an hour, the team had a working exploit two hours later, and the total token bill was under $200.
Now the timeline underneath that. The bug was already public. A user called sundarms hit it in the wild in June and opened an Adoptium support issue; on September 8 they posted a proof of concept that reproduced the crash, and the same day another developer identified the root cause and proposed a fix in an OpenJDK pull request. That pull request was closed without being merged. Calif, unaware, rediscovered the bug in October, found the original public report two days later, and only then did the fix get built, with the disclosure moving forward after Calif demonstrated pre-authentication code execution in Jenkins and Keycloak.
So AI did not find something a human could not. It made the severity impossible to defer. The discovery was never the expensive step; the triage, the ownership and the decision to spend engineering time were. We saw the same pattern in October with PHP2Shell: the PHP RCE that puts 70% of the web at risk, where a bug class flagged years earlier waited for a frontier model to make it urgent.
What to do this week
Nothing reported confirmed exploitation in the wild as of November 17 — Qualys and Upwind both said so — and the CVE was not in CISA's known-exploited catalog at disclosure. That is a head start, not an all-clear, because the exploit code exists and the patch is public.
Patch by blast radius rather than by ticket order: internet-facing identity providers first, then Jira, Confluence, Jenkins and Artifactory, then anything that decodes Basic auth headers, SAML messages, tokens or uploads before it authenticates you. Check every process, not every host, because the JDK that matters is often the one baked into an application image. If a system cannot be patched immediately, the platform can fall back to its software Base64 decoder by starting the JVM with -XX:-UseBASE64Intrinsics, at some cost in throughput on Base64-heavy services.
The Java bug lands in the year the vulnerability count broke its own scale: 2026 passed 100,000 disclosed vulnerabilities this week, more than double 2024 and 2025 combined, Wired reports. In 2022, the last year before LLMs went mainstream, the number was around 25,000. AI-assisted code auditing is producing the supply, and AI-assisted exploit development is shortening the other end of the pipeline.
The exploited subset is still small, and that is the honest counterweight. CISA's known-exploited catalog has taken roughly 300 additions this year; VulnCheck's own database puts it near 1,500, which is 1.5% of everything discovered. Most AI-found bugs are not weaponizable, and Dataminr's Joe Slowik told Wired that the number you need to care about has stayed roughly constant while the pace of weaponization has risen sharply.
The pressure shows up as operational failure rather than breaches. Last week's streak of outages — Outlook, Apple, several US banks, United Airlines, and the NSA's internal comms — had routine causes, not an AI attack campaign. The NSA's was a botched patch install after October's emergency PHP updates. Cloudflare chief executive Matthew Prince told Wired it will "feel like the sky is falling for two years" before defenders get on top of common vulnerability classes. Slowik's version is blunter: there is no longer time to validate a patch before it has to ship.
What to watch: whether Java4Shell reaches CISA's exploited list, the first public exploit for a specific product, and whether the OpenJDK project changes how it handles a reported crash that comes with a reproduction but no working attack.
Are you inventorying the JDKs inside your containers, or just the ones on the host?







