Go straight to an AI summary of this blog post instead

  • Summarize this post with Perplexity
  • Summarize this post with Gemini

CVE-2026-114938 Update for OpenJDK Users

Updated November 18, 2026. TuxCare’s OpenJDK 17 builds include the Java4Shell fix in the latest TuxCare release. Java 7, 8 and 11 don’t contain the vulnerable decoder, so customers on those OpenJDK versions have nothing to patch for this CVE.

If a host can’t take the update right away, the -XX:-UseBASE64Intrinsics startup flag disables the vulnerable code path on affected HotSpot 17 builds.

Get Endless Lifecycle Support for OpenJDK →

Key Takeaways

  • Java4Shell (CVE-2026-114938) is a heap overflow in OpenJDK’s Base64 decoder that Calif chained into remote code execution.
  • Unpatched Java 17.0.6+, 21, 25 and 27 builds are at risk on x86-64 servers with AVX-512 VBMI.
  • Oracle, OpenJDK, Corretto and Zulu shipped fixes on November 17, 2026, while Temurin, Red Hat and Ubuntu lag.
  • Starting the JVM with -XX:-UseBASE64Intrinsics disables the vulnerable code path until a fixed runtime is installed.

The Short Version

Jump to the Long Version ↓

What happened. Calif disclosed Java4Shell (CVE-2026-114938) on November 17, 2026, the same day Oracle and the OpenJDK project shipped fixes. A malformed Base64 string ending in bad “=” padding makes HotSpot’s AVX-512 decoder write 62 or 63 bytes past the end of a heap buffer, and Calif says it turned that into remote code execution in apps like Jira, Jenkins and Keycloak. Jump to this section →

Who’s affected. Anyone running an unpatched build on the Java 17.0.6+, 21, 25 or 27 lines on an Intel or AMD x86-64 processor with AVX-512 VBMI. That includes builds from Oracle, Corretto, Temurin, Zulu, Red Hat, Microsoft and other OpenJDK-based vendors. Standard Java 8, Java 11 and ARM64 hosts are not affected. Jump to this section →

How bad it is. Oracle scores it 8.1 under CVSS 3.1, Calif rates it 9.2 under CVSS 4.0, and Red Hat rates the impact Critical. Exploitation takes target-specific work, but crashing a vulnerable JVM is much simpler, and no in-the-wild attacks had been reported as of November 18, 2026. Jump to this section →

Where things stand. Fixed upstream releases are 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1, and Amazon Corretto and Azul Zulu fixes have shipped. Temurin, Red Hat and Ubuntu builds were still pending as of November 18, 2026, and Debian had a fix only in unstable. OpenJDK 17 users on TuxCare’s Endless Lifecycle Support get the fix in TuxCare’s latest release, inside the OpenJDK 17 line they already run. Jump to this section →

What to do today. Find every JVM, including the ones bundled inside products and baked into container images. Install fixed builds where they exist, set -XX:-UseBASE64Intrinsics on affected hosts still waiting for a vendor fix, and restart either way. Jump to this section →

The Long Version

Java’s big promise for three decades has been that developers don’t have to think about memory. The JVM checks every array access, so buffer overflows are supposed to be a C and C++ problem. Java4Shell is a reminder that the JVM itself is still built out of C++ and hand-tuned assembly, and the safety net only covers the code running on top of it.

CVE-2026-114938 lives in one of those hand-tuned routines, the AVX-512 Base64 decoder HotSpot swaps in on newer Intel and AMD server chips. Feed it a malformed string with bad padding at the end and it writes past the end of its output buffer before the JVM rejects the input. Calif, the firm that found it, says it used that write to build working remote code execution chains against Jira, Jenkins, Keycloak and other widely deployed applications in their default configurations.

The fix is small, the workaround is a single JVM flag, and no exploitation had been publicly reported as of November 18, 2026. The harder part is that plenty of Java runtimes still don’t have a fixed build, and many teams have no clear count of how many JVMs they actually run.

