← Back to the cybersecurity blog

Java4Shell (CVE-2026-114938) slips past dependency scanners: how to tell which Java servers are exposed

By Thilina Manana · COO, Director Técnico de Seguridad hard2bit y socio fundador · Published: 19 November 2026 · Updated: 19 November 2026
Java4Shell (CVE-2026-114938)

Dependency scanners will not flag CVE-2026-114938, and many version scanners cannot say whether a given server is exploitable. The flaw, which the researchers at Calif have named Java4Shell, sits in the Base64 decoder of the Java virtual machine and only fires on x86-64 processors with one particular AVX-512 extension. Calif demonstrated unauthenticated remote code execution against default installs of Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate.

Oracle fixed it in its November Critical Security Patch Update, crediting Albert Yang and Quang Luong. Establishing whether a particular server is exposed is harder, because it means joining up three facts that usually sit in different tools: the runtime build, the processor model and what the application does with certain kinds of input.

What can be exploited today, and how serious is it?

Calif rates it 9.2 under CVSS 4.0. Oracle puts it at 8.1 under CVSS 3.1 with high attack complexity, as Tenable's FAQ sets out. The two scales differ, and part of the gap probably comes from the fact that every application needs a bespoke exploitation chain, with a failed attempt liable to crash the service. Red Hat puts it at 9.8 under CVSS 3.0.

As of 18 November the CVE was not in CISA's KEV catalogue, and the Canadian Centre for Cyber Security knew of no active exploitation when it issued alert AL26-029. Check Point reports that independent teams had reproduced the crashes and the memory leak, though not code execution. Tenable adds that GreyNoise has logged exploitation attempts with no confirmed success, and that VulnCheck offers a working exploit to its customers. CISA's SSVC assessment on 18 November rated it as exploitation none, not automatable and total technical impact, and its EPSS score was 0.0073 (55th percentile).

Calif also describes a read primitive, JavaBleed, which pulls contents out of the JVM heap: private keys, tokens or personal data. On an identity provider, a leaked signing key is enough to mint valid tokens without running any code at all.

Timeline: from leak to patch

  • Details leaked before a fix was available, according to Calif, which went public on 17 November.
  • On 17 November at 1pm Pacific time, Oracle released its update and OpenJDK its advisory. Calif then published its technical write-up and a checker that only tests whether a given JVM and CPU combination reproduces the bug, without attempting code execution.
  • The same day, the Canadian Centre for Cyber Security issued alert AL26-029 and CISA issued guidance urging organisations to patch, according to Tenable.
  • By 18 November Keycloak had recommended an interim mitigation, Amazon Corretto and Azul Zulu had fixed builds out and Eclipse Temurin had begun releasing its own. Ubuntu shipped fixed packages on 18 November (through Ubuntu Pro only on 18.04 and 20.04), while Red Hat was still investigating and Debian had fixed only its unstable branch.

That last point shapes the schedule more than any other. Teams relying on their Linux distribution's packages may spend several days with the advisory public and no fixed package to install.

Calif says it found the bug through an AI-assisted audit. If attackers adopt the same approach at scale, the time between a patch appearing and someone knowing how to exploit it may shrink.

How does the bug work, without the recipe?

To speed up Base64 decoding, the HotSpot virtual machine swaps the Java code for a hand-written assembly routine (an intrinsic) on processors that support AVX-512 VBMI instructions. According to JFrog's analysis, the routine has been present in Java 17 since 17.0.6 and in every later release line.

When the input ends in malformed padding, the routine computes a negative output length. Because of the way the processor reads that value, the write mask ends up full, and a 64-byte vector store runs past the end of the destination buffer. Java then rejects the input with an exception, but by then the adjacent memory has already been overwritten. The value written is close to fixed; what the attacker chooses is where it lands.

The routine only comes into play once the C2 compiler has compiled that code path, which on a busy service happens within minutes, JFrog says. Any place where externally supplied Base64 passes through Java's standard decoder can serve as a way in: Basic authentication headers, JWTs, SAML artefacts, CSRF tokens or uploaded files.

