Critical Java and nginx flaws Java4Shell + nginx2rootScan my domain
JavaOpenJDKRCECVEVulnerabilityJava4Shell

CVE-2026-114938 (Java4Shell): memory corruption in OpenJDK's Base64 decoder

Java4Shell, CVE-2026-114938: out-of-bounds write in the Base64 decoder of OpenJDK 17.0.6 and later on AVX-512 processors. Fixed versions, checks, workaround.

by Updated on 29 min read
CVE-2026-114938 (Java4Shell): memory corruption in OpenJDK's Base64 decoder

Background

On 17 November 2026, Oracle released security builds of Java SE. The OpenJDK Vulnerability Group published an advisory the same day listing CVE-2026-114938, a memory corruption in the HotSpot virtual machine.

The flaw was reported by the security firm Calif, which named it Java4Shell. It sits in the JVM's Base64 decoder, in the variant optimised for recent x86-64 processors. A malformed Base64 value makes it write 62 bytes past the destination array.

Base64 is not a feature an application chooses to use. A Java server decodes some with every authentication header, every token and every uploaded file. That explains the list Calif published: unauthenticated code execution on Keycloak, Jenkins, Jira, Confluence, Artifactory and PingFederate, in their default configuration.

We have not reproduced this flaw. The article relies on Calif's publication, on the advisories from Oracle, OpenJDK, Red Hat and Debian, and on the analyses released over the following twenty-four hours. Some information is still missing, notably the fixed versions of several distributions. We say so each time.

We revised this article on the evening of 18 November. Three things had changed since the morning: Eclipse Temurin released its fixed builds, Red Hat and Keycloak now recommend the workaround that only Calif had put forward, and GreyNoise is seeing the first attempts on its sensors.

We revised it a second time on the morning of 19 November, because the night moved the problem. Ubuntu and Red Hat published their packages, Keycloak rebuilt its images, and the fix can now be read in OpenJDK's public sources. The day before, the question was when fixes would arrive. For most estates it is now where they have not been installed yet. Debian stable and the Temurin container images were the two that lagged at that point.

A third revision followed on 20 November. Debian published its packages during the day of the 19th, which leaves the Temurin images alone. The other new element concerns the history of the flaw more than its fix: Calif added a timeline to its publication, and it shows that the bug had been reported publicly since June, with a fix proposed in September. We have reworked the Timeline section accordingly.

The video below sums up the flaw in two minutes. The rest of the article goes through each point in detail, with its sources.

Technical summary

ItemValue
IdentifierCVE-2026-114938, "Java4Shell"
ComponentHotSpot, hand-written AVX-512 Base64 decoding routine (stubGenerator_x86_64.cpp)
ClassCWE-787, out-of-bounds write on the heap
SeverityOracle: CVSS 3.1 of 8.1. Calif: CVSS 4.0 of 9.2. Red Hat: preliminary 9.8
Affected versionsOpenJDK 17.0.6 and later, lines 17, 21, 25 and 27; Oracle Java SE 8 Enterprise Performance Pack
FixOracle Java SE 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1 and 8u513-perf, released 17 Nov 2026
Conditionsx86-64 processor with AVX-512 VBMI, and untrusted data decoded by java.util.Base64
DiscoveryQuang Luong (Calif); Oracle also credits Albert Yang, who had found the root cause in September
ExploitationAttempts recorded by GreyNoise, no confirmed intrusion as of 20 November; not in KEV

Three scores are in circulation for the same flaw. Oracle rates it 8.1 with the vector AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H, which the Debian security tracker reproduces. Calif announces 9.2 under CVSS 4.0 without publishing its vector. Red Hat shows 9.8 and rates the flaw "critical", noting that its scores apply to its own builds.

The whole gap comes from attack complexity, which Oracle rates high and Red Hat low. Exploitation depends on the processor, on the state of the JVM's compiler and on memory preparation that differs for each product. Oracle's reading seems to us the most accurate of the three.