How the Base64 Bug Works

When a method gets called often enough, HotSpot’s C2 compiler replaces it with faster native code. For a few hot paths, including java.util.Base64 decoding, it can swap in an intrinsic instead, a hand-written routine JVM engineers built at the assembly level for specific x86-64 processors. On chips with AVX-512 VBMI, the Base64 intrinsic decodes 64 bytes at a time using masked vector stores, where a 64-bit mask decides which bytes actually get written to memory.

The bug sits in how that mask is built for the last chunk of input. If the leftover tail is a malformed padding sequence like “=”, “==” or “X=”, the routine computes an output length of zero and then subtracts one for each “=”. The length underflows to -1 or -2. The BZHI instruction that builds the mask reads its bit count from the low byte of that value, which comes out as 255 or 254. Both exceed the 64-bit operand width, so all 64 mask bits stay set and the store writes a full 64 bytes. In Calif’s example, a 65-character input made of 64 “A” characters plus “=” gets a 50-byte result array, and the decoder writes 62 bytes past its end. On OpenJDK 17, Calif says the trigger is 128 “A” characters plus “=”, because the length threshold for the fast path is higher there.

Java does throw an IllegalArgumentException for the malformed input. It just throws it after the write has already happened, and by then whatever object sat next to the buffer on the heap may have been corrupted.

The overflow bytes are mostly fixed values rather than attacker-chosen data, which sounds limiting. Calif got around that with a classic browser-exploit trick. Groom the heap so the spill lands on another array’s length field, then use that enlarged array to write chosen bytes into its neighbors. A second array with a corrupted length field, whose contents get copied back into an HTTP response, becomes a heap reader, which Calif nicknamed JavaBleed. That stage alone can potentially leak private keys and session tokens before any code runs.

In Datadog’s testing of OpenJDK 17.0.6, only the basic and URL decoders returned by Base64.getDecoder() and Base64.getUrlDecoder() reached the vulnerable path. The MIME decoder doesn’t, and Base64 libraries that never call java.util.Base64 don’t touch the intrinsic at all. That helps with triage, but don’t lean on it too hard. Calif points to ordinary features like authentication and file uploads as ways for attacker input to reach the decoder.

Which Java Versions and Servers Are Affected

Three conditions have to line up.

The runtime. Java4Shell affects unpatched OpenJDK 17 builds from 17.0.6 onward, plus the later release lines, including 21, 25 and 27, before the November 17, 2026 fixes. OpenJDK 17.0.6 shipped in January 2023, so the vulnerable decoder has been part of OpenJDK 17 for almost four years. Standard Java 8 and Java 11 are not affected because neither has the x86 decode stub, and Java 17.0.0 through 17.0.5 aren’t affected either. The one Java 8 exception is Oracle’s Java SE 8 Enterprise Performance Pack, which Oracle lists as affected at 8u511b33-perf.

Unpatched builds from other OpenJDK vendors carry the bug too. Calif’s list includes Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat’s OpenJDK, Oracle OpenJDK, Oracle Java SE and Oracle GraalVM for JDK.

The CPU. The vulnerable code only runs on x86-64 chips with AVX-512 VBMI. Calif’s list names Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids, plus AMD EPYC and Ryzen on Zen 4 or newer. Skylake-SP, Cascade Lake and pre-Zen 4 AMD hardware generally lack VBMI and don’t take the vulnerable path, and ARM64, including AWS Graviton and Apple silicon, isn’t affected at all. So the hosts at risk are mostly newer servers and cloud instances, which flips the usual assumption that old hardware is where the risk lives. Newer doesn’t automatically mean VBMI, though, so the CPU flag check below is the real test.

The data path. The application has to pass attacker-controlled input to the standard basic or URL decoder, and that method has to run hot enough for C2 to compile it with the intrinsic. In a busy web service, both conditions can be met. Calif says it demonstrated pre-auth RCE in default configurations of Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins and PingFederate, and post-auth RCE in Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit and Spinnaker. Calif says it also reached RCE in sample apps built on Spring Boot and Apache Struts.