Upwind confirmed that Spring Security, Basic authentication in Tomcat and Jetty 12, and Auth0's java-jwt library all hand those values straight to the affected decoder. Calif further describes a client-side variant, in which a Java program connecting over TLS to a malicious server can be compromised, which brings integration servers that call third-party APIs into scope.

Which servers are exploitable?

A server is only exploitable when all three conditions in the table hold. If any one is missing, it cannot be exploited today.

What has to be true for a server to be vulnerable to Java4Shell
ConditionHow to check itWhich tool usually sees it
Affected runtime: OpenJDK and downstream builds from 17.0.6 on the 17, 21, 25 and 27 lines without the fixed build, plus the unsupported 18 to 20, 22 to 24 and 26 lines; for Java 8, only Enterprise Performance Pack 8u511b33-perfThe running process, queried with jcmd, not the installed packageVulnerability scanner or software inventory, if it finds that runtime
x86-64 CPU with AVX-512 VBMI: Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids or Granite Rapids, or AMD Zen 4 and later; ARM64 is not affectedThe avx512f, avx512bw, avx512vbmi and bmi2 flags in /proc/cpuinfoFew: Tenable, for one, warns that its checks look at the Java version, not the processor
Attacker-controlled Base64 reaching Java's standard decoderReview Basic authentication, SAML, JWT and file uploads in each applicationCode analysis, or the development team

Sources: Calif, JFrog, Check Point, Tenable, Qualys and Upwind, consulted on 19 November 2026.

An SBOM and software composition analysis describe the application's libraries, not the JVM running them, and Semgrep warns that dependency scanners will not report this issue because it lives in the runtime. A network scanner picks up the version but not the CPU. Whoever knows the hardware, whether the infrastructure team or the cloud provider, usually cannot say what the application does with an Authorization header.

Inventories tend to break down in three places. Products that ship their own JDK, such as Jira, Confluence or Elasticsearch, are not fixed by updating the system package and need the vendor's release. Container images carry the JDK inside them and do not show up in the host inventory.

In the cloud, a workload can move to another instance family without anyone touching the code. Upwind reproduced the bug on an AWS c6i instance and lists c6i, m6i, c7i, c7a and m7a as examples of affected families. A server running on ARM or an older Xeon today is out of reach only until somebody migrates it, so a negative CPU result does not close the finding if the instance can be moved.

How can exposure be checked server by server?

On Linux, adapting the check published by Calif and Qualys, the four CPU flags can be counted:

# The host meets the hardware condition only if the result is 4.
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -cE '^(avx512f|avx512bw|avx512vbmi|bmi2)$'

For the runtime, the reliable answer comes from the running process, because a service can keep using the old build until it restarts. The jcmd utility ships with the JDK; on images that only carry a JRE, the process command line or the vendor's documentation is needed instead. jcmd has to run as the same user as the JVM and, for containers, inside the container.

# Exact version of the running JVM.
jcmd <pid> VM.version
# Effective value of the two relevant options in that process.
jcmd <pid> VM.flags -all | grep -E 'UseBASE64Intrinsics|UseAVX'

JFrog also publishes a script that combines both checks and labels each host as not x86-64, missing the extensions, without Java, patched or vulnerable.

Detection and containment until the patch is in

None of the sources consulted has yet published indicators of compromise from confirmed attacks, so detection rests mainly on two signals. The first is instability. A failed attempt corrupts memory and can end in a JVM crash, which leaves an hs_err_pid<pid>.log file behind; Check Point also lists garbage collector crashes as a known symptom.

With Microsoft Defender for Endpoint, this query finds those files:

// JVM fatal error files created over the last 14 days.
DeviceFileEvents
| where Timestamp > ago(14d)
| where ActionType == "FileCreated"
// The name the JVM gives its crash report.
| where FileName startswith "hs_err_pid" and FileName endswith ".log"
| project Timestamp, DeviceName, FolderPath, FileName, InitiatingProcessCommandLine
// Sorting by device makes repeated crashes stand out.
| order by DeviceName asc, Timestamp asc

A single hs_err file on a server that was upgraded yesterday proves little. What needs a closer look is an internet-facing service that used to be stable and now crashes repeatedly, especially alongside bursts of IllegalArgumentException from the Base64 decoder in the application logs, another signal Semgrep points to.