It does not change the priority the fix deserves. The products Calif tested are identity providers, forges and artefact repositories: whoever takes control of one obtains the secrets and the access of everything that depends on it. On an internet-facing Java service running on an affected processor, we would treat this flaw as critical. Our triage method is described in the article on vulnerability prioritisation.

Affected systems

A system is exposed when three conditions are met:

  1. its JVM is built from OpenJDK 17.0.6 or later, without the fix;
  2. its processor is an x86-64 that supports AVX-512 VBMI;
  3. data supplied by a third party reaches Java's standard Base64 decoder.

Java versions

The faulty routine was written for JDK 18, then backported to the 17 branch in version 17.0.6, in January 2023. That sets the lower bound: versions 17.0.0 to 17.0.5 do not contain it, nor do Java 11 or standard Java 8.

Oracle reports one exception for Java 8. Its "Enterprise Performance Pack" build (8u511b33-perf) carries optimisations taken from recent versions, including this one. It is fixed in 8u513-perf.

The advisories only name the maintained lines, 17, 21, 25 and 27. Calif, for its part, writes that the flaw affects OpenJDK "17.0.6 or newer", which includes the intermediate lines (18 to 20, 22 to 24, 26). These no longer receive updates. We consider them affected, with no fix to expect: the only way out is to move to a maintained line.

The defect belongs to OpenJDK's common code. Every distribution inherits it: Eclipse Temurin, Amazon Corretto, Azul Zulu, Microsoft Build of OpenJDK, BellSoft Liberica, SapMachine, GraalVM, Red Hat's packages and those of Linux distributions.

Processor

The vulnerable code only runs on processors that have the AVX-512 VBMI instruction set. At Intel, these are the Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids Xeon generations. At AMD, EPYC and Ryzen from Zen 4 onwards.

An ARM64 server, such as AWS Graviton instances, is not affected. Neither is an older x86-64. Recent x86 instances at cloud providers almost all are, however: Upwind reproduced the overflow on an AWS c6i instance.

This condition makes the inventory harder. The same container image is vulnerable on one node and not on another, and the orchestrator can move it between them without telling anyone. We advise against relying on the processor type to postpone the upgrade.

Entry points

The Base64.getDecoder() and getUrlDecoder() decoders are affected. The MIME decoder is not, according to Endor Labs, and an application that goes through another decoding library does not reach this code.

The labs that studied the flaw identified several paths reached before any authentication:

  • HTTP Basic authentication, as handled by Tomcat, Jetty 12 and Spring Security;
  • token decoding by the java-jwt library;
  • file uploads, on some products.

The first of these paths deserves a closer look. A server decodes the Authorization header in order to check the password, so before it knows whether the caller is legitimate. Requiring authentication does not protect against a flaw located in the processing of authentication.

Calif also describes the reverse scenario, where the victim is the client. A Java program that opens a TLS connection to a malicious server can be reached. Batch jobs, connectors and agents that call third-party services are therefore in scope, even if they listen on no port.

Products tested by Calif

Access requiredProducts
No authenticationKeycloak, Jira, Confluence, Artifactory, Jenkins, PingFederate
Authenticated userKafka (broker), Solr, Elasticsearch, Gerrit, Spinnaker
Sample appsApache Struts, Spring Boot

This table lists what Calif tested. It does not delimit what is vulnerable: the defect is in the JVM, and any Java application that decodes Base64 received from the network is a candidate, in-house developments included.

How it works

This section is based on Calif's publication and on the Endor Labs analysis. We have not verified these elements in the OpenJDK source code.

A decoder written in assembly

When a Java method is called often, HotSpot's just-in-time compiler, C2, translates it into machine code. For a handful of very hot methods it goes further and substitutes a hand-written assembly routine, known as an intrinsic. Base64 decoding is one of them.

On an AVX-512 VBMI processor, this routine handles the input in 64-byte blocks. The end of the input, shorter than a block, is written through a mask that limits how many bytes are copied to the output array.

This explains one detail of the exploitation. Until the decoder has been called often enough to be compiled by C2, the vulnerable routine is not used. On a production service, which decodes Base64 with every request, that condition is met permanently.

