A poster of a 1960s punched-tape reader. A security engineer with headphones round his neck turns a large switch beside a cracked red high-speed reader, and its paper tape runs right into a dark panel. On the panel: a red CVE-2026-114938 tag and a Java 17, 21, 25 tag; a diagram where decode() splits into three decoders, AVX-512 in red, where the reports place the flaw, then AVX2 and plain Java; the name JAVA4SHELL; the lines same Java build, different CPU, different answer; and a green label: mitigate today, -XX:-UseBASE64Intrinsics.

CVE-2026-114938 · Java 17, 21, 25

Java4Shell depends on the CPU under yourJVM

Antonio Firmiano

CEO · · 12 min read

Java4Shell is the name going around today for CVE-2026-114938, a reported flaw in the Java runtime. Early reports describe remote code execution in OpenJDK 17.0.6 and later, with a CVSS 4.0 score of 9.2 [1]. It arrived on the same day Oracle shipped its November update with 11 fixes for Java SE [1], [3].

Most of the details aren't confirmed yet. What we can already check is where the reports place the flaw: the hand-written machine code the JVM uses to decode Base64 fast on processors with AVX-512 [8]. That code only runs on some CPUs. So the same Java build, in the same container image, can be in scope on one server and out of scope on the next.

This post covers what's confirmed and what isn't, how that code path works, the four conditions a server needs, read-only checks, the flag that turns the fast path off today, and where the fixed builds stand.

Key findings

  • The details are still unconfirmed. At 21:00 UTC on 17 November, cve.org had no published record for CVE-2026-114938 [9]. Oracle's announcement of its 11 Java SE fixes names no CVEs, and the vulnerable component hasn't been confirmed [1], [2].
  • The reports point at one fast path. An open-source project that shipped a mitigation today describes the flaw as a bug in the JDK's AVX-512 Base64 decoder [8]. That code reached Java 17 in update 17.0.6, in January 2023, which matches the "17.0.6 and later" in the reports [4].
  • Only some processors run it. The JVM uses that decoder only on x86-64 CPUs with both the AVX-512 VBMI and AVX-512 BW features. That means Intel Ice Lake and newer Xeons, and AMD Zen 4 and Zen 5 [5], [10]. ARM servers and older x86 chips take other paths. Java 8 and 11 never got this code [4].
  • The path needs four things at once. A build with the decoder, a CPU with both features, the JVM's Base64 fast path switched on (the default), and Base64 from outside reaching the JDK's decoder.
  • One flag turns the fast path off. -XX:-UseBASE64Intrinsics sends Base64 decoding back to plain Java code. We checked that it works on Java 17 and 25 without any unlock option, set through JAVA_TOOL_OPTIONS or JDK_JAVA_OPTIONS.
  • No known attacks. CISA's Known Exploited Vulnerabilities catalog doesn't list it as of its 17 November release [11].
Key findings panel, six numbers. 17.0.6: the first Java 17 update with the AVX-512 Base64 decoder, January 2023. 4 conditions: all four have to hold on the same machine. 2 CPU features: AVX-512 VBMI and AVX-512 BW, both required. 1 flag: -XX:-UseBASE64Intrinsics turns the fast path off. 11 fixes: Java SE fixes in Oracle's 17 November update, highest CVSS 3.1 score 8.1, none tied to this CVE yet. 0 entries: in CISA's Known Exploited Vulnerabilities catalog.
Java4Shell at a glance, as of 17 November 2026, 21:00 UTC. Each number is explained below.

1. What happened

On 17 November Oracle released a Critical Security Patch Update, a smaller format it now ships between its quarterly Critical Patch Updates. It has 11 fixes for Java SE, and Oracle says all of them may be exploitable over a network without credentials. The affected versions include Java SE 8u511, 11.0.33, 17.0.21, 21.0.13, 25.0.5 and 27.0.1, along with GraalVM and JavaFX. The highest CVSS 3.1 score among the Java SE fixes is 8.1 [2]. Oracle's pre-release announcement lists products and versions, with no CVE numbers and no mention of Base64. Those details come with the full advisory [2], [3].

