CybersecurityArtificial intelligenceServers

Java4Shell (CVE-2026-114938): Codex finds in one hour the flaw that opens Jira, Jenkins and Keycloak. What to do now

Java4Shell (CVE-2026-114938): Codex finds in one hour the flaw that opens Jira, Jenkins and Keycloak. What to do now

On 17 November 2026 the research firm Calif disclosed Java4Shell (CVE-2026-114938), a vulnerability in OpenJDK, the open source implementation of Java. It lets an attacker read sensitive memory and execute code remotely, in several cases without any credentials. The detail making the most noise is something else: the researcher found it in one hour using Codex, OpenAI's coding agent.

This is the same team that a month ago disclosed PHP2Shell, the critical flaw in the PHP interpreter. This time the target sits even deeper: Java runs in banks, airlines, telecoms and a large share of the business software we use every day.

The flaw in the Base64 decoder

Base64 is a way of representing binary data as text. You find it everywhere: in authentication protocols, in tokens, in file uploads, in messages exchanged over the network.

Java has a reputation for memory safety: it manages memory automatically and checks accesses, so applications are protected from the memory corruption bugs typical of other languages. But the virtual machine that runs Java is largely written in C, C++ and Assembly, where those bugs are still possible.

To decode Base64 faster, OpenJDK uses a set of specialised instructions on compatible x86-64 processors, AVX-512 VBMI, which process many bytes in one go. Calif found a bug in the hand-written Assembly code that handles the last few characters of the string: with malformed Base64 input (a few dozen characters are enough) the length calculation goes negative and the routine writes 62 bytes past the end of the allocated memory area. Java eventually rejects the input as invalid, but by then neighbouring objects in memory may already have been overwritten.

From there Calif first managed to read the process memory (they called it JavaBleed, a nod to Heartbleed: personal data, private keys, tokens) and then to execute code.

The affected applications

Calif demonstrated remote code execution without authentication, in default configurations, on:

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

And with authentication on Apache Kafka, Apache Solr, Elasticsearch, Gerrit and Spinnaker.

The lists, Calif stresses, are not exhaustive. The attack also worked on sample applications built with Apache Struts and Spring Boot: perfectly ordinary features such as login or file upload can end up passing attacker data to the vulnerable decoder. Calif's site also has a video of the demos.

Then there is an aspect many will underestimate: researcher samczsun demonstrated a client-side exploit. A Java program that opens a TLS connection to a malicious server can be compromised, even if it exposes no service at all. It is not only internet-facing servers that are at risk.

Severity and affected systems

Calif scores Java4Shell 9.2 out of 10 on CVSS 4.0, Critical. The official OpenJDK advisory rates it 8.1 on CVSS 3.1: two different scales, same substance.

Affected are unpatched OpenJDK versions from 17.0.6 onwards (the 17, 21, 25 and 27 lines), and therefore every distribution built on OpenJDK: Oracle Java SE, Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat OpenJDK, GraalVM. Standard Java 8 and Java 11 builds are not listed as affected.

There is some good news, though: the vulnerable code only runs on specific processors.

Processor Exposed
Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids Yes
AMD EPYC and Ryzen, Zen 4 and newer Yes
x86-64 without AVX-512 VBMI support No
ARM64 (Graviton, Ampere, Apple Silicon) No

Be careful, though: these are exactly the processors in modern servers and the latest cloud instances. And a virtual machine running on unaffected hardware today can be moved to a host that is affected tomorrow.

What to do now

1. Check the processor

On Linux:

grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'

If all four flags appear, the processor meets the vulnerable condition. If even one is missing, that machine is not exposed (but check again after every migration or instance change).

2. Find every Java, not just the system one

java -version                                  # the system Java
find / -type f -path '*/bin/java' 2>/dev/null  # every installed Java

Many products (Jira, Confluence, Jenkins, Elasticsearch, Keycloak in containers) ship their own Java, which operating system updates do not touch. The same goes for Docker images: they need to be rebuilt.

3. Update as soon as the fixed version is available

Oracle and OpenJDK published fixes on 17 November. Oracle's first fixed versions are 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1; Amazon Corretto 17.0.21.1.2 was already available the same day. For Temurin, Microsoft, Zulu and the others, check the vendor's advisory and make sure it names CVE-2026-114938.

Linux distributions are slower: as of 18 November the Debian security tracker still lists the openjdk 17, 21 and 25 packages as vulnerable. If you use your distribution's Java, you need the temporary workaround.

4. Meanwhile: switch off the optimisation

