java4shell-cover

Java4Shell: What We Know Now and What Comes Next

November 17, 2026

Java4Shell: What We Know Now and What Comes Next

Book a Demo

A reported pre-authentication flaw in Java, tracked as CVE-2026-114938 and named Java4Shell, leaked before its patch. Technical details are expected today at 1 PM PT (21:00 UTC). This post reflects what we know as of 19:15 UTC, including our own reading of the OpenJDK source, which is not yet confirmed by Oracle or Calif.

TL;DR

On 17 November 2026, the security firm Calif said it had discovered and reported Java4Shell (CVE-2026-114938), and that the vulnerability had leaked. Calif plans to publish technical details by 1 PM PT (21:00 UTC), after Oracle releases its patch. We flagged it on X and are tracking it as an urgent event. We will update this post after the disclosure.

  • Java4Shell is reported as an unauthenticated remote code execution flaw in Java. Calif found it and reported it to Oracle. The details leaked before the fix.
  • Oracle is shipping 11 Java SE fixes today, without saying which one is Java4Shell. The CVE record is still reserved.
  • The only public root-cause claim points to Java’s AVX-512 Base64 decoder. We read the OpenJDK source and found a bug that matches that claim exactly.
  • By our reading, it is not Java 17 only. The same vulnerable code is in Java 17.0.6 and later, and in Java 21, 25 and 27. Java 8 and 11 do not have it.
  • The reliable outcome we see is a JVM crash, not code execution. The attacker controls when the overflow happens, not what it writes. RCE is not proven.
  • One JVM flag removes the suspected code path. -XX:-UseBASE64Intrinsics is the stopgap to test now.

Status: Our findings come from a code-level model, not a lab run. Oracle’s patch and Calif’s write-up are both expected at 21:00 UTC and may change this picture.

What do we know now?

Confirmed:

  • The discovery. Calif discovered and reported the flaw, and says it leaked.
  • The timing. Calif will publish details by 1 PM PT (21:00 UTC), after Oracle’s patch.
  • Oracle’s update. Oracle’s November Critical Security Patch Update includes 11 Java SE fixes, all remotely exploitable without authentication. The highest CVSS 3.1 score among them is 8.1.
  • The CVE record. CVE-2026-114938 is still reserved.

Reported, not confirmed: Oligo described an integer underflow in the padding handling of OpenJDK’s AVX-512 Base64 decoder, where a crafted 65-byte input causes a 62-byte heap overflow. watchTowr warned that the technical details are still unconfirmed.

What did we find in the OpenJDK source?

A bug that matches Oligo’s description exactly. We read the decoder in Java 17, Java 21 and current OpenJDK, and modeled its length math for every input length from 32 to 1,100 bytes. We did not run it: we had no AVX-512 host.

In one sentence: when a malformed Base64 string ends with padding at the wrong length, the decoder computes an output size of minus one, and that turns a 2-byte write into a 64-byte write.

  • The underflow. A few bytes are left after the decoder’s 64-byte loop, so the output size is zero. The trailing = decrements it to -1.
  • The mask. The CPU instruction that builds the write mask reads only the low 8 bits of that value, so the mask stays fully open.
  • The overflow. The decoder writes 64 bytes where 2 were expected: 62 bytes past the end of the buffer.
  • Oligo’s example reproduces in our model. A 65-byte input produces exactly a 62-byte overflow.
  • Valid input is safe. No valid Base64 string overflowed in our sweep.
  • Catching the exception doesn’t help. The decoder throws an error for the malformed input, but only after the write. The heap is already damaged.

Who would be exposed if this holds?

All four conditions must be true:

  • An affected Java version on x86-64. Java 17.0.6 and later, and Java 21, 25 and 27. Oracle JDK 17 may start at 17.0.7. ARM servers, such as AWS Graviton, never run this code.
  • A CPU with AVX-512 VBMI. Intel Ice Lake, Sapphire Rapids or newer (for example AWS c6i, m6i, c7i), or AMD Zen 4 or newer (c7a, m7a). Skylake and Cascade Lake lack it.
  • Attacker-controlled Base64 reaching Base64.getDecoder() or getUrlDecoder(). The MIME decoder skips this path. In Java 17 the input must be over 128 bytes; in Java 21 and later, over 31. Likely carriers are JWTs, SAML messages and API payloads.
  • A JIT-compiled decoder. That is true on any busy server.

Is this really remote code execution?

Not proven. The 62 bytes written past the buffer are always the same. An attacker chooses when and where the write lands, not what it contains. The reliable result is a corrupted neighboring object and a JVM crash, which is a remote denial of service. Turning fixed bytes into code execution would need careful heap grooming. That may be what Calif shows tonight, and we will update this post either way.

What will we check at 21:00 UTC?

  • The fix. We expect it to change the output-size and mask logic in the decoder’s padding path.
  • The scope. We expect fixes for Java 17, 21, 25 and 27, and none for 8 or 11. Take version numbers from Oracle’s page directly, since secondary sources already disagree.
  • Exploitability. Whether Calif demonstrates code execution or a crash.
  • Other OpenJDK builds. Eclipse Temurin, Amazon Corretto and Azul Zulu have no dates or builds yet.

What should security teams do now?

  • Inventory Java 17, 21, 25 and 27 runtimes. Include hosts, container images and vendor products that ship their own JRE. Run java -version inside the workload, not on the host.
  • Join that list with instance types. Affected versions on Ice Lake, Sapphire Rapids or Zen 4 instances go to the top, internet-facing services first.
  • Test the stopgap now. -XX:-UseBASE64Intrinsics stops the vulnerable code from being generated. -XX:UseAVX=2 also removes the path, but disables other AVX-512 speedups too. Neither is vendor-confirmed, and both slow Base64 decoding.
  • Patch when fixed builds are live, from Oracle and from your OpenJDK vendor.
  • Watch for crashes and odd processes. Unexplained JVM crashes on affected hosts may be exploitation attempts. A Java process that spawns a shell is a stronger signal.
  • Be careful with “PoCs”. Leaked bugs attract fake exploits.

How is Upwind keeping you protected?

Our MDR team is handling Java4Shell as an urgent event and is staffed for the disclosure at 21:00 UTC. We are mapping which customer environments run affected Java versions, and on which instance types, so that the moment the details are confirmed we can tell each customer where they stand. Then we will ship detection rules where the bug allows it, hunt for indicators across customer environments, and contact affected customers directly.

Upwind’s sensor inventories the packages in each workload, including Java runtimes, and maps which workloads face the internet. At runtime it watches process lineage and network activity, so a Java process that starts a shell or reaches out unexpectedly is visible, whatever the exploit looks like.

To learn more about how Upwind finds exposed Java workloads and detects exploitation at runtime, schedule a demo.

Contents
Add the Upwind RSS Feed to Slack
Connect the Upwind RSS Feed to your Slack.
Follow the how-to here.
Threat RSS
Add the Upwind RSS Feed to Slack
Connect the Upwind RSS Feed to your Slack.
Follow the how-to here.
Main RSS