Java4Shell: the Java vulnerability AI found in an hour
The Java4Shell vulnerability (CVE-2026-114938) lets attackers take over Jira and Jenkins servers without a login. Who's exposed and how to check yours.

On this page 4 sections ▾
WHAT TO DO
- Patched Java builds came out November 17, but apps that ship their own Java, like self-managed Jira and Confluence, don't get the fix from OS updates.
- Probing has started, though no successful attack is confirmed and the app-specific exploits are held back. Patch this week, and today for internet-facing Jira, Confluence, Jenkins or Keycloak on newer Intel and AMD hardware.
- Affected
- Java 17.0.6 and later, 21, 25 and 27, on x86-64 CPUs with AVX-512 VBMI
- Fixed in
- 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1
- Disclosed
- Nov 17, 2026
- Exploited
- No confirmed exploitation
- Workaround
- Start the JVM with -XX:-UseBASE64Intrinsics
A researcher at the security firm Calif found the Java4Shell vulnerability with AI help in about an hour, had a working exploit two hours later, and spent under $200 on AI tokens doing it. The bug lets an attacker take over Jira, Confluence, Jenkins and Keycloak servers without logging in, which sounds like the whole internet is on fire. It isn't, and a couple of quick checks will tell you whether yours is one that should worry.
Quick facts
Older is safer this time: standard Java 8 and 11 aren't affected, because the buggy code only exists from Java 17.0.6 on.
ARM servers, AWS Graviton included, never run the vulnerable code, so the same app on ARM is out of reach.
It works in reverse too: a Java program can be compromised just by connecting over TLS to a server an attacker controls.
#How a Base64 bug becomes a takeover
Base64 is everywhere in web apps: login tokens, auth headers and uploads often pass through it. On x86-64 chips that support AVX-512 VBMI, Java swaps its normal Base64 decoder for a hand-written fast version. Feed that fast version a short, malformed string and it writes 62 bytes past the end of its buffer before Java notices the input is bad and rejects it. By then the memory next door is already overwritten, and that corruption is what Calif steered into running its own code. On a CPU without AVX-512 VBMI, the fast path never runs at all.
ELI5: explain it simply▾

