Critical Java4Shell Remote Code Execution Vulnerability (CVE-2026-114938)
Dear OSG Security Contacts,
A critical remote code execution vulnerability, known as Java4Shell (CVE-2026-114938), has been disclosed in OpenJDK's optimized Base64 decoder. The vulnerability can allow an attacker to corrupt application memory and potentially execute arbitrary code by supplying specially crafted Base64 input to an affected Java application. [1, 2]
The issue affects certain Java runtimes on x86-64 processors supporting AVX-512 VBMI instructions [3]. It is particularly relevant to OSG and research computing environments operating Java-based services, including authentication infrastructure, research portals, and applications that process externally supplied data.
IMPACTED VERSIONS:
Java4Shell (CVE-2026-114938) affects vulnerable OpenJDK 17 builds beginning with version 17.0.6, as well as affected Java 21, 25, and 27 releases, running on x86-64 processors with AVX-512 VBMI support. [1, 3] Affected runtimes include Oracle Java SE and OpenJDK-based distributions such as Red Hat OpenJDK, Eclipse Temurin, Amazon Corretto, and others.
Oracle has released fixes in the following versions:
- Java 17: 17.0.21.1
- Java 21: 21.0.13.1
- Java 25: 25.0.5.1
- Java 27: 27.0.1.1
Standard OpenJDK 8 and 11 are not affected by this vulnerability. ARM64 systems and x86-64 processors without AVX-512 VBMI support are also not affected by the identified vulnerable code path.
To check whether the host CPU supports AVX-512 VBMI: grep -m1 -ow 'avx512_vbmi' /proc/cpuinfo
If the command returns avx512_vbmi, the processor exposes the required instruction set. This alone does not confirm that the Java application is vulnerable. If there is no output, the required CPU feature is not exposed to the system, and the vulnerable AVX-512 VBMI code path is not expected to be used. [1] Other Java vendors may use different version numbers or release schedules. Administrators should consult their vendor's security advisories for the appropriate fixed versions.
WHAT ARE THE VULNERABILITIES:
Java4Shell is a memory-corruption vulnerability in the hardware-accelerated implementation of Java's Base64 decoder (java.util.Base64.Decoder).On affected systems, specially crafted Base64 input can cause the optimized decoder to write beyond its allocated memory buffer. Depending on the application and exploitation conditions, this may lead to memory disclosure, application crashes, or remote code execution. [1]
Base64 decoding is commonly used in authentication tokens, HTTP headers, file uploads, and other application data. Applications that process attacker-controlled Base64 input may therefore expose the vulnerable code path, potentially before authentication.
Researchers have demonstrated remote code execution against several Java-based applications, including authentication and development platforms. However, exploitation is application-dependent, and not every Java service is necessarily vulnerable to remote attack.
For OSG sites, this is particularly relevant to Java-based authentication components and research services, including potentially affected Pelican/OSDF deployments using OA4MP-based token issuance. Some sites may also use Keycloak, whose maintainers have published specific guidance for checking and mitigating Java4Shell in Keycloak deployments. [5]
MITIGATION:
Until an appropriate Java security update can be installed, administrators may temporarily disable the vulnerable hardware-accelerated Base64 implementation.
- Disable Base64 intrinsics (preferred workaround)
Start the affected JVM with the following option: -XX:-UseBASE64Intrinsics
For Java services that support the JDK_JAVA_OPTIONS environment variable, this can be configured as: JDK_JAVA_OPTIONS="-XX:-UseBASE64Intrinsics"
Restart the affected Java service for the setting to take effect.
- Restrict AVX instruction usage (alternative) On affected x86-64 systems, administrators may instead start the JVM with: -XX:UseAVX=2
This prevents the JVM from using the vulnerable AVX-512 code path. This option should not be applied to ARM64 systems.
Both approaches may affect application performance and should be tested before broad deployment. These are temporary workarounds and do not replace installing a fixed Java runtime. [1]
WHAT YOU SHOULD DO:
OSG site administrators should review Java-based services and applications for potential exposure, prioritizing internet-facing systems and services that process untrusted input.
- Identify affected Java deployments: Check installed and bundled Java runtimes, including those used by authentication services, research applications, and containers.
- Verify hardware requirements: Determine whether affected systems use x86-64 processors supporting AVX-512 VBMI and whether the vulnerable JVM optimization is enabled.
- Apply security updates: Install the appropriate vendor-fixed Java builds as soon as available. Rebuild or update affected containers and restart services to ensure the corrected runtime is in use.
- Review temporary protections: Where updates are not immediately available, verify that the selected workaround is active and does not interfere with legitimate workloads.
Sites operating Pelican/OSDF services with Java-based authentication components should pay particular attention to the relevant runtime configuration and any project-specific guidance.
REFERENCES
[1] https://access.redhat.com/security/vulnerabilities/RHSB-2026-018
[2] https://www.oracle.com/security-alerts/cspunov2026.html
[3] https://access.redhat.com/security/cve/cve-2026-114938
[4] https://calif.io/java4shell
[5] https://www.keycloak.org/2026/11/java4shell-vulnerability-cve-2026-114938
Please contact the OSG security team at [email protected] if you have any questions or concerns.
OSG Security Team