The same day, reports of CVE-2026-114938 started to spread under the name Java4Shell. They describe unauthenticated remote code execution in OpenJDK 17.0.6 and later, with a CVSS 4.0 score of 9.2 [1]. The name borrows from Log4Shell, the 2021 flaw in the Log4j library (CVE-2021-44228) [12]. The two have little in common beyond the language. Log4Shell sat in a library that almost every Java service shipped. Java4Shell is reported in the runtime itself, in code that only runs on certain processors.

The reports' 9.2 is a CVSS 4.0 score. Oracle's highest Java SE score this month is 8.1 under CVSS 3.1 [2]. The two scales aren't directly comparable, so neither number settles how serious Java4Shell is.

Here is where things stood when we published, at 21:00 UTC:

  • CVE record: cve.org had no published record for CVE-2026-114938 [9].
  • Oracle: no link between this CVE and its 11 Java SE fixes. Its announcement names no CVEs [2], and the vulnerable component and what an attacker needs were still unconfirmed [1].
  • Mitigations in the wild: at least one open-source Java project shipped a change that turns off the JDK's Base64 fast path, and it cited this CVE [8].
  • Exploitation: not in CISA's Known Exploited Vulnerabilities catalog [11].
  • Government advice: Switzerland's National Cyber Security Centre told operators to take stock of every application and device that uses Java, including embedded components and externally managed services, and to get ready to install updates quickly [3].

We'll update this post when the CVE record and vendor advisories are out.

2. Where the reports point: the JVM's Base64 fast path

When your code calls Base64.getDecoder().decode(...), the JVM doesn't always run the Java code you'd find in the JDK source. For some hot methods, HotSpot's JIT compiler swaps in a routine written by hand in machine code, called an intrinsic, and picks a version that suits the CPU it found at startup. Base64 decoding has one. On x86-64 processors with AVX-512, it decodes dozens of bytes at a time.

Java checks array bounds in Java code. An intrinsic is machine code written by hand, so every length and offset in it has to be right by construction. That's the trade the JVM makes for speed, and it's where the reports place this flaw [8].

Flow diagram. Base64 from outside, such as a header, token, cookie, upload or message, goes to your code or a framework calling the JDK's java.util.Base64 decoder. At startup the JVM picks one of three decoders. On an x86-64 CPU with AVX-512 VBMI and BW, with the intrinsic on: the AVX-512 decoder, in red, where the reports place the flaw. On other x86-64 CPUs with Java 21 or later: an AVX2 decoder, a separate routine. On Java 17 without AVX-512, or with the flag set: plain Java code with the JVM's bounds checks. A green label shows that -XX:-UseBASE64Intrinsics cuts the red branch, and decoding falls back to plain Java with the same results. ARM CPUs use their own decoder.
Figure 1. One call, three possible decoders. Which one runs depends on the CPU and one JVM flag. Sources: [5], [8].

The AVX-512 decoder is young as JVM code goes. It reached OpenJDK in June 2021 and Java 17 in update 17.0.6, in January 2023 [4]. It has been fixed twice before: for a JVM crash traced to the original change in 2021, and for lost data during decoding in January 2024 [6], [7].

Timeline from 2021 to 2027. June 2021: AVX-512 Base64 decoder added to OpenJDK, JDK-8268276. December 2021: fix for a JVM crash traced to it, JDK-8273108. January 2023: both ship in Java 17.0.6. January 2024: fix for data loss in the AVX-512 decoder, JDK-8321599, shipped in 17.0.11 in April 2024. 17 November 2026, in red: Java4Shell reported. A bar shows the decoder in Java 17 updates for almost four years.
Figure 2. Almost four years in Java 17 updates, with two earlier fixes. Sources: [4], [6], [7].

Base64 shows up wherever data crosses a boundary: credentials in HTTP headers, tokens, cookies, file uploads sent as text, signed messages, webhook bodies and queue messages. Some of these arrive before any login. Plenty of libraries ship their own Base64 code, such as Apache Commons Codec and Guava, and that code never reaches the JDK's decoder. The fast path only matters for calls that reach java.util.Base64, directly or through a framework.

