Tech BlogNovember 18, 2026Sarah Kim107 views

Java Vulnerability Java4Shell (CVE-2026-114938): Scope and Patch

This document outlines the scope of impact (JDK 17, 21, 25, 27, AVX-512 CPU) and patch versions for the Java vulnerability Java4Shell (CVE-2026-114938). It also details the secure update procedure for JDK and OpenJDK, temporary mitigations before patching (JVM options, JAVA_TOOL_OPTIONS, cacerts certificate deletion), and a script for checking Java versions across an entire server.

#Java Version Verification#Java Runtime Vulnerability#Oracle CPU#Server Security#PowerShell Script#Linux Shell Script#Docker Security
Java Vulnerability Java4Shell (CVE-2026-114938): Scope and Patch
Sarah Kim

November 18, 2026

The most urgent Java vulnerability at present is Java4Shell (CVE-2026-114938). Systems utilizing OpenJDK 17, 21, 25, or 27 series on x86-64 CPUs supporting AVX-512 VBMI are affected and require an upgrade to the vendor's November patched build. The following sections detail how to identify affected systems, the patch (update) procedure, temporary mitigations before patching, and a script for server-wide checks.

While the java -version command is commonly used to verify the Java version on a single server, this command alone is insufficient for a comprehensive assessment of Java vulnerabilities across the entire system. It is necessary to identify all Java runtimes installed on the server, their respective vendors, and complete build information.

Java4Shell Vulnerability at a Glance

ItemDetails (As of 2026-11-18)
VulnerabilityJava4Shell, CVE-2026-114938 (OpenJDK Base64 Decoder Memory Corruption, Unauthenticated Remote Code Execution Possible)
SeverityCVSS 3.1 8.1 (Oracle·OpenJDK), CVSS 4.0 9.2 (Vulnerability Discloser's Assessment)
Affected SystemsUnpatched builds of JDK 17, 21, 25, 27 series + x86-64 CPUs supporting AVX-512 VBMI. Includes Oracle Java SE 8u511b33-perf.
Not AffectedARM64 (aarch64) servers, Java 8, 11 (excluding Oracle 8 perf builds)
Patch Versions (Oracle Java SE)17.0.21.1, 21.0.13.1, 25.0.5.1, 27.0.1.1 (KISA Advisory). OpenJDK-based distributions require vendor-specific patched builds.
Temporary Mitigations Before PatchingJVM options -XX:UseAVX=2 (x86-64 only) or -XX:-UseBASE64Intrinsics.
Related AlertseMudhra Certificates CVE-2026-91403, CVE-2026-114820 (cacerts Root Certificate Deletion)

Java Security Updates to Review (As of November 18, 2026)

Oracle has released four Java SE security updates within the last month. The version numbers below refer to Oracle Java SE, and the listed versions along with all earlier versions are affected. Other vendors release corresponding fixes in their own builds.

  • 2026-10-20 Quarterly Security Update (CPU): 55 Java SE security fixes. Affected versions include 8u503, 11.0.32.1, 17.0.20.1, 21.0.12.1, 25.0.4.1, 26.0.2, 27, and earlier versions (Oracle CPU October 2026).
  • 2026-10-21 Urgent Advisory CVE-2026-91403 (CVSS 9.1, JSSE): Private keys for eight intermediate CA certificates from the Certificate Authority eMudhra have been leaked. Affected versions include the October quarterly update builds 8u511, 11.0.33, 17.0.21, 21.0.13, 25.0.5, 27.0.1, and earlier versions (Oracle Advisory).
  • 2026-10-24 Urgent Advisory CVE-2026-114820 (CVSS 9.1, JSSE): This update involves the deletion of related root certificates from the trust store (cacerts). Affected versions include 21.0.13.0.2, 25.0.5.0.2, and earlier versions (Oracle Advisory).
  • 2026-11-17 Monthly Security Update (CSPU): 11 Java SE security fixes, all of which can be exploited remotely without authentication. The highest-scoring vulnerability is CVE-2026-114938 (CVSS 8.1, Compiler), known as Java4Shell. Affected versions include the October 24 builds 8u511b33, 11.0.33.0.3, 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3, 27.0.1.0.3, and earlier versions (Oracle CSPU November 2026).

In summary, runtimes updated in October still require action. According to the KISA Security Advisory, the resolving Oracle Java SE versions are 8u513, 11.0.33.1, 17.0.21.1, 21.0.13.1, 25.0.5.1, and 27.0.1.1. OpenJDK-based distributions (such as Eclipse Temurin, Amazon Corretto, Azul Zulu, Microsoft, Red Hat) should apply their respective vendor-specific patched versions. If immediate updates are not feasible, it is advised to remove the four root certificates (emSign Root CA - G1, emSign Root CA - G2, emSign ECC Root CA - G3, AAA Certificate Services) from cacerts as per Oracle's guidance (ops.java/emudhra). Practical steps for verification and deletion are available in the CVE-2026-91403 check article. Oracle now releases security patches on the third Tuesday of every month; the next release is scheduled for December 15, 2026 (CSPU), followed by the next quarterly update (CPU) on January 19, 2027.

Java4Shell Scope: Identifying Affected Java Versions and CPUs

Java4Shell is a memory corruption (heap-based buffer overflow) vulnerability in the OpenJDK Base64 decoder, disclosed on November 17, 2026 (US time). KISA has recommended a security update due to the potential for crafted Base64 input to lead to unauthenticated remote code execution. The vulnerability is rated CVSS 3.1 8.1 according to Oracle·OpenJDK advisories, and the discloser assessed it as CVSS 4.0 9.2 (OpenJDK Advisory).

Attack input can originate from any application input received as Base64, such as login credentials (HTTP Basic), SAML, or tokens. The discloser demonstrated unauthenticated remote code execution in default configurations of applications including Apache Kafka, Jenkins, Keycloak, and Spring Boot.

Systems are affected if both of the following conditions are met:

  1. JDK: Unpatched builds of JDK 17, 21, 25, 27 series (as per OpenJDK advisory; researchers have confirmed impact from OpenJDK 17.0.6 onwards). Oracle Java SE 8u511b33-perf is also affected.
  2. CPU: x86-64 CPU supporting AVX-512 VBMI. ARM64 (aarch64) servers are not affected.

The following commands can be used to verify these two conditions. A UseAVX value of 3 indicates that the JVM is utilizing AVX-512, and UseBASE64Intrinsics being true signifies that the problematic Base64 acceleration code is enabled.

# Windows: JVM configuration check
java -XX:+UnlockDiagnosticVMOptions -XX:+PrintFlagsFinal -version | findstr "UseAVX UseBASE64Intrinsics"
# Windows: Check if CPU supports AVX-512 VBMI (if any line appears, it supports it)
java -Xlog:os+cpu -version | findstr avx512_vbmi
# Linux: JVM configuration check
java -XX:+UnlockDiagnosticVMOptions -XX:+PrintFlagsFinal -version | grep -wE "UseAVX|UseBASE64Intrinsics"
# Linux: Check if CPU supports AVX-512 VBMI
grep -o -m1 avx512vbmi /proc/cpuinfo

For environments with multiple servers or bundled JDKs within products, the java-inventory script below should be utilized. This script indicates 'affected', 'not affected', or 'patched' in the java4shell column for each runtime and also specifies whether running JVMs are operating with temporary mitigation options.

Actions

  • Update: Upgrade to the vendor's patched build and restart services. For Oracle Java SE, these are 17.0.21.1, 21.0.13.1, 25.0.5.1, and 27.0.1.1 (KISA Advisory).
  • Temporary Mitigation When Immediate Update Is Not Possible: Add -XX:UseAVX=2 (usable only on x86-64 JVMs; ARM JVMs cannot start with this option) or -XX:-UseBASE64Intrinsics to the JVM startup options. Performance may be impacted, so prior testing in a staging environment is recommended. Temporary mitigations do not replace permanent updates. The location for applying these options and verification methods are detailed in the 'Responding to Java Vulnerabilities: Temporary Mitigations Before Patching' section below.
  • Compromise Status: Abnormal indicators during the exposure period prior to the update should be investigated separately.

Patching Java Vulnerabilities: JDK·OpenJDK Update Methods and Procedure

JDK updates extend beyond merely replacing files. Running JVMs continue to use the older runtime until restarted, and overwrite installations may delete custom certificates or configurations. The following procedure should be followed:

  1. Identify Targets and Prioritize: Select runtimes from the java-inventory results where java4shell indicates 'affected' or status indicates 'update needed'. Prioritize publicly exposed services and JVMs running without mitigations.
  2. Obtain Patched Build: Download the patched build from the official vendor source, ensuring it matches the current vendor and Java version (e.g., Temurin 21 for Temurin 21). Verify the file using checksums or signatures provided by the vendor. Changes in vendor or Java version should be handled as a separate task.
  3. Backup: Retain copies of the current JDK folder, cacerts, and configuration files containing JVM options (service units, setenv.sh, container definitions).
  4. Side-by-Side Installation and Path Adjustment: Install the new JDK in a separate folder and update only the paths pointed to by JAVA_HOME, symbolic links, or update-alternatives. In case of issues, rollback can be performed by reverting the paths. OpenJDK installed via OS packages should be updated using package managers such as apt or dnf.
  5. Migrate Internal Certificates: If internal certificates were manually added to the old cacerts, re-import them into the new JDK's cacerts using keytool -importcert. Avoid copying the old cacerts file entirely, as this could restore the eMudhra root certificates removed in this update.
  6. Test in Staging Environment First: Deploy the application with the new build in a test environment to verify functionality. Also, confirm that external HTTPS connections are normal, as the list of trusted certificates has changed.
  7. Restart and Verify: After restarting the service, re-run java-inventory to confirm that running_pids reflect the new path and that java4shell indicates 'patched'. A running JVM's version can be inspected using jcmd <PID> VM.version.
  8. Containers: Do not modify the JDK within a running container. Instead, rebuild and deploy with a base image that includes the patched build. As content may differ even with the same tag, verify with java -version in the new container.
  9. JDKs Bundled with Products: For JDKs embedded in WAS or solution products, follow the update procedures guided by the product vendor. Unauthorized modifications may lead to unsupported configurations.
  10. Remove Temporary Options: After upgrading to a patched build, remove the temporary JVM options listed below. This ensures that performance-degrading options are not retained.

Responding to Java Vulnerabilities: Temporary Mitigations Before Patching

This section describes methods to reduce exposure when immediate updates are not feasible due to restart schedules or testing requirements. Temporary mitigations do not replace updates; therefore, an upgrade to a patched build is still required after applying these measures.

Java4Shell Temporary Mitigations: JVM Options

  • -XX:UseAVX=2: Disables AVX-512 usage. This option is recognized only by x86-64 JVMs; ARM JVMs cannot start if this option is present.
  • -XX:-UseBASE64Intrinsics: Disables the problematic Base64 acceleration code.

Both options may increase CPU utilization and response times; therefore, prior testing in a staging environment is recommended. JVMs will not start if they encounter an unrecognized VM option, issuing an Unrecognized VM option error. If deploying the same configuration to both x86-64 and ARM servers, -XX:UseAVX=2 should only be applied to x86-64 servers. Options require a JVM restart to take effect.

Locations for JVM Options: JAVA_TOOL_OPTIONS, Tomcat, Docker

# Direct in startup command
java -XX:UseAVX=2 -jar app.jar
# Environment variable: applies to all JVMs started in that environment, prints "Picked up JAVA_TOOL_OPTIONS" on startup
export JAVA_TOOL_OPTIONS="-XX:UseAVX=2"
# Tomcat: bin/setenv.sh
CATALINA_OPTS="$CATALINA_OPTS -XX:UseAVX=2"
# systemd service: systemctl edit &lt;service name&gt;
[Service]
Environment="JAVA_TOOL_OPTIONS=-XX:UseAVX=2"
# Docker
docker run -e JAVA_TOOL_OPTIONS="-XX:UseAVX=2" ...
# Kubernetes (container env)
env:
  - name: JAVA_TOOL_OPTIONS
    value: "-XX:UseAVX=2"

If an application is already using JAVA_TOOL_OPTIONS, append new options to the existing value. Replacing the value will overwrite existing options.

Verification of Application

# Actual options of a running JVM (run as the user who started the JVM)
jcmd &lt;PID&gt; VM.flags | grep -E "UseAVX|UseBASE64Intrinsics"
jcmd &lt;PID&gt; VM.command_line
# Windows
jcmd &lt;PID&gt; VM.flags | findstr "UseAVX UseBASE64Intrinsics"

If -XX:UseAVX=2 or -XX:-UseBASE64Intrinsics appears in VM.flags, the option has been applied. The java-inventory script only reads process command lines, so options set via JAVA_TOOL_OPTIONS must be verified using jcmd.

cacerts Certificate Deletion: eMudhra Root Certificates (keytool)

As per Oracle's guidance (ops.java/emudhra), delete the four root certificates (emSign Root CA - G1, emSign Root CA - G2, emSign ECC Root CA - G3, AAA Certificate Services). Aliases vary by distribution. For instance, the alias in Oracle's guide is emsignrootcag1 [jdk], while in Eclipse Temurin 21, it appears as cn_emsign_root_ca__g1,o_emudhra_technologies_limited,ou_emsign_pki,c_in [jdk]. Therefore, it is necessary to locate the alias first before deletion.

# 1) Backup (JDK 8 is $JAVA_HOME/jre/lib/security/cacerts)
cp "$JAVA_HOME/lib/security/cacerts" "$JAVA_HOME/lib/security/cacerts.bak"
# 2) Find aliases to delete
keytool -J-Duser.language=en -list -v -cacerts -storepass changeit \
  | grep -B 6 -E "^Owner: CN=(emSign Root CA - G1|emSign Root CA - G2|emSign ECC Root CA - G3|AAA Certificate Services)," \
  | grep "^Alias name:"
# 3) Delete each found alias (JDK 8 uses -keystore &lt;cacerts path&gt; instead of -cacerts)
keytool -delete -cacerts -storepass changeit -alias "&lt;found alias&gt;"

After deletion, all JVMs utilizing that JDK must be restarted. If immediate deletion is not feasible, an alternative method, as per Oracle's guidance, involves adding -Dcom.sun.net.ssl.checkRevocation=true and -Dcom.sun.security.enableCRLDP=true to the startup options of TLS-enabled applications to enable checking for revoked certificates. This method requires network access to retrieve Certificate Revocation Lists. Practical steps for verification and deletion are available in the CVE-2026-91403 check article.

Why Java Version Verification Is the Starting Point for Vulnerability Checks

Java runtimes (JDK/JRE) are distributed by various vendors, and continuous security patching is crucial. Oracle releases Java SE security fixes quarterly (January, April, July, October) through its Critical Patch Updates (CPU). Please refer to Oracle Security Advisories.

OpenJDK also provides security information through its Vulnerability Advisories, and other vendors such as Eclipse Adoptium (Temurin), Red Hat, Amazon Corretto, Azul, and like provide their own updated builds. Consequently, major version numbers like '17' or '21' alone are insufficient to determine if a Java runtime has been patched. It is imperative to verify the full build number (e.g., 21.0.11+10-LTS) along with the vendor information (java.vendor) and compare this against the latest security updates from the respective vendor to assess the security posture.

Java Version Verification Command (Single Host)

On a single server, the java -version command provides version information for the default Java runtime configured in the PATH environment variable. For more detailed information, including vendor, build number, and architecture, please use the -XshowSettings:properties -version command.

# Windows (Command Prompt or PowerShell)
java -version
java -XshowSettings:properties -version 2&gt;&amp;1 | findstr /C:"java.vendor =" /C:"java.runtime.version =" /C:"os.arch ="
# Linux
java -version
java -XshowSettings:properties -version 2&gt;&amp;1 | grep -E 'java.vendor =|java.runtime.version =|os.arch ='

The execution output of the above commands may appear as follows.

java.runtime.version = 21.0.11+10-LTS
java.vendor = Eclipse Adoptium
os.arch = amd64

Why java -version Alone Is Insufficient

Relying solely on java -version makes it challenging to identify all Java runtimes installed on a server. In actual operating environments, multiple Java runtimes may be present due to various reasons. For example, runtimes might be bundled with WAS or other solution products, or build tools like Gradle might download and use their own JDKs (e.g., in .gradle\jdks). Additionally, runtimes not registered in PATH may be difficult to locate with standard commands, and runtimes existing within Docker containers also need consideration. Verification via a script in a real environment revealed 5 Java runtimes on one development PC, with 2 of them located within the Gradle cache.

Below is the actual result of running the script from the next section on a single development PC (2026-11-18, some columns omitted). The last two lines represent JDKs within the Gradle cache. Four runtimes were older than the vendor's latest build, and the Red Hat runtime indicated that manual verification was required due to outdated comparison data. All five runtimes still contained two eMudhra root certificates in cacerts, and since this PC's CPU supports AVX-512 VBMI, all are affected by Java4Shell.

runtime_build  latest_build               status                                               emudhra_roots                                       java4shell
-------------  ------------               ------                                               -------------                                       ----------
21.0.11+10-LTS 21.0.13+9 (2026-10-22)     update needed                                        FOUND: emSign Root CA - G1; emSign ECC Root CA - G3 AFFECTED (update needed)
25.0.4.1+1-LTS 25.0.5+8 (2026-10-22)      update needed                                        FOUND: emSign Root CA - G1; emSign ECC Root CA - G3 AFFECTED (update needed)
21.0.11+10-LTS 21.0.9.0.10-1 (2025-10-17) check manually (vendor data last updated 2025-10-17) FOUND: emSign Root CA - G1; emSign ECC Root CA - G3 AFFECTED (update needed)
17.0.20.1+1    17.0.21+9 (2026-10-22)     update needed                                        FOUND: emSign Root CA - G1; emSign ECC Root CA - G3 AFFECTED (update needed)
17.0.20.1+1    17.0.21+9 (2026-10-22)     update needed                                        FOUND: emSign Root CA - G1; emSign ECC Root CA - G3 AFFECTED (update needed)

Script for Locating All Java Runtimes on a Server

The java-inventory script (java-inventory.ps1 for Windows, java-inventory.sh for Linux) scans all Java runtimes on a server to collect detailed information. For each runtime, it records the comparison result against the vendor's latest build, checks for remaining eMudhra root certificates, and determines Java4Shell impact. This script executes -XshowSettings:properties -version for each found Java runtime and keytool -list once to read version and certificate lists. Container interiors are checked using the docker exec command. No system settings are altered during this process. To accurately scan all processes and folders, the script must be run with administrator privileges on Windows and root privileges on Linux.

Download

Both scripts are available in the Copy & Run lab code repository (GitHub).

Search Locations

  • Windows Script: Verifies bin\java.exe files on disk (including product bundles), runtimes used by currently running java.exe or javaw.exe processes, JAVA_HOME and PATH environment variables, and JavaSoft keys in the registry. Oracle's javapath launcher (a file that only redirects to other runtimes) is excluded from the search. It also searches for bin/java within running Docker containers (Linux containers).
  • Linux Script: Searches for bin/java files on disk (skipping /proc, /sys, /dev, /run, Docker, and containerd repositories), currently running Java processes, and bin/java within running Docker containers.

Windows Usage

The method for executing the script in a Windows environment is as follows:

# Run in an elevated PowerShell (as Administrator)
# All fixed drives + running processes + JAVA_HOME/PATH/Registry + running Docker containers
powershell -NoProfile -ExecutionPolicy Bypass -File java-inventory.ps1
# Quick scan of Program Files, ProgramData, user folders only, excluding containers
powershell -NoProfile -ExecutionPolicy Bypass -File java-inventory.ps1 -Quick -NoContainers
# Specify folders to search (comma-separated) and output file
powershell -NoProfile -ExecutionPolicy Bypass -File java-inventory.ps1 -Roots C:\,D:\ -Out result.csv
# For servers without internet access: list and check eMudhra only, without latest build lookup
powershell -NoProfile -ExecutionPolicy Bypass -File java-inventory.ps1 -Offline
# Check containers with names containing 'was' only
powershell -NoProfile -ExecutionPolicy Bypass -File java-inventory.ps1 -ContainerFilter was

Linux Usage

The method for executing the script in a Linux environment is as follows:

# Run as root (to see all processes and folders)
# Entire / filesystem + running java processes + running Docker containers
sudo sh java-inventory.sh
# Specify folders to search and output file
sudo sh java-inventory.sh -o web01.csv /opt /usr
# Do not check containers
sudo sh java-inventory.sh -n
# For servers without internet access: list and check eMudhra only, without latest build lookup
sudo sh java-inventory.sh -x
# Check containers with names containing 'was' only
sudo sh java-inventory.sh -f was

How to Interpret the Result CSV

The script's execution results are generated in CSV format. Consolidating CSV files collected from multiple servers can create a comprehensive list of Java runtimes across the entire organization.

host,os,where,java_path,vendor,version,runtime_build,arch,running_pids,latest_build,status,emudhra_roots,java4shell
  • where: host or container:name (image)
  • vendor, runtime_build: Vendor and full build. Patch status is determined by these two values.
  • running_pids: Process IDs currently running with this runtime.
  • latest_build: The latest build for the same vendor and Java version, along with its release date. Public data from endoflife.date is queried.
  • status: The result of comparing feature.interim.update, and if they are the same, comparing up to the patch number (e.g., 21.0.13.0.3). 'Latest' is based on data as of the date in parentheses. The Linux version displays 'Latest' / 'Update Needed' / 'End of Support' / 'Check Manually', while the Windows version shows 'up to date' / 'update needed' / 'end of support' / 'check manually'.
  • emudhra_roots: Remaining eMudhra root certificates in cacerts. Searches for the four certificates targeted by CVE-2026-91403, CVE-2026-114820 by their Common Name (CN).
  • java4shell: Java4Shell (CVE-2026-114938) impact status. 'Affected' if JDK 17, 21, 25, 27 is at or below the last affected build according to OpenJDK advisories, and the JVM detects AVX-512 VBMI in the CPU capabilities. If a running JVM is operating with -XX:UseAVX=0/1/2 or -XX:-UseBASE64Intrinsics, it is indicated as 'temporary mitigation applied'; otherwise, it is shown as 'running without mitigation' along with the PID. For OpenJDK-based distributions, build number notation may vary, so patched builds might still appear as 'affected'; final confirmation should be made via vendor advisories.

Actions Based on Results

  • Runtimes with remaining certificates in emudhra_roots should be upgraded to a build that includes the eMudhra fix (confirming CVE-2026-114820 remediation in the release notes), or, if immediate upgrade is not possible, the relevant certificates should be deleted from cacerts.
  • Runtimes with a 'status' of 'update needed' should be upgraded to latest_build or newer. Even if shown as 'latest', if a vendor security advisory has been released after the latest_build date, re-verify with the build specified in that advisory (e.g., Oracle 2026-11-17 CSPU). For 'end of support' runtimes, a plan should be developed to migrate to a supported Java version.
  • 'Check manually' indicates cases where vendor data is unavailable (e.g., Azul, OS packages) or outdated. Direct verification via the respective vendor or distribution security advisories is required.
  • Runtimes where java4shell indicates 'affected' and there are running PIDs without mitigation are the most urgent. Publicly exposed services should be prioritized for upgrading to a patched build. If immediate upgrade is not possible, apply temporary mitigation options and restart.
  • Actions should commence with runtimes that have running_pids (Java currently in use by services).
  • Unused runtimes should be categorized as candidates for deletion. For runtimes bundled with products, avoid arbitrary changes and follow the update guidance provided by the product vendor.

Additional Areas for Verification

After completing the runtime check, the following items require additional verification. This script only inspects the Java runtime itself (build, trust store, CPU conditions, execution options). Temporary mitigation options are only visible from the command line of running processes, so cases where options are set via JAVA_TOOL_OPTIONS or option files must be verified separately.

  • Library Vulnerabilities: Vulnerabilities in application-included libraries (JAR files) are managed separately from Java runtime versions. For instance, Log4Shell (CVE-2021-44228) is a vulnerability in the Apache Log4j library and cannot be detected by this script. Such library vulnerabilities must be checked separately using Software Composition Analysis (SCA) tools like OWASP Dependency-Check.
  • Container Status: This script only verifies Java runtimes within currently running Docker containers. It does not directly scan stopped containers, container images themselves, Podman environments, or containerd environments on Kubernetes nodes. Container images must be inspected using specialized tools such as image scanners.
  • CVE-Specific Assessment and Inter-Quarterly Advisories: The status field represents a comparison with the vendor's latest build and does not individually cross-reference each CVE. Public data may be updated later than vendor advisories, and Oracle releases patches monthly. Therefore, continuous monitoring of Oracle Security Advisories and OpenJDK Vulnerability Advisories is recommended.

Frequently Asked Questions

What is the Java version verification command?

To check the Java version on a single server, use the java -version command. For more detailed information (vendor, full build, architecture), please execute the java -XshowSettings:properties -version command.

How is the JDK version checked in Linux?

A single instance can be checked with java -version. To view the location and version of all Java runtimes installed on a server, execute the java-inventory.sh script as root. This script searches not only for Java in PATH but also in common installation paths, running processes, and within Docker containers.

What is Java4Shell?

Java4Shell is a memory corruption vulnerability (CVE-2026-114938) in the OpenJDK Base64 decoder, disclosed on November 17, 2026. Systems using JDK 17, 21, 25, or 27 series on x86-64 CPUs supporting AVX-512 VBMI are affected, and crafted Base64 input may lead to unauthenticated remote code execution.

Is our server affected by Java4Shell?

Both the JDK series and CPU must be considered. Verify the UseAVX value from java -XX:+UnlockDiagnosticVMOptions -XX:+PrintFlagsFinal -version and the CPU's support for avx512_vbmi. For the entire server, the java4shell column in the java-inventory script provides a consolidated view of impact status and temporary mitigation application for each runtime. ARM64 servers are not affected.

What are the most urgent Java vulnerabilities currently?

As of November 18, 2026, the most urgent Java vulnerabilities include the November 17 monthly update containing Java4Shell (CVE-2026-114938) with 11 Java SE security fixes, and two eMudhra certificate advisories (CVE-2026-91403, CVE-2026-114820, both CVSS 9.1). All October builds are also affected. Therefore, it is necessary to upgrade to a build with November security fixes (Oracle's November 17 build). If immediate upgrade is not feasible, the four relevant root certificates should first be deleted from cacerts. The emudhra_roots column in the script can be used to check for their presence.

Where should temporary JVM options be placed, and how are they verified?

Options should be placed in the location used by the specific service: startup command, JAVA_TOOL_OPTIONS environment variable, Tomcat's setenv.sh, systemd service, or container environment variables, followed by a JVM restart. Application can be verified using jcmd <PID> VM.flags. The -XX:UseAVX=2 option should only be applied to x86-64 servers.

What are the Java4Shell patch versions?

According to the KISA Advisory, the resolving Oracle Java SE versions are 17.0.21.1, 21.0.13.1, 25.0.5.1, and 27.0.1.1. OpenJDK-based distributions such as Eclipse Temurin, Amazon Corretto, Azul Zulu, Microsoft, and Red Hat should apply their respective vendor's November patched builds.

How are cacerts certificates deleted?

First, back up cacerts. Then, locate the alias of the certificate to be deleted using keytool -list -v -cacerts, and delete it with keytool -delete -cacerts -alias "alias_name". Aliases vary by distribution and must be manually verified. After deletion, restart all JVMs using that JDK.

How is OpenJDK updated?

Install the patched build of the same vendor and Java version into a new folder, then update JAVA_HOME or symbolic links and restart the service. If installed via OS packages, upgrade using a package manager like apt or dnf. For containers, rebuild and deploy with an image containing the patched build.

Does this script detect Log4j vulnerabilities?

No. This script is a tool for verifying Java runtime versions and does not detect vulnerabilities present in application libraries (e.g., Apache Log4j). Library vulnerabilities such as Log4j must be checked separately using SCA tools.

Does this script check Java within containers?

Yes, this script verifies Java runtimes installed inside currently running Docker containers using the docker exec command. However, it does not directly scan stopped containers or container images themselves. Java runtimes in such environments must be checked through other image scanners.

Stay Updated

Get the latest security insights delivered to your inbox.

Tags

#Java Version Verification#Java Runtime Vulnerability#Oracle CPU#Server Security#PowerShell Script#Linux Shell Script#Docker Security