← All articles

Java4Shell (CVE-2026-114938): The Base64 Decoder Flaw That Puts Jira, Jenkins, Keycloak and Confluence at Risk of Pre-Auth RCE

A newly disclosed Java vulnerability is sending enterprise security teams scrambling this week. Dubbed Java4Shell by the research firm Calif, which disclosed the flaw, CVE-2026-114938 is a buffer overflow in the Java Development Kit's Base64 decoder that can be triggered by an attacker who has never logged in — and it sits in a code path that runs on nearly every modern enterprise server chip.

Oracle and the OpenJDK project rushed out patches this week, but the flaw's reach — into Jira, Jenkins, Keycloak, Confluence, Artifactory, PingFederate, Kafka, Solr, Elasticsearch, Gerrit, and Spinnaker — means remediation will stretch across thousands of organizations' infrastructure for weeks.

What Is Java4Shell?

Modern Java servers routinely decode Base64-encoded data before they even check whether a request is authenticated. HTTP Basic Auth headers, SAML artifacts, CSRF tokens, and session identifiers are all Base64-encoded, and the decoding happens in the earliest stages of request handling — often before any login check runs.

On Java 17.0.6 and later, when the decoder runs frequently enough, the JVM's just-in-time compiler swaps in a faster, vectorized version of the Base64 decoder that takes advantage of the AVX-512 VBMI instruction set available on modern x86-64 chips: Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids, and Granite Rapids, along with AMD Zen 4 and newer.

The bug: a malformed Base64 string ending in an extra = padding character causes this optimized decoder to write 62 or 63 bytes past the end of its output buffer before Java notices anything is wrong and rejects the string. The write happens first; the rejection comes too late.

Early analysis of the vulnerable code suggested this would only cause crashes, since the overflow writes fixed, attacker-uncontrolled byte values. Calif's researchers went further. By carefully arranging server memory ahead of the overflow, they found they could make the overflow corrupt a neighboring array in a way that extends it — turning a fixed-content overflow into a primitive that lets an attacker write chosen bytes using one array and read memory contents back using a second array, a technique they named JavaBleed. From there, Calif says, the exploit chain can reach the parts of the JVM that execute code.

There is no single universal exploit. Each target application requires its own memory-layout grooming and timing, and some exploit paths are sensitive to network latency — a detail that matters for defenders, discussed below.

Severity and Scoring Disagreements

The vulnerability has drawn unusually divergent severity scores from different vendors, reflecting genuine disagreement about exploit difficulty:

  • Oracle: CVSS 3.1 score of 8.1, officially acknowledging that "successful attacks of this vulnerability can result in takeover of Oracle Java SE."
  • Red Hat: preliminary score of 9.8, rating it as requiring no authentication at all.
  • Amazon: 8.8, describing the risk as "a JVM crash for unauthenticated users or, in certain application environments, code execution by an authenticated low-privileged user."
  • Calif (the discoverers): 9.2 under CVSS 4.0.

As of this writing, Canada's Canadian Centre for Cyber Security says it is not aware of active exploitation, and CISA had not yet added CVE-2026-114938 to its Known Exploited Vulnerabilities (KEV) catalog. Independent labs — Upwind and Blackpoint Cyber's Adversary Pursuit Group — have reproduced crashes and the JavaBleed memory-read primitive but have not yet independently reproduced full remote code execution. Calif is deliberately withholding working exploit code for the six flagship applications it tested, which somewhat limits immediate real-world risk — but the underlying primitive is now public, and history suggests weaponized exploits for high-value Base64-reachable endpoints typically follow within days to weeks of this level of public technical detail.

Who Is Exposed

Affected Java versions: The vulnerable AVX-512 code path exists in Java 17.0.6 and later across the Java 17, 21, 25, and 27 release lines. Standard Java 8 and Java 11 builds are not affected, but the Java SE 8 Performance Pack build 8u511b33-perf is. GraalVM for JDK 17.0.21.0.3, GraalVM for JDK 21.0.13.0.3, and GraalVM Enterprise Edition 21.3.20.0.3 are also vulnerable.

Affected hardware: Exploitation requires an x86-64 chip supporting AVX-512 VBMI — Intel Ice Lake/Sapphire Rapids/Emerald Rapids/Granite Rapids Xeon chips, or AMD Zen 4 and later. ARM64 servers (including many cloud Graviton-class instances) do not run the vulnerable path at all, which meaningfully narrows the attack surface for organizations that have migrated to ARM.

To check if a given Linux server's CPU is vulnerable:

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

If all four flags appear, the chip supports the vulnerable path (the application still needs to be hitting the decoder with attacker-reachable Base64 input to actually be exploitable).

Affected applications tested by Calif:

Confirmed exploitable without any login under default settings:

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

Confirmed exploitable with a login (lower-privilege account sufficient):

  • Apache Kafka Broker
  • Apache Solr
  • Elasticsearch
  • Gerrit
  • Spinnaker

Calif explicitly notes this list is incomplete — any Java 17+ service on vulnerable hardware that decodes attacker-supplied Base64 before authentication is a candidate, including custom in-house applications. Calif also reports that a Java program that merely initiates an outbound TLS connection to a malicious server can be compromised client-side, via an exploit path contributed by researcher samczsun that has not yet been publicly detailed.

Fixes and Workarounds

Oracle and OpenJDK shipped patched builds this week:

