A malformed Base64 value can be rejected by Java and still damage memory first. Calif’s researchers found this out-of-bounds write in OpenJDK’s accelerated Base64 decoder, now tracked as Java4Shell (CVE-2026-114938). They report using it to reach code execution in several widely deployed Java products, including Keycloak, Jira, Confluence, and Jenkins. Oracle and Red Hat have issued security guidance, and corrected runtime builds are being released.
For defenders, the immediate task is to identify the JVM that actually serves each workload, the CPU features exposed to it, and whether untrusted Base64 reaches the affected decoder. A java -version result from an administrator’s shell answers only part of that question.
TL;DR
- CVE-2026-114938 is a memory-corruption flaw in the x86-64 AVX-512 VBMI implementation of
java.util.Base64.Decoder. Calif demonstrated memory disclosure and application-specific remote code execution; Oracle rates its Java SE entry 8.1 under CVSS 3.1, while Calif rates the issue 9.2 under CVSS 4.0.- The affected path requires a vulnerable Java build, an x86-64 CPU exposing AVX-512 VBMI to the JVM, and attacker-controlled data reaching the standard Base64 decoder. ARM64 and x86-64 hosts without that CPU feature are not known to be affected by this path.
- Calif reports pre-authentication code execution in default configurations of several Java products. Those demonstrations do not establish that every Java service has a working remote exploit.
- Update each affected runtime using its vendor’s CVE-specific advisory. Include JVMs inside containers, application bundles, appliances, and secondary jobs. Restart the processes after deployment.
- If a corrected runtime cannot be deployed immediately,
-XX:-UseBASE64Intrinsicsdisables the affected accelerated decoder. Verify that the flag reaches every relevant JVM and remains in effect after restart.
How rejected input becomes a memory write
Java’s Base64 API is familiar application code, but HotSpot can replace part of its work with CPU-specific native instructions. Calif found the flaw in an x86-64 intrinsic used when the processor supports AVX-512 VBMI. Near the end of a malformed input, the native routine calculates an invalid output length and turns it into a write mask that stores too many bytes. The Java decoder subsequently throws an exception for the bad Base64 string, after the write has occurred.
Calif’s published reproduction shows a 65-character malformed input causing 62 bytes to be written beyond the calculated output length on an affected build. That establishes the corruption primitive in a controlled test. The reported memory disclosure and code-execution chains require additional control over object layout and application behavior. Calif says there is no universal payload for every product; each demonstrated chain uses a product-specific route and heap arrangement.
A malformed Base64 value in a request is an investigation lead, not proof that memory was corrupted or code ran. An application that rejects the value may still have reached the vulnerable native decoder.
Which workloads deserve priority?
Red Hat identifies four conditions to examine together: the Java runtime build, x86-64 AVX-512 VBMI support, the JVM’s AVX settings, and an application path that sends attacker-controlled input to java.util.Base64.Decoder. Authentication endpoints deserve early attention because Basic credentials, SAML data, and tokens often carry Base64 before a user has logged in. Calif also reports a client-side path involving a Java application connecting to a malicious TLS server, so inventory should include outbound consumers as well as public services.
| Evidence | What it answers | What it cannot answer alone |
|---|---|---|
| Runtime vendor and full build number for the running process | Whether the deployed JVM may contain the vulnerable code | Whether an attacker can reach its decoder |
| CPU flags visible inside the host or guest | Whether AVX-512 VBMI can select the affected path | Whether the JVM is using a corrected build or mitigation flag |
| Routes and libraries that decode external Base64 | Where untrusted bytes enter the API | Whether a product-specific exploit chain exists |
| JVM launch arguments and process start time | Whether an interim flag or patched runtime is active now | Whether the service was compromised before the change |
Inventory needs to follow the process, not the host package list. A product may ship a private JRE. A container may run an older image after the node’s Java package has been updated. A VM can expose a different CPU feature set from its physical host. For each exposed workload, record the executable path, runtime vendor and full build, image or package identity, CPU features visible to the process, launch flags, and restart time.
Version claims also need vendor context. Red Hat says its OpenJDK 8 and 11 builds lack the affected code path; Oracle’s November advisory lists a particular Java 8 performance build among affected versions. Treat a major-version label as a starting point and use the vendor advisory for the exact distribution and build. Oracle’s affected-version column describes builds requiring its November security update, not a universal threshold for every OpenJDK vendor.
Patch verification and temporary mitigation
Deploy the corrected runtime from the supplier of each running JVM, then replace every process that loaded the old build. For containers and bundled runtimes, update the image or product release and verify the new artifact on each replica. A patched package on disk does not repair an already running JVM.
Where patching is delayed, Red Hat and Calif recommend -XX:-UseBASE64Intrinsics to bypass the vulnerable optimized Base64 path. -XX:UseAVX=2 is a broader alternative that disables AVX-512 use on x86-64. Test the chosen flag with the actual application and check the running process arguments after restart. The first flag is narrower; neither flag repairs a JVM that starts without it on another node, job, or failover instance.
Do not use an exploit repository or the published corruption trigger against production as a patch test. A memory-corruption test can crash the service and disturb evidence. Build provenance, vendor advisories, deployment records, and a controlled non-production check provide a safer way to verify remediation.
What You Can Do Today
- Map the running JVMs. Include authentication services, public Java applications, outbound fetchers, containers, scheduled jobs, vendor appliances, and privately bundled JREs. Record the full build and its supplier.
- Check CPU and input reachability. Determine whether each JVM sees AVX-512 VBMI and where unauthenticated or otherwise untrusted Base64 reaches
java.util.Base64.Decoder. Prioritize internet-facing and identity workloads. - Apply the supplier’s fix. Match each runtime to its vendor’s CVE-2026-114938 guidance, deploy the corrected build, and restart or redeploy every affected process. Save the new build, image digest, and process start time as evidence.
- Use the narrow interim flag if needed. Set
-XX:-UseBASE64Intrinsicson affected JVMs that cannot yet be patched. Confirm the effective launch arguments on all replicas, including standby instances and jobs, then remove the workaround after the corrected runtime is verified. - Review suspicious activity in context. Correlate unusual Base64-bearing requests or responses with JVM crashes, restarts, unexpected child processes, outbound connections, account changes, and secret use. Ordinary access logs may omit the relevant request body; absence of a matching string is weak evidence.
- Treat credible post-exploitation evidence as an incident. Preserve logs and runtime evidence, contain the affected workload, investigate the process’s reachable secrets and systems, and rotate exposed credentials after containment. Installing the fix does not undo earlier access.
Related Posts
- N-days Are Becoming N-hours — how quickly public vulnerability details can become working exploits.
- ChocoPoC: The Exploit You Cloned Is the Attack — the risk of running untrusted proof-of-concept repositories during validation.
- From CVE to RCE in Hours: What the Patch Gap Really Means — operational decisions when a public exploit window opens quickly.
Sources
Useful read?
Find us again on Google.
Add Hive Security as a preferred source for practical security research and analysis.
Add as a preferred source on GoogleChoose Hive Security in Google's source preferences.