Java4Shell: Critical Vulnerability in Oracle Java OpenJDK (CVE-2026-114938)
Executive Summary
On November 17th, Oracle published their periodic Security Patch Update, which included a high severity vulnerability in Java OpenJDK. The root cause was a bug in the base64 decoding routine that can cause memory corruption, in some cases leading to remote code execution. However, at the time of writing an affected Java version is only exploitable under specific conditions, and each target may require a custom-built attack.
Because core Java functions sit so low in an application stack, exploitability depends heavily on the application in question. Researchers who found the vulnerability, reported achieving unauthenticated remote code execution in testing against popular products, including Atlassian Jira, Atlassian Confluence, and Jenkins.
No exploitation in the wild has been reported at the time of writing. With the trigger input and exploitation approach now public, Beazley Security expects threat actors to attempt working exploits in the coming days. Due to the widespread use of Java and the impact of this vulnerability, Beazley Security strongly recommends organizations review patch update bulletins from downstream products, and update any edge connected, affected applications as soon as possible.
Affected Systems or Products
Mitigations / Workarounds
Oracle released updated Java SE builds on November 17th, 2026, and no vendor-validated workaround has been published. A running Java Virtual Machine (JVM) keeps using the vulnerable code until it restarts on a new build. Java Development Kits (JDKs) bundled inside applications and container base images need their own updates, because upgrading the operating system package does not change them.
At the time of writing, some hardware and configurations are reported as not affected. The table below captures unaffected categories:
If patching cannot be immediately applied on affected builds, the following may help to temporarily reduce risk.
- Calif recommends starting the JVM with one of these flags as in the table above, then restarting:
- Both flags are temporary and may reduce performance. Test them first, and remove them once a fixed build is installed.
- -XX:-UseBASE64Intrinsics
- turns off the vulnerable Base64 fast path.
- -XX:UseAVX=2
- turns off AVX-512. Use it only on x86-64 hosts, because the JVM fails to start with it on ARMturns off AVX-512. Use it only on x86-64 hosts, because the JVM fails to start with it on ARM.
- Prioritize internet-facing services that can decode untrusted input before login, such as authentication headers, tokens, SAML assertions and file uploads. Reverse proxies that buffer full request bodies (the nginx default) disrupt some attack paths but should be considered a temporary stop gap.
Patches
Oracle released new Java SE builds and other products on November 17th, 2026, in its November 2026 Critical Security Patch Update: Oracle CSPU November 2026: Affected Products and Patch Information
Additional details specific to affected versions of Oracle GraalVM for JDK, Java SE, and JavaFX can be found within their patch availability document (requires authentication).
Technical Details
CVE-2026-114938 is an integer underflow in the x86-64 Base64 decoding intrinsic of OpenJDK HotSpot. On processors that support AVX-512 VBMI, HotSpot replaces the Java implementation of java.util.Base64decoding with hand-written assembly once the C2 just-in-time (JIT) compiler compiles the decode path.
The bug is in the code that handles the last few characters of the input. According to Calif’s write-up, that code calculates the output length and then subtracts one for each trailing = padding character. With certain short endings, such as =, X=, or XY=, the length is already zero before that subtraction, so it wraps around to a negative value. The decoder then writes a full 64-byte block instead of the few bytes intended. For a 65-character input, OpenJDK allocates a 50-byte output array, and the write runs 62 bytes past its end. Java eventually rejects the input as invalid, but by then neighboring objects in memory may already be corrupted.
Calif published the trigger input: 64 A characters followed by a single =. On older OpenJDK 17 builds, the trigger is 128 A characters followed by =, because the length threshold for the vulnerable path is higher.
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=
The attacker fully controls only the first byte and partly controls the second, and the remaining bytes are fixed values. Calif turned this into a usable primitive by overwriting the length field of an adjacent array, which then accepts attacker-chosen data into its neighbors. Corrupting a second array that is copied back into an application response gives a heap disclosure primitive that Calif calls "JavaBleed", which can expose secrets, tokens, private keys, and personal data held in memory. Calif then escalated to arbitrary writes and code execution, using remote heap grooming against the G1 garbage collector with repeated attempts until the layout aligned.
Calif stresses that no universal exploit exists, and at the time of writing Beazley Security assesses the same as each target would require a tailored exploit. Quang Luong of Calif reported discovering the flaw with the help of artificial intelligence tooling.
How Beazley Security is responding
Beazley Security is monitoring client perimeter devices through our Exposure Management Platform to identify impacted devices and support organizations in remediation of any issues found.
We are also conducting threat hunts across our MDR environment to detect potential exploitation attempts against our clients.
If you believe your organization may have been impacted by this attack campaign and need support, please contact our Incident Response team.
Sources
Aware of an incident impacting your industry? Let us know: