Critical severity

Java4Shell: critical OpenJDK flaw lets attackers run code on Jenkins, Jira and Keycloak

Researchers at Calif say a bug in Java's fast Base64 decoder lets unauthenticated attackers take over popular enterprise software, and that AI found it in about an hour.

By Mr Elite Published 8 min read

Severity
Critical
Status
Reported by outlets
Sources
2
Last checked

The short version

  • Calif disclosed CVE-2026-114938, nicknamed Java4Shell, on Tuesday 17 November; Oracle shipped patches the same day.
  • The bug is a memory-corruption flaw in OpenJDK's hardware-accelerated Base64 decoder, which runs only on x86-64 chips with AVX-512 support.
  • Calif reported unauthenticated code execution in Keycloak, Jira, Confluence, Jenkins, JFrog Artifactory and PingFederate in default configurations.
  • No exploitation in the wild had been reported by CyberScoop's publication time, and Calif is withholding its weaponised exploits.
  • Calif says researcher Quang Luong found the flaw in about an hour using OpenAI's Codex, at a cost of under $200.

What happened

Researchers at Calif disclosed a critical flaw in OpenJDK, the open-source Java runtime, on Tuesday 17 November 2026. The bug, tracked as CVE-2026-114938 and nicknamed Java4Shell, can let an attacker who has no login run code on a server, BleepingComputer and CyberScoop reported.

Calif rated the flaw 9.2 on the CVSS 4.0 scale, which counts anything above 9 as critical. BleepingComputer reported that Oracle scored it lower, at 8.1 (High) under the older CVSS 3.1 system. The two scores come from different versions of the scoring method, so they are not a direct disagreement about the danger.

The researchers demonstrated remote code execution against several widely used products running default settings. Calif reported unauthenticated attacks on Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins and PingFederate. Attacks that need a valid account worked against Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit and Spinnaker, BleepingComputer reported.

OpenJDK published a security advisory on Tuesday, and Oracle shipped patched Java builds that afternoon, CyberScoop reported. The two outlets give slightly different sizes for Oracle's November update: BleepingComputer says it covers 655 vulnerabilities, CyberScoop says 652. CyberScoop added that CISA published a notice late Tuesday calling for the patch.

Calif has published a proof-of-concept that demonstrates the memory corruption. It has not released the weaponised exploits used against the enterprise products, and told CyberScoop it is holding them back until users have had time to upgrade. CyberScoop said no exploitation in the wild had been reported and that the CVE was not on CISA's Known Exploited Vulnerabilities list at publication.

Why it happened

The flaw sits in Java's Base64 decoder, which turns encoded text back into raw bytes. Base64 appears in logins, file uploads and network traffic, so many applications pass outside data through it. OpenJDK has a hand-written, hardware-accelerated version of the decoder for processors that support AVX-512, a set of extra-wide CPU instructions.

Calif says a specific input breaks that fast path: 64 'A' characters followed by one equals sign, the padding mark Base64 uses. CyberScoop reported that the code miscalculates a length and writes 64 bytes into a buffer that may hold as few as 50, overwriting the memory next to it. The program rejects the input afterwards, but the damage is already done. Older OpenJDK 17 builds need 128 'A' characters, according to BleepingComputer.

On its own the overflow usually crashes the program. Calif says it turned the corruption into control of a server by arranging what sits in nearby memory, a technique called heap grooming. The group also said an attacker could read nearby data, in a manner similar to the 2014 Heartbleed bug. Calif stresses there is no universal exploit: each application needs its own way of getting the crafted data to the decoder.

How this kind of failure works

Memory corruption happens when a program writes data past the end of the space reserved for it. Languages such as Java normally guard against this, which is why the bug is unusual. The guard rails do not apply to the hand-tuned processor code that the Java runtime uses to go faster, so mistakes there can be as dangerous as in older languages like C.

Picture a row of 50 numbered coat hooks at a cloakroom. A new attendant, working quickly, hangs 64 coats and the last 14 land on a neighbour's hooks, pushing their belongings off. The attendant notices something is wrong and rejects the order, but the neighbour's things are already on the floor. If the neighbour's hooks held something that controlled the building, someone who planned where everything hung could exploit that.

That planning is what heap grooming means. The attacker cannot see exactly what lies beside the buffer, so they shape the memory beforehand until the overflow lands on something useful. It is slow, fiddly work, which explains Calif's point that each product needs tailored steps.

The case also shows how a shared component spreads risk. Calif argued that the AVX-512 speedup ships in every copy of Java though few programs need it, so an optimisation became a risk for all, CyberScoop reported. Many unrelated products inherit the same flaw because they run on the same runtime.

