Java4Shell flaw allows remote code execution in Jira and Jenkins on specific chips
A critical Java vulnerability enables unauthenticated attackers to run code on servers using modern Intel or AMD processors. Fixes are available for most major Java distributions.
Security researchers have disclosed a severe vulnerability in the Java runtime environment that allows attackers to execute arbitrary code on affected servers without logging in. The flaw, tracked as CVE-2026-114938 and nicknamed Java4Shell, impacts widely used self-hosted applications including Jira, Jenkins, Keycloak, and Confluence. Oracle and the OpenJDK project released patches this week, though some vendors like Red Hat have not yet issued fixes.
What happened
The vulnerability exists in a performance-optimized Base64 decoder within Java versions 17.0.6 and later, as well as Java 21, 25, and 27. This specific code path only activates on x86-64 processors from Intel and AMD that support the AVX-512 VBMI instruction set. When the Java Virtual Machine (JVM) detects these hardware capabilities, it switches to a faster decoder for frequently executed code. However, a malformed Base64 string ending with an extra equals sign causes this decoder to write data past the end of its allocated memory buffer.
Although Java eventually rejects the invalid string, the out-of-bounds write occurs first. Researchers from the security firm Calif demonstrated that attackers can manipulate server memory layout to exploit this overflow. By expanding a neighboring array, they gain the ability to write chosen bytes and read back memory contents, a technique they call JavaBleed. This process ultimately allows them to hijack parts of the Java runtime to execute their own code. The attack works against default configurations of several major enterprise tools, requiring no authentication for some and low-level access for others.
Key details
- Affected Hardware: Only x86-64 CPUs with AVX-512 VBMI support, such as Intel Ice Lake, Sapphire Rapids, and AMD Zen 4 or newer. ARM64 chips are not vulnerable.
- Affected Software: Java 17.0.6+, 21, 25, and 27. Standard Java 8 and 11 are safe, except for the Java SE 8 Performance Pack build 8u511b33-perf.
- Vulnerable Applications: Jira, Confluence, Jenkins, Keycloak, JFrog Artifactory, and PingFederate are exploitable without login. Kafka, Solr, Elasticsearch, Gerrit, and Spinnaker require authentication.
- Fix Status: Oracle, Amazon Corretto, Azul Zulu, SAP, and GraalVM have released patched versions. Red Hat Enterprise Linux and its OpenJDK builds do not have fixes yet.
- Severity Scores: Calif rates the flaw 9.2/10 (CVSS 4.0). Oracle rates it 8.1/10 (CVSS 3.1), while Red Hat assigns a preliminary 9.8/10.
- Detection Signs: Look for bursts of
IllegalArgumentExceptionerrors fromjava.util.Base64$Decoderor unexpected JVM crash logs (hs_err_pid).
Background
Base64 is a common encoding scheme used to transmit binary data over text-based protocols like HTTP. Applications often decode Base64 strings in login headers, security tokens, or cross-site request forgery protections before verifying user credentials. Because this decoding happens early in the request process, an attacker can send malicious data without having a valid account. The vulnerability arises from a trade-off between speed and safety. Java includes specialized machine code instructions (intrinsics) to accelerate Base64 decoding on modern hardware. While these intrinsics improve performance, a bug in the boundary checking logic allows data to spill into adjacent memory regions, corrupting the state of the application.
Why it matters
For teams running self-hosted software, this vulnerability presents a high-risk scenario because it bypasses authentication mechanisms. Tools like Jenkins and Jira are often exposed to internal networks or the internet to facilitate development workflows. An unauthenticated remote code execution flaw means an attacker could potentially take control of the server hosting these critical services. Since the exploit depends on specific hardware features, the risk is unevenly distributed. A container image running on an older server might be safe, while the same image on a new cloud instance with Ice Lake processors is vulnerable. This inconsistency makes inventory management and patching more complex.
Furthermore, the reliance on underlying Java updates means that product owners cannot always fix the issue immediately by updating the application itself. If the vendor bundles a vulnerable Java runtime, users must wait for a vendor-specific patch or manually replace the runtime. For organizations using Red Hat Enterprise Linux, the lack of an immediate fix leaves a window of exposure that requires manual mitigation. The potential for service disruption is also significant, as failed exploit attempts can crash the JVM, leading to downtime for essential business tools.
What you can do
- Check your hardware: Run
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'on Linux servers to see if your CPU has the required flags. All four must be present for vulnerability. - Update Java runtime: Upgrade to the latest patched versions listed by your vendor, such as Oracle 17.0.21.1 or Amazon Corretto 17.0.21.1.2. Restart all Java services after updating.
- Apply temporary mitigations: If you cannot update immediately, start the JVM with the flag
-XX:-UseBASE64Intrinsicsto disable the vulnerable code path. Alternatively, use-XX:UseAVX=2on x86-64 systems to disable AVX-512 entirely. - Rebuild containers: If you use Docker or Kubernetes, rebuild your images with the updated Java base layers and redeploy them to ensure the running processes use the fixed runtime.
- Monitor logs: Set up alerts for spikes in
IllegalArgumentExceptionerrors related to Base64 decoding or unusual JVM restarts, which may indicate exploitation attempts. - Verify vendor patches: Check if your specific application vendor (e.g., Atlassian, Jenkins) has released an update that bundles the fixed Java version, especially if you do not manage the Java runtime separately.



