On November 18, 2026, Microsoft’s Azure Network Security Blog published upgrade guidance and Azure WAF mitigations for Java4Shell CVE-2026-114938, a memory-corruption flaw in OpenJDK’s Base64 decoder. The short answer is to patch the Java runtime first. Use Azure Front Door WAF custom rules only to cover the gap until that patch lands.
What Happened: Java4Shell CVE-2026-114938 explained
Researchers at Calif disclosed Java4Shell on November 17, 2026. A short, crafted Base64 string can corrupt memory in the hardware-accelerated decoder, which can crash the JVM.
CISA and Red Hat describe the flaw as capable of unauthenticated remote code execution. AWS’s advisory notes that actual exploitability depends on how the application exposes the decoder, and some deployments may require authentication.
The vulnerable path needs three things:
- Runtime: The flaw entered OpenJDK’s Base64 decoder around version 17.0.6, so builds derived from that baseline, including Oracle Java SE, Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu and Red Hat OpenJDK, can be affected. Each vendor has since shipped fixed builds, and some fixed version numbers still fall within the 17.x-and-later range, so don’t assume every build at or above 17.0.6 is vulnerable. Confirm exposure by matching the exact installed build against that vendor’s fixed-release list rather than the version floor alone. EU-CERT’s advisory also lists two older backport branches, Java SE 8u511-perf and 11.0.33, as affected, so check those branches too before assuming an 8 or 11 deployment is out of scope.
- CPU: x86-64 processors with AVX-512 VBMI. That means Intel Ice Lake-generation Xeons and newer, or AMD Zen 4 and newer. That CPU feature is the actual requirement; ARM64 processors, which don’t implement AVX-512 VBMI, fall outside the confirmed scope.
- Input: Attacker-controlled data has to actually reach the vulnerable Base64 decoder through how the application processes it. An affected runtime build on qualifying hardware establishes the capability for the bug to fire; it doesn’t by itself mean a given deployment is reachable, since that depends on what the app does with untrusted input.
BleepingComputer reports that the following apps run on Java versions inside the vulnerable range:
- Jira and Confluence
- Jenkins and Keycloak
- JFrog Artifactory and PingFederate
- Kafka, Solr and Elasticsearch
- Gerrit and Spinnaker
Patch the internet-facing, pre-authentication cases first, Jira, Confluence, Jenkins, Keycloak and PingFederate are commonly cited in that group. Internal services that only accept the payload after login rank lower, though actual exploitability still depends on how each app uses the decoder.
Severity scoring varies by source. Calif rates the flaw 9.2 under CVSS 4.0, while Oracle’s advisory publishes its own severity rating under CVSS 3.1, check Oracle’s bulletin directly for the current figure.
Oracle’s November 2026 Critical Patch Update ships these fixed builds:
- 17.0.21.1
- 21.0.13.1
- 25.0.5.1
- 27.0.1.1
For Microsoft, Temurin, Corretto, Zulu and Red Hat builds, check each vendor’s own advisory for the fixed version.
Calif and BleepingComputer also say researcher Quang Luong found the bug with OpenAI Codex in about three hours, for under $200.
As of the November 17-18 reports, there was no confirmed in-the-wild exploitation. CISA’s alert urges immediate patching regardless, given the severity and breadth of affected runtimes.
How It Stacks Up: patch vs. WAF vs. JVM flags
Microsoft’s blog calls updating the runtime the primary fix. It describes Azure WAF custom rules on Azure Front Door as supplementary defense-in-depth. Those rules inspect Base64-like values in four places:
- request headers
- request bodies
- query strings
- the
Authorizationheader
Microsoft says to apply only the rule categories that match what each app actually accepts. CISA’s alert takes the same patch-first line. It also flags the biggest blind spot: bundled JDKs inside containers, appliances and vendor installers that “may not appear as separate entries” in inventories.
CISA’s recommended actions go beyond patch-first messaging alone: inventory bundled JDKs in containers, appliances and vendor installers; apply each vendor’s patch; restrict and validate Base64 input where patching has to wait; enforce input-size limits; limit unauthenticated access to exposed services; and monitor for suspicious activity.
| Option | What it covers | Source framing | Trade-off |
|---|---|---|---|
| Patch runtime and restart | Removes the bug | Primary fix (Microsoft, CISA) | Needs a restart or container rebuild. Bundled JDKs need separate patching. |
| Azure Front Door WAF custom rules | Traffic routed through Front Door | Interim only (Microsoft) | Legitimate tokens, uploads and API bodies carry Base64 too, so false positives are likely. No protection for internal traffic. |
-XX:-UseBASE64Intrinsics | Said to turn off the vulnerable decoder path | Temporary (Calif, BleepingComputer) | Applies per JVM. Easy to forget it’s set. |
-XX:UseAVX=2 | Reported to turn off AVX-512 entirely | Temporary alternative (Calif), x86-64 JVMs only | Every workload in that JVM loses AVX-512. Passing it to an ARM64 JVM can keep the JVM from recognizing the option and failing to start; prefer -XX:-UseBASE64Intrinsics where supported. |
For container hosts, Docker and Podman face the same basic constraint: a bundled JDK baked into an image needs a rebuilt image, and a system-wide Java update on the host won’t touch it. Exactly how each tool handles image layers, volumes and any host-mounted JDKs can still differ, so confirm your specific setup rather than assuming identical behavior across both.
Windows: find every java.exe
A system-wide Java update won’t touch bundled runtimes. Search the whole drive instead. This PowerShell syntax is intended for Windows PowerShell 5.1 and PowerShell 7.x on Windows Server.
# -Recurse walks all subfolders; SilentlyContinue hides access-denied noise
Get-ChildItem -Path C:\ -Filter java.exe -Recurse -ErrorAction SilentlyContinue | Select-Object FullName
Then check each hit’s version:
& "C:\Program Files\Java\jdk-17\bin\java.exe" -version
Compare the version string against that build’s vendor advisory and fixed-release list rather than against the 17.0.6 floor alone. A build reporting 17.0.21 or later from Oracle may already be patched, while a same-looking version from another vendor might not be. Treat a runtime as in scope only when it predates that vendor’s fixed build and the host CPU supports AVX-512 VBMI.
Calif and BleepingComputer describe -XX:-UseBASE64Intrinsics as a temporary mitigation that disables the vulnerable decoder path. If you can’t patch tonight, add the flag at JVM startup and restart the service:
java -XX:-UseBASE64Intrinsics -jar C:\apps\your-app.jar
Linux homelabbers can get a preliminary read on CPU exposure with grep -o -w avx512vbmi /proc/cpuinfo. No output rules out AVX-512 VBMI on that host’s /proc/cpuinfo representation, but it doesn’t by itself confirm the vulnerable path is unreachable.
Virtualized guests, heterogeneous CPU pools, and non-Linux hosts can report differently, and the check says nothing about whether an application actually routes untrusted input through the Base64 decoder. Treat it as one preliminary signal, then confirm the installed JVM’s build version against the vendor’s fixed-release list and, where available, check the JVM’s own reported CPU capabilities or the vendor’s guidance.
Jenkins on a Raspberry Pi 5 or another ARM64 board is outside the reported scope. A Ryzen 7000-series mini PC (Zen 4) generally supports AVX-512 VBMI, but run the grep check above to confirm rather than relying on the processor family name alone. Don’t pass -XX:UseAVX=2 to a JVM on ARM64 hardware either; it’s an x86-64-specific flag and can keep the JVM from starting.
Web: Azure Front Door WAF
Microsoft’s blog has the rule logic, so work from the post itself. Scope the rules to the request locations each app uses. Watch the WAF logs for blocked legitimate traffic before you trust them.
The Reaction
Discussion is still forming. Coverage so far comes mostly from security outlets: SecurityWeek, CyberScoop and heise. All of them echo the patch-first message.
Our Take
Verdict: Adopt the patch now. Pilot WAF rules only where Front Door already fronts a Java app you can’t restart this week.
For an IT shop, the cost is mostly inventory time, not licensing. The runtime updates are free. The work is finding every bundled JDK, rebuilding images and scheduling restarts.
WAF rules carry an ongoing cost too. Someone has to tune false positives on Base64-heavy traffic. That’s why we’d keep them short-lived.
Wrapping Up
Runtime version and CPU AVX-512 VBMI support are the two starting checks for exposure, but they’re not the whole picture. Exact patched build, JVM vendor, and whether the application actually routes untrusted input through the Base64 decoder all affect real-world risk.
Patch the internet-facing, pre-authentication apps first. The real risk often sits in the JDK hiding inside a vendor appliance, not the one you already know about.
Once you’ve patched, remove -XX:-UseBASE64Intrinsics or -XX:UseAVX=2 from your startup scripts. If -XX:UseAVX=2 was used, confirm it was only applied to x86-64 JVMs, since the flag doesn’t apply to ARM64 and can keep those JVMs from starting. Re-run the java.exe sweep as a scheduled task so new bundled runtimes don’t slip back in unnoticed.