Who is affected

BleepingComputer reported that OpenJDK 17.0.6 and later are affected, along with distributions built from the same code: Oracle Java SE, Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu and Red Hat OpenJDK. CyberScoop reported that ARM64 systems are not affected.

Exposure also depends on hardware. The vulnerable function runs only on x86-64 processors with AVX-512 VBMI support, so a server is at risk only if it runs an affected Java build on such a chip. Check your CPU flags and your Java version rather than assuming either way. Some products ship their own bundled Java, so the runtime you installed may not be the one in use.

In practice, a server that is both affected and reachable by untrusted input is the worry, particularly login systems, build servers and collaboration tools. Calif demonstrated unauthenticated attacks on products of exactly that kind. Oligo Security's Gal Elbaz told CyberScoop that not every Java application is vulnerable, but that organisations should treat this as a serious exposure.

How to defend against it

Tick each step as you check it. Your progress is saved on this device.

What to learn from this

The concept: Shared dependency risk

Most software is assembled from components that other people wrote. When one of those components has a flaw, every product built on it inherits the flaw, even if the product's own code is flawless. Java4Shell reaches Jenkins, Jira and Keycloak because they all sit on the same runtime.

This pattern recurs whenever a widely used library or runtime is found faulty, and it makes inventory the first defensive task. You cannot patch what you do not know you run. Keeping a list of runtimes, libraries and bundled copies lets you answer quickly which systems are exposed on the day a flaw lands.

It also explains why optional features deserve scrutiny. Calif noted that few programs need the AVX-512 speedup, yet all of them carry it. Turning off components you do not use, where the software allows it, removes risk you never benefited from.

A flaw in a shared runtime becomes a flaw in every product that runs on it, so know what you run and where.

Quick check

Sign in to earn 10 XP for a right answer

Why can one bug in OpenJDK's Base64 decoder affect Jenkins, Jira and Keycloak at once?

Timeline

  1. Last month (October 2026) Calif discloses php2shell, an earlier AI-assisted find, according to CyberScoop.
  2. Before 17 November 2026 Researcher Quang Luong finds the flaw in about an hour using OpenAI's Codex, Calif says, and builds an initial exploit in about two more hours.
  3. Tuesday 17 November 2026 Calif publishes details of CVE-2026-114938 and a proof-of-concept for the memory corruption.
  4. Tuesday 17 November 2026 OpenJDK publishes a security advisory, and Oracle ships patched Java builds in its November update.
  5. Late Tuesday 17 November 2026 CISA publishes a notice calling for the patch, CyberScoop reported; the CVE was not on the Known Exploited Vulnerabilities list.

What is not known yet

  • Whether attackers are exploiting the flaw in the wild. None had been reported by CyberScoop's publication time.
  • How many internet-facing servers run an affected Java build on AVX-512 hardware. Neither BleepingComputer nor CyberScoop gives a figure.
  • Which other applications beyond those Calif tested can be attacked in practice.
  • When Calif will release its product-specific exploit details.

Questions people ask

What is Java4Shell?

Java4Shell is the nickname for CVE-2026-114938, a memory-corruption flaw in the Base64 decoder of OpenJDK. Calif, the research group that disclosed it, says it can let an attacker without a password run code on servers running popular Java applications. Oracle patched it on 17 November.

Which Java versions are affected by CVE-2026-114938?

BleepingComputer reported that OpenJDK 17.0.6 and later are affected, plus distributions built from that code, including Oracle Java SE, Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu and Red Hat OpenJDK. The flaw only triggers on x86-64 processors with AVX-512 support, and CyberScoop reported that ARM64 systems are unaffected.

How do I protect a server I cannot patch yet?

Calif recommends starting Java with -XX:-UseBASE64Intrinsics, which disables the vulnerable decoder, or with -XX:UseAVX=2, which turns off AVX-512 instructions. These are temporary measures. You should also limit who can reach the server and update the runtime as soon as you can.

Is Java4Shell being exploited in attacks?

CyberScoop reported that no exploitation in the wild had been seen when it published, and that the CVE was not on CISA's Known Exploited Vulnerabilities list. Calif has not released its weaponised exploits. Researchers quoted by CyberScoop consider real-world exploitation likely, so patching promptly is sensible.

Sources

  • BleepingComputer: Critical Java4Shell flaw allows RCE attacks on major Java applications
  • CyberScoop: A vulnpocalypse bug worthy of attention: Researchers disclose critical flaw in Java with help of AI

Know someone who should see this?

Keep reading