Back to Explore
NewsVibeFix editorialUpdated Nov 20, 2026

65 Characters to Break Java: Java4Shell Exposed on 17 November, With Unauthenticated RCE in Jenkins and Jira

On 17 November 2026, OpenJDK disclosed Java4Shell (CVE-2026-114938), a critical RCE flaw triggered by 64 A's and one '='. Calif proved unauthenticated code execution against Jenkins, Jira, Confluence and three more apps; patches shipped the same day, but exposure also depends on whether the CPU supports AVX-512 VBMI.

Real photograph of a computer screen showing Java code in a dark-themed editor

In short: 65 characters, no login, and your Jenkins is gone

On 17 November 2026, a vulnerability in OpenJDK was publicly disclosed as CVE-2026-114938, and the security firm Calif gave it a name: Java4Shell. Calif scores it 9.2 under CVSS 4.0, which is Critical; Oracle, which assigned the CVE, scores it 8.1 under the older CVSS 3.1 and calls it "difficult to exploit". The two scores are far apart, but both sides agree on the core fact: an attacker can execute code remotely without logging in. The input that triggers it is absurdly short — 64 letter A's followed by a single equals sign, 65 characters in total. Patches shipped the same day, with Oracle JDK 17.0.21.1 and fixed Amazon Corretto builds both released on 17 November. The catch is that you have to work out whether you are in scope first, and that takes more than checking a Java version number: it also depends on the CPU model in your servers.

Start with how the bug works. Base64 decoding is everywhere in Java: login credentials, uploaded files, and data in network traffic all pass through it. To make it fast, OpenJDK uses a hand-written assembly routine on x86-64 processors that support AVX-512 VBMI instructions. The bug sits in that assembly: when it handles the trailing padding characters (the equals signs) at the end of an input, it miscalculates the length of the output array. Given a specific sequence — 64 A's followed by one equals sign — the length calculation underflows to a negative value, and the decoder then writes past the end of the allocated heap buffer, overwriting the metadata of adjacent objects. Once heap memory is corrupted this way, an attacker can steer execution toward code they control, which is how remote code execution happens. Calif also found a second use for the same flaw: by corrupting the length of a neighbouring array, the application can be made to copy far more heap memory back into its normal response than it should. The heap can hold personal data, private keys, other secrets, and tokens, and Calif calls this read primitive JavaBleed — the same idea as Heartbleed, applied to Java. So the flaw can be used to run code or to steal data, depending on what the attacker wants.

Whether you are affected depends on three conditions, all of which must hold. First, the Java version: OpenJDK from 17.0.6 onward is affected, across the 17, 21, 25, and 27 lines. The affected distributions cover almost every mainstream choice: Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat OpenJDK, and Oracle Java SE itself. Oracle lists the affected builds as 8u511b33-perf, 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3, and 27.0.1.0.3. Second, the CPU: it must be an x86-64 chip with AVX-512 VBMI instructions, including Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids, and Granite Rapids, and AMD EPYC and Ryzen Zen 4 or newer. ARM64 machines are not affected at all. Third, reachability: the application has to pass attacker-controlled input into this decoder, and the most ordinary features do exactly that — authentication and file uploads. Censys adds a point that is easy to miss: a Java client program can be compromised when it opens a TLS connection to a malicious server, even if it exposes no service of its own. Turn that around and the picture widens: even if your services sit behind a firewall, a Java tool on a developer laptop that connects outward can be an entry point.

Calif tested this itself. In default configurations, it achieved remote code execution without authentication against Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, and PingFederate; after authentication, against Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, and Netflix Spinnaker. Wiz names Jenkins, Confluence, and Apache Tomcat as proven, and notes that custom frameworks built on Spring Boot and Apache Struts are in range too. The list is not exhaustive — Calif says so explicitly. If you run Jenkins for pipelines, Jira for tickets, and Keycloak for logins, do the maths: these are the usual residents of one DevOps stack, and a compromised Jenkins hands the attacker the machine that can reach your code, trigger your builds, and read your pipeline secrets. The one piece of good news is that there is no universal exploit. Each application needs its own exploit chain, and Calif is withholding the per-product chains, so an attacker cannot sweep every Java application with one ready-made script. That buys time; it is not immunity.