Computing the mask

The defect is in how that mask is computed. If the end of the input carries one or two = padding characters at a position the routine does not expect, the computed output length becomes negative, and the resulting mask no longer limits anything.

The routine then writes a full 64-byte block where it should have written two bytes. The 62 extra bytes overwrite whatever follows the array on the JVM heap.

Java then rejects the input with an IllegalArgumentException, as it does for any invalid Base64. The write has already happened. The application has only seen a refused request, and nothing in its behaviour signals the incident.

From the write to code execution

The Java heap lays objects out one behind another. The extra bytes therefore land on the neighbouring object, and their content comes from the input supplied by the attacker.

Calif derives two uses from this. The first is reading the process memory, which holds session tokens, keys and other users' data. The second is code execution. In both cases, the attacker first has to bring the memory into a favourable layout, through preparatory requests that depend on the targeted product.

Kill chain

From a Base64 input to heap corruption

  1. 1

    Warm-up

    ordinary requests lead C2 to compile the decoder and substitute the AVX-512 routine.

  2. 2

    Badly terminated input

    the attacker sends a Base64 value whose padding sits where the routine does not expect it.

  3. 3

    Unbounded mask

    the computed output length drops below zero, the routine writes a full block.

  4. 4

    Overflow

    62 bytes overwrite the object that follows the output array on the heap.

  5. Late rejection

    Java throws its exception after the write. The application only sees an invalid request.

Reconstructed from Calif's publication and the Endor Labs analysis. We have not reproduced these steps.

What slows exploitation down

Calif makes clear that its exploit is in no way universal. Each target needs a dedicated profile, and the chain is sensitive to network latency: the researchers had to rent a machine in the same region as their target.

A badly tuned attempt brings the JVM down. Upwind measured that an overflow on an exactly sized array corrupted the next object in 97% of runs and eventually caused a crash. That is only half an obstacle: the service restarts, and the attacker starts again.

We would not count on these obstacles to buy time. They slow down the first attacker who writes a profile for a given product. Once that profile is published, they slow down nobody.

Two protections that are often mentioned do not hold either. A reverse proxy that buffers requests does not reliably block the attack, according to Upwind and Sysdig. And the fix for another defect in this same decoder, shipped in 17.0.11 and 21.0.3 under reference JDK-8321599, does not cover this one.

Available fixes

The table below gives the status we recorded on the morning of 20 November. The major distributions are now all fixed, and what remains open comes down to container images and to products that bundle their own JVM.

DistributionStatus recorded on the morning of 20 November 2026
Oracle Java SEFixed in 17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1 and 8u513-perf
Amazon CorrettoFixed in 17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2 and 27.0.1.1.4 (as recorded by Aikido)
Eclipse TemurinArchives 17.0.21.1+2, 21.0.13.1+2, 25.0.5.1+2 and 27.0.1.1+4; nothing for Windows, no image
Azul ZuluFixed in 17.70.201, 21.54.201, 25.38.201 and 27.30.201 (.202 builds for customers)
SapMachineFixed in 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1, released on the evening of 17 November
MicrosoftBuilds 17.0.21.1, 21.0.13.1 and 25.0.5.1 listed in the release notes
Red HatErrata for java-17-openjdk (RHEL 8, 9), java-21-openjdk (RHEL 8, 9, 10), java-25-openjdk
UbuntuFixed from 18.04 to 26.10 (USN-9155-1 to USN-9158-1), -crac packages included since the 20th
DebianFixed: DSA-6639-1 and DSA-6640-1 (Debian 13, lines 21 and 25), DLA-4917-1 (Debian 12, line 17)
SUSETumbleweed fixed; fixes in preparation for SLES 15 SP7 and 16, no advisory published
OpenJDK (sources)Fix present in the -ga tags of the 17, 21 and 25 repositories

Temurin remains the case that needs care. The Linux x64 archives of all four lines are online, as are the macOS ones for 17, 21 and 25, but the project's release tracker shows nothing for Windows and no container image. We queried Docker Hub on the morning of the 19th, then again on the 20th: the eclipse-temurin tags, rebuilt every night around 05

