Report an Incident Become a Partner Careers Contact
Book a Demo
Threat Research

Every JVM You Didn't Know You Had: Finding Java4Shell (CVE-2026-114938) Exposure Before The Exploit Code Lands

Mohammad A'mir · Incident Response & Threat Intelligence Analyst 19 November 2026 8 min read
Four application boxes (Jira, Jenkins, Keycloak, a build agent) each sitting on its own bundled JDK, three marked in red as vulnerable, above a Windows Server layer patched by Windows Update, with a note that the bundled JDKs are not, beside the headline 'Every JVM you didn't know you had'.

On 18 November 2026, Oracle and the OpenJDK project shipped fixes for CVE-2026-114938, a flaw in the Java runtime's Base64 decoder that researchers have named Java4Shell. On the same day CISA urged organisations to patch immediately, warning that "specially crafted Base64 input could crash the JVM and allow for unauthenticated remote code execution."

At the time of writing nobody has reported attacks, the flaw isn't in CISA's Known Exploited Vulnerabilities catalogue, and the researchers are holding back their exploit code. That gives defenders a window. The hard part isn't applying the patch. It's finding every copy of Java that needs it, because many of them won't show up where you expect.

What the flaw is

  • The bug. An out-of-bounds write in the optimised (intrinsic) Base64 decoding routine of the HotSpot JVM on x86-64. It only applies on processors that support the AVX-512 VBMI instruction set. ARM64 systems are not affected.
  • Affected versions. According to The Hacker News' summary of the disclosure, Java 17.0.6 and later, plus Java 21, 25 and 27, along with some GraalVM builds and a Java 8 performance pack.
  • Severity. Oracle scores it 8.1 under CVSS 3.1. The researchers score it 9.2 under CVSS 4.0, and Red Hat's preliminary score is 9.8. If you're unsure how the same bug gets three numbers, our explainer on CVSS covers it.
  • Why it matters. Base64 is everywhere in authentication: basic auth headers, tokens, SAML. The researchers say they have pre-authentication exploits, on default settings, for Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate. They also list targets that need a login, including Kafka, Solr and Elasticsearch.
  • What's been reproduced. Other labs have reproduced crashes and a memory leak. Blackpoint reported crashing a server with about 28,300 malformed login requests in roughly 20 seconds, but did not reproduce full code execution.

One more detail raises the urgency: the input that triggers the bug was posted publicly in an OpenJDK pull request on 9 September. Anyone motivated has had two months' head start.

Why your patch report won't find it

Most Microsoft-centric estates patch Windows well. Java is different, because it usually arrives in one of three ways:

  1. Installed system-wide from a JDK vendor. Your vulnerability scanner probably sees these.
  2. Bundled inside an application. Atlassian products, CI servers, identity platforms, reporting tools and many line-of-business apps ship their own Java runtime in their install folder. Windows Update never touches it, and the vendor of the application, not the JDK vendor, decides when it's updated.
  3. Inside containers and appliances. A container image pins a Java version at build time. A virtual appliance has whatever its vendor put there.

CISA's guidance makes the same point: review your JDK and JRE inventory "including those bundled in third-party apps, container images and appliances". It's the same problem we wrote about in library flaws hiding from your patch report.

Finding Java with Microsoft Defender

These queries are starting points to tune. Defender Vulnerability Management will often map the CVE for you once its data updates, but the bundled runtimes are where the gaps are.

1. Installed JDKs and JREs

DeviceTvmSoftwareInventory
| where SoftwareName has_any ("jdk", "jre", "openjdk", "java", "graalvm", "corretto", "zulu", "temurin")
| summarize Devices = dcount(DeviceId), DeviceList = make_set(DeviceName, 50) by SoftwareVendor, SoftwareName, SoftwareVersion
| order by Devices desc

2. Every java.exe that actually runs, wherever it lives

