Introduction
A Java service can reject malformed input and still have its memory corrupted. That is the central problem behind Java4Shell, CVE-2026-114938, a vulnerability in an accelerated Base64 decoder inside the Java runtime.
For security teams, the immediate task is to identify where an unpatched runtime, the required CPU features and an exposed decoding path meet. Those systems need prompt remediation. An affected version number alone does not establish remote exploitability, while a failed decoding request does not establish that the application remained unharmed.
This article explains the vulnerability, the conditions that determine exposure, and the actions organizations should take. Version and exploitation information is current as of November 18, 2026. We will update this article as additional vendor guidance and verified findings become available.
Group-IB’s assessment
Prioritize reachable services by what their Java process can access. A reachable decoder in an identity provider or build system warrants emergency attention if the service handles signing keys, deployment credentials or other sensitive material. An internal service that decodes untrusted inputs after login still belongs in the patch queue, especially when many users or integrations can send it data. The same runtime flaw can have very different consequences across those deployments.
Plan for disruption as well as intrusion. Calif demonstrated code execution on multiple applications, but getting from a constrained memory overwrite to reliable RCE required application-specific work. A reachable workload can suffer a JVM crash without that work. For a critical service, repeated restarts can justify urgent mitigation even when there is no evidence of code execution.
Treat unknown exposure as a triage task. Neither a product name nor a Java version tells you which path is running. If you cannot verify the CPU features or trace the decoder in a critical service, prioritize checking or patching it. Workloads that cannot use the affected instructions can move behind confirmed reachable systems in the Java4Shell patch queue.
What happened
On November 17, 2026, Calif disclosed Java4Shell (CVE-2026-114938), a vulnerability in the Base64 decoder in HotSpot, the JVM used by many OpenJDK distributions. Calif credited Quang Luong with the research and Jenish Rakholiya with improving the exploits. Oracle released security updates the same day.
The flaw lets the decoder write past the end of a buffer and corrupt memory in the Java heap. That alone can crash the JVM and take a service offline. Reading sensitive data from memory or executing code with the Java process’s permissions takes additional work tailored to the application and its runtime environment.
Calif demonstrated remote code execution against several enterprise applications, reaching the vulnerable decoder before login in some cases and after login in others. For any given deployment, exposure depends on the Java build in use, the CPU features available to the JVM, and whether the application passes untrusted input to the affected decoder.
As of November 18, Group-IB’s Threat Intelligence team has found no evidence of Java4Shell exploitation in the wild through its monitoring. Our review of public reporting also found no confirmed cases of malicious exploitation. We continue to monitor for activity.
Why the CVSS figures differ
Two severity scores appear prominently in the disclosures:
| Assessor | Scoring system | Published score |
| Calif | CVSS 4.0 | 9.2 Critical |
| Oracle | CVSS 3.1 | 8.1 High |
Oracle rates attack complexity as high, while assigning high impacts to confidentiality, integrity and availability. Calif’s findings offer a technical explanation for that combination. The initial overwrite is constrained, and reliable code execution depends on the behavior of the application and its JVM. The CPU requirement narrows the set of deployments that can run the vulnerable decoder. Even where it can, the application still has to pass untrusted data to that decoder.
How the vulnerability works
HotSpot accelerates some Base64 decoding by running a native routine on x86-64 systems that expose the required AVX-512 VBMI capabilities. Java4Shell occurs when the native decoder encounters malformed padding in the final Base64 fragment. The routine miscalculates how much data to write and can overwrite adjacent memory in the Java heap.
The order matters. By the time the Java layer rejects the input, the native write may already have occurred. An application can return an error to the caller while its JVM continues running in a corrupted state. For defenders, that means the request that caused the damage and the crash that exposed it can appear at different times.

