dispatch - Security
SECURITY42 MIN

Java4Shell (CVE-2026-114938): How 65 Bytes of Base64 Overflow the OpenJDK Heap, Who Is Affected, and How I Checked It

byBackend & Systems Engineer

Java4Shell (CVE-2026-114938) is a heap overflow in OpenJDK's AVX-512 Base64 decoder. How the mask math breaks, who is affected, and the fixed builds.

⚠ TL;DR

Java4Shell (CVE-2026-114938) is a heap out-of-bounds write in the hand-written x86-64 assembly that OpenJDK's HotSpot JVM uses to decode Base64 on CPUs with AVX-512 VBMI. Once the C2 JIT has warmed up the decoder, a malformed string as short as 64 A characters plus one = makes the tail-length math underflow to -1, the 64-bit store mask becomes all ones, and a single masked store writes 64 bytes starting at offset 48 of a 50-byte array: 62 bytes past the end. Java throws IllegalArgumentException afterwards, but the neighbors are already overwritten. Calif's Quang Luong found it (Calif says in about an hour, with AI help) and turned the fixed-byte write into heap leaks ("JavaBleed") and pre-auth RCE in Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate in default configs. Affected: OpenJDK 17.0.6 and later, plus 21, 25 and 27, on x86-64 with avx512f, avx512bw, avx512vbmi and bmi2. ARM64 and standard Java 8/11 are not affected. Scores: Calif 9.2 (CVSS 4.0), Oracle 8.1 (CVSS 3.1, AC:H), Red Hat 9.8, Amazon 8.8. Fixed on November 17, 2026 in Oracle's 17.0.21.1 / 21.0.13.1 / 25.0.5.1 / 27.0.1.1 and matching vendor builds. On my M3 Pro I checked that the native image runs as aarch64 (which Calif and the vendors list as not affected), that -XX:UseAVX=2 stops an ARM JVM from starting at all while -XX:-UseBASE64Intrinsics starts fine, that an emulated amd64 container exposes no AVX of any kind (the JVM picks UseAVX=0) so my Mac cannot test this, and that on November 19 the official eclipse-temurin:21 Docker image still pulled the pre-fix 21.0.13+9.

◆ IMG800×600
Cover card for Java4Shell CVE-2026-114938: 65 characters of Base64 write 62 bytes past the end of a heap array, CVSS 9.2 from Calif and 8.1 from Oracle, affects OpenJDK 17.0.6 and later on x86-64 with AVX-512 VBMI, fixed in Oracle 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1
↳ Cover card for Java4Shell CVE-2026-114938: 65 characters of Base64 write 62 bytes past the end of a heap array, CVSS 9.2 from Calif and 8.1 from Oracle, affects OpenJDK 17.0.6 and later on x86-64 with AVX-512 VBMI, fixed in Oracle 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1

What is Java4Shell (CVE-2026-114938)?

Java is supposed to be the memory-safe one. You do not free memory yourself, every array access is bounds-checked, and a whole class of C bugs simply does not exist in Java code. That promise is about the Java code you write. The JVM that runs it is written in C++ and, in a few hot spots, hand-written assembly. Java4Shell lives in one of those hot spots.

Calif, the firm that found it, describes it as "a memory-corruption vulnerability in OpenJDK's Base64 decoder." One section of their write-up is headed with the obvious question: "Wait, Java has a memory-corruption vulnerability, in Base64?!" Their answer: "Yes. First time?"

In plain terms:

  • Base64 is the text encoding behind HTTP Basic auth headers, JWTs, SAML assertions, file uploads and plenty of API fields. Servers decode attacker-supplied Base64 all day, often before anyone has logged in.
  • To make that decoding fast, the JVM swaps the Java implementation of java.util.Base64 for a hand-tuned assembly routine on x86-64 CPUs that support AVX-512 VBMI.
  • That routine mishandles a stray = at the end of the input. It computes a negative length, and the negative length turns into "write all 64 bytes." For a 65-character input, 62 of those bytes land past the end of the output array.
  • Java notices the input is malformed and throws an exception, but only after the write has happened.

Calif's researcher Quang Luong then showed that this limited, mostly fixed-value overwrite can be turned into a Heartbleed-style heap leak, which Calif calls JavaBleed, and then into remote code execution. Calif reports doing that against six widely deployed products without credentials and five more with credentials.

The fix shipped on November 17, 2026 in Oracle's Critical Security Patch Update and the OpenJDK vulnerability advisory of the same day. The bug had leaked before then, which compressed everything into a single afternoon. CISA put out an alert the same day titled "Critical Java Vulnerability Requires Immediate Patching."

⚠ WARNING

This post explains the bug from the defender's side: the arithmetic, who is exposed, how to check, how to patch and what to look for. It contains no exploit code and no payload construction beyond the trigger string Calif published on the front of its own page. Calif's write-up includes a bounded, self-contained check that keeps every write inside a real 4096-byte array and prints REPRODUCED on an affected JDK. If you run AVX-512 hardware and want to confirm a build, that is the thing to use. I did not run it: I do not have an AVX-512 machine, and as I show below, my Apple silicon Mac could not reach the vulnerable path even under emulation.

This is the second big runtime bug from Calif in about a month. In October they disclosed PHP2Shell, which I wrote up in PHP2Shell: Anatomy of the CVE-2026-109618 and CVE-2026-109619 Unauthenticated RCE. Calif's own opener: "After we disclosed PHP2Shell, we realized many people didn't know what PHP was. So we decided to go after something a little more familiar: Java." It also landed one day before the nginx release I covered in nginx2root, so if you run Java behind nginx, you had two emergency patches in two days.


Base64 in one section: where the 50 comes from

To follow the bug you need exactly one fact about Base64: it turns every 3 bytes into 4 characters.

Each Base64 character carries 6 bits (64 possible symbols: A-Z, a-z, 0-9, +, /). Four characters carry 24 bits, which is 3 bytes. When the input data is not a multiple of 3 bytes, the encoder pads the final group with =:

Encoded tailReal data bytes in that groupPadding
XXXX3none
XXX=2one =
XX==1two =

A decoder therefore computes the output size from the input length: every full group of 4 characters gives 3 bytes, minus one byte per =. Calif gives the formula the decoder's Java side uses at runtime to size the output array:

● ● ●TEXT
output_length = ceil(input_length / 4) * 3 - padding

Now plug in the Java4Shell trigger, 64 A characters followed by one =, which is 65 characters:

