CyberPeople

Java4Shell: Critical OpenJDK Flaw Threatens Jira, Jenkins and Keycloak

Java4Shell (CVE-2026-114938): Critical OpenJDK RCE Flaw

A critical OpenJDK flaw dubbed Java4Shell (CVE-2026-114938) enables pre-auth RCE in Jira, Jenkins and Keycloak. How to protect your servers.

On November 17, 2026, a new name echoed through the Java world: Java4Shell. Researchers at the security firm Calif found a critical vulnerability not in any single application, but in the very foundation of the platform — OpenJDK, the open-source implementation of Java. According to their findings, an attacker with no account at all can execute arbitrary code on servers running widely used products such as Atlassian Jira and Confluence, Jenkins, Keycloak, JFrog Artifactory, and PingFederate.

The flaw is tracked as CVE-2026-114938. What makes it unusual is that the defect hides in optimized machine code that Java generates on the fly only for x86-64 processors supporting the AVX-512 VBMI instruction set. So it is not one or two products at risk, but an entire class of servers — and the full scale of the impact is still being assessed.

A laptop showing code next to a coffee mug

What happened: a defect in Java's engine itself

Calif discovered and reported the flaw, and on November 17 the OpenJDK Vulnerability Group confirmed it. The same day Oracle released fixed Java builds, and Calif published its technical write-up. The researchers rated the issue 9.2 under CVSS 4.0; Oracle and OpenJDK gave a more conservative 8.1 under CVSS 3.1. Both ratings mean critical or high severity.

