Java4Shell - remote code execution in the Java runtime

CAST position on Java4Shell (CVE-2026-114938), how to check whether your CAST Imaging deployment is concerned and how to protect it until the fixed release

Overview

Java4Shell is the name given to CVE-2026-114938 external link, a vulnerability in the Java runtime published on November 17, 2026. CAST Imaging runs on Java and is concerned only under specific hardware conditions. This bulletin explains how to check whether your deployment is concerned, a configuration change that protects it today, and what CAST is doing to deliver a fix.

Severity Status Published Last updated
High Affected - mitigation available, fix pending the Eclipse Temurin release 2026-11-18 2026-11-18

In short

  • Your deployment is concerned only if it runs on a recent x86-64 processor with the AVX-512 VBMI instruction set (Intel Xeon 3rd generation or later, AMD EPYC 4th generation or later). Arm processors and older processors are not concerned. A one-line check is provided below.
  • If your deployment is concerned, a configuration change protects it now, without upgrading CAST Imaging. CAST has tested it on CAST Imaging 3.6.9.
  • CAST will publish a CAST Imaging release with fixed Java runtimes as soon as Eclipse Temurin, the Java distribution used by CAST Imaging, releases its fix. This bulletin will be updated when it is available.
  • At the time of writing, CAST is not aware of any exploitation of this vulnerability against CAST Imaging.

What is Java4Shell?

Java4Shell is a memory corruption flaw in an optimized version of the Base64 decoder built into the Java runtime (OpenJDK). Java uses this optimized decoder only on x86-64 processors that support the AVX-512 VBMI instruction set. An attacker who can send specially crafted data to a Java application running on such a processor may be able to crash it or run code on the server. Because the flaw is in the Java runtime itself, it can affect any Java application, whatever the quality of the application code.

The flaw affects Java 17.0.6 and later releases of Java 17, and Java 21 and Java 25. Java 8 and Java 11 are not affected. The Java vendors started publishing fixed releases on November 17, 2026: Oracle and OpenJDK 17.0.21.1, 21.0.13.1 and 25.0.5.1, as well as Amazon Corretto and Azul Zulu. Eclipse Temurin, the Java distribution used by most CAST Imaging components, had not yet published its fixed releases at the time of writing.

Is my deployment concerned?

Step 1 - Check the processor

Run the following command on each machine that runs CAST Imaging: the Docker host, or each node of your Kubernetes cluster:

$ grep -c avx512vbmi /proc/cpuinfo
  • 0: the processor does not support AVX-512 VBMI. Your deployment is not concerned on this machine and no action is required. You will receive the fixed Java runtimes with the next CAST Imaging release.
  • Any other number: the processor supports AVX-512 VBMI. Continue with Step 2.

On Microsoft Windows, display the processor model in Task Manager > Performance > CPU, and compare it with the processor families listed below.

The following processors support AVX-512 VBMI:

  • Intel Xeon Scalable 3rd generation (Ice Lake) and later, including Xeon 6 processors with Performance-cores. Intel Xeon 6 processors with Efficient-cores do not support it.
  • AMD EPYC 4th generation (Genoa, Bergamo) and later.

The following table translates these processor families into the virtual machine families of the main cloud providers. Kubernetes node pools (Amazon EKS, Azure AKS, Google GKE) follow the virtual machine size of each node.

Cloud provider Concerned Not concerned
Amazon Web Services Intel 6th generation and later (m6i, c6i, r6i and their variants, i4i, x2idn, x2iedn, m7i, m7i-flex, c7i, r7i, r7iz, i7ie, m8i, c8i, r8i, i7i), AMD 7th generation and later (m7a, c7a, r7a, hpc7a, m8a, c8a, r8a) Intel 5th generation and earlier (m5, c5, r5, t3, m5zn, z1d), AMD 6th generation and earlier (m5a, m6a, c6a, r6a, t3a), all AWS Graviton (Arm) families
Microsoft Azure Intel v5 and v6 sizes (Dsv5, Ddsv5, Esv5, Edsv5, Ebsv5, Dlsv5, Bsv2, Dsv6, Ddsv6, Esv6, Edsv6, Dlsv6), AMD v6 and later sizes (Dasv6, Dadsv6, Easv6, Falsv6, Fasv6, HBv4, HX, Dasv7) Intel v3 and v4 sizes (Dv3, Dsv3, Dv4, Dsv4, Ev4, Fsv2), AMD v4 and v5 sizes (Dav4, Dasv5, Easv5, Basv2), Arm sizes (Dpsv5, Dpsv6, Bpsv2)
Google Cloud C3, C3D, C4, C4D, N4, N4D, M3, Z3, H3, and N2 when it runs on Intel Ice Lake N1, E2, N2D, T2D, C2, C2D, M1, M2, Arm families (T2A, C4A, N4A)

