Thursday, 19 November 2026
NEXA NEWSHD
Science & Technology

Java4Shell Flaw in Java Lets Attackers Take Over Enterprise Servers Without a Password

A critical flaw in Java, the programming platform that runs some of the world’s most widely used enterprise software, can let an attacker take over a server without a password, according to security researchers who disclosed it on Tuesday. The vulnerability, tracked as CVE-2026-114938 and nicknamed Java4Shell, sits not in any single application but in the Java runtime itself, which means every program built on the affected versions of Java inherits the risk. Oracle released a patch on 17 November 2026, and the United States Cybersecurity and Infrastructure Security Agency has issued an alert urging organisations to patch immediately.

The flaw was found by researchers at the security firm Calif, who disclosed it on Tuesday 17 November, according to BleepingComputer. Calif rated it critical, with a score of 9.2 out of 10 under the CVSS 4.0 severity scale, while Oracle assigned it a lower score of 8.1, or High, under CVSS 3.1. The OpenJDK project’s own advisory for 17 November lists CVE-2026-114938 as the highest-scored entry in its risk table, in the hotspot compiler component, and confirms that it affects Java versions 17, 21, 25 and 27 only.

What makes the disclosure striking is not only the severity of the flaw but how it was found. According to Calif, researcher Quang Luong used OpenAI’s Codex, an AI coding assistant, to audit the internals of OpenJDK, the open-source implementation of Java. He found the bug in about an hour and built a first working exploit in two more hours, at a total cost in computing tokens of less than 200 US dollars, the researchers said. AI agents also helped develop the additional exploit chains used against individual applications. It is, by the researchers’ own account, one of the most consequential vulnerabilities ever found with the help of an AI assistant, and it arrived in a component that thousands of organisations trust without ever thinking about it.

Calif demonstrated that the flaw can be exploited to achieve remote code execution, the most serious outcome in vulnerability research, against widely used enterprise applications running with their default settings, without any login at all. The unauthenticated targets named by the researchers are Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins and PingFederate. With a login, the researchers also achieved code execution against Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit and Spinnaker, and they exploited the flaw in sample applications built with the Apache Struts and Spring Boot frameworks, according to BleepingComputer.

No attacks in the wild had been reported as of 17 November, according to the security press, and Calif has published a proof of concept demonstrating the memory corruption while withholding the weaponised exploits it built for individual products, to give users time to upgrade. That restraint buys time, but not much of it. The proof of concept is public, the trigger is 65 characters long, and the patch is already out, which means the window between disclosure and exploitation is now measured in days, not months.

How 65 characters break Java’s memory safety

The vulnerability is a memory-corruption flaw in Java’s hardware-accelerated Base64 decoding, according to BleepingComputer. Base64 is the encoding scheme that turns binary data into plain text, and it is used constantly in authentication tokens, file uploads and network communications. Java’s decoder includes hand-written processor instructions, written in x86-64 assembly, that use a feature called AVX-512 VBMI to speed up decoding on modern server chips, according to Calif’s write-up as reported by the security press.

That optimisation is where the bug lives. According to Calif, a specially crafted Base64 string, 64 letter “A” characters followed by a single equals sign, makes the decoder write 62 bytes past the end of its output array. OpenJDK allocates a 50-byte buffer for the input and ends up writing 62 bytes beyond it, according to Security Affairs. Older versions of OpenJDK 17 need a longer trigger, 128 letter “A” characters followed by an equals sign, according to BleepingComputer. The flaw sits in how the decoder handles padding at the end of a Base64 string, Security Affairs reported: when the trailing characters are equals signs, the code can compute a negative output length, and that underflow turns into a write of far more bytes than should ever leave the decoder.

That matters because Java’s central promise is memory safety. Java programs are supposed to be unable to read or write memory outside the areas they are given, and that promise is what makes Java a safe choice for software that faces the internet. A heap out-of-bounds write, which is what CVE-2026-114938 is, breaks that promise at the level of the runtime itself. As one security publication put it, the flaw matters because it breaks one of Java’s core promises: memory safety. Malformed Base64 text can make the optimised decoder write past the end of a byte array, and Calif says it turned that write into remote code execution against several well-known Java products.

The researchers also found that the same bug can leak the contents of memory, a capability they call JavaBleed, according to SecurityWeek. An attacker who can read memory from a server can steal secrets such as passwords, session tokens and cryptographic keys, even without taking the server over entirely.