3. Four conditions, all at once

The path needs four conditions on the same machine.

Diagram of four boxes joined by plus signs. Condition 1: a build with the AVX-512 Base64 decoder, Java 17.0.6 and later, 21 and 25 per the reports. Condition 2: an x86-64 CPU with AVX-512 VBMI and BW, such as Intel Ice Lake and newer Xeons, or AMD Zen 4 and Zen 5. Condition 3: the JVM uses them, AVX-512 in use and the Base64 intrinsic on, the defaults on those CPUs. Condition 4: Base64 from outside reaches the JDK's decoder, through headers, tokens, cookies, uploads or messages. A green band reads: break one, any condition that doesn't hold closes the path, and the flag breaks condition 3 today.
Figure 3. All four have to hold at once. The first three are defaults on modern x86 servers. Sources: [1], [4], [5], [8].

That makes it narrower than "every Java 17 server":

  • Java 8 and Java 11 never got the AVX-512 Base64 decoder. There's no backport in either update repository [4]. Oracle's November fixes still cover them for other issues [2].
  • ARM servers, such as AWS Graviton, Ampere and Apple silicon, run a different architecture and never take this path.
  • AMD EPYC before Zen 4 (Naples, Rome, Milan) has no AVX-512 at all [10].
  • Intel Xeon Skylake-SP, Cascade Lake and Cooper Lake have AVX-512 but not VBMI, so the JVM skips this decoder [5], [10].
  • Intel Ice Lake Xeons, Sapphire Rapids and newer P-core Xeons, and AMD Zen 4 and Zen 5 have both features. On these, a Java build in the reported range uses the AVX-512 decoder by default [5], [10].

4. Same image, different answer

A container sees the CPU of the machine it runs on. So a Java image in a Kubernetes cluster with mixed node pools can take the AVX-512 path on some nodes and not on others. A reschedule or an autoscaler can move it between them without anyone noticing.

Illustration of one container image with Java 17.0.13 scheduled on three node types. On an ARM node: other path, out of scope. On an AMD Zen 3 node: no AVX-512, out of scope. On an Intel Sapphire Rapids node, in red: AVX-512 VBMI and BW present, the AVX-512 decoder runs, in scope. The image is identical in all three.
Figure 4. An illustration. One image, three nodes, and only one takes the fast path. Sources: [5], [10].

This is why a scan of image versions can't settle Java4Shell on its own. It will flag every Java 17 image you have. Which of those are really in scope depends on where they run and what they decode.

5. How to check a machine

These commands only read. Run them on the host, or inside the container, since the container sees the host's CPU.

# 1. Which Java runs here, and which build?
java -version

# 2. Does this CPU have both features? Two lines means yes.
grep -o -w -E 'avx512vbmi|avx512bw' /proc/cpuinfo | sort -u

# 3. What the JVM chose on this machine.
java -XX:+PrintFlagsFinal -version 2>/dev/null | grep -E ' (UseAVX|UseBASE64Intrinsics) '

For a JVM that's already running, ask it directly. jcmd ships with the JDK.

jcmd -l                                   # list running JVMs and their pids
jcmd <pid> VM.version
jcmd <pid> VM.flags -all | grep -E ' (UseAVX|UseBASE64Intrinsics) '

A machine is in scope when the build is in the reported range, the CPU has both features, UseAVX is 3 and UseBASE64Intrinsics is true.

Here's the output from one of our own machines, an AMD EPYC 7B12 (Zen 2) running Temurin 17.0.13:

$ grep -o -w -E 'avx512vbmi|avx512bw' /proc/cpuinfo | sort -u
$
$ java -XX:+PrintFlagsFinal -version 2>/dev/null | grep -E ' (UseAVX|UseBASE64Intrinsics) '
     intx UseAVX                 = 2        {ARCH product} {default}
     bool UseBASE64Intrinsics    = false    {product} {default}