DeviceProcessEvents
| where Timestamp > ago(30d)
| where FileName in~ ("java.exe", "javaw.exe")
| summarize LastRun = max(Timestamp), Parents = make_set(InitiatingProcessFileName, 10), SampleCmd = any(ProcessCommandLine)
    by DeviceName, FolderPath, ProcessVersionInfoProductVersion
| order by DeviceName asc

Anything under an application folder (for example ...\jre\bin\java.exe inside a product directory) is a bundled runtime. Note who owns that application, because they're the ones who'll need to update it.

3. Java listening on the network

DeviceNetworkEvents
| where Timestamp > ago(7d)
| where InitiatingProcessFileName in~ ("java.exe", "javaw.exe")
| where ActionType == "ListeningConnectionCreated"
| summarize Ports = make_set(LocalPort, 20) by DeviceName, InitiatingProcessFolderPath
| join kind=leftouter (DeviceInfo | summarize arg_max(Timestamp, IsInternetFacing, PublicIP) by DeviceName) on DeviceName
| order by IsInternetFacing desc

Patch internet-facing Java services first, especially anything that handles a login.

If you can't patch today

Fixed builds are available from Oracle and several OpenJDK distributors. At the time of the reporting, some distributors, including the Microsoft Build of OpenJDK, had not yet listed fixed builds, so check your vendor's page rather than assuming.

Until a fix is in place, the researchers' preferred workaround is to switch off the vulnerable optimisation by adding -XX:-UseBASE64Intrinsics to the JVM options and restarting the service. Expect a small performance cost on Base64-heavy workloads. Test it first: one alternative flag reported in the coverage stops the JVM from starting at all. CISA also suggests restricting unauthenticated access to these services and limiting the size of Base64 input at the application edge, for example on a reverse proxy or WAF.

Watching for the first attempts

There are no indicators of compromise yet, so watch for the side effects. The coverage suggests three signals:

  • JVM crash logs. A crash writes an hs_err_pid<n>.log file in the working directory.
  • Bursts of Base64 errors in application logs, such as IllegalArgumentException from java.util.Base64$Decoder.
  • Malformed tokens. Base64 strings of 32 or more characters ending in = whose length isn't a multiple of four, especially in Authorization headers.
DeviceFileEvents
| where Timestamp > ago(7d)
| where FileName startswith "hs_err_pid" and FileName endswith ".log"
| summarize Crashes = count(), First = min(Timestamp), Last = max(Timestamp) by DeviceName, FolderPath
| order by Crashes desc

One crash log is routine. A cluster of them on an internet-facing server, alongside service restarts, is worth an investigation. If your web or proxy logs reach Sentinel, add a check for floods of failed logins with oversized or malformed Authorization headers.

What to do now

  1. Build the list. Run the inventory queries above and add containers and appliances by hand.
  2. Prioritise by exposure. Internet-facing Keycloak, Jira, Confluence, Jenkins and Artifactory first, then anything else that decodes credentials before authentication.
  3. Patch or mitigate. Fixed JDK where you control it. The application vendor's update where the runtime is bundled. The JVM flag where neither is ready yet.
  4. Watch for crashes and malformed-token floods until every service is fixed.

How a managed SOC helps

A disclosure like this tests two things: whether you know where your exposure is, and whether someone notices the first exploitation attempts before they succeed. Our vulnerability and patch management service helps with the first, including the software your Windows patching doesn't cover.

For the second, our SOCs are staffed 24/7. CYBERSHIELD AI investigates each incident as it arrives, with an average time to verdict of 3 minutes 30 seconds, and a senior analyst signs off by default on the managed service. If you think a Java service may already have been hit, a compromise assessment will tell you.

To see it on your estate, talk to us or book a demo.

Java4ShellCVE-2026-114938JavaOpenJDKVulnerability ManagementPatch ManagementDefender Vulnerability ManagementKQLThreat HuntingRemote Code Execution

Ready to see the agents work?

Book a demo of CYBERSHIELD AI against a real scenario.