UTC, still carry 17.0.21+9, 21.0.13+9 and 25.0.5+8. A docker pull run today therefore brings back an affected JVM, inside an image dated today. Adoptium explains that images only ship once every binary of a version has been published. Until then, what counts is the version read inside the image, not its date.

At Red Hat, the first errata came out during the night of 18 to 19 November: RHSA-2026

for java-17-openjdk on RHEL 9, RHSA-2026
and 100568 for java-21-openjdk on RHEL 8, 9 and 10. The list filled out during the day of the 19th, with RHSA-2026
for java-17-openjdk on RHEL 8, then RHSA-2026
and 100572 for java-25-openjdk on RHEL 9 and 10. Bulletin RHSB-2026-018 was modified on 20 November and yet still describes fixes as ongoing. Between that page and the errata list, the list is the one to trust.

The same bulletin widens the scope beyond the java-*-openjdk packages. It names UBI containers, the products that take their JVM from the RHEL channel (OpenShift among them), the Red Hat build of Keycloak, and Red Hat Single Sign-On 7.6 when it runs on OpenJDK 17. On OpenJDK 11, the latter is not affected. Most of these products are still listed as affected.

On Ubuntu, the openjdk-17, -21, -25 and -27 packages have been fixed since 18 November. The openjdk-*-crac variants in 26.04 and 26.10, which we still reported as vulnerable on the 19th, received their fixes on the 20th. Only openjdk-26 is still awaiting evaluation.

Debian published on 19 November, in two steps: two DSAs for lines 21 and 25 in Debian 13, and an advisory from the LTS team for line 17 in Debian 12. The packages follow Oracle's numbering (21.0.13.1+2-1~deb13u1, for instance), which keeps the check simple. The testing release, forky, is still vulnerable.

Numbering is not the same from one vendor to the next. Oracle's fourth digit (17.0.21.1) does not carry over as is, and a Linux distribution may backport the fix without changing the displayed version. The only authoritative document is the advisory from the vendor of the JVM actually in use.

One point we had left open is settled. Endor Labs tied the fix to ticket JDK-8393212, "Base64 optimization improvements", without official confirmation. The public sources now let anyone check. Between the jdk-21.0.13.0.3-ga and jdk-21.0.13.1-ga tags of the jdk21u repository we count fifteen commits. Only one touches the decoder: it carries that number and adds four lines to stubGenerator_x86_64.cpp. No official page writes the two identifiers side by side, since the ticket stays closed to the public, but little room is left for doubt.

Four lines: that is the size of the fix for a flaw scored as high as 9.8. The figure matters to anyone who maintains their own OpenJDK distribution or is waiting for a backport, because a change that short carries over to a branch without difficulty. We see it as one more reason not to accept "fix in preparation" from a vendor for long.

Checking a machine

The check is done on the server and concerns the running process, not the installed package. Many products ship their own JVM in their installation directory: upgrading the system openjdk package changes nothing for them.

Start with the processor. On Linux, the hardware condition is met when this command returns all four flags:

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

Then, for each running Java process, record the binary in use and its version:

readlink -f /proc/<pid>/exe
jcmd <pid> VM.version

The last command gives the state of the two options that control the faulty code, which also lets you confirm that a workaround is actually applied:

jcmd <pid> VM.flags -all | grep -E 'UseBASE64Intrinsics|UseAVX '

In a container, these commands run inside the container. The processor remains the host's.

From the outside

Very little can be read remotely. An application server announces neither its JVM version nor its machine's processor, and those are precisely the two elements that decide exposure.

There is no safe active test either. A vulnerable JVM and a fixed one answer a malformed input in the same way: they reject it. What sets them apart is the memory write, in other words the corruption itself. Sending that input to a server to find out whether it is vulnerable means taking the risk of bringing it down. We do not do it, and we advise against tools that offer to.

