TLP:CLEARCTI Vulnerability Alert: CVE-2026-114938 "Java4Shell" (Java / OpenJDK Base64)Page 1 of 9

CTI VULNERABILITY ALERT · CONFIRMED · v1.3

Ghost in the Runtime

CVE-2026-114938 — "Java4Shell" — is now public and confirmed: a heap buffer overflow in the HotSpot AVX-512 accelerated Base64 decoder (java.util.Base64). Malformed Base64 overruns the output array by 62–63 bytes. The finder (Calif) claims unauthenticated RCE; independent teams reproduced the overflow, not code execution. It is bounded: only HotSpot Java 17.0.6+ / 21 / 25 / 27 on x86-64 with AVX-512 VBMI, where attacker data reaches a Base64 decoder. Java 8, 11, 17.0.0–17.0.5 and ARM are not affected. Patch, or disable the intrinsic, now.

Author
Douglas Mun with AI assistance
Issued
18 Nov 2026, ~22:00 SGT
Version
1.3 (fix commit verified)
Information cut-off
18 Nov 2026, 21:00 SGT (18 Nov 13:00 UTC)
Marking
TLP:CLEAR
Still only inventory and stage?
No — patch
or mitigate now.
The pre-disclosure caveats are resolved: the flaw is real and the component is named. The finder claims pre-auth RCE; independent teams reproduced the heap overflow but not code execution. It is not "any Java 17 server" — exploitation needs an AVX-512 VBMI x86-64 CPU with the intrinsic active and attacker bytes reaching a java.util.Base64 decoder (KJ-2). Where that holds, patch to the November build now, or set -XX:-UseBASE64Intrinsics as an interim fix.
9.2CVSS 4.0 (Critical), per the finder / NCSC. Oracle's max Java SE CVSS 3.1 this release is 8.1; official per-CVE matrix still pending
62Bytes written past a 50-byte output array (offsets 50–111) for the 64×"A"+"=" trigger; a full 64-byte store
17.0.6+Affected HotSpot line, plus 21/25/27, on AVX-512 VBMI x86-64 only. Not 8, 11, 17.0.0–17.0.5 or ARM
0Confirmed in-the-wild exploitation at cut-off; not in CISA KEV. Finder PoC withheld; RCE not independently reproduced

Changes in v1.3

  • Fix commit verified: the patch is JDK-8393212, commit 5177a70b (pushed 16 Nov 2026) — the cmpl length,4 / jcc less,L_bruteForce guard at line 3395, confirmed against the OpenJDK tree. The “exact commit unverified” hedge is resolved.
  • The commit's own comment confirms the trigger shape (a valid padded tail shorter than one block), vindicating v1.2's correction.
  • Reported, single-source: a fixed overflow pattern (0x9a 0x69 0xa6 repeating) as a forensic IOC, and a ~200k-invocation C2 warm-up — not reproduced here. Elasticsearch added to the finder's named targets.

Confirmed vs open

  • Confirmed: the component (java.util.Base64 AVX-512 decode intrinsic), the 62–63-byte heap overflow (reproduced here under ASan), the AVX-512/x86-64 precondition (shown by a negative control), the 8/11/ARM exclusion, and the -XX:-UseBASE64Intrinsics mitigation — all cross-checked against OpenJDK source.
  • Still open: Oracle's final risk matrix and official CVSS 3.1 vector, the NVD enrichment, whether 9.2 (4.0) and 8.1 (3.1) are the same scored bug, and how common an exploitable app is in the wild (G-5).

Keys

Confidence in a judgementHighModerateLow
Status of a factConfirmedReportedOpen

Likelihood follows ICD 203: unlikely 20–45%, likely 55–80%, very likely 80–95%. Confidence is kept separate from likelihood and rests on source quality and corroboration. Source grades (Admiralty) are on page 6.

WhatCVE-2026-114938 "Java4Shell": a heap buffer overflow in the HotSpot AVX-512 Base64 decode intrinsic behind java.util.Base64. Malformed input overruns the output array by 62–63 bytes.
Who found itCalif (the PHP2Shell team), published 17 Nov; independently analysed by Oligo, Semgrep, Equixly, JFrog and watchTowr.
AffectedHotSpot Java 17.0.6+, 21, 25, 27 on x86-64 with AVX-512 VBMI. Not stock Java 8/11, 17.0.0–17.0.5 or ARM64 — bar the Java SE 8 Perf Pack (p3).
WhenDisclosed 17 Nov 2026 with Oracle's November Critical Security Patch Update. CVE enrichment and Oracle risk matrix still landing.
Why it mattersBase64 decoding of untrusted input is everywhere — tokens, headers, uploads, JSON/XML payloads. Where the hardware and a reachable decoder line up, this is a pre-auth memory-corruption RCE.
ExploitationFinder claims pre-auth RCE in its own testing; independent teams reproduced the overflow, not RCE; PoC withheld. No in-the-wild use and not in CISA KEV at cut-off.
Five questions, short answers
Is this confirmed real?
Yes. The CVE is public, the finder (Calif) and six independent teams have analysed it, and the flawed code is visible in OpenJDK. The uncertainty is now in the formal records (Oracle matrix, NVD), not the flaw.
Are we exposed?
Only if three things line up: a HotSpot JVM on the affected lines, an x86-64 CPU with AVX-512 VBMI (the intrinsic is on by default there), and attacker-controlled bytes reaching a java.util.Base64 decoder. ARM and non-AVX-512 x86 are not exploitable this way.
Only Java 17?
No — 17.0.6+, 21, 25 and 27 carry the intrinsic (also mainline ≥18). 17.0.0–17.0.5 and stock Java 8/11 lack it and are not affected. One exception: the Java SE 8 Enterprise Performance Pack 8u511b33-perf backported it and is affected (fixed 8u513-perf; detail p3).
Is there a workaround?
Yes, now. Start the JVM with -XX:-UseBASE64Intrinsics (preferred) or -XX:UseAVX=2 to force the safe scalar decoder. It is a mitigation, not a fix — still patch.
What do we do now?
Patch to the November build, or apply the flag where patching lags. Prioritise internet-facing services that decode Base64 from untrusted input on AVX-512 hosts. Watch for java.util.Base64 decoder crashes (page 4).
TLP:CLEAR — may be shared publicly, without restrictionGhost in the Runtime · CVE-2026-114938 · v1.3
TLP:CLEARCTI Vulnerability Alert: CVE-2026-114938 "Java4Shell" (Java / OpenJDK Base64)Page 2 of 9

