Java4Shell, tracked as CVE-2026-114938, is a memory-corruption vulnerability in the Java runtime’s optimized Base64 decoder. It can lead to remote code execution in affected deployments. Oracle released security updates on November 17, 2026. The Oracle advisory identifies the affected component as Compiler and describes exploitation without authentication.
We would start with the Java processes that are actually serving traffic, especially identity services, application servers, and build infrastructure. Updating a JDK package on a host does not tell you which runtime a container or bundled application is still using.
The immediate work is to identify the runtime and CPU conditions, deploy the appropriate vendor fix, restart or replace affected processes, and confirm what is running afterward. If a patch cannot be deployed yet, the researchers describe JVM startup options that can avoid the vulnerable optimization.
Sources reviewed November 17, 2026, Central Standard Time (CST). Vendor builds and detection coverage are changing. Use the linked advisories when making a deployment decision.
What to do first
- Find the running JVMs. Include production services, build controllers and agents, scheduled jobs, containers, and applications with bundled runtimes. Assign an owner to each service.
- Record the exact runtime. Capture the vendor, full build version, architecture, and process or container identity. A major version such as “Java 17” is insufficient.
- Check the relevant CPU features and JVM settings. Assess the features presented to the guest or workload, along with the active JVM options. Keep uncertain results open for investigation.
- Prioritize exposed and sensitive services. Review untrusted input paths, internet access, internal callers, and the credentials or data available to the service.
- Install the fixed build specified by your vendor. For bundled runtimes, follow the application vendor’s supported update route. If that is temporarily unavailable, assess the mitigations below.
- Restart or replace and verify. Confirm the version and relevant flags in each running JVM, test application behavior, and check that scaling or scheduled jobs cannot bring the old image back.
What Java4Shell affects
The OpenJDK advisory marks Java 17, 21, 25, and 27 as affected by this CVE. Its broader introductory version list also covers other vulnerabilities; read the row for CVE-2026-114938 rather than treating every release in that introduction as affected by this particular flaw.
Calif’s research places the introduction in OpenJDK 17.0.6 and identifies an x86-64 execution path requiring AVX-512 VBMI. ARM64 does not execute that path. The researchers demonstrated pre-authentication RCE in products including Atlassian Jira, Confluence, Jenkins, and Keycloak. That establishes practical risk, but it does not establish the exposure of every installation of those products.
| Question | What to establish |
|---|---|
| Which runtime is executing? | Distribution, full build, architecture, and the JVM used by this service |
| Does the CPU expose the required features? | Features available inside the relevant VM or execution environment |
| Can the optimization be used? | Active JVM settings and whether the build contains the vulnerable implementation |
| Can untrusted data reach the decoder? | Application routes and protocols, including processing before authentication |
| Has the fix reached this process? | Vendor advisory, deployed artifact, and running-process evidence after restart |
Checking a CPU flag or finding a Base64 API call does not demonstrate remote code execution. Likewise, a quiet service or a failed test request does not establish that the vulnerable path is unreachable under a different workload.
The Java 8 Performance Pack exception
Oracle’s CVE record explicitly lists 8u511b33-perf, an Oracle Java 8 Enterprise Performance Pack build, among affected products. It also lists affected Oracle GraalVM variants. An inventory entry that only says “Java 8” can hide that distinction.
The OpenJDK matrix does not mark its ordinary Java 8 or Java 11 lines as affected by this CVE. Those lines receive other security fixes, so continue their normal patching. Do not move a service to an old Java 17 release simply because it predates this optimization; that would introduce a different maintenance and security problem.
Unsupported and custom builds need separate verification. Absence from the current supported-release table is not evidence that a build is safe.
Which Java versions contain the fix?
For Oracle JDK, the November 17 release notes identify these builds. Use the update for the release line your application supports, or a later vendor release that includes the fix.
| Oracle JDK line | November 17 update and full build |
|---|---|
| Java 17 | 17.0.21.1+4 |
| Java 21 | 21.0.13.1+4 |
| Java 25 | 25.0.5.1+4 |
| Java 27 | 27.0.1.1+4 |
These are Oracle JDK build identifiers, not a universal version table for every distribution. Temurin, Corretto, Zulu, Microsoft, Red Hat, and other distributors have their own packaging and release channels. For the Java 8 Performance Pack and GraalVM, use the product-specific Oracle advisory and update instructions.
Follow the advisory for the package you deploy. For example, Amazon Linux tracks this CVE by package and platform. An upstream release announcement does not establish that a particular distribution repository, application bundle, or container tag already contains the update.
Record the package version or image digest that contains the fix. A mutable image tag alone makes the evidence difficult to reproduce later.
Check the running JVM before closing the ticket
A shell’s java -version identifies the binary that shell resolves. It does not identify every JVM already running on the machine. We would use the service manager or container runtime to locate the application’s process, then inspect that process where supported.
The following example uses JDK diagnostic tools. Replace the example PID with the application JVM’s PID. Run it in the correct host or container context with a compatible JDK toolset. Oracle documents that jcmd requires the same machine and effective user/group as the target JVM; attachment can also be restricted by the runtime or deployment. See the jcmd reference.
# Replace 1234 with the application JVM's process ID.
java_pid=1234
jcmd "$java_pid" VM.version
jcmd "$java_pid" VM.flags -all \
| grep -E 'UseBASE64Intrinsics|UseAVX'
VM.version reports the target JVM version. VM.flags -all reports supported flags and their current values. If the command fails, the output is incomplete, or the relevant settings are absent, record that as an unresolved check. Use vendor-supported diagnostics rather than treating missing output as a pass.
For a Linux workload, inspect the CPU information available in its execution environment:
lscpu
grep -m1 '^flags' /proc/cpuinfo
Calif’s CPU check looks for avx512f, avx512bw, avx512vbmi, and bmi2. CPU information is one input to triage. A hypervisor can expose a different feature set from the physical processor, and moving a workload can change that set. Assess each relevant node class rather than inferring the whole fleet from one machine.
Keep the runtime version, CPU evidence, and JVM options together. They answer different questions. Enabled flags describe configuration; they do not prove that a particular request has executed a JIT-compiled decoder or that the application is exploitable.
Containers and bundled runtimes need their own checks
For a container, inspect the JVM inside the application container. An updated host JDK does not replace the JDK baked into an image. Some minimal images lack a shell or jcmd; use the application’s supported diagnostics or an approved inspection workflow instead of installing tools into production ad hoc.
Record both the desired image digest and the digest actually running. Then review deployments, stateful workloads, scheduled jobs, build agents, and rollback configurations that might start the older artifact again. An application vendor may ship its own JRE even when the operating system package inventory looks current.
Temporary mitigation when patching is delayed
Calif recommends either of two JVM startup options to avoid the vulnerable path:
-XX:-UseBASE64Intrinsics
This disables the hardware-accelerated Base64 intrinsics. The alternative limits AVX use so the JVM does not select AVX-512:
-XX:UseAVX=2
Use the second option only on x86-64. The researchers warn that ARM OpenJDK does not recognize it and can fail to start. Do not distribute an x86-specific startup setting indiscriminately across a mixed-architecture fleet.
These mitigations come from the researchers. Confirm that your JVM and application vendor support the chosen setting, and plan to install the fixed runtime even after applying it.
To apply a temporary mitigation:
- Test the selected option with the same runtime distribution and application configuration used in production.
- Put it in the application’s actual JVM startup configuration, before application arguments. Preserve existing options and follow the product’s launch instructions.
- Restart or replace the JVM through your normal availability procedure. Editing an environment variable in a separate shell does not change an existing process.
- Inspect the running process again. For the intrinsic option, confirm
UseBASE64Intrinsicsis false; for the AVX option, confirmUseAVXis 2 on the intended x86-64 workload. - Check latency, CPU use, startup behavior, and application errors under representative traffic. Disabling an optimization can affect performance.
- Assign an owner and deadline to replace the mitigation with a fixed build. After patching, review whether to remove the temporary option through a tested change.
Do not assume jcmd VM.set_flag can change these options live. Treat this as a startup-and-restart procedure unless your vendor explicitly supports another approach.
What the vulnerability does, and what “pre-auth” means
The bug is in native runtime code used to accelerate Base64 decoding. Malformed input can cause a write beyond the intended output array and corrupt neighboring heap memory. Java’s normal memory-safety checks do not repair a mistake in that lower-level implementation. Chainguard’s independent disclosure describes the same vulnerable decoder and its memory-corruption impact.
Pre-authentication describes where a vulnerable processing path is reachable. Authentication data may need parsing before a service can decide whether credentials are valid. Requiring users to sign in therefore does not, by itself, establish that the decoding happens after authentication.
For your application, trace where external data is decoded and under which runtime. Include internal services and data received from other systems. A firewall rule that removes direct internet access can reduce exposure, but it does not answer what trusted callers can send or what outbound connections the application makes.
Run active tests that can trigger memory corruption in controlled staging environments. Use runtime inventory and vendor patch checks to assess production first.
Why the severity scores differ
Oracle rates this CVE 8.1 under CVSS 3.1, with high attack complexity and no required privileges. Calif reports 9.2 under CVSS 4.0. These are different scoring assessments and versions of the scoring system. Keep the source and version attached to each number.
Use the scores alongside your exposure and business context. An internet-facing identity service with a reachable vulnerable decoder deserves urgent attention even if a vendor summary calls the issue “High” rather than “Critical.”
Detection and investigation
At our November 17 review, Cisco Talos reported that it had not observed exploitation in the wild. That is a statement about its observations at disclosure, not evidence that every environment is clean.
Talos lists Snort coverage for malformed Base64 in specific HTTP fields: Snort 2 SIDs 1:67502 through 1:67513; Snort 3 includes those rules and 1:301754. Check the current advisory and rule availability for your engine. Network visibility, encryption, protocol coverage, and application-specific paths limit what any such rule can observe.
Our investigation starting points would be:
- Unexpected JVM exits, restart spikes, fatal error reports, or core dumps around unusual application requests.
- Java processes launching shells or unexpected utilities, making unusual outbound connections, or writing files outside their normal behavior.
- Suspicious use of service credentials, tokens, or administrative sessions after the suspected exposure window.
- Relevant application, proxy, identity, endpoint, and network events that can establish a timeline.
These are investigation leads, not unique indicators of Java4Shell. A crash can have an unrelated cause; absence of a crash or shell process does not exclude memory disclosure or another exploitation path. Preserve evidence and assess the privileges available to the affected process before deciding the incident’s scope.
Keep request logs and crash artifacts under appropriate access controls. Authentication headers and memory dumps can contain credentials or personal data. If compromise is suspected, isolate affected workloads as appropriate, preserve relevant evidence, and review credential or session revocation as part of the response. Our incident-response planning guide can help organize ownership and escalation.
Patch rollout and closure checklist
Use the following as acceptance criteria for each service, with an owner and evidence link beside each item in your change record:
- The exact runtime distribution and build are recorded for every relevant workload instance.
- The selected package or application update is tied to a vendor statement covering CVE-2026-114938.
- The replacement artifact is deployed, and the running JVM reports the expected version after restart.
- The running process has the intended temporary mitigation settings, where needed, with a plan to replace or remove them.
- Authentication, normal transactions, scheduled work, and representative performance checks pass.
- Scaling, restart, and rollback paths use an approved artifact instead of silently restoring a vulnerable runtime.
- Relevant telemetry has been reviewed for suspicious behavior during the exposure window, with concerns handed to incident response.
- Exceptions have an owner, a reason, compensating measures, and a review deadline.
We would keep “package installed,” “process restarted,” and “running build checked” as separate pieces of evidence. That makes it much easier to spot the application that was missed during an otherwise successful rollout.
For build infrastructure, also review the service’s credentials and outbound access. Our CI/CD egress-controls guide covers ways to constrain network access during builds. Those controls can limit some follow-on activity; they do not fix this JVM vulnerability.
If you need help locating affected runtimes or reviewing a remediation plan, see our security services or contact us with the runtime distribution, application, and deployment model.
