Threat Advisories

Java4Shell: A Ubiquitous Threat

Written by UltraViolet Cyber | Nov 18, 2026, 6:01:03 PM

Executive Snapshot

On November 17, 2026, Oracle and the OpenJDK project patched CVE-2026-114938, dubbed “Java4Shell” by the discovering researchers. Java4Shell is a critical memory corruption vulnerability in a performance shortcut built into the Java runtime’s Base64 decoder. Simply put, the flaw can let an attacker corrupt memory in ways that lead to either running their own code on an affected system or reading sensitive data sitting nearby in memory. Because the flaw lives in the Java runtime itself rather than in any single application, it affects a wide swath of enterprise software built on OpenJDK 17.0.6 and later, including Oracle Java SE, Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, Red Hat OpenJDK, and Oracle GraalVM.

Security researchers demonstrated working pre-authentication remote code execution, meaning no login required, against default configurations of Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, and PingFederate, and separately showed post-authentication exploitation against Kafka, Solr, Elasticsearch, Gerrit, and Spinnaker. Importantly, there is no universal exploit; each application requires its own tailored exploitation work, and no in-the-wild exploitation has been confirmed as of this writing.

Priorities for addressing this vulnerability:

  • Inventory every system, container image, and bundled JRE running an affected Java version, since the runtime-level fix must still be deployed individually everywhere Java runs.
  • Prioritize patching for internet-facing instances of the pre-authentication-affected platforms named above.
  • Apply the official Oracle/OpenJDK runtime patch rather than waiting on a separate application-specific fix.
  • Treat this as an opportunity to validate and strengthen your organization’s Java asset inventory more broadly.

What UltraViolet Cyber is Doing

  • Tracking new CVEs and high impact vulnerabilities, analyzing and deploying public Proof-Of-Concept code against custom built targets.
  • Proactively enabling custom detections based on the collected artifacts, tactics, techniques, and procedures identified in this activity. UltraViolet is also maximizing detection coverage proactively through Equinox.
  • Performing hypothesis driven threat hunts based on threat actor behavior and artifacts. UVCyber customers will be informed of the results through secure channels.
  • Parsing available victim dump data for any social, financial, business, or technical relations to UVCyber Clients and partner organizations.
  • Aggregating threat intelligence from myriad sources and applying the most up-to-date knowledge to proactive threat hunting and response.


DOWNLOAD THE PDF REPORT


TIDE Team Analysis

Vulnerability Profile

CVE-2026-114938

Name

Java4Shell — OpenJDK Base64 Decoder Heap Overflow

Severity

CRITICAL v4.0 9.2 · HIGH v3.1 8.1

First Exploited

N/A (no confirmed in-the-wild exploitation as of November 18, 2026; vulnerability details reportedly leaked prior to coordinated disclosure).

KEV

Not listed in CISA KEV as of November 18, 2026.

Software

Java SE / OpenJDK (HotSpot JVM) by Oracle / OpenJDK Project

Affected

17.0.6 through 27.0.1 and prior builds (also Java SE 8 Enterprise Performance Pack 8u511b33-perf)

Patch

17.0.21, 21.0.13, 25.0.5, 27.0.1 available from Oracle and OpenJDK since November 17, 2026 — Oracle Security Advisory

On November 17, 2026, Oracle and the OpenJDK project patched CVE-2026-114938, a critical memory corruption vulnerability in the Java runtime that researchers have dubbed “Java4Shell.” The flaw lives in a specific performance feature built into HotSpot (the engine most Java applications run on): a shortcut that uses special processor instructions, known as AVX-512, to decode Base64-encoded data faster than standard code would. According to security researchers, the root cause is a miscalculated boundary check in how that fast-path decoder handles a padded input tail: when a Base64 string’s length doesn’t cleanly divide into the decoder’s expected block size, the routine computes the wrong stopping point for its write operation, causing a fixed-size overwrite past the end of the destination buffer.