Java buildAffected versionsFixed release
Oracle Java SE 1717.0.6 – 17.0.21.0.317.0.21.1
Oracle Java SE 21up to 21.0.13.0.321.0.13.1
Oracle Java SE 25up to 25.0.5.0.325.0.5.1
Oracle Java SE 27up to 27.0.1.0.327.0.1.1
Amazon Corretto 17/21/25/27from 17.0.6 onward17.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2, 27.0.1.1.4
Azul Zulu 17/21/25/27from 17.0.6 onward17.70.201, 21.54.201, 25.38.201, 27.30.201
Red Hat (RHEL 8/9/10, Red Hat OpenJDK 17/21/25)17.0.6 and laterNot yet released

SAP has shipped SapMachine 17.0.21.1, 21.0.13.1, 25.0.5.1, and 27.0.1.1. Eclipse Temurin, Microsoft Build of OpenJDK, and BellSoft Liberica had not published fixed builds at the time of writing. Red Hat customers running RHEL or Red Hat's OpenJDK builds currently have no official patch and should prioritize the workarounds below.

Immediate remediation steps:

  1. Patch the JVM. Update to the fixed build for your Java vendor and version line (see table above). This is the only complete fix.
  2. Restart every Java service after patching, and rebuild and redeploy any container images that bundle a JVM — an updated host JVM does nothing for an unpatched JVM baked into a container.
  3. If you cannot patch immediately, start affected JVMs with one of these flags as a temporary mitigation:

- -XX:-UseBASE64Intrinsics — disables only the vulnerable fast-path Base64 decoder, leaving other AVX-512 optimizations intact. This is the recommended workaround. - -XX:UseAVX=2 — disables AVX-512 entirely. x86-64 only; do not use on ARM64, where it will prevent the JVM from starting. - Avoid -XX:DisableIntrinsic=_base64_decodeBlock used alone — testing by Upwind found it can prevent the JVM from starting.

  1. Check whether any of your production Java services run on AVX-512 VBMI-capable hardware using the CPU flag check above. If your fleet is entirely ARM64 or older x86-64 chips, you are not exposed to this specific flaw (though you should still patch on general principle).
  2. Audit any custom or third-party Java 17+ application that decodes Base64-encoded data (Authorization headers, SAML, JWT-adjacent tokens, CSRF tokens) prior to authentication — not just the six named applications.

Detection Guidance

Upwind suggests monitoring for the following signs — with the caveat that none of them individually confirms a compromise attempt, and their absence doesn't guarantee safety:

  • Base64 tokens of 32+ characters that end in = padding and whose total length is not a multiple of 4 — especially inside Authorization headers.
  • Bursts of IllegalArgumentException errors originating from java.util.Base64$Decoder.
  • Unexplained hs_err_pid crash logs, or clusters of unexpected JVM restarts.

Blackpoint Cyber's lab testing found that roughly 28,300 malformed login requests sent over about 20 seconds crashed a test Spring Boot application without a single successful login attempt — a volume and pattern that should be straightforward to catch with basic WAF or rate-limiting rules, and a useful baseline for tuning detection thresholds.

A network proxy that buffers and waits for complete requests, such as nginx in its default configuration, blocks some but not all attack variants — it should not be relied upon as a primary control.

Background: A Public Trail Since September

Notably, a pull request submitted to the OpenJDK code repository on September 9, 2026, publicly described an overflow in the same AVX-512 Base64 decoder code as a proposed fix. The pull request's author closed it without merging after an automated bot flagged it as inactive for over eight weeks — meaning the underlying flaw sat in a public GitHub thread, undisclosed as a security issue, for more than two months before this week's coordinated disclosure.

FAQ

Is CVE-2026-114938 being actively exploited? As of this writing, no. Canada's Cyber Centre and CISA's KEV catalog show no evidence of in-the-wild exploitation. Independent researchers have reproduced crashes and a memory-read primitive (JavaBleed) but not full remote code execution outside Calif's own lab, and Calif has withheld working exploits for the named applications.

Does this affect ARM-based servers (e.g., AWS Graviton)? No. The vulnerable fast-path decoder only activates on x86-64 chips with AVX-512 VBMI support. ARM64 processors do not execute this code path and are not exposed to this specific CVE.

My app uses Java 11 — am I safe? Yes, for this specific flaw. Standard Java 8 and Java 11 builds don't contain the vulnerable AVX-512 intrinsic. The exception is the Java SE 8 Performance Pack (build 8u511b33-perf), which is affected and should be updated to 8u513.

What's the single fastest mitigation if I can't patch tonight? Add the JVM startup flag -XX:-UseBASE64Intrinsics to affected services and restart them. It disables only the vulnerable Base64 fast path while preserving other performance optimizations, and Upwind's lab confirmed it stops the overflow on every version tested.

Why do Oracle, Red Hat, and Amazon disagree so much on severity? They're scoring different things. Oracle's 8.1 reflects its own assessment of exploit difficulty against its builds; Red Hat's 9.8 assumes worst-case unauthenticated exploitability; Amazon's 8.8 splits the risk between a near-certain crash and a conditional authenticated RCE. The spread itself is a signal that exploit reliability varies heavily by target application and environment — treat it as "serious and worth urgent patching" rather than getting hung up on the exact number.

Find what attackers can see, before they do.

AI pentesting agents test your web app, API and cloud, and every finding comes with evidence and a fix. First report in about 10 minutes.

Stay ahead of attackers.

New vulnerabilities, breach write-ups and practical fixes. A few emails a month.