Java vulnerability CVE-2026-114938 ("Java4Shell"): check and mitigation for on-premises installations

On 17 Nov 2026 a vulnerability in Java's Base64 decoder was published. It affects Java 17.0.6 and newer, 21 and 25. It can only be exploited on x86-64 processors with the AVX-512 VBMI instruction set extension (for example Intel Xeon "Ice Lake" or newer, AMD "Zen 4" or newer). ARM systems are not affected. On virtual machines, what counts is the processor the hypervisor passes to the VM.

This guide applies to installations you operate yourself. Each section stands on its own: read only the sections for the FTAPI products you use. Based on our checks, the FTAPI Cloud and the IEE gateways operated by FTAPI are not exploitable; no action is needed there.

The mitigation is a temporary measure: it switches off hardware-accelerated Base64 decoding. The application works and behaves the same. We will inform you as soon as fixed versions are available; then remove the mitigation again.

Is a server affected?

The check is the same for all products: what decides is whether the server's processor exposes AVX-512 VBMI. Check every server, and every node of a cluster.

Linux (shell):

uname -m
grep -cw avx512vbmi /proc/cpuinfo

Affected if the first line is x86_64 and the second is greater than 0.

Windows (PowerShell), with a Java runtime on the server, for example the one bundled with SecuTransfer:

& "<installation directory>\ftapi-server\jre\windows\bin\java.exe" -Xlog:os+cpu -version 2>&1 | Select-String 'avx512_vbmi(?!2)'

Affected if a line is printed. No output: not affected.

Note: the Java setting UseBASE64Intrinsics (for example from java -XX:+PrintFlagsFinal -version) is true on almost every server and on its own does not mean a server is affected. What decides is AVX-512 VBMI.

SecuTransfer

The mitigation sets the environment variable JAVA_TOOL_OPTIONS for the SecuTransfer service. The service has to be restarted once; SecuTransfer is briefly unavailable during the restart. Applies to version 4.48 or later.

Linux (systemd)

  1. As root, add the drop-in file and restart the service (shell):
mkdir -p /etc/systemd/system/ftapi.service.d
cat > /etc/systemd/system/ftapi.service.d/cve-2026-114938.conf <<'EOF'
[Service]
Environment="JAVA_TOOL_OPTIONS=-XX:-UseBASE64Intrinsics"
EOF
systemctl daemon-reload
systemctl restart ftapi
  1. Check that the mitigation is active (shell). Expected output: Picked up JAVA_TOOL_OPTIONS: -XX:-UseBASE64Intrinsics
journalctl -u ftapi --since "10 minutes ago" --no-pager | grep "Picked up JAVA_TOOL_OPTIONS"

The file is outside the installation directory and survives SecuTransfer updates.

Remove it after updating to a fixed version (shell, as root):

rm /etc/systemd/system/ftapi.service.d/cve-2026-114938.conf
systemctl daemon-reload
systemctl restart ftapi

Windows (service "FTAPI Server")

  1. Back up the file <installation directory>\ftapi-server\ftapi-server.xml.
  2. In that file, add below the existing <env ... /> lines (XML):
<env name="JAVA_TOOL_OPTIONS" value="-XX:-UseBASE64Intrinsics"/>
  1. Restart the service (PowerShell as administrator):
Restart-Service -Name FTAPI
  1. Check that the mitigation is active (PowerShell). Expected output: a line with Picked up JAVA_TOOL_OPTIONS: -XX:-UseBASE64Intrinsics
Select-String -Path "<installation directory>\ftapi-server\service-logs\ftapi-server.err.log" -Pattern "Picked up JAVA_TOOL_OPTIONS"

Important: a SecuTransfer update that replaces the ftapi-server folder resets ftapi-server.xml. After every update, check that the line is still there, until you have installed a version with a fixed Java runtime.

Remove it after updating to a fixed version: delete the <env name="JAVA_TOOL_OPTIONS" .../> line and restart the service.

Docker

  1. Set the environment variable JAVA_EXTRA_OPTS=-XX:-UseBASE64Intrinsics on the SecuTransfer container (for example in your compose or env file) and recreate the container.
  2. Check that the mitigation is active (shell on the Docker host). Expected output: -XX:-UseBASE64Intrinsics