Key judgements: a confirmed flaw; RCE is the finder's claim — serious where the hardware and decoder line up

KJ-1

The vulnerability is confirmed and multiply sourced; the v1.0 single-source caveat no longer applies.

— · High

The finder, Calif, published a technical account on 17 Nov, and Oligo, Semgrep, Equixly, JFrog and watchTowr produced independent analyses within hours; downstream projects have already begun disabling the intrinsic. The flaw is the AVX-512 Base64 decode intrinsic behind java.util.Base64 — a claim we verified directly against the public OpenJDK source (page 3, page 5). The earlier chain back to one unpublished NCSC advisory is superseded.

Gap (G-1) closed. Residual: Oracle's and NVD's formal records had not published the per-CVE matrix at cut-off (G-4, below).

KJ-2

Pre-auth RCE is the finder's claim, not yet independently reproduced; the overflow is, and reachability is bounded by CPU and input path.

Overflow confirmed; RCE unproven · Moderate

The finder's write-up details a full chain: the fixed-byte overwrite corrupts an adjacent array's length (a "writer"), escalated to a chosen-value heap write, then a heap-disclosure primitive they call "JavaBleed" (leaking keys, tokens and PII before any code execution), and on to the Code Cache / JVM hooks for RCE — which the finder says it demonstrated against Keycloak, Jira, Jenkins and Elasticsearch via remote heap grooming. But each weaponised chain is bespoke per target and sensitive to network timing; Calif calls it "not a universal point-and-shoot". IONIX independently reproduced the underlying out-of-bounds write (fixed-pattern bytes) but not the full chain. So a crash is the easy outcome; heap disclosure and RCE are the finder's claims, shown only in its own testing and not yet independently reproduced. Our own lab confirms this split: a logic-level C model of the exact tail arithmetic reproduces the 62-byte out-of-bounds write under AddressSanitizer in under an hour (appendix, p7), but we did not achieve RCE — consistent with "overflow confirmed, RCE unproven". All of it needs an x86-64 AVX-512 VBMI CPU with the intrinsic active (default there) and attacker bytes reaching a java.util.Base64 decoder; ARM and non-AVX-512 hosts are out of scope.

Gap (G-2) closed on component/vector; a reproducing PoC is now public. Residual: the weaponised per-product RCE chains are held back, so independent end-to-end RCE confirmation is pending.

KJ-3

The 9.2 (CVSS 4.0) and Oracle's 8.1 (CVSS 3.1) are very likely one bug under two systems — but Oracle has not mapped the CVE, so the link is the finder's.

— · High

Both figures describe one memory-corruption flaw; the CVSS 4.0 9.2 sits above Oracle's 3.1 8.1 because 4.0 weighs the hardware-and-input attack requirements differently. This is likely but not Oracle-confirmed: Calif lists the affected Oracle Java SE builds and an OpenJDK advisory shipped, but Oracle's notice carries no CVE IDs and has not mapped this CVE to any of its 11 fixes. Treat "the November release fixes -114938" as the finder's mapping, not Oracle's. Only the public NVD record and Oracle's per-CVE matrix page were still propagating at cut-off.

Gap (G-4): the official CVSS 3.1 vector string and NVD enrichment were not yet public at cut-off; the version mapping is the finder's, as Oracle lists no CVE IDs.

KJ-4

No in-the-wild exploitation is evident at cut-off, but the public-PoC clock has started.

— · High

No in-the-wild report (KEV, vendor and public feeds checked 17 Nov 21:30 UTC) and no public exploit code; the finder is withholding the PoC until patches propagate. This is an evidence claim: a working private exploit exists, the defect is a short, well-understood overflow, and comparable Calif disclosures (PHP2Shell) saw exploitation within about a week. Treat the coming days as the high-risk window.

Gap (G-3): no constituency telemetry tied to this flaw. A KEV listing, a public PoC, or a decoder-crash cluster would move this sharply.

Keep it separate from October's eMudhra certificate issue (CVE-2026-91403)

Different flaw, different fix. In late October, Oracle and the OpenJDK group patched CVE-2026-91403 (CVSS 3.1 9.1) — a JSSE trust-store problem from compromised eMudhra intermediate CA certificates, fixed by blocking those certificates. Some coverage conflated it with "a critical Java memory flaw"; it is not this one. CVE-2026-114938 is a code-execution fix (upgrade the runtime or disable the intrinsic), not a certificate-trust fix. Confidence High — the distinction rests on the dates, scores, components and the October advisories, all confirmed.

Where the judgements sit

unlikely 20–45% even likely 55–80% very likely 80–95% KJ-2/3 Bounded flaw; RCE unproven; 9.2≈8.1 KJ-1 · KJ-4 are evidence claims (confirmation, exploitation), not probabilities — not placed on the scale.
Marker colour shows confidence: orange Moderate. KJ-2 and KJ-3 are the forward-looking judgements; KJ-1 and KJ-4 state what the evidence does and does not show at cut-off.
TLP:CLEAR — may be shared publicly, without restrictionGhost in the Runtime · CVE-2026-114938 · v1.3
TLP:CLEARCTI Vulnerability Alert: CVE-2026-114938 "Java4Shell" (Java / OpenJDK Base64)Page 3 of 9

The component, confirmed in the open source: the AVX-512 Base64 decode intrinsic