A virtual machine family can run on more than one processor generation, for example Google Cloud N2. The command in this step gives the definitive answer for each machine.

Step 2 - Check which components you use

CAST Imaging component Containers Concerned
imaging-services sso-service, gateway, auth-service, console, control-panel Yes
imaging-node analysis-node Yes
imaging-dashboards dashboards Yes
imaging-viewer neo4j Yes
imaging-viewer server, etl, imaging_apis, ai_manager No - no Java runtime included
Extend Local Server, MCP Server extend-proxy, mcp-server No - no Java runtime included

CAST has verified the CAST Imaging 3.6.8 and 3.6.9 container images. Earlier 3.x releases also run Java 17 or later and should be considered concerned. On Microsoft Windows, the CAST Imaging services run on the Java JDK installed on the machine and on the Java runtime embedded in CAST Imaging Core 8.4.10 and later, so they are concerned when one of these runtimes is an affected release.

The services that matter most are those your users can reach over the network. In a standard deployment, users only need the CAST Imaging gateway port (8090 by default), which also serves the sign-in pages. The other ports, such as the Neo4j ports, the analysis node port and the direct ports of the individual services, are used between CAST Imaging components and should not be reachable from your users’ network. See Network access for the full port list. Restricting these ports significantly reduces your exposure, but does not replace the mitigation below.

What do I need to do?

If the check in Step 1 returns 0 on every machine, or if CAST Imaging runs on Arm processors, no action is required.

Otherwise:

  1. Apply the mitigation for your deployment type below. It disables the optimized Base64 decoder in Java, which is where the flaw lies. Java then uses its standard Base64 decoder instead. CAST has verified that CAST Imaging operates normally with this setting, and no noticeable performance impact is expected. The setting has no effect on machines that are not concerned, so you can apply it everywhere if you prefer a single procedure.
  2. Check that only the ports your users need are reachable, as explained in Step 2.
  3. Install the CAST Imaging release with fixed Java runtimes when it is available. CAST will publish it as soon as Eclipse Temurin releases its fix, and this bulletin will be updated with the release number. You can keep the mitigation in place after the update.

Applying the mitigation restarts the CAST Imaging services. Apply it when no analysis is running.

Docker on Linux

The mitigation is a setting added to the docker-compose.override.yml file of each component, so that it is kept when you update CAST Imaging. See Managing docker-compose.yml files for how override files work. If a docker-compose.override.yml file already exists in a folder, add the environment entries below to it, under the existing service sections, rather than creating a second services: section. If a service already sets JAVA_TOOL_OPTIONS or JAVA_OPTS_APPEND, for example for a custom truststore, keep its existing value and add -XX:-UseBASE64Intrinsics at the end, separated by a space.

  1. In /opt/cast/installation/imaging-services/docker-compose.override.yml, add:

    services:
      console:
        environment:
          JAVA_TOOL_OPTIONS: "-XX:-UseBASE64Intrinsics"
      auth-service:
        environment:
          JAVA_TOOL_OPTIONS: "-XX:-UseBASE64Intrinsics"
      gateway:
        environment:
          JAVA_TOOL_OPTIONS: "-XX:-UseBASE64Intrinsics"
      control-panel:
        environment:
          JAVA_TOOL_OPTIONS: "-XX:-UseBASE64Intrinsics"
      sso-service:
        environment:
          JAVA_OPTS_APPEND: "-XX:-UseBASE64Intrinsics"
    

    The sso-service container uses JAVA_OPTS_APPEND, which is the variable Keycloak reads for additional Java options.

  2. In /opt/cast/installation/imaging-node/docker-compose.override.yml, add:

    services:
      nodev3:
        environment:
          JAVA_TOOL_OPTIONS: "-XX:-UseBASE64Intrinsics"
    
  3. In /opt/cast/installation/imaging-dashboards/docker-compose.override.yml, add:

    services:
      dashboards:
        environment:
          JAVA_TOOL_OPTIONS: "-XX:-UseBASE64Intrinsics"
    
  4. In /opt/cast/installation/imaging-viewer/docker-compose.override.yml, add:

    services:
      neo4j:
        environment:
          JAVA_TOOL_OPTIONS: "-XX:-UseBASE64Intrinsics"
    
  5. In each of the four folders, recreate the containers. Docker Compose recreates only the containers whose configuration changed:

    $ cd /opt/cast/installation/imaging-services
    $ sudo docker compose up -d
    

    If the components are installed on separate machines, apply the steps for each component on the machine where it is installed.

  6. Check that the setting is active. Each of the console, auth-service, gateway, control-panel, analysis-node, dashboards and neo4j containers prints the Java options it received when it starts, and the line must contain -XX:-UseBASE64Intrinsics:

    $ sudo docker logs console 2>&1 | grep "Picked up JAVA_TOOL_OPTIONS"
    Picked up JAVA_TOOL_OPTIONS: -XX:-UseBASE64Intrinsics
    

    For the sso-service container, check that the setting is on the Java command line:

    $ sudo docker top sso-service | grep -c -- "-XX:-UseBASE64Intrinsics"
    1
    

