← News

Java4Shell Vulnerability (CVE-2026-114938) Allows Pre-Authentication RCE in Key Applications

A critical flaw, dubbed Java4Shell (CVE-2026-114938), allows unauthenticated remote code execution in several popular Java applications such as Jira and Jenkins on servers with AVX-512 VBMI processors.

By CyberX I.T SolutionsCibersegurança12 min readSource: Java4Shell (CVE-2026-114938) Enables Pre-Auth RCE in Jira, Jenkins, Keycloak on Java 17+ AVX-512 VBMI Servers ↗Ler em português →

A critical flaw in Java, dubbed Java4Shell and tracked as CVE-2026-114938, allows unauthenticated attackers to execute arbitrary code in widely used applications such as Jira, Jenkins, and Keycloak. The vulnerability, disclosed this week by the security research firm Calif, affects Java 17.0.6 and later versions, but only on Intel and AMD x86-64 processors that support the AVX-512 VBMI feature.

Oracle and the OpenJDK project have released patches for the flaw, which resides in an optimized version of Java's Base64 decoder. While Calif researchers claim to have achieved remote code execution (RCE) in six applications, other labs were able to reproduce only crashes and memory leaks. The Canadian Centre for Cybersecurity stated that it is not aware of any actively exploiting attacks on the flaw to date.

The Flaw Mechanism

The Java4Shell vulnerability exploits how servers often decode Base64-encoded data, such as HTTP Basic login headers, SAML artifacts, and CSRF tokens, before even verifying user authentication. This allows an unauthenticated attacker to manipulate the process.

The flaw is specifically in a faster version of Java's Base64 decoder, which is enabled on chips with AVX-512 VBMI. Java switches to this high‑performance decoder when the code is executed frequently. A malformed string that ends with an extra ‘=’ character causes this decoder to write 62 or 63 bytes beyond the end of its output. Although Java rejects the string, the out‑of‑bounds write already occurs.

The bytes written out of bounds are fixed, meaning an attacker only controls where those bytes are written in memory. Initially this suggested only system crashes, but Calif researchers developed a technique called “JavaBleed”. They manipulate the server’s memory layout so that the overflow expands a neighboring array, thereby allowing arbitrary byte writes and reading back memory. From there, the team claims the attack can reach the parts of Java responsible for code execution.

Impact and Exploitation

Calif reports that the attacks work without login on the default configurations of Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, and PingFederate. With authentication, the flaw can be exploited in Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, and Spinnaker. It is important to note that there is no single universal exploit; each target requires a specific memory layout and timing, and some attacks are sensitive to network latency.

Security firms such as Upwind and Blackpoint Cyber reproduced the memory corruption and crashes in lab environments. Upwind observed damage to adjacent objects in memory and Java crashes on an AWS server with an Intel Ice Lake chip. Blackpoint Cyber managed to trigger the flaw in a test Spring Boot application by sending about 28,300 malformed login requests in 20 seconds, and also used the JavaBleed stage to read a secret stored near the overflow in local tests, although it did not reproduce remote code execution.

The CVSS scores for CVE-2026-114938 vary: Calif rates it at 9.2 (CVSS 4.0), Oracle at 8.1 (CVSS 3.1), Red Hat preliminarily at 9.8, and Amazon at 8.8. Oracle’s description in its CVE record states that “successful attacks of this vulnerability may result in takeover of Oracle Java SE”.

Affected Versions and Fixes

The vulnerable code is present in Java 17.0.6 and later releases of the Java 17 line, as well as in Java 21, 25, and 27. The default Java 8 and Java 11 releases are not affected, but the Java SE 8 Performance Pack build 8u511b33-perf is vulnerable. 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 affected.

The vulnerability is exploitable only on x86‑64 chips that support AVX‑512 VBMI, including Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids, and AMD Zen 4 or newer chips. ARM64 chips are not affected. This means the same container image can be vulnerable on one server and not on another, depending on the underlying hardware.

To check whether a Linux server has the required CPU features, the following command can be used:

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

All four flags must appear in the output for the server to be potentially vulnerable.

The fixes have been released by the OpenJDK project and Oracle. Amazon has already patched its Corretto Java builds, and Azul has also updated its Zulu releases. However, Red Hat is still preparing patches for its OpenJDK builds and Red Hat Enterprise Linux. SAP, Eclipse Temurin, Microsoft Build of OpenJDK, and BellSoft Liberica had not listed patched builds at the time of the original news check.

