LEFTEROS / PERSONAL NOTES
Java4Shell: one Base64 bug in Java, and why your Jira, Jenkins or Keycloak may need a Java update today
18 November 2026 / Lefteris Iliadis / SomniusX

A month after PHP2Shell, the same team is back with Java. On 17 November Calif disclosed Java4Shell, CVE-2026-114938: a memory bug in the part of Java that decodes Base64, the text encoding used everywhere for logins, tokens, keys and attachments. Oracle released patches and the OpenJDK project published its advisory the same day.
If your company runs Jira, Confluence, Jenkins, Keycloak, Artifactory, Elasticsearch or almost anything else built on Java, on a recent Intel or AMD server, this one is about you.

Why this one is different
Java is supposed to be safe from this kind of bug. You can't write past the end of an array in Java code. But to be fast, Java has hand-written machine code for some common jobs, and Base64 decoding on newer CPUs is one of them. That's where the bug is.
- It's in Java itself, not in one application. Every program running on an affected Java build inherits it.
- Base64 is everywhere. A login header, a token, a certificate, an uploaded file: if a Java program decodes it from the outside, the bug is reachable. Calif says that in default configurations it reached remote code execution with no login on Keycloak, Jira, Confluence, JFrog Artifactory, Jenkins and PingFederate, and after login on Kafka, Solr, Elasticsearch, Gerrit and Spinnaker. They say the list isn't complete.
- It also leaks memory. Besides writing, the same bug can be used to read memory the way Heartbleed did, which can expose keys, tokens and personal data.
- Clients too. A Java program that only connects out to a malicious TLS server can be attacked, even if it exposes nothing.
- Only some hardware. It needs an x86-64 CPU with AVX-512 VBMI: Intel Xeon from Ice Lake on (Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids) and AMD EPYC and Ryzen from Zen 4 on. That's most new servers and a lot of the cloud. ARM64 isn't affected.

Is anyone actually attacking?
Not that anyone has reported, as of 17-18 November. Here's where things stand:
- No attacks seen in the wild so far, say Tenable, Cisco Talos (via SecurityWeek), Endor Labs and watchTowr. It isn't in CISA's list of known exploited vulnerabilities according to Tenable, watchTowr and Endor. I didn't check the CISA list myself on the day.
- Calif's public code only proves the bug, it doesn't take control of anything. Calif is holding back its exploits for each product "until everyone has had a chance to upgrade".
- Others say they have working exploits and haven't published them: VulnCheck and Kevin Breen of Immersive say so, and Wiz built a proof of concept in about two hours and says remote exploitation is feasible against Jenkins, Confluence and Tomcat. Endor Labs reproduced crashes and calls the code execution claims not independently verified; Upwind reproduced memory corruption and crashes and didn't test code execution.
- It isn't easy. Each target needs its own tuning, and Calif rented a server in the same cloud region as its target to get the timing right. VulnCheck doesn't expect it to be "easily or widely exploitable".
So: not an internet-wide fire yet, but a real bug with private exploits already out there. With PHP2Shell, attempts started within hours. I'd patch this week, internet-facing servers first.
Which versions are affected, and which are fixed
The sources don't fully agree on the details yet, so here's what each one says.
- Affected, per Calif: OpenJDK 17.0.6 and newer (Endor and the OpenJDK advisory name the 21, 25 and 27 lines too), and every build made from it: Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat, Oracle OpenJDK, Oracle Java SE and GraalVM for JDK.
- Not affected, per Endor Labs: 17.0.0 to 17.0.5, Java 8 and Java 11. Upwind tested 11.0.33 and 17.0.5 and found them clean. One exception: Oracle lists its Java 8 Enterprise Performance Pack (8u511b33-perf) as affected.
- Fixed by Oracle, per Tenable: 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1 and 8u513-perf. Endor Labs said on the 17th that the 25 and 27 builds weren't out yet, so check Oracle's page.
- OpenJDK: the fix is in 27.0.1.1 (per Endor). On the 17th the public 17, 21 and 25 update repositories didn't have it yet (Endor Labs, as SecurityWeek also reported).
- Everyone else (Corretto, Temurin, Zulu, Red Hat, your Linux distribution, your Docker base image) ships its own fixed build on its own schedule. Check their security notices today.
- Severity: Calif rates it 9.2 of 10 (CVSS 4.0); Oracle rates it 8.1 (CVSS 3.1, "high" attack complexity). Different scales, same advice.

The five-minute check

- Does the CPU have it? On the server (or inside the VM or container, which see the host CPU), run:
If all four names print, the CPU can trigger the bug. Your laptop may not have it while your cloud server does, so run it where the Java app runs.grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$' - Which Java is actually running?
java -versionshows the one on your path, which isn't always the one the app uses. For a running app:jcmd <pid> VM.version. Products like Jira, Confluence and Jenkins often bring their own Java, so check their folders too. - Update to your vendor's fixed build. For Linux packages, check your distribution's security notice, because the version number may not change the way you expect.
- Restart every Java process after the update. A running JVM keeps the old code until it restarts.
- If you have a vendor or an agency, send them one line: "Are our Java servers on a build fixed for Java4Shell, CVE-2026-114938?" If they can't answer today, that's your answer.
If you can't update today
Calif, Wiz, Upwind and Endor all point to the same switch: start Java with
-XX:-UseBASE64Intrinsics
It turns off the fast hand-written Base64 code and uses the normal Java code, which doesn't have the bug. It costs some speed in Base64-heavy work. You can confirm it took effect with java -XX:+PrintFlagsFinal -version | grep UseBASE64Intrinsics, using the same options the app starts with.
The other option, -XX:UseAVX=2, turns off AVX-512 entirely. It's for x86-64 only: Java on ARM won't start with it, so don't push it to every machine blindly.
A proxy in front doesn't fix it. nginx's request buffering breaks some of Calif's attack chains, but Calif says plainly it isn't a mitigation, and it doesn't help against WebSockets or single-request attacks like the Elasticsearch one.
The poster
Calif's disclosures come with artwork, and this one made me laugh.

What's still open
- Whether the code execution claims hold up outside the labs that made them. Only Calif and a few companies say they have it working, and none has published it.
- The exact affected and fixed versions per vendor. They are still settling.
- Whether attacks start. I'll update this post if CISA or the vendors report any.
Calif also says the bug took about an hour to find with AI tools, and two more hours for a first working exploit. If that's the pace now, the time between "a fix exists" and "someone uses the bug" is only going to get shorter. Update early.
Sources: Calif, OpenJDK advisory, Oracle security alerts, Tenable FAQ, Wiz, Endor Labs, Upwind, watchTowr, SecurityWeek.