Back to Devoured - November 20, 2026
DEVOURED
CVE-2026-114938 OpenJDK RCE (Java4Shell): Everything You Need to Know

CVE-2026-114938 OpenJDK RCE (Java4Shell): Everything You Need to Know

DevOps Wiz
A critical RCE vulnerability in OpenJDK, dubbed 'Java4Shell', exploits optimized AVX-512 Base64 decoding on x86-64 processors.
What: CVE-2026-114938 (CVSS 9.2) allows unauthenticated remote code execution via heap memory corruption in OpenJDK 17.0.6+ on specific Intel and AMD CPUs. The vulnerability was disclosed by security firm Calif and affects common frameworks like Jenkins, Confluence, and Tomcat.
Why it matters: This highlights the danger of performance-optimized intrinsic functions, which often bypass high-level memory safety checks and create architecture-specific attack surfaces that are difficult to patch universally.
Takeaway: Run 'grep -E "(avx512f|avx512bw|avx512vbmi|bmi2)" /proc/cpuinfo' to check for vulnerability; if affected, upgrade OpenJDK or apply '-XX:-UseBASE64Intrinsics' until patched.
Deep dive
  • Vulnerability Type: Memory corruption via heap overflow in the JVM's Base64 intrinsic implementation.
  • Root Cause: An underflow calculation in AVX-512 assembly code when handling specific trailing padding characters (=).
  • Exploitation: Overwriting adjacent object metadata allows for arbitrary code execution.
  • AI Risk: Wiz Research demonstrated that an AI-based vulnerability harness could generate a proof-of-concept exploit within two hours.
  • Hardware Scope: Limited to x86-64 CPUs with AVX-512 VBMI instructions; ARM64 is not affected.
  • Mitigation: Official patches are available for major OpenJDK distributions; runtime flags like '-XX:UseAVX=2' act as a secondary defense.
Decoder
  • Intrinsic: A function implemented directly in assembly or machine code by the compiler or JVM to provide hardware-accelerated performance, often bypassing standard language-level safety checks.
  • RCE (Remote Code Execution): A vulnerability that allows an attacker to execute arbitrary commands on a target system from a remote location.
  • AVX-512 VBMI: A set of Intel processor instructions (Vector Bit Manipulation Instructions) used for accelerated data processing and decoding.
Original article

On November 17, 2026, details emerged exposing a critical remote code execution (RCE) vulnerability in OpenJDK, tracked as CVE-2026-114938 (dubbed "Java4Shell") with a CVSSv4.0 score of 9.2. The bug exists in the optimized assembly code handling AVX-512 Base64 decoding, allowing remote unauthenticated attackers to cause heap memory corruption. Triggering this flaw on affected systems can lead to remote code execution.

The "Java4Shell" vulnerability and exploit were discovered and disclosed by security firm Calif.

What is CVE-2026-114938?

CVE-2026-114938 is a memory-corruption vulnerability residing in the optimized Base64 decoding intrinsic engine of the Java Virtual Machine (JVM). To maximize performance, OpenJDK uses an optimized implementation on supported x86-64 processors, based on AVX-512 VBMI instructions. However, the optimized assembly code miscalculates the output array bounds when handling inputs that contain an unexpected number of trailing padding characters (=).

When an input containing a specific sequence -such as 64 A characters followed by a single = - is parsed, the decoder's length calculation underflows to a negative value. This calculation mismatch causes an out-of-bounds write past the allocated heap memory buffer. Attackers can leverage this to overwrite adjacent object metadata, which can lead to code execution. We have proved that remote exploitation is feasible against standard Java applications such Jenkins, Confluence, and Apache Tomcat.

Wiz Research data: what’s the risk to cloud environments?

Like other memory safety issues, exploitation is possible with AI, but is not trivial. Our AI based vulnerability research harness, Wiz Atlas, managed to find and build a proof-of-concept exploit for this vulnerability within 2 hours, even before the full details were disclosed. Having said that, generalizing the exploit for an arbitrary target is difficult. We should expect adversaries to target commonplace Java applications, where specific builds and memory layouts repeat across targets. Motivated adversaries may tailor exploits with AI for specific targets, including home-grown applications.

Web Application Firewalls can help mitigate some of the exploits as they emerge in the wild. Since this vulnerability is rooted in OpenJDK itself, many possible code paths using user inputs may lead into the vulnerable code path, so it’s unlikely that WAF rules will be able to cover all possible paths, and will never be able to cover home grown applications completely. The best solution is upgrading to the latest OpenJDK version.

Prioritize externally facing, packaged Java applications, and make sure they are either patched or restricted from public access. Upgrade home-grown Java applications and update to the latest OpenJDK version containing the fix.

Which products are affected?

The vulnerability affects OpenJDK versions 17.0.6 and later, as well as downstream distributions, provided they run on x86-64 hardware supporting AVX-512 VBMI instruction sets (ARM64 processors are unaffected). Affected software distributions and hardware include:

  • OpenJDK Distributions: Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat OpenJDK, and Oracle Java SE (specifically versions 8u511b33-perf, 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3, 27.0.1.0.3).
  • Vulnerable CPU Architectures: Intel Xeon (Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids) and AMD EPYC/Ryzen (Zen 4 or newer).
  • Proven Vulnerable Applications (Pre-Auth RCE): Atlassian Jira, Atlassian Confluence, Keycloak, JFrog Artifactory, Jenkins, and custom frameworks built on Spring Boot, Apache Struts, Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, Netflix Spinnaker and Apache Tomcat.

Which actions should security teams take?

Security teams should immediately prioritize the following mitigation steps:

  1. Audit and Patch: Identify all systems running OpenJDK 17.0.6 or later on AVX-512-capable x86-64 hardware. Apply the official security patches released on November 17, 2026, or update to downstream vendor-supplied builds immediately.
  2. Verify Hardware Vulnerability: Run the following command on Linux systems to check if your infrastructure is physically affected:
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'

If all four CPU flags are present in the output, the host runs the vulnerable hardware execution path.

  1. Implement JVM Runtime Workarounds: If immediate patching is not possible, apply one of the following flags to JVM startup parameters to completely neutralize the vulnerability. They may have performance impact on the application.
    1. Disable Base64 Intrinsics (Recommended): -XX:-UseBASE64Intrinsics
    2. Disable AVX-512 execution (x86-64 only): -XX:UseAVX=2
  2. Isolate Internet-Facing Services: Temporarily restrict external network access to vulnerable management portals (e.g., Jira, Jenkins, Keycloak) until mitigations or updates are deployed.

References

  • Oracle security alert
  • Calif blogpost
  • OpenJDK advisory
  • Oracle release notes
Explore all 56 articles in today's digest

Fresh dev news, AI-digested daily. Never miss a trend at devoured.fyi