Java was supposed to be the safe one. It manages its own memory, and that promise has carried banking, airlines, and telecoms for thirty years. On November 17, that promise cracked in the last place anyone looked: CVE-2026-114938, now called Java4Shell, a memory-corruption bug in OpenJDK’s Base64 decoder that lets an attacker run code on your servers with no password and no account.
Here is what Base64 does and why it matters to you. Base64 turns binary data into text, and Java uses it everywhere: auth headers, tokens, file uploads, most network messages. To decode it faster, OpenJDK swaps the normal code for AVX-512 CPU instructions that chew through 64 bytes at a time. The bug lives in that hand-written assembly, and it only fires on x86-64 machines with AVX-512 VBMI: Intel Ice Lake and newer, AMD Zen 4 and newer. ARM64 is not affected.
The trigger is almost embarrassing: 64 letter A’s followed by an equals sign. On OpenJDK 17 it takes 128 A’s plus the equals sign. That malformed tail makes the routine compute a negative output length, which turns into a full 64-byte write. For a 65-character input, OpenJDK allocates a 50-byte buffer and writes 62 bytes past the end. Java rejects the input afterward, but the neighboring memory is already overwritten. Your own input validation does not help: the corruption happens inside the decoder before your code gets a chance to say no.
The researchers at Calif, who published the finding, turned that write into a Heartbleed-style memory leak and then into remote code execution. They showed pre-auth RCE against Keycloak, Atlassian Jira, Confluence, JFrog Artifactory, Jenkins, and PingFederate in their default configs, plus post-auth RCE against Apache Kafka, Solr, Elasticsearch, Gerrit, and Spinnaker. They are holding back the specific exploit chains to give everyone time to patch. Cloudflare says it has seen no sign of exploitation on its own infrastructure, so the bug is critical but, as far as anyone knows, not being mass-exploited yet.
The score tells you how seriously to take this: 9.2 out of 10 under CVSS 4.0, critical, according to the researchers. Ubuntu rates it high with an 8.1 under CVSS 3.1. This is not a rare corner case. Any app that decodes attacker-controlled Base64 on the right hardware is exposed.
The story behind the patch is worth more than the score. Back in June, a user going by sundarms hit the bug in production and filed an Adoptium issue. In September, albertnetymk found the root cause and proposed a fix in OpenJDK. The pull request went quiet and was closed without merging. On October 24, a Calif researcher named Quang Luong pointed an AI model at the JVM’s JIT compiler and intrinsics, and it found the bug in an hour. He reported it to Oracle with a proof of concept, and Oracle shipped the patch on November 17.
Java4Shell affects OpenJDK 17.0.6 and newer, which means Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat OpenJDK, Oracle OpenJDK, Oracle Java SE, and GraalVM. Oracle lists these Java SE builds as vulnerable: 8u511b33-perf, 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3, and 27.0.1.0.3. The fix landed the same day in Oracle’s November Critical Patch Update and the OpenJDK security advisory.
On distributions the fix ships as a package. On Ubuntu, the fixed versions are openjdk-17 17.0.21.1+2, openjdk-21 21.0.13.1+2, openjdk-25 25.0.5.1+2, and openjdk-27 27.0.1.1+4. Updating the system package is not enough. Plenty of applications bundle their own JDK, and container images pin a fixed version, so you have to update each one and restart every service. A JVM that is already running keeps the old code.
If you cannot patch today, the researchers document two flags that disable the vulnerable path: -XX:-UseBASE64Intrinsics and -XX:UseAVX=2, the second only on x86-64. Both need a restart and can slow down workloads that decode a lot of Base64. They buy time. They do not replace the update.
The pattern is familiar, and that is what stings: a bug that was reported, with a fix proposed in September, sat there until someone proved it could be exploited. The difference between a hacker who finds flaws and a white hat who reports them is what they do with the discovery. The operational lesson is the same one we repeat: a patched Java with least privilege shrinks what an overflow like this can reach. Your to-do list is concrete: inventory the JDKs you run, update them, and restart the services. Leave it for later and you are up against a proof of concept that already works.