Java4Shell: Finding Java and What You Can Do Now to Be Safe

Java4Shell is here, and every cybersecurity mind in the world dealing with it thought the exact same first thing: where, exactly, is all my Java?

Java4Shell (CVE-2026-114938) is a memory-corruption flaw in the Java runtime’s Base64 decoder that can let a remote, unauthenticated attacker crash a Java application, read its memory, or in some cases run code. Oracle fixed it on November 17, 2026. The first step for security teams is finding every Java runtime they operate, then patching it or applying the mitigation below.

On November 17, 2026, Oracle released its November 2026 Critical Security Patch Update, 655 new security patches that include a fix for CVE-2026-114938, the flaw researchers have nicknamed Java4Shell. The update carries 11 new patches for Java SE, and Oracle states that all 11 may be remotely exploitable without authentication. Oracle’s guidance is plain: apply the patches “as soon as possible.”

Java4Shell tests asset inventory as much as patch speed. The fix exists, but it only helps on systems a team knows are running Java, and Java often ships inside software that never appears on a list labeled “Java.” As always, check with the latest Oracle sources for more up-to-date guidance or other updates.

Is Asimily Affected by Java4Shell?

Asimily has evaluated its systems and is not affected by this vulnerability.

What Is Java4Shell?

Java4Shell is a memory-corruption vulnerability in OpenJDK’s Base64 decoder, the commonly used Java functionality for decoding text-encoded data such as credentials, authentication tokens, and attachments. Under certain hardware and application conditions, specially crafted Base64 input can corrupt Java Virtual Machine (JVM) memory, potentially crashing the Java process, exposing sensitive memory contents, or enabling remote code execution (RCE). Calif calls the memory-leak form of the flaw “JavaBleed.”

Similar to PHP2Shell, Java4Shell highlights how long-standing vulnerabilities in widely used software can go undetected for years. Its recent discovery also illustrates how advances in AI-assisted security research are making it easier to identify serious flaws in established codebases. Despite the similar name, Java4Shell is unrelated to Log4Shell (CVE-2021-44228), which affected the Log4j logging library rather than the Java runtime itself.

Oracle scores the flaw 8.1 via Common Vulnerability Scoring System (CVSS), with high attack complexity and no privileges or user interaction required. Calif.io, whose researcher Oracle credits with the discovery, rates it at a higher severity. According to SecurityWeek, exploitation requires x86-64 processors with AVX-512 VBMI support, and Calif says AI tools helped it find the bug in about an hour and build a first working exploit in two more, for under $200 in total token costs.

Java4Shell at a Glance

ItemDetail
CVECVE-2026-114938
Oracle CVSS 3.1 score8.1 (high attack complexity)
Authentication requiredNone; exploitable over the network
Oracle products listedJava SE 8 (performance build), 17, 21, 25, and 27; GraalVM for JDK 17 and 21; GraalVM Enterprise Edition 21
Other Java distributionsBuilds based on OpenJDK 17.0.6 and later, per Calif; vendor fixes arrive separately
FixOracle November 2026 Critical Security Patch Update, November 17, 2026
Oracle’s advisory-wide workaroundBlock network protocols an attack requires; test changes on non-production systems first

Sources: Oracle November 2026 Critical Security Patch Update; SecurityWeek.

Why Java Is Hard to Find

Java, like the drink it evokes, rarely announces itself. It ships inside identity servers, ticketing and collaboration tools, build servers, message brokers, search platforms, and vendor appliances, often as a private runtime the application installs and updates on its own schedule. Calif, which discovered the flaw, reported that default configurations of several widely used enterprise applications were exploitable before login.

The Cybersecurity and Infrastructure Security Agency (CISA) has urged organizations to hunt for Java embedded in third-party software, containers, and appliances, which may not appear in asset inventories. For a security team, that means the real Java4Shell patch list is typically longer than the endpoint team’s list of Java installs.

A central Java runtime (JVM) connected to six places Java is often bundled: identity and access servers, ticketing and collaboration apps, build and CI/CD servers, middleware and message brokers, search and data platforms, and vendor appliances and containers.
Which Java Versions Are Affected by Java4Shell?

Java4Shell affects HotSpot-based Java runtimes from 17.0.6 onward on x86-64 processors with AVX-512 VBMI support. Patched builds start at 17.0.21.1, 21.0.13.1, 25.0.5.1, and 27.0.1.1, or the vendor equivalent. End-of-life releases in between need an upgrade to a supported version. Oracle’s Java 8 Enterprise Performance Pack build (8u511b33-perf) is also affected.

Java ReleaseAffected VersionsFixed Version or Action
Java 8 Enterprise Performance Pack8u511b33-perf8u513-perf
Java 17 (LTS)17.0.6 through 17.0.21 (Oracle’s listed affected build: 17.0.21.0.3)17.0.21.1 or vendor equivalent
Java 18, 19, 20 (EOL)All releases in these linesNo fix for these EOL lines. Upgrade to a supported, patched release, such as 21.0.13.1 or later
Java 21 (LTS)21.0.13 and earlier (Oracle’s listed affected build: 21.0.13.0.3)21.0.13.1 or vendor equivalent
Java 22, 23, 24 (EOL)All releases in these linesNo fix for these EOL lines. Upgrade to a supported, patched release, such as 25.0.5.1 or later
Java 25 (LTS)25.0.5 and earlier (Oracle’s listed affected build: 25.0.5.0.3)25.0.5.1 or vendor equivalent
Java 26 (EOL)All releases in this lineNo fix for this EOL line. Upgrade to a supported, patched release, such as 27.0.1.1 or later
Java 2727.0.1 and earlier (Oracle’s listed affected build: 27.0.1.0.3)27.0.1.1 or vendor equivalent

Standard Java 8 and Java 11 builds are not affected by CVE-2026-114938. The Java 8 exception is Oracle’s Enterprise Performance Pack build 8u511b33-perf, fixed in 8u513-perf. Java 17 releases before 17.0.6 are also not affected. The .0.3 suffixes are Oracle build identifiers; Temurin, Corretto, and other distributions use their own build numbering, so check each vendor’s advisory for its fixed build.

How Do I Check if a Server Is Vulnerable to Java4Shell?

To check a server, confirm four things: whether its CPU supports AVX-512 VBMI, whether the running JVM disables the vulnerable code path, which JVM binary and runtime type the service uses, and whether attacker-controlled Base64 input can reach the application.

Asimily detects Java runtimes and their versions in the environment where possible. A potentially affected Java version does not, by itself, mean a server is exploitable. Risk depends on several factors:

These are the other factors that need to be checked and commands you can use now to check them:

Step 1: Check CPU Architecture and AVX-512 VBMI Flags

The vulnerable code only executes on x86-64 CPUs that support the AVX-512 Vector Byte Manipulation Instructions (VBMI). If your server runs on ARM64, such as AWS Graviton, or older Intel/AMD processors, the vulnerable code path never runs.

  • On Linux hosts (or container host nodes): According to Qualys, run this command to verify if all four required CPU flags are present:
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512_?vbmi|bmi2)$'

Result: If this returns nothing, or returns fewer than all four flags, the device is not affected.

  • On Windows hosts: Run coreinfo.exe (from Microsoft Sysinternals) or check the processor model; only Intel Xeon Ice Lake (3rd Gen) or newer and AMD EPYC Zen 4 (4th Gen / Genoa) or newer expose AVX-512 VBMI.
Step 2: Inspect Effective JVM Flags on Running Processes

A server is safe if the running JVM was started with flags that disable either the Base64 intrinsic or AVX-512 instructions. Check the live flags of your running Java process ID (<PID>) rather than just startup scripts:

jcmd <PID> VM.flags

or

jinfo -flags <PID>
Step 3: Verify the Exact JVM Binary and Runtime Type

Production servers often have multiple Java installations, and services frequently use a bundled Java Runtime Environment (JRE) rather than the system PATH.

  • Confirm the running binary: Run ps -ef | grep java (Linux) or check Task Manager / Process Explorer (Windows) to find the exact path to the java executable used by each service, then run /path/to/java -version against that specific binary.
  • Check for OpenJ9: If the output says Eclipse OpenJ9 or IBM Semeru Runtime, the server is not affected because OpenJ9 does not use the HotSpot C2 compiler where this bug exists.
Step 4: Check Whether Untrusted Base64 Input Reaches the Application

The vulnerable decoder only matters when an application decodes Base64 data an attacker controls. Common paths include HTTP Basic authentication credentials, JSON Web Tokens (JWTs), SAML messages, cookies, and CSRF tokens. A Java client that connects to an attacker-controlled server over TLS can also be exposed.

How Do I Mitigate Java4Shell?

The permanent fix for Java4Shell is upgrading to a patched Java build. Until then, disabling the JVM’s Base64 intrinsic removes the vulnerable code path. The above process can be tedious to do for all systems running Java, so instead of running these processes, either of the following actions can be taken once Java is discovered:

  1. Upgrade Java to patched versions
  2. On Java 11 and later, add this option to any existing JAVA_TOOL_OPTIONS value, then restart the affected Java services:
    1. Set JAVA_TOOL_OPTIONS="-XX:-UseBASE64Intrinsics"

This neutralizes the vulnerability across both Linux and Windows without editing individual application startup configs. Do not apply this option to Java 8, which does not recognize -XX:-UseBASE64Intrinsics and can fail to start with it. The affected Java 8 Enterprise Performance Pack build needs its patch instead. If the option causes issues on Java 11 or later, -XX:UseAVX=2 is a fallback that stops the JVM from using AVX-512 instructions.

Even with the environment variable set, upgrading Java to patched versions is still good practice for all systems where patching is possible.

How Asimily Helps Teams Respond to Java4Shell

Asimily helps teams find Java runtimes and their versions across their assets, rank exposed servers by real exploitability, and contain the ones that can’t be patched yet. Attacks on systems are likely to continue to rise. Asimily is actively defending its customers against these attacks through a combination of techniques:

  1. Unified Asset Visibility across all devices, services, applications, and middleware, including Java runtimes and their versions
  2. Continuous Exposure Management specifically around IoT, Medical or OT devices
  3. Detecting threats ( malware, misconfiguration or other issues) for affected servers and assets across the environment
  4. Packet Capture and Policy Management capabilities for forensic analysis if a Java server behaves abnormally
  5. Patching and changing passwords for IoT devices
  6. Segmenting or microsegmenting the network to contain Java servers that can’t be patched yet

Asimily hopes your environments are safe or on the way there. Our customers have been in touch with their representatives on this topic and can reach out with any other related questions.

[Related: Defending Against the Next PHP2Shell: Why Patching Alone Isn’t Enough]

Secure Every IoT Device.
Automatically.

Cyber threats move fast — so should you. Asimily gives instant inventory and smart, prioritized risk mitigation insights for every IoT, OT, and IoMT device — so you can take action before threats strike.