Java BuildAffected VersionsFixed Version
Oracle Java SE 1717.0.6 to 17.0.21.0.317.0.21.1
Oracle Java SE 2121.0.13.0.3 and earlier21.0.13.1
Oracle Java SE 2525.0.5.0.3 and earlier25.0.5.1
Oracle Java SE 2727.0.1.0.3 and earlier27.0.1.1
Amazon Corretto 17, 21, 25 and 27Earlier builds, from 17.0.6 onward for Corretto 1717.0.21.1.2, 21.0.13.1.2, 25.0.5.1.2 and 27.0.1.1.4
Azul Zulu 17, 21, 25 and 27Earlier builds, from 17.0.6 onward for Zulu 1717.70.201, 21.54.201, 25.38.201 and 27.30.201 (free builds)
Red Hat Enterprise Linux 8, 9 and 10, and Red Hat build of OpenJDK 17, 21 and 2517.0.6 and later, including 21 and 25None yet

Products that bundle their own Java runtime require a vendor update. After updating, it is crucial to restart Java services and rebuild and redeploy container images to ensure the running process uses the new build.

Mitigation and Detection Measures

For systems that cannot be updated immediately, it is possible to start the JVM with one of the following flags, which should be removed after the patched version is installed:

  • -XX:-UseBASE64Intrinsics: Disables only the faster Base64 code, removing the vulnerable path while keeping other AVX-512 optimizations.
  • -XX:UseAVX=2: Completely disables AVX-512. This flag should be used only on x86-64 servers, as Java on ARM64 does not recognize it and will fail to start.

Upwind's laboratory tests confirmed that both flags prevented the overflow in all tested affected versions.

To identify exploitation attempts, Upwind suggests checking for the following indicators, with the caveat that none of them prove a compromise and their absence does not guarantee the server's safety:

  • Base64 tokens of 32 characters or more that end with '=' and whose length is not a multiple of 4, especially in Authorization headers.
  • Spikes of IllegalArgumentException errors from java.util.Base64$Decoder.
  • Unexplained hs_err_pid crash logs or bursts of restarts.

Interestingly, a malformed input that triggers the overflow was publicly posted on September 9, in a fix proposal submitted to the OpenJDK code repository as a pull request. The proposal described an overflow in the same AVX-512 Base64 decoder code. Its author closed it without merging in early November, after an automated inactivity warning.

CyberX Technical Analysis

The Java4Shell vulnerability (CVE-2026-114938) poses a significant risk due to its ability to allow remote code execution (RCE) without prior authentication under a specific set of conditions. The technical analysis reveals that exploitation is not trivial and depends on a combination of software and hardware factors.

Exploitation Mechanism and Hardware Dependency

The core of the flaw lies in the optimized implementation of Java's Base64 decoder, which is enabled exclusively on x86-64 processors that support the AVX-512 VBMI extension. This hardware dependency is crucial, as servers lacking this CPU capability are not susceptible to the vulnerability, even if they run the affected Java versions. Exploitation occurs when a malformed Base64 string ending with a '=' character is processed by this optimized decoder, resulting in a buffer overflow of 62 or 63 bytes beyond the allocated limit.

Although the written bytes are fixed, the "JavaBleed" technique developed by the Calif researchers demonstrates how this overflow can be chained to manipulate the memory layout of the Java process. By expanding a neighboring array in memory, attackers can then write arbitrary bytes and read memory, paving the way for code execution. This process requires deep knowledge of the JVM's memory allocation and the target application, making exploitation more complex and environment-specific.

Attack Surface and Conditions

The attack surface is broad, covering applications that decode Base64 data before authentication, such as HTTP Basic headers, SAML or CSRF tokens. A proxy like Nginx's ability to block some, but not all attempts, suggests that exploitation may be sensitive to network latency and request processing behavior. The lack of a universal exploit and the need to tailor the attack for each target indicate that large‑scale exploitation may be more challenging than with more generic vulnerabilities.

CyberX Recommendations

  • Patch Prioritization: The most effective measure is the immediate application of security updates provided by Oracle, OpenJDK, and Java distributors (Amazon Corretto, Azul Zulu). For products that bundle their own Java, wait for and apply updates from the respective vendors.
  • Use of Mitigation Flags: For systems where immediate patching is not possible, applying the JVM flags -XX:-UseBASE64Intrinsics or -XX:UseAVX=2 is a validated temporary mitigation. The former is preferred as it disables only the vulnerable component while retaining other AVX-512 optimizations. The latter disables all AVX-512 and should not be used on ARM64.
  • Hardware Verification: Proactively identifying servers that use processors with AVX-512 VBMI is crucial to determine actual exposure. The command grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$' on Linux can help with this identification.
  • Enhanced Monitoring: Implement monitoring for the suggested detection signals, such as IllegalArgumentException errors from the Base64 decoder and hs_err_pid crash logs, which can help identify exploitation attempts.
  • Container Image Rebuilding: After applying patches, it is imperative to rebuild and redeploy all container images that use the affected Java versions to ensure the new binaries are loaded.