No AVX-512, and Java 17 leaves the Base64 intrinsic off. Out of scope. On the same machine, Temurin 25.0.1 reports UseBASE64Intrinsics = true with UseAVX = 2. Java 21 and later have a separate AVX2 decoder for CPUs without AVX-512, and that's a different routine from the one in the reports [5]. So UseBASE64Intrinsics = true doesn't put a machine in scope on its own. UseAVX = 3 and the two CPU features do.

6. What to do today

Turn the fast path off on machines in scope. The flag sends Base64 decoding back to the JDK's plain Java code, the same code the JVM uses on CPUs without the fast path. Decoding gives the same results either way.

# Read by the JVM itself, so it covers any launcher.
# If JAVA_TOOL_OPTIONS is already set, append to it.
export JAVA_TOOL_OPTIONS="${JAVA_TOOL_OPTIONS:+$JAVA_TOOL_OPTIONS }-XX:-UseBASE64Intrinsics"

In a Dockerfile, use ENV JAVA_TOOL_OPTIONS=-XX:-UseBASE64Intrinsics, and in Kubernetes add the variable to the container's env. JDK_JAVA_OPTIONS works too, but only the java launcher reads it. JVMs started some other way, by a service wrapper or a native launcher for example, miss it. With JAVA_TOOL_OPTIONS the JVM prints a "Picked up JAVA_TOOL_OPTIONS" line on stderr, which matters if a tool parses that stream.

The flag only takes effect when the JVM starts, so restart the service. Then confirm on the running JVM:

jcmd <pid> VM.flags -all | grep ' UseBASE64Intrinsics '
# bool UseBASE64Intrinsics = false {product} {environment}

We tested both variables on Temurin 17.0.13 and 25.0.1. Neither needs an unlock option.

Option What it changes Cost When
-XX:-UseBASE64Intrinsics Base64 decoding runs as plain Java Slower Base64 decoding only Today, on machines in scope
-XX:UseAVX=2 Turns off every AVX-512 routine in the JVM Slower vector-heavy code across the JVM, crypto and array copies included If you want all AVX-512 paths off while you wait
Keep the service on nodes without AVX-512 Condition 2 no longer holds Scheduling rules that can drift Short term, for a few critical services
Your vendor's fixed build Replaces the flawed code A normal update and restart As soon as your vendor ships one for CVE-2026-114938

How much slower Base64 gets depends on how much your service decodes. For most services it's a small share of the CPU time, and the project that shipped this mitigation today called the impact negligible for theirs [8]. Measure on services that decode a lot, like large uploads or message brokers.

Patch when the fixed build is out. Oracle lists Java SE 17.0.21, 21.0.13 and 25.0.5, the current builds, as affected by its November fixes, so every Oracle Java 17, 21 and 25 install needs this update [2]. Oracle hasn't said whether it addresses CVE-2026-114938 [1], [2]. Take it anyway, for the 11 issues it does fix. If you run an OpenJDK build from another vendor, such as Eclipse Temurin, Amazon Corretto, Azul Zulu, Red Hat or Microsoft, watch that vendor's advisory for this CVE by number. Oracle's notice covers Oracle's own builds.

Look for the runtimes that hide. Container base images, runtimes bundled into applications with jlink, build agents, and appliances or vendor products that ship their own JRE all carry their own copy [3]. Each one needs its own update. For images, rebuild without the layer cache, or the old runtime comes back from the cache.

7. Questions we're hearing

Is Java4Shell confirmed?

Partly. Oracle's 11 Java SE fixes from 17 November are confirmed [2], [3]. CVE-2026-114938 had no published record when we wrote this. Oracle's announcement names no CVEs and doesn't mention Base64 [2]. The reports and one project's mitigation place it in the AVX-512 Base64 decoder [8].

Which Java versions does Java4Shell affect?

The reports say OpenJDK 17.0.6 and later [1]. Java 21 and 25 carry the same AVX-512 decoder, next to a separate AVX2 one [5]. Whether a given machine is in scope also depends on its CPU, as covered in sections 3 and 4.

Are Java 8 and Java 11 affected?

Not by this decoder. It was never backported to either [4]. Oracle's November update still fixes other issues in both, so update them anyway [2].

Am I affected on ARM, or on AWS Graviton?