Then there’s the client side. Calif reports that an exploit shared with it compromised a Java program that simply opened a TLS connection to a malicious server, with no exposed service of its own. Batch jobs, crawlers and integration services that only make outbound calls are in scope too.

Why Dependency Scans Can Miss Java4Shell

Log4Shell trained a lot of teams to go hunting for vulnerable JARs. That reflex doesn’t help here. Java4Shell isn’t a dependency you’ll find in a pom.xml or build.gradle, and it won’t show up in a software composition analysis report that only reads application dependencies. The vulnerable code ships inside the JDK, which usually arrives from a container base image, an OS package, an installer bundled with a vendor product, or a JAVA_HOME someone set up in 2023 and never touched again.

That’s why CISA’s alert specifically calls out JDKs bundled with third-party applications, container images and appliances. A patched system JDK does nothing for a product that runs from its own bundled copy, and a patched host does nothing for a JDK baked into an image that hasn’t been rebuilt.

Library hygiene still matters, and SecureChain for Java covers the Maven side of the house. For this one, though, the runtime is the patch target. Treat every JVM as its own asset to inventory.

How Bad Java4Shell Really Is

It depends who’s scoring. Oracle rates CVE-2026-114938 at 8.1 under CVSS 3.1 and describes it as difficult to exploit, with network access, no privileges and no user interaction required but high attack complexity. Calif rates it 9.2 under CVSS 4.0. Red Hat’s bulletin, RHSB-2026-018, rates the impact Critical.

Calif says there’s no universal exploit. Each target needs its own heap grooming profile, Calif’s chains are sensitive to network jitter and round-trip time, and a failed grooming attempt can crash the JVM. Calif also found that a reverse proxy buffering full request bodies, which nginx does by default, breaks some of its grooming paths. Some, not all. Calif says its Elasticsearch chain works from one complete request, so buffering doesn’t stop it.

Two things push the other way. First, a crash is a lot easier to cause than code execution. Blackpoint Cyber reached the bug through a local Spring Boot app using Spring Security, and roughly 28,000 unauthenticated requests carrying a malformed Base64 auth value killed the JVM after about 20 seconds. Blackpoint also reported changes to live application data without an immediate crash, which is much harder to spot. Second, Calif says it found the bug in an hour with AI assistance and had a first working exploit two hours later, using less than $200 in AI tokens. Calif is holding back its product-specific chains for now.

As of November 18, 2026, there’s no reported exploitation in the wild. GreyNoise had logged zero Java4Shell-shaped requests as of its 00:48 UTC update that day, and the CVE wasn’t in CISA’s Known Exploited Vulnerabilities catalog. CISA still put out an alert on November 17 urging immediate patching, a good sign of how seriously the agency is taking it.

The trigger has also been public longer than most people realize. According to The Hacker News, a proposed fix posted to OpenJDK’s repository on September 9 included input that triggers the overflow, and it was closed unmerged in early November after going inactive. Calif has said the bug leaked before the patch. Nothing public shows Java4Shell was exploited before a fix shipped, and no attacks have been reported since, but defenders shouldn’t assume they’re the first ones reading the details.

How Java4Shell Compares to Log4Shell

Log4Shell (CVE-2021-44228) scored a 10.0 under CVSS 3.1, worked on any CPU, and could fire whenever a vulnerable Log4j 2 version logged an attacker-controlled string. Public exploits appeared fast and mass scanning followed almost immediately.

Java4Shell is narrower. It needs a specific CPU feature, a warm JIT, an exposed decode path and a target-specific exploit, so spray-everything attacks are far less likely. Where it’s worse is reach and cleanup. Log4Shell lived in a library you could find and swap. Java4Shell lives in the Java runtime beneath the application, across a long list of vendor builds that each ship fixes on their own schedule, and every patched JVM needs a restart.

Patch Status by Java Vendor