The complexity of exploitation and hardware dependency may limit the number of successful attacks in real‑world environments, but the pre‑authentication nature and RCE impact warrant a swift and prioritized response.

CyberX SOC Intelligence Bulletin

The Java4Shell vulnerability (CVE-2026-114938) allows remote code execution (RCE) without authentication on specific Java systems. The threat is critical for environments running vulnerable Java versions on hardware compatible with AVX-512 VBMI, exposing applications such as Jira, Jenkins, and Keycloak to total compromise.

Assets and Exposure Conditions

  • Affected Java Versions: Java 17.0.6+, Java 21, 25, 27. Also Java SE 8 Performance Pack build 8u511b33-perf and certain GraalVM versions.
  • Required Hardware: Intel x86-64 processors (Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids) or AMD (Zen 4 or newer) that support AVX-512 VBMI. ARM64 chips are not affected.
  • High‑Risk Applications: Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, PingFederate (pre‑authentication RCE). Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, Spinnaker (RCE with authentication).
  • CPU Verification (Linux): Run grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'. The presence of all four flags indicates potential hardware vulnerability.

Investigation and Detection Indicators

  • Application/Web Server Logs: Look for HTTP requests containing Base64 tokens of 32 characters or more, that end with '=' and whose length is not a multiple of 4, especially in Authorization headers.
  • JVM Logs: Monitor for spikes of IllegalArgumentException errors originating from java.util.Base64$Decoder.
  • System/Crash Logs: Investigate unexplained hs_err_pid failure logs or patterns of unexpected restarts of Java services.
  • Network Monitoring: Traffic analysis for unusual patterns of malformed Base64 requests to sensitive endpoints.

MITRE ATT&CK

  • TA0001 - Initial Access:
    • T1190 - Exploit Public-Facing Application: The exploitation of Java4Shell allows an unauthenticated attacker to gain initial access to vulnerable systems through internet-exposed applications.
  • TA0002 - Execution:
    • T1059 - Command and Scripting Interpreter: After successful exploitation, the attacker can execute arbitrary code in the context of the compromised Java application.

Remediation and Mitigation

  • Urgent Patching: Update all affected Java installations to the patched versions (e.g., Oracle Java SE 17.0.21.1, Amazon Corretto 17.0.21.1.2, Azul Zulu 17.70.201).
  • JVM Flags: As a temporary measure, apply -XX:-UseBASE64Intrinsics or -XX:UseAVX=2 (x86-64 only) when starting the JVM.
  • Container Rebuilding: Rebuild and redeploy container images after applying patches to ensure the new Java builds are used.
  • WAF/IPS: Configure Web Application Firewalls (WAF) or Intrusion Prevention Systems (IPS) to detect and block HTTP requests with malformed Base64 patterns that may indicate exploitation attempts.

Response and Evidence Preservation

  • Containment: Isolate compromised or potentially vulnerable systems. Apply patches or mitigations immediately.
  • Eradication: Remove any malicious artifacts or backdoors installed after exploitation.
  • Recovery: Restore systems to a safe state from reliable backups, ensuring the vulnerabilities have been fixed.
  • Forensic Analysis: In case of compromise, collect application, system, network logs and memory dumps for forensic analysis, aiming to identify the attack's scope and accessed data.

Indicators of Compromise (IoCs)

No verifiable indicators of compromise (hashes, IPs, malicious domains) were identified in the sources consulted for this specific vulnerability. Detection should focus on the investigative signals and telemetry described above.

Frequently Asked Questions

Which Java versions are affected by Java4Shell?

Java 17.0.6 and later versions, as well as Java 21, 25, and 27, are affected. The default Java 8 and Java 11 releases are not affected, except for the Java SE 8 Performance Pack build 8u511b33-perf.

What hardware is required for the vulnerability to be exploitable?

The vulnerability is exploitable only on x86-64 chips that support the AVX-512 VBMI feature, including Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids, and AMD Zen 4 or newer chips.

How can I temporarily mitigate Java4Shell if I cannot patch immediately?

You can start the JVM with specific flags that prevent the overflow, which should be removed after the patched version is installed. Upwind's tests confirmed these flags prevent the overflow in affected versions.

Which applications are vulnerable to pre-authentication exploitation?

Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, and PingFederate are vulnerable without login on default configurations. With authentication, Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, and Spinnaker are also affected.

Esta análise foi útil?

Ainda não há avaliações.