Two observations remain possible without disturbing anything. The first is the presence, on the internet, of one of the products Calif tested. The second is the JVM version, when a management interface left open publishes it: a Spring Boot Actuator, a Solr system page, an Elasticsearch API.

Our Java4Shell scanner performs these two reads, and we wrote the matching Nuclei template. Neither sends a malformed input. Their result places a machine, it does not settle the question: the processor stays unknown, and the check ends on the server.

Remediation

  1. Upgrade the JVM to a version its vendor declares fixed.
  2. Restart every Java process. A JVM that is already running keeps the old code until it stops.
  3. Rebuild container images on a fixed base, then redeploy.
  4. Deal first with exposed services running on an AVX-512 processor: identity providers, forges, artefact repositories, collaboration tools.
  5. Inventory bundled JVMs inside products. They do not follow system updates and depend on their own vendor's fix.

Workaround

Neither Oracle nor OpenJDK offers a workaround in its advisory. Calif gives two, which several labs have tried. Since then, Red Hat has taken them up in its bulletin, and Adoptium, Keycloak and Jenkins recommend the first. This is no longer one researcher's advice.

The first disables the optimised Base64 routine. It is the one we would apply, and the one Red Hat gives as preferred:

-XX:-UseBASE64Intrinsics

Upwind reports that this option blocked the overflow on every version it tested. Decoding falls back to the Java code, which is slower. The difference only shows on services that decode large volumes, and it should be measured before a general rollout.

The second, -XX:UseAVX=2, disables all AVX-512 optimisations. Its performance cost is broader, and it has a trap: an ARM JVM does not recognise this option and refuses to start. Applied indiscriminately to a mixed fleet, it causes an outage. Red Hat, for that matter, restricts it to x86-64 machines.

A third variant is circulating, -XX:DisableIntrinsic=_base64_decodeBlock. It requires -XX:+UnlockDiagnosticVMOptions, failing which the JVM does not start. We would avoid it.

The CERT-EU advisory writes the first workaround with that same prefix, -XX:+UnlockDiagnosticVMOptions -XX:-UseBASE64Intrinsics, whereas Calif, Red Hat, Adoptium, Keycloak and Jenkins give the option alone. We did not settle it with a test. The jcmd check described above tells you what is actually in force in any case, whichever spelling is used.

Whichever option is chosen, it only takes effect on restart. Passed through the JAVA_TOOL_OPTIONS environment variable, it applies to every Java process on the machine, including the ones nobody had in mind. Better to try it on one service before rolling it out everywhere.

Keycloak deserves a separate word, since it tops Calif's list. The project published its own advisory on 18 November: its 26.8.2-1 and 26.8.2-2 images bundle an affected OpenJDK 21.0.13. Images rebuilt on OpenJDK 21.0.13.1 have been online since 19 November at 07

UTC, under the latest, 26.8 and 26.8.2-3 tags. A maintainer first announced them on the project's issue tracker, and the official post was updated later that morning. Where the image cannot be replaced right away, the option is passed through the JAVA_OPTS_APPEND variable. The project stresses one point that we make our own: the result is checked with jcmd on every running instance, not by reading the environment variable back.

Jenkins published a blog post on 18 November, which points to the Java update and, failing that, to the same option. It is not a security advisory, and it says nothing about fixed images: those of jenkins/jenkins on Docker Hub dated from the morning of 17 November when we looked, so from before the fix. Atlassian has since published a note on its Data Center products, which we could not read directly. According to SecurityWeek, it lists Bamboo, Bitbucket, Confluence, Crowd, Jira and Jira Service Management as affected, announces fixes to come and offers a workaround in the meantime.

Looking for compromise

No indicator of compromise has been published. The analyses from Sysdig, Upwind and Endor Labs describe indirect signals, to be looked for in this order.

The most specific is the shape of the request. A standard encoder never produces a Base64 value ending in = whose length is not a multiple of four. The search covers values longer than 32 characters, starting with Authorization headers where the proxy or the WAF logs them.