Oracle and the OpenJDK project shipped fixes at 1:00 p.m. Pacific on November 17, 2026. The fixed upstream releases are 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1. Downstream vendors build from that source on their own timelines and with their own version strings, so the build number on a given host matters more than the date on the advisory.

Java build Affected Fix status (November 18, 2026)
Oracle Java SE 17, 21, 25, 27 17.0.6 through 17.0.21.0.3, plus 21.0.13.0.3, 25.0.5.0.3, 27.0.1.0.3 and earlier Fixed in 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1 (build +4)
Oracle Java SE 8 Enterprise Performance Pack 8u511b33-perf Fixed in 8u513-perf
OpenJDK upstream Java 17 builds from 17.0.6, plus 21, 25 and 27 builds, before the fix Fixed in 17.0.21.1+4, 21.0.13.1+4, 25.0.5.1+4, 27.0.1.1+4
Amazon Corretto and Amazon Linux 17, 21, 25, 27 Fixed in Corretto 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2, 27.0.1.1.4, with matching Amazon Linux packages
Azul Zulu 17, 21, 25, 27 Fixed in 17.0.21.1+2, 21.0.13.1+2, 25.0.5.1+2, 27.0.1.1+4 per Azul’s CVE table
Eclipse Temurin 17.0.6 and later, including 17.0.21+9 and 21.0.13+9 No fixed build published yet
Red Hat build of OpenJDK (RHEL 8, 9, 10) 17, 21, 25 Fix pending per RHSB-2026-018
Debian openjdk-17, 21, 25, 27 openjdk-21 21.0.13.1+2-1 accepted into unstable on November 18. Stable and testing still vulnerable
Ubuntu openjdk-17, openjdk-21 and newer OpenJDK packages No fixed package or security notice confirmed yet
Microsoft, SapMachine, Liberica 17.0.6 and later Affected per Calif, no fixed builds confirmed yet
Standard Java 8, Java 11, Java 17.0.0 to 17.0.5 Not affected No Java4Shell-specific action needed

Container images are their own line item. Updated base images have to ship first, and then every image built on them needs a rebuild and a redeploy. A fixed package on the host doesn’t reach inside a container that brought its own JDK.

How to Mitigate Java4Shell Today

Patching the runtime is the real fix. Install your vendor’s fixed build for every affected JVM, then restart the process. The restart isn’t optional, because a running JVM keeps using the code it already loaded.

Where a fixed build doesn’t exist yet, Calif and Red Hat both point to one JVM flag.

-XX:-UseBASE64Intrinsics

It disables HotSpot’s hardware-accelerated Base64 routines and falls back to the plain Java implementation, which doesn’t use the vulnerable native decoder path. The broader alternative, -XX:UseAVX=2, caps HotSpot at AVX2 so it stops using AVX-512. It works, but it also gives up every other AVX-512 code path in the JVM, which can cost some speed, and Calif notes that on ARM the JVM doesn’t recognize the flag and won’t start. That makes it a poor default for mixed fleets.

The simplest way to apply the narrow flag broadly is JAVA_TOOL_OPTIONS, which HotSpot JVMs read at startup. Keep in mind it applies to every JVM started in that environment, build tools included, so test it before rolling it out fleet-wide.

export JAVA_TOOL_OPTIONS="-XX:-UseBASE64Intrinsics"

For a systemd service, open a drop-in with sudo systemctl edit <service>, add these two lines, then save and restart the service. Check the unit first, though. If it already sets JAVA_TOOL_OPTIONS, add the flag to that value instead, or the drop-in will replace whatever was there.

[Service]
Environment="JAVA_TOOL_OPTIONS=-XX:-UseBASE64Intrinsics"

For containers, set it as an ENV in the runtime stage. Then restart and confirm it took. Products with their own launcher scripts may override or ignore environment variables, so check the flags on the live process instead of trusting the config file.

