NEWS

Java4Shell (CVE-2026-114938): RCE in OpenJDK's Base64 decoder

An out-of-bounds write in OpenJDK's AVX-512 Base64 intrinsic leads to pre-auth RCE in apps like Keycloak, Jira and Jenkins. Who is affected, how to check, and which Tenable plugins to scan with.

In one sentence

Java4Shell is a heap corruption flaw affecting Java 17, 21, 25 and 27 on modern Intel and AMD servers; until you patch, disable the Base64 intrinsic and scan with Tenable plugins 382091 and 382045.

Another name ending in "Shell" didn't surprise me last night; after Squidbleed and PHP2Shell, the same team, Calif, came out of Java this time. What surprised me was where the flaw lives. There's no library or framework bug here; the problem is in the JVM itself, in something as ordinary as decoding Base64, which almost every application does somewhere. So this time we don't get to say "we don't use Log4j, we're fine."

I wrote this to quickly explain what matters to the teams who will run the scans and everyone around me: what the flaw is, who is really at risk, how to check today, and which plugins to scan with.

What is Java4Shell?

CVE-2026-114938 is an out-of-bounds write in OpenJDK HotSpot's x86-64 Base64 intrinsic. The intrinsic kicks in when the C2 JIT compiler turns Base64 decoding into hot code, and it runs on AVX-512 VBMI instructions.

The bug shows up on inputs that end in padding (=). The code decrements the output length once more for the padding; the length drops to -1 or -2, the store mask becomes all ones, and the CPU writes all 64 bytes. In Calif's example, a 65-character input gets a 50-byte buffer and 62 bytes are written past its end. Java then rejects the input as invalid, but the neighbouring heap objects are already corrupted.

Calif says it took that corruption to two outcomes:

  • JavaBleed: Heartbleed-style reads from the heap, which can leak keys, tokens and sessions.
  • RCE: running code on the server through data-only attacks and the Code Cache.

Two scores are going around. Oracle gives it 8.1 under CVSS 3.1 and rates attack complexity as high; Calif gives it 9.2 (critical) under CVSS 4.0. I think both are saying the right thing: the exploit is application-specific and not easy, but when it works it's an RCE that needs no login.

Who is really at risk?

There's good news here: the flaw doesn't affect every Java install. Three conditions have to hold together:

  1. CPU: x86-64 with AVX-512 VBMI. On Intel Xeon that means Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids; on AMD, Zen 4 and newer. ARM64 is not affected.
  2. Java version: the OpenJDK 17, 21, 25 and 27 lines (17.0.6 and newer, per Calif). Standard Java 8 and 11 are not listed as affected in the OpenJDK advisory; Oracle's Java 8 Enterprise Performance Pack is.
  3. Application: attacker-controlled Base64 data has to reach this decoder. Very common flows such as authentication and file uploads are enough.

Based on Calif's testing in default configurations, the affected applications are:

Exploitable before login Exploitable after login
Keycloak, Jira, Confluence, Artifactory, Jenkins, PingFederate Kafka Broker, Solr, Elasticsearch, Gerrit, Spinnaker

The list isn't exhaustive, and Calif presents it that way. There's also a client-side variant shared by samczsun: a Java program that connects over TLS to an attacker-controlled server can be a target too. So looking only at internet-facing servers isn't enough.

Which versions do you need?

Oracle released patches on November 17:

Java line Fixed build
Java 8 Enterprise Performance Pack 8u513-perf
Java 17 17.0.21.1
Java 21 21.0.13.1
Java 25 25.0.5.1
Java 27 27.0.1.1

Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine and Red Hat OpenJDK are also among the affected distributions. Each vendor ships fixes on its own schedule, so check the advisory for the distribution you run. Don't forget JREs bundled inside applications (the Java that products like Jira, Jenkins or Elasticsearch ship with); updating the system Java doesn't update them.

How to check today

First, check whether the CPU is actually the affected kind. On Linux, if all four flags show up, the server is in the risk group:

Bash
grep -o -w -E 'avx512f|avx512bw|avx512vbmi|bmi2' /proc/cpuinfo | sort -u

Then list every Java install and its version on the machine. Searching for java binaries is safer, because it also catches bundled JREs:

Bash
find / -type f -name java -path '*/bin/*' 2>/dev/null | while read j; do echo "$j"; "$j" -version 2>&1 | head -1; done

Calif also published a test program that only triggers the flaw and stays inside memory bounds. It shows whether a given Java version and CPU combination is affected, not whether your application is exploitable. I'd run it on a test machine with the same hardware and JDK, not in production.

Scanning with Tenable

The first question scanning teams ask is "which plugin should we scan with?" As of November 18, Tenable has two published plugins:

Plugin ID Name Type
382091 Oracle Java SE Oracle CSPU Nov 2026 (Java4Shell) Nessus, Local, High
382045 Amazon Corretto Java 17.x < 17.0.21.1.2 Multiple Vulnerabilities Nessus, Local, Critical

Five Amazon Linux advisories (ALAS2-2026-4123, ALAS2023-2026-3478, 3479, 3480 and 3481) show up in the pipeline as "Coming Soon"; they'll be listed on the same CVE page as they are released.

A few practical notes:

  • Both plugins are local checks. An uncredentialed network scan can't see the Java version, so run authenticated scans (SSH or Windows credentials) or use Nessus Agents.
  • Update the plugin feed before scanning; new vendor plugins will be added over the next few days.
  • If you use Tenable One, Explore > Software with a Java filter shows every install and version, and in Attack Surface Management the filter "Programming Languages contains Java" finds internet-facing Java assets.

Until the patch lands

For systems you can't update right away, Calif recommends two JVM flags (these are not in the Oracle or OpenJDK advisories):

Bash
# Disables the hardware-accelerated Base64 path
-XX:-UseBASE64Intrinsics

# Disables AVX-512 entirely (x86-64 only; the JVM won't start on ARM)
-XX:UseAVX=2

The first is narrower and, I think, the one to prefer. The second has a wider performance impact. Calif also notes that nginx request buffering is not a general protection against this flaw and doesn't apply at all after a WebSocket upgrade, so waiting behind a WAF is not a good plan.

What to do

  1. Build an inventory: every system running Java 17, 21, 25 or 27, including JREs bundled with applications.
  2. Prioritize those systems by CPUs with AVX-512 VBMI; put Keycloak, Jira, Confluence, Jenkins, Artifactory and PingFederate at the top.
  3. Run authenticated scans in Tenable with plugins 382091 and 382045, and keep the plugin feed up to date.
  4. Move to patched builds; check your distribution's advisory separately.
  5. Where you can't patch right away, disable the Base64 intrinsic with -XX:-UseBASE64Intrinsics.
  6. Watch Java applications for unexpected crashes and JVM error logs; failed exploit attempts often show up as crashes.

Sources: Calif: Java4Shell · Tenable: Java4Shell FAQ · Tenable: CVE-2026-114938 plugins

Sedat Özdemir

SEDAT ÖZDEMIR

Sr. Expert Pentest & Vulnerability Management Engineer

Close to a decade in offensive security. Writes about penetration testing, red teaming, vulnerability management and DevSecOps.