This is memory corruption that can be leveraged toward two serious outcomes: an attacker running their own code on the affected system, or an attacker reading sensitive data, such as credentials or private keys, that happens to be sitting elsewhere in that same memory space. Oracle classifies this as CWE-122, a heap-based buffer overflow, and rates it 8.1 (High) under CVSS 3.1; where the researchers rate the same flaw 9.2 (Critical) under CVSS 4.0, a discrepancy that reflects differences in how the two scoring models weigh exploit conditions rather than a disagreement about severity in practice.

The scale of exposure here is genuinely unusual for a single CVE. Because this is a flaw in the JVM itself rather than in any specific application, it affects every major OpenJDK-based distribution from version 17.0.6 onward, including Oracle Java SE, Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, Red Hat OpenJDK, and Oracle GraalVM. Oracle separately lists its Java SE 8 Enterprise Performance Pack as affected as well. In practice, this means the vulnerability isn’t confined to a product category; it’s present in the foundation underneath an enormous share of enterprise Java applications, regardless of what those applications do or who built them. Because the flaw lives in the JVM itself rather than in any individual application, Oracle and OpenJDK’s November 17 fix applies at the runtime level rather than requiring a separate patch from each affected application vendor; however, that patched runtime still has to be deployed to every server, container image, and bundled JRE running an affected version, which is a meaningfully different and often larger undertaking than applying a single vendor’s update.

Security researchers demonstrated that the base memory corruption, on its own, writes fixed bytes that the attacker doesn’t get to choose, and they initially considered it close to unexploitable. Researchers then built a multi-stage technique to turn that fixed overwrite into something more useful: corrupting the length field of an adjacent array to read further into heap memory than intended (a heap-disclosure technique researchers call “JavaBleed”), combined with garbage-collector manipulation to reliably control where objects land in memory. Using this approach, security researchers report achieving pre-authentication remote code execution against default configurations of several widely deployed enterprise platforms, including Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, and PingFederate.

This is an important point for calibrating risk rather than inflating it: Researchers have been explicit that there is no universal, one-click exploit. Each affected application needs its own tailored exploitation chain, built around how that specific application happens to use the vulnerable decoder and what’s sitting in its heap at the time. The firm has stated it is withholding its fully weaponized, per-application exploit chains rather than publishing them alongside the disclosure, and has only released a safe, non-weaponized trigger program that confirms whether a given Java runtime and processor combination reproduces the underlying memory corruption, without attempting code execution. As of this writing, there is no confirmed exploitation in the wild, and the vulnerability is not yet listed in CISA’s Known Exploited Vulnerabilities catalog.

Two details are worth flagging for awareness rather than alarm. First, the vulnerability reportedly leaked prior to coordinated disclosure, and a South Korean NCSC advisory flagged an unauthenticated Java RCE a day before Oracle’s patch, suggesting the window between knowledge of the flaw and defensive readiness was already narrowing before the public CVE existed. Second, the researchers’ account of the discovery is itself notable: they reportedly used an AI coding agent to audit HotSpot’s JIT compiler and cryptographic intrinsics, finding the bug in roughly an hour and producing a working exploit two hours later, at a total token cost under $200. Whatever one makes of that specific framing, it’s a useful, concrete example of a broader pattern this organization has already been tracking: AI tooling is increasingly capable of turning up genuinely exploitable bugs on its own, and doing so faster and more cheaply than the traditional manual research process this kind of discovery used to require.

Why It Matters

The most immediate reason this matters is scale, and that scale shows up twice: once in how many applications are built on an affected Java version, and again in how much work patching actually involves once you account for where those applications run. Because the vulnerability lives in the JVM rather than in any individual product, there’s a genuine simplification on the vendor side: you’re tracking one fix rather than a dozen separate advisories from Atlassian, Jenkins, JFrog, and every other affected vendor. But that simplification doesn’t extend to deployment. Every server, VM, or container with its own Java installation needs that installation updated individually, and environments with bundled or embedded JREs, where an application ships its own private copy of Java rather than relying on a shared system install, need those identified and patched separately, since a routine “update Java on this host” sweep won’t reach them. For most organizations, this makes a thorough internal audit the real first step: which systems run Java, which version, and where that Java installation actually lives, system-wide or bundled inside a specific application.