What about performance? Calif’s own point is that the accelerated decoder mostly helps applications chewing through enormous volumes of Base64. A login endpoint or an API decoding a few hundred bytes per request is unlikely to notice a meaningful difference.

If a fixed build is available from your Java vendor, install it, restart and verify the version. If it isn’t available yet and the host has AVX-512 VBMI, set the flag today and schedule the runtime update for the day your vendor ships. If the host is ARM64 or an older x86 chip without VBMI, it isn’t affected by this bug, but patch on your normal cycle anyway, since workloads move between instance types more often than anyone plans for.

Edge controls help a little. CISA suggests validating and size-limiting Base64 input at the application boundary and limiting unauthenticated access. A WAF rule aimed at oddly padded Base64 in auth headers can add some friction, but expect false positives and don’t count it as a fix.

Quick Server Check

Start with the CPU. On Linux, Calif’s check looks for the four CPU flags the vulnerable path needs.

grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'

If all four show up, the hardware meets the prerequisite. If avx512vbmi is missing, the vulnerable decoder path isn’t used on that host.

Next, list running processes named java across every service account, not just the JVM on your PATH. Run it as root, since an unprivileged user can’t resolve other users’ processes.

sudo sh -c 'for p in (pgrepjava);doreadlink-f/proc/p/exe; done' | sort -u

Treat that as a starting point rather than a full inventory. JVMs launched under other names, installed packages that aren’t running right now, runtimes bundled inside vendor products and container images all need their own check.

Then check each runtime’s version and whether the intrinsic is enabled, swapping in a path from the previous step.

/path/to/bin/java -version
/path/to/bin/java -XX:+PrintFlagsFinal -version | grep -E ' (UseAVX|UseBASE64Intrinsics) '

If the version falls in an affected range, the CPU check passed, UseAVX is above 2 and UseBASE64Intrinsics is true, that JVM may use the vulnerable path. For a process that’s already running, jcmd shows its effective flags. Run it as the same user that owns the process.

jcmd <pid> VM.flags -all | grep -E 'UseAVX|UseBASE64Intrinsics'

Calif also published a bounded proof of concept that warms the decoder, feeds it the malformed input and prints REPRODUCED on an affected JDK. It’s designed to keep every write inside a real 4096-byte array, but still run it in an isolated test environment against a copy of each production runtime. One catch for Java 17 shops: the published PoC uses the 65-character trigger (64 “A” characters plus “=”), and Calif says OpenJDK 17 needs 128 “A” characters plus “=”, so a NOT REPRODUCED result on a Java 17 runtime doesn’t prove much. The vendor’s fixed build number is the real proof that a runtime is patched.

Where Endless Lifecycle Support for OpenJDK Stands

TuxCare covers OpenJDK 7, 8, 11 and 17, keeping security fixes coming after the support window for a given build closes. Three of those four aren’t affected by Java4Shell. Java 7, 8 and 11 don’t include the x86 Base64 decode stub, so customers on those versions have nothing to patch for this CVE.

OpenJDK 17 is a different story. Unpatched 17 builds from 17.0.6 onward contain the vulnerable decoder, and TuxCare’s OpenJDK 17 packages fell in that range. TuxCare’s engineers have confirmed the Java4Shell fix is part of the latest release, so customers pick it up through the same repositories they already use. The fix lands in the OpenJDK 17 line customers already run, without a major-version jump or the compatibility work that comes with one.

OpenJDK version Affected by Java4Shell TuxCare status (November 18, 2026)
OpenJDK 7 No Not affected
OpenJDK 8 No Not affected
OpenJDK 11 No Not affected
OpenJDK 17 Yes, on AVX-512 VBMI hosts Fixed in the latest TuxCare release

For hosts that can’t take the update right away, -XX:-UseBASE64Intrinsics works on TuxCare’s OpenJDK 17 builds the same way it does on other affected HotSpot 17 runtimes.

