Skip to content
Exploit for CVE-2026

Exploit for CVE-2026

Sploitus • November 17, 2026

> **Status:** Preliminary. Compiled from third-party research published 2026-11-17 (Calif, Equixly, Semgrep, Endor Labs, Upwind, JFrog, Orca, HeroDevs). Oracle does not publish root-cause details; verify specifics against the OpenJDK fix commit (JDK-8393212) and your JDK vendor's advisory before acting.

| CVE | CVE-2026-114938 (OpenJDK issue JDK-8393212) |

| Nickname | Java4Shell (also "Java2Shell") |

| Class | Heap out-of-bounds write (memory corruption) |

| Component | HotSpot x86-64 AVX-512 Base64 decode intrinsic |

| Access | Network, pre-authentication, no user interaction |

| Severity | 9.2 (CVSS 4.0, per discoverer / NCSC) — note some trackers list a lower CVSS 3.1 of 8.1 |

| Confirmed impact | JVM crash → denial of service |

| Claimed impact | Unauthenticated RCE (demonstrated privately by discoverer; independent RCE reproduction pending) |

Java is a memory-safe language: array writes are bounds-checked, so a heap overflow should be impossible in Java code. This bug lives *beneath* that guarantee, in the JVM runtime.

1. **Intrinsic substitution.** For hot standard-library methods, HotSpot's C2 JIT compiler replaces the Java implementation of `java.util.Base64.Decoder.decode()` with a hand-written, CPU-specific machine-code routine (an "intrinsic"). This routine does not carry Java's automatic bounds checking — its own length arithmetic must be exactly correct.

2. **Integer underflow in tail handling.** The AVX-512 variant of the intrinsic processes 64 bytes per iteration and uses a store mask to limit how many bytes the final partial block writes. For inputs ending in `=` padding, the computed "bytes remaining" value underflows to a negative number. The negative length is used to build the store mask, which then covers **all 64 lanes** instead of the few that remain.

3. **Out-of-bounds write.** Because the mask stores a full block, the routine writes **62–63 bytes past the end of the output array** on the Java heap.

**Key qualifier:** the overwritten bytes are produced by the decoder, **not chosen by the attacker**. The attacker controls *that* the overflow happens and roughly *where* the output buffer sits, but not the content written past it. This is the crux of the RCE-vs-DoS dispute (below).

The write corrupts adjacent heap memory — object headers, references, or allocator metadata. The JVM's integrity is violated.

### Observed outcome (independently reproduced)

**JVM crash → denial of service.** Heap corruption is not a catchable `Exception`; it takes down the entire JVM process, not a single request or thread. One crafted input can therefore take an entire service offline for all users. Multiple teams (Equixly, Upwind) have reproduced the overflow and the crash.

### Claimed outcome (discoverer, not yet independently reproduced)

**Unauthenticated remote code execution.** The discoverer (Calif) reports escalating the bounded write into attacker-useful memory corruption by combining it with a target application's own heap layout and behavior, and states it demonstrated RCE against six named enterprise products in default configurations. Calif published a proof-of-concept showing the memory corruption but withheld the weaponized per-product exploits. As of 2026-11-17, independent reproduction of full code execution is still pending, and two research teams explicitly describe code execution as unproven. The honest summary: **the overflow is confirmed; reliable, general RCE is claimed but contested.**

## Exposure conditions (all three required)

A host is only reachable by this bug if **all** of the following are true:

1. **Runtime:** OpenJDK/Java **17.0.6 or later**; the same code is present in the 21 and 25 update lines and mainline. Java 8 and 11 have no Base64 decode intrinsic and are **not affected**.

2. **CPU:** x86-64 with **AVX-512 VBMI + AVX-512 BW** (Intel Ice Lake or later, AMD Zen 4 or later) with the accelerated decoder active.

- **Not affected:** ARM (Graviton, Ampere, Apple Silicon); x86 without VBMI (Skylake/Cascade Lake Xeon, pre-Zen 4 EPYC, many desktops); x86 under emulation (Rosetta, QEMU).

3. **Reachable sink:** the application decodes **attacker-influenced Base64** (request headers, tokens, cookies, query params, uploaded fields), typically **before authentication**.

Check CPU support: `grep -o 'avx512vbmi' /proc/cpuinfo | head -1`

## Why it is invisible to application-layer tooling

The vulnerable code is correct at the application level. A plain call such as:

byte[] decoded = java.util.Base64.getDecoder().decode(token);

is used exactly as intended. SAST (SonarQube, Veracode), code review, and dependency scanning on application code will find nothing, because the defect is a runtime intrinsic substituted by the JIT — not in the source, and not in a library dependency the SBOM would flag. Detection is via **runtime inventory** (JDK version × CPU features), not static analysis.

| **Patch the JDK** | Apply the vendor's fixed build (Oracle Java SE 17.0.21 / 21.0.13 / 25.0.5 per the Nov 17 CPU; some reports cite 17.0.21.1 — confirm against your vendor). Then **restart every JVM and rebuild container images** — a running JVM keeps the vulnerable intrinsic until restart. |

| **Stopgap (test first)** | `-XX:-UseBASE64Intrinsics` forces the safe Java decoder (small performance cost). `-XX:UseAVX=2` disables all AVX-512 (larger cost). No vendor has formally confirmed either flag for this CVE — test before deploying. Verify applied flags with `java -XX:+PrintFlagsFinal -version`. |

| **Reduce exposure** | Restrict network reach of Java services; consider a WAF rule rejecting malformed/over-padded Base64 in Basic-auth values. |

| **App hardening (defense in depth)** | Bound the length of encoded input and reject malformed padding early (e.g., in an auth filter). Does not fix the bug, but shrinks the attack surface. |

**Prioritize by exposure, not CVSS:** fix hosts meeting all three exposure conditions first, internet-facing services before internal ones.

C2 JIT has substituted the AVX-512 Base64 intrinsic

Tail-length arithmetic underflows → store mask covers all 64 lanes

62–63 bytes written past end of output array on the heap

│ (bytes decoder-chosen, not attacker-chosen)

├─► JVM crash → DoS (confirmed, independently reproduced)

└─► Memory disclosure / RCE (claimed by discoverer; contested)

- Calif (discoverer): and

- Equixly:

- Semgrep:

- Endor Labs:

- Upwind:

- HeroDevs:

- Orca Security:

- BleepingComputer:

- Verify against: CVE.org record, NVD (CVE-2026-114938), Oracle November 2026 CPU, OpenJDK fix JDK-8393212

Extracted Entities

Attack Types (1)

Domains (1)

IP Addresses (1)

Platforms (3)

Vulnerabilities (1)