There are two important limits on the flaw. First, it only affects the hardware-accelerated decoding function, which runs only on x86-64 processors that support AVX-512 instructions with VBMI, such as Intel Xeon processors from the Ice Lake generation onwards and AMD chips based on the Zen 4 architecture or newer, according to SecurityWeek. Servers running on older processors, or on ARM chips, do not take the vulnerable code path. Second, there is no universal exploit. As BleepingComputer reported, the researchers said Java4Shell does not have a universal exploit, and attackers must find an application-dependent way to deliver malicious Base64 data to the vulnerable decoder to achieve code execution. That is a real constraint, but it is a thin one: Base64 data arrives in login tokens, uploaded files and API requests, and the researchers have already shown it can be delivered to six major products with no login at all.

What is affected, and what is not

According to the OpenJDK advisory, CVE-2026-114938 affects Java versions 17, 21, 25 and 27. BleepingComputer reported that it affects OpenJDK 17.0.6 and later, as well as Java distributions built from the affected code, including Oracle Java SE, Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu and Red Hat OpenJDK. The advisory’s fixed versions are 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3 and 27.0.1.0.3. Java 8 and Java 11 are not affected by this specific flaw, according to the advisory’s risk matrix.

The hardware condition narrows the exposure further, but not by as much as it might seem. The vulnerable code path runs on modern server processors, and modern server processors are exactly what enterprises run in their data centres. Intel Xeon chips from Ice Lake onwards and AMD Zen 4 chips and newer are the current generation of server hardware, so a large share of the Java servers in production today are, in principle, exposed. The flaw does not affect every Java installation, but it affects the ones that matter most: the current, supported, production servers running the software that businesses depend on.

Java is, as BleepingComputer put it, one of the most widely used programming platforms in the world, powering enterprise applications, web services, financial systems and critical business infrastructure. Because many applications use the same Java runtime, a vulnerability in its core components can affect a wide range of different and unrelated applications at once. That is the difference between a flaw in one product and a flaw in a platform. A flaw in Jira affects Jira. A flaw in Java affects Jira, Confluence, Jenkins, Keycloak and everything else that runs on the same runtime, which is why the disclosure landed with such force.

The list of products Calif says it compromised without authentication reads like a catalogue of the software that runs modern companies. Keycloak manages logins and single sign-on. Jira and Confluence run project tracking and internal documentation. Jenkins runs the build pipelines that ship software. Artifactory stores the artefacts those pipelines produce. PingFederate manages federated identity. An attacker who takes over any one of these does not merely own a single application: they own the keys to the systems around it. Jenkins, in particular, is a prized target, because a build server that can run arbitrary code can, in principle, inject malicious code into the software a company ships to its own customers.

The patch, and the race to install it

Oracle released patches for CVE-2026-114938 on 17 November as part of its November Critical Patch Update, which BleepingComputer reported addresses 655 security vulnerabilities across Oracle’s product portfolio. The OpenJDK project published an out-of-cycle vulnerability advisory the same day, listing the flaw alongside nine other Java CVEs fixed in the release, and recommended that users upgrade as soon as possible. Oracle credits Calif researchers Albert Yang and Quang Luong in its November 2026 Critical Security Patch Update, according to the security press.

The patch arrived on a compressed timetable. According to CyberKendra, Calif went public on 17 November after news of the flaw leaked ahead of the coordinated disclosure, and published its full write-up once Oracle’s patch went out at 1 p.m. Pacific time. As of 7:30 a.m. Indian time on 18 November, Oracle and Amazon had shipped fixed builds for Java 17, 21, 25 and 27, while Eclipse Temurin, Azul Zulu, Microsoft, Red Hat and the Linux distributions had not yet published fixes, according to the same report. That gap is normal in a disclosure of this kind: each distributor builds, tests and ships its own version of the patch, and the process takes hours to days. It is also the most dangerous part of the disclosure, because attackers can read the public write-up and the public proof of concept while many users are still waiting for a patch they can install.

The United States Cybersecurity and Infrastructure Security Agency issued an alert urging organisations to immediately patch the recently disclosed Oracle Java memory-corruption vulnerability, according to Silicon Report. As of 17 November, CISA had not placed the flaw on its Known Exploited Vulnerabilities catalogue, which is the list of flaws that federal agencies are required to fix on a deadline, and no active exploitation in the wild had been documented, according to the same report. CISA advised administrators who cannot immediately apply patches to deploy temporary compensating controls.

For administrators who cannot patch immediately, Calif recommends two temporary workarounds, according to BleepingComputer. The first is to launch OpenJDK with the option -XX:-UseBASE64Intrinsics, which disables the vulnerable hardware-accelerated Base64 functionality. The second, for administrators running Java on x86-64 systems, is to use -XX:UseAVX=2, which disables AVX-512 instructions. Both are temporary mitigations, and the researchers and Oracle alike say the real answer is to update the Java runtime to the latest version. Disabling the optimisation costs some performance; leaving the flaw open costs far more.