OpenJDK is developed in the open, and the flaw is in code that has been public for years. The vulnerable routine is generate_base64_decodeBlock() in src/hotspot/cpu/x86/stubGenerator_x86_64.cpp — the hand-written AVX-512 VBMI fast path that the JIT substitutes for java.util.Base64.Decoder.decode(). We confirmed the intrinsic and its 17.0.6 introduction in the OpenJDK source; the tail-handler mechanism below follows the public analyses and the shipped fix hunk (page 5).

  • When it runs. HotSpot auto-enables the intrinsic when UseAVX > 2 and the CPU supports AVX-512 VL and BW (the decode path additionally uses VBMI). On such CPUs it is on by default; elsewhere the JVM falls to a safe scalar loop. This is the whole reason ARM and non-AVX-512 x86 are not exploitable here.
  • The defect (page 5 has the code). In the 1–63-byte tail handler, the output length is computed as (len/4)*3 and then decremented once per trailing '=' with no floor at zero. A final fragment of 1–3 bytes ending in '=' drives it to −1 or −2; the store mask is derived from that via BZHI, which reads only the low 8 bits of the index, so the mask becomes all-ones and a full 64-byte vector store lands 62–63 bytes past the output byte[]. Lab subtlety: both −1 and −2 truncate to the same all-ones mask, so it is the array size (smaller for "=="), not the length, that moves the overrun between 62 and 63.
  • Trigger (as reported by Oligo / Equixly). A Base64 string ending in '=' whose length is 1–3 more than the intrinsic's block size — the canonical illustration is 64 Base64 characters plus one '=' (65 bytes), which overruns by 62 — reported around 65–67 bytes on Java 21/25, with a longer trigger tail on Java 17 — decoded by a basic or URL Base64 decoder. Base64 is decoded before login all over: HTTP Basic headers, JWTs, SAML assertions — hence "pre-auth".
  • Lab caveat on the canonical string. The literal 64×"A"+"=" is rejected by java.util.Base64 up front (wrong 4-byte ending unit) — a lone '=' after a full quad is not valid Base64. It stays the clearest arithmetic illustration; the real trigger is a well-formed padded string whose final fragment reaches the tail handler.
What the over-wide store mask writes (canonical 64×"A"+"=" case) masked AVX-512 store — a full 64 bytes from offset 48 output byte[] — 50 bytes allocated 62 bytes written out of bounds offset 50 — array ends offset 111 — last byte written offset 0
The mask should expose only the final decoded bytes; the underflow turns it all-ones, so a full 64-byte vector lands from offset 48 and 62 bytes fall past the 50-byte array. Java 21/25 case; Java 17's trigger tail is longer.

Why 17.0.6 is the floor: the AVX-512 VBMI decode path (JDK-8268276, backported to 17u) arrived at 17.0.6 — absent at jdk-17.0.5-ga, present at jdk-17.0.6-ga; 17.0.0–17.0.5 shipped without it. Stock Java 8/11 have no Base64 decode intrinsic — the exception is Oracle's Java SE 8 Enterprise Performance Pack, which backported it: 8u511b33-perf is affected (fixed 8u513-perf).

Affected lines and the November fixed builds

From Oracle's November CSPU and the OpenJDK schedule. The November update carries 11 Java SE fixes across all lines; the Affected by -114938 column flags which lines carry this bug (the Base64 intrinsic), as distinct from lines that get the update for other fixes.

Java lineBaselineNov fixed build-114938?Notes
8 (LTS)8u5118u513PerfStandard 8 has no intrinsic; Oracle lists 8u511-perf as affected.
11 (LTS)11.0.3311.0.33.1NoNo Base64 intrinsic. Update is for other CVEs.
17 (LTS)17.0.2117.0.21.1Yes17.0.6+ only, on AVX-512 VBMI x86-64.
21 (LTS)21.0.1321.0.13.1YesTrigger reported at 65–67-byte tails.
25 (LTS)25.0.525.0.5.1YesSame intrinsic as mainline.
2727.0.127.0.1.1YesCurrent feature release.

Because the flaw is in shared OpenJDK code, the finder lists every mainstream distribution as vulnerable: Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat OpenJDK, Oracle OpenJDK, Oracle Java SE and Oracle GraalVM. Calif lists these as the affected Oracle builds; Oracle's own notice carries no CVE IDs: 8u511-perf, 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3, 27.0.1.0.3. Each distribution ships fixed builds on its own schedule and may use different numbers, so track your vendor's advisory. The same hardware/decoder preconditions apply to all.

Timeline

WhenEventStatus
17 Jan 2023OpenJDK 17.0.6 ships the AVX-512 VBMI Base64 decode path — start of the affected 17u rangeConfirmed
24 Oct 2026eMudhra certificate advisory (CVE-2026-91403) — a separate JSSE trust issueConfirmed
~12 Nov 2026Oracle Nov CSPU pre-release: 11 Java SE fixes, max 8.1, all no-auth networkConfirmed
17 Nov 2026NCSC/NIS advisory flags a coming Java flaw; CVE-2026-114938 reservedConfirmed
17 Nov ~13:00 PT
(18 Nov ~05:00 SGT)
Oracle November release; OpenJDK advisory; Calif publishes "Java4Shell: Write once, RCE everywhere" (technical write-up; weaponised PoC withheld); Oligo, Semgrep, Equixly, IONIX, JFrog, watchTowr analyseConfirmed
Cut-off 17 Nov 21:30 UTCFinder-listed affected versions in hand (Oracle lists no CVE IDs); public NVD enrichment and official CVSS 3.1 vector still propagating; no in-the-wild use; not in KEVOpen
TLP:CLEAR — may be shared publicly, without restrictionGhost in the Runtime · CVE-2026-114938 · v1.3
TLP:CLEARCTI Vulnerability Alert: CVE-2026-114938 "Java4Shell" (Java / OpenJDK Base64)Page 4 of 9

Response: patch the affected lines, or disable the intrinsic where patching lags

