runbook / 005 · Tailwind Resource Group · Customer advisory · Disclosed November 17, 2026
Interim protections for OpenJDK 17 to 27 until you install the Java4Shell fix
A malformed Base64 string can corrupt memory in OpenJDK 17.0.6 and later on x86-64 CPUs with AVX-512 VBMI. Install the fixed JDK from your vendor. Until then, start each JVM with `-XX:-UseBASE64Intrinsics`. This page gives you a check script, the steps and a BIG-IP iRule.
- Applies to
- OpenJDK 17.0.6+, 21, 25, 27 on x86-64 with AVX-512 VBMI
- Fix
- The fixed JDK from your vendor
- Interim
- 1 JVM option; F5 signatures or 1 BIG-IP iRule
- CVE
- CVE-2026-114938, CVSS 3.1 score 8.1 (Oracle)
Summary
On November 17, 2026, Oracle and the OpenJDK Vulnerability Group published fixes for CVE-2026-114938. Calif found the vulnerability and named it Java4Shell.
The vulnerability is in the HotSpot JVM. The JVM has special code that decodes Base64 with AVX-512 instructions. Calif says a short, malformed Base64 input makes this code write 62 bytes after the end of the output buffer. Java then refuses the input, but the write is already done.
Oracle gives the vulnerability a CVSS 3.1 score of 8.1 and says it is difficult to exploit. Oracle also says an attacker needs no account and can use more than one network protocol. Calif gives a CVSS 4.0 score of 9.2. Calif says it got remote code execution without a logon on default installations of Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate. Calif has published a test for the memory corruption. Calif has not published the attacks on those products.
We did the memory corruption test in our lab on November 18, 2026. These are our results:
- The corruption is real. On an AMD Zen 5 CPU, Temurin 21.0.13+9 and 25.0.5+8 wrote 62 bytes after the end of the buffer for the Calif input. Temurin 17.0.21+9 did the same for an input of 128 characters. An emulated Intel CPU gave the same results.
- The fixed builds are clean. Amazon Corretto 17.0.21.1.2, 21.0.13.1.2 and 25.0.5.1.2 did not corrupt memory.
- The interim option works. With
-XX:-UseBASE64Intrinsics, the affected builds did not corrupt memory. - The iRule works. In block mode on a BIG-IP, it refused each input that corrupted an affected JVM.
Install the fixed JDK from your vendor in each affected JVM. Until you can do that, the option
-XX:-UseBASE64Intrinsicsstops the JVM from using the vulnerable code. This page gives you a script that finds the exposed JVMs on a Linux host, and the steps to set the option. It also gives you a BIG-IP iRule that finds and refuses the malformed input in HTTP requests.Does this apply to you?
A JVM is exposed if all of these statements are true:
- The JVM is HotSpot from OpenJDK, or from a product built from OpenJDK. Calif lists Oracle Java SE, Oracle GraalVM for JDK, Amazon Corretto, Eclipse Temurin, Microsoft Build of OpenJDK, Azul Zulu, BellSoft Liberica, SAP SapMachine and Red Hat OpenJDK. We tested Eclipse Temurin.
- The Java version is on the 17, 21, 25 or 27 line and does not have the fix. The OpenJDK advisory gives 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3, 27.0.1.0.3 and earlier. Calif says the vulnerable code starts at 17.0.6. In our lab, Temurin 17.0.5+8 did not have the vulnerable code. We did not test 17.0.6 or the 27 line.
- The CPU is x86-64 and has the flags
avx512f,avx512bw,avx512vbmiandbmi2. Calif names Intel Xeon from Ice Lake and AMD from Zen 4. We tested AMD Zen 5. We tested Intel Ice Lake and Sapphire Rapids only on an emulator. - The application decodes Base64 data that an attacker can send. Calif says that logon functions and file uploads do this.
Many products include a JDK of their own. The Java version of the operating system does not tell you the version that such a product uses. Examine each running JVM.
You are not affected in these conditions:
- A CPU without AVX-512 VBMI. In our lab, Temurin 21.0.13+9 on an Intel Kaby Lake CPU did not corrupt memory.
- ARM64. Calif says ARM64 is not affected. We did not test ARM64.
- Java 8 and Java 11, standard builds. The OpenJDK advisory does not list the 8 and 11 lines for this CVE. Oracle lists one Java 8 build as affected:
8u511b33-perf. - BIG-IP, BIG-IQ, F5 Insight and F5OS. F5 article K000164290 says these products are not vulnerable. On November 18, 2026, the article showed that F5 was still examining F5 Distributed Cloud and NGINX One Console.
Java lines that have no more updates, such as 18 to 20, 22 to 24 and 26, get no fix. Our estimate is that they have the vulnerable code. We did not test them. Move them to a line that has the fix.
Recommended actions, in order
- Find the exposed JVMs. Run the check script on each Linux host. Start with the hosts that the internet can reach, and with identity providers.
- Set the interim option. Add
-XX:-UseBASE64Intrinsicsto each exposed JVM that you cannot update today. Start the JVM again. - Protect at the BIG-IP. If a BIG-IP is in front of the application, enforce F5's three OpenJDK attack signatures on Advanced WAF. If you do not use Advanced WAF, attach
java4shell_b64_guardin log mode, and change it to block mode after you examine the log. - Install the fixed JDK. Use the build from your JDK vendor. For a product that includes a JDK, use the update from the product vendor.
- Confirm the result. Run the check script again. Each JVM must show
OKorMITIGATED. - Monitor. Look for the signs in "What to monitor".
- Remove the interim protections. Do this after the fixed JDK is in use. Remove the iRule. Remove the JVM option if you want the Base64 speed back.
Find the exposed JVMs
The check script examines each running process that has
libjvm.soloaded. It reads the CPU flags, the Java version from thereleasefile of the JDK, and the options in the command line and the environment of the process. It only reads. It does not start Java and it changes nothing.The script gives one status for each JVM:
Status Meaning Action OKThe version or the CPU is not affected, or the version is at or above the fixed version None. Confirm a fixed version in the release notes of your vendor MITIGATEDAn affected version, with an interim option set Install the fixed JDK EXPOSEDAn affected version on an affected CPU, with no interim option found Set the interim option, then install the fixed JDK REVIEWThe script cannot decide Examine the JVM manually The script has these limits:
- It finds running JVMs only. It does not find a JDK in a container image that is not running. It does find a JVM in a running container.
- It does not see an option that comes from a JVM options file. Such a JVM shows
EXPOSEDalthough the option is set. Use the confirmation command in the next step. - The JVM uses the last value of an option. If a JVM has options that disagree, such as
-XX:-UseBASE64Intrinsicsand-XX:+UseBASE64Intrinsics, the script showsREVIEW. Use the confirmation command in the next step. - If you do not run it as root, it shows only your own JVMs.
- The fixed versions at the top of the script are from reports. Change them to agree with the release notes of your vendor.
The check script
Save this file on the host. Run it as root with
bash java4shell_check.sh. The exit status is 0 when no JVM isEXPOSEDorREVIEW, 1 when one or more are, and 2 when the script cannot do the check on the host.java4shell_check.shDownload Show all 166 linesHide 166 lines
# Copyright 2026 Tailwind Resource Group # SPDX-License-Identifier: Apache-2.0 # Provided as is, with no warranty. License: https://everythingsfine.io/license/ # # java4shell_check.sh: report the exposure of this Linux host to CVE-2026-114938. # # The script only reads /proc and the JDK "release" file. It changes nothing # and it does not start Java. Run it with bash, as root, so that it can see # every JVM: # # bash java4shell_check.sh # # Exit status: 0 = no running JVM is exposed, 1 = one or more JVMs are EXPOSED # or need REVIEW, 2 = the script cannot do the check on this host. # # The script examines running JVMs only. It does not find a JDK that is # installed but not running, or a JDK in a container image that is not running. # Lowest version with the vulnerable code on the 17 line (source: Calif). FIRST_17="17.0.6" # Lowest version with the fix on each line. Change these to agree with the # release notes of your JDK vendor. FIXED_17="17.0.21.1" FIXED_21="21.0.13.1" FIXED_25="25.0.5.1" FIXED_27="27.0.1.1" # ver_ge A B: true when version A is equal to or higher than version B. ver_ge() { [ "$(printf '%s\n%s\n' "$1" "$2" | sort -V | head -n 1)" = "$2" ] } # classify VERSION CPU_EXPOSED OPTIONS: print one status word and a reason. classify() { c_ver=$1 c_cpu=$2 c_opts=$3 c_major=${c_ver%%.*} c_fixed="" case "$c_ver" in "") echo "REVIEW: cannot read the Java version" return ;; 1.8.*perf*) echo "REVIEW: Java 8 performance build; Oracle lists 8u511b33-perf as affected" return ;; 1.*) echo "OK: Java 8 or earlier; the standard builds are not listed as affected" return ;; esac case "$c_major" in *[!0-9]*) echo "REVIEW: cannot read the Java version" return ;; esac if [ "$c_major" -lt 17 ]; then echo "OK: Java $c_major is not listed as affected" return fi case "$c_major" in 17) c_fixed=$FIXED_17 ;; 21) c_fixed=$FIXED_21 ;; 25) c_fixed=$FIXED_25 ;; 27) c_fixed=$FIXED_27 ;; esac if [ "$c_major" = 17 ] && ! ver_ge "$c_ver" "$FIRST_17"; then echo "OK: lower than $FIRST_17; Calif says the vulnerable code starts at $FIRST_17" return fi if [ -n "$c_fixed" ] && ver_ge "$c_ver" "$c_fixed"; then echo "OK: at or above $c_fixed; confirm the fix in the release notes of your vendor" return fi if [ "$c_cpu" != yes ]; then echo "OK: affected version, but this CPU does not use the vulnerable code" return fi # The JVM uses the last value of an option. If the options disagree, # the script does not decide. c_b64=no c_avx=no c_dis=no c_plus=no c_avx3=no case " $c_opts " in *" -XX:-UseBASE64Intrinsics "*) c_b64=yes ;; esac case " $c_opts " in *" -XX:UseAVX=0 "*|*" -XX:UseAVX=1 "*|*" -XX:UseAVX=2 "*) c_avx=yes ;; esac case " $c_opts " in *DisableIntrinsic=*_base64_decodeBlock*) c_dis=yes ;; esac case " $c_opts " in *" -XX:+UseBASE64Intrinsics "*) c_plus=yes ;; esac case " $c_opts " in *" -XX:UseAVX=3 "*) c_avx3=yes ;; esac if [ "$c_avx" = yes ] && [ "$c_avx3" = no ]; then echo "MITIGATED: -XX:UseAVX is 2 or lower; install the fixed JDK" return fi if [ "$c_b64" = yes ] && [ "$c_plus" = no ]; then echo "MITIGATED: -XX:-UseBASE64Intrinsics is set; install the fixed JDK" return fi if [ "$c_dis" = yes ] && [ "$c_plus" = no ]; then echo "MITIGATED: DisableIntrinsic names the Base64 decode intrinsic; install the fixed JDK" return fi if [ "$c_b64$c_avx$c_dis" != nonono ]; then echo "REVIEW: the options disagree; confirm with jcmd" return fi if [ -z "$c_fixed" ]; then echo "EXPOSED: Java $c_major has no fixed version; move to a supported line (our estimate)" return fi echo "EXPOSED: affected version on an affected CPU, and no mitigation option found" } if [ ! -r /proc/cpuinfo ]; then echo "Cannot read /proc/cpuinfo. This script is for Linux." >&2 exit 2 fi cpu_exposed=no if [ "$(uname -m)" = "x86_64" ]; then cpu_flags=$(grep -m 1 '^flags' /proc/cpuinfo) cpu_exposed=yes for flag in avx512f avx512bw avx512vbmi bmi2; do case " $cpu_flags " in *" $flag "*) ;; *) cpu_exposed=no ;; esac done fi echo "CPU: $(uname -m), uses the vulnerable Base64 code: $cpu_exposed" if [ "$(id -u)" != 0 ]; then echo "WARNING: not root. JVMs of other users are not visible." fi found=0 bad=0 for dir in /proc/[0-9]*; do pid=${dir#/proc/} jvm=$(grep -m 1 '/libjvm\.so' "$dir/maps" 2>/dev/null | awk '{ print $NF }') [ -n "$jvm" ] || continue found=$((found + 1)) # libjvm.so is in <java home>/lib/server/. Read through /proc/<pid>/root # so that a JVM in a container gives the path in its own file system. home=${jvm%/lib/*} version=$(sed -n 's/^JAVA_VERSION="\(.*\)"$/\1/p' "$dir/root$home/release" 2>/dev/null | head -n 1) opts=$(tr '\0' ' ' < "$dir/cmdline" 2>/dev/null) env_opts=$(tr '\0' '\n' < "$dir/environ" 2>/dev/null | sed -n 's/^\(JAVA_TOOL_OPTIONS\|_JAVA_OPTIONS\|JDK_JAVA_OPTIONS\)=//p' | tr '\n' ' ') result=$(classify "$version" "$cpu_exposed" "$opts $env_opts") case "$result" in EXPOSED*|REVIEW*) bad=$((bad + 1)) ;; esac echo "pid $pid: java ${version:-unknown} in $home" echo " $result" done echo "JVMs found: $found. EXPOSED or REVIEW: $bad." if [ "$bad" -gt 0 ]; then exit 1 fi exit 0Example output
This is the output on a host with three JVMs. Two have an interim option. One has options that disagree.
text CPU: x86_64, uses the vulnerable Base64 code: yes pid 160: java 21.0.13.0.3 in /usr/lib/jvm/java-21-openjdk-amd64 MITIGATED: DisableIntrinsic names the Base64 decode intrinsic; install the fixed JDK pid 161: java 21.0.13.0.3 in /usr/lib/jvm/java-21-openjdk-amd64 MITIGATED: -XX:-UseBASE64Intrinsics is set; install the fixed JDK pid 162: java 21.0.13.0.3 in /usr/lib/jvm/java-21-openjdk-amd64 REVIEW: the options disagree; confirm with jcmd JVMs found: 3. EXPOSED or REVIEW: 1.Turn off the Base64 intrinsic
The option
-XX:-UseBASE64Intrinsicstells the JVM to decode and encode Base64 with its usual Java code. Calif gives this option as a mitigation. The vulnerable code is then not used. In our lab, Temurin 17.0.21+9, 21.0.13+9 and 25.0.5+8 did not corrupt memory with this option. Base64 work becomes slower. We did not measure how much.This option is not the fix. It stays correct only while each start of the JVM has it. A new service file, a new container image or a product update can remove it. Install the fixed JDK.
The JVM reads the option only when it starts. Start the JVM again after you set it.
Set the option in the environment
The JVM reads the variable
JAVA_TOOL_OPTIONSwhen it starts. Use this when you cannot change the command line. Put this line where the service gets its environment.shell export JAVA_TOOL_OPTIONS="-XX:-UseBASE64Intrinsics"If the variable already has a value, add the option to that value. Do not replace the value.
The JVM prints a line when it uses this variable. Each JVM writes
Picked up JAVA_TOOL_OPTIONS: ...to its error output. Java tools such asjcmddo this also. A script that reads the error output of a Java command can fail. Test such scripts.Set the option in a systemd service
Put this text in a drop-in file for the service, then reload systemd and start the service again.
/etc/systemd/system/example.service.d/java4shell.conf [Service] Environment="JAVA_TOOL_OPTIONS=-XX:-UseBASE64Intrinsics"Set the option in a container image
Add this line to the Dockerfile, then build and deploy the image again. As an alternative, set the same variable in the container definition.
text ENV JAVA_TOOL_OPTIONS="-XX:-UseBASE64Intrinsics"Set the option in the product
Many products have a file or a variable of their own for JVM options. If your product has one, add
-XX:-UseBASE64Intrinsicsthere. The documentation of your product gives the location.Confirm that a running JVM has the option
Run this command as the user that owns the JVM. Replace
1234with the process ID.shell jcmd 1234 VM.flags | tr ' ' '\n' | grep UseBASE64IntrinsicsThe option is set when the output is the line
-XX:-UseBASE64Intrinsics. If there is no output, the option is not set.The second option: UseAVX
Calif gives a second mitigation,
-XX:UseAVX=2. It stops all use of AVX-512 in the JVM, which has a larger effect on speed. In our lab, Temurin 17.0.21+9 and 21.0.13+9 did not corrupt memory with this option. Use-XX:-UseBASE64Intrinsicsunless you have a reason not to.Do not set
-XX:UseAVX=2on ARM hosts. Calif says OpenJDK on ARM does not know this option and does not start. We did not test this.Do not use
-XX:DisableIntrinsicas the interim option. Some guides give-XX:DisableIntrinsic=_base64_decodeBlock. In our lab, a JVM with this option did not start unless-XX:+UnlockDiagnosticVMOptionswas before it. If you put it inJAVA_TOOL_OPTIONSwithout the unlock option, no JVM that reads the variable starts.Enforce the F5 attack signatures on Advanced WAF
On November 18, 2026, F5 released three attack signatures named "OpenJDK Buffer Overflow", in the attack signature update
ASM-AttackSignatures_20261118_135133. F5's notes for that update do not name a CVE. We expect that these signatures are for this vulnerability, but F5 has not said so, and we have not tested them.Signature ID Name 200011116 OpenJDK Buffer Overflow (1) 200011117 OpenJDK Buffer Overflow (2) 200011118 OpenJDK Buffer Overflow (3) - Install the signature update. Go to System > Software Management > Live Update. Install
ASM-AttackSignatures_20261118_135133or a later file. - Find the signatures in the policy. In each Advanced WAF policy in front of a Java application, go to Attack Signatures and search for "OpenJDK Buffer Overflow". You must see all three. If you do not, add them to a signature set that the policy uses.
- Enforce them. A new signature is in staging. In staging, it logs and does not block. Select the three signatures, click Enforce, then click Apply Policy.
- Make sure that the policy blocks. The policy enforcement mode must be Blocking.
Signatures do not replace the JVM option or the fixed JDK. A signature finds the forms of the attack that F5 knows. You can use the iRule below with the signatures, or in their place if you do not have Advanced WAF.
- Install the signature update. Go to System > Software Management > Live Update. Install
Find and refuse the malformed Base64 at a BIG-IP
If a BIG-IP is in front of the Java application, this iRule gives you a second interim protection. CISA tells you to validate Base64 input at the application boundary when you cannot patch immediately. The iRule does this for HTTP requests.
The iRule examines the URI, each request header and the start of the request body. It looks for a run of 60 or more Base64 characters that has
=padding after it. Correct padding has only two forms: a run with a length of 4n+2 and==, or a run with a length of 4n+3 and=. The iRule writes a log line for all other padding. It also refuses the request with status 400 if you set it to block. The test input from Calif, 64Acharacters and one=, has a run length of 4n and is malformed.Attach the iRule to each HTTP virtual server that sends requests to an exposed JVM. The virtual server must have an HTTP profile. For HTTPS, the BIG-IP must decrypt the traffic. If the virtual server has an APM access profile, the iRule examines a request before the access policy does.
What we tested
We tested the iRule on BIG-IP 17.5.1.11 on November 18, 2026, with HTTP, HTTPS and HTTP/2 virtual servers and with an APM access profile.
- Against an affected JVM. We sent 9 inputs through the BIG-IP to Temurin 21.0.13+9 on an emulated AVX-512 VBMI CPU. With no iRule, 7 of them corrupted memory. In log mode, the iRule wrote a log line for each of the 9. In block mode, it refused each of the 9 with status 400, and the JVM did not get the request. Correct Base64 went through with no log line.
- The padding rule. We sent 9600 inputs to each of Temurin 17.0.21+9, 21.0.13+9 and 25.0.5+8 on an AMD Zen 5 CPU. The run lengths were 1 to 200. The rule calls each input that corrupted memory malformed. The shortest run that corrupted memory had 64 characters on the 21 and 25 lines, and 128 characters on the 17 line.
- Usual logon traffic. An APM logon and 12 requests with recorded SAML responses caused no log lines.
This iRule does not replace the JVM option or the fixed JDK. The rule for malformed padding is our analysis. It is not from Oracle or OpenJDK. Our tests stopped at runs of 200 characters, and we do not know all the inputs that cause the overflow. The iRule also does not examine all data. Set
-XX:-UseBASE64Intrinsicson each JVM that you can.The iRule does not examine this data. We tested each item unless it says differently.
- A request body that has no
Content-Lengthheader, such as a body with chunked encoding. - The part of a request body after the first 1048576 bytes.
- A compressed request body.
- Base64 that has a different encoding around it, such as JSON escape sequences or two levels of percent-encoding.
- WebSocket messages, and protocols that are not HTTP. We did not test these.
- Requests that do not go through the virtual server.
The settings
The settings are at the top of the iRule, in
RULE_INIT.Setting Default Meaning static::j4s_block00writes a log line only.1writes a log line and refuses the requeststatic::j4s_min_run60The iRule ignores runs that are shorter than this. Keep it at 64 or less, for the reason in "What we tested" static::j4s_max_body1048576The number of bytes of each request body that the iRule examines Keep only one copy of this iRule on a BIG-IP. All iRules on a BIG-IP share the
static::settings. In our lab, a second copy withstatic::j4s_blockat1made the first copy block also. If you need a copy with different settings, change the names of the settings in the copy.The iRule
Create an iRule with the name
java4shell_b64_guardand paste this text.java4shell_b64_guard.tclDownload Show all 161 linesHide 161 lines
# Copyright 2026 Tailwind Resource Group # SPDX-License-Identifier: Apache-2.0 # Provided as is, with no warranty. License: https://everythingsfine.io/license/ # # java4shell_b64_guard.tcl: find Base64 with padding that cannot be correct. # # Interim protection for CVE-2026-114938 (Java4Shell). Attach this iRule to # an HTTP virtual server that is in front of a Java application. The virtual # server must have an HTTP profile and must decrypt TLS. # # The iRule examines the URI, each request header and the start of the # request body. It looks for a run of Base64 characters that has "=" padding # after it. Correct padding has only two forms: a run with a length of # 4n+2 and "==", or a run with a length of 4n+3 and "=". All other padding # is malformed. The iRule writes a log line for a malformed run. It also # refuses the request if you set static::j4s_block to 1. # # This iRule does not replace the fixed JDK or -XX:-UseBASE64Intrinsics. when RULE_INIT { # 0 = write a log line only. 1 = write a log line and refuse the request. set static::j4s_block 0 # Ignore runs that are shorter than this number of characters. set static::j4s_min_run 60 # Examine no more than this number of bytes of each request body. set static::j4s_max_body 1048576 # The search patterns find 4 x (j4s_min_run / 4) or more Base64 # characters with padding after them that is not correct for that # length. j4s_any finds only a full run, and is fast when nothing # matches. j4s_re finds the position fast, but it can also match the # end part of a correct run. Keep j4s_min_run at 1020 or less. set j4s_map [list @K@ [expr { $static::j4s_min_run / 4 }] @C@ {[A-Za-z0-9+/_-]}] set static::j4s_any [string map $j4s_map {(?:\A|[^A-Za-z0-9+/_-])(?:@C@{4}){@K@,}(?:=+|@C@=+|@C@{2}(?:=(?!=)|={3,})|@C@{3}={2,})}] set static::j4s_re [string map $j4s_map {(?:@C@{4}){@K@,}(?:=+|@C@=+|@C@{2}(?:=(?:[^=]|$)|={3,})|@C@{3}={2,})}] } # j4s_scan: return "" if the text has no malformed padded run. If it has # one, return a description of the first. The text is examined in parts # of about 16384 characters. A part never ends in a run or in its padding. # Each -start index is less than the text length: some Tcl versions read # past the end of the text if it is not. proc j4s_scan { text } { if { [string first "=" $text] < 0 } { return "" } set len [string length $text] set from 0 while { $from < $len } { set to $len set next [expr { $from + 16384 }] if { $next < $len && [regexp -indices -start $next {[^A-Za-z0-9+/_-][^=]} $text cut] } { set to [expr { [lindex $cut 0] + 1 }] } set part [string range $text $from [expr { $to - 1 }]] if { [regexp $static::j4s_any $part] } { set detail [call j4s_find $part] if { $detail ne "" } { return $detail } } set from $to } return "" } # j4s_find: the same as j4s_scan, for one part. A match of j4s_re is a # malformed run only if it starts where the run starts. proc j4s_find { text } { set len [string length $text] set start 0 while { $start < $len && [regexp -indices -start $start $static::j4s_re $text match] } { set first [lindex $match 0] set eq [string first "=" $text $first] regexp -indices -start $eq {\A=+} $text pads set start [expr { [lindex $pads 1] + 1 }] set run [expr { $eq - $first }] if { $run < $static::j4s_min_run } { continue } if { $first > 0 && [regexp {[A-Za-z0-9+/_-]} [string index $text [expr { $first - 1 }]]] } { continue } return "run=$run pad=[expr { [lindex $pads 1] - $eq + 1 }]" } return "" } # j4s_check: do j4s_scan on the text. If the text has percent-encoding, do # j4s_scan on the decoded text also. proc j4s_check { text } { set detail [call j4s_scan $text] if { $detail eq "" && [string first "%" $text] >= 0 } { set detail [call j4s_scan [URI::decode [string map {+ %2B} $text]]] } return $detail } when HTTP_REQUEST { set j4s_where "" set j4s_detail [call j4s_check [HTTP::uri]] if { $j4s_detail ne "" } { set j4s_where "uri" } else { foreach j4s_name [HTTP::header names] { foreach j4s_value [HTTP::header values $j4s_name] { set j4s_detail [call j4s_check $j4s_value] if { $j4s_detail ne "" } { set j4s_where "header $j4s_name" break } } if { $j4s_detail ne "" } { break } } } if { $j4s_detail ne "" } { if { $static::j4s_block } { log local0.warning "java4shell_guard: malformed Base64 in $j4s_where ($j4s_detail), client [IP::client_addr], virtual [virtual name], host [HTTP::host], action=block" HTTP::respond 400 content "Bad Request" "Connection" "close" return } log local0.warning "java4shell_guard: malformed Base64 in $j4s_where ($j4s_detail), client [IP::client_addr], virtual [virtual name], host [HTTP::host], action=log" } # Collect the start of the body. A body with no Content-Length header # (chunked encoding) is not examined. if { [HTTP::header exists "Content-Length"] } { set j4s_len [string trimleft [HTTP::header value "Content-Length"] "0"] if { $j4s_len ne "" && [string is digit -strict $j4s_len] } { if { [string length $j4s_len] > 9 || $j4s_len > $static::j4s_max_body } { set j4s_len $static::j4s_max_body } HTTP::collect $j4s_len } } } when HTTP_REQUEST_DATA { # The BIG-IP can collect more bytes than requested. Examine only the # first static::j4s_max_body bytes. set j4s_body [HTTP::payload $static::j4s_max_body] set j4s_detail [call j4s_scan $j4s_body] if { $j4s_detail eq "" } { set j4s_type [string tolower [HTTP::header value "Content-Type"]] if { [string match "application/x-www-form-urlencoded*" $j4s_type] } { set j4s_detail [call j4s_scan [URI::decode [string map {+ %2B} $j4s_body]]] } } unset j4s_body if { $j4s_detail ne "" } { if { $static::j4s_block } { log local0.warning "java4shell_guard: malformed Base64 in body ($j4s_detail), client [IP::client_addr], virtual [virtual name], host [HTTP::host], action=block" HTTP::respond 400 content "Bad Request" "Connection" "close" return } log local0.warning "java4shell_guard: malformed Base64 in body ($j4s_detail), client [IP::client_addr], virtual [virtual name], host [HTTP::host], action=log" } HTTP::release }How to install, tune, and remove the iRule
We created, changed and removed the iRule with iControl REST and
tmshin our lab. We did not test the steps in the Configuration utility.- Create the iRule. In the Configuration utility, go to Local Traffic, iRules, iRule List, and select Create. Use the name
java4shell_b64_guard. Paste the text and save. - Attach it in log mode. Add the iRule to the virtual server, on the Resources tab. Keep
static::j4s_blockat0. - Read the log. Let usual traffic go through for a period that includes logons, uploads and API calls. Then use the log command that follows.
- Examine each log line. A line from usual traffic is a false alarm. Find the cause before you block. We found one cause in our lab: a parameter name of 60 or more characters before an
=character. - Block. When usual traffic causes no log lines, change
static::j4s_blockto1in the iRule and save. The change starts with the next request. A refused request gets status 400 and the connection closes. - Update it under a new name. On BIG-IP 17.5.1.8 to 17.5.1.11, a changed iRule procedure can keep its old body until TMM restarts (F5 Bug ID 2493485). In our lab, this happened when we changed this iRule in place, and when we deleted it and created it again with the same name. To install a new version, create it with a new name, such as
java4shell_b64_guard_2. Keep the same settings as the old one. Attach it to the virtual server in place of the old one, then delete the old one. - Remove it. After the fixed JDK is in use on each JVM behind the virtual server, remove the iRule from the virtual server. Then delete the iRule. The BIG-IP does not let you delete an iRule that a virtual server uses.
The iRule collects the start of each request body that has a
Content-Lengthheader. This uses memory and CPU on the BIG-IP. In our lab, the iRule added no more than approximately 0.12 seconds to a request with a 1 MB body. The slowest body was one made only of+characters. On a virtual server with many large uploads, decreasestatic::j4s_max_body.The log command
Run this command on the BIG-IP. It finds the lines that the iRule writes. It also finds TCL errors and CPU notices that name the iRule.
shell grep -E 'java4shell_guard|java4shell_b64_guard' /var/log/ltmThe log line
The iRule writes a line such as this for each malformed run. The line gives the location, the run length and the number of padding characters. It does not contain the data. With HTTP/2, the header name is in lowercase.
/var/log/ltm Nov 18 08:08:53 example.com warning tmm[12042]: Rule /Common/java4shell_b64_guard <HTTP_REQUEST>: java4shell_guard: malformed Base64 in header Authorization (run=64 pad=1), client 192.0.2.10, virtual /Common/vs_example, host example.com:8083, action=log- Create the iRule. In the Configuration utility, go to Local Traffic, iRules, iRule List, and select Create. Use the name
Install the fixed JDK
The fix is in the JDK builds of November 17, 2026 and later. The OpenJDK advisory does not give the fixed version numbers. The numbers in this table are from reports. We did not confirm them in the Oracle release notes.
Java line Affected, from the OpenJDK advisory Fixed, from reports 17 17.0.21.0.3 and earlier 17.0.21.1 21 21.0.13.0.3 and earlier 21.0.13.1 25 25.0.5.0.3 and earlier 25.0.5.1 27 27.0.1.0.3 and earlier 27.0.1.1 We tested three fixed builds: Amazon Corretto 17.0.21.1.2, 21.0.13.1.2 and 25.0.5.1.2. None of them corrupted memory in our lab. The change log of Amazon Corretto 27.0.1.1.4 names CVE-2026-114938. We did not test that build.
Not all vendors released a fixed build on the same day. On November 18, 2026, Eclipse Temurin had no build later than 17.0.21+9, 21.0.13+9 and 25.0.5+8, and our lab shows that those builds are affected. Confirm that the release notes of your build name CVE-2026-114938. If your vendor has no fixed build yet, keep the interim option.
For a product that includes its own JDK, the product vendor supplies the update. The interim option protects such a product until then.
What to monitor
- Base64 decode errors. Look in the application logs for many
IllegalArgumentExceptionerrors fromjava.util.Base64, most of all from requests with no logon. In our lab, each input that corrupted memory also caused this exception. The exception also occurs for bad input that is not an attack, and on a fixed JVM. A sudden increase is the sign. - JVM crashes. Look for a JVM that stops and for new
hs_err_pidfiles in the working directory of the application. CISA tells you to look for JVM crashes that you did not expect. Do not use a crash as the only sign. In our lab, 1000 writes into the next object in memory did not crash the JVM. - Processes that the Java service starts. CISA tells you to look for suspicious Java processes and for Java runtimes that you did not install.
- The iRule log. Use the log command in "How to install, tune, and remove the iRule". In block mode, a line shows a request that the BIG-IP refused. Examine the client address.
- The interim option. Run the check script after each deployment. A JVM that changes from
MITIGATEDtoEXPOSEDlost the option.
The error messages
In our lab, an input that corrupted memory caused one of these two messages. The message is the same on a JVM that has the interim option.
text java.lang.IllegalArgumentException: Input byte array has wrong 4-byte ending unit java.lang.IllegalArgumentException: Last unit does not have enough valid bits- Base64 decode errors. Look in the application logs for many
References
- NVD, CVE-2026-114938 (opens in a new tab): the CVE record, the Oracle description, the CVSS 3.1 score of 8.1 and the affected Oracle versions.
- CISA alert, November 17, 2026 (opens in a new tab): the instruction to patch immediately and the signs to monitor.
- F5 attack signature update
ASM-AttackSignatures_20261118_135133, release notes: the three "OpenJDK Buffer Overflow" signatures, 200011116, 200011117 and 200011118. - F5 Bug ID 2493485 (opens in a new tab): a changed iRule procedure keeps its previous body on BIG-IP 17.5.1.8 to 17.5.1.11.
- F5 article K000164290 (opens in a new tab): the F5 products that are not vulnerable and those that F5 is still examining.
- oss-security, CVE-2026-114938 (opens in a new tab): the public notice, with the affected CPUs and the two mitigation options.
- OpenJDK Vulnerability Advisory 2026/11/17 (opens in a new tab): the affected Java lines and versions, and the
hotspot/compilercomponent. - Oracle Critical Security Patch Update Advisory, November 2026 (opens in a new tab): the affected Oracle versions, the CVSS score and the credit to Calif.
- Calif, "Java4Shell: Write once, RCE everywhere" (opens in a new tab): the cause, the test input, the affected CPUs, the products that Calif tested and the mitigation options.
- Amazon Corretto 17.0.21.1.2 change log (opens in a new tab): a fixed build that names the CVE.
- Amazon Corretto 21.0.13.1.2 change log (opens in a new tab): a fixed build that names the CVE.
- Amazon Corretto 25.0.5.1.2 change log (opens in a new tab): a fixed build that names the CVE.
- Amazon Corretto 27.0.1.1.4 change log (opens in a new tab): a fixed build that names the CVE.
About this advisory
This page gives the results of our analysis. It is not a statement from Oracle, the OpenJDK project, Calif or F5. Oracle and the OpenJDK Vulnerability Group confirmed the vulnerability, the affected versions and the CVSS 3.1 score. They did not publish the technical cause or the mitigation options. Those are from Calif. We tested the memory corruption, three fixed builds, the interim options, the check script and the iRule in our lab on November 18, 2026. We did not test an attack that runs code, the products that Calif names, Intel hardware, ARM hardware, or the Oracle builds. The code is licensed under the Apache License 2.0 and is supplied as it is, with no warranty. You are responsible for tests in your environment. We will update this page when more vendors publish fixed builds, when the fixed version numbers are confirmed, or when attacks are reported.