Found by AI, in an hour, for less than 200 dollars

The detail of this disclosure that will be quoted for years is the price tag. According to Calif, Luong discovered the flaw in approximately one hour and developed an initial working exploit in another two hours, at a total token cost of less than 200 dollars. The AI assistant did the tedious part, auditing the HotSpot Java Virtual Machine’s just-in-time compiler, its intrinsic functions and its cryptography code, and a human researcher did the part that still needs a human: recognising that one of the many things the AI flagged was a genuine, exploitable bug. Calif said most of the AI’s early results were useless, according to Security Affairs, which is itself a useful detail. The story is not that an AI found a bug on its own. It is that an AI made it cheap and fast for a skilled researcher to find a bug that a team of humans had missed for years in one of the most scrutinised codebases in the world.

The OpenJDK code in question is not obscure. It is the core of the Java platform, reviewed by Oracle’s engineers, by the OpenJDK community and by security researchers for decades. The vulnerable routine is a hand-written assembly optimisation, the kind of code that is fast precisely because it is close to the metal, and the kind of code that is hardest to review by eye. That an AI coding assistant found the flaw by auditing that code is a measure of how far these tools have come, and a warning about how far they will go. If a legitimate researcher can find a critical flaw in a core runtime for 200 dollars in an afternoon, then an attacker with the same tools, the same afternoon and no scruples can do the same. The disclosure is, among other things, a demonstration that the cost of finding serious vulnerabilities has collapsed, and that the advantage now belongs to whoever moves first.

That is also why the researchers’ decision to withhold the weaponised exploits matters. Calif has published a proof of concept that demonstrates the memory corruption, but not the chains that turn that corruption into a takeover of a specific product, according to BleepingComputer. Dark Reading reported that the researchers are holding back the release of the weaponised chains for individual products. The distinction is deliberate. A proof of concept lets defenders confirm that they are vulnerable and test that their patch works. A weaponised exploit lets anyone with a copy take over a server. The gap between the two is the time the security community has to patch, and the researchers have chosen to keep that gap open for as long as they can.

The Log4Shell echo

The name Java4Shell is a deliberate echo. In December 2021, a flaw called Log4Shell was disclosed in Apache Log4j, the logging library used by Java applications everywhere. It was rated 10.0, the maximum severity score, it allowed unauthenticated remote code execution, and it was exploited within hours of disclosure, in one of the largest patching emergencies the industry has ever seen. Organisations spent months finding every copy of Log4j in their systems, because the library was embedded in software they did not know they ran. The name Java4Shell is a claim that this flaw belongs in the same conversation, and the comparison is instructive in both directions.

Java4Shell is, in one sense, less dangerous than Log4Shell. Log4Shell could be triggered by a single string in a log message, on any hardware, in any version of a library that was everywhere. Java4Shell needs a specific hardware feature, a specific set of Java versions, and an application-specific route to deliver the malicious data. It is a serious flaw with real limits, and the researchers have been careful to state those limits.

In another sense, it is more dangerous. Log4Shell was a flaw in a library, and libraries can be replaced. Java4Shell is a flaw in the runtime, and runtimes are harder to move. Updating Java is not a matter of swapping one file: it means testing every application that runs on it, in every environment, against a new version of the platform, and that is work that organisations put off. The long tail of unpatched Java is the real risk here. The patch exists, the workarounds exist, and the alert has been issued. The question is how many servers will still be running the vulnerable versions in a month, in six months, in a year. History suggests the answer will be: too many.

There is also a difference in how the flaw was found, and it cuts both ways. Log4Shell was found by a human researcher at Alibaba. Java4Shell was found by a human researcher working with an AI. The next Log4Shell may be found the same way, and it may be found by someone who does not disclose it. The security industry has spent the last two years arguing about whether AI coding assistants will write more secure code or more vulnerable code. Java4Shell is the first major piece of evidence in a different argument: that AI will find the vulnerabilities in the code we already have, faster and cheaper than ever before, and that the side that patches fastest will win.

Analysis: Why It Matters

A runtime bug is every application’s bug

The most important fact about Java4Shell is where it lives. It is not a bug in Jira, or in Jenkins, or in Keycloak. It is a bug in the thing they all run on. That is why a single 65-character string can threaten six different products at once, and why the list of affected software will almost certainly grow as researchers test more applications. Every Java application that decodes Base64 data on a modern server chip is, in principle, in scope, and Base64 is one of the most common encodings in computing. The flaw is a reminder that the software supply chain is not only the libraries an application imports. It is the runtime, the operating system, the processor and the compiler, and a bug at any of those layers is a bug in everything above it. Organisations that audit their applications but not their runtimes have been auditing the wrong layer.