Flow chart: a 65-character input triggers a length underflow, an out-of-bounds heap write overwrites adjacent object metadata, and ends in unauthenticated remote code execution

The 9.2 versus 8.1 question: which score should you trust?

The same flaw, two scores — and the gap is about more than the numbers. Calif uses CVSS 4.0, where 9.2 is Critical; Oracle uses CVSS 3.1, where 8.1 is High, and its record describes the flaw as a "difficult to exploit vulnerability" that can only be exploited by supplying data to APIs in the affected component, for example through a web service. Both Wiz and Censys quote Oracle's wording as written. How should you read the disagreement? Oracle is talking about how hard it is to go from finding the bug to a reliable exploit: memory layouts differ between applications, and each chain has to be adapted by hand, so there is no one-size-fits-all attack. Calif is talking about the other side: it already ran unauthenticated code execution against six mainstream applications in their default configurations, so "difficult" does not hold up well against a motivated attacker. Both are describing the same fact from different angles. For someone sweeping the internet at random, the flaw is genuinely awkward to exploit at scale; for someone who has picked your Jenkins server as a target, 9.2 is not an exaggeration.

Another set of numbers belongs next to this one. Oracle's November Critical Patch Update fixed 655 security vulnerabilities in total, and Java4Shell was one of 11 new Java SE patches in it. Calif says Oracle's patch went out at 1:00 p.m. Pacific, and Corretto's fixed builds — 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2, and 27.0.1.1.4 — listed the CVE in their changelogs the same day. As of 17 November, no exploitation in the wild had been reported. That "no exploitation in the wild" line is easy to read as reassurance, but what it really means is "nobody has publicly seen it yet", not "nobody can do it". Calif's write-up is explicit about how it got there: it built pipelines and strategies first, then directed AI agents to run the initial exploitation, and most of the later chains were built almost autonomously by AI. Wiz reports the same on its side: its AI vulnerability-research harness, Atlas, found and built a proof-of-concept exploit within two hours, before the full details were even disclosed. Two firms, different AI tools, working exploits on the same day. The window between disclosure and a working attack is being compressed to hours by AI. Waiting for a news story about in-the-wild exploitation before patching is very likely too late.

There is a recent precedent, from just last month. In October 2026 we covered PHP2Shell: a critical PHP remote code execution flaw found with AI assistance, also scored 9.2 under CVSS 4.0, with 70% of websites patching overnight. That piece and this one are different vulnerabilities — PHP2Shell lives in the PHP interpreter, Java4Shell in OpenJDK's decoder, with different fixes and different blast radii. But the pattern is identical: AI-assisted auditing digs a memory-safety bug out of foundational code that everyone assumed had been reviewed years ago, the patch ships on disclosure day, and the impact is so broad nobody can count the exposed services. Twice in a month is not a coincidence; it is the new normal now that AI has changed how fast vulnerabilities are found. The good news for defenders is that patches arrive fast too. The bad news is that attackers get working exploits just as fast, and the reaction time in between only shrinks.

Do not stop at your servers: clients and WAFs are not cover

When people hear "remote code execution", the first instinct is to check their servers — whether Jenkins and Jira are patched. Java4Shell has two places where that instinct misses. The first is clients. Censys states it plainly: a Java program that opens a TLS connection to a malicious server can be compromised even if it exposes no service of its own. Developer laptops and test machines running Java tools that connect outward are in scope in principle. Patching cannot stop at servers: the JDK on developer and CI machines has to be upgraded too, and every JVM has to be restarted afterwards, or the old build keeps running. The second is the web application firewall. Wiz is blunt about it: a WAF can help mitigate some exploits as they emerge, but the flaw is rooted in OpenJDK itself, many code paths that take user input can lead into the vulnerable decoder, and WAF rules are unlikely to cover all of them — and will never cover home-grown applications completely. A WAF can buy time as a stopgap, but it is not a substitute for upgrading. Treating a WAF as "already fixed" is the easiest mistake to make here.

