---
title: "Java security update"
description: "Learn how to check whether Opsview is affected by CVE-2026-114938 (Java4Shell), update Java on each supported operating system, or apply the interim mitigation."
url: "https://docs.itrsgroup.com/docs/all/opsview/java-security-update/index.html"
---

**Opsview Cloud**


On Opsview Cloud, ITRS manages and updates the Orchestrator, so no action is required for the Opsview Reporting Module.

The only exception is if you use `check_jmx` or your own custom uploaded Java plugins on your own Collectors. In that case, you must still carry out the plugin-related checks and remediation below on each of your Collectors that uses Java. If you are unsure whether you use `check_jmx` or your own custom uploaded Java plugins, contact ITRS Support for assistance, as the detection steps require access to the Orchestrator.



ITRS has reviewed a recently disclosed vulnerability in Java, **CVE-2026-114938**, also known as Java4Shell. The vulnerability is in the hardware-accelerated Base64 decoding that Java uses on x86_64 (64-bit Intel and AMD) processors that support AVX-512 VBMI instructions. Base64 is a common way of encoding data as text. Specially crafted data could let a malicious party run code on the host. For more information, see the [CVE record](https://www.cve.org/CVERecord?id=CVE-2026-114938) and the [Red Hat security bulletin RHSB-2026-018](https://access.redhat.com/security/vulnerabilities/RHSB-2026-018).


**Note**


Opsview does not include its own Java packages. The operating system installs and updates Java. Only the Reporting Module and Java-based plugins such as `check_jmx` use Java.



The following Java versions are affected:

- Java 17.0.6 up to, but not including, 17.0.21.1
- Java 21.0.0 up to, but not including, 21.0.13.1
- Java 25.0.0 up to, but not including, 25.0.5.1
- Oracle Java SE 8 Enterprise Performance Pack up to and including 8u511-perf (fixed in 8u513-perf)
- Short-term Java releases 18 to 20, 22 to 24, 26 and 27

Java 8 (except the Oracle Enterprise Performance Pack build) and Java 11 are not affected.

## How Opsview is affected

Opsview is affected only if all of the following are true:

- A component that uses Java is in use. This is either the Reporting Module, or the `check_jmx` plugin or another custom uploaded Java plugin used in a Service Check.
- That component runs on an affected Java version.
- The host has an x86_64 processor with AVX-512 VBMI support. ARM (`aarch64`) hosts are not affected.

Opsview uses the Java version provided by the operating system on the orchestrator:

| Operating system           | Default Java | Status                   |
| -------------------------- | ------------ | ------------------------ |
| RHEL and Oracle Linux 8    | Java 8       | Not affected             |
| RHEL and Oracle Linux 9    | Java 17      | Potentially affected |
| Debian 12                  | Java 17      | Potentially affected |
| Ubuntu 22.04               | Java 8       | Not affected             |
| Ubuntu 20.04 (end of life) | Java 8       | Not affected             |
| Debian 10 (end of life)    | Java 11      | Not affected             |

If you have installed a different Java version from the default, check its version with the steps below.

If FIPS mode is enabled and you have installed a separate Java in `/opt/opsview/java` as described in the FIPS documentation, the Reporting Module uses that Java instead. Check its version with the steps below. The default FIPS instructions use Java 8, which is not affected.

The following are not affected or are not covered by this page:

- The Infrastructure Agent does not include Java, and its built-in plugins do not use Java.
- The **Application - Alfresco** Opspack runs `check_jmx` on monitored servers through a remote JNRPE agent, using `check_nrpe`. ITRS does not ship the JNRPE agent. If you use a JNRPE agent on a monitored server, follow the advisories from its vendor.


**Warning**


The Reporting Module is not compatible with Java 22 or later. The included `aspectjweaver-1.8.9.jar` file fails the stricter ZIP checks in newer Java versions, and the Reports page returns a 404 error. `/opt/opsview/jasper/apache-tomcat/logs/catalina.out` shows the following error:

```
java.util.zip.ZipException: Invalid CEN header (invalid zip64 extra data field size)
```

Use the default Java version for your operating system or FIPS, as listed above, rather than a newer Java version.



## Check whether you are affected

### Reporting Module

Run these steps on the Orchestrator, or on the host that runs the Reporting Module.

1. Check whether the Reporting Module is installed:

   ```
   dpkg -l opsview-jasper 2>/dev/null | grep ^ii || rpm -q opsview-jasper
   ```

   If no package is listed, the Reporting Module is not installed and is not affected.

2. Check which Java the running Reporting Module uses:

   ```
   JAVA=$(sudo readlink -f /proc/$(sudo pgrep -of org.apache.catalina.startup.Bootstrap)/exe)
   echo "$JAVA"; "$JAVA" -version
   ```

   If the Reporting Module is not running, it uses the first existing directory listed in `/opt/opsview/jasper/etc/java_homes`. Run `<directory>/bin/java -version` for that directory.

3. Check whether the processor is x86_64 with AVX-512 VBMI support:

   ```
   uname -m; grep -qw avx512vbmi /proc/cpuinfo && echo "AVX-512 VBMI: YES" || echo "AVX-512 VBMI: no"
   ```

Use the results to decide what to do:

- **Vulnerable now** — The Reporting Module is installed, its Java version is affected, and the host is `x86_64` with AVX-512 VBMI. [Update Java](#update-java) for your operating system. If you cannot update Java yet, apply the [interim mitigation](#apply-the-interim-mitigation-if-you-cannot-update-java).
- **Update Java when you can** — The Reporting Module is installed and its Java version is affected, but the host does not have AVX-512 VBMI. The host cannot be exploited today, but a virtual machine can be moved to a newer processor. [Update Java](#update-java) during your next maintenance window.
- **Not affected** — The Reporting Module is not installed, its Java version is not affected, or the host is `aarch64`. No action is required.

### check_jmx and other Java plugins

These steps check whether the `check_jmx` plugin shipped with Opsview is used directly in a custom Service Check or Host Check Command. If you have uploaded your own custom Java plugins, replace `check_jmx` with the name of your plugin. By default, Java is not installed on Collectors, so this also assumes you have manually installed Java to run the plugin(s).

1. On the Orchestrator, confirm that you can connect to the `opsview` database. The following command must print `connected`:

   ```
   sudo /opt/opsview/coreutils/utils/cx -C /root/.cx_creds opsview "SELECT 'connected' AS DB"
   ```

   If `cx` does not work, run the queries below with the `mysql` client and the connection details for your `opsview` database instead.

2. List the configured Opsview Hosts that use the plugin:

   ```
   PLUGIN="check_jmx"

   # configured Opsview Hosts with the Service Check assigned directly
   sudo /opt/opsview/coreutils/utils/cx -C /root/.cx_creds opsview "SELECT '$PLUGIN' AS plugin, h.name AS host, mc.name AS cluster, s.name AS servicecheck FROM hostservicechecks hs JOIN servicechecks s ON s.id = hs.servicecheckid JOIN hosts h ON h.id = hs.hostid LEFT JOIN monitoringclusters mc ON mc.id = h.monitored_by WHERE s.plugin = '$PLUGIN' AND hs.remove_servicecheck = 0 ORDER BY 2, 1"

   # configured Opsview Hosts that get the Service Check through a Host Template, excluding Opsview Hosts where it was removed
   sudo /opt/opsview/coreutils/utils/cx -C /root/.cx_creds opsview "SELECT '$PLUGIN' AS plugin, h.name AS host, mc.name AS cluster, s.name AS servicecheck, ht.name AS template FROM hosttemplateservicechecks hts JOIN servicechecks s ON s.id = hts.servicecheckid JOIN hosttemplates ht ON ht.id = hts.hosttemplateid JOIN hosthosttemplates hht ON hht.hosttemplateid = ht.id JOIN hosts h ON h.id = hht.hostid LEFT JOIN monitoringclusters mc ON mc.id = h.monitored_by WHERE s.plugin = '$PLUGIN' AND NOT EXISTS (SELECT 1 FROM hostservicechecks r WHERE r.hostid = h.id AND r.servicecheckid = s.id AND r.remove_servicecheck = 1) ORDER BY 2, 1"

   # configured Opsview Hosts whose Host Check Command uses the plugin
   sudo /opt/opsview/coreutils/utils/cx -C /root/.cx_creds opsview "SELECT '$PLUGIN' AS plugin, h.name AS host, mc.name AS cluster, hc.name AS hostcheckcommand FROM hosts h JOIN hostcheckcommands hc ON hc.id = h.check_command LEFT JOIN monitoringclusters mc ON mc.id = h.monitored_by WHERE hc.plugin = '$PLUGIN' ORDER BY 2, 1"
   ```

   If no rows are returned, the plugin is not in use and no further action is required.

3. If rows are returned, check which Java the Executor uses on each Collector in each cluster listed:

   ```
   PID=$(sudo pgrep -of executorlauncher)
   EXEC_PATH=$(sudo cat /proc/$PID/environ | tr '\0' '\n' | sed -n 's/^PATH=//p')
   [ -n "$EXEC_PATH" ] || echo "Could not read executor PATH"
   sudo -u opsview env PATH="$EXEC_PATH" bash -c 'J=$(command -v java) || { echo "no java on PATH"; exit 1; }; readlink -f "$J"; "$J" -version'
   ```

4. On the same Collector, check whether the processor is x86_64 with AVX-512 VBMI support:

   ```
   uname -m; grep -qw avx512vbmi /proc/cpuinfo && echo "AVX-512 VBMI: YES" || echo "AVX-512 VBMI: no"
   ```

Use the results to decide what to do for each Collector:

- **Vulnerable now** — A configured Opsview Host monitored by the Collector uses `check_jmx` or another custom uploaded Java plugin, the Collector is running Java, the Collector's Java version is affected, and the Collector is `x86_64` with AVX-512 VBMI. [Update Java](#update-java) for your operating system. If you cannot update Java yet, apply the [interim mitigation](#apply-the-interim-mitigation-if-you-cannot-update-java).
- **Update Java when you can** — A configured Opsview Host monitored by the Collector uses `check_jmx` or another custom uploaded Java plugin, the Collector is running Java, and the Collector's Java version is affected, but the Collector does not have AVX-512 VBMI. The Collector cannot be exploited today, but a virtual machine can be moved to a newer processor. [Update Java](#update-java) during your next maintenance window.
- **Not affected** — No configured Opsview Hosts use `check_jmx` or another custom uploaded Java plugin, Java is not installed on the Collector, the Collector's Java version is not affected, or the Collector is `aarch64`. No action is required.

## Update Java

Updating Java to a fixed version resolves the vulnerability. Re-running `opsview-deploy` does not update Java, so use your normal operating system package update process.


**Warning**


Updating Java and restarting the Reporting Module or Executor causes a short outage of that component. Carry out these steps during a planned maintenance window.



1. Make sure a backup is available before you change the system.
2. Update the Java packages to the fixed version for your operating system:

   | Operating system | Fixed packages |
   | --- | --- |
   | RHEL 8 | `java-17-openjdk` **17.0.21.1.2-2.1.el8** ([RHSA-2026:100563](https://access.redhat.com/errata/RHSA-2026:100563)), `java-21-openjdk` **21.0.13.1.2-1.1.el8** ([RHSA-2026:100567](https://access.redhat.com/errata/RHSA-2026:100567)) |
   | RHEL 9.7 or later | `java-17-openjdk` **17.0.21.1.2-2.2.el9** ([RHSA-2026:100564](https://access.redhat.com/errata/RHSA-2026:100564)), `java-21-openjdk` **21.0.13.1.2-1.2.el9** ([RHSA-2026:100567](https://access.redhat.com/errata/RHSA-2026:100567)) |
   | RHEL 9.6 | `java-17-openjdk` **17.0.21.1.2-2.1.el9** ([RHSA-2026:100564](https://access.redhat.com/errata/RHSA-2026:100564)), `java-21-openjdk` **21.0.13.1.2-1.1.el9** ([RHSA-2026:100567](https://access.redhat.com/errata/RHSA-2026:100567)), available only through Red Hat extended support channels |
   | Oracle Linux 8 | `java-17-openjdk` **17.0.21.1.2-2.1.0.1.el8** ([ELSA-2026-100563](https://linux.oracle.com/errata/ELSA-2026-100563.html)), `java-21-openjdk` **21.0.13.1.2-1.1.0.1.el8** ([ELSA-2026-100567](https://linux.oracle.com/errata/ELSA-2026-100567.html)) |
   | Oracle Linux 9 | `java-17-openjdk` **17.0.21.1.2-2.2.0.1.el9** ([ELSA-2026-100564](https://linux.oracle.com/errata/ELSA-2026-100564.html)), `java-21-openjdk` **21.0.13.1.2-1.2.0.1.el9** ([ELSA-2026-100567](https://linux.oracle.com/errata/ELSA-2026-100567.html)) |
   | Debian 12 | `openjdk-17` **17.0.21.1+2-1~deb12u1** ([DLA-4917-1](https://security-tracker.debian.org/tracker/DLA-4917-1)) |
   | Ubuntu 22.04 | `openjdk-17` **17.0.21.1+2-1~22.04.1** ([USN-9155-1](https://ubuntu.com/security/notices/USN-9155-1)), `openjdk-21` **21.0.13.1+2-1~22.04.1** ([USN-9156-1](https://ubuntu.com/security/notices/USN-9156-1)) |
   | Ubuntu 20.04 (end of life) | `openjdk-17` **17.0.21.1+2-1~20.04.1** ([USN-9155-1](https://ubuntu.com/security/notices/USN-9155-1)), available only through Ubuntu Pro (ESM) |
   | Debian 10 (end of life) | No fix available. Use the [interim mitigation](#apply-the-interim-mitigation-if-you-cannot-update-java) if affected. |

3. Restart the components that use Java so that they load the updated version. On the Orchestrator, or the host that runs the Reporting Module:

   ```
   sudo /opt/opsview/watchdog/bin/opsview-monit restart opsview-reportingmodule
   ```

   On each Collector that uses `check_jmx` or other Java plugins:

   ```
   sudo /opt/opsview/watchdog/bin/opsview-monit restart opsview-executor
   ```

4. Repeat the steps in [Check whether you are affected](#check-whether-you-are-affected) to confirm that the fixed Java version is in use.

If you use a short-term Java release, such as Java 18 to 20, change to a fixed long-term release that your operating system and the Reporting Module support (Java 21 or earlier).

### Java installed outside the operating system packages

Operating system updates do not update Java that you installed manually, for example in `/opt/opsview/java` for FIPS compatibility. Replace it yourself with a fixed OpenJDK build at a supported version, then restart the Reporting Module.

Opsview never installs the Oracle Java SE 8 Enterprise Performance Pack. If `java -version` shows `Java(TM) SE` with a `-perf` build, update it to 8u513-perf or later. For more information, see the [Oracle 8u513-perf release notes](https://www.oracle.com/java/technologies/javase/8u513-perf-relnotes.html).

## Apply the interim mitigation if you cannot update Java

If you cannot update Java yet, turn off hardware-accelerated Base64 decoding in Java. This is the interim mitigation recommended in the [Red Hat security bulletin RHSB-2026-018](https://access.redhat.com/security/vulnerabilities/RHSB-2026-018). It adds two Java options:

- `-XX:-UseBASE64Intrinsics` turns off the vulnerable code.
- `-XX:+IgnoreUnrecognizedVMOptions` lets Java versions that do not recognize the first option, such as Java 8, start normally.


**Warning**


Always add both options. If you add `-XX:-UseBASE64Intrinsics` without `-XX:+IgnoreUnrecognizedVMOptions`, Java 8 refuses to start and the Reporting Module stops working.



These changes remain in place until the next Opsview upgrade or package reinstall. Update Java as soon as a fixed version is available for your operating system.

### Reporting Module

If the Reporting Module is installed, carry out these steps on the Orchestrator, or on the host that runs the Reporting Module:

1. Add the Java options to the Reporting Module start script:

   ```
   sudo grep -q IgnoreUnrecognizedVMOptions /opt/opsview/jasper/bin/rc.jasperserver || \
     sudo sed -i 's|-Djava.awt.headless=true\( -XX:-UseBASE64Intrinsics\)\?|-Djava.awt.headless=true -XX:+IgnoreUnrecognizedVMOptions -XX:-UseBASE64Intrinsics|g' /opt/opsview/jasper/bin/rc.jasperserver
   ```

2. Confirm that both lines that contain `headless` now include both options:

   ```
   sudo grep -n 'headless' /opt/opsview/jasper/bin/rc.jasperserver
   ```

3. Restart the Reporting Module:

   ```
   sudo /opt/opsview/watchdog/bin/opsview-monit restart opsview-reportingmodule
   ```

4. Wait 30 seconds, then confirm that the running Reporting Module has the option. The following command must print `-XX:-UseBASE64Intrinsics`:

   ```
   sleep 30
   sudo pgrep -o -u opsview -af 'java.*/opt/opsview/jasper' | grep -o -- '-XX:-UseBASE64Intrinsics' || echo "option NOT active"
   ```

   If it prints `option NOT active`, check `/opt/opsview/jasper/apache-tomcat/logs/catalina.out` for errors.

5. Compare the default setting for this Java and processor with the setting when the options are used. With the options, the value must be `false`. On Java 8, the option is not recognized, which is expected:

   ```
   JAVA=$(sudo readlink -f /proc/$(sudo pgrep -of org.apache.catalina.startup.Bootstrap)/exe)
   echo "default:      $(sudo -u opsview "$JAVA" -XX:+PrintFlagsFinal -version 2>/dev/null | grep -F UseBASE64Intrinsics || echo 'not recognized (expected on Java 8)')"
   echo "with options: $(sudo -u opsview "$JAVA" -XX:+IgnoreUnrecognizedVMOptions -XX:-UseBASE64Intrinsics -XX:+PrintFlagsFinal -version 2>/dev/null | grep -F UseBASE64Intrinsics || echo 'not recognized (expected on Java 8)')"
   ```

   On processors without AVX-512 VBMI, Java may already report `false` without the options.

6. Confirm that the Reporting Module is working.

### check_jmx

If custom Service Checks or Host Check Commands use `check_jmx`, carry out these steps on each Collector in the clusters that use it. The steps update the installed plugin, the copy that Opsview restores when you Apply Changes, and the stored **Application - Alfresco** Opspack that contains `check_jmx`. This means that running `opsview-deploy` does not overwrite the change.

1. Add the Java options to both installed copies of the plugin:

   ```
   sudo sed -i 's|^java -jar |java -XX:+IgnoreUnrecognizedVMOptions -XX:-UseBASE64Intrinsics -jar |' /opt/opsview/monitoringscripts/builtin/plugins/check_jmx
   sudo sed -i 's|^java -jar |java -XX:+IgnoreUnrecognizedVMOptions -XX:-UseBASE64Intrinsics -jar |' /opt/opsview/monitoringscripts/plugins/check_jmx
   ```

2. Confirm that both copies include the options:

   ```
   sudo grep -n 'jmxquery.jar' /opt/opsview/monitoringscripts/builtin/plugins/check_jmx
   sudo grep -n 'jmxquery.jar' /opt/opsview/monitoringscripts/plugins/check_jmx
   ```

3. Add the same change to the stored Opspack:

   ```
   T=/opt/opsview/monitoringscripts/opspacks/application-alfresco.tar.gz
   W=$(sudo mktemp -d)
   sudo tar -C "$W" -xzf "$T"
   P="$W/application-alfresco/plugins/check_jmx"
   sudo grep -q IgnoreUnrecognizedVMOptions "$P" || \
     sudo sed -i 's|^java -jar |java -XX:+IgnoreUnrecognizedVMOptions -XX:-UseBASE64Intrinsics -jar |' "$P"
   sudo tar -C "$W" -czf "$W/new.tar.gz" application-alfresco
   sudo cp "$W/new.tar.gz" "$T"
   sudo rm -r "$W"
   ```

   Copying over the existing file keeps its owner and permissions.

4. Confirm that the stored Opspack includes the options:

   ```
   sudo tar -xzOf /opt/opsview/monitoringscripts/opspacks/application-alfresco.tar.gz application-alfresco/plugins/check_jmx | grep -n 'jmxquery.jar'
   ```

5. Restart the Executor:

   ```
   sudo /opt/opsview/watchdog/bin/opsview-monit restart opsview-executor
   ```

6. Wait 30 seconds, then confirm that the Executor's Java accepts the options. With the options, the value must be `false`. On Java 8, the option is not recognized, which is expected:

   ```
   sleep 30
   PID=$(sudo pgrep -of executorlauncher)
   EXEC_PATH=$(sudo cat /proc/$PID/environ | tr '\0' '\n' | sed -n 's/^PATH=//p')
   OPTS=$(sudo sed -n 's/^java \(.*\)-jar .*/\1/p' /opt/opsview/monitoringscripts/plugins/check_jmx)
   [ -n "$OPTS" ] || echo "check_jmx does not include the options"
   echo "check_jmx options: $OPTS"
   sudo -u opsview env PATH="$EXEC_PATH" OPTS="$OPTS" bash -c '
   J=$(command -v java) || { echo "no java on PATH"; exit 1; }
   echo "default:      $("$J" -XX:+PrintFlagsFinal -version 2>/dev/null | grep -F UseBASE64Intrinsics || echo "not recognized (expected on Java 8)")"
   echo "with options: $("$J" $OPTS -XX:+PrintFlagsFinal -version 2>/dev/null | grep -F UseBASE64Intrinsics || echo "not recognized (expected on Java 8)")"'
   ```

### Other Java plugins

If you have uploaded your own custom Java plugins, add `-XX:+IgnoreUnrecognizedVMOptions -XX:-UseBASE64Intrinsics` to the `java` command in each plugin. Import the updated plugins using the UI, API, or CLI, then Apply Changes.


