Root cause
The stub decodes in 256- and 64-byte blocks, then handles the trailing fragment on a path that derives a store mask from the output length:
__ BIND(L_padding);
__ decrementq(output_size, 1); // underflow not guarded
...
__ bzhiq(output_mask, output_mask, output_size);
__ evmovdqub(Address(dest, dp), k1, tmp, true, Assembler::AVX_512bit);bzhiq leaves the destination untouched when its index is 64 or higher. When the input ends in padding — =, ==, X=, XY=, === — the length drops below zero, reads as unsigned, and the mask stays all ones, so the store writes a full 64 bytes instead of nothing.
For a 65-byte input the decoder has allocated a 50-byte array. The destination sits at offset 48, so the store covers bytes 48 to 111: 62 bytes past the allocation. Java then throws IllegalArgumentException, several instructions too late. It is one store of largely constant bytes at a partly predictable offset, which is why the exploitation work is heap shaping rather than payload construction.
On JDK 17 the trigger is A × 128 + = (129 bytes) rather than 65, because the stub diverts to a scalar path at length <= 128. Testing the 65-byte input there produces nothing and reads as a fixed build.
Exposure
Three conditions must hold at once, and each is a hard disqualifier.
CPU. The stub is emitted only when the processor reports all four of avx512f, avx512bw, avx512vbmi, bmi2: Intel Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids, or AMD Zen 4 and later. ARM64 is out by architecture. Intel's 12th to 14th generation consumer parts are out because AVX-512 was disabled before those chips shipped.
Runtime. JDK 17.0.6 or later, on Oracle Java SE, GraalVM or any distribution built from the same source.
Intrinsic state. The JVM must actually be using it. On a Temurin 17.0.21 build we checked, UseBASE64Intrinsics defaults to false; on 21.0.13 it is true. Two hosts with the same version can sit on opposite sides of the risk boundary, which makes version-keyed inventory worthless on its own.
Oracle scopes it to code that feeds attacker data into the decoder: the bug can only be exploited by supplying data to APIs in the affected component. Base64 turns up in Authorization: Basic headers, JWT segments, WS-Security tokens, upload handlers, brokers and cache keys, which is why the affected product list is long.
Check CPUID first, since it disqualifies most hosts:
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'All four must appear. Then confirm the runtime and whether the intrinsic is live:
java -XX:+PrintFlagsFinal -version 2>/dev/null | grep -E 'UseBASE64Intrinsics|UseAVX'We confirm exposure with a bounded trigger that warms the decode path until C2 compiles the intrinsic, then decodes the malformed fragment into a 4096-byte array. Every write stays inside a live allocation, so it is safe on a production JVM, and it asserts exactly 62 bytes changed at offsets 50 to 111. Anything else means the vector path was not taken and the result is inconclusive, not negative.
Exploitability
What is public demonstrates the overwrite; what is not public turns it into an attack. Publicly reported demonstrations reach code execution against default configurations of Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate before authentication, plus Kafka, Solr, Elasticsearch, Gerrit and Spinnaker with credentials. There is also a client-side case: a Java process opening a TLS connection to a malicious server can be compromised with no service exposed, which inverts the usual direction of the threat.
Oracle describes the vulnerability as difficult to exploit and assigns high attack complexity, reflecting the distance between a proof of concept and a reliable remote chain rather than any doubt about the defect.
Why the primitive escalates
We measured two properties on Temurin 17.0.21 x86-64 that raise the practical impact.
Base64.Decoder.decode(byte[] src, byte[] dst) accepts a caller-allocated destination, and 50 bytes is the minimum Java allows for the 65-byte trigger. A 50-byte array occupies 72 bytes of heap, so a neighbour allocated immediately behind it begins exactly where the store ends, covering its mark word, class pointer, length field and 40 bytes of data. Placement needs no grooming; only the escalation does.
The JIT code cache is mapped writable and executable on that build. We patched a DirectByteBuffer address field from a corrupted length, used it for native read/write, and ran a payload out of the code cache inside a live JVM. That removes the usual W^X obstacle and is why these bugs should be scoped as code execution rather than denial of service.
Remediation
Upgrade to a fixed build; that is the whole task for most estates. Where a service cannot move at the same time:
| Flag | Effect | Consideration |
|---|---|---|
-XX:-UseBASE64Intrinsics | Disables the hardware Base64 encoder and decoder | Modest cost on Base64-heavy paths; the narrower option |
-XX:UseAVX=2 | Constrains the JVM to AVX2 | x86-64 only |
Both are start-up flags, needing a config change and a restart. Neither replaces the upgrade, and the first should be validated against token issuance, mail processing or any pipeline that decodes at volume.
Start with hosts meeting all three conditions, internet-facing or not, since a JVM that only makes outbound connections can still be compromised by a server it talks to. Anything that cannot move gets the flag plus a ticket, not a permanent disposition. Then record CPU feature sets alongside runtime versions, because the deciding facts here were build, CPU and flag, and most estates can only answer the first.
CVE-2026-114938 was reported to Oracle by Quang Luong of Calif.io, who published the initial analysis and named it Java4Shell; the November 2026 advisory credits the report, and the OpenJDK advisory credits Quang Luong alongside Albert Yang.