One more detail deserves its own mention: Oracle's affected list includes only the 8u511b33-perf build for Java 8, and no Java 11 build at all — Censys flags this explicitly. That is good news for teams still on old Java, but do not read it as "old versions are safe". Oracle's list only covers the builds it maintains; each distribution's fix schedule is its own, and Corretto, Temurin, Zulu, and the rest have to be checked against their own release notes. When you audit your environment, do not stop at the major version number — check the full build number. The safer approach is to move straight to the latest fixed build your distribution has published rather than hunting through lists to see whether your version appears.

Four things to do today

First, check the CPU. The flaw only travels the AVX-512 VBMI accelerated path, so whether a machine is exposed depends on its processor. On Linux, look at /proc/cpuinfo: all four flags — avx512f, avx512bw, avx512vbmi, and bmi2 — must be present for the host to run the vulnerable code path. Check cloud VMs too: the host CPU model shows through, and a container does not hide the instruction set. Second, patch. Move to the fixed builds released on 17 November — Oracle JDK 17.0.21.1, or the matching fixed builds from Corretto, Temurin, and the other distributions — and restart every JVM so the fixed build is the one actually running. Wiz's advice is to start with externally facing packaged applications: Jenkins, Jira, Confluence, and Keycloak first, then home-grown Java applications. Third, if you cannot patch immediately, use the JVM flags. Wiz gives two: -XX:-UseBASE64Intrinsics disables the Base64 intrinsics and is the recommended one; -XX:UseAVX=2 disables AVX-512 execution but only works on x86-64 — it fails to start on ARM. Both can cost performance, but a slower decoder is a far better deal than remote code execution. Fourth, isolate and rotate. Until patches or flags are in place, pull management portals such as Jira, Jenkins, and Keycloak back inside the network and restrict external access; and rotate credentials that may have been exposed — if a machine was reachable while unpatched and compromise cannot be ruled out, assume its credentials leaked, because rotation is the cheapest insurance.

The order matters too: check the CPU to size the problem, patch, fall back to flags if patching is blocked, and isolate if even that is not possible. Many teams do it the other way around — study the bug, hold a meeting to assess impact, wait for a slot in the schedule. For a flaw where AI produced a proof of concept on disclosure day and the patch was ready the same day, every day spent scheduling is a day handed to the attacker. The patch is already on the table; what is left is execution speed.

Why Base64 of all things: a decoder sitting in every request

The unsettling part of this flaw is not how hard it is to understand but where it hides. Base64 decoding is not some obscure feature; it is a step almost every request in a Java application passes through. Credentials sent at login, data attached to uploads, encoded parameters passed between services, the contents of certificates and tokens — all of it has to be decoded before it can be used. Wiz's post states plainly why OpenJDK wrote hand-tuned assembly for this decoder: to make it faster, because Base64 is used so often that slowing it down slows the whole application. So an optimization that exists for performance became a single point of failure sitting on a path everyone must walk. An attacker does not need to find a special endpoint in your application; any entry point that passes user input into the decoder will do, and those entry points are nearly everywhere — a login box, an upload button, any interface that accepts outside data.

That also explains why the CPU model matters so much in the exposure conditions. The AVX-512 VBMI accelerated path only exists on relatively new x86-64 chips; older machines and ARM machines take a different decoding path and are not affected at all. In other words, the same code on the same Java version is vulnerable on a new server and safe on an old laptop. This "depends on the hardware" behaviour makes the flaw easy to miss during triage: a problem that cannot be reproduced on a developer machine may be wide open in production. Many teams develop on ARM-based Apple silicon and test on older cloud instances, while only production runs the newest Xeon processors — and the vulnerability only triggers in production. Checking the CPU flags is a step that cannot be skipped, and checking one machine is not enough: development, testing, and production need to be checked separately, as do different instance types from the same cloud provider, where old and new chips can sit side by side under one account.