THE WORDS
- Base64
- A way to write any data using only letters, numbers and a couple of symbols, so it can travel inside text.
- Buffer
- A fixed-size chunk of memory set aside to hold data while a program works on it.
- AVX-512 VBMI
- A set of extra instructions in newer Intel and AMD chips that let software crunch bytes much faster.
THE IDEA
Imagine a fast mail sorter that drops letters into a row of slots. Hand it one oddly folded envelope and it jams letters into the next desk's slots before it realizes the envelope was bad. If you know exactly how it jams, you can choose what lands on the neighbor's desk.
Calif then built working attacks against 11 popular Java apps, and the split that matters is whether the attacker needs an account first:
- No login neededKeycloak, Jira, Confluence, JFrog Artifactory, Jenkins and PingFederate, all in their default configurations.
- Login needed firstCalif got code execution in Apache Kafka, Apache Solr, Elasticsearch, Gerrit and Spinnaker once it had an account.
#Easy to crash, hard to take over
Knocking a vulnerable app over is simple. Cyble reports that Blackpoint Cyber crashed a test Spring Boot app with about 28,300 malformed login requests in roughly 20 seconds, and Upwind crashed Java on an Intel Ice Lake server on AWS. Neither got code execution. That part takes a separate chain for each product, and Calif is holding its chains back until people have had time to patch.
That's also why the severity scores disagree. Calif rates it 9.2 (CVSS 4.0) because it took over six apps without a login. Oracle and OpenJDK rate it 8.1 (CVSS 3.1) because, outside a lab, pulling that off is hard. Both are describing the same bug: a crash anyone can trigger, and a takeover only a skilled attacker can build today.
#Is your Java server affected by Java4Shell?
Three things have to be true at once: an affected Java build, a CPU with AVX-512 VBMI, and a way for outside data to reach a Base64 decoder, which any web-facing Java app has. Here's how the Java versions break down:
| System | Status |
|---|---|
| Standard Java 8 and 11 | Not affected |
| Java 17.0.0 to 17.0.5 | Not affected |
| Java 17.0.6 and later, before 17.0.21.1 | Affected |
| Java 21 before 21.0.13.1 | Affected |
| Java 25 before 25.0.5.1 | Affected |
| Java 27 before 27.0.1.1 | Affected |
| Oracle Java 8 Performance Pack 8u511b33-perf | Affected, fixed in 8u513-perf |
Those fixed numbers are Oracle's and OpenJDK's, and the trailing .1 matters: a build with the same number minus the .1 is still vulnerable. Amazon Corretto shipped 17.0.21.1.2 on day one, and other vendors and the Linux distro packages are shipping on their own schedules, so check your vendor's advisory for the build that names CVE-2026-114938.
On Linux, start with the hardware and the system Java. This is our own test machine, an Intel Xeon VM:
student@opnf:~$ grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$' bmi2 avx512f avx512bw avx512vbmi # all four flags: the CPU runs the vulnerable fast path student@opnf:~$ java -version openjdk version "21.0.12.1" 2026-08-18 OpenJDK Runtime Environment (build 21.0.12.1+1-1-24.04.4-Ubuntu) OpenJDK 64-Bit Server VM (build 21.0.12.1+1-1-24.04.4-Ubuntu, mixed mode, sharing) # 21.0.12 is older than the fixed Java 21 build
Our box prints all four flags and runs an unpatched Java 21, so it's squarely in scope. If yours prints fewer than four, the CPU never runs the buggy code. Treat that as a reason to patch it later rather than never, though: resizing a cloud instance or moving it to different hardware can change the answer.
Check the Java your apps actually run
java -version only shows the system Java, and that's the trap. Self-managed Jira, Confluence and many other products ship their own runtime that OS updates never touch, and a container carries its own JDK that only changes when the image is rebuilt. jcmd lists every running Java process and asks each one which build it's on. Run it as the user the app runs as:
student@opnf:~$ jcmd -l 363 MyApp student@opnf:~$ jcmd 363 VM.version 363: OpenJDK 64-Bit Server VM version 21.0.12.1+1-1-24.04.4-Ubuntu JDK 21.0.12.1 # the build this process is running right now, bundled or not
On a Jira server, that version line is what matters, even if java -version already shows a patched build. jcmd only comes with a full JDK, so if the server has nothing but the product's bundled runtime, run the java inside the product's own install folder with -version instead. For containers, run it inside the container (docker exec <container> java -version).
If you're exposed
Patch first, and use the startup flag only to cover the gap until the patch is in:
- Patch the runtime, or the product that bundles itInstall your Java vendor's November 17 build. For products with their own Java, apply the product vendor's update, and rebuild container images on a patched base image.
- Restart, then check the running processA patched package changes nothing until the app restarts. Run
jcmd <pid> VM.versionagain afterward to confirm the new build is the one running. - Can't patch yet? Switch off the fast decoderAdd
-XX:-UseBASE64Intrinsicsto the app's JVM options and restart. Java falls back to its standard Base64 decoder, which apps that decode a lot of Base64 may notice as a slowdown. Take the flag back out once you've patched.
To confirm the flag took effect, ask the running process for its flags. No output means it isn't set:
student@opnf:~$ jcmd 470 VM.flags | tr ' ' '\n' | grep -i base64 -XX:-UseBASE64Intrinsics
No successful attack has been confirmed and there are no published signs of compromise yet. CISA's advice is to watch for unexpected JVM crashes or suspicious Java processes, since a crash is the one effect independent labs have reproduced. If you can't tell which Java an app is using, set the flag anyway: it only switches off one fast path.
Watch for fake exploits
Fake Java4Shell "PoC" repositories have already appeared, Cyber Kendra reports. Read any script before you run it against your own servers.
#Calif's second AI-found bug in a month
This is the same team behind one of last month's PHP2Shell flaws: Calif used OpenAI's GPT-5.6 Sol to find one of the two PHP bugs, while Wiz found both independently. For Java4Shell, Cyber Kendra reports Calif's researcher used OpenAI's Codex to audit Java's fast-path code, and it flagged the Base64 bug after about 20 minutes of prompting. Two language-level bugs in a month, both found with AI help, is a fair sign of what the next year of patching looks like.
Finding every Java process on a box, checking what it runs and restarting services cleanly is everyday server administration. If that kind of work is new, the Security Pro ProCourse teaches Linux server administration in a simulated terminal in your browser, and Level 1 is free.
Is Java4Shell being exploited?
Is Java4Shell as bad as Log4Shell?
Does a firewall or reverse proxy stop Java4Shell?
What this means for you
Find every Java process on your x86 servers, starting with internet-facing Jira, Confluence, Jenkins and Keycloak. Patch the runtime each one actually uses and restart it, and put -XX:-UseBASE64Intrinsics on anything you can't patch this week.
Get opnF in your inbox
Tech news for IT professionals that actually teaches you something.
Our promise to you: we'll be conscious about email quality/frequency, and your address will never be shared/sold.