On November 17, 2026, researchers at Calif disclosed Java4Shell (CVE-2026-114938), a memory corruption flaw in OpenJDK. Oracle and the OpenJDK project released fixes the same day. Calif reports code execution without authentication in default installations of Keycloak, Jira, Confluence, Artifactory, Jenkins, and PingFederate.
Oracle rates the flaw 8.1 under CVSS 3.1, citing high attack complexity. Calif rates it 9.2 under CVSS 4.0. If you run Java behind Azion, you can narrow that exposure while the patch rolls out.
What is Java4Shell?
Java4Shell is a bug in the Java runtime itself. To decode Base64 faster, OpenJDK uses a hand-written routine built on AVX-512 processor instructions. A short malformed input makes that routine write 62 bytes past the end of a buffer before Java rejects the input.
The trigger Calif published is 64 A characters followed by a single =. Older OpenJDK 17 builds need 128 A characters before the =.
Any Base64 value the application decodes can carry the input. Help Net Security lists HTTP Basic credentials, SAML artifacts, CSRF tokens, and MIME encoded words as examples. An application with no bug of its own is exposed as soon as it decodes a value the attacker controls.
An attacker pays a different price for each outcome:
- Crash. Crashing an affected JVM is easy, and repeated requests can keep a service down.
- Code execution. This requires heap grooming and a separate memory leak. Calif says each product needs its own exploit chain and that there is no universal payload.
Calif also describes reading heap memory before any code runs, which can expose keys and tokens.
Who is affected by Java4Shell?
Two conditions must both be true: an unpatched runtime and a specific processor feature.
Runtime. The OpenJDK advisory covers the 17, 21, 25, and 27 release lines, and Calif places the start at 17.0.6. Oracle also lists its Java SE 8 Enterprise Performance Pack. The condition applies to OpenJDK builds from any vendor, including Amazon Corretto, Eclipse Temurin, Azul Zulu, Microsoft Build of OpenJDK, BellSoft Liberica, SAP SapMachine, and Red Hat OpenJDK.
Processor. The vulnerable routine only runs on x86-64 processors with AVX-512 VBMI. That includes Intel Xeon from Ice Lake onward and AMD Zen 4 or newer. ARM64 servers are not affected.
On Linux, this check from Qualys prints the relevant flags. The host meets the hardware condition only when all four appear:
Use the result to set priorities and keep the finding open. Workloads move between hosts, and a container scheduled on a different machine tomorrow can land on affected hardware.
Has Java4Shell been exploited?
As of November 18, there was no confirmed successful exploitation, and the flaw was not in the CISA Known Exploited Vulnerabilities catalog. Tenable reports that GreyNoise had already observed exploitation attempts and scanning for affected Java versions.
The root cause and the trigger are public. According to Qualys, the researchers say they built their first working exploit about two hours after finding the bug. Expect targeted exploits to follow.
What to patch first
Every advisory gives the same first instruction: update the Java runtime. These are Oracle’s fixed builds:
| Release line | Fixed build |
|---|---|
| Java SE 8 Enterprise Performance Pack | 8u513-perf |
| 17 | 17.0.21.1 |
| 21 | 21.0.13.1 |
| 25 | 25.0.5.1 |
| 27 | 27.0.1.1 |
Other vendors publish on their own schedule, and their build numbers can differ. As of November 18, Tenable reported fixes from Amazon Corretto and Azul Zulu, with Eclipse Temurin in progress. Red Hat and Ubuntu had not shipped fixes yet.
Before you count a host as patched, check three things:
- Find every runtime. Containers, appliances, and packaged applications often bundle their own JDK, which an operating system update doesn’t touch.
- Restart the service. Upgrading a package doesn’t replace a JVM that is already running.
- Check the running version. Cloudflare’s guidance suggests confirming it on the process itself, for example with
jcmd <pid> VM.version.
Qualys recommends starting with internet-facing identity providers, then internet-facing Jira, Confluence, Jenkins, and Artifactory. Other public Java services that handle logins, tokens, or uploads come next, followed by internal systems such as Kafka, Solr, and Elasticsearch.
If you can’t patch today
Calif identified a JVM flag that turns off the accelerated Base64 routine. Java then falls back to its standard decoder:
The flag requires a JVM restart and can slow applications that decode large volumes of Base64. Neither Oracle nor the OpenJDK advisory mentions it, so check your vendor’s guidance. Keycloak recommends it as an interim mitigation, and Cloudflare reports applying an equivalent startup option to its own Java workloads.
Calif lists a second flag, -XX:UseAVX=2, which disables AVX-512 at a larger performance cost. Use it only on x86-64 hosts. Java on ARM fails to start with it.
What WAF rules can and can’t do for Java4Shell
Vendors shipped rules within a day, and most of them log by default. The table shows what each announcement says:
| Vendor | What shipped | Default action |
|---|---|---|
| AWS WAF | Three Java4Shell_* rules in the Known bad inputs rule group, version 1.28 | Count. You override the action to Block. |
| Cloudflare | Six malformed Base64 rules in the Cloudflare Managed Ruleset | Log |
| Azure WAF | Custom rule definitions for Front Door and Application Gateway | Block, after you create the rules |
| Akamai | Adaptive Security Engine rule 3000992 | Not stated in the announcement |
Vendors log first because legitimate traffic is full of Base64: session cookies, JWTs, file uploads, API payloads. Watch a rule on real traffic before you let it block.
Microsoft writes that “these mitigations are intended to complement patching, not replace it.” Cloudflare calls its rules a compensating control. Qualys adds that input-size limits alone won’t stop this bug, because the malformed input is only 65 characters long.
A filter in front of the application reduces who can reach the vulnerable service and rejects the known shape of the trigger. The decoder stays broken until you patch it.
How Azion reduces Java4Shell exposure
The same limit applies to Azion: no control in front of the origin fixes a memory flaw inside the JVM. While you patch, Azion narrows access to the application and filters the known trigger format.
Restrict who reaches Java applications
Few identity, build, and collaboration consoles need to be open to the whole internet. In your firewall, a Rules Engine rule combined with Network Lists limits those paths to known addresses, such as your VPN and office ranges. A blocked request never reaches the origin.
This control works whatever the payload looks like.
Filter the trigger format with a function
We built a function for Firewall that inspects the path, query string, cookies, headers, and body of each request. It blocks long Base64 values with invalid padding, which is the shape of the published trigger. It runs on Functions. You instantiate it in your firewall and call it from a Rules Engine rule.
In a staging test on the Azion Platform, the function blocked 19 of 19 variations of the public trigger and allowed 9 of 9 legitimate requests. The test used the public trigger with no vulnerable JVM at the origin. The result shows that the function recognizes the format. We have not tested it against a real exploit.
Review detections before blocking
Real-Time Events records each detection with the part of the request where the function found the pattern. Start in log-only mode, review the events, and handle false positives before you turn on blocking.
What the mitigation doesn’t cover
The function doesn’t inspect:
- compressed request bodies;
- bodies larger than 8 MiB;
- Base64 nested inside another encoding;
- traffic that reaches the origin without passing through Azion.
If the origin accepts direct connections, an attacker who finds its address bypasses every rule described here. Restrict the origin to accept traffic only from Azion.
What Azion customers should do now
- Update Java to your vendor’s fixed build and restart the services.
- If the patch has to wait, start the JVM with
-XX:-UseBASE64Intrinsicsafter checking your vendor’s guidance. - In Azion Console, add a Rules Engine rule to your firewall that restricts access to administrative Java applications.
- Instantiate the mitigation function in your firewall in log-only mode.
- Review the events in Real-Time Events, handle false positives, and then turn on blocking.
- Watch for unexpected JVM crashes or restarts on internet-facing Java services. Qualys lists them as an indicator to monitor.
Patch first, filter while you wait
The fix for Java4Shell is a patched runtime. Patch the origin first, and use the layer in front of it to buy time and visibility. Our security team is tracking the flaw and will update this post as new information is published.
Need help applying these measures? Talk to a specialist.