For people running side projects, the self-check list is short. First, look at whether you run any ready-made Java applications — many people have an old computer at home or a small cloud server running a self-hosted Jenkins, or a Keycloak login service for friends, and both are on Calif's tested list. Second, look at your own Java projects: a small Spring Boot service, a personal site on Tomcat, any Java program that exposes an interface to the outside is in scope. The check is three steps: java -version for the full build number, /proc/cpuinfo for the four CPU flags, and then your distribution's site for the fixed build number. Container users need one more step: the JDK inside the base image has to be upgraded too, upgrading the host alone does nothing, and containers must be restarted after the image is rebuilt, since old container instances still run the old JDK. Once those steps are done, take another look at your pipeline secrets and database passwords and whether they need rotating — if that machine was ever exposed to the outside, one rotation costs far less than discovering an intrusion after the fact.

Our judgment: do not be fooled by 8.1, or by "no exploitation in the wild"

There are two easy misreadings here. The first is Oracle's 8.1. It sounds much gentler than 9.2, and "difficult to exploit" invites postponement. But Oracle's wording is about the difficulty of a universal exploit, while Calif has already demonstrated unauthenticated code execution against six mainstream applications, and Wiz's Atlas built a proof of concept within two hours. How hard exploitation is depends on whether an attacker is willing to build a chain for your application, not on how severe the flaw is. For an internet-facing Jenkins server, the practical difference between 8.1 and 9.2 is close to zero. The second is "no exploitation in the wild". As of 17 November there were no public reports — which means nobody has publicly reported seeing it, not that nobody is trying. Now that AI has compressed exploit development to hours, the shelf life of "not yet" keeps getting shorter.

Three signals are worth watching next. First, when in-the-wild exploitation appears, and against which applications: if Jenkins and Jira go first, attackers are picking the highest-value doors. Second, how fast the other distributions ship fixed builds: Corretto and Oracle are out, and whether Temurin, Zulu, and Liberica follow determines how many long-tail users stay exposed. Third, whether Calif publishes the per-product chains it is holding back: if it does, the bar drops again; if it does not, attackers have to build their own, and the window lasts a little longer. But whichever way those signals go, today's actions are the same: check the CPU, patch, restart the JVMs, rotate the credentials. Do those four things and Java4Shell is just a news story for you; skip them and it can become an incident. A flaw that opens a server with 65 characters of input is not worth gambling on with "let's wait and see".

Views 2Comments 0

Comments (0)

ME
0/1000
Loading comments...

Sources

Browse projectsPublish your project

Related articles

An analyst seen from behind in a dark security operations center, facing large screens showing world maps and network topology
News
The Patch Just Shipped and the Exploit Is Already There: Google Finds the First Fully Autonomous AI Exploitation Framework

On 16 November 2026, Google's Threat Intelligence Group reported the first fully automated vulnerability discovery and exploitation chain: no human in the loop. The evidence is an exposed server running exploit_agent, a framework that diffs code around patch announcements, writes exploits and fires them. The same report shows a North Korean cluster turning Claude Code's settings file into a backdoor trigger — and stolen cloud compute running up $100,000 bills in a day.

Industry TrendsAI CodingSecurity & Privacy
A modern data center corridor lined with black server racks, cable trays and ventilation ducts overhead, blue indicator lights blinking on the racks
News
Two Months Late, PostgreSQL 19 Is Finally Here: Repack Tables While They Run, and Make Standbys Wait for Your Writes

On 19 November 2026, PostgreSQL 19 shipped — two months late, after a flood of AI-reported vulnerabilities rewrote the schedule. It brings REPACK (CONCURRENTLY), pg_plan_advice, and WAIT FOR LSN: tables can be reorganized while they run, query plans can be pinned, and standbys wait for your writes.

Product LaunchData WorkflowsBackend Engineering