News / Security / Java4Shell: the Java vulnerability AI found…
Security · Vulnerability

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.

opnF.shNov 18, 20267 min readjava4shelljava vulnerabilitycve-2026-114938
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.
New to this?Ping explains the hardest part in plain words.
CVE-2026-114938
"Java4Shell" · OpenJDK and Oracle Java (HotSpot Base64 decoder)
HIGH8.1
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
Ping explainsNo experience needed.
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:

SystemStatus
Standard Java 8 and 11Not affected
Java 17.0.0 to 17.0.5Not affected
Java 17.0.6 and later, before 17.0.21.1Affected
Java 21 before 21.0.13.1Affected
Java 25 before 25.0.5.1Affected
Java 27 before 27.0.1.1Affected
Oracle Java 8 Performance Pack 8u511b33-perfAffected, 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:

is this server in scope?
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:

ask a running app its build
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:

  1. 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.
  2. Restart, then check the running processA patched package changes nothing until the app restarts. Run jcmd <pid> VM.version again afterward to confirm the new build is the one running.
  3. Can't patch yet? Switch off the fast decoderAdd -XX:-UseBASE64Intrinsics to 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:

confirm the stopgap is on
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.

i
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?
Not successfully, as far as anyone knows, but attackers are already looking. Precursor Security reports GreyNoise logged 53 Java4Shell-shaped requests from 3 IP addresses by the morning of November 18 with no confirmed compromise, and the flaw isn't on CISA's Known Exploited Vulnerabilities list yet.
Is Java4Shell as bad as Log4Shell?
No, despite the name. Log4Shell worked with one crafted string on almost any vulnerable app; Java4Shell needs specific hardware, and each app needs its own exploit chain, which Calif hasn't released.
Does a firewall or reverse proxy stop Java4Shell?
Not reliably. The attack rides inside ordinary requests to a port you already expose, and Qualys says a reverse proxy only sometimes breaks the exploit by buffering requests, so patch or set the flag rather than counting on it.

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.