Tellingly, the flaw leaked before the official patch. As Upwind notes, the string that triggers the overflow was posted as early as September 9 in the form of a proposed fix (pull request #32781) in the OpenJDK repository. The Upwind and Equixly labs independently reproduced the memory corruption, and CISA issued an alert the same day calling for "immediate" patching.

The disclosure landed during Oracle's November patch cycle: the company shipped 655 patches, 62 of them critical, covering 62 products. By Tenable's count, 249 of the patches address high-severity flaws. So Java4Shell is the loudest issue of this update window, but not the only one.

How the flaw works: Base64, AVX-512 and the "extra equals sign"

Servers constantly decode Base64 data: HTTP Basic authentication headers, SAML artifacts, CSRF tokens, file uploads. This decoding often happens before the server checks whether the user is authenticated. That is exactly why the attack can be carried out without an account.

To speed up decoding, Java uses a dedicated optimized Base64 decoder written in machine code on processors that support AVX-512 VBMI. Once Java sees that this code runs frequently, it compiles it for maximum speed — and that optimized version is where the bug hides.

When the decoder receives a string with an "extra" equals sign at the end — for example, 64 "A" characters followed by a single "=" — the calculation of the output buffer length underflows to a negative value. The decoder writes 62–63 bytes past the end of the allocated memory. Java rejects the string, but only after the write has already happened. This is a classic heap out-of-bounds write.

Colorful programming code on a computer screen

JavaBleed: from buffer overflow to code execution

The bytes written past the end are fixed, so at first it looked like this would only crash the JVM. But Calif's researchers found a way around it: they arrange the server's memory so the overflow expands a neighboring array. They then use that array to write bytes of their choosing, and a second array to read memory back. They named this memory-reading technique JavaBleed, an allusion to the legendary Heartbleed.

From leaking memory — which may include tokens, encryption keys, and personal data — it is one step to full code execution. There is no universal exploit: each product needs its own heap layout and timing. Some chains depend on network conditions and partial request bodies, so buffering proxies break certain exploits but not all. Failed attempts may simply crash the JVM — and the attacker retries.

Which products are affected

Calif calls its list of affected products incomplete, but pre-authentication RCE in default configurations is already known for:

  • Keycloak
  • Atlassian Jira
  • Atlassian Confluence
  • JFrog Artifactory
  • Jenkins
  • PingFederate

After authentication, the flaw is confirmed for Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, and Netflix Spinnaker. Calif also exploited the bug in samples built on Apache Struts and Spring Boot, and Wiz proved RCE against Jenkins, Confluence, and Apache Tomcat.

One more unpleasant surprise: it is not only servers at risk. Calif reports that even an ordinary Java program that opens a TLS connection to a malicious server can be compromised — meaning the client side is vulnerable too.

Who is actually vulnerable: the processor requirement

There is an important nuance that narrows the scope. The vulnerable code runs only on x86-64 processors supporting AVX-512 VBMI. That means server Intel Xeon CPUs from the Ice Lake, Sapphire Rapids, Emerald Rapids, and Granite Rapids generations, plus AMD EPYC/Ryzen on Zen 4 or newer. ARM64 processors do not run this code and are not affected.

By Java version, the problem exists in 17.0.6 and later on the 17 line, as well as in Java 21, 25, and 27. Standard Java 8 and Java 11 do not contain the flaw — however the Oracle Java SE 8 Performance Pack (8u511b33-perf) is affected. GraalVM for JDK 17 and 21 and GraalVM Enterprise Edition 21.3.20.0.3 are also affected.

Because OpenJDK underpins builds from many vendors, nearly all distributions are touched: Oracle Java SE, Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, and Red Hat OpenJDK. Oracle and OpenJDK shipped fixes on November 17 (builds ending in ".1"), Amazon has already fixed Corretto, and Red Hat is still preparing its own builds.

A laptop showing code in a dimly lit room

How to protect yourself: patches and workarounds

The main advice is to update Java to a fixed version without delay. If a quick update is not possible, there are two workarounds at the JVM level:

  1. -XX:-UseBASE64Intrinsics — turns off only the accelerated Base64 decoder, removing the vulnerable path while keeping the rest of the AVX-512 optimizations.
  2. -XX:UseAVX=2 — turns off AVX-512 entirely. This works only on x86-64: Java on ARM64 does not recognize the flag and will fail to start.

Upwind notes that both flags stopped the overflow on every version they tested. They also warn that the flag -XX:DisableIntrinsic=_base64_decodeBlock must not be used on its own — Java will not start at all with it.

It is also worth doing an inventory: Java often "lives" on servers invisibly — as a dependency of other products or inside containers. Check not only your main applications but also which JDK versions are actually running, and compare them against your vendor's list of fixed builds. Vendors ship fixes on different schedules: some updated on November 17, others are still preparing builds.

It is also worth remembering general hygiene: update not only Java but also the products running on top of it (Jira, Jenkins, Keycloak, and so on), keep track of which versions are actually running on your servers, and check whether your data has already appeared in breaches — you can do that with our data breach check tool. The fundamentals of cyber hygiene for your team are covered in our cybersecurity training guide.

Why this matters for Ukrainian teams

Jira, Confluence, and Jenkins are standard tooling for Ukrainian IT companies, product teams, and even government and banking projects. Keycloak is often used as an SSO gateway through which authentication to internal services passes. That means a successful Java4Shell exploit on one such server can open a path not only to the application itself but also to adjacent systems — and through them to user data and the internal network.

The second factor is infrastructure. Many Ukrainian teams host Java applications on AWS or other clouds, where instances on Intel Ice Lake and newer processors are common — exactly the chips that support AVX-512 VBMI and run the vulnerable code. Upwind, by the way, reproduced the memory corruption on an AWS c6i instance with an Intel Ice Lake chip. So an "ordinary" cloud server may well be vulnerable even if you long ago forgot about the Java on it — it often lingers as a dependency or inside containers.

The practical conclusion is simple: take an inventory of which Java versions your services run on (including the ones that "update themselves" rarely), and update them. The worst thing you can do now is postpone the update "until next week": as the Wiz Atlas example showed, a working exploit can appear within hours of the details being disclosed.

Conclusion

Java4Shell is a reminder that even the most mature software can hide defects that reveal themselves only on specific hardware and years later. The flaw has no universal exploit, and at the time of writing it had not been observed in real attacks: it is not in the CISA KEV catalog, and Canada's Cyber Centre had not recorded any exploitation. But that is no reason to delay.

It is also telling how fast things move: the AI-powered research tool Wiz Atlas built a working proof-of-concept in two hours — before the full details were even published. That means the window between a patch and the appearance of exploits is shrinking, and the best defense is to update immediately rather than "when possible." Check your Java versions today.

Stay ahead of threats

Weekly cybersecurity intelligence in your inbox. No spam.

CyberPeople contributor