Calif gives two JVM startup flags. The more targeted one:

-XX:-UseBASE64Intrinsics

It disables only hardware-accelerated Base64 decoding: Java falls back to the regular decoder. Applications that decode large volumes of Base64 might slow down a little, so test it, but in most cases you will not notice the difference.

The broader alternative is -XX:UseAVX=2, which disables AVX-512 across the whole JVM. x86-64 only: a JVM on ARM does not recognise the flag and will not start.

Where to put it depends on the product: JAVA_OPTS, Tomcat's setenv.sh (which sits under Jira and Confluence), Elasticsearch's jvm.options, the container's environment variables. Alternatively, the JAVA_TOOL_OPTIONS variable is read by any JVM at startup. Either way you must restart the process, then check that the flag is really active:

jcmd <PID> VM.flags -all | grep UseBASE64Intrinsics   # must show false

5. Reduce your exposure

Jira, Confluence, Jenkins, Artifactory, Keycloak: how many of these really need to be reachable by anyone on the internet? Java4Shell strikes before login: all it takes is for the service to answer a request. If nobody reaches that request without being verified first, the problem changes scale entirely.

That is exactly why we built Neti, our Zero Trust Application Gateway. Neti sits between the internet and your services: every request is checked at the entrance and only authorised traffic gets through, everything else is stopped before it touches your machines. Jira, Jenkins or Keycloak are no longer directly exposed, and a scanner hunting for the vulnerable Base64 decoder finds a closed door instead of the application. It does not replace the patch, but it gives you the time to apply it calmly, today and at the next flaw. If you have no gateway, at least move these services behind a VPN. Do not rely, on the other hand, on request size limits or generic reverse proxy rules: the input that triggers the bug is very short and can hide in perfectly legitimate fields.

As of 17 November there were no reports of real-world attacks, and Calif has not published product-specific exploits. But the technical details are public, and after PHP2Shell we know how quickly things move from announcement to automated scanners.

How Codex found the flaw

Calif researcher Quang Luong focused on the most complex parts of the Java Virtual Machine: the JIT compiler, the processor-specific optimised routines, the most widely used APIs, cryptography. Or rather, as the technical write-up puts it, Luong asked Codex to look at them "like any serious security researcher in 2026".

At first the AI mostly produced false alarms: unreachable vulnerabilities or ones with completely unrealistic exploitation conditions. Luong kept pushing with new prompts, discarding the useless results, for about twenty minutes. Eventually Codex identified the bug in the Base64 decoder.

The numbers:

  • 1 hour to discover the vulnerability;
  • 2 hours to develop the first working exploit;
  • under 200 dollars in total token cost.

There is no universal exploit: the way to reach the decoder changes from application to application. So Calif first had human researchers work on attack strategies and on tooling for the agents (including a small memory visualiser, because the AI kept getting stuck in the most delicate phase). Then the AI agents followed those strategies, building most of the later exploits almost autonomously.

The era of the centaur hacker

Calif uses an image from Greek mythology: the centaur, half human and half horse. AI brings the horsepower, researchers bring the context. In their view the best hacker today is neither an AI nor a human on their own, but the centaur, combining the two.

It is a point worth pausing on. Until recently, finding and exploiting a memory corruption bug in Java took weeks of work by extremely rare specialists. Today a good researcher with an AI agent does it in an afternoon and spends less than a business dinner. The same, inevitably, applies to whoever does it with the opposite intentions.

Vibe uncoding: asking what to remove

Calif's most interesting reflection, though, is about software, not AI.

Java is one of those shared components we all rely on. Over the years it has grown to serve very different needs, and every new feature, taken on its own, made sense. But everyone inherits the complexity: those who need a feature get the benefit, everyone else carries its code and its risks.

Java4Shell is the perfect example. The Assembly optimisation serves applications that decode huge amounts of data. But it ships to everyone, including applications that decode a few hundred bytes and gain nothing from it. On those systems, an optimisation almost nobody needed became a serious risk.

Hence the proposal Calif calls vibe uncoding, a play on the "vibe coding" people now do with AI: use the same human and AI collaboration not only to find vulnerabilities but to identify and remove dead code, bloated features and needless optimisations. Removing code is hard, because a seemingly unused feature can have hidden dependencies, and someone has to understand that, make the change and test what remains. But it is exactly the kind of work AI can make sustainable at scale.

Calif closes with a question I fully endorse: with AI, everyone is asking "what can we build?". Perhaps, for security, the right question is "what can we delete?".

Sources

Written by Claudio