The second signal is what follows a successful exploit: the JVM starting command shells or download tools. This query looks for that parent-child relationship:

// Shells and download utilities started by a JVM, directly or through a shell.
DeviceProcessEvents
| where Timestamp > ago(14d)
| where InitiatingProcessFileName in~ ("java", "java.exe", "javaw.exe")
or InitiatingProcessParentFileName in~ ("java", "java.exe", "javaw.exe")
// Child processes of interest.
| where FileName in~ ("sh", "bash", "dash", "cmd.exe", "powershell.exe", "pwsh.exe", "curl", "wget")
// What is rare on each server comes first.
| summarize Executions = count(), First = min(Timestamp), Last = max(Timestamp) by DeviceName, InitiatingProcessFileName, FileName, InitiatingProcessCommandLine
| order by Executions asc

False positives are to be expected. Jenkins starts shells for every build and other Java services legitimately run helper processes, which is why the query sorts from fewest to most executions: the rows that matter are child processes that appear a handful of times on a server where the JVM does not usually spawn them. On Jenkins, the controller matters more than the build agents. If the EDR is a different product, the same logic carries over to its data model.

If the WAF or proxy stores Base64 values from headers or parameters, SentinelOne suggests looking for long values whose trailing padding does not fit the block length. It is a useful retrospective search, limited by the fact that Authorization headers are not usually logged by default. Nor should the proxy be treated as a barrier: Check Point warns that request buffering in a reverse proxy does not stop the attack.

The client-side variant shows up in outbound traffic instead. A Java process opening TLS connections to destinations outside its baseline, particularly if it then crashes or spawns child processes, needs reviewing even on a server that never receives internet traffic.

Since JavaBleed can pull keys and tokens out of memory, where an internet-facing identity provider stayed unpatched the secrets held in it should be treated as compromised and rotated: token signing keys, OAuth client secrets and certificates. On Keycloak or PingFederate that means invalidating active sessions, with the disruption that brings for users, so the work should be coordinated with the incident response team.

Patching, and mitigation where patching is not yet possible

Check Point proposes an order that follows attacker logic: identity providers first (Keycloak, PingFederate), then Jira, Confluence, Jenkins and Artifactory, then other exposed services handling logins, tokens or uploads, and internal systems and Java clients last.

Affected and fixed Oracle Java SE builds
BranchAffectedFixed
1717.0.6 to 17.0.21.0.317.0.21.1
21Up to 21.0.13.0.321.0.13.1
25Up to 25.0.5.0.325.0.5.1
27Up to 27.0.1.0.327.0.1.1
8 Enterprise Performance Pack8u511b33-perf8u513-perf

Branches 18 to 20, 22 to 24 and 26 get no fix, so the route is to move to a supported branch (JFrog). Standard Java 8 and 11 and OpenJ9 are not affected. Each distribution uses its own numbering; Amazon Corretto 17, for instance, is fixed in 17.0.21.1.2 (Qualys).

Where the vendor has not yet shipped a fixed build, two JVM start-up options block the overflow. Neither appears in the Oracle or OpenJDK advisories. Calif proposed them, and Upwind has independently confirmed that they work on every affected version it tested:

  • -XX:-UseBASE64Intrinsics turns off the accelerated Base64 encode and decode routines, so Java falls back to its standard implementation. It may slow applications that process large volumes of Base64, but it is also safe on ARM. Qualys prefers it and Keycloak recommends it.
  • -XX:UseAVX=2 turns off AVX-512 across the whole JVM, with a wider performance cost, and only applies to x86-64.

Check Point notes that -XX:DisableIntrinsic=_base64_decodeBlock on its own can stop Java from starting, because it is a diagnostic option that requires -XX:+UnlockDiagnosticVMOptions. If the option is pushed centrally to a fleet that includes ARM nodes, -XX:UseAVX=2 will take them offline, because on ARM the JVM refuses to start with it. On Elasticsearch the option belongs in a new .options file under config/jvm.options.d/, leaving the main jvm.options untouched. After the restart, jcmd confirms whether the process has picked it up, and the option is removed once the patch is installed.