● ● ●TEXT
ceil(65 / 4) = 17          (16 full groups plus 1 leftover character)
17 * 3       = 51
51 - 1       = 50 bytes    (one '=' counted as padding)

So the JVM allocates a 50-byte array. The first 64 characters are 16 perfectly valid groups that decode to 48 bytes, filling offsets 0 through 47. The 65th character is a lone =, which is not a legal Base64 ending at all: a group needs at least two real characters before any padding. A correct decoder rejects it. The question is what happens in the fast path before the rejection.


Why does Java have assembly in its Base64 decoder?

Because Java runs in tiers. When a method first runs, the JVM interprets its bytecode. If the method gets called a lot, HotSpot compiles it to native code, and the most aggressive of its JIT compilers is C2. Calif puts it simply: "if you trigger a function repeatedly, then it will compile that function into native code."

Even optimized native code is not as fast as it could be, though. Modern CPUs have vector instructions that process 32 or 64 bytes per instruction. HotSpot uses those in intrinsics: routines, written by hand in assembly for a specific CPU feature set, that the JIT drops in place of certain standard-library methods. JFrog's explainer describes it as the JIT swapping "a standard library method for an intrinsic: a small, hand-written piece of assembly tuned for a specific CPU." Base64 decoding has one of these for x86-64 CPUs with AVX-512 VBMI.

Three details from Calif's write-up matter here:

  1. Warm-up. The intrinsic only runs after C2 has compiled the decode path. Calif's bounded self-check warms the decoder with 200,000 valid decodes before trying the malformed one. JFrog notes that any busy service gets there within minutes, so "it needs warm-up" is not a defense for a production server.
  2. Block sizes. The stub "iterates through the input in 256-byte blocks; if it is less than 256, then it will do so in 64-byte blocks." Whatever is left at the end, under 64 bytes, goes through a separate tail path.
  3. The tail uses a masked store. For the tail, the stub uses evmovdqub, HotSpot's assembler name for the x86 instruction VMOVDQU8. It moves up to 64 bytes in one instruction, with a 64-bit mask in which bit i decides whether byte i is actually read or written. A mask of 0b1111 writes 4 bytes. A mask of all ones writes all 64.

The CPU features in the requirement line up with that design. AVX-512 provides the 64-byte registers and the mask registers, VBMI (Vector Byte Manipulation Instructions) adds byte-level vector operations, and BMI2 provides bzhi, the instruction the stub uses to build a mask with exactly N low bits set. Calif, Red Hat and the vendor write-ups all list the same four /proc/cpuinfo flags: avx512f, avx512bw, avx512vbmi and bmi2.


How does the Java4Shell bug work? The mask math

Here is the tail logic, as Calif presents it in pseudocode (my comments):

● ● ●TEXT
// bzhiq(x, n): keep the low n bits of x, zero the rest ("Zero High Bits", 64-bit)
input_mask  := bzhiq(-1, input_length)     // one bit per remaining input char
output_len  := (input_length / 4) * 3      // integer division: full groups only

if input[input_length - 1] == '=':          // one '=' at the end
    output_len -= 1
    input_mask >>= 1
    if input[input_length - 2] == '=':      // a second '='
        output_len -= 1
        input_mask >>= 1

output_mask := bzhiq(-1, output_len)        // one bit per output byte to store

On a well-formed tail this is fine. Take an 8-character tail AAAAAA==:

● ● ●TEXT
output_len  = (8 / 4) * 3 = 6
two '='     -> output_len = 6 - 2 = 4
output_mask = bzhi(-1, 4) = 0x000000000000000F   -> store 4 bytes

Now take the malformed tail Calif lists: anything of the form =, ==, X=, X==, XY= or ===. Every one of those has fewer than 4 characters, so the integer division gives zero full groups, and then the padding check subtracts anyway. For the trigger's lone =:

● ● ●TEXT
output_len  = (1 / 4) * 3 = 0
one '='     -> output_len = 0 - 1 = -1

As a 64-bit value, -1 is 0xFFFFFFFFFFFFFFFF. The last step is the one that turns a small bug into a large one. JFrog's explanation: bzhi reads only the low 8 bits of its index, so -1 is read as 255. And when the index is 64 or more, bzhi clears nothing:

● ● ●TEXT
index       = 0xFFFFFFFFFFFFFFFF & 0xFF = 255    (64 or more: no bits cleared)
output_mask = bzhi(-1, 255) = 0xFFFFFFFFFFFFFFFF  -> store all 64 bytes

With two padding characters the length is -2, the low 8 bits are 254, and the result is the same all-ones mask. In Calif's words, "since bzhiq(-1, output_len) doesn't change any bits if output_len >= 64, this results in output_mask == -1u64."

So the store that should have written zero bytes writes 64. Where does it write? At the current output position, which is right after the 48 bytes already decoded:

● ● ●TEXT
store start   = offset 48
store end     = offset 48 + 64 - 1 = 111
array size    = 50 bytes (valid offsets 0..49)
in bounds     = offsets 48, 49            -> 2 bytes
out of bounds = offsets 50..111           -> 111 - 50 + 1 = 62 bytes

That matches Calif's own self-check, which looks for exactly 62 changed bytes at offsets 50 to 111.

◆ IMG800×600
Byte map of the Java4Shell tail store: offsets 0 to 47 hold the 48 decoded bytes, offsets 48 and 49 are the last two bytes of the 50-byte array, and offsets 50 to 111 are 62 bytes written past the end, with offsets 96 to 111 always 0x9a; beside it the arithmetic from 65 input characters to a -1 output length to an all-ones mask
↳ Byte map of the Java4Shell tail store: offsets 0 to 47 hold the 48 decoded bytes, offsets 48 and 49 are the last two bytes of the 50-byte array, and offsets 50 to 111 are 62 bytes written past the end, with offsets 96 to 111 always 0x9a; beside it the arithmetic from 65 input characters to a -1 output length to an all-ones mask

What does the stub write into those 64 bytes? Calif breaks it down relative to the start of the store: byte 0 fully controlled, byte 1 has 4 controlled bits, bytes 2 to 63 are not attacker-chosen, and bytes 48 to 63 are always 0x9a. In array terms, that means the last 16 bytes of the spill (offsets 96 to 111) are always 0x9a. The attacker can influence where the write lands, and almost nothing about what it writes. Keep that in mind for the exploitation section.

Then the stub returns. Calif: "The generated stub returns the number of bytes it successfully decoded, and returns early when it detects invalid input. The remaining bytes are handled by the Java code, which throws IllegalArgumentException if the input is invalid." The Java side does exactly the right thing. It is just too late.

