A vulnerable Java runtime hidden inside an application, Docker image or identity service can leave an organization exposed even when the Linux host itself is patched. On 17 November 2026, Oracle and OpenJDK issued fixes for CVE-2026-114938, known as Java4Shell. The flaw is memory corruption in an accelerated Base64 decoder inside the HotSpot JVM. Under specific conditions it can cause a crash, disclose memory or enable unauthenticated remote code execution.
This is a confirmed vulnerability, but not every Java server is exploitable. The processor must support particular AVX-512 instructions, the vulnerable intrinsic must be active and attacker-controlled Base64 data must reach it. Internet-facing applications such as Keycloak do process certain inputs before authentication.
Primary references include Oracle's 17 November security update, CERT-EU advisory 2026-021 of 18 November and the original research by Calif. Oracle assigns CVSS 3.1 8.1/10 to this CVE; other assessments using CVSS 4.0 reach 9.2/10. These are different scoring systems and should not be conflated.
Why can Base64 decoding become remote code execution?
Base64 is an encoding format, not encryption. Applications decode it in authentication headers, SAML messages, cookies, tokens and various protocol fields. Some decoding occurs before users are authenticated.
HotSpot's JIT compiler optimizes frequently executed code, sometimes using the CPU's vector instructions. In the affected x86-64 Base64 routine, malformed padding could cause an incorrect memory-write mask. The accelerated decoder then wrote beyond the intended output buffer.
Calif's researchers showed how they could extend the memory corruption into Java heap disclosure and application-specific remote code execution. Their examples do not form one universal payload against every Java service: each chain needs its own input route, heap conditions and subsequent application behavior.
The research also discusses a client-side path where Java processes data from a malicious TLS server. Consequently, a WAF protecting inbound HTTP requests cannot by itself eliminate all exposure.
Which Java builds and CPU architectures are affected?
CERT-EU and Red Hat identify three essential conditions:
- An unpatched affected runtime, principally OpenJDK 17 from 17.0.6 onward, and affected builds from Java 21, 25 and 27.
- An x86-64 CPU exposing avx512f, avx512bw, avx512vbmi and bmi2. Examples can include Intel Xeon Ice Lake or later and AMD Zen 4 or later. For a virtual machine, check the capabilities actually exposed to the guest.
- Base64 intrinsics enabled, with malformed attacker-influenced data reaching the accelerated decoder.
ARM64 machines and x86-64 processors without AVX-512 VBMI are not known to be affected through this vulnerable path. Ordinary Java 8 and 11 builds lack the code path, with an important exception: Oracle identified a special Java 8 performance build, 8u511b33-perf, as affected.
Patch references
| Java line | Example affected build | Oracle fixed build |
|---|---|---|
| Java 17 | 17.0.21 and earlier affected builds back to 17.0.6 | 17.0.21.1 |
| Java 21 | 21.0.13 and earlier affected builds | 21.0.13.1 |
| Java 25 | 25.0.5 and earlier affected builds | 25.0.5.1 |
| Java 27 | 27.0.1 and earlier affected builds | 27.0.1.1 |
These are Oracle release references, not a universal versioning scheme for every OpenJDK provider. Temurin, Corretto, Zulu, Liberica, Microsoft Build of OpenJDK, Red Hat and other vendors release patched builds or backports on their own schedules. Always verify the complete vendor-specific package version and advisory.
Canonical published USN-9155-1 for OpenJDK 17, USN-9156-1 for OpenJDK 21 and USN-9157-1 for OpenJDK 25 on 18 November 2026. On Ubuntu 26.04 LTS, one example of a fixed OpenJDK 21 package is 21.0.13.1+2-1~26.04.1. Package-level evidence is more reliable than assuming an upstream-style `java -version` string proves patch status.
Practical checklist: find the JVM actually running
1. Inspect running Java processes
On Linux, list Java processes and resolve the executable used by each service:
pgrep -af '[j]ava'
java -version
# Replace 1234 with the PID of the relevant Java service
readlink -f /proc/1234/exe
Running `java -version` in an interactive shell reports only that shell's selected Java. A systemd unit, bundled application runtime or container may use another binary. Audit each service and instance, not only the host installation.
Where compatible JDK tools are available:
jcmd -l
jcmd 1234 VM.version
jcmd 1234 VM.flags -all | grep -F UseBASE64Intrinsics
A successfully applied interim mitigation should show `UseBASE64Intrinsics = false` on the running JVM. Missing `jcmd` or an attachment error is not evidence that the runtime has been fixed; permissions and container namespaces may prevent inspection.
2. Check CPU flags
Inspect the CPU capabilities visible to Linux:
grep -m1 '^flags' /proc/cpuinfo \
| tr ' ' '\n' \
| grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
All four flags must appear to meet the documented hardware condition. Looking for `avx512f` alone is insufficient. For VMs, run the check inside the guest; for Kubernetes, check the nodes on which affected pods can actually be scheduled.
Even a match on all four flags does not establish exploitability: the runtime, effective JVM settings and vulnerable application path must still be evaluated.
3. Inspect container and Kubernetes runtimes
Check Java inside the application container, not just on its host:
docker ps --format '{{.Names}} {{.Image}}'
docker exec CONTAINER_NAME java -version
# Kubernetes: adapt the pod, container and namespace
kubectl exec POD -c CONTAINER -- java -version
Record image tags and digests, Dockerfiles and available software bills of materials (SBOMs). Rebuilding from an unpatched base image may reproduce the problem. Check replicas, failover nodes and pods running during rolling updates.
The Keycloak team specifically identified 26.8.2-1 and 26.8.2-2 x86-64 images bundling an affected OpenJDK 21 build. Their tags alone do not prove a particular deployment is exploitable; CPU capabilities and effective JVM flags still matter.
Permanent patching and interim mitigations
The durable fix is a vendor-confirmed patched Java runtime followed by a restart of every affected JVM. Installing updated system packages without restarting a service can leave the old runtime in memory. Likewise, pushing a fixed container image does not help pods still using an old digest.
Until a fixed runtime can be deployed, Red Hat and CERT-EU document disabling the accelerated Base64 implementation:
-XX:-UseBASE64Intrinsics
Depending on JVM and option handling, CERT-EU also documents the diagnostic-option unlock:
-XX:+UnlockDiagnosticVMOptions -XX:-UseBASE64Intrinsics
On x86-64, `-XX:UseAVX=2` is an alternative limiting the runtime to AVX2; it may carry a wider performance penalty and must not be blindly applied to ARM64 JVMs.
For Keycloak, the vendor recommends appending `-XX:-UseBASE64Intrinsics` via `JAVA_OPTS_APPEND`, restarting every instance and checking the effective flag with `jcmd`. A Kubernetes Operator may require separate settings from the application it manages. A variable in a manifest or Compose file is not proof that every running JVM is protected.
Do not disable unrelated security features or assume a simple application dependency update replaces the runtime fix.
What is known about exploitation by 19 November?
By 19 November 2026, observers including GreyNoise and WatchTowr had reported probing and apparent exploit attempts. According to SecurityWeek's report on 19 November, GreyNoise saw more than 150 requests resembling an attack from five IP addresses early that day, while reporting no successful intrusion on its sensors.
A laboratory exploit and scanning seen in the wild do not prove a successful production compromise. Conversely, the absence of a WAF alert is not enough to clear a server: some Java client and non-HTTP paths do not traverse an inbound WAF.
Incident-response checks for potentially exposed environments
- Exposure window: identify when vulnerable builds were running, public endpoints and failover nodes, and when every instance actually restarted with the patch.
- Telemetry: review authentication and Base64 decoding failures, JVM crashes, abnormal process launches, suspicious outbound connections and application security events.
- Evidence preservation: retain logs, file hashes, relevant image or memory artifacts, configurations and an authorized incident timeline before destructive remediation.
- Interpretation: a JVM crash is a nonspecific indicator; a running service with no visible crash is not automatically clean.
- Prioritization: focus on public identity services and admin consoles first, then internal applications, containers, agents and client-side Java components.
Cloudflare's 18 November WAF guidance offers an additional detection and blocking layer, not a substitute for patching. Rules may initially run in logging mode because some benign inputs resemble suspicious patterns.
The broader risk-management lesson
Java4Shell highlights a common gap: the runtime bundled into software, the base container image, and the CPU features visible to it may have different security implications from the host OS. A useful asset inventory connects each service to its actual Java binary, vendor patch status, CPU capabilities, image provenance and restart procedure.
GLOV Consulting covers GLOV Solutions' risk-management and organizational services. Our earlier analyses of the PHP2Shell intrusion chain reaching ESXi and the LiteLLM supply-chain compromise describe different failures: application exploitation and compromised software distribution rather than a vulnerable JVM runtime.
Information reviewed on 19 November 2026. GLOV AI and digital forensics are still presented as upcoming services on the website. This article does not allege that GLOV Solutions or any of its customers were compromised.
Official references and independent analysis
- Oracle — Critical Security Patch Update, 17 November 2026.
- OpenJDK — official security advisory, 17 November 2026.
- CERT-EU — advisory 2026-021, 18 November 2026.
- CISA — immediate patching guidance, 17 November 2026.
- Red Hat — RHSB-2026-018, hardware requirements and mitigations.
- Ubuntu — USN-9155-1, OpenJDK 17.
- Ubuntu — USN-9156-1, OpenJDK 21.
- Ubuntu — USN-9157-1, OpenJDK 25.
- Keycloak — official container guidance, 18 November 2026.
- Calif — original technical research.
- Cloudflare — WAF guidance and its limitations, 18 November 2026.
- SecurityWeek — observed probing and attempts, 19 November 2026.