One more thing for anyone weighing their options. Java4Shell is exactly the kind of news that pushes teams into rushed major-version upgrades, and jumping from 17 to 21 or 25 under pressure only helps if the new build is itself patched, since unpatched builds on those lines carry the same bug. The fastest safe path is a patched build of the version already in production.

Keep your current OpenJDK version patched without a forced upgrade. Explore Endless Lifecycle Support for OpenJDK →

Quick Answers on Java4Shell

Is Java 8 affected by Java4Shell? Standard Java 8 builds are not affected, because they don’t contain the vulnerable decode stub. The only Java 8 exception is Oracle’s Java SE 8 Enterprise Performance Pack, which Oracle lists as affected at 8u511b33-perf.

Is Java 11 affected? No. Java 11 doesn’t have the x86 decode stub either.

Are ARM servers affected? No. ARM64 hosts, including AWS Graviton and Apple silicon, never generate the x86 stub.

Is Java4Shell being exploited? Not as of November 18, 2026. No in-the-wild exploitation has been reported, and the CVE isn’t in CISA’s KEV catalog.

Is this a Log4j problem? No. The bug is in the JDK’s own Base64 decoder, not in a logging library or any other application dependency.

Does the workaround break anything? The -XX:-UseBASE64Intrinsics flag only swaps the accelerated decoder for the regular one. Many applications won’t see a meaningful difference, but a quick test before a fleet-wide rollout is still smart.

Patch the Runtime Under Everything

Java4Shell is a runtime problem, and runtime problems hide well. It needs an x86-64 server with AVX-512 VBMI, an unpatched OpenJDK build from 17.0.6 onward and a code path that decodes Base64 from the network, a combination that’s common in modern enterprise Java. The practical move today is short. Inventory every JVM, including the bundled and containerized ones, patch where vendor builds exist, set -XX:-UseBASE64Intrinsics on affected hosts still waiting for a fix, and restart. Then keep an eye on Temurin, Red Hat, Debian and Ubuntu, since those fixes were still on the way, or only partly out, as of November 18, 2026.

For teams running OpenJDK past the point their vendor wants to support it, TuxCare’s Endless Lifecycle Support for OpenJDK keeps security fixes flowing into the exact version in production, so the next Java4Shell doesn’t turn into a forced migration.

Java4Shell Timeline

Date Event
January 2023 OpenJDK 17.0.6 ships with the AVX-512 Base64 decode intrinsic, the first Java 17 release carrying the vulnerable code
September 9, 2026 A proposed OpenJDK fix containing a triggering input is posted publicly, according to The Hacker News
Early November 2026 That proposed fix is closed unmerged after going inactive
November 17, 2026 Oracle releases its November Critical Security Patch Update and OpenJDK publishes its advisory with fixed builds
November 17, 2026 Calif publishes its Java4Shell write-up and proof of concept, withholding product-specific exploit chains
November 17, 2026 CISA urges immediate patching, Red Hat publishes RHSB-2026-018, and Amazon Corretto and Azul Zulu ship fixed builds
November 18, 2026 Debian accepts a fixed openjdk-21 into unstable. Temurin, Red Hat and Ubuntu fixes are still pending, and no exploitation has been reported

Sources

Calif, Java4Shell write-up

OpenJDK Vulnerability Advisory, November 17, 2026

Oracle Critical Security Patch Update Advisory, November 2026

CISA alert on the critical Java vulnerability

Red Hat security bulletin RHSB-2026-018

CVE-2026-114938 record

Azul Zulu CVE table, November 2026

Amazon Linux CVE-2026-114938 page

The Hacker News, CISA urges immediate patching of Java4Shell

The Hacker News, Java4Shell enables pre-auth RCE

Datadog Security Labs, Java4Shell analysis

Blackpoint Cyber, Java4Shell testing

GreyNoise, Java4Shell activity tracker

TuxCare OpenJDK documentation

Join 4,500+ Linux & Open Source Professionals!

2x a month. No spam.

Table of Contents
Get the open-source security answers you need

Join 4,500+ Linux & Open Source Professionals!

2x a month. No spam.