Java4Shell (CVE-2026-114938) Patched: OpenAI's Codex Found the Java RCE in an Hour, but the Bug Sat in a Public Tracker Since June — Who Is Really Exposed and How to Fix It

Oracle and OpenJDK have fixed Java4Shell, a Base64 decoder overflow that allows pre-auth RCE in Keycloak, Jenkins, Jira and more on AVX-512 VBMI servers, after an AI agent rediscovered a crash first reported publicly in June.
Oracle and the OpenJDK project have shipped fixes for Java4Shell (CVE-2026-114938), a memory-corruption flaw in the Java Virtual Machine's Base64 decoder. When we covered it on 17 November it was still a reserved CVE with no advisory. Since then the fixes are out, CISA has told organisations to patch immediately, and the discoverers' timeline has turned up something odd: the bug was not new. A user had reported the crash publicly in June. An AI coding agent then found it again in under an hour in October, and that rediscovery, backed by working exploits, is what got it fixed.
This piece covers what changed since the CVE went public, which systems are actually exposed (fewer than the "Log4Shell" comparisons suggest), and what to do before the product-specific exploits come out.
What Happened
Oracle and OpenJDK released the fixes at 01:00 Mauritius time on 18 November (21:00 UTC on 17 November). Security firm Calif, which reported the flaw to Oracle, published its write-up minutes later and named the bug Java4Shell. CISA issued an alert the same day. It urged organisations to find every affected Java installation, including runtimes bundled inside third-party applications, container images and appliances, and to patch internet-facing systems first.
Calif says it has demonstrated pre-authentication remote code execution against default configurations of Keycloak, Jira, Confluence, JFrog Artifactory, Jenkins and PingFederate. It also reports post-authentication RCE in Kafka, Solr, Elasticsearch, Gerrit and Spinnaker. The firm is holding back those product-specific exploit chains until users have had time to upgrade, and says it will publish them later. Its public proof of concept only reproduces the memory corruption.
The AI Angle: Found in an Hour, but Reported in June
According to Calif's timeline, researcher Quang Luong told OpenAI's Codex agent to audit HotSpot's JIT compiler, intrinsics and cryptography code. Codex flagged the bug within an hour on 24 October. Calif says a first working exploit took about two more hours and less than $200 in model costs, and that the transcripts show the agent did not look up existing bug reports.
Two days later Calif found that the bug was already public:
- 9 June: a user hit the crash and opened an issue in the Eclipse Adoptium (Temurin) tracker.
- 8 September: the same user posted a reproducer, and an OpenJDK developer identified the root cause that day.
- 9 September: a fix was proposed as an OpenJDK pull request, which was closed without being merged.
- 24 October: Calif reported the flaw to Oracle with a post-auth Elasticsearch RCE proof of concept.
- 31 October: Calif sent pre-auth RCE proofs of concept for Jenkins and Keycloak.
- 13 November: Oracle confirmed a fix and set the release date.
- 17 November: the fix shipped, crediting both the OpenJDK developer and Quang Luong.
Calif's own conclusion is that the bug "was actually public" and was fixed only once someone showed it could be exploited. For defenders this is the part that matters. Crash reports that look like reliability bugs can hide security flaws for months. AI agents can now go through that backlog, and turn a crash into an exploit, faster and more cheaply than many triage teams can.
Technical Details
The flaw is in HotSpot's hand-written x86-64 Base64 intrinsic: optimised machine code the JVM uses in place of the Java implementation of java.util.Base64.Decoder. On CPUs with AVX-512 VBMI, the JVM picks a vector routine that decodes 64 bytes at a time. Calif found that the store mask for the padded tail is calculated wrongly. With = padding the output length underflows, the mask becomes all ones, and 64 bytes are written at offset 48 of a 50-byte buffer, 62 bytes past its end. Java then rejects the malformed input, but by that point memory has already been corrupted.
Things to know about exploitability:
- The code must be hot. The intrinsic only runs after the JIT has compiled the decoder into native code (C2), which Calif's exploit forces by "warming" it. On busy servers that decode Base64 constantly, the decoder is already compiled.
- Basic and URL-safe decoders are affected. Researchers report that the MIME decoder does not take the vulnerable path.
- The attack surface is pre-auth in many products. HTTP Basic credentials, SAML messages, tokens and file uploads are often Base64-decoded before authentication finishes.
- Crashing is easy. Code execution is harder. Researchers note that crashing an affected JVM is trivial and can be repeated to keep a service down. Reliable RCE needs heap grooming plus a separate memory leak to defeat ASLR.
- Clients are exposed too. Calif reports a client-side exploit, shared by another researcher, that compromises a Java program when it connects over TLS to a malicious server, even with no listening port.
Who Is Affected
All three of these must be true:
- Java version: OpenJDK-based HotSpot 17.0.6 or later, including 21, 25 and 27. Java 8 and 11 are not affected, except Oracle's Java SE 8 Performance Pack build (8u511b33-perf), which Oracle lists as vulnerable. End-of-life lines such as 18–20, 22–24 and 26 are affected and will not get fixes.
- CPU: x86-64 with AVX-512 VBMI, which means Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids or Granite Rapids, or AMD Zen 4 and newer. ARM64 is not affected, and older x86 CPUs take a different decode path. Red Hat notes that many current cloud instance families run on these CPUs, including AWS C6i/M6i/R6i and C7i/M7i/R7a, GCP C3/C3D/C4/N4 and Azure Dsv5 to Dsv6. In Kubernetes, a container sees its node's CPU.
- JVM settings: the JVM was not started with AVX disabled (
-XX:UseAVX=2or lower) or the Base64 intrinsic turned off.
Red Hat calls affected systems "vulnerable out of the box", because the JVM selects the AVX-512 path automatically.
Patch Status
Oracle rates the flaw 8.1 under CVSS 3.1, citing high attack complexity. Calif scores it 9.2 (Critical) under CVSS 4.0, and Red Hat rates it Critical. Oracle's fixed builds are 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1. Amazon Corretto, Azul Zulu, Oracle GraalVM and Eclipse Temurin have published matching builds. Distribution packages are uneven. As of its 20 November update, Red Hat says it is still expediting errata for RHEL 8, 9 and 10, and Debian had fixed only its unstable branch. The Keycloak project has shipped updated images.
Restart services after patching. A running JVM keeps the vulnerable code until it is restarted.
As of 19 November, no exploitation in the wild had been confirmed, and the CVE was not in CISA's Known Exploited Vulnerabilities catalog. Internet-scanning researchers have logged a small number of Java4Shell-shaped probes from a handful of IP addresses, with no successful intrusions reported.
What To Do Now
- Inventory runtimes, not just hosts. Check bundled JREs in vendor appliances, container base images and CI agents. Many do not show up as separate inventory items.
- Prioritise by CPU. Patch internet-facing Java services running on AVX-512 VBMI hardware first.
- Upgrade and restart. Re-pull container images, because some registries reuse the same tags for the fixed builds.
- Apply the interim mitigation where you can't patch yet. Red Hat's preferred workaround disables only the Base64 intrinsic. Avoid
-XX:UseAVX=2in mixed fleets, because JVMs on ARM fail to start with it. - Watch for crashes. Unexpected JVM crashes (hs_err logs) on exposed services could be exploitation attempts and are worth investigating.
# Does this CPU have the vulnerable feature set? (all four must print)
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
# Java version
java -version 2>&1 | head -1
# Interim mitigation until the fixed build is installed
export JAVA_TOOL_OPTIONS="${JAVA_TOOL_OPTIONS:+$JAVA_TOOL_OPTIONS }-XX:-UseBASE64Intrinsics"
# Confirm a running JVM picked it up (expect: bool UseBASE64Intrinsics = false)
jcmd <pid> VM.flags -all | grep -F UseBASE64Intrinsics
Why It Matters
Java4Shell is unlikely to be a repeat of Log4Shell. The CPU requirement, JIT warm-up and ASLR bypass narrow it considerably, and several researchers do not expect mass exploitation. The risk will go up once Calif publishes its product chains, though, and denial of service is already easy for anyone who can reach an exposed decoder. The bigger lesson is in the timeline. A security bug sat in a public tracker for four months, with a proposed fix that was closed unmerged, until an AI agent rediscovered it and a human team proved it was exploitable. Attackers have the same agents, and public crash reports are now material for exploits.