What GreyNoise has observed since 17 November matches this signal. On the morning of 20 November its dashboard counted 197 requests of this shape from seven addresses, up from 156 and five addresses the day before. They are carried in the Authorization header (Basic and Bearer schemes). No intrusion is confirmed on its sensors, and Cloudflare, which published firewall rules on the 18th, says it has detected no sign of exploitation either.

The targeted paths have changed since the day before, and that is what holds our attention most. The first requests almost all went to the site root. The 19 November reading also listed /login.action, /rest/api/space and /actuator/env, which are Confluence and Spring Boot paths. The 20 November one adds /crumbIssuer/api/json, /whoAmI/api/json and /cli, which are Jenkins paths, along with a Jira API path. Whoever sends these requests is no longer sweeping at random, they are aiming at the products on Calif's list. The volume is still low, and some of it probably comes from researchers. An exposed Java service nonetheless has a fair chance of having received some, and its access logs can tell.

Application logs give a second signal. Each attempt leaves an IllegalArgumentException thrown by java.util.Base64. A single exception is nothing unusual, a badly written client is enough to produce one. A tight series coming from one address warrants a look.

That leaves crashes. A failed attempt leaves an hs_err_pid*.log file in the JVM's working directory:

find / -xdev -name 'hs_err_pid*.log' -newermt '2026-11-01' 2>/dev/null

Endor Labs indicates that the call stack of these crashes contains Base64$Decoder.decode0. Unexplained restarts of a Java service since mid-November should be compared with the access logs of the same moment.

None of these signals proves an attack, and their absence proves nothing either. A successful exploitation may leave neither an unusual exception nor a crash. What remains is the usual monitoring: a Java process that spawns a command interpreter, or opens an outbound connection to an unknown destination.

Timeline

Disclosure did not go as planned. Calif says details had leaked before the fix was released, and brought its publication forward. The fix was ready nonetheless: it had been in the OpenJDK repositories for a month, under embargo, according to Endor Labs.

The timeline Calif added to its publication on 19 November changes how this story reads. The bug was not unknown. A user had hit it in production and reported it to Adoptium on 9 June. On 8 September that user posted a program that reproduced the crash, and an OpenJDK developer, Albert Yang, identified the root cause the same day, then proposed a fix the next day in a public pull request. That pull request saw no further activity and was closed without being merged. Calif says it found the flaw on its own on 24 October, without consulting those reports, and only came across the public ticket two days later.

We take two things from this. The first is that the bug spent more than two months in a public repository, described as a crash, with its cause and its fix, without anyone treating it as a security flaw. It took a demonstration of code execution for that to happen, and Calif notes that php2shell followed the same path. The second is practical: a crash ticket in a decoder, opened with a JVM or library vendor, deserves to be read as a possible security report, even when its author does not present it that way.

Calif also gives the cost of its research. The flaw was found in about an hour with the help of an AI model, and a first exploit followed two hours later, for less than 200 dollars of compute. The firm lists php2shell among its earlier work.

That figure is worth keeping in mind. An assembly routine shipped in JVMs since 2022 contained a defect that took one hour to find. Other teams have the same tools, and more advisories of this kind should be expected on components everyone considered battle-tested.

Timeline

Timeline of CVE-2026-114938

Origin

  1. January 2023

    OpenJDK 17.0.6

    the AVX-512 decoding routine, written for JDK 18, is backported to the 17 branch.

Fix

  1. 9 June 2026

    First report

    a user hits the crash in production and opens a ticket with Adoptium, according to Calif.

  2. 8 and 9 September 2026

    Root cause found

    a program reproduces the crash, Albert Yang finds the cause and proposes a fix in a public OpenJDK pull request, which will not be merged.

  3. 14 October 2026

    Embargoed commit

    the fix lands in the sources, according to Endor Labs.

  4. 24 October 2026

    Discovery by Calif

    Quang Luong finds the flaw independently and reports it to Oracle with a demonstration of code execution.

  5. 12 November 2026

    Oracle pre-release notice

    eleven Java SE fixes announced, highest score 8.1, no CVE identifier.

