Skip to content

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:

  1. Stop the Insight WildFly Windows service using Windows Services.
  2. Back up X:\GiS\Insight\Wildfly\bin\standalone.conf.bat (adjust the path to your installation).
  3. Append the following line after the existing JAVA_OPTS assignments, 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

  1. 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 custom ES_PATH_CONF, use that directory instead.
  2. Create jvm.options.d\java4shell.options inside that configuration directory, creating jvm.options.d if 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.

References