One wrinkle: on JDK 17 builds the trigger is longer. Calif says that "on OpenJDK 17, the trigger input is 'A' * 128 + '=' instead of 'A' * 64 + '=', because the length threshold to reach the code path is higher." (The intro on Calif's page phrases it as "older OpenJDK 17.") The bug is the same; only the input length needed to reach the tail path differs.

What the fix changes

JFrog describes the upstream fix as four lines: any tail shorter than one 4-character block goes back to the safe Java implementation instead of the assembly tail path. That closes the underflow at its source, because the subtraction only goes negative when the integer division has already produced zero full groups. A short tail never reaches the masked store, and the Java code, which bounds-checks every write, rejects the malformed ending.


How does a fixed-byte overwrite become JavaBleed and RCE?

This is the part that makes Java4Shell more than a crash bug, and it is worth understanding at the concept level even if you never write an exploit. Before the patch, Upwind and Equixly read the OpenJDK source, found the same AVX-512 Base64 decoder, and concluded (per The Hacker News) that a crash was the likely result "because the bytes written past the buffer are fixed and not chosen by the attacker." That was a reasonable reading of the primitive, and both firms' current posts now describe the RCE. Calif's write-up shows why it was not the end of the story.

Calif's own framing: "exploiting it looked difficult, perhaps even borderline unexploitable, since it only wrote fixed bytes to the heap. Only the landing position of the out-of-bounds write is controllable." They got around it with what they call "a common JavaScript engine exploitation primitive": overwrite a length field.

Every Java array stores its length in a header right before its data, and the JVM checks every access against that length. As JFrog explains it, if the decoder's output array happens to sit right before another array, the 62-byte spill lands on that neighbor's header and makes its length larger. Calif calls the neighbor the writer:

  1. Writer. Once its length is inflated, the application keeps writing attacker-chosen bytes into it, now past its real end. A fixed-value spill has become a bounded, chosen-value linear write.
  2. Reader. The writer is used to inflate the length of a second array whose contents the application copies back into a response. Reading through it returns heap memory the application never meant to expose. That is JavaBleed: before any code runs, the attacker can read the Java heap, which Calif notes "may hold PII, private keys, other secret keys, and tokens."
  3. Repair and escalate. Using the leaked bytes, Calif's chain restores headers it damaged so the JVM keeps running, and then turns the bounded write into arbitrary writes that reach the JIT's Code Cache and JVM hooks for code execution.

None of that works unless the decoder's output array lands directly before a writer. That is heap grooming, and it is where most of the difficulty lives:

  • HotSpot gives each Java thread a thread-local allocation buffer (TLAB), a private slice of Eden. Objects allocated by different request threads advance different cursors, so by default there is no useful ordering between a decoder buffer in one thread and a writer in another. Calif's first grooming layer steers the critical allocations onto what Calif calls the "attacker-preferred outside-TLAB allocation path."
  • The G1 collector divides the heap into fixed-size regions. Calif does not get to choose the layout or see the heap state, so the second layer is what they call "Spray and Pray": many live writer and reader pairs, so the decoder output has several possible neighbors. When it lines up, the application's response gets larger. Misses are discarded and retried.
  • Doing this remotely means controlling when allocations happen inside the target. Calif sends each request up to the point just before the critical allocation, waits until the earlier data has been acknowledged at the TCP level, then sends the rest. That makes the attack sensitive to round-trip time and jitter. Calif's solution, in their words: "Calif turned to physics and utilized money to solve the problem." They rented a VM in the same region as the target.

Calif summarizes the chain as six phases:

And Calif is explicit about the limits, which matter for how you prioritize:

  • No universal exploit. "Each chain needs a decoder route, a live writer, a returned reader or another feedback path, a heap layout, and an application action. Every target needs a bespoke profile. The exploit is not a universal point-and-shoot."
  • Request streaming. Some grooming profiles need partial request bodies to reach the application. A proxy that buffers the whole body first removes that timing, and nginx buffers request bodies by default.
  • Buffering is not a mitigation. Calif's Elasticsearch chain runs from one complete request, and after a WebSocket upgrade, frames pass through a tunnel where request-body buffering does not apply.
  • Crashes. "Incorrect placement could cause the JVM to crash, but in many instances, we can simply try again."

Calif is holding back the product-specific chains: "The weaponized chains for individual products stay private until everyone has had a chance to upgrade. We will publish them later." That is your window.


Which products did Calif exploit?

Calif reports remote code execution in these applications, in their default configurations, and says both lists are non-exhaustive:

Access neededProducts Calif demonstrated
None (pre-auth RCE)Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, PingFederate
Authenticated (post-auth RCE)Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, Spinnaker
Sample appsApps built on Apache Struts and Spring Boot
Client sideA Java program that opens a TLS connection to a malicious server (exploit shared with Calif by samczsun)

The pre-auth list is the scary one, and it is not random. It is identity providers, build and artifact servers, and collaboration tools: the systems that issue the tokens everything else trusts, the systems that build and ship your software, and the places your engineers already log in to every day. As Calif puts it, "Ordinary features such as authentication and file uploads can expose the vulnerable Base64 decoder."

The client-side line deserves attention too. Most patch triage starts with "what is listening on the internet." Here, a Java process that only makes outbound TLS connections was also exploitable, per the client-side exploit samczsun shared with Calif, so batch jobs, integration workers and CLIs that talk to external servers belong on the list.

Independent confirmation came quickly. Upwind reproduced the overflow on an AWS c6i instance (Intel Ice Lake) and reports:

  • Affected in their lab: Temurin 17.0.6, 17.0.21, 21.0.13 and 25.0.5. Clean: 11.0.33 and 17.0.5, which matches the 17.0.6 boundary.
  • With an exact-size output buffer, the overflow corrupted the next object in 97% of rounds and eventually crashed the JVM.
  • Pre-auth paths that hand attacker tokens straight to the vulnerable decoder: Spring Security, Tomcat and Jetty 12 Basic auth, and Auth0's java-jwt.

Who is affected by Java4Shell?

Four conditions have to hold on the same JVM at the same time.

◆ IMG800×600
The four Java4Shell gates: an affected HotSpot runtime (OpenJDK 17.0.6 and later, 21, 25, 27, or Oracle 8u511b33-perf), an x86-64 CPU with avx512f, avx512bw, avx512vbmi and bmi2, a decoder compiled by C2 with UseBASE64Intrinsics on, and untrusted Base64 reaching the java.util.Base64 basic or URL decoder; not affected: ARM64, x86-64 without VBMI, standard Java 8 and 11, OpenJDK 17.0.0 to 17.0.5, OpenJ9 and fixed builds
↳ The four Java4Shell gates: an affected HotSpot runtime (OpenJDK 17.0.6 and later, 21, 25, 27, or Oracle 8u511b33-perf), an x86-64 CPU with avx512f, avx512bw, avx512vbmi and bmi2, a decoder compiled by C2 with UseBASE64Intrinsics on, and untrusted Base64 reaching the java.util.Base64 basic or URL decoder; not affected: ARM64, x86-64 without VBMI, standard Java 8 and 11, OpenJDK 17.0.0 to 17.0.5, OpenJ9 and fixed builds

1. The runtime

  • OpenJDK 17.0.6 and later. Calif states the range; Red Hat adds that "the vulnerable code path was introduced in OpenJDK 17.0.6; OpenJDK 8 and OpenJDK 11 do not contain it and are not affected." Orca traced it in the source history: the AVX-512 Base64 decoding intrinsic (JDK-8268276) went into mainline in 2021, first shipped in JDK 18, and was backported to the 17 update line, first shipping in 17.0.6 in January 2023.
  • 21, 25 and 27 before their fixes. The OpenJDK risk matrix marks CVE-2026-114938 against 17, 21, 25 and 27 and leaves 8 and 11 blank.
  • End-of-life feature releases (18 to 20, 22 to 24, 26) carry the same code and get no fix, per JFrog and Cycode. Amazon lists "No Fix Planned" for Corretto 22, 23, 24 and 26.
  • Every OpenJDK distribution. Calif names 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 for JDK.
  • One Java 8 exception. Oracle lists 8u511b33-perf, the Java 8 Enterprise Performance Pack, as affected. The Hacker News points to Oracle's 8u371-perf release notes, which added a "Base64 Decoding optimization for x86 using AVX-512" to that pack. Standard Java 8 is not affected.
  • Not affected: Eclipse OpenJ9 (JFrog), which is a different JVM.

2. The CPU

The vulnerable code only exists in the AVX-512 stub, so the host needs an x86-64 CPU exposing all four flags. Calif's check, which I would put in every runbook:

● ● ●BASH
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
# Exposed only if all four flags print

Calif names the mainstream families that qualify: Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids, and AMD EPYC and Ryzen on Zen 4 or newer. ARM64 is not affected: AWS Graviton and Apple silicon run different decoder code.

That hardware gate is why the reach of this bug is genuinely hard to estimate. LiveOverflow asked about it less than an hour after the patch:

◆ EMBED𝕏 POST

The honest answer is "it depends on the node." JFrog and Upwind both point out that newer AWS families such as c6i, m6i, c7i, c7a and m7a do qualify, and JFrog adds that many older generations, burstable types and every Graviton instance do not. The consequence for defenders: the same container image can be exploitable on one node and safe on the next, and a rescheduling or instance resize can move it from one to the other. Use the CPU check to order your work, not to close tickets.

3. The JIT state

The stub only runs once C2 has compiled the decode path and UseBASE64Intrinsics is on, which is the default on capable CPUs. Turning off the intrinsic, or turning off AVX-512, closes this gate. That is what both mitigation flags do.

4. The input

Attacker-controlled bytes have to reach the basic or URL decoder of java.util.Base64 (Upwind names Base64.getDecoder() and getUrlDecoder()). In practice that is extremely common, which is why JFrog describes it as something that "usually happens before any authentication check." Do not clear a service because your own code never calls the decoder: frameworks and libraries do it for you, as Upwind's Spring Security, Tomcat, Jetty and java-jwt findings show.


How severe is Java4Shell? Why the scores disagree

Four base scores and one SSVC decision:

ScorerScoreVersionVector / note
Calif (finder)9.2 CriticalCVSS 4.0Vector not published on Calif's page
Oracle (CNA), OpenJDK advisory8.1 HighCVSS 3.1AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H
Red Hat9.8 CriticalCVSS 3.0AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Amazon Linux8.8 ImportantCVSS 3.1AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
CISA ADP (SSVC)Exploitation: none, Automatable: no, Technical impact: totalSSVC 2.0.3Recorded 21:53 UTC on Nov 17

They agree on most of it: network-reachable, no user interaction, total compromise of confidentiality, integrity and availability. They disagree on two levers.

Attack complexity. Oracle says High, and its CVE description calls it a "Difficult to exploit vulnerability." That reflects everything in the exploitation section: heap grooming, a per-application profile, network timing. Red Hat says Low, and gives its reason directly: "public research has demonstrated working exploits against multiple widely deployed Java applications in their default configurations." Flipping AC from High to Low with everything else equal moves a CVSS 3.x score from 8.1 to 9.8. That one field is the whole gap between the two.

Privileges required. Amazon scores PR:L and describes the impact as "a JVM crash for unauthenticated users or, in certain application environments, code execution by an authenticated low-privileged user." That reads more conservatively than Calif's list of six pre-auth RCEs. It is Amazon's scoring choice for its packages; it does not mean the pre-auth chains do not exist.

Calif's 9.2 is on CVSS 4.0, which is not directly comparable with the 3.x numbers at all. The weakness classification differs slightly too: CISA's enrichment tags it CWE-122 (heap-based buffer overflow) and Red Hat uses CWE-787 (out-of-bounds write). Both are accurate.

My read: score it by your exposure, not by the lowest number. If you run Keycloak or Jenkins on Ice Lake or Zen 4 and it faces the internet, Red Hat's 9.8 describes your situation better than Oracle's 8.1. If every JVM you have runs on Graviton, it is a version bump in your next maintenance window.


The Java4Shell disclosure timeline

The disclosure did not go to plan. Oracle reserved the CVE ID on October 22. On the morning of November 17, before the patch existed, Calif posted that the bug had leaked:

◆ EMBED𝕏 POST

Since the vulnerability has leaked: Calif discovered and reported Java4Shell (CVE-2026-114938). We're publishing technical details by 1 PM Pacific today, after Oracle releases a patch. Stay tuned!

Calif
Calif
@calif_io

19e1b44520669be6269a485a3f361de95e800e68cb6d880285f5d5f4b34bf10f

3.6K
Reply

In the hours before the patch, watchTowr published an FAQ (16:23 UTC) describing a "reported" RCE with no confirmed component or fix, and The Hacker News ran a story noting that Oracle had pre-announced 11 Java SE fixes with a maximum CVSS 3.1 of 8.1, but that nothing yet tied CVE-2026-114938 to them. Upwind and Equixly separately read the OpenJDK source and pointed at the AVX-512 Base64 decoder. Then, per Calif, OpenJDK released its advisory and Oracle its patch at 1:00 PM Pacific (21:00 UTC), and Calif followed with the full write-up. The advisory page itself only carries a "Last update: 2026/11/17 17:44 UTC" footer, and the CVE record went public at 21:32 UTC. Those early "unconfirmed" and "no fix yet" statements were accurate when written and were stale by that afternoon.

A few details worth knowing about the patch itself:

  • Oracle shipped it as a Critical Security Patch Update (CSPU), which Oracle describes as "targeted, high-priority security fixes in a smaller, more focused format" that complement its quarterly Critical Patch Updates (The Hacker News reports Oracle started this monthly cycle in May). The November CSPU had 655 patches across Oracle products, 11 of them in Java SE, and Oracle notes all 11 Java SE issues may be remotely exploitable without authentication.
  • Oracle's acknowledgements credit two reporters for CVE-2026-114938: Albert Yang and Quang Luong of Calif.io.
  • Calif's write-up credits Quang Luong for the research, write-up and exploits, and Jenish Rakholiya for exploit improvement.

Fixed versions: what to upgrade to

The simplest rule of thumb comes from Symantec: Oracle's fixed builds end in ".1", and the same version number without that suffix remains vulnerable. That holds for Oracle-numbered builds. Other vendors number their builds their own way, so check the vendor, not the pattern.

Vendor / distro17212527Status (sources read Nov 18 to 19)
Oracle JDK17.0.21.121.0.13.125.0.5.127.0.1.1Fixed Nov 17. Java 8 Performance Pack: 8u513-perf (JFrog, Qualys)
OpenJDK advisoryaffected up to 17.0.21.0.3up to 21.0.13.0.3up to 25.0.5.0.3up to 27.0.1.0.3Fixed in the Nov 17 release
Azul Zulu17.0.21.1+221.0.13.1+225.0.5.1+227.0.1.1+4Fixed, release notes dated Nov 17
Amazon Corretto17.0.21.1.221.0.13.1.225.0.5.1.227.0.1.1.4Corretto changelogs list CVE-2026-114938, released Nov 17; Amazon Linux advisories dated Nov 17 (AL2 for 17; AL2023 and AL2027 preview for 17, 21, 25, 27). Docker Hub images keep the plain tag, so pull again (Cycode)
Eclipse Temurin binaries17.0.21.1+221.0.13.1+225.0.5.1+227.0.1.1+4Adoptium API lists all four as updated Nov 18
eclipse-temurin Docker images17.0.21_921.0.13_925.0.5_8-Still pre-fix on Docker Hub on Nov 19
Debian17.0.21.1+2-121.0.13.1+2-125.0.5.1+2-127.0.1.1+4-1Fixed in unstable only; bookworm, trixie and forky listed vulnerable
Red HatRHEL 8, 9, 10 and Red Hat build of OpenJDK 17, 21, 25 affectedRated Critical; bulletin RHSB-2026-018 listed no errata yet (last updated Nov 18)
Microsoft Build of OpenJDK17.0.21.121.0.13.125.0.5.1Release notes (page updated Nov 18) list these against the Nov 17 advisory; Cycode's Nov 18 check had found no fix yet. 17.0.21.0.2, 21.0.13.0.2 and 25.0.5.0.2 are affected

Two traps hide in that table:

  1. Microsoft's 17.0.21.0.2 looks newer than 17.0.21 but is not fixed. Version strings with extra components are easy to misread in a scanner. The fix is the vendor's build for the November 17 advisory (for Microsoft, 17.0.21.1).
  2. Binaries and images ship separately. Adoptium had fixed Temurin binaries out on November 18, but a Dockerfile that says FROM eclipse-temurin:21 was still getting 21.0.13+9 on November 19. More on that in my checks below.

Red Hat's bulletin also lists the Red Hat build of Keycloak (26.6 and later, and 26.4) and Red Hat Single Sign-On 7.6 on OpenJDK 17 as affected, and gives Keycloak-specific mitigation steps. Many of the products on Calif's list bundle their own JDK, so updating the host's Java package does not fix them. Follow each product's own update.


How I checked it on my M3 Pro

I checked how the mitigation flags behave, and whether this can be tested locally at all. On November 19, I ran the official eclipse-temurin:21 image under OrbStack on my Apple M3 Pro laptop: once natively on arm64, and once as linux/amd64 under emulation. I did not run Calif's trigger, I did not have an AVX-512 machine, and I did not exploit anything. Everything below is version, flag and tag checks.

◆ IMG800×600
Three terminal panels from November 19 2026: native arm64 eclipse-temurin:21 reports Temurin 21.0.13+9 with UseBASE64Intrinsics true, refuses to start with -XX:UseAVX=2, and starts with -XX:-UseBASE64Intrinsics; emulated linux/amd64 shows none of avx, avx2, avx512f, avx512bw, avx512vbmi or bmi2, UseAVX 0 and UseBASE64Intrinsics false, and also starts with -XX:-UseBASE64Intrinsics; Docker Hub eclipse-temurin tags top out at 21.0.13_9 while the Adoptium API lists 21.0.13.1+2
↳ Three terminal panels from November 19 2026: native arm64 eclipse-temurin:21 reports Temurin 21.0.13+9 with UseBASE64Intrinsics true, refuses to start with -XX:UseAVX=2, and starts with -XX:-UseBASE64Intrinsics; emulated linux/amd64 shows none of avx, avx2, avx512f, avx512bw, avx512vbmi or bmi2, UseAVX 0 and UseBASE64Intrinsics false, and also starts with -XX:-UseBASE64Intrinsics; Docker Hub eclipse-temurin tags top out at 21.0.13_9 while the Adoptium API lists 21.0.13.1+2

1. Native arm64: not affected, and -XX:UseAVX=2 kills the JVM

● ● ●BASH
docker run --rm eclipse-temurin:21 java -version
docker run --rm eclipse-temurin:21 uname -m
docker run --rm eclipse-temurin:21 java -XX:+PrintFlagsFinal -version | grep -E "UseBASE64Intrinsics|UseAVX "
● ● ●TEXT
openjdk version "21.0.13" 2026-10-20 LTS
OpenJDK Runtime Environment Temurin-21.0.13+9 (build 21.0.13+9-LTS)
OpenJDK 64-Bit Server VM Temurin-21.0.13+9 (build 21.0.13+9-LTS, mixed mode, sharing)

aarch64

     bool UseBASE64Intrinsics                      = true                                      {product} {default}

So the ARM JVM does use a Base64 intrinsic, but it is the aarch64 one, not the x86-64 AVX-512 stub. Orca notes that ARM hosts "use different decoder code," and Red Hat, Calif and JFrog all list ARM64 as not affected. Notice what is missing too: there is no UseAVX line at all, because, as JFrog puts it, "UseAVX is an x86-only flag." That is exactly what bites the next command:

● ● ●BASH
docker run --rm eclipse-temurin:21 java -XX:UseAVX=2 -version
● ● ●TEXT
Unrecognized VM option 'UseAVX=2'
Error: Could not create the Java Virtual Machine.
Error: A fatal exception has occurred. Program will exit.
exit=1

The JVM refuses to start. Calif warns about this ("OpenJDK on ARM doesn't recognize it and will fail to start"), and seeing it fail took one command. The operational consequence is the important part: if someone pushes -XX:UseAVX=2 into a JAVA_TOOL_OPTIONS value, a Helm chart default or a base image that is shared by x86 and ARM nodes, every ARM JVM that picks it up will fail at startup the same way (I passed the flag on the command line; Upwind makes the same point about another bad flag, -XX:DisableIntrinsic=_base64_decodeBlock: "Pushed through JAVA_TOOL_OPTIONS, it is a fleet-wide outage"). In Kubernetes, that is a fleet of pods crash-looping because of a mitigation for a bug they were never vulnerable to. Semgrep's runbook says to flag any use of -XX:UseAVX=2 in configuration shared with ARM systems for this reason.

The other flag behaves well:

● ● ●BASH
docker run --rm eclipse-temurin:21 java -XX:-UseBASE64Intrinsics -version
● ● ●TEXT
openjdk version "21.0.13" 2026-10-20 LTS
OpenJDK Runtime Environment Temurin-21.0.13+9 (build 21.0.13+9-LTS)
OpenJDK 64-Bit Server VM Temurin-21.0.13+9 (build 21.0.13+9-LTS, mixed mode, sharing)
exit=0

-XX:-UseBASE64Intrinsics is accepted on ARM, and in the emulated amd64 container below it starts too. I only verified that the JVM starts with it; for x86-64 hardware that actually has AVX-512 VBMI, Upwind reports that the same flag "stopped the overflow on every affected version we tested." That is why it is the mitigation I would put in shared configuration, and the one Red Hat and Qualys list as preferred.

2. Emulated amd64: no way to test this on my Mac

Next, the same image under x86-64 emulation (OrbStack uses Rosetta here). All of these ran inside docker run --rm --platform linux/amd64 eclipse-temurin:21 ...:

● ● ●BASH
uname -m
grep -m1 ^flags /proc/cpuinfo | tr " " "\n" | grep -E "^(avx512f|avx512bw|avx512vbmi|bmi2|avx2|avx)$"
java -XX:+PrintFlagsFinal -version | grep -E "UseBASE64Intrinsics|UseAVX "
java -XX:UseAVX=2 -version
java -XX:-UseBASE64Intrinsics -version
● ● ●TEXT
x86_64

exit=1

      int UseAVX                                   = 0                                    {ARCH product} {default}
     bool UseBASE64Intrinsics                      = false                                     {product} {default}

OpenJDK 64-Bit Server VM warning: UseAVX=2 is not supported on this CPU, setting it to UseAVX=0
openjdk version "21.0.13" 2026-10-20 LTS
OpenJDK Runtime Environment Temurin-21.0.13+9 (build 21.0.13+9-LTS)
OpenJDK 64-Bit Server VM Temurin-21.0.13+9 (build 21.0.13+9-LTS, mixed mode, sharing)
exit=0

openjdk version "21.0.13" 2026-10-20 LTS
OpenJDK Runtime Environment Temurin-21.0.13+9 (build 21.0.13+9-LTS)
OpenJDK 64-Bit Server VM Temurin-21.0.13+9 (build 21.0.13+9-LTS, mixed mode, sharing)
exit=0

The emulated CPU exposes none of avx, avx2, avx512f, avx512bw, avx512vbmi or bmi2 (the grep printed nothing and exited 1). The JVM picks UseAVX = 0 and turns the Base64 intrinsic off entirely, and -XX:-UseBASE64Intrinsics starts normally, with nothing left to switch off. So on my M3 Pro, the vulnerable stub is unreachable even when the container pretends to be x86. If you want to test a fix, you need real AVX-512 VBMI hardware, like Upwind's c6i.

There is a useful contrast in the last command. On x86-64, -XX:UseAVX=2 on a CPU without AVX only prints a warning, falls back, and starts. On ARM, the same flag is fatal. That asymmetry is exactly why it is dangerous in a mixed fleet: it will look harmless in every x86 test you run.

3. Image tags: the fix was out, the image was not

Finally, I listed the official eclipse-temurin tags on Docker Hub and compared them with the latest Temurin binaries in the Adoptium API. These are the queries for 21 (the same ran for 17 and 25), with each JSON reply reduced to version and last-updated pairs:

● ● ●BASH
curl -s "https://hub.docker.com/v2/repositories/library/eclipse-temurin/tags?page_size=50&name=21.0.13"
curl -s "https://hub.docker.com/v2/repositories/library/eclipse-temurin/tags?page_size=10&name=21.0.13.1"
curl -s "https://api.adoptium.net/v3/assets/latest/21/hotspot?architecture=x64&image_type=jdk&os=linux&vendor=eclipse"

Output, trimmed:

● ● ●TEXT
[('21.0.13_9-jdk', '2026-11-16'), ('21.0.13_9-jdk-alpine', '2026-11-05'), ... ('21.0.13_9-jdk-noble', '2026-11-19'), ... ('21.0.13_9-jdk-ubi9-minimal', '2026-11-19'), ...]
[('17.0.21_9-jdk', '2026-11-16'), ...]
[('25.0.5_8-jdk', '2026-11-16'), ...]
adoptium 17: [('17.0.21.1+2', '2026-11-18')]
adoptium 21: [('21.0.13.1+2-LTS', '2026-11-18')]
adoptium 25: [('25.0.5.1+2-LTS', '2026-11-18')]
# 21.0.13.1: []   17.0.21.1: []   25.0.5.1: []

The newest tags are 17.0.21_9, 21.0.13_9 and 25.0.5_8, the searches for .1 tags came back empty, and the plain eclipse-temurin:21 tag pulled Temurin-21.0.13+9 in the arm64 run above. Some 21.0.13_9 variants were even refreshed on November 18 and 19, which makes them look current in a registry UI while still carrying the pre-fix JDK. So on November 19, a rebuild of anything FROM eclipse-temurin:21 was still pulling 21.0.13+9, a build Upwind found vulnerable on AVX-512 hardware. (Cycode reported on November 18 that Temurin 17 was still pending; by the time I checked, the Adoptium API listed 17.0.21.1+2 as well.)

The practical lesson: "rebuild your images" is necessary but not sufficient. Check what the rebuilt image actually contains with java -version before you mark it done. If your base image lags, apply -XX:-UseBASE64Intrinsics until it catches up, or install the fixed binary directly.


Defender playbook: find it, patch it, watch for it

Step 1: inventory every JVM, not just packages

CISA's first action item is to review inventory for JDKs and runtimes "including those bundled with third-party applications or included in container images and appliances," with the warning that they "may not appear as separate entries in software inventories." Semgrep's runbook names Jenkins, Elasticsearch, Kafka, Keycloak, Jira and Confluence as examples of products that bundle their own runtime, and suggests searching for the JVM library itself (libjvm.so, jvm.dll, libjvm.dylib) rather than only the java on the PATH, and finding running JVMs by the library they have loaded, since products with their own launcher do not show up as a process named java.

Step 2: check the CPU, the way the JVM sees it

● ● ●BASH
# The host's view (Calif's check). Exposed only if all four print.
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'

# The JVM's own view of CPU features (from Semgrep's runbook)
java -Xlog:os+cpu=info -version

On Kubernetes, Semgrep points at the Node Feature Discovery label feature.node.kubernetes.io/cpu-cpuid.AVX512VBMI to find which nodes qualify.

Step 3: check the version the workload actually runs

● ● ●BASH
# On a host
java -version

# Inside an image, without trusting its tag (Cycode)
docker run --rm --entrypoint java <image> -version

Compare against your vendor's fixed build in the table above. Remember that java -version in your shell is not necessarily the runtime your service uses.

Step 4: patch, restart, rebuild, verify

  • Install the vendor's fixed build. Oracle: 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1.
  • Restart every JVM. A running JVM keeps the vulnerable code until it restarts. Symantec, Cycode and Qualys all repeat this, and it is the easiest step to skip.
  • Rebuild images and check the result with java -version, because a base image tag can lag the binaries (see my Temurin check).
  • For products that bundle Java, use the product's supported update, not a host package.
  • Do not leave end-of-life feature releases (18 to 20, 22 to 24, 26) in place. They get no fix; move to 17, 21, 25 or 27.

Step 5: if you cannot patch today, mitigate with the right flag

OptionWhat it doesCaveats
-XX:-UseBASE64Intrinsics (preferred)Turns off the hardware-accelerated Base64 code; Java falls back to its built-in decoderBase64-heavy workloads may slow down. Accepted on ARM too (I checked it starts on arm64 and on emulated amd64)
-XX:UseAVX=2Turns off AVX-512 on x86-64, which removes the vulnerable pathx86-64 only. ARM JVMs refuse to start (I reproduced this). Broader performance cost. Orca notes that on 21 and later the Base64 intrinsic stays active through its AVX2 path
-XX:DisableIntrinsic=_base64_decodeBlock aloneDo not useSymantec and Upwind both report it stops the JVM from starting; pushed fleet-wide it is an outage

Getting the flag into the running process is the hard part:

  • JAVA_TOOL_OPTIONS is read when the JVM itself is created (JNI_CreateJavaVM), not by the java launcher, so it also reaches JVMs that a product starts with its own launcher. That is why it is the common delivery route. Semgrep's runbook notes the precedence order (JAVA_TOOL_OPTIONS, then JDK_JAVA_OPTIONS and the command line, then _JAVA_OPTIONS), so a later source can override it.
  • A container must be recreated, not just restarted, to pick up a new environment variable (Semgrep, Upwind).
  • Red Hat's bulletin gives product-specific routes, for example JAVA_OPTS_APPEND for Keycloak, and verifies the running JVM rather than the config file:
● ● ●BASH
jcmd <pid> VM.flags -all | grep -F UseBASE64Intrinsics
# expect: bool UseBASE64Intrinsics = false

A mitigated JVM is not a fixed JVM. Track the two separately and remove the flag when the patched build is in place.

Step 6: what CISA's compensating controls do and do not buy

CISA suggests, where patching is not feasible, "restricting and validating Base64 input at the application boundary, enforcing input-size limits, and limiting unauthenticated access." Two of those need a caveat:

  • Size limits alone will not stop it. As Qualys points out, the malformed input is very short. The trigger is 65 characters. No sane limit on an Authorization header is below that.
  • Limiting unauthenticated access is the strongest of the three. Qualys suggests taking identity, build and collaboration consoles off the open internet, or putting them behind a VPN, until they are patched. For Keycloak, PingFederate, Jenkins, Artifactory, Jira and Confluence, that removes the pre-auth path Calif demonstrated.
  • A buffering reverse proxy is not a control. Calif says request buffering breaks some chains but not the Elasticsearch one, and not WebSocket traffic after an upgrade.

Step 7: detection signals

Semgrep's point comes before any list: patch or mitigate first, because "a memory-corruption exploit may leave little behind." With that said, these are the signals the vendor write-ups agree on, as leads rather than proof:

  • Unexpected JVM crashes and new hs_err_pid*.log files on internet-facing services. CISA lists "unexpected JVM crashes" alongside "rogue runtimes" and "suspicious Java processes." A failed grooming attempt can crash the JVM, and Calif says attackers can retry.
  • Bursts of IllegalArgumentException from java.util.Base64$Decoder in application logs (Semgrep, Upwind). Symantec gives the message to grep for: "Input byte array has wrong 4-byte ending unit." Because the exception is thrown after the overflow, Symantec notes it indicates an attempt, not a blocked attack.
  • Request shape: Upwind suggests Base64-alphabet tokens of 32 characters or more that end in = with a length that is not a multiple of 4, starting with Authorization headers. A legitimate padded Base64 string always has a length that is a multiple of 4, so this is a cheap filter.
  • Java processes doing new things: spawning a shell or opening outbound connections they have not made before (Qualys).

If a service was exposed and unpatched, also assume the JavaBleed part may have happened. Red Hat's statement says successful exploitation can "read adjacent heap memory that may contain credentials, private keys, and session tokens." Rotating the secrets that service held is cheap insurance.

Patch order

Qualys suggests an order I agree with, because it follows Calif's pre-auth list:

  1. Internet-facing identity providers: Keycloak, PingFederate.
  2. Internet-facing Jira, Confluence, Jenkins and Artifactory.
  3. Other internet-facing Java services that handle logins, tokens or file uploads.
  4. Internal systems, starting with Kafka, Solr, Elasticsearch, Gerrit and Spinnaker.

I would add, following Upwind: Java clients that open outbound TLS connections, because of the client-side exploit.


Calif's bigger argument: "vibe-uncoding" and the AI angle

Two parts of Calif's write-up go beyond the bug, and they are worth reading as Calif's arguments rather than settled fact.

The optimization few needed. Calif calls it a tragedy of the commons. Java grew features to serve many needs, and "everyone inherits the added complexity." The AVX-512 Base64 path helps applications that decode huge amounts of data, "but the code ships to everyone else too, including applications that gain little from it. On affected systems, an optimization few applications needed became a serious security risk." Their proposal is what they call vibe-uncoding: "identify the parts a system actually needs, then remove everything else to reduce its attack surface." They close with: "maybe the right question for security is, 'What can we delete?'"

I find this persuasive in this specific case, and the mitigation makes the point: -XX:-UseBASE64Intrinsics switches the optimization off at runtime, and the JVM keeps working on its built-in decoder. Calif's own question: "Do you need that hand-rolled assembly Base64 decoder to process a few hundred bytes? Probably not." Calif makes the same point about its earlier find, Squidbleed, "an older cousin of Heartbleed" that hid in the Squid proxy's FTP module since 1997, in a protocol Calif argues should simply be removed. Deleting code is harder than it sounds, as Calif admits: "An apparently unused feature may have hidden dependencies." But the question "do we need this hand-rolled fast path at all?" is a good one to ask of any runtime option you inherit by default.

AI-assisted discovery. Calif says it "used AI to find and weaponize Java4Shell," and gives specific numbers:

  • Quang Luong audited HotSpot by pointing Codex at the JIT compiler, intrinsics, widely accessible APIs and cryptography. Most early results were, in his word, "slops," either unreachable or unrealistic to exploit.
  • The "sheer persistence" that eventually produced the Base64 finding was, per his note, "prompting AI and ignoring slops for around 20 minutes."
  • Calif says it took an hour to discover the vulnerability and two more hours to develop the first working exploit, at a total token cost of less than $200.
  • The AI got stuck on heap grooming, so Calif wrote a small heap tracer and visualizer to feed it heap state. After initial pipelines were built, Calif says "most of the later chains are built almost autonomously with AI."

Calif's term for this is the "centaur hacker, part human, part AI." I cannot verify the timings independently, and the discovery story is Calif's own account. What I can say is that the defensive implication does not depend on the exact numbers: Qualys put it plainly, "Expect others to repeat that work." The bug is a short malformed string, the root cause and the general technique are public, and the only thing being held back is the per-product chains. Oracle also credits a second reporter for this CVE, Albert Yang; if that was an independent find, it is one more sign the bug was findable.


FAQ

What is Java4Shell (CVE-2026-114938)?

Java4Shell is a heap out-of-bounds write in the x86-64 AVX-512 VBMI Base64 decoder intrinsic that OpenJDK's HotSpot JVM uses after C2 JIT compilation. A malformed padded tail makes the output length underflow to -1, the store mask becomes all ones, and a 65-character input writes 62 bytes past the end of a 50-byte array. Calif turned it into heap disclosure ("JavaBleed") and remote code execution in several products.

Which Java versions are affected and which are fixed?

OpenJDK 17.0.6 and later, plus 21, 25 and 27, from every vendor, are affected when they run on x86-64 CPUs with avx512f, avx512bw, avx512vbmi and bmi2; Oracle also lists its 8u511b33-perf build. Oracle's fixed builds are 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1, released November 17, 2026, and Azul, Amazon Corretto, Temurin, Microsoft and Debian unstable have matching fixed builds. Standard Java 8 and 11 are not affected.

Is my ARM server or Apple silicon Mac affected?

No. The vulnerable code exists only in the x86-64 AVX-512 stub, and ARM64 JVMs use different decoder code. On my M3 Pro, the native arm64 Temurin 21 image used its own aarch64 intrinsic, and the emulated amd64 image exposed none of the AVX, AVX2, AVX-512 or BMI2 flags, so the JVM chose UseAVX=0 and turned the Base64 intrinsic off.

How do I mitigate Java4Shell if I cannot patch today?

Start the JVM with -XX:-UseBASE64Intrinsics, which disables the hardware-accelerated Base64 code and is accepted on ARM too, then restart or recreate the process and verify the running flag. Use -XX:UseAVX=2 only on x86-64 hosts, because an ARM JVM refuses to start with it, and never use -XX:DisableIntrinsic=_base64_decodeBlock on its own.

Is Java4Shell being exploited in the wild?

Symantec and Cycode, both writing on November 18, 2026, and Upwind reported no exploitation in the wild, and Cycode and Upwind noted it was not in CISA's Known Exploited Vulnerabilities catalog. Calif is holding back its product-specific exploit chains until people have had time to upgrade, but the root cause and the trigger string are public.

◆ KEY TAKEAWAY

Java4Shell is what happens when a performance shortcut meets a stray =: a tail-length underflow in HotSpot's AVX-512 VBMI Base64 stub turns into a 64-byte masked store and a 62-byte heap overflow, and Calif turned that into JavaBleed and pre-auth RCE in identity and CI/CD products. Exposure needs all four gates on the same JVM: OpenJDK 17.0.6+ (or 21, 25, 27), an x86-64 CPU with avx512f, avx512bw, avx512vbmi and bmi2, a C2-compiled decoder, and untrusted Base64 input. Patch to your vendor's fixed build (Oracle's ".1" releases), restart every JVM, and check what your rebuilt images actually contain, because on November 19 eclipse-temurin:21 still pulled 21.0.13+9. If you need a stopgap, use -XX:-UseBASE64Intrinsics, not -XX:UseAVX=2: I watched the second one stop an ARM JVM from starting.


References

© 2026 Dhruv VakharwalaNext.js · TypeScript · Tailwind · Cloudflare