That audit should prioritize by reachability, not just by presence. The findings of researchers draw a meaningful line between applications where they demonstrated pre-authentication remote code execution, meaning no valid login is required at all, including Keycloak, Jira, Confluence, Artifactory, Jenkins, and PingFederate, and a separate set where exploitation required valid credentials first, including Kafka, Solr, Elasticsearch, Gerrit, and Spinnaker. Internet-facing instances of the pre-authentication-affected platforms deserve to move to the front of the patching queue, since they’re reachable by anyone who can reach the application at all. Post-authentication-affected platforms and internal-only systems still need the same underlying runtime update; they simply carry a somewhat longer reasonable timeline rather than an open-ended one.

None of this is a reason to treat monitoring as secondary to patching, and it’s worth being direct about that. Researchers have been explicit that there’s no universal exploit here; turning the underlying memory corruption into working code execution took dedicated, application-specific engineering for each named target, and the firm hasn’t published those weaponized chains. That cuts both ways: an application not named in the research isn’t confirmed safe by omission, and an application that is named isn’t automatically compromised just because the flaw exists somewhere in its stack. That genuine uncertainty is precisely why active hunting matters here alongside patching rather than after it. Watching for attempted exploitation, unusual Base64-decoding crashes, or anomalous behavior in Java-based services is a reasonable, valuable use of monitoring resources from day one, independent of how far along your patching rollout is.

Finally, this is a useful moment to reinforce a practice that pays off well beyond this single CVE: maintaining a current software and runtime inventory, including where every Java installation actually lives, system-wide or bundled, is what turns a sprawling, ecosystem-wide disclosure like this one into a short, confident answer rather than a multi-week scramble. Organizations that can produce that answer quickly today are in a meaningfully better position, not just for this vulnerability, but for whatever comes next.

How to Respond

  • Conduct a full inventory of every server, container image, and bundled JRE running an affected OpenJDK version (17.0.6 and later), since the runtime-level patch must be deployed individually to each location rather than applied once centrally.
  • Prioritize patching for internet-facing, pre-authentication-affected platforms first (Keycloak, Jira, Confluence, Artifactory, Jenkins, PingFederate), since these are reachable without any valid credentials and represent the most urgent exposure.
  • Apply Oracle’s November 17 runtime patch, or the equivalent fixed build from your specific OpenJDK distribution (Corretto, Temurin, Zulu, Red Hat OpenJDK, GraalVM), rather than waiting on an application vendor to issue a separate fix.
  • Where immediate patching isn’t feasible on a given system, apply the -XX:-UseBASE64Intrinsics JVM flag as a temporary mitigation to disable the vulnerable hardware-accelerated decoding path.
  • Extend this inventory effort into standard practice going forward, since a current, accurate record of where Java runs and which version it’s on is what turns the next ecosystem-wide runtime disclosure into a fast, confident response rather than a renewed scramble.


What UltraViolet Cyber is Doing

  • Tracking new CVEs and high impact vulnerabilities, analyzing and deploying public Proof-Of-Concept code against custom built targets.
  • Proactively enabling custom detections based on the collected artifacts, tactics, techniques, and procedures identified in this activity. UltraViolet is also maximizing detection coverage proactively through Equinox.
  • Performing hypothesis driven threat hunts based on threat actor behavior and artifacts. UVCyber customers will be informed of the results through secure channels.
  • Parsing available victim dump data for any social, financial, business, or technical relations to UVCyber Clients and partner organizations.
  • Aggregating threat intelligence from myriad sources and applying the most up-to-date knowledge to proactive threat hunting and response.