Java4Shell (CVE-2026-114938)
Last reviewed: 18 November 2026, 11:15 CET (UTC+01:00).
If you have questions about this advisory or need help assessing your installation, please contact Insight Support or your project lead.
Java4Shell is a security vulnerability in the accelerated Base64 decoding implementation of affected Java runtimes. Malformed input can cause memory corruption and may allow remote code execution.
Insight patches and updated Docker images will be provided as soon as the required upstream fixes are available. Until then, apply the temporary mitigation below to affected installations. Install the applicable Insight update when available.
Affected Java and Insight versions
Insight changed from JDK 11 to JDK 17 with version 34.1.0, and to JDK 25 with version 36.2.0. This also applies to our WildFly-based Docker images, including the product, service and adapter images.
Insight middleware 34.1.0 and later are potentially affected when using an unpatched HotSpot-based JDK. The affected code was introduced in JDK 17.0.6 and is also present in later Java lines, including JDK 25. Moving to JDK 25 does not resolve the issue; install a vendor-confirmed fixed build or apply the mitigation below. Insight 34.0 installations using JDK 11 are outside this affected code path.
For manually installed WildFly or a custom image, check the runtime configured for the service, including older installations upgraded to a newer JDK. Verify the full running Java build to confirm security patch status. See the 34.0 release notes and 34.1 release notes for the JDK 17 transition.
Hardware and input conditions
The known vulnerable execution path requires an x86-64 CPU with all four
features available: avx512f, avx512bw, avx512vbmi and bmi2. All four
must be exposed to the JVM; support for AVX-512 alone is insufficient. An
affected Java build, enabled Base64 intrinsics and attacker-controlled Base64
input reaching the decoder are also required. See the
CERT-EU advisory
for these prerequisites and the
vendor advisory
for affected builds and mitigation.
ARM64 systems and x86-64 systems where at least one of these four features is unavailable are outside this known vulnerable execution path. Use the checks below before changing JVM settings.
Check CPU features before applying mitigation
Check the environment where the Java service actually runs. In a virtual machine, use the guest's results: the physical host's CPU model does not show which features the hypervisor exposes. Repeat the check for each server or container node, and after moving a workload to different hardware.
Running containers
For any Linux service container with uname and awk available, replace
CONTAINER with its name or ID and run these commands from the Docker host:
docker exec CONTAINER uname -m
docker exec CONTAINER awk '
BEGIN { n = split("avx512f avx512bw avx512vbmi bmi2", required) }
/^processor[[:space:]]*:/ { cpu = $3 }
/^flags[[:space:]]*:/ {
printf "CPU %s:", cpu
for (i = 1; i <= n; i++)
printf " %s=%s", required[i], (index(" " $0 " ", " " required[i] " ") ? "yes" : "no")
print ""
found = 1
}
END { if (!found) print "No CPU flags available: check inconclusive" }
' /proc/cpuinfo
x86_64 identifies x86-64; aarch64 identifies ARM64. On x86-64, the second
command reports each feature separately for each visible CPU. A row with all
four features available looks like this:
CPU 0: avx512f=yes avx512bw=yes avx512vbmi=yes bmi2=yes
If any CPU reports all four as yes, the hardware prerequisite is present;
check the Java build and apply the mitigation if affected. If every CPU's
complete flags list lacks at least one required feature, the known hardware
prerequisite is absent on that node. Missing tools, inaccessible or incomplete
CPU information, or a command error leave the check inconclusive.
These commands apply to middleware, service, adapter and Elasticsearch Linux containers alike. For Windows containers, use the Windows check inside the container. If the required tools cannot run there, have the administrator verify the features exposed to that container; do not infer the result from the image tag or a different machine.
Windows
Use the JDK's jcmd.exe on the Windows server or VM running the service.
Open PowerShell under the service account with permission to attach to the
Java process. Set $jdkHome to the JDK used by that service, then list the
running Java processes:
$jdkHome = 'C:\path\to\service-jdk'
& "$jdkHome\bin\jcmd.exe" -l
Identify the service JVM and replace 1234 with its process ID. These
diagnostic commands inspect the running JVM without changing its settings:
$javaPid = 1234
& "$jdkHome\bin\jcmd.exe" $javaPid VM.version
& "$jdkHome\bin\jcmd.exe" $javaPid VM.info | Select-String '^CPU:'
& "$jdkHome\bin\jcmd.exe" $javaPid VM.flags -all |
Select-String 'UseBASE64Intrinsics|UseAVX'
In the CPU: line, check for all four feature names as separate entries in
the comma-separated list:
| Required feature | HotSpot feature name |
|---|---|
avx512f |
avx512f |
avx512bw |
avx512bw |
avx512vbmi |
avx512_vbmi |
bmi2 |
bmi2 |
HotSpot commonly includes an underscore in avx512_vbmi; avx512_vbmi2 is
a different feature and does not replace it. All four entries indicate that
the required CPU features are available to this JVM.
The list reflects the JVM's effective feature settings. UseAVX = 2 or lower
disables AVX-512 and can remove those entries even on capable hardware;
UseBASE64Intrinsics = false disables the affected Base64 acceleration even
if all four features are listed. These settings show mitigation in the
running process, not that the physical CPU lacks support. Keep an existing
mitigation in place while checking.
If a complete feature list from a supported HotSpot JVM lacks a required
feature, that feature is unavailable to that JVM under its current settings.
If attachment fails, the CPU: line is missing or incomplete, or the runtime
does not support these diagnostics, the check is inconclusive. A VBMI entry
with unclear reporting of the remaining features must still be treated as
potentially affected. See the JDK diagnostic command reference.
Decide whether mitigation is needed
If all four features are available and the running HotSpot build is affected, apply the mitigation below unless it is already active. CPU support alone does not establish that a service is vulnerable; verify the running Java build and effective JVM flags as described in the relevant section.
If the hardware prerequisite is confirmed absent, no additional JVM flag is needed for this known path on the current system. Continue installing security updates and recheck before moving the service to another host. If the check is inconclusive, do not classify the installation as unaffected: use the mitigation for an affected runtime until the prerequisites can be verified.
Temporary mitigation
First complete the CPU feature check above to determine whether the known hardware prerequisite is present.
For affected HotSpot-based JVMs, add the following Java startup option to the service configuration as described in the Windows or Docker sections below. This option is passed to the Java Virtual Machine (JVM); it is not a command to run on its own:
-XX:-UseBASE64Intrinsics
The -XX: prefix identifies a JVM-specific option. The minus sign before
UseBASE64Intrinsics switches that option off: Java stops using its optimized,
hardware-accelerated Base64 implementation and uses the regular implementation
instead. Base64 encoding and decoding remain available, but the vulnerable
accelerated decoding path is disabled.
Base64 processing may be slower with this setting. The option takes effect when Java starts, so the service must be restarted after it is added. It is a temporary workaround, not a replacement for a fixed JDK.
An alternative on x86-64 only is -XX:UseAVX=2. It disables AVX-512 more
broadly. Do not apply that option to ARM64 JVMs: they do not recognize it and can
fail to start. Both options are described in the
mitigation advisory.
Use one mitigation, preserve existing JVM settings, restart the affected Java process and verify the effective flags. Changing a configuration file or environment variable does not change an already running JVM.
WildFly on Windows
For the documented WildFly installation using standalone.bat and the supplied
Windows service scripts:
- Stop the Insight WildFly Windows service using Windows Services.
- Back up
X:\GiS\Insight\Wildfly\bin\standalone.conf.bat(adjust the path to your installation). - Append the following line after the existing
JAVA_OPTSassignments, on the executed path before the configuration script returns:
set "JAVA_OPTS=%JAVA_OPTS% -XX:-UseBASE64Intrinsics"
Keep existing heap, metaspace, truststore and other application options. 4. Start the service again and check that WildFly and the Insight applications start successfully. 5. Verify the flag on the running JVM as described below.
If a custom Windows service wrapper starts Java directly and does not load
standalone.conf.bat, append the option to that wrapper's JVM configuration
instead. Setting a variable in an interactive command prompt does not update
the environment or configuration of an existing Windows service.
Verify the Windows JVM
Run PowerShell under the service account with permission to attach to the Java process. Use the JDK belonging to this installation:
& "$env:JAVA_HOME\bin\jcmd.exe" -l
Identify the WildFly JVM, then replace 1234 below with its process ID:
$wildflyPid = 1234
& "$env:JAVA_HOME\bin\jcmd.exe" $wildflyPid VM.version
& "$env:JAVA_HOME\bin\jcmd.exe" $wildflyPid VM.flags -all |
Select-String 'UseBASE64Intrinsics|UseAVX'
For the preferred mitigation, confirm UseBASE64Intrinsics = false.
If attachment fails or the flag cannot be inspected, mitigation has not been
verified. A separate java -version command checks an installed runtime; it
does not establish which runtime or flags the service is using.
Related manual pages: Windows services and JVM environment variables.
Insight Docker images
Apply the option to every affected WildFly container, including separately deployed middleware, service and adapter containers.
Add the flag using JAVA_TOOL_OPTIONS
For these WildFly images, JAVA_TOOL_OPTIONS lets the JVM pick up an additional
option while keeping the existing WildFly JAVA_OPTS and memory defaults. Add
the following environment entry to the existing Compose service; retain its
image, ports, volumes and other settings:
services:
middleware:
environment:
JAVA_TOOL_OPTIONS: "-XX:-UseBASE64Intrinsics"
If JAVA_TOOL_OPTIONS is already set, append the flag to its existing value
instead of replacing that value. Remove conflicting options that explicitly
enable Base64 intrinsics. Scope the setting to the relevant container.
Recreate the container to apply the environment change (replace middleware
with the actual Compose service name):
docker compose up -d --force-recreate middleware
A simple container restart retains its previous environment. JVM startup logs
normally report Picked up JAVA_TOOL_OPTIONS; verify the effective flag too.
See Oracle's JAVA_TOOL_OPTIONS documentation
for how the JVM reads this variable.
Alternative: use the existing JAVA_OPTS configuration
If the deployment already manages all JVM options through JAVA_OPTS, append
the mitigation there. For example, using the documented default sizing:
services:
middleware:
environment:
JAVA_OPTS: >-
-Xms256m -Xmx1024m
-XX:MetaspaceSize=96M -XX:MaxMetaspaceSize=512m
-XX:-UseBASE64Intrinsics
Retain your actual sizing, truststore, proxy and other existing options.
Defining JAVA_OPTS overrides WildFly's default option construction; setting
only the mitigation flag can discard the memory defaults. See
JAVA_OPTS and JBOSS_JAVA_SIZING.
Verify the running container
Replace CONTAINER with the container name:
docker exec --user jboss CONTAINER jcmd -l
Identify the WildFly JVM and replace JAVA_PID with its PID inside the container:
docker exec --user jboss CONTAINER jcmd JAVA_PID VM.version
docker exec --user jboss CONTAINER jcmd JAVA_PID VM.flags -all \
| grep -E 'UseBASE64Intrinsics|UseAVX'
Confirm UseBASE64Intrinsics = false, or, for the x86-64 alternative,
UseAVX = 0, 1 or 2. Use the actual Java service user if it differs from
jboss. Missing JDK tools, disabled attachment or permission errors make this
check inconclusive. These commands inspect the running JVM. A check in a newly
started container cannot verify the flags of the existing service.
After a fixed image is supplied, pull it, recreate all affected containers and verify the running Java build against the JDK vendor's fix information before removing the workaround.
Elasticsearch
In the intended Insight deployment, Elasticsearch is not directly accessible to clients. Search requests go through the Insight middleware and require a valid, authenticated Insight session and the required search permissions. With such access, a manually crafted search request can reach Base64 decoding in Elasticsearch and may trigger the vulnerability if the Java runtime and hardware conditions described above are met. Authentication therefore limits access but does not eliminate this risk.
Elasticsearch permits scripting by default; an explicit enable step is not required. See Elastic's scripting security documentation. The availability of individual request paths depends on the deployed settings.
Apply the temporary mitigation to every affected Elasticsearch node, and install an updated Elasticsearch version addressing this issue as soon as it is available and supported by your Insight release. Keep Elasticsearch access restricted to the required services.
Temporary mitigation for Elasticsearch
The following steps apply the
Java runtime vendor's recommended workaround
using Elastic's documented JVM configuration methods. The option
-XX:-UseBASE64Intrinsics disables accelerated Base64 processing while keeping
normal encoding and decoding available. A restart is required.
Windows service
- Locate the service's Elasticsearch configuration directory. By default this
is
X:\GiS\Insight\elasticsearch\config(adjust the installation path). If the service uses a customES_PATH_CONF, use that directory instead. - Create
jvm.options.d\java4shell.optionsinside that configuration directory, creatingjvm.options.dif necessary. Add this single line:
-XX:-UseBASE64Intrinsics
Ensure the file ends in .options, not .options.txt. Keep the main
jvm.options file and existing memory settings unchanged.
3. Save the file, then open Windows Services (services.msc).
4. Select the Elasticsearch service and choose Stop. Wait until it has
stopped, then choose Start to start it again. If it is already stopped,
choose Start.
5. Verify the running node as described below. The mitigation is
only confirmed when the running node reports the new option.
Repeat for every affected node. Use the configuration directory of the installed service, rather than a directory selected by an interactive shell. See Elastic's JVM configuration guidance.
The same .options file also applies to .zip or .tar.gz installations
started without a Windows service: put it in the active config/jvm.options.d/
directory. For Debian/RPM installations, use
/etc/elasticsearch/jvm.options.d/. Restart the Elasticsearch process and
verify the running node after adding the file.
Docker Compose
Define the option directly in docker-compose.yaml using an inline Compose
configuration. It is mounted as a read-only file; no separate local file is
needed. This requires Docker Compose 2.23.1 or later, which you can check
with docker compose version.
Merge the following into the existing Compose file, retaining the
Elasticsearch image, volumes and other settings. The first configs section
is at the top level, alongside services:
configs:
elasticsearch-java4shell:
content: |
-XX:-UseBASE64Intrinsics
services:
elasticsearch:
configs:
- source: elasticsearch-java4shell
target: /usr/share/elasticsearch/config/jvm.options.d/java4shell.options
Recreate the container, replacing elasticsearch with the actual service name:
docker compose up -d --force-recreate elasticsearch
Apply the configuration to every affected node. See Docker inline configurations and Elastic's JVM configuration guidance.
Verify the Elasticsearch nodes
After restarting, use an authorized administration connection or Kibana Dev Tools to inspect the running nodes' JVM arguments:
GET /_nodes/jvm?filter_path=nodes.*.name,nodes.*.jvm.input_arguments
Confirm that every expected node reports -XX:-UseBASE64Intrinsics in
jvm.input_arguments. Remove any conflicting option that enables Base64
intrinsics, and check node startup and cluster health. Missing nodes or
unavailable JVM arguments leave the check incomplete. See the
Nodes information API.
Retain the workaround until a fixed Elasticsearch runtime has been installed and verified.
Maximo and Maximo Application Suite (MAS)
Customers running IBM Maximo or MAS should also check those environments, including their application servers, container images and Java runtimes. Check the JVM implementation as well as the JDK vendor, full build and hardware. If a component uses an OpenJ9-based runtime such as IBM Semeru, it is outside the known affected HotSpot code path; see IBM's implementation guidance and the technical analysis excluding OpenJ9.
Verify the runtime used by each component and follow IBM's product-specific security advisories and supported update procedures. An Insight mitigation or update does not change the JVM used by Maximo or MAS.
Android app
The standard Insight Android app is outside the known affected code path of CVE-2026-114938. Android's Java components use the Android Runtime (ART), which is a different implementation from HotSpot. The vulnerable HotSpot Base64 acceleration is therefore not used by the app on the device. This assessment follows the runtime distinction described in the Android runtime documentation and the technical analysis of the affected HotSpot implementation.
No Java startup flag or Android app update is required to mitigate this specific issue on the device. The Java version used to build an Android app does not determine the runtime used by the installed app.
The Insight middleware and other server components must still be checked and mitigated as described above, including when they are accessed exclusively from Android devices.