Skip to main content

Java4Shell (CVE-2026-114938): What We Did and What You Need to Do

· 6 min read
Robert Loipfinger
Circle Lead Platform @ ADITO

On November 17, 2026, a critical vulnerability in OpenJDK became public: CVE-2026-114938, also known as Java4Shell. Our cloud systems are already protected by a JVM setting, and a Java security update will fix the problem for good. Appliance and on-premise installations need one change to the JVM configuration and a restart.

Below you will find the background, the steps for your own installations and our view on the performance impact.

What the vulnerability is​

The bug sits in the Base64 decoder of the HotSpot JVM. On x86-64 processors with AVX-512, the JIT compiler swaps the Java code of java.util.Base64 for a hand-written machine code routine, a so-called intrinsic. Some malformed inputs, for example a block of valid characters followed by a single =, make this routine get the output length wrong. It then writes up to 64 bytes past the end of the target array. Java does throw an IllegalArgumentException for the invalid input, but by then the memory is already overwritten.

Base64 is used wherever data enters a system: Basic authentication headers, JSON Web Tokens, file uploads and many API payloads. Anyone who can send such data to a service can corrupt the JVM heap, often without logging in first.

The most likely outcome is a crash. The overwritten memory usually takes the JVM down at the next garbage collection, and that is not hard to provoke. Remote code execution is possible in theory, but it needs an exploit built for the specific application and JVM. As of November 18, 2026, no public exploit chain was known.

Which systems are affected​

A system is only vulnerable if all of these conditions are met:

ConditionDetails
Java versionOpenJDK 17.0.6 and later on the 17, 21, 25 and 27 lines, including derivatives such as Temurin
CPU architecturex86-64
CPU featuresAVX-512 with VBMI, for example Intel Xeon Ice Lake and newer or AMD Zen 4 and newer
JVM settingsDefault settings, so the Base64 intrinsic is active

ARM64 systems are not affected, and neither are older x86 CPUs without AVX-512 VBMI, Java 8 or Java 11.

On Linux, you can check whether a host has the relevant CPU feature:

# Prints "avx512vbmi" if the CPU supports the affected instruction set
grep -om1 -E 'avx512_?vbmi' /proc/cpuinfo

What we did in the ADITO cloud​

We are handling this in two steps.

  1. We have switched off the affected JVM function on all cloud systems.
  2. Once patched Java builds are available for our runtime, we update, test and roll them out. Until then, the workaround stays in place.

You do not need to do anything for ADITO cloud systems.


What you need to do on appliance and on-premise installations​

You or your partner operate these installations, so the workaround has to be set there by hand.

1. Add the JVM option​

The bug is in the Java runtime, not in ADITO. That means every Java service on the system is affected, not just the ADITO server. Solr is one example, and the same goes for any other Java service running next to ADITO.

Add this option to the JVM startup configuration of each of these services:

# Disables the vulnerable Base64 intrinsic and falls back to the regular Java implementation
-XX:-UseBASE64Intrinsics

This option alone closes the vulnerability, on every architecture.

On x86-64 systems you can also set:

# Optional, x86-64 only: limits the JVM to AVX2 and turns off all AVX-512 code paths
-XX:UseAVX=2

Do not set -XX:UseAVX=2 on non x86-64 systems. The JVM does not know the option there and will refuse to start.

2. Restart the services​

The option is only picked up on restart. Restart every Java service you changed, Solr included.

3. Check that the setting is active​

After the restart, you can check the setting on the running JVM:

# Replace <PID> with the process ID of the Java service
jcmd <PID> VM.flags -all | grep -E 'UseBASE64Intrinsics|UseAVX'

You should see UseBASE64Intrinsics = false, plus UseAVX = 2 if you set the optional AVX option as well.


What the workaround does​

-XX:-UseBASE64Intrinsics​

By default, the JIT compiler replaces the Base64 methods with machine code that handles many bytes per CPU instruction. With this option, the JVM keeps running the normal Java implementation of java.util.Base64, which ships with every JDK and returns exactly the same results. It just works through the data byte by byte instead of in wide vector blocks.

All other JIT optimizations stay as they are, including every other use of AVX-512.

-XX:UseAVX=2​

This option has a wider effect. The JVM stops using AVX-512 altogether and falls back to AVX2. That also removes the vulnerable code path, but it hits every other spot where the JVM would use AVX-512, such as array copies, string comparisons and auto-vectorized loops. AVX2 is a vector instruction set too, so these operations remain fast with half the vector width.

Since -XX:-UseBASE64Intrinsics already closes the gap, you can treat -XX:UseAVX=2 as an extra layer of protection. It is not required.


How much performance does this cost​

The published advisories do not include measurements. They say the workaround may reduce performance and recommend keeping an eye on it. Our assessment below is based on how ADITO uses Base64.

Base64 intrinsic​

The intrinsic only pays off when a lot of Base64 data is processed in tight loops. Without it, the plain Java implementation still decodes several hundred megabytes per second. A JWT or a Basic authentication header is a few hundred bytes and takes microseconds to decode, with or without the intrinsic. A document of several megabytes sent as Base64 takes a few milliseconds longer, which is small next to the database access or network transfer.

ADITO spends its time on database queries, network round trips, business logic and rendering. Base64 decoding barely shows up, so users will not notice the change.

AVX-512​

-XX:UseAVX=2 touches more operations, but AVX2 still handles them well. Many server CPUs also lower their clock speed under heavy AVX-512 load, so in mixed workloads AVX-512 has less of a lead than it seems. For a business application like ADITO, we expect the difference to be lost in normal measurement noise.

Summary​

OptionWhat it affectsExpected impact on ADITO
-XX:-UseBASE64IntrinsicsBase64 encoding and decoding onlyNot noticeable
-XX:UseAVX=2All AVX-512 code paths of the JVMNot noticeable in typical ADITO workloads

Next steps​

The permanent fix is a Java security update. The fixed OpenJDK builds are 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1. We are building the update into our runtime and testing it, and will then roll it out to the cloud and ship it as an update for appliance and on-premise installations. When your installation runs the patched Java version, you can remove the JVM options.

./Robert