HotSpot Java 17.0.6+ · 21 · 25 · 27? the lines that carry the Base64 intrinsic Not affected: Java 8 std · 11 · 17.0.0–17.0.5 · any ARM64 build no yes x86-64 CPU with AVX-512 VBMI? Intel Ice Lake+ / Sapphire Rapids · AMD Zen 4+ Buggy path never runs — not exploitable (ARM, older Xeon, AVX-512 off) no yes Base64 intrinsic left on? (default) no -XX:-UseBASE64Intrinsics / -XX:UseAVX=2 Flag set → mitigated (still patch) no yes IN SCOPE — patch now (or set the flag) if untrusted Base64 can reach a java.util.Base64 decoder
Is this host in scope? All three gates must hold; the input-path question (untrusted Base64 reaching a decoder) is the one to judge per service.
IDActionOwnerByCheck
M-1Inventory Java runtimes — standalone JDK/JRE, app-bundled runtimes, container images, embedded JVMs. Record line, build, CPU and architecture (flag AVX-512 VBMI x86-64 hosts).System owners24 hAsset list reconciled against running processes and host CPU flags
M-2Prioritise internet-facing services on affected lines that decode Base64 from untrusted input (tokens, auth headers, uploads, serialised/JSON/XML payloads) on AVX-512 hosts.SOC + owners24 hExposure list ranked by CPU + decoder reachability
M-3Patch to the November build per line (page 3): 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1, or the equivalent from your JDK vendor.Platform owners72 hjcmd <PID> VM.version shows the fixed build
M-4Where patching lags, disable the intrinsic: add -XX:-UseBASE64Intrinsics (preferred) or -XX:UseAVX=2 to the JVM start-up. Mitigation, not a fix — do not skip the patch. Do not set UseAVX=2 on ARM JVMs (they refuse to start).Platform ownersInterimFlag present in effective command line; decoder crashes stop
M-5Confirm the official mapping at release: read Oracle's risk matrix and the CVE/NVD record for the CVSS 3.1 vector and the exact affected/fixed ranges; adjust prioritisation if they differ from this alert.CTI + SOCRelease + 24 hMatrix read; deltas, if any, circulated
M-6Reduce exposure for anything unpatched and unflagged: restrict untrusted-facing endpoints behind firewalls, security groups and allowlists.NetworkInterimRule in place; exposure re-scanned
# Is this host's CPU even capable? All four flags must appear, else out of scope grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$' # Inventory, then confirm the running build and whether the intrinsic is active java -version jcmd <PID> VM.version # exact build of a running JVM java -XX:+PrintFlagsFinal -version | grep -E 'UseBASE64Intrinsics|UseAVX' # Interim mitigation (restart required): JAVA_TOOL_OPTIONS="-XX:-UseBASE64Intrinsics" # forces the safe scalar decoder

Detection: hunt for the decoder crashing, not for an IOC

There are no network IOCs — the payload is ordinary-looking Base64. The signal is the overflow failing rather than succeeding: a JVM on an affected line producing hs_err_pid crash dumps (faulting frame in or near StubRoutines::_base64_decodeBlock), or bursts of IllegalArgumentException / ArrayIndexOutOfBoundsException from java.util.Base64$Decoder — attempts or instability, not compromise. Keep the generic Java-RCE behavioural alerts too: child processes of Java service accounts (shells, curl/wget, scripting hosts) and unexpected outbound connections from Java hosts. Note on proxies: buffering the request body before forwarding (nginx default) disrupts some remote-grooming profiles, but single-request targets (Elasticsearch, post-upgrade WebSocket) bypass it — defence-in-depth, not a fix.

Intelligence gaps, tied to the judgements