The initial overwrite is constrained and is not an arbitrary block of memory chosen by the attacker. Reliable exploitation must account for surrounding objects, allocation behavior and application functionality. This is why a small trigger can coexist with a substantially more demanding RCE chain.
Where Java4Shell is reachable
Check three things for each workload:
- The runtime. Identify the vendor and full build of the JVM the service actually runs. Include runtimes bundled with applications and containers.
- The CPU features and JVM settings. The disclosed path requires x86-64 with AVX-512 VBMI and related instruction support, exposed to the running workload. In practice, this mostly means modern servers: Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids, and AMD EPYC and Ryzen processors based on Zen 4 or newer. Intel client chips from 2019–2021 (Ice Lake, Tiger Lake and Rocket Lake) also qualify. Most current Intel desktops and laptops do not, because Intel has disabled AVX-512 on client processors since the 12th-generation Alder Lake. Native ARM64 JVMs, including those on AWS Graviton and Ampere, do not execute this path. For virtualized workloads, check features visible to the guest.
- The input path. Determine whether data from outside the trust boundary reaches the affected decoder and whether decoding happens before authentication. In the OpenJDK 17.0.6 build analyzed, the basic and URL decoders,
Base64.getDecoder()andBase64.getUrlDecoder(), use the vulnerable path, while the MIME decoder,Base64.getMimeDecoder(), does not. Start with code that decodes authentication headers, tokens, SAML messages, file uploads and network messages. An application that uses its own decoder or rejects invalid input before it reaches the JDK may handle the same data differently.
Calif reported RCE in the following applications under its test conditions. Use the list to prioritize review, then check the runtime and configuration of your own deployment.
| Access required in tests | Applications |
| Before authentication | Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, PingFederate |
| After authentication | Apache Kafka Broker, Apache Solr, Elasticsearch, Gerrit, Spinnaker |
Affected Java versions and fixes
Oracle’s fixed builds are listed below. OpenJDK distributors may use different build numbers or ship fixes as backports. Confirm the package against your supplier’s advisory, especially for bundled runtimes and release lines outside this table.
| Runtime | Affected releases or builds | Fixed build or action |
| Java 17 | 17.0.6 through unpatched releases before 17.0.21.1 | Oracle 17.0.21.1+4 or vendor-confirmed equivalent |
| Java 21 | Unpatched releases before 21.0.13.1 | Oracle 21.0.13.1+4 or vendor-confirmed equivalent |
| Java 25 | Unpatched releases before 25.0.5.1 | Oracle 25.0.5.1+4 or vendor-confirmed equivalent |
| Java 27 | Unpatched releases before 27.0.1.1 | Oracle 27.0.1.1+4 or vendor-confirmed equivalent |
| Oracle Java 8 Enterprise Performance Pack | Oracle lists 8u511b33-perf | Check Oracle’s Performance Pack patch guidance |
| Oracle GraalVM for JDK | Oracle lists 17.0.21.0.3 and 21.0.13.0.3 | Check Oracle’s GraalVM patch guidance |
| Oracle GraalVM Enterprise Edition | Oracle lists 21.3.20.0.3 | Check Oracle’s Enterprise Edition patch guidance |
Standard OpenJDK 8 and 11 lack the affected decoder path. Oracle Java 8 Enterprise Performance Pack is the exception listed in Oracle’s advisory. The full affected ranges and first fixed builds for the Performance Pack and GraalVM variants are still to be confirmed here.
What to check and how to mitigate
Verify the build in the running process. A shell’s java -version can report a different installation. Where available, use jcmd <PID> VM.version and jcmd <PID> VM.flags -all to inspect the running service. Check CPU capabilities in the workload’s execution environment. On Linux, Calif lists avx512f, avx512bw, avx512vbmi and bmi2 as the flags to look for. Confirm with the application owner whether untrusted input reaches the affected decoder.
Install the vendor’s fix. Use the application vendor’s supported update path when it ships its own JVM. Rebuild and redeploy containers with an updated base image, restart affected processes and verify the new runtime across replicas.
Disable the affected optimization if patching has to wait. The narrower workaround is -XX:-UseBASE64Intrinsics. Some builds accept this flag only when diagnostic options are unlocked: -XX:+UnlockDiagnosticVMOptions -XX:-UseBASE64Intrinsics. Without the unlock option, such a JVM may fail to start. On x86-64, -XX:UseAVX=2 is an alternative that disables AVX-512 more broadly and may affect performance. Scope that flag to x86-64: native ARM64 JVMs may fail to start if they receive it. Test the chosen setting with your build, restart the application and verify the effective flags. Keep the vendor update scheduled.
Do not rely on a reverse proxy as a mitigation. Some exploitation techniques send a request in parts, and proxies that buffer the full request body, such as nginx by default, disrupt that timing. The protection is incomplete: Calif’s Elasticsearch chain works from a single complete request, and traffic after a WebSocket upgrade is not subject to request-body buffering.
What to look for in logs and telemetry
Start with JVMs that meet the exposure conditions. Build a timeline from the first unusual requests through any crash or restart, then check what the service did before and after the event. For clustered services, match request and runtime logs to the same instance. A request anomaly followed by a crash warrants investigation. Evidence of unauthorized process activity, changes to application state or possible data disclosure warrants escalation to incident response.
On services that meet the exposure conditions, correlate bursts of Base64 parsing errors with JVM crashes, fatal error logs or unexpected restarts. Memory corruption can surface later in the JVM, including during garbage collection. A crash or decoding error in isolation is weak evidence of exploitation. Use request timestamps and the affected process’s logs to establish whether the events are related.
If you suspect compromise, review endpoint and network telemetry for unexpected processes, file changes and outbound connections associated with the Java service. Check application logs for unexplained changes to accounts or permissions. Where you have the relevant evidence, investigate signs of memory disclosure as well. Preserve available evidence, contain the workload and assess which credentials and data the process could access. Use existing authorized telemetry and keep raw credentials and tokens out of new logging.
How Group-IB can help
- The Threat Intelligence team is monitoring for signs of Java4Shell exploitation. We publish new findings, vendor updates and changes to mitigation guidance in the Java4Shell client notification on the Group-IB Threat Intelligence Platform.
- Attack Surface Management helps teams identify internet-facing services to prioritize for runtime and configuration checks.
- Managed XDR helps teams investigate suspicious Java service activity using available endpoint and network telemetry.
- Incident Response and Digital Forensics can help preserve evidence, determine the scope of a suspected compromise, contain affected systems and support recovery.