Not by the reported code. It's x86-64 AVX-512 machine code, and ARM processors don't run it. ARM has its own Base64 routine, and nothing so far points at it.

Does turning off the Base64 intrinsic change my results?

No. The plain Java decoder is the reference the fast path has to match. Base64 decoding just costs more CPU.

Is Java4Shell being exploited?

CISA's Known Exploited Vulnerabilities catalog doesn't list it as of its 17 November release [11]. We'll update this post if that changes.

8. What I take from this

The question "which version are we on?" doesn't settle this one. The same build can be in scope on one machine and out of scope on the next, and a container can move between them overnight. What matters is the path: does Base64 from outside reach the JDK's decoder, in a service running on a CPU that takes the fast path?

Java's safety guarantees hold for Java code. Underneath, the JVM runs a small set of routines written by hand in machine code, for speed, on the hottest paths: string handling, array copies, crypto and Base64. They're small, and they're hard to test on every CPU the JVM supports. This one has been fixed twice before.

And a name and a score arrived hours before the record did. The work that helps on day one is the same either way. Know where your Java runtimes are, which machines they run on, and which services read Base64 from outside input. That map will help with the next JDK fix too.

What we're building at Arvion

That's the question our product-security team works on: can attacker input reach the flaw in your system? It reads your code, open-source dependencies, infrastructure as code and the AI agents in your repositories. For each finding, it traces whether attacker input can reach the vulnerable code and marks each step of the path as traced or assumed.

For findings with a real path, it writes the fix and opens a pull request. Your engineers review the evidence and decide what gets merged.

References

  1. The Hacker News. "Oracle to Patch 11 Java Flaws Today as Critical OpenJDK RCE (CVE-2026-114938) Report Emerges," 17 November 2026. thehackernews.com
  2. Oracle. "Oracle Critical Security Patch Update Pre-Release Announcement - November 2026," for release on 17 November 2026. oracle.com
  3. National Cyber Security Centre (Switzerland). "Java security updates announced: Operators should check their systems," 17 November 2026. bacs.admin.ch
  4. OpenJDK. JDK-8268276, "Base64 Decoding optimization for x86 using AVX-512." Mainline commit c37988d, 25 June 2021 (github.com); Java 17 backport 07050b0, 9 November 2022, first in jdk-17.0.6-ga (github.com). No backport in jdk11u-dev or jdk8u-dev. bugs.openjdk.org
  5. OpenJDK. src/hotspot/cpu/x86/vm_version_x86.cpp (when UseBASE64Intrinsics is on, and AVX-512 features cleared when UseAVX is below 3) and stubGenerator_x86_64.cpp (the AVX-512 VBMI and BW decode branch), in jdk17u-dev and jdk21u-dev.
  6. OpenJDK. JDK-8273108, "RunThese24H crashes with SEGV in markWord::displaced_mark_helper() after JDK-8268276." Mainline commit 9a1bbaf, 12 December 2021 (github.com); Java 17 backport b7a0a0a, 10 November 2022 (github.com).
  7. OpenJDK. JDK-8321599, "Data loss in AVX3 Base64 decoding." Mainline commit 13c1148, 4 January 2024 (github.com); backports to Java 17 (1f95796, first in jdk-17.0.11-ga) and Java 21 (1e66488), 8 January 2024.
  8. Cardano Foundation. cardano-rosetta-java pull request #900, "fix: avoid JDK Base64 decoder intrinsic (reported CVE-2026-114938)," 17 November 2026. github.com
  9. CVE Program. CVE-2026-114938, checked 17 November 2026 at 21:00 UTC: no published record. cve.org
  10. "AVX-512," CPUs with AVX-512, VBMI subset. wikipedia.org
  11. CISA. Known Exploited Vulnerabilities Catalog, version 2026.11.17. cisa.gov
  12. NIST. National Vulnerability Database, CVE-2021-44228. nvd.nist.gov

Which of your Java services decode Base64 from outside input?

The flag in this post turns the fast path off one JVM at a time. Your repositories decide which services read Base64 from requests, tokens and messages, and which machines they run on. Book 15 minutes with the Arvion team to go through them.

Book 15 min