GapWhat it blocksWhat would close it
G-1 (KJ-1)Closed — component and flaw confirmed, multi-source and verified in OpenJDK source—
G-2 (KJ-2)Closed on component/vector; open on real-world exploit reliabilityThe withheld PoC, or independent exploitation testing
G-3 (KJ-4)Whether exploitation is occurringKEV listing, a public PoC, or decoder-crash telemetry
G-4 (KJ-3)The official CVSS 3.1 vector string and NVD enrichment (version mapping is the finder's; Oracle lists no CVE IDs)The public NVD record and Oracle's per-CVE risk matrix page
G-5 (KJ-2)How common a genuinely exploitable app is in the wild — the crash reproduces trivially, but the precondition set (affected line ∩ AVX-512 VBMI ∩ untrusted Base64) is unmeasuredFleet inventory of affected ∩ AVX-512 hosts, then which decode attacker Base64
TLP:CLEAR — may be shared publicly, without restrictionGhost in the Runtime · CVE-2026-114938 · v1.3
TLP:CLEARCTI Vulnerability Alert: CVE-2026-114938 "Java4Shell" (Java / OpenJDK Base64)Page 5 of 9

Secure-coding lecture: a store mask derived from a length that was allowed to go negative

The real component and the shipped fix. v1.0's illustrative diff is replaced with the actual vulnerable routine, generate_base64_decodeBlock() in stubGenerator_x86_64.cpp. The fix hunk below is the actual upstream change (JDK-8393212, commit 5177a70b, line 3395, verified against the OpenJDK tree, diff verbatim); the underlying underflow is reconstructed from the public analyses (Calif, Oligo, Equixly, Upwind). We then ported this exact arithmetic to a C model and confirmed, under AddressSanitizer, that it writes 62 bytes out of bounds — and that adding only these two guard lines removes the overflow (a mutation check; appendix p7).

Java is memory-safe, so "memory corruption in Java" means corruption in the native code the JDK ships and calls — here, a hand-written AVX-512 stub the JIT swaps in for java.util.Base64.Decoder.decode(). The stub handles its final 1–63-byte fragment itself; the security-decision line is the store mask, which alone decides how many of a 64-byte vector reach the output array.

The defect, and the two-line guard that fixes it

The actual fix hunk. In L_finalBit the copy is a masked AVX-512 store of a full 64-byte register, so the store mask decides everything. The shipped guard is purely additive — it sends any tail shorter than one 4-char block to the scalar path (L_bruteForce) before the mask arithmetic runs.

stubGenerator_x86_64.cpp · generate_base64_decodeBlock() @@ -3395,6 +3395,10 @@ __ BIND(L_finalBit); // now have 1 to 63 bytes left to decode + // A padded Base64 tail shorter than one complete block is handled by Java. + __ cmpl(length, 4); // the fix: a tail shorter than + __ jcc(Assembler::less, L_bruteForce); // one 4-char block -> scalar path // "...it will repeatedly call this routine for every 4 bytes of input, // so handle the rest here." <- why the tail is decoded in native code output_len = (tail_len/4)*3; // 1-3 byte tail -> 0 if (tail ends "=") output_len -= 1; // -> -1 ("==" -> -2): the underflow mask = bzhi(~0ULL, output_len); // BZHI reads low 8 bits: 0xFF=255 >= 64 -> all-ones store64_masked(dest, mask, vec); // writes all 64 bytes -> 62-byte OOB

The green block is the shipped fix, verbatim: a comment plus the two-line guard (cmpl length,4 / jcc less,L_bruteForce). It sends any tail under 4 chars to the scalar path, so the mask arithmetic only ever sees lengths ≥ 4, where output_len cannot go negative. Why 62: for the canonical "A"×64 + "=" the array is 50 bytes but the all-ones mask writes a full 64 from offset 48 — 62 past the end (page 3 map). We reproduce this exact arithmetic in the appendix.

Reproduced in C. The real AVX-512 assembly cannot run on the ARM lab host, so we modelled its two load-bearing steps and let ASan catch the write (full source p7–p8, output p9):

// base64_tail_model.c — the two steps that make the intrinsic corrupt memory static uint64_t bzhi(uint64_t src, int64_t index) { unsigned idx8 = (unsigned)((uint64_t)index & 0xFF); // low 8 bits ONLY (x86 BZHI) if (idx8 >= 64) return src; // >= opsize: NOTHING cleared return src & ((1ULL << idx8) - 1ULL); } // ... in the tail handler (L_finalBit): int64_t output_len = (int64_t)(tail_len / 4) * 3; // 1-3 byte tail -> 0 output_len -= pad; // '=' -> -1, '==' -> -2 (UNDERFLOW) uint64_t mask = bzhi(~0ULL, output_len); // -1 & 0xFF = 255 >= 64 -> all-ones store64_masked(out + 48, mask, vec); // writes 64 bytes from offset 48 -> OOB

Three principles a reviewer applies at the native edge

1

In a memory-safe language, the memory bugs live at the native/intrinsic boundary.

The java.util.Base64 call site is bounds-checked; the corruption is in the assembly stub the JIT substitutes for it. Audit JDK intrinsics, JNI, Unsafe, DirectByteBuffer and bundled C libraries as if they were standalone C — because they are, and the managed layer's guarantees stop at their edge.

2

Never derive a length or mask from a count that can go negative; floor it, then bound it.

The whole bug is a subtraction with no floor feeding a bit-count. Any value that sizes a copy or a store mask earns an explicit non-negative floor and an upper bound before it is used — especially when it reaches an instruction like BZHI that silently truncates its index to 8 bits. Validate the degenerate cases (empty, 1–3-byte, all-padding tails) rather than trusting the arithmetic to stay in range.

3

An optional accelerated path is attack surface you can turn off.

This flaw only exists because an AVX-512 fast path replaced a safe scalar decoder, and it is reachable only where that path is active. That cuts both ways: the same switch is the mitigation — -XX:-UseBASE64Intrinsics restores the scalar loop. Know which accelerated intrinsics your fleet runs, keep the switch to disable them, and keep untrusted input away from the ones you do not need.

The broader rule: the memory-safe guarantee ends at the intrinsic/JNI boundary. Harden what crosses it — floor and bound every length, validate the degenerate inputs, and keep a kill-switch for the optional native paths — rather than trusting the managed layer to have made it safe.

TLP:CLEAR — may be shared publicly, without restrictionGhost in the Runtime · CVE-2026-114938 · v1.3
TLP:CLEARCTI Vulnerability Alert: CVE-2026-114938 "Java4Shell" (Java / OpenJDK Base64)Page 6 of 9

What is confirmed, what is reported, and what is our judgement

StatementType
The flaw is a heap overflow in the HotSpot AVX-512 Base64 decode intrinsic behind java.util.Base64; a full 64-byte store overruns the output array by 62–63 bytesConfirmed
Affected: HotSpot Java 17.0.6+ / 21 / 25 / 27 on x86-64 with AVX-512 VBMI; not Java 8, 11, 17.0.0–17.0.5 or ARM64Confirmed
-XX:-UseBASE64Intrinsics (or -XX:UseAVX=2) forces the safe scalar decoder and mitigates the flawConfirmed
The fix adds a length<4 guard routing sub-block padded tails to the scalar path — verified as JDK-8393212, commit 5177a70b (line 3395), against the OpenJDK treeConfirmed
The finder (Calif) claims pre-auth RCE against named products; the overflow is independently reproduced, RCE is not; CVSS 4.0 9.2 reportedReported
The OOB store lays down a fixed pattern (0x9a 0x69 0xa6 repeating), and the trigger needs a ~200k-invocation C2 warm-up first (single third-party source; not reproduced here)Reported
The tail arithmetic produces a 62-byte OOB write under AddressSanitizer, and a two-line length guard removes it (reproduced locally via a logic-level C model and a mutation check; appendix p7)Confirmed
An affected JDK (Temurin 21.0.13) on non-AVX-512 silicon takes the safe scalar path and does not crash (local QEMU negative control)Confirmed
9.2 (CVSS 4.0) and Oracle's 8.1 (CVSS 3.1) are the same bug scored under two systemsJudgement
Reliable RCE from a 62–63-byte overwrite is hard, so a crash/DoS is the more common outcome per targetJudgement
No confirmed in-the-wild exploitation and no public PoC at cut-off; not in CISA KEVReported

Sources and grades

SourceGradeDateUsed for
OpenJDK source (stubGenerator_x86_64.cpp, 17u)A118 NovPrimary: flawed routine, enablement gate, mitigation flag, and the fix commit (JDK-8393212 / 5177a70b) verified in-tree
This lab — ASan model + mutation check + QEMU control (appendix p7)A118 NovOwn reproduction: 62-byte OOB confirmed, guard isolated as the fix, hardware precondition shown. Models arithmetic, not the real intrinsic; no RCE
Calif — "Java4Shell" (calif.io/java4shell)B217 NovFinder: component, claimed RCE, affected targets, mitigation
IONIX (ionix.io blog)B217 NovReproduced the OOB write (no crash/RCE shown); confirms 17/21/25, flag on 17.0.21
Oligo / Equixly technical analysesB217 NovMechanism: underflow, BZHI mask, overflow size, trigger lengths
Semgrep research (java4shell-openjdk-base64)B217 NovConfirmed OOB write; 8/11/17.0.0–.5 and ARM exclusion; flags
JFrog Security Research; watchTowr intelB217 NovIdentifier, 9.2 CVSS 4.0, independent corroboration
Oracle CSPU Nov 2026 pre-release (oracle.com/security-alerts)A212 Nov11 Java SE fixes, max 8.1, affected/fixed builds
NVD / CVE Program record—18 NovNot yet enriched at cut-off; pending (G-4)
Oracle/OpenJDK Oct advisories (CVE-2026-91403, eMudhra)A2OctThe separate certificate-trust issue (de-conflation)

Admiralty: source reliability A–F, information credibility 1–6, judged independently. The research accounts corroborate each other and the OpenJDK source, so the component and mechanism are graded Confirmed; the demonstrated-RCE and scoring claims remain Reported pending Oracle's matrix, the NVD record and a public PoC.

Status

This product (v1.3) supersedes v1.2. The component, scope, mechanism and mitigation are confirmed and cross-checked against OpenJDK source and multiple independent analyses; v1.2 added our own local reproduction — a logic-level C model that aborts under AddressSanitizer on the 62-byte overflow, a mutation check isolating the two-line guard as the fix, and a QEMU negative control showing an affected JDK on non-AVX-512 silicon is safe (appendix, p7). The reproduction models the arithmetic faithfully; it does not run the real AVX-512 intrinsic (that needs AVX-512 VBMI x86-64 silicon, absent on the ARM lab host), and we did not achieve RCE. v1.3 closes the fix-commit gap: the patch is verified in-tree as JDK-8393212, commit 5177a70b (pushed 16 Nov 2026), and its own comment confirms the trigger is a valid padded tail. Full RCE remains the finder's claim; a reported fixed overflow pattern and warm-up cost are noted as single-source. What remains open is narrow: the official CVSS 3.1 vector string and NVD enrichment, how large the genuinely-exposed population is (G-5), and whether exploitation moves from the finder's demonstrations to the wild. A v1.4 will follow on the first confirmed in-the-wild exploitation or KEV listing, or if the published risk matrix changes the scope or score.

TLP:CLEAR — may be shared publicly, without restrictionGhost in the Runtime · CVE-2026-114938 · v1.3
TLP:CLEARCTI Vulnerability Alert: CVE-2026-114938 "Java4Shell" (Java / OpenJDK Base64)Page 7 of 9

Appendix A — the reproduction model (1 of 2): BZHI, the masked store, the tail handler

What this is, and what it is not. base64_tail_model.c is a faithful logic-level port of the vulnerable tail handler — not the shipped AVX-512 assembly, which needs AVX-512 VBMI x86-64 silicon the ARM lab host lacks. It models the arithmetic and lets AddressSanitizer catch the write. Part 2 on p8; captured output p9. Build at -O0.

/* * base64_tail_model.c * * A faithful logic-level model of the CVE-2026-114938 ("Java4Shell") defect in * HotSpot's generate_base64_decodeBlock() (stubGenerator_x86_64.cpp), the * AVX-512 VBMI Base64 decode intrinsic. * * We cannot run the real AVX-512 VBMI assembly on Apple Silicon / QEMU, so this * reproduces the EXACT arithmetic of the vulnerable tail handler (L_finalBit) * and the masked 64-byte vector store, in plain C, and lets AddressSanitizer * catch the resulting out-of-bounds write. * * The defect, verbatim from the alert (page 5): * output_len = (tail_len/4)*3; // 1-3 byte tail -> 0 * if (tail ends "=") output_len -= 1; // -> -1 ("==" -> -2): the underflow * mask = bzhi(~0ULL, output_len); // BZHI reads low 8 bits: 0xFF=255 >= 64 -> all-ones * store64_masked(dest, mask, vec); // writes all 64 bytes -> 62-byte OOB * * Build: make (see Makefile) — or: * cc -O0 -g -fsanitize=address -fno-omit-frame-pointer base64_tail_model.c -o model * (-O0 is required: at -O1+ the compiler vectorizes/elides the lane-write * loop and the overflow slips past ASan's instrumentation.) * * Usage: ./model vuln -> canonical case: triggers the OOB write (ASan aborts) * ./model fixed -> applies the shipped guard (tail < 4 -> scalar); no OOB * ./model vuln <tl> <pad>-> drive a specific final fragment (tail_len, pad) * ./model fixed <tl> <pad>-> same, with the guard applied * ./model sweep -> table over the documented 1-2 byte / 1-2 pad cases * (no store; shows the arithmetic without aborting) * * Where the geometry comes from (canonical Java 21/25 trigger, 64 'A' + '='): * 64 input chars = 16 full 4-char quads -> 16*3 = 48 fully-decoded body bytes. * => the tail store begins at offset STORE_OFF = 48. * the final quad decodes to 2 bytes -> total output array = 48 + 2 = 50 bytes. * the AVX-512 ZMM register is 64 bytes wide, so the masked store writes lanes * 0..63 -> offsets 48..111; the last byte is 48 + 63 = 111. * array ends at offset 50, so offsets 50..111 = 62 bytes out of bounds. * Java 17's trigger tail is one byte longer, giving a 49-byte array and 63 OOB; * both -1 and -2 output_len values truncate to the same all-ones mask (the low * 8 bits are >= 64 either way), so it is the ARRAY SIZE, not the pad count, that * moves the OOB figure between 62 and 63 -- the truncation swallows the -1/-2 * difference. That is itself the lesson: the mask no longer encodes the length. */ #include <stdint.h> #include <stdio.h> #include <string.h> #include <stdlib.h> /* The body (all full 4-char quads before the final fragment) has already decoded * to this many bytes, so the tail's masked store begins here. 48 for the * canonical 64-char trigger (16 quads * 3 bytes). */ #define STORE_OFF 48 /* * Faithful model of the x86 BZHI instruction (BMI2): * BZHI dst, src, index -- zero the high bits of `src` starting at bit `index`. * Hardware semantics (Intel SDM): the bit index used is index & 0xFF -- i.e. * only the LOW 8 BITS of the index operand are read. If that 8-bit value is * >= operand size (64), NO bits are cleared and the result is `src` unchanged. * * This single truncation is the whole bug: a negative output_len (-1) arrives * as a 64-bit value 0xFFFF...FF; BZHI looks at the low 8 bits -> 0xFF = 255; * 255 >= 64, so the mask is left all-ones. */ static uint64_t bzhi(uint64_t src, int64_t index) { unsigned idx8 = (unsigned)((uint64_t)index & 0xFF); /* low 8 bits only */ if (idx8 >= 64) return src; /* >= opsize: unchanged */ return src & ((1ULL << idx8) - 1ULL); } /* * Model of the masked 64-byte AVX-512 vector store: store64_masked(dest, mask, vec). * For each of the 64 lanes, if the corresponding mask bit is set, the byte is * written to dest[i]. With an all-ones mask this writes all 64 bytes. */ static void store64_masked(uint8_t *dest, uint64_t mask, const uint8_t vec[64]) { for (int i = 0; i < 64; i++) { if (mask & (1ULL << i)) { dest[i] = vec[i]; /* <-- ASan trips here when i runs past the array */ } } } /* * The vulnerable tail handler (L_finalBit), modelling the final 1-63 byte * fragment. `tail_len` is the number of remaining Base64 chars (1-63); * `pad` is the number of trailing '=' (0, 1, or 2). * * `applied_guard` selects the shipped fix: `cmpl length,4 / jcc less, L_bruteForce` * -- a tail shorter than one 4-char block goes to the scalar path and never * reaches the mask arithmetic. */ static int decode_tail(uint8_t *out, size_t out_cap, int tail_len, int pad, int applied_guard) { /* The shipped guard (the two green lines in the diff: cmpl + jcc): */ if (applied_guard && tail_len < 4) { /* L_bruteForce: scalar path handles short tails safely. */ int n = (tail_len / 4) * 3 - pad; if (n < 0) n = 0; /* scalar loop never writes a negative count */ /* (a real scalar decoder writes `n` bytes; nothing to overflow here) */ (void)out; (void)out_cap; return n; }
TLP:CLEAR — may be shared publicly, without restrictionGhost in the Runtime · CVE-2026-114938 · v1.3
TLP:CLEARCTI Vulnerability Alert: CVE-2026-114938 "Java4Shell" (Java / OpenJDK Base64)Page 8 of 9

Appendix A — the reproduction model (2 of 2): array sizing, the sweep, and main

Continued from p7. out_cap_for() is the lever that moves the overrun between 62 and 63 bytes; trace_case() drives the non-aborting sweep; main defaults to the canonical case and accepts vuln/fixed/sweep plus optional tail/pad overrides.

/* --- The vulnerable arithmetic, exactly as on page 5 --- */ int64_t output_len = (int64_t)(tail_len / 4) * 3; /* 1-3 byte tail -> 0 */ output_len -= pad; /* "=" -> -1, "==" -> -2 (UNDERFLOW) */ uint64_t mask = bzhi(~0ULL, output_len); /* all-ones when output_len < 0 */ fprintf(stderr, " tail_len=%d pad=%d -> output_len=%lld mask=0x%016llx (%d bits set)\n", tail_len, pad, (long long)output_len, (unsigned long long)mask, __builtin_popcountll(mask)); /* The decoded vector (contents irrelevant to the overflow; use a marker). */ uint8_t vec[64]; memset(vec, 0x41 /* 'A' */, sizeof vec); /* The masked store lands at the tail's output offset: the body (the full * quads before the tail) has already decoded to STORE_OFF=48 bytes, so the * store always begins at offset 48 regardless of pad. An all-ones mask * writes 64 bytes -> offsets 48..111. The array ends at `out_cap` (50 for a * '=' tail, 49 for '=='), so the OOB count is 111 - out_cap + 1 = 62 or 63. */ size_t store_off = STORE_OFF; (void)out_cap; store64_masked(out + store_off, mask, vec); return (int)output_len; } /* Model the output array size for a final fragment of `pad` trailing '='. * The body (all the full quads before the tail) decodes to STORE_OFF bytes; the * final quad decodes to (3 - pad) bytes. So the array is STORE_OFF + (3 - pad). * For the canonical case STORE_OFF=48: pad=1 -> 50 bytes (62 OOB), pad=2 -> 49 * bytes (63 OOB). This is the lever that moves the OOB figure, NOT output_len. */ static size_t out_cap_for(int pad) { int tail_bytes = 3 - pad; /* '='->2, '=='->1 real bytes in the final quad */ if (tail_bytes < 0) tail_bytes = 0; return (size_t)STORE_OFF + (size_t)tail_bytes; } /* Non-aborting arithmetic trace for one (tail_len,pad) case, used by `sweep`. * Reports what the mask and OOB count WOULD be, without performing the store. */ static void trace_case(int tail_len, int pad) { int64_t output_len = (int64_t)(tail_len / 4) * 3 - pad; uint64_t mask = bzhi(~0ULL, output_len); size_t out_cap = out_cap_for(pad); size_t last = (size_t)STORE_OFF + 63; /* last lane of a 64-byte store */ long oob = (long)(last - out_cap + 1); /* offsets out_cap..last */ printf(" tail_len=%d pad=%d | output_len=%2lld | low8=%3llu | mask=%d bits | " "array=%zu B | would write %ld bytes OOB\n", tail_len, pad, (long long)output_len, (unsigned long long)((uint64_t)output_len & 0xFF), __builtin_popcountll(mask), out_cap, oob); } int main(int argc, char **argv) { const char *mode = (argc > 1) ? argv[1] : "vuln"; if (strcmp(mode, "sweep") == 0) { /* The documented range: 1-2 byte tails with 1-2 trailing '='. Every row * underflows to a negative output_len whose low 8 bits are >= 64, so the * mask is all-ones in every case -- the OOB count varies only with the * array size (pad), spanning the 62-63 bytes the alert cites. */ printf("CVE-2026-114938 tail-handler sweep (arithmetic only, no store)\n"); trace_case(1, 1); /* canonical Java 21/25: 62 OOB */ trace_case(2, 1); trace_case(2, 2); /* "==" tail: 63 OOB */ trace_case(3, 1); printf(" (all rows: mask all-ones -> a 64-byte store; array size sets the OOB count)\n"); return 0; } int guard = (strcmp(mode, "fixed") == 0); /* Default: canonical Java 21/25 case (64 'A' + '=') -> 1-byte tail, pad=1, * 50-byte array, 62 OOB. Optional argv overrides pick other documented * cases; the array size is derived from pad so the OOB count is faithful. */ int tail_len = (argc > 2) ? atoi(argv[2]) : 1; int pad = (argc > 3) ? atoi(argv[3]) : 1; size_t OUT_CAP = out_cap_for(pad); printf("CVE-2026-114938 tail-handler model [mode=%s]\n", guard ? "fixed" : "vuln"); printf(" output array: %zu bytes; final fragment: %d byte(s), %d trailing '='\n", OUT_CAP, tail_len, pad); uint8_t *out = (uint8_t *)malloc(OUT_CAP); /* heap alloc so ASan knows the bound */ if (!out) return 2; memset(out, 0, OUT_CAP); int n = decode_tail(out, OUT_CAP, tail_len, pad, guard); printf(" decode_tail returned %d; no overflow detected.\n", n); free(out); printf(" SURVIVED (mode=%s)\n", guard ? "fixed" : "vuln"); return 0; }
TLP:CLEAR — may be shared publicly, without restrictionGhost in the Runtime · CVE-2026-114938 · v1.3
TLP:CLEARCTI Vulnerability Alert: CVE-2026-114938 "Java4Shell" (Java / OpenJDK Base64)Page 9 of 9