What should be watched over the coming days?

Two developments would raise the urgency: the CVE entering KEV, and publication of the per-application exploit chains Calif is holding back. A third would change the schedule: fixed packages from Red Hat and Debian stable, which many on-premises installs depend on. The nearest precedent is PHP2Shell, another Calif finding that leaked early and led several public bodies and companies to take their websites offline.

Prioritising with KEV, EPSS and SSVC remains sound, but only once it is known where Java runs and on which processor, and the scanner does not know which processor each service runs on. A runtime inventory that covers container images and embedded JDKs, with the CPU type of every node, shortens the job considerably, for Java4Shell and for the next flaw of this kind; it is groundwork for vulnerability management.

While that inventory is being built, two tasks cannot wait. One is reviewing the attack surface to find Java services published to the internet. The other is a threat hunt for JVM crashes and Java child processes over the past two weeks, which is a quick way to find out whether an attacker beat the patch.

Sources and methodology: Oracle's advisory and the CVE record (CVE.org and NVD); Calif's technical analysis; Ubuntu, Red Hat and Debian advisories; Canadian Centre for Cyber Security alert AL26-029; analysis by Tenable, Check Point, JFrog, Upwind, Qualys, Semgrep and SentinelOne. Information checked as of 19 November 2026.
Disclaimer: the commands, start-up options and queries in this article are provided as defensive reference material and should be tested in a controlled environment before being applied in production. Versions, patch status and exploitation status reflect public information available on 19 November 2026 and may change; the advisory from the Java provider and from each product vendor should always be checked.

Frequently asked questions

What is Java4Shell? ▾

It is the name Calif gave to CVE-2026-114938, an out-of-bounds write in the hardware-accelerated version of OpenJDK's Base64 decoder. Crafted input can leak process memory and, with application-specific work, lead to code execution on the server.

Is running Java 17 or 21 enough to be at risk? ▾

No. An affected build also needs an x86-64 processor with AVX-512 VBMI (Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids or Granite Rapids, or AMD Zen 4 and later) and an application that decodes Base64 received from outside. An ARM64 server on the same Java version cannot be exploited.

Why do dependency scans and SBOMs miss it? ▾

Because the defect is in the JVM that runs the application, not in its libraries. Software composition analysis describes what the project packages; the runtime is usually installed separately, bundled inside the product or baked into the container image.

Which products have been shown to be vulnerable? ▾

Without credentials: the Keycloak and PingFederate identity providers, Atlassian's Jira and Confluence, Jenkins and JFrog Artifactory. With a valid session, Kafka, Solr, Elasticsearch, Gerrit and Spinnaker as well, according to Calif's testing. The researchers stress that the list is not exhaustive.

What can be done if the Linux distribution has no fixed package yet? ▾

Starting the JVM with -XX:-UseBASE64Intrinsics, which disables the accelerated Base64 routines, and checking with jcmd that it is active after the restart. The alternative, -XX:UseAVX=2, carries a bigger performance hit and must not be used on ARM servers. Either is removed once the patch is installed.

Is Java4Shell being exploited? ▾

As of 18 November 2026 there was no confirmed exploitation and no entry in CISA's KEV catalogue. Attempts without confirmed success had been observed, however, and at least one commercial provider holds a working exploit, so the window for patching may close quickly.

Should credentials be rotated if a server was exposed? ▾

For identity providers and other critical internet-facing services that stayed unpatched, it is the prudent choice. The memory leak Calif describes can expose signing keys, OAuth client secrets or tokens, and an orderly rotation costs less than investigating their misuse afterwards.

Want to know what's actually exposed, and what to fix first?

Thirty minutes with a technical consultant — not a salesperson — is enough to get the problem in order: what's exposed right now, what gets fixed this week, what can wait, and what each stage costs. Penetration testing, security audits, vulnerability management, Microsoft 365, SOC/MDR and incident response.

If your situation is different, tell us anyway — we also take one-off questions on cybersecurity and regulatory compliance.

Based in Spain · Working across the EU and LATAM · ENS High · ISO 27001 · We usually reply in under 24 business hours