The AI found it in an hour, and that changes the economics of both sides

The headline figure of this story is not 9.2, the severity score. It is 200 dollars, the cost of finding the flaw. For years, the security industry has assumed that finding a critical vulnerability in a mature, well-reviewed codebase takes weeks of expert work. That assumption is now false, at least for this class of bug. An AI assistant audited the code, a human recognised the finding, and three hours later there was a working exploit. The cost of attack has fallen, and the cost of defence has not. Patching a Java runtime across a large organisation still takes weeks of testing and scheduling, and it still competes with every other priority in the business. The gap between how fast a flaw can be found and how fast it can be fixed is the central problem in computer security, and Java4Shell has just made that gap wider. The only honest response is to make patching faster, which is a matter of organisation, not technology: automated testing, staged rollouts, and a culture that treats a runtime patch as urgent by default.

The name is a warning, not a joke

Security researchers give vulnerabilities memorable names for a reason. Log4Shell, Heartbleed, Shellshock: the names are marketing, but they are also a signal to the people who need to act. A name that echoes Log4Shell tells every administrator who lived through December 2021 to stop what they are doing and patch. That is a useful signal, and it is also a risk. If Java4Shell turns out to be less widely exploited than Log4Shell, the name will be remembered as an exaggeration, and the next warning will be taken less seriously. The researchers have handled that risk well, by being precise about the limits of the flaw: the hardware condition, the version range, the absence of a universal exploit. The name gets attention; the details tell the truth. Both matter, and both are present in this disclosure.

Patching is the hard part, and the long tail is where the damage will happen

The patch exists. The workarounds exist. The alert has been issued. None of that guarantees that the vulnerable servers will be patched. Java is embedded in systems that are hard to update: industrial control software, banking systems, hospital infrastructure, government services, and the appliances and devices that run Java under the hood. Many of those systems are updated rarely, or never, or only by vendors who have not yet shipped a fix. The history of Log4Shell is the history of a long tail: years after disclosure, vulnerable copies of Log4j were still being found in production systems. Java4Shell will have the same long tail, and the damage, if it comes, will come from the systems that nobody remembered were running Java. The work that matters now is not the patch. It is the inventory: knowing where Java runs in your organisation, which versions, on which hardware, and in which products. Organisations that cannot answer those questions today are the ones that will be answering for it later.

Disclosure worked this time, but only just

The disclosure of Java4Shell followed the rules of responsible disclosure, but only narrowly. According to the security press, the flaw leaked ahead of the coordinated disclosure, and Calif went public on 17 November, publishing its full write-up once Oracle’s patch was out. The leak is a reminder that coordinated disclosure is fragile: it depends on many people keeping a secret, and it only takes one of them to fail. The researchers’ decision to withhold the weaponised exploits is the part of the process that worked, and it is the part that buys defenders their time. But that time is measured in days, and the proof of concept is already public. The lesson for the industry is not that disclosure failed. It is that disclosure is a race, and the race is getting shorter as AI makes exploitation cheaper. The institutions that manage disclosure, the vendors that ship patches, and the distributors that package them will all need to move faster, because the next flaw will be found just as quickly, and it may not leak first. It may simply appear, fully weaponised, with no warning at all.

What to Watch Next

  1. Whether any exploitation in the wild is reported in the coming days, and whether CISA adds CVE-2026-114938 to its Known Exploited Vulnerabilities catalogue, which would set a binding patching deadline for United States federal agencies.
  2. How quickly the remaining Java distributors, including Eclipse Temurin, Azul Zulu, Microsoft and Red Hat, ship fixed builds, and whether any of them report delays.
  3. Whether Calif, or independent researchers, publish exploits against additional products beyond the six unauthenticated targets already named.
  4. Whether Oracle or the OpenJDK project revise the severity assessment, or issue further guidance on the hardware scope of the flaw.
  5. How many organisations report that they have patched, and whether any major breach is attributed to Java4Shell in the weeks ahead.
  6. Whether the AI-assisted discovery method used here is repeated, and whether other critical flaws in widely used runtimes and libraries are disclosed in the coming months.
  7. Whether the disclosure changes how enterprises manage Java updates, and whether the long tail of unpatched Java runtimes shrinks or grows over the next year.

Sources

About the Author — Abdul Mannan

Leave a Reply

Your email address will not be published. Required fields are marked *