Disclosure

  1. 17 November 2026, 10

    Leak

    the flaw is discussed publicly before the fix is out.

  2. 17 November 2026, 17

    OpenJDK advisory

    CVE-2026-114938 listed for versions 17, 21, 25 and 27. Oracle releases its fixed builds.

  3. 17 November 2026, 21

    Calif publication

    technical analysis and list of tested products. CISA issues an alert that evening.

Aftermath

  1. 18 November 2026

    Fixes and workaround

    Temurin and Ubuntu release their fixed builds. Red Hat and Keycloak recommend disabling the routine until theirs are out.

  2. 19 November 2026, 07

    Red Hat and Keycloak

    first RHEL errata during the night, Keycloak images rebuilt on OpenJDK 21.0.13.1.

  3. 19 November 2026, during the day

    Debian

    DSA-6639-1 and DSA-6640-1 for Debian 13, DLA-4917-1 for Debian 12. Red Hat completes its errata.

  4. 20 November 2026, morning

    Status on that date

    197 attempts recorded by GreyNoise from seven addresses, no confirmed intrusion, flaw absent from the KEV catalogue.

Dates taken from the publications of Calif, Endor Labs, Sysdig, Tenable and GreyNoise. Times in UTC.

Knowing where Java runs

Upgrading a known JVM takes a few minutes. The time-consuming work is finding them all: the system one, those that products bundle, those in container images built six months ago and never rebuilt since.

Java has one trait that does not help. It does not announce itself. A Jenkins, a Keycloak or a Jira is recognised by its login page, not by its language, and many teams run Java applications without ever having classified them as such.

The services most exposed to this flaw are also the ones readily published on the internet for convenience: a forge opened to a contractor, an identity provider for remote logins, an artefact repository for an external build chain. That list is not drawn up on the day of the advisory. It is kept current continuously, by inventorying your external attack surface.

Frequently asked questions about Java4Shell

What is Java4Shell?

It is the name Calif gave to CVE-2026-114938, an out-of-bounds write in the optimised Base64 decoder of the HotSpot JVM. A malformed input makes it write 62 bytes past a heap array, which can lead to a read of the process memory or to code execution.

Which Java versions are affected?

OpenJDK from 17.0.6 onwards, on lines 17, 21, 25 and 27, along with every distribution built from it. Java 11 and standard Java 8 do not contain the faulty code. Oracle's Java SE 8 Enterprise Performance Pack build is affected.

Is my server affected if it runs on ARM?

No. The vulnerable routine only exists for x86-64 and is only used on processors with AVX-512 VBMI. An x86-64 older than Ice Lake at Intel, or Zen 4 at AMD, is not affected either.

How does it relate to Log4Shell?

By name, and nothing else. Log4Shell affected the Log4j library and was exploited with a simple string, on any machine. Java4Shell is a memory corruption in the JVM itself. It depends on the processor, and its exploitation is prepared product by product.

Is there a workaround?

Yes. Starting the JVM with -XX:-UseBASE64Intrinsics disables the optimised routine. First suggested by Calif, this option is now recommended by Red Hat, Adoptium and Keycloak. It does not appear in the Oracle and OpenJDK advisories, requires a restart and does not replace the upgrade.

Is the flaw being exploited?

Attempts are being observed, no intrusion is confirmed. On the morning of 20 November 2026, GreyNoise counted 197 malicious requests from seven addresses, and the flaw was still absent from the KEV catalogue. Calif published a program that reproduces the overflow on a local machine and is holding back its per-product exploit code. According to Tenable, Immersive says it has written one, and VulnCheck supplies one to its customers. Wiz writes that it built one in two hours, without publishing it. A GitHub repository created on the evening of 17 November advertises per-product exploit chains: we have not examined its code, and no trusted source confirms that it works.

Can a server be tested remotely?

Not without risk. The request that tells a vulnerable JVM from a fixed one is the one that corrupts memory, and it can bring the service down. The reliable check is done on the machine: JVM version, processor flags, startup options.

Sources

Let’s discuss your external exposure

Request a personalized Flawfence demo and discover your real exposure level.