Java4Shell (CVE-2026-114938) is a heap overflow in the hardware-accelerated Base64 decoder of OpenJDK's HotSpot JVM. Oracle and the OpenJDK project shipped fixes on 17 November 2026. Calif, the research firm that found the bug, demonstrated pre-authentication remote code execution against six widely deployed Java products in their default configurations.
The vulnerable code only runs on x86-64 processors with AVX-512 VBMI, which covers most current Intel and AMD server hardware. As of 19 November 2026, exploitation attempts had been seen in the wild, and one security firm had reported, without independent confirmation, a compromised Confluence server.
Our recommendation is to patch or apply the interim JVM flag now and use detection to scope what may already have happened. The rest of this post explains why, and gives the hunting queries and log sources to do it.
Fast facts
- The bug: a heap overflow in OpenJDK's AVX-512 Base64 decoder, fixed on 17 November 2026 in 17.0.21.1, 21.0.13.1, 25.0.5.1 and 27.0.1.1.
- Who is exposed: Java 17.0.6 and later, 21, 25 and 27 on x86-64 CPUs with AVX-512 VBMI (Intel Xeon Ice Lake or newer, AMD Zen 4 or newer). ARM64 is not affected.
- Impact: pre-authentication remote code execution demonstrated in Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate. Exploitation attempts in the wild, one unconfirmed report of a compromised Confluence server, and no public remote code execution exploit, as of 19 November 2026.
- What to do: install your vendor's fixed build, or start the JVM with
-XX:-UseBASE64Intrinsicsuntil you can.
How the flaw works
HotSpot replaces hot standard-library methods with hand-written machine code called intrinsics. On x86-64 CPUs with AVX-512 VBMI, java.util.Base64.Decoder runs through one of them, generate_base64_decodeBlock, which works through the input in 256-character and then 64-character blocks.
The bug sits in the code that handles the final few characters. Calif's write-up shows that when 1 to 3 characters are left over and the last one is =, the routine computes an output length of zero and then decrements it for the padding. The length underflows to -1 or -2, the store mask becomes all ones, and the instruction writes a full 64 bytes.
On Java 21 and later, for a 65-character input, Java allocates a 50-byte result array. The intrinsic writes 64 bytes starting at offset 48, so 62 bytes land past the end of the array. Java then rejects the input with an exception, but by that point neighbouring heap objects may already be corrupted.
The minimal trigger is 64 A characters followed by =. Java 17 builds need 128 characters before the padding. The A is arbitrary: proofs of concept use it only because it decodes to 0x00 bytes, which makes the overwrite easy to check. Any Base64 characters work, and attackers cannot choose the bytes written out of bounds, only where they land, so a filter that looks for runs of the letter A is easy to bypass.
Who is exposed
A host is exposed when three conditions hold: an affected Java build, a CPU that reports AVX-512 VBMI, and attacker-controlled Base64 reaching java.util.Base64.Decoder. Missing any one of them removes the vulnerable path.
Java versions
| Java line | Affected | Fixed upstream |
|---|---|---|
| Java 27 | 27.0.1.0.3 and earlier | 27.0.1.1 |
| Java 25 | 25.0.5.0.3 and earlier | 25.0.5.1 |
| Java 21 | 21.0.13.0.3 and earlier | 21.0.13.1 |
| Java 17 | 17.0.6 to 17.0.21.0.3 | 17.0.21.1 |
| Java 8 | Oracle 8u511b33-perf (Performance Pack) only | 8u513 |
Sources: the OpenJDK vulnerability advisory and Oracle's November 2026 security alert. Standard Java 8 and Java 11 do not contain the vulnerable code.
Every OpenJDK-based distribution inherits the bug, including Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine, Red Hat build of OpenJDK, Oracle Java SE, and Oracle GraalVM for JDK. Fixed downstream builds are arriving at different speeds. Amazon and Azul shipped on 17 November; Red Hat's bulletin RHSB-2026-018 listed RHEL 8, 9 and 10 fixes as pending on 18 November. Check your distribution's own advisory for the exact build.
Processors
The vulnerable intrinsic only runs on x86-64 CPUs with AVX-512 VBMI. CPUs without it fall back to a decode path that does not contain the bug.
| Vendor | Affected families |
|---|---|
| Intel Xeon | Ice Lake, Sapphire Rapids, Emerald Rapids, Granite Rapids |
| AMD EPYC and Ryzen | Zen 4 and newer |
| Intel client | Ice Lake, Tiger Lake, Rocket Lake (2019 to 2021); later client parts have AVX-512 disabled |
| ARM64 (Graviton, Ampere) | Not affected |
Check from inside the guest, because a hypervisor can hide CPU features from a virtual machine. All four flags must be present:
grep -m1 '^flags' /proc/cpuinfo \
| tr ' ' '\n' \
| grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
Applications
Calif demonstrated remote code execution in default configurations of these products. The list is a sample: any Java service that decodes untrusted Base64 is a candidate.
| Access needed | Products |
|---|---|
| None (pre-authentication) | Keycloak, Atlassian Jira, Atlassian Confluence, JFrog Artifactory, Jenkins, PingFederate |
| Authenticated | Apache Kafka broker, Apache Solr, Elasticsearch, Gerrit, Spinnaker |
Calif also showed code execution in sample Apache Struts and Spring Boot applications, and described a client-side variant where a Java program is compromised by connecting to a malicious TLS server. Common Base64 sinks include HTTP Basic credentials, SAML artifacts, CSRF tokens, file uploads, and MIME-encoded email headers.
Exploitation status on 18 November 2026
No successful exploitation has been independently confirmed, and CVE-2026-114938 is not in the CISA Known Exploited Vulnerabilities catalog. Cisco Talos had seen no attacks when it published and expected probing to follow, and it has started: by 06:48 UTC on 19 November the GreyNoise Java4Shell tracker had recorded 125 trigger-shaped requests from five IP addresses, with no successful intrusions against its sensors. CERT-EU recommends updating vulnerable OpenJDK versions, prioritising internet-facing applications, and restarting all JVMs after the update.
On 19 November, Hexastrike reported exploitation of a Confluence server on Windows that it attributes to Java4Shell. Confluence's Tomcat service, running as NETWORK SERVICE, started cmd.exe, a tool that obtained SYSTEM privileges, and PowerShell commands that disabled Microsoft Defender. Hexastrike has not published evidence linking the entry point to Java4Shell, and no other source had confirmed it at the time of writing.
On 18 November, Cloudforce One reported the first instance of a single IP address sending both ARTEX and Java4Shell traffic. ARTEX is an open-source, LLM-driven penetration testing framework that, according to an (FLASH-20261113-001), threat actors have used since at least August 2026. It is one of a fast-growing set of such tools, alongside CyberStrikeAI and Cairn: Cloudflare saw daily requests from AI pentesting tools grow more than 30-fold between 1 October and 12 November. A shared IP address does not prove that ARTEX sent the Java4Shell request, but it suggests agentic tooling is already being pointed at the bug.
Working exploits exist, but none is public:
- Calif published only a safe local trigger and is withholding its product-specific chains until organisations have had time to upgrade.
- VulnCheck released a full remote code execution exploit to its commercial customers on 17 November. On 18 November an Immersive researcher, posting in a personal capacity, reported a working application-specific proof of concept and named Tomcat's Basic authentication and the java-jwt library as pre-authentication paths.
- Public GitHub repositories carry triggers, version scanners and community detection rules. Treat any repository claiming a working remote code execution chain with suspicion and never run one outside an isolated lab.
Calif's previous disclosure, PHP2Shell, was on CISA's KEV list within five days of publication; our PHP2Shell post covers that timeline. Java4Shell is harder to exploit, but the gap between disclosure and attack can be short.
Why the severity scores disagree
OpenJDK and Oracle rate the bug 8.1 under CVSS 3.1, citing high attack complexity. Calif rates it 9.2 under CVSS 4.0, and Red Hat rates its impact Critical. The gap reflects how hard the bug is to turn into code execution, which Calif and VulnCheck have both demonstrated.
Crashing an affected JVM is easy once an attacker finds a reachable decoder. VulnCheck found that a single trigger rarely crashes a default server, because thread-local allocation buffers absorb most overflows, but a short burst of requests reliably brought the service down. Code execution is harder. It needs heap grooming plus a target-specific memory leak to get past address space layout randomisation, and Calif describes a separate application profile for every product. Its current technique is also sensitive to network latency.
That combination points to narrow, targeted exploitation of high-value services and makes mass scanning less likely. It does not mean the risk is low for an internet-facing Keycloak or Jira instance on recent server hardware. Calif reported building its first working chain in about two hours.
What to do now
Run patching and the interim mitigation in parallel. For many estates the JVM flag can go out today, while a fixed build depends on a
vendor's release cycle.
Prioritise by real exposure
Start with internet-facing services that run a demonstrated pre-authentication product on a host whose guest CPU reports AVX-512 VBMI. Patch or mitigate those within hours. Internal services and the authenticated-access products follow within days. ARM64 hosts and CPUs without VBMI can go into the normal patch cycle.
Patch
Install your distribution's fixed build and restart every JVM, because a running process keeps the old code until it restarts. Rebuild container images rather than patching running containers. Products that bundle their own Java runtime, such as Atlassian Data Center and many appliances, need the vendor's update or the vendor's supported way of changing JVM options. Swapping the bundled runtime yourself can break support. CISA warns that these bundled runtimes may not appear as separate entries in software inventories, so check container images and appliances as well as installed packages.
Apply the interim flag where you cannot patch yet
Two JVM options remove the vulnerable path:
# Preferred: turns off only the accelerated Base64 code
-XX:-UseBASE64Intrinsics
# Alternative on x86-64 only: turns off all AVX-512 code paths
-XX:UseAVX=2
Prefer -XX:-UseBASE64Intrinsics. It leaves other AVX-512 optimisations in place, so the performance cost is limited to Base64-heavy workloads. Do not push -XX:UseAVX=2 through a startup profile shared with ARM64 hosts: an ARM64 JVM does not recognise the option and fails to start.
Red Hat's bulletin also prefers -XX:-UseBASE64Intrinsics, while Cisco Talos leads with -XX:UseAVX=2. Both flags remove the vulnerable path, so follow your vendor's guidance where your support terms require it.
Where you can neither patch nor set a flag, CISA suggests temporary controls at the application boundary: validate Base64 input, enforce input-size limits, and limit unauthenticated access. The most direct check is to reject Base64 values that end in = but whose length is not a multiple of four. Size limits alone do not help, because a trigger can be as short as 65 characters.
Verify the flag on the running process with jcmd <pid> VM.flags. Options set through JAVA_TOOL_OPTIONS do not appear on the command line, and some service wrappers and container entrypoints drop environment variables without warning.
Check whether you were already hit
The vulnerable code has shipped since OpenJDK 17.0.6 in January 2023, and details of the bug circulated before the fix. Patching closes the hole but says nothing about whether a host was already used. On exposed hosts, review the past few weeks for JVM crash files, unexplained restarts, Java processes starting shells, Java runtimes you did not install, and unexpected administrative changes in the applications listed above.
Where that review finds unexplained crashes or anomalies on a pre-patch host, rotate the secrets the JVM held in memory: signing keys, client secrets, API tokens, and session keys. Keycloak and PingFederate deserve particular attention, because their keys sign tokens other systems trust.
Make the next crash easier to find
Set -XX:ErrorFile=/var/log/java/hs_err_pid%p.log (or an equivalent path on Windows) so fatal error logs land in one monitored directory. By default HotSpot writes them to the process working directory, which differs for every service and is rarely monitored.
Detection with Guardsix SIEM
Each of the hunting queries below returns candidates for an analyst to triage.
These queries need host telemetry from the Java servers and logs from the Java applications themselves. Crash files land in each service's working directory unless -XX:ErrorFile sets a fixed path, and in containers they are lost on restart unless that path sits on a volume. Many products log Base64 decoder exceptions only at debug level, and debug logging on authentication components can record usernames and request details. To see what a product logs, replay the trigger against a staging instance started with -XX:-UseBASE64Intrinsics.
The queries do not replace patching, and an absence of matches does not rule out exploitation or memory disclosure. Memory disclosure happens in the same response as the trigger, before any code runs, so a query can only record that loss afterwards, and leaked keys and tokens stay valid until they are rotated. Code that stays inside the JVM and data-only changes start no process, so pair the queries with application audit logs.
Expect little visibility of the attempt itself. Most estates log web requests without headers, cookies or bodies, do not inspect decrypted traffic with an IDS, and keep Java application logs on the host. The fields that carry the trigger, such as Basic authentication and JWT headers, cookies and SAML POST bodies, are rarely logged because they contain credentials, and the client-side TLS path bypasses inbound sensors entirely.
Log sources required
- Linux
- Sysmon Process Creation (Event ID 1) with process and parent-process executable paths and command lines
- Sysmon File Create (Event ID 11) covering the JVM working directories or the
-XX:ErrorFilepath
- Windows
- Process Creation with Command Line Auditing
- Sysmon File Create (Event ID 11) on Windows Java servers
- Network IDS
- Snort alerts from sensors that inspect decrypted traffic in front of the Java services, with the Talos Java4Shell rules enabled.
- Java applications
- Application logs forwarded with exception messages, from the components that decode Base64 (authentication filters, SAML handlers, upload handlers).
Hunting query: Snort alerts for Java4Shell attempts
Cisco Talos released Snort coverage on 17 November: Snort 2 SIDs 1:67502 to 1:67513, and Snort 3 SIDs 1:301754 and 1:67502 to 1:67513. The rules are in the subscriber ruleset and in the free Community Ruleset. Check that all of them are enabled on sensors that inspect Java traffic.
The sensor must see decrypted traffic, so place it behind TLS termination in front of the Java services. A match shows that an attempt reached the service, not that it succeeded; correlate it with the decoder-exception and crash-log queries for the same host.
norm_id IN ["Snort", "SuricataIDS"]
message="*OpenJDK Base64 decoder remote code execution attempt"
Hunting query: Base64 decoder exceptions in JVM application logs
Java rejects every trigger with an IllegalArgumentException after the overflow has already happened, so a burst of these exceptions on one host is the most direct signal of exploitation attempts. Every malformed padded tail produces one of two messages ("Input byte array has wrong 4-byte ending unit" or "Last unit does not have enough valid bits"), and neither contains the input. Broken clients produce the same messages occasionally, so start from the per-host burst count and use individual exceptions for context.
("Input byte array has wrong 4-byte ending unit"
OR "Last unit does not have enough valid bits")
| timechart count() as cnt by device_ip every 1 hour
| filter cnt > 10
Raise the threshold for services that routinely receive malformed tokens from a known integration. On a match, read the stack trace to find the calling component, such as an authentication filter or SAML handler, then check the host for crash files. Many products log these exceptions only at debug level; the log sources above explain how to check what yours records.
Hunting query: JVM fatal error log created
Failed exploitation usually crashes the JVM, often inside a garbage collection routine with a compiled Base64 decoder frame on the stack. Unplanned JVM crashes are rare on stable production services.
label=File label=Create label=Overwrite file IN ["hs_err_pid*.log", "replay_pid*.log"]
| timechart count() as cnt by host every 1 hour
| filter cnt > 1
Most Sysmon configurations log File Create (Event ID 11) only for selected paths, so add a FileCreate include rule for TargetFilename matching hs_err_pid and replay_pid (or the -XX:ErrorFile directory) on Windows and Linux before relying on this query.
For each hit, read the crash file: the signal, the Problematic frame line, and any Base64$Decoder, StubRoutines or G1 frames. Then pull proxy logs for the minutes before the crash.
Hunting query: shell or utility started by a Java process
This catches code execution that hands off to the operating system. It will not catch code that stays inside the JVM or data-only changes, so pair it with the application audit logs listed under log sources above.
label="Process" label=Create (parent_process="*/java" OR parent_image="*/java")
("process" IN ["*/sh", "*/bash", "*/dash", "*/busybox", "*/curl", "*/wget", "*/nc", "*/ncat", "*/socat", "*/python3", "*/perl", "*/base64", "*/whoami", "*/id", "*/uname"]
OR
(image IN ["*/sh", "*/bash", "*/dash", "*/busybox", "*/curl", "*/wget", "*/nc", "*/ncat", "*/socat", "*/python3", "*/perl", "*/base64", "*/whoami", "*/id", "*/uname"]
)
Exclude Jenkins controllers that run builds locally and any service whose design includes shell hooks, by host or service account rather than by child process.
The Windows equivalent covers java.exe and javaw.exe starting shells, script hosts, discovery commands or download tools. It also covers the Tomcat service wrapper (tomcat9.exe, prunsrv.exe) that Atlassian's Windows installers use to host the JVM inside their own process, which is how Confluence and Jira appear in process telemetry on Windows.
label="Process" label=Create parent_process IN ["*\java.exe", "*\javaw.exe", "*\tomcat*.exe", "*\prunsrv.exe"]
"process" IN ["*\cmd.exe", "*\powershell.exe", "*\pwsh.exe", "*\cscript.exe", "*\wscript.exe", "*\mshta.exe", "*\rundll32.exe", "*\certutil.exe", "*\bitsadmin.exe", "*\curl.exe", "*\whoami.exe", "*\hostname.exe", "*\systeminfo.exe", "*\net.exe", "*\net1.exe"]
Jenkins agents and build tools on Windows legitimately start cmd.exe and powershell.exe, so exclude them by host or service account after checking the command line.
Conclusion
Java4Shell is easy to crash and hard to turn into code execution, yet working chains already exist privately, and one firm has already reported a compromised Confluence server. Calif plans to publish its product-specific exploits once organisations have had time to upgrade, and that release will make targeted attacks on Keycloak, Atlassian and Jenkins servers much cheaper.
Calif found Java4Shell with an AI coding agent and had a working exploit chain within hours, and it used the same approach to find PHP2Shell a month earlier. A day after disclosure, an independent researcher reported an AI-built proof of concept of their own. On the attack side, an IP address running the ARTEX agentic framework was sending Java4Shell traffic within ten hours of Calif's write-up.
Finding and weaponising memory-corruption bugs in language runtimes is getting cheaper, so the gap between disclosure and a working exploit will keep shrinking. Patch cycles measured in weeks leave that gap open. Detections that watch what follows exploitation, such as a Java service starting a shell, are the ones that will still work when the next runtime bug arrives.
Ready to learn more about using Guardsix SIEM against the latest threats? Sign up for the Guardsix Academy and become certified with Guardsix.