Java4Shell - remote code execution in the Java runtime
Overview
Java4Shell is the name given to CVE-2026-114938 , 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:
- 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.
- Check that only the ports your users need are reachable, as explained in Step 2.
- 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.
-
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-servicecontainer usesJAVA_OPTS_APPEND, which is the variable Keycloak reads for additional Java options. -
In
/opt/cast/installation/imaging-node/docker-compose.override.yml, add:services: nodev3: environment: JAVA_TOOL_OPTIONS: "-XX:-UseBASE64Intrinsics" -
In
/opt/cast/installation/imaging-dashboards/docker-compose.override.yml, add:services: dashboards: environment: JAVA_TOOL_OPTIONS: "-XX:-UseBASE64Intrinsics" -
In
/opt/cast/installation/imaging-viewer/docker-compose.override.yml, add:services: neo4j: environment: JAVA_TOOL_OPTIONS: "-XX:-UseBASE64Intrinsics" -
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 -dIf the components are installed on separate machines, apply the steps for each component on the machine where it is installed.
-
Check that the setting is active. Each of the
console,auth-service,gateway,control-panel,analysis-node,dashboardsandneo4jcontainers 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:-UseBASE64IntrinsicsFor the
sso-servicecontainer, 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.
-
For the dashboards, set
DashboardsJavaToolOptionsin thevalues.yamlfile 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) orhelm-upgrade.bat(Microsoft Windows) from the same folder. Do this first: a Helm upgrade can reset the settings added withkubectlin the next steps. -
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 -
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:-UseBASE64IntrinsicsIf analysis node autoscaling is enabled (
AnalysisNodeAutoscaling.enabled: true), the analysis node is an OpenKruise statefulset, whichkubectl set envdoes not support. Edit it instead:$ kubectl edit statefulsets.apps.kruise.io console-analysis-node-core -n castimaging-v3In the
envlist of the container, add the following entry, or if aJAVA_TOOL_OPTIONSentry already exists, add-XX:-UseBASE64Intrinsicsat the end of its value:- name: JAVA_TOOL_OPTIONS value: "-XX:-UseBASE64Intrinsics" -
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}'
Running helm-upgrade.sh or helm-upgrade.bat can reset the settings added with kubectl in steps 2 and 3. Run these steps again, then the check in step 4, after each Helm upgrade until you install the CAST Imaging release with fixed Java runtimes.
Microsoft Windows
-
Create the
JDK_JAVA_OPTIONSsystem 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.
-
Restart the machine. Microsoft Windows services only take new system environment variables into account after a restart.
-
Check that the setting is active: the log files of the CAST Imaging services contain the line
NOTE: Picked up JDK_JAVA_OPTIONS: -XX:-UseBASE64Intrinsicsafter the restart.
Use JDK_JAVA_OPTIONS on Microsoft Windows, not JAVA_TOOL_OPTIONS. The variable applies to every Java application on the machine. Java 17 and later apply JDK_JAVA_OPTIONS, while Java 8, which is not affected by Java4Shell, ignores it. Java 8 does not know the -XX:-UseBASE64Intrinsics option and refuses to start when it receives it through JAVA_TOOL_OPTIONS: this would stop analyses with CAST Imaging Core releases before 8.4.10, which embed Java 8, and any other Java 8 application on the machine.
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.