Appendix B — captured demo outputs

Real runs on the lab host (Apple Silicon arm64, Apple clang; Temurin 21.0.13 under Docker/QEMU for the control). Addresses, PIDs and the temp path are normalised (NNNN, <TMPDIR>); the extent — 62 bytes past a 50-byte region — is stable across runs. These are the evidence behind the judgements on pages 2–6.

1 · The proof — AddressSanitizer catches the write, the guard removes it

The mutation check: the only difference between ABORTING and SURVIVED is the two-line guard.

$ make vuln # canonical Java 21/25 case: 64 'A' + '=', 50-byte array CVE-2026-114938 tail-handler model [mode=vuln] output array: 50 bytes; final fragment: 1 byte(s), 1 trailing '=' tail_len=1 pad=1 -> output_len=-1 mask=0xffffffffffffffff (64 bits set) ==NNNN==ERROR: AddressSanitizer: heap-buffer-overflow ... WRITE of size 1 #0 ... in store64_masked base64_tail_model.c:80 #1 ... in decode_tail base64_tail_model.c:126 #2 ... in main base64_tail_model.c:191 0x... is located 0 bytes after 50-byte region SUMMARY: AddressSanitizer: heap-buffer-overflow base64_tail_model.c:80 in store64_masked ==NNNN==ABORTING $ make fixed # identical input, the two-line guard applied decode_tail returned 0; no overflow detected. SURVIVED (mode=fixed) [exit 0]