docker top <container> | grep -o -- -XX:-UseBASE64Intrinsics

Remove it after updating to a fixed version: remove JAVA_EXTRA_OPTS again and recreate the container.

Versions before 4.48 use a different start mechanism. Please contact our support.

IEE gateway (CipherMail)

The mitigation follows the CipherMail advisory. It adds a systemd drop-in file for each CipherMail back-end service; other Java programs on the gateway are not changed.

  1. As root, add the drop-in files (shell):
for s in ciphermail-backend ciphermail-portal-backend ciphermail-company-portal-backend; do
systemctl cat "$s" >/dev/null 2>&1 || continue
mkdir -p /etc/systemd/system/$s.service.d
printf '[Service]\nEnvironment=JAVA_TOOL_OPTIONS=-XX:-UseBASE64Intrinsics\n' \
> /etc/systemd/system/$s.service.d/base64-intrinsics.conf
done
systemctl daemon-reload
  1. Restart the running services (shell, as root). Services that are stopped on your gateway stay stopped. Email that arrives during the restart is queued by Postfix and delivered afterwards. On a cluster, do one node at a time.
for s in ciphermail-backend ciphermail-portal-backend ciphermail-company-portal-backend; do
systemctl cat "$s" >/dev/null 2>&1 && systemctl try-restart "$s"
done
  1. Check that the mitigation is active (shell). Expected last line: Picked up JAVA_TOOL_OPTIONS: -XX:-UseBASE64Intrinsics. Repeat for the other services you restarted.
journalctl -u ciphermail-backend -b | grep "Picked up JAVA_TOOL_OPTIONS"

The drop-in file stays in place when the CipherMail playbook is run again.

Process Client

Until a ProcessClient release with a patched Java runtime is available, set this one environment variable for the ProcessClient:

JDK_JAVA_OPTIONS=-XX:-UseBASE64Intrinsics

It switches off only the faulty hardware acceleration. Java then uses its regular Base64 implementation, and the ProcessClient works exactly as before.

Is the ProcessClient affected?

Your ProcessClient is affected if both apply:

  • It runs on an affected Java version. All current ProcessClient versions do. The service installation (Windows and Linux) ships Java 21.0.12.1, and the Docker image ftapi/process-client uses Java 21.0.13. Affected are Java 17.0.6 up to 17.0.21 and every Java 21 release up to 21.0.13.
  • The machine has an x86-64 CPU with AVX-512 VBMI. These are Intel Xeon Ice Lake, Sapphire Rapids, Emerald Rapids and Granite Rapids, and AMD EPYC/Ryzen Zen 4 or newer. ARM machines are not affected.

A single Java command shows both the Java version and the CPU features. Run it with the Java runtime the ProcessClient uses. Replace <PROCESSCLIENT> with the installation folder and <CONTAINER> with the container name.

Linux service (shell):

<PROCESSCLIENT>/jre/linux/bin/java -Xlog:os+cpu -version 2>&1 | grep -E 'version|CPU:'

Windows service (PowerShell):

& "<PROCESSCLIENT>\jre\windows\bin\java.exe" -Xlog:os+cpu -version 2>&1 | Select-String 'version|CPU:'

Docker (shell on the Docker host):

docker exec <CONTAINER> java -Xlog:os+cpu -version 2>&1 | grep -E 'version|CPU:'

You see

Meaning

openjdk version "21.0.12.1", or any other version in the affected range above

The Java runtime is affected.

avx512_vbmi in the line containing CPU:

The vulnerable code is used on this machine: apply the stopgap now.

No avx512_vbmi in the line containing CPU:

The vulnerable code is not used on this hardware right now.

Linux service

  1. Open an override for the service (shell):
sudo systemctl edit FTAPIProcesses
  1. Add these lines in the editor, then save:
[Service]
Environment="JDK_JAVA_OPTIONS=-XX:-UseBASE64Intrinsics"
  1. Restart the service (shell):
sudo systemctl restart FTAPIProcesses

The setting is stored in a separate override file under /etc/systemd/system/FTAPIProcesses.service.d/. The service file itself stays unchanged, and the setting survives updates of the ProcessClient.