Kubernetes

The following commands use the default namespace castimaging-v3: adapt it if you changed it. Kubernetes restarts the pods automatically after each command. The commands set the variables to -XX:-UseBASE64Intrinsics alone: if you have already customized JAVA_TOOL_OPTIONS or JAVA_OPTS_APPEND on a workload, set the variable to its existing value followed by -XX:-UseBASE64Intrinsics instead.

  1. For the dashboards, set DashboardsJavaToolOptions in the values.yaml file of the folder you deployed CAST Imaging from. If the variable already has a value, add the setting at the end of it, separated by a space:

    DashboardsJavaToolOptions: "-XX:-UseBASE64Intrinsics"
    

    Then run helm-upgrade.sh (Linux) or helm-upgrade.bat (Microsoft Windows) from the same folder. Do this first: a Helm upgrade can reset the settings added with kubectl in the next steps.

  2. Add the setting to the other deployments and to the Neo4j statefulset:

    $ kubectl set env -n castimaging-v3 deployment/console-service deployment/console-authentication-service deployment/console-gateway-service deployment/console-control-panel JAVA_TOOL_OPTIONS=-XX:-UseBASE64Intrinsics
    $ kubectl set env -n castimaging-v3 deployment/console-sso-service JAVA_OPTS_APPEND=-XX:-UseBASE64Intrinsics
    $ kubectl set env -n castimaging-v3 statefulset/viewer-neo4j-core JAVA_TOOL_OPTIONS=-XX:-UseBASE64Intrinsics
    
  3. For the analysis node, if analysis node autoscaling is disabled (the default):

    $ kubectl set env -n castimaging-v3 statefulset/console-analysis-node-core JAVA_TOOL_OPTIONS=-XX:-UseBASE64Intrinsics
    

    If analysis node autoscaling is enabled (AnalysisNodeAutoscaling.enabled: true), the analysis node is an OpenKruise statefulset, which kubectl set env does not support. Edit it instead:

    $ kubectl edit statefulsets.apps.kruise.io console-analysis-node-core -n castimaging-v3
    

    In the env list of the container, add the following entry, or if a JAVA_TOOL_OPTIONS entry already exists, add -XX:-UseBASE64Intrinsics at the end of its value:

    - name: JAVA_TOOL_OPTIONS
      value: "-XX:-UseBASE64Intrinsics"
    
  4. Check that the setting is active on each workload. The line must contain -XX:-UseBASE64Intrinsics:

    $ for w in deployment/console-service deployment/console-authentication-service deployment/console-gateway-service deployment/console-control-panel deployment/console-dashboards statefulset/viewer-neo4j-core statefulset/console-analysis-node-core; do echo "$w: $(kubectl logs -n castimaging-v3 $w | grep -m1 'Picked up JAVA_TOOL_OPTIONS')"; done
    $ kubectl get deployment console-sso-service -n castimaging-v3 -o jsonpath='{.spec.template.spec.containers[0].env[?(@.name=="JAVA_OPTS_APPEND")].value}'
    

Microsoft Windows

  1. Create the JDK_JAVA_OPTIONS system environment variable with the value -XX:-UseBASE64Intrinsics, either in System Properties > Environment Variables > System variables, or from a command prompt run as administrator:

    setx /M JDK_JAVA_OPTIONS "-XX:-UseBASE64Intrinsics"
    

    If the variable already exists, keep its existing value and add the option at the end, separated by a space.

  2. Restart the machine. Microsoft Windows services only take new system environment variables into account after a restart.

  3. Check that the setting is active: the log files of the CAST Imaging services contain the line NOTE: Picked up JDK_JAVA_OPTIONS: -XX:-UseBASE64Intrinsics after the restart.

You can also update the Java JDK referenced by %JAVA_HOME% to a release that includes the fix, as listed in What is Java4Shell?, within the Java releases supported by CAST Imaging (see Software requirements).

Your Solution Architect or CAST Professional Services can help you apply the mitigation.