Java4Shell (CVE-2026-114938) is a critical OpenJDK Base64 bug hitting Java 17, 21, 25 and 27 on AVX-512 CPUs. How to check exposure and patch it today.
Vamsi Tallapudi
Manager, Architect Technology at Cognizant
Java4Shell (CVE-2026-114938) is a critical memory-corruption bug in OpenJDK's Base64 decoder that lets an attacker with zero credentials crash or potentially take over a Java app, as long as the app runs on an x86-64 chip with AVX-512 VBMI and the attacker can get malformed Base64 data in front of it. Oracle patched it on November 17, 2026. If you're running Java 17, 21, 25 or 27 on a server built in the last three years, you need to read this today, not next sprint.
Modern OpenJDK doesn't decode Base64 the slow, pure-Java way on fast CPUs. It uses a hand-written AVX-512 assembly routine ("intrinsic") that processes 64 bytes at a time for speed. That routine has a final-fragment handler that takes the leftover bytes at the end of an input, divides the length by four, drops the remainder, and multiplies by three to figure out how many output bytes to write.
Feed it a single padding character in the wrong spot and that math produces -1. Instead of writing zero bytes, the masked store instruction writes across a full 64-bit lane, overrunning the destination buffer by up to 62 bytes and corrupting whatever heap memory sits next to it. Researchers at Calif (the same team behind php2shell) found it, and by their own account they used AI tooling to help narrow down the exact trigger input in about an hour. That's a detail worth sitting with regardless of how you feel about AI-assisted security research: the bug itself is real and it's in shipped code.
Depending on what's sitting in adjacent heap memory, that overwrite can leak secrets (think Heartbleed-style information disclosure) or, with enough work tailored to the specific app and JVM build, lead to remote code execution.
Here's the version matrix, pulled from Oracle's advisory and corroborated by Qualys and Datadog:
| Release | Vulnerable range | Fixed in |
|---|---|---|
| Java 17 | 17.0.6 – 17.0.21.0 | 17.0.21.1 |
| Java 21 | up to 21.0.13.0 | 21.0.13.1 |
| Java 25 | up to 25.0.5.0 | 25.0.5.1 |
| Java 27 | up to 27.0.1.0 | 27.0.1.1 |
| Java 8 / 11 | not affected (standard builds) | N/A |
Standard Java 8 and 11 never shipped this particular AVX-512 intrinsic, so they're off the hook. The one exception is Oracle's paid Java 8 Enterprise Performance Pack, which backports the fast-path decoder and got its own fix in 8u513-perf. If you're on plain OpenJDK 8 or 11, relax on this one. But go check your 17/21/25/27 fleet right now.
This isn't just an Oracle JDK problem either. Amazon Corretto, Eclipse Temurin, Azul Zulu, BellSoft Liberica, Microsoft's OpenJDK build, SAP SapMachine and Red Hat's OpenJDK all inherited the same intrinsic from upstream OpenJDK, so they all need the equivalent patched build from their own vendor.
This is the part everyone skips and shouldn't. The vulnerable code path only runs on x86-64 processors with AVX-512 VBMI support: think Intel Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids Xeons, or AMD EPYC Zen 4 and newer. On Linux, check with:
grep -om1 -E 'avx512vbmi' /proc/cpuinfo
No output means that CPU can't trigger the bug. ARM64 is unaffected entirely: Graviton instances, Apple Silicon build servers, Ampere boxes, all of it. If your whole fleet runs on Graviton, you can deprioritize this one, though I'd still patch on your normal cadence.
CPU support alone isn't enough. The app also has to hand attacker-controlled bytes to Base64.getDecoder() or Base64.getUrlDecoder() (the MIME decoder isn't affected, interestingly). The reason this is scored as pre-auth is mundane and a little depressing: servers decode Base64 constantly before they check who you are. HTTP Basic auth headers, SAML assertions, JWTs, multipart form boundaries, OAuth state params: all Base64, all parsed before login succeeds.
Qualys and Datadog both call out specific products where this lines up badly:
To check a running JVM without restarting it:
jcmd <PID> VM.version
jcmd <PID> VM.flags -all | grep BASE64
If VM.version reports a build older than the fixed numbers above, and UseBASE64Intrinsics isn't explicitly disabled, treat that process as exposed.
Two options, and you should do both in the order that fits your change window:
-XX:-UseBASE64Intrinsics to your JVM startup flags. This forces Java back to the plain, non-vectorized decoder (slower, but safe). The alternative flag -XX:UseAVX=2 also works on x86-64, but do not push that flag fleet-wide if any of your nodes are ARM64. It'll stop the JVM from starting there.If you're triaging a pile of CVEs this week, this isn't the only one: we covered the kernel side of this exact "find it, flag it, patch it" workflow in our Ubuntu kernel CVE patch walkthrough, and the naming convention here (Java4Shell) is the same branding Calif used on the Brotli bug we wrote up a few months back in http2shell. Worth bookmarking that post if you want to see how these "write once, RCE everywhere" disclosures tend to play out after the initial panic.
As of November 17, 2026, no. It's not in CISA's Known Exploited Vulnerabilities catalog, and the major vendors tracking it haven't seen in-the-wild attacks. Calif published a reproducer that proves the memory corruption (64 "A" characters followed by a padding character), but that's a crash-and-corrupt demo, not a working remote shell. They've said they're holding back the application-specific exploit chains against Jira, Confluence and Keycloak for now.
The Hacker News thread on this is worth your time if you want the skeptic's take. The consensus there: mass, drive-by exploitation is unlikely because turning this into working RCE takes real per-application engineering, not a copy-pasted payload. But a slow trickle of unpatched, internet-facing identity and CI/CD boxes getting popped over the next six months is entirely plausible. That's basically every "critical" memory-corruption bug ever: loud week one, quiet exploitation for the rest of the year.
I don't think this is Log4Shell. Log4Shell needed nothing more than a user agent string and a vulnerable logger. Java4Shell needs a specific CPU generation, a specific Java version, and an app that happens to feed attacker bytes into the right decoder before auth. That's a meaningfully narrower blast radius, and the CVSS scores reflect the disagreement: Oracle rates it 8.1 under CVSS 3.1, Calif rates it 9.2 under 4.0, and both numbers are defensible depending on how much weight you put on attack complexity.
That said, "narrower than Log4Shell" still includes Keycloak and Jenkins sitting on the internet with a Sapphire Rapids CPU underneath, which is not a rare setup in 2026. Patch the identity providers and CI/CD systems first, flip the mitigation flag everywhere else today, and do the full JDK upgrade on your normal schedule. Don't let the "write once, RCE everywhere" tagline talk you into either panic or complacency. Do the boring version-check work instead.
One more thing: the fact that this lived in hand-written AVX-512 assembly for years is the real lesson here, not the CVE number. Hot paths that bypass the JIT and the type system are exactly where this class of bug hides, and this won't be the last one found in OpenJDK's intrinsics. If your org has leaned on LiteLLM or other fast-moving dependencies lately, it's also worth a reminder of how quickly these things turn into "rotate everything" incidents: see our notes on the LiteLLM backdoor from earlier this year for what that scramble actually looks like.
New AI tools, automation workflows, and course drops — straight to your inbox. Join 2,400+ builders.
MAI Code 2 claims 96% of Claude Opus 5.5's coding performance at 5% of the price in GitHub Copilot. We checked the benchmarks, the promo pricing, and real-world reports.
GPT-6.2 Astra ($8/$40 per 1M tokens) and Sol ($2/$10) are live in ChatGPT, Codex, and GitHub Copilot. Here's the pricing, the backlash, and whether to switch from Opus 5.5.
A researcher found Windows 11 checks for claude.exe, codex.exe, cursor.exe and copilot.exe and reports which ones you run. Here's how to check and disable it.
Comments