2 · Why 62 vs 63 — the array size, not the length

$ ./model sweep # arithmetic only, no store -- why 62 vs 63 CVE-2026-114938 tail-handler sweep (arithmetic only, no store) tail_len=1 pad=1 | output_len=-1 | low8=255 | mask=64 bits | array=50 B | would write 62 bytes OOB tail_len=2 pad=1 | output_len=-1 | low8=255 | mask=64 bits | array=50 B | would write 62 bytes OOB tail_len=2 pad=2 | output_len=-2 | low8=254 | mask=64 bits | array=49 B | would write 63 bytes OOB tail_len=3 pad=1 | output_len=-1 | low8=255 | mask=64 bits | array=50 B | would write 62 bytes OOB (all rows: mask all-ones -> a 64-byte store; array size sets the OOB count)

3 · Detection — hunt the decoder crashing (no network IOC)

$ make detect-demo # hunts over committed synthetic fixtures (p4 signal) === hunt_hserr.sh (primary: decoder crash dump) === [HIGH score=6] <TMPDIR>/hs_err_pid_java21_sample.log ( fatal-signal decoder-stub-frame base64-decode-frame problematic-frame ) [HIGH score=6] <TMPDIR>/hs_err_pid_java17_sample.log ( fatal-signal decoder-stub-frame base64-decode-frame problematic-frame ) -> at least one dump matches the decoder crash signature. === hunt_logs.sh (secondary: decode-exception burst) === [BURST 14] <TMPDIR>/app.log burst threshold (10) reached: investigate the source endpoint.

4 · Negative control — affected JDK, no AVX-512, no crash

Proves the hardware precondition: an affected version on the wrong silicon takes the safe scalar path.

$ make qemu-control # affected JDK on emulated x86-64 WITHOUT AVX-512 openjdk version "21.0.13" 2026-10-20 LTS <- an affected build x86_64 avx avx2 <- no avx512* exposed by QEMU int UseAVX = 2 <- needs > 2 for the intrinsic bool UseBASE64Intrinsics = true <- true, but inert without the silicon === run trigger sweep (expect: all SURVIVED) === AA== (1-byte tail), quads=15 len=64 -> decoded 46 bytes, SURVIVED AAA= (2-byte tail), quads=15 len=64 -> decoded 47 bytes, SURVIVED ALL SURVIVED: scalar path, no AVX-512 intrinsic on this CPU.
TLP:CLEAR — may be shared publicly, without restrictionGhost in the Runtime · CVE-2026-114938 · v1.3 · supersedes v1.2