To make the change without an editor, for example for scripted rollouts (shell):

sudo mkdir -p /etc/systemd/system/FTAPIProcesses.service.d
printf '[Service]\nEnvironment="JDK_JAVA_OPTIONS=-XX:-UseBASE64Intrinsics"\n' \
| sudo tee /etc/systemd/system/FTAPIProcesses.service.d/cve-2026-114938.conf
sudo systemctl daemon-reload
sudo systemctl restart FTAPIProcesses

Check: after the restart, the service log contains a line confirming that Java picked up the setting (shell):

sudo journalctl -u FTAPIProcesses --since "10 min ago" | grep "Picked up JDK_JAVA_OPTIONS"
# NOTE: Picked up JDK_JAVA_OPTIONS: -XX:-UseBASE64Intrinsics

Windows service

  1. Open <PROCESSCLIENT>\windows\ProcessClientWindowsService.xml in a text editor started as administrator.
  2. Add this line directly below the <arguments>…</arguments> line. Leave the <arguments> line itself unchanged (XML):
<env name="JDK_JAVA_OPTIONS" value="-XX:-UseBASE64Intrinsics"/>
  1. Restart the service, either in PowerShell as administrator or from the Services console (services.msc):
Restart-Service FTAPIProcesses

Check: after the restart, the service log contains a line confirming that Java picked up the setting (PowerShell):

Select-String -Path "<PROCESSCLIENT>\log\*.log" -Pattern "Picked up JDK_JAVA_OPTIONS"
# ... NOTE: Picked up JDK_JAVA_OPTIONS: -XX:-UseBASE64Intrinsics

Note for updates: a ProcessClient update replaces the whole installation folder, including this XML file, and the setting is lost. If the new version still ships an affected Java runtime (check as above), add the line again.

Docker

Set the variable in the container definition, then re-create the container. Restarting the container is not enough, because environment variables are fixed when the container is created.

docker compose: add the variable to the ProcessClient service (YAML):

services:
processclient:
image: ftapi/process-client:latest
environment:
- JDK_JAVA_OPTIONS=-XX:-UseBASE64Intrinsics
# ... your existing settings

Then re-create the container from the folder that contains the compose file (shell):

docker compose up -d

docker run: add -e JDK_JAVA_OPTIONS=-XX:-UseBASE64Intrinsics to your command. Then remove the old container and start a new one (shell):

docker stop <CONTAINER> && docker rm <CONTAINER>
docker run -d --name <CONTAINER> -e JDK_JAVA_OPTIONS=-XX:-UseBASE64Intrinsics <your other options> ftapi/process-client:latest

Kubernetes: add the variable to the container spec (env: with name: JDK_JAVA_OPTIONS, value: "-XX:-UseBASE64Intrinsics") and roll out the deployment.

Check (shell):

docker exec <CONTAINER> java -XX:+PrintFlagsFinal -version 2>/dev/null | grep UseBASE64Intrinsics
# bool UseBASE64Intrinsics = false {product} {command line}

= false means the stopgap is active. If the line ends in = true ... {default}, the variable is not set in the container.

If JDK_JAVA_OPTIONS is already set

Your setup may already set JDK_JAVA_OPTIONS, for example in an existing systemd override, an <env> line in the Windows XML, or the container definition. In that case, don't add a second entry. Add the option to the existing value, separated by a space:

JDK_JAVA_OPTIONS=-Xmx2g -XX:-UseBASE64Intrinsics

After updating to a patched release

Once a ProcessClient release with a patched Java runtime is available, update as described in the update guide. For a service installation, that means replacing the whole installation folder, including jre/. For Docker, pull the new image and re-create the container.

After that, the stopgap is no longer needed. Leaving it in place does no harm. To remove it:

  • Linux: run sudo systemctl edit FTAPIProcesses and delete the two lines, or delete the cve-2026-114938.conf file and run sudo systemctl daemon-reload. Then restart the service.
  • Windows: delete the <env name="JDK_JAVA_OPTIONS" …/> line and restart the service. After a full update, it is already gone with the old XML file.
  • Docker: remove the variable from the container definition and re-create the container.