# Java4Shell (CVE-2026-114938): Check Exposure, Patch and Apply the Workaround

> A defensive guide to Java4Shell (CVE-2026-114938): how to check your Java version and CPU, which builds fix it, and the interim JVM flag until you patch.

Source: https://www.epifive.com/blog/java4shell-cve-2026-114938-openjdk-check-patch-workaround · Published 2026-11-19 · EpiFive

## Key takeaways

- Java4Shell (CVE-2026-114938) is an out-of-bounds write in OpenJDK's optimized Base64 decoder, disclosed on 17 November 2026.
- Exposure needs an affected Java build, an x86-64 CPU with AVX-512 VBMI, and a code path that decodes untrusted Base64; ARM64 is not affected.
- Oracle's reported fixed builds are 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1, and other vendors ship their own version numbers.
- The interim workaround is the JVM flag -XX:-UseBASE64Intrinsics, which needs a process restart and is not documented by Oracle or OpenJDK.
- Bundled runtimes in applications, appliances and container images are the usual blind spot, so check the running process, not the shell's default Java.

Java4Shell is the nickname for CVE-2026-114938, an out-of-bounds write in the optimized Base64 decoder of OpenJDK, disclosed on 17 November 2026. You are only at risk if an affected Java build runs on an x86-64 CPU with AVX-512 VBMI and your application decodes untrusted Base64 input. The fix is to update to a patched runtime and restart every Java process; until then a JVM startup flag can switch off the vulnerable code path.

This is a defensive guide. It contains no exploit details and links to no proof-of-concept code. It is a companion to [Oracle November 2026 CSPU: What to Patch First](https://www.epifive.com/blog/oracle-november-2026-cspu-what-to-patch-first), which covers the wider Oracle patch release in which this issue was reported.

## Who this is for and what you will have at the end

This is for sysadmins, security engineers, DevOps teams and small IT shops that run Java servers, build agents, containers, or products that bundle a Java runtime. By the end you will have answered "am I affected?" with three checks, chosen a patch order, know the interim workaround and its limits, and have a way to verify that the running processes picked up the change.

A note on sourcing. The facts below come from Tenable's FAQ, Qualys's guidance and Datadog Security Labs, all opened on 2026-11-19. Oracle's advisory returned HTTP 403 to automated fetching in earlier work, so Oracle's own figures are quoted as reported by those sources. Sources also disagree in places, and this article says where.

## What the vulnerability is

According to Tenable, the flaw is in a performance shortcut that decodes Base64, where crafted input writes past its allocated memory. Datadog describes it as an out-of-bounds write in OpenJDK's optimized Base64 decoder and says denial of service is more readily achievable than reliable code execution, because code execution needs additional, application-specific work. The headline "remote code execution" label is therefore a worst case, not a universal outcome.

Two scores are in circulation:

| Source | Score | Notes |
|---|---|---|
| Oracle | CVSS 3.1 base 8.1 | High attack complexity, per Tenable |
| Calif (the reporting researchers) | CVSS 4.0 base 9.2 | Reported as Critical by Datadog |

Do not argue over which number is right. Both are high enough to schedule patching, and the real question is whether your systems meet the conditions in the next section.

## Check 1: Are you running an affected Java version?

Tenable says the OpenJDK Vulnerability Group lists the Java 17, 21, 25 and 27 release lines, while Calif says OpenJDK 17.0.6 and newer. Qualys likewise lists unpatched builds from 17.0.6 onward and says releases before 17.0.6, including standard OpenJDK 8 and 11, are not affected. Oracle also lists the Java SE 8 Enterprise Performance Pack (8u511b33-perf) as affected. Oracle says earlier builds are likely affected too.

Datadog's table gives the first fixed release per line:

| Java line | Affected | First fixed release |
|---|---|---|
| Java 17 | 17.0.6 up to before 17.0.21.1 | 17.0.21.1+4 |
| Java 21 | All before 21.0.13.1 | 21.0.13.1+4 |
| Java 25 | All before 25.0.5.1 | 25.0.5.1+4 |
| Java 27 | All before 27.0.1.1 | 27.0.1.1+4 |

Check the version on each host:

```bash
java -version
```

The first line shows the version string, for example `openjdk version "17.0.21"`. That example would be affected, because the fixed release is 17.0.21.1. This only tells you about the Java on the shell's PATH. Applications often ship or point at a different runtime, which is covered under bundled runtimes below.

### Check the running process, not the shell

Datadog advises checking the running process, including any bundled runtime. Find the process ID and ask the JVM directly:

```bash
jcmd <PID> VM.version
```

The output includes the JVM's own version information for that process. Use this wherever `java -version` and the application could point at different installations.

## Check 2: Does the CPU support AVX-512 VBMI?

All three sources agree that only x86-64 processors with AVX-512 VBMI are affected, and that ARM64 is not. Tenable cites Calif's list: Intel Xeon (Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids) and AMD Zen 4 or newer. Qualys phrases the AMD side as EPYC and Ryzen (Zen 4 and newer).

On Linux, Qualys gives this check for the four CPU flags it names:

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

Qualys says the host meets the hardware condition only if all four flags appear. Datadog gives a shorter test for the VBMI flag alone:

```bash
grep -om1 -E 'avx512[_]?vbmi' /proc/cpuinfo
```

No output means the CPU does not support VBMI. Output containing `avx512vbmi` or `avx512_vbmi` means it does, and the host may be vulnerable.

None of the pages we opened gives a Windows command for this check. On Windows, look up your processor model against the vendor lists above.

Qualys adds a caution worth following: treat the CPU check as a way to prioritize work, not to close a finding. A workload can move to affected hardware later, for example when a cloud instance type changes or a container is rescheduled. Tenable makes a related point: its scanner plugins check Java versions and do not account for the processor requirement, so scan results may list hosts that are not actually exposed.

## Check 3: Does the application decode untrusted Base64?

Datadog says the application must pass attacker-controlled data to the vulnerable decoder. In the 17.0.6 build its authors tested, the basic and URL decoders are affected and the MIME decoder bypasses this path. Base64 is everywhere in web software: tokens, basic authentication headers, file uploads, API payloads. If a Java service accepts such data from the network, assume it reaches the decoder.

Qualys states that reverse proxies are not a reliable control and that input-size limits alone will not stop the bug. Do not treat a proxy in front of the service as a reason to delay.

## Decide the order

| Situation | Priority |
|---|---|
| Internet-facing Java service, affected build, AVX-512 VBMI CPU | Patch or apply the workaround first |
| Internal Java service, affected build, AVX-512 VBMI CPU | Next, in the same window if possible |
| Affected build, CPU without VBMI or ARM64 | Patch in the normal cycle |
| Java 8 or 11 standard builds | Not listed as affected; patch in the normal cycle |

## Patch

### Oracle and OpenJDK builds

Tenable and Qualys both report these Oracle fixed versions: 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1, plus 8u513-perf for the Java 8 Enterprise Performance Pack. GraalVM for JDK is reported fixed in 17.0.21.1 and 21.0.13.1.

Be aware that sources disagree on one point. Earlier coverage of Oracle's November update said Oracle had not tied the CVE to its listed fixes, and Sonatype and Orca said the timing of the update did not by itself establish which build addresses the issue. Tenable and Qualys, which were updated later, list the fixed builds above. Confirm against the advisory for your distribution.

### Other distributions

Other vendors number their builds differently. Qualys reports Amazon Corretto 17.0.21.1.2 as carrying the fix as of 17 November 2026. Tenable (updated 18 November) says Amazon Corretto and Azul Zulu have released fixes, Eclipse Temurin has begun, and Red Hat and Ubuntu had not yet, while Debian had fixed only its unstable branch. Check your distribution's advisory and confirm that it names CVE-2026-114938 before you mark a host done.

### Bundled runtimes

Datadog and Qualys both stress runtimes bundled inside applications and container images. For containers, update the base image, then rebuild and redeploy. For applications that bundle their own JRE, such as application servers, identity providers, CI servers and vendor appliances, the fix has to come from the vendor. Check each vendor's advisory for this CVE rather than updating the system Java and assuming the product follows. Tenable notes that Keycloak recommends the Base64 flag below as an interim mitigation, which is an example of a vendor publishing guidance for its own product.

## Interim workaround until you can patch

Both Tenable and Datadog describe two temporary JVM startup flags that originate with Calif. Datadog says its authors tested them to prevent the out-of-bounds writes. Tenable notes that neither Oracle nor the OpenJDK advisory mentions them, and Orca says they are not validated by Oracle or OpenJDK as a fix.

| Flag | Scope | Notes |
|---|---|---|
| `-XX:-UseBASE64Intrinsics` | Narrower: turns off the Base64 shortcut | Java falls back to its standard decoder; large Base64 workloads may slow down |
| `-XX:UseAVX=2` | Broader: limits the JVM to AVX2 | x86-64 only; Java on ARM may fail to start with it; affects other AVX-512 optimizations |

Prefer the first flag. Add it wherever the application defines its JVM options, using the product's documented mechanism for extra JVM arguments:

```text
-XX:-UseBASE64Intrinsics
```

Then restart the service. Qualys is explicit that running Java processes stay exposed until restarted, even after a patch or flag is applied. Test first on a non-production copy, because the flag changes performance characteristics, and scope `-XX:UseAVX=2` to x86 deployments only, since an ARM64 JVM does not recognize it.

### Verify the flag took effect

Datadog's verification uses the running process:

```bash
jcmd <PID> VM.flags -all
```

Look in the output for `UseBASE64Intrinsics = false` if you used the narrower flag, or `UseAVX = 2` if you used the broader one. If the line is missing or shows the default, the process did not pick up your change, usually because the service was not restarted or the option was set in the wrong place.

## After patching: verify and record

1. Restart every affected Java process so it loads the updated runtime.
2. Run `jcmd <PID> VM.version` against the running process and compare it with the fixed release for that line.
3. Rebuild and redeploy container images from updated base images, then check the image, not the host.
4. Remove the temporary flag in a later change window if you added one, so your configuration does not carry an undocumented override forever.
5. Record each exception with an owner and an end date for any host you cannot update yet.

## Troubleshooting

- **The service will not start after adding `-XX:UseAVX=2`.** You are probably on ARM64, where the option is not recognized. Remove it and use `-XX:-UseBASE64Intrinsics` instead.
- **`VM.flags` does not show the flag.** The process was not restarted, or you are inspecting a different PID than the one that serves traffic. Check the process list for wrapper scripts that start a child JVM.
- **The scanner flags hosts that are fine.** Tenable says its plugin detections check Java versions and do not account for the processor requirement. Use the CPU check above to rank findings, and patch anyway.
- **The vendor has no fixed build yet.** Ask the vendor for guidance, apply the Base64 flag if the product supports custom JVM options, and restrict network access to the service in the meantime.
- **Java 8 or 11 shows up in a scan.** The OpenJDK advisory does not list standard Java 8 or 11. Qualys states they are not affected. Oracle's Java 8 Enterprise Performance Pack is the exception.

## Exploitation status

Tenable reported on 2026-11-18 that the CVE was not in CISA's Known Exploited Vulnerabilities catalog, that GreyNoise reports exploitation attempts but no confirmed successful exploitation, and that VulnCheck says a working exploit is available to its customers. Qualys notes there is no public confirmation of exploitation in the wild and advises not to plan around that. Status changes quickly, so check the catalog and your vendors on the day you decide.

## What we checked

- Opened Tenable's Java4Shell FAQ on 2026-11-19 (updated by Tenable on 2026-11-18): disclosure on 17 November 2026, scores of 8.1 (Oracle, CVSS 3.1) and 9.2 (Calif, CVSS 4.0), and the two workaround flags.
- Opened Qualys's guidance on 2026-11-19 and compared its fixed versions (17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1, 8u513-perf) with Tenable's list: they match.
- Opened Datadog Security Labs on 2026-11-19 and compared its fixed-release table with the Qualys and Tenable versions: the same four lines and the same fixed numbers, with Datadog adding the +4 build suffix.
- Compared the affected range across three pages: Tenable, Qualys and Datadog all give 17.0.6 and later for the OpenJDK lines, ARM64 not affected, and Java 8 and 11 not listed.
- Compared the CPU checks: Qualys uses a four-flag grep (avx512f, avx512bw, avx512vbmi, bmi2) and Datadog a single VBMI grep. They test overlapping but not identical conditions, which is why both are shown.
- Documented outputs for the commands, as described by Datadog: no output from the VBMI grep means no VBMI support, and `jcmd <PID> VM.flags -all` should show `UseBASE64Intrinsics = false` or `UseAVX = 2` after the workaround. We did not capture real command output.
- Not checked: the Oracle and OpenJDK advisories themselves (not opened), vendor advisories for Temurin, Zulu, Red Hat, Ubuntu or Debian beyond what Tenable reports, and none of the commands were run on a live system.

Last tested: 2026-11-19

## References

- Tenable, Java4Shell (CVE-2026-114938) FAQ: https://www.tenable.com/blog/java4shell-cve-2026-114938-frequently-asked-questions-about-openjdk-rce-vulnerability
- Qualys, How to Find, Mitigate, and Patch Java4Shell: https://blog.qualys.com/vulnerabilities-threat-research/2026/11/17/how-to-find-mitigate-and-patch-the-critical-java4shell-flaw-cve-2026-114938-now
- Datadog Security Labs, Java4Shell: https://securitylabs.datadoghq.com/articles/java4shell-remote-code-execution-in-openjdk-cve-2026-114938.md
- Oracle Critical Security Patch Update advisory, November 2026: https://www.oracle.com/security-alerts/cspunov2026.html
- Sonatype, Critical OpenJDK RCE CVE-2026-114938: What to Know: https://www.sonatype.com/blog/critical-openjdk-rce-cve-2026-114938-what-to-know

## Frequently asked questions

### Am I affected by Java4Shell (CVE-2026-114938)?

You are exposed only if three things are true: you run an affected OpenJDK-based build (the 17, 21, 25 and 27 lines before the fixed releases), the process runs on an x86-64 CPU that supports AVX-512 VBMI, and the application passes untrusted data to the Base64 decoder. ARM64 Java is not affected, and the OpenJDK advisory does not list standard Java 8 or 11, according to Tenable and Qualys.

### Which Java versions fix CVE-2026-114938?

Oracle's reported fixed builds are 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1, plus 8u513-perf for the Java 8 Enterprise Performance Pack. Qualys reports Amazon Corretto 17.0.21.1.2 as fixed. Other vendors use their own version numbers, so confirm that the vendor advisory names the CVE.

### Can I mitigate Java4Shell without patching?

The researchers who published the issue describe two temporary JVM startup flags: -XX:-UseBASE64Intrinsics, the narrower option, and -XX:UseAVX=2, which is broader and works on x86-64 only. Neither Oracle nor the OpenJDK advisory documents them as a fix, and you must restart each Java process for them to take effect. Treat them as a bridge to the patch.

### Is Java4Shell being exploited in the wild?

As of 2026-11-18, Tenable reported that the CVE was not in CISA's Known Exploited Vulnerabilities catalog, while GreyNoise reported exploitation attempts without confirmed successful exploitation. Qualys advises not to plan around the absence of confirmed exploitation. Re-check the catalog before you decide on urgency.

