everythingsfine.io

runbook / 002 · Tailwind Resource Group · Customer advisory · Disclosed October 21, 2026

Update PHP and BIG-IP for php2shell, and protect your PHP servers until you do

Two PHP flaws let an attacker who has not logged in run code on a web server. Attacks started before the fix was public. Update PHP, and update BIG-IP, because BIG-IP uses PHP too. This page gives you the checks, settings, signatures and an iRule that decrease your risk until then.

CVE
CVE-2026-109618, CVE-2026-109619
PHP fix
8.2.35, 8.3.36, 8.4.27, 8.5.12
BIG-IP fix
17.1.3.7, 17.5.1.11, 21.1.0.4
Log prefix
php2shell:
  1. Summary

    On October 21, 2026, the PHP project released PHP 8.2.35, 8.3.36, 8.4.27 and 8.5.12. These releases correct two critical vulnerabilities, CVE-2026-109618 and CVE-2026-109619. Together they are named "php2shell". Each has a CVSS 4.0 score of 9.2. An attacker who has not logged in can run code on the web server with the privileges of the PHP worker.

    • CVE-2026-109618. PHP can stop in the middle of a request when it runs out of memory. Request cleanup then uses memory that is not ready. The PHP project confirmed remote code execution on Apache with mod_php, with the default limits, before any application code runs.
    • CVE-2026-109619. A persistent PHP worker can keep data from a request after PHP releases that memory. A later request to the same worker can use the old data. The confirmed paths go through session upload progress and, on PHP 8.5, fatal error backtraces.

    F5 Labs saw the first scans five hours before the releases. CISA added both CVEs to its Known Exploited Vulnerabilities catalog on October 26, 2026.

    BIG-IP also uses PHP. F5 article K000163821 lists the BIG-IP Configuration utility on all modules, and the APM access profile, as affected. F5 released fixed BIG-IP versions on October 23, 2026.

    Update PHP on every server, and upgrade BIG-IP. The PHP project says that no setting is a complete mitigation. The steps on this page decrease your risk until your change window.

  2. Does this apply to you?

    You are at risk if one or more of these statements is true:

    • A web server runs PHP 8.2, 8.3, 8.4 or 8.5 earlier than 8.2.35, 8.3.36, 8.4.27 or 8.5.12.
    • A web server runs PHP 8.1 or earlier, and your vendor has not supplied a package that names these CVEs. The PHP project does not release fixes for these branches.
    • You run PHP as an Apache module (mod_php). The PHP project confirmed remote code execution for both CVEs on mod_php. PHP-FPM, FrankenPHP and LiteSpeed (LSAPI) are also at risk.
    • An appliance or product that you operate uses PHP for its web interface. Many network and storage vendors have published their own advisories.
    • You operate BIG-IP 17.1.0 to 17.1.3, 17.5.0 to 17.5.1, or 21.1.0. If APM or SSLO is provisioned, the attack does not need a logon. On other systems, the attacker must log on to the Configuration utility.

    Not affected, as F5 states in K000163821: BIG-IQ, F5OS, NGINX products, F5 Distributed Cloud and BIG-IP Next.

    Linux distributions often backport fixes and keep the old version number. A server that shows an old number can be fixed. Read the package changelog to confirm. The check script below does this for RPM and Debian packages.

    1. Update PHP. Install PHP 8.2.35, 8.3.36, 8.4.27, 8.5.12 or a later release, or your vendor's package that names CVE-2026-109618 and CVE-2026-109619. Restart every PHP worker. Do mod_php servers that the internet can reach first.
    2. Upgrade BIG-IP. Install 17.1.3.7, 17.5.1.11 or 21.1.0.4. Do systems with APM or SSLO first. F5 article K000163848 lists the fixed releases.
    3. Restrict the BIG-IP Configuration utility. Permit only your management networks. This step is correct also after the upgrade.
    4. Apply the interim PHP settings on servers that you cannot update today. Turn off session upload progress and limit request input.
    5. Enforce the three F5 attack signatures on each Advanced WAF policy that protects a PHP application. If you do not have Advanced WAF, add the iRule below in log-only mode.
    6. Look for signs of an attack from October 20, 2026 onward. See "What to monitor". If you find signs, treat the server as compromised. An update does not remove an attacker who is already on the server.
  3. Find the PHP versions on a server

    This script reports each PHP binary, its version and its state. It also reports the Apache PHP module, the vendor changelog entries for the two CVEs, and the interim settings. It changes nothing. Run it as root on each server.

    The settings come from php -i and php-fpm -i. Apache mod_php, FPM pools, .htaccess files and the web server can change the values that a web request uses. Read your configuration to confirm. Do not publish a phpinfo() page to check: it shows your configuration to everyone.

    php2shell-check.sh

    php2shell-check.shDownload
    Show all 96 linesHide 96 lines
    #!/usr/bin/env bash
    # Copyright 2026 Tailwind Resource Group
    # SPDX-License-Identifier: Apache-2.0
    # Provided as is, with no warranty. License: https://everythingsfine.io/license/
    #
    # php2shell-check.sh
    #
    # Read-only. Reports the PHP versions, the Apache PHP module, vendor
    # backports and the interim settings on this host for CVE-2026-109618
    # and CVE-2026-109619 ("php2shell"). It changes nothing.
    #
    # Run as root, so that apachectl and php-fpm can read their configuration.
    # Exit status: 0 = every PHP binary found is a fixed release,
    # 1 = one or more is not, or is not known, 2 = no PHP binary found.
    
    set -u
    
    # Fixed release for each supported branch.
    fixed_patch() {
        case "$1" in
            8.2) echo 35 ;;
            8.3) echo 36 ;;
            8.4) echo 27 ;;
            8.5) echo 12 ;;
            *) echo "" ;;
        esac
    }
    
    status=0
    found=0
    seen=""
    
    for bin in php php-fpm php-cgi \
        /usr/bin/php[0-9]* /usr/sbin/php-fpm* /usr/local/bin/php /usr/local/sbin/php-fpm \
        /opt/remi/php*/root/usr/bin/php /opt/remi/php*/root/usr/sbin/php-fpm; do
        path=$(command -v "$bin" 2>/dev/null) || continue
        real=$(readlink -f "$path" 2>/dev/null || echo "$path")
        case " $seen " in *" $real "*) continue ;; esac
        seen="$seen $real"
        found=1
    
        ver=$("$real" -v 2>/dev/null | sed -n '1s/^PHP \([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\).*/\1/p')
        if [ -z "$ver" ]; then
            echo "UNKNOWN  $real: cannot read the version"
            status=1
            continue
        fi
        branch=${ver%.*}
        patch=${ver##*.}
        want=$(fixed_patch "$branch")
        if [ -z "$want" ]; then
            echo "CHECK    $real: PHP $ver. The PHP project does not fix this branch. Ask your vendor for a backport, or upgrade."
            status=1
        elif [ "$patch" -ge "$want" ]; then
            echo "FIXED    $real: PHP $ver (fixed in $branch.$want)"
        else
            echo "UPDATE   $real: PHP $ver (fixed in $branch.$want). A vendor backport can keep the old number: see below."
            status=1
        fi
    
        case "$real" in
            *php-cgi*) ;;
            *)
                "$real" -i 2>/dev/null | grep -E '^(Server API|Loaded Configuration File|Scan this dir|session\.upload_progress\.enabled|fatal_error_backtraces|memory_limit|post_max_size|max_input_nesting_level) ' | sed 's/^/         /'
                ;;
        esac
    done
    
    echo
    echo "Apache PHP module (mod_php has the highest risk):"
    apache_found=0
    for ctl in apachectl apache2ctl httpd; do
        if command -v "$ctl" >/dev/null 2>&1; then
            apache_found=1
            "$ctl" -M 2>/dev/null | grep -Ei 'php[0-9_]*_module' | sed "s/^/         $ctl: /"
        fi
    done
    [ "$apache_found" -eq 1 ] || echo "         no apachectl, apache2ctl or httpd found"
    
    echo
    echo "Vendor package changelogs that name the CVEs (backports):"
    if command -v rpm >/dev/null 2>&1; then
        for pkg in $(rpm -qa 2>/dev/null | grep -E '^php[0-9.]*-(common|cli|fpm)-' ); do
            rpm -q --changelog "$pkg" 2>/dev/null | grep -m 1 -E 'CVE-2026-10961[89]' | sed "s/^/         $pkg: /"
        done
    fi
    for log in /usr/share/doc/php*/changelog.Debian.gz; do
        [ -r "$log" ] || continue
        gzip -dc -- "$log" | grep -m 1 -E 'CVE-2026-10961[89]' | sed "s|^|         $log: |"
    done
    
    if [ "$found" -eq 0 ]; then
        echo "No PHP binary found on this host."
        exit 2
    fi
    exit "$status"

    Each line starts with one word:

    Word Meaning Action
    FIXED The version is a fixed release or later. None.
    UPDATE The version is earlier than the fixed release. Update, or confirm a vendor backport in the changelog section.
    CHECK The PHP project does not fix this branch. Ask your vendor, or upgrade to a supported branch.
    UNKNOWN The script cannot read the version. Check the binary manually.
  4. Interim PHP settings

    Use these settings only on a server that you cannot update today. They come from the PHP advisories. They remove the confirmed attack paths that a setting can remove, and decrease the input that PHP decodes before your code runs. They do not correct the vulnerabilities.

    Session upload progress stays off after you update. The PHP project recommends that you keep it off if no application uses it. A separate, lower-risk issue, CVE-2026-115560, also goes through this feature.

    php2shell-interim.ini

    Put the file in the directory that PHP scans for additional .ini files. The command php --ini shows the directory. Each PHP version and SAPI can have its own directory, for example /etc/php/8.3/fpm/conf.d/ and /etc/php/8.3/apache2/conf.d/ on Debian. Then restart Apache or PHP-FPM.

    php2shell-interim.iniDownload
    Show all 30 linesHide 30 lines
    ; Copyright 2026 Tailwind Resource Group
    ; SPDX-License-Identifier: Apache-2.0
    ; Provided as is, with no warranty. License: https://everythingsfine.io/license/
    ;
    ; php2shell-interim.ini
    ;
    ; Interim settings for CVE-2026-109618 and CVE-2026-109619 ("php2shell").
    ; They decrease the risk. They do not correct the vulnerabilities.
    ; Install PHP 8.2.35, 8.3.36, 8.4.27, 8.5.12 or later.
    ;
    ; Put this file in the directory that PHP scans for additional .ini files
    ; ("php --ini" shows it) for each PHP installation and SAPI. Then restart
    ; all PHP workers. Pool, directory, .htaccess and PHP_VALUE settings can
    ; change these values. See the runbook.
    
    ; CVE-2026-109619: remove the session upload progress path.
    ; Keep it off after you update, unless an application needs it.
    session.upload_progress.enabled = 0
    
    ; CVE-2026-109618: decrease the input that PHP decodes before your code
    ; runs. Set each value to the smallest value that your applications need.
    post_max_size = 8M
    upload_max_filesize = 7M
    max_file_uploads = 20
    max_input_vars = 1000
    max_input_nesting_level = 16
    
    ; PHP 8.5: remove the fatal error backtrace path (CVE-2026-109619).
    ; PHP 8.4 and earlier do not have this directive and ignore it.
    fatal_error_backtraces = 0
    • Set the limits for your applications. If an application accepts large uploads, increase post_max_size and upload_max_filesize to the smallest values it needs. If a form has deeply nested field names, increase max_input_nesting_level.
    • Remove late configuration. CVE-2026-109619 can use a warning that PHP writes while it applies settings at the start of a request. Move php_value and php_flag lines from .htaccess files into php.ini. Remove PHP_VALUE and PHP_ADMIN_VALUE from the FastCGI parameters in nginx or Apache. Remove obsolete directives.
    • Make sure that nothing turns the feature back on. A pool file, a .user.ini file or an application can set session.upload_progress.enabled. Search for it.
    • Optional: recycle workers. In PHP-FPM, pm.max_requests = 1 makes each request use a new worker. This removes most of the stale state between requests. It costs CPU. Test the load first.

    The PHP advisory gives one more partial step for CVE-2026-109618: memory_limit = -1, which removes the limit that the attack uses. We do not put it in the file. Without a memory limit, one request can use all the memory of the server. If you use it, set a memory limit for the service in systemd or the container instead, and do not use RLIMIT_AS or RLIMIT_DATA. The PHP project says these make the vulnerable path more likely.

  5. Enforce the F5 attack signatures on Advanced WAF

    F5 article K000163821 lists three attack signatures for these CVEs. Use them on each BIG-IP Advanced WAF policy that protects a PHP application.

    Signature ID Name CVE
    200204113 PHP Remote Code Execution CVE-2026-109619
    200103697 PHP Remote Code Execution (2) CVE-2026-109618
    200204115 PHP Remote Code Execution (3) CVE-2026-109618
    1. Install the signature update. Go to System > Software Management > Live Update. Install ASM-AttackSignatures_20261022_154742 or a later file. F5 changed signatures 200103697 and 200204115 in this file. If the system only downloads updates, the status shows that the file is not installed.
    2. Put the signatures in the policy. The usual "Generic Detection Signatures" set does not contain PHP signatures. Add the PHP server technology to the policy, or make a manual signature set with the three IDs and assign it to the policy. In the policy, go to Attack Signatures and search for "PHP Remote Code Execution". You must see all three.
    3. 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.
    4. Make sure that the policy blocks. The policy enforcement mode must be Blocking, and the signature set must have Block selected in Learning and Blocking Settings.
    5. Check again after each signature update. When F5 changes a signature, the new version can go back to staging.

    K000163821 also gives optional policy settings. Scripts that partners published to apply K000163821 check these HTTP protocol compliance checks: "Bad multipart/form-data request parsing", "Bad multipart parameters parsing", "Check maximum number of headers", "Check maximum number of parameters", "Chunked request with Content-Length header", "Several Content-Length headers", and "Unparsable request content". Read K000163821 for the current list, and test each one in transparent mode first. They can block valid uploads.

    Signatures do not replace the PHP update. A signature finds known forms of the attack. The PHP project says that out-of-memory errors can also come from application input that a signature does not know. Update PHP.

  6. iRule for PHP servers behind BIG-IP without Advanced WAF

    This iRule examines requests to PHP pool members. It finds the request forms that the PHP advisories and F5 Labs describe:

    • The user agents of public php2shell scanners.
    • Multipart POST requests that are chunked or have no Content-Length header. The PHP advisory says that this form can pass the post_max_size check.
    • Multipart POST requests larger than static::p2s_max_body.
    • The session upload progress field name in the first static::p2s_scan_bytes of a multipart body. F5 Labs reported that most attempts use this field.

    Attach it to each HTTP virtual server whose pool members run PHP. It starts in log-only mode. In our lab, the body scan used about 1 to 2 ms of one TMM for each multipart POST. On a site with many uploads, watch the CPU use when you attach it.

    This iRule is a partial control. It examines only the first 128 KB of a body. An attack can put the field after that point, or use an out-of-memory form that the iRule does not know. It does not protect BIG-IP itself. Use it with the interim PHP settings, and update PHP.

    iRule php2shell_upload_guard

    php2shell_upload_guard.tclDownload
    Show all 102 linesHide 102 lines
    # Copyright 2026 Tailwind Resource Group
    # SPDX-License-Identifier: Apache-2.0
    # Provided as is, with no warranty. License: https://everythingsfine.io/license/
    #
    # php2shell_upload_guard
    #
    # Tested on BIG-IP 17.5.1.x. Start in log-only mode.
    #
    # Purpose: temporary filter for multipart requests to PHP applications,
    # until the PHP servers run 8.2.35, 8.3.36, 8.4.27, 8.5.12 or later
    # (CVE-2026-109618 and CVE-2026-109619, "php2shell").
    # This iRule does not replace the PHP update.
    #
    # It finds:
    #   - user agents of public php2shell scanners
    #   - multipart POST requests that are chunked or have no Content-Length
    #   - multipart POST requests larger than static::p2s_max_body
    #   - the session upload progress field name in the first
    #     static::p2s_scan_bytes of a multipart body
    #
    # Attach to: HTTP virtual servers whose pool members run PHP.
    # It does not protect BIG-IP itself. See the runbook for BIG-IP.
    # Log: /var/log/ltm, prefix "php2shell:". The iRule does not log body content.
    
    when RULE_INIT {
        # 1 = log only. 0 = log and reject with HTTP 403.
        set static::p2s_log_only 1
    
        # 1 = reject every multipart POST. Use only if no application on the
        # virtual server accepts file uploads or multipart forms.
        set static::p2s_block_multipart 0
    
        # The PHP default for session.upload_progress.name. If your servers
        # use a different name, put it here in lower case.
        set static::p2s_field "php_session_upload_progress"
    
        # Bytes of each multipart body to examine.
        set static::p2s_scan_bytes 131072
    
        # Largest multipart body to permit. Make it equal to post_max_size.
        set static::p2s_max_body 8388608
    }
    
    when HTTP_REQUEST priority 40 {
        set p2s_collect 0
        set p2s_reason ""
    
        set p2s_ua [string tolower [HTTP::header value "User-Agent"]]
        if { [string first "php2shell" $p2s_ua] >= 0 || [string first "php-upload-progress-scan" $p2s_ua] >= 0 } {
            set p2s_reason "scanner_user_agent"
        } elseif { [HTTP::method] eq "POST" } {
            set p2s_ctype [string tolower [string trimleft [HTTP::header value "Content-Type"]]]
            if { [string first "multipart/" $p2s_ctype] == 0 } {
                set p2s_len [HTTP::header value "Content-Length"]
                if { $static::p2s_block_multipart } {
                    set p2s_reason "multipart_not_permitted"
                } elseif { [HTTP::header exists "Transfer-Encoding"] || $p2s_len eq "" } {
                    set p2s_reason "multipart_no_content_length"
                } elseif { ![string is digit -strict $p2s_len] || [string length $p2s_len] > 12 } {
                    set p2s_reason "bad_content_length"
                } else {
                    # Remove leading zeros, so that Tcl does not read the value as octal.
                    set p2s_len [string trimleft $p2s_len "0"]
                    if { $p2s_len eq "" } { set p2s_len 0 }
                    if { $p2s_len > $static::p2s_max_body } {
                        set p2s_reason "multipart_too_large len=$p2s_len"
                    } elseif { $p2s_len > 0 } {
                        set p2s_collect 1
                        if { $p2s_len > $static::p2s_scan_bytes } {
                            HTTP::collect $static::p2s_scan_bytes
                        } else {
                            HTTP::collect $p2s_len
                        }
                    }
                }
            }
        }
    
        if { $p2s_reason ne "" } {
            log local0.warning "php2shell: reason=$p2s_reason client=[IP::client_addr] vs=[virtual name] path=[HTTP::path] enforce=[expr {!$static::p2s_log_only}]"
            if { !$static::p2s_log_only } {
                set p2s_collect 0
                HTTP::respond 403 content "Forbidden" "Content-Type" "text/plain" "Connection" "close"
            }
        }
    }
    
    when HTTP_REQUEST_DATA priority 40 {
        if { !$p2s_collect } { return }
        set p2s_collect 0
    
        set p2s_body [string tolower [HTTP::payload $static::p2s_scan_bytes]]
        set p2s_found [string first $static::p2s_field $p2s_body]
        unset p2s_body
    
        if { $p2s_found >= 0 } {
            log local0.warning "php2shell: reason=upload_progress_field client=[IP::client_addr] vs=[virtual name] path=[HTTP::path] enforce=[expr {!$static::p2s_log_only}]"
            if { !$static::p2s_log_only } {
                HTTP::respond 403 content "Forbidden" "Content-Type" "text/plain" "Connection" "close"
            }
        }
    }
  7. How to install, tune, and remove the iRule

    Install

    1. Save a UCS archive of the configuration.
    2. In the Configuration utility, go to Local Traffic > iRules > iRule List. Click Create.
    3. Enter the name php2shell_upload_guard. Paste the iRule text. Click Finished.
    4. Go to Local Traffic > Virtual Servers. Open the virtual server. On the Resources tab, click Manage in the iRules area.
    5. Move the iRule to Enabled. Click Finished.
    6. Synchronize the configuration to the other units in the device group.

    Read the log

    shell
    grep 'php2shell:' /var/log/ltm

    Each entry gives a reason, the client address, the virtual server and the path. Example:

    /var/log/ltm
    php2shell: reason=upload_progress_field client=203.0.113.7 vs=/Common/vs_shop path=/index.php enforce=0
    • upload_progress_field from a valid user means an application uses session upload progress. Change the application, because the interim PHP settings turn this feature off.
    • multipart_too_large from a valid user means static::p2s_max_body is too small. Make it equal to post_max_size on the pool members.
    • multipart_no_content_length from a valid client is rare. Browsers send a Content-Length header with forms. Find the client before you block.
    • bad_content_length shows only for a Content-Length of more than 12 digits. The HTTP profile rejects a value that is not a number before the iRule runs.

    Change to blocking mode

    1. Keep log-only mode for a minimum of one full business day. Include a file upload in each application.
    2. Open the iRule. Change set static::p2s_log_only 1 to 0. Click Update.
    3. Do a test upload. A rejected request gets an HTTP 403 response.

    If no application on the virtual server accepts uploads, you can also set static::p2s_block_multipart to 1. The PHP advisory recommends this when multipart requests are not necessary.

    Remove

    1. Remove the iRule from each virtual server.
    2. Delete the iRule from the iRule List.
    3. Synchronize the configuration.

    Remove the iRule after every pool member runs a fixed PHP release.

  8. Upgrade and protect BIG-IP

    F5 article K000163821 describes two paths on BIG-IP:

    Path Who can attack Affected Fixed
    APM access profile Any client that can reach the APM virtual server 17.1.0 to 17.1.3, 17.5.0 to 17.5.1, 21.1.0 17.1.3.7, 17.5.1.11, 21.1.0.4
    Configuration utility, all modules A user who can log on 17.1.0 to 17.1.3, 17.5.0 to 17.5.1, 21.1.0 17.1.3.7, 17.5.1.11, 21.1.0.4

    An earlier version of K000163821 also listed SSLO with APM. Treat a system with SSLO provisioned like an APM system. F5 evaluates only versions that have technical support.

    The fix is a backport. A fixed BIG-IP still reports PHP 5.4.45, so a scanner that reads the PHP version can report a fixed system as vulnerable. Check the BIG-IP version and the package changelog.

    Check a BIG-IP system

    This script reports the version, the PHP changelog entries for the CVEs, the interim file, APM and SSLO provisioning, and access to the Configuration utility. It changes nothing. Run it in the advanced shell (bash) as root, on each unit.

    bigip-php2shell-check.shDownload
    Show all 75 linesHide 75 lines
    #!/bin/bash
    # Copyright 2026 Tailwind Resource Group
    # SPDX-License-Identifier: Apache-2.0
    # Provided as is, with no warranty. License: https://everythingsfine.io/license/
    #
    # bigip-php2shell-check.sh
    #
    # Read-only. Run in the BIG-IP advanced shell (bash) as root.
    # Reports the facts that decide your BIG-IP exposure to CVE-2026-109618
    # and CVE-2026-109619 ("php2shell"): version, PHP fix, interim file,
    # APM and SSLO provisioning, and access to the Configuration utility.
    # It changes nothing. Compare the result with F5 article K000163821.
    
    set -u
    
    # Return 0 if version $1 is equal to or later than version $2.
    ver_ge() {
        local -a a b
        local i x y
        IFS=. read -r -a a <<< "$1"
        IFS=. read -r -a b <<< "$2"
        for i in 0 1 2 3; do
            x=${a[i]:-0}
            y=${b[i]:-0}
            if (( 10#$x > 10#$y )); then return 0; fi
            if (( 10#$x < 10#$y )); then return 1; fi
        done
        return 0
    }
    
    ver=$(tmsh show sys version | awk '$1 == "Version" { print $2; exit }')
    edition=$(tmsh show sys version | awk '$1 == "Edition" { $1 = ""; sub(/^ /, ""); print; exit }')
    echo "Version: $ver ($edition)"
    
    case "$ver" in
        17.1.*) fixed=17.1.3.7 ;;
        17.5.*) fixed=17.5.1.11 ;;
        21.1.*) fixed=21.1.0.4 ;;
        *) fixed="" ;;
    esac
    
    if ! [[ "$ver" =~ ^[0-9]+(\.[0-9]+){1,3}$ ]]; then
        echo "CHECK   Cannot read the version."
    elif [ -z "$fixed" ]; then
        echo "CHECK   This branch is not in the K000163821 tables that we read. Read K000163821."
    elif ver_ge "$ver" "$fixed"; then
        echo "FIXED   $ver is $fixed or later."
    else
        echo "UPGRADE $ver is earlier than $fixed."
    fi
    
    echo
    echo "PHP package changelog entries for the CVEs:"
    rpm -q php --changelog 2>/dev/null | grep -E 'CVE-2026-10961[89]' || echo "        none found"
    
    echo
    echo "Interim PHP settings (/etc/php.ini.d):"
    ls -l /etc/php.ini.d/ 2>/dev/null || echo "        no /etc/php.ini.d directory"
    php -i 2>/dev/null | grep -E '^(Additional \.ini files parsed|memory_limit|post_max_size|upload_max_filesize|session\.upload_progress\.enabled) '
    
    echo
    echo "Provisioning (APM or SSLO puts the unauthenticated path in scope):"
    for module in apm sslo; do
        tmsh list sys provision "$module" one-line 2>/dev/null
    done
    
    echo
    echo "Configuration utility access on the management port (K13309):"
    tmsh list sys httpd allow
    
    echo
    echo "Self IPs that permit HTTPS to the Configuration utility:"
    tmsh list net self allow-service one-line 2>/dev/null \
        | grep -E 'allow-service (all|default|\{[^}]*(tcp:443|tcp:https)[^}]*\})' \
        || echo "        none"
    • UPGRADE means the version is earlier than the fixed release for its branch.
    • A self IP that the script lists permits HTTPS to the Configuration utility from the networks that reach that self IP. Set its port lockdown to Allow None or to the services you need.
    • The sys httpd allow list must contain only your management networks. See F5 article K13309.

    Interim settings on BIG-IP

    If you cannot upgrade today, K000163821 gives PHP settings for BIG-IP. They are the PHP project's interim settings, in a file in /etc/php.ini.d/. Use the file and the restart commands exactly as the current version of K000163821 gives them. At the time we wrote this page, the file set memory_limit = -1, post_max_size = 8M, upload_max_filesize = 7M and session.upload_progress.enabled = 0, and the commands restarted httpd and, on APM systems, httpd_sam.

    • The restart of httpd stops the Configuration utility for a short time. The restart of httpd_sam can end APM sessions. Use a change window.
    • Do it on each unit in the device group, and on each blade of a chassis.
    • The file does not stay after an upgrade. F5 article K000163878 recommends that you keep session.upload_progress.enabled = 0 after the upgrade, for CVE-2026-115560. Put that setting back after you upgrade.
  9. What to monitor

    Use this script on web server access logs, error logs and PHP-FPM logs. It reads .gz files. It changes nothing.

    php2shell-log-search.sh

    php2shell-log-search.shDownload
    Show all 47 linesHide 47 lines
    #!/usr/bin/env bash
    # Copyright 2026 Tailwind Resource Group
    # SPDX-License-Identifier: Apache-2.0
    # Provided as is, with no warranty. License: https://everythingsfine.io/license/
    #
    # php2shell-log-search.sh
    #
    # Read-only. Searches web server and PHP logs for signs of php2shell
    # (CVE-2026-109618 and CVE-2026-109619) scans and attempts.
    #
    # Usage: php2shell-log-search.sh LOGFILE...
    # Give access logs, error logs and PHP-FPM logs. Files that end in .gz
    # are read with gzip. The access log check expects the combined format.
    
    set -u
    
    if [ "$#" -eq 0 ]; then
        echo "usage: $0 LOGFILE..." >&2
        exit 2
    fi
    
    read_log() {
        case "$1" in
            *.gz) gzip -dc -- "$1" ;;
            *) cat -- "$1" ;;
        esac
    }
    
    for f in "$@"; do
        if [ ! -r "$f" ]; then
            echo "skip: cannot read $f" >&2
            continue
        fi
        echo "== $f"
    
        echo "-- Public scanner user agents"
        read_log "$f" | grep -Ei 'php2shell|php-upload-progress-scan' | head -n 50
    
        echo "-- PHP worker crashes"
        read_log "$f" | grep -E 'exit signal (Segmentation fault|Aborted|Bus error)|exited on signal (6|7|11)' | head -n 50
    
        echo "-- PHP memory exhaustion"
        read_log "$f" | grep -E 'Allowed memory size of [0-9]+ bytes exhausted|Out of memory' | head -n 50
    
        echo "-- Clients with the most POST requests to / or /index.php"
        read_log "$f" | awk '$6 == "\"POST" && ($7 == "/" || $7 ~ /^\/index\.php/) { print $1 }' | sort | uniq -c | sort -rn | head -n 20
    done
    • Scanner user agents. F5 Labs reported these user agents: php2shell-verify/1.0, php2shell-scan/1.0, php2shell-scanner/1.0, php2shell-poc/1.0, php2shell-109618 and php-upload-progress-scan/1.0. A match is a scan. Attacks also use normal browser user agents, so no match does not mean no attack.
    • Many POST requests to / or /index.php from one address. F5 Labs reported repeated multipart requests to these paths, each with a new boundary and a new session ID. F5 Labs says that this pattern can prepare the memory of the worker for the attack.
    • PHP worker crashes. Look for exit signal Segmentation fault in the Apache error log, and exited on signal 11 in the PHP-FPM log. Both CVEs use memory after PHP releases it. A failed attempt can crash a worker.
    • Bursts of memory errors. Many Allowed memory size ... exhausted errors from requests that do not usually use much memory can show attempts on CVE-2026-109618.
    • Advanced WAF events. In Security > Event Logs > Application > Requests, filter on the three signature IDs.
    • iRule entries. Look for php2shell: in /var/log/ltm.
    • Signs of a compromise. New PHP files in web directories, new cron jobs or users, and outbound connections from the web server user. The attacker runs code as the PHP worker user.

    If you think a server is compromised, isolate it and keep its logs and disk before you make changes. Contact your incident response team. The CISA catalog entry for these CVEs calls for forensic triage under BOD 26-04.

  10. References

  11. About this advisory

    This page gives the results of our analysis. It is not a statement from the PHP project, F5 or CISA. The PHP project confirmed the vulnerabilities, the fixed releases and the interim settings. F5 confirmed the BIG-IP exposure, the fixed BIG-IP versions and the signatures in K000163821. F5 Labs reported the scan and request patterns. The iRule and the scripts are ours. We tested the iRule on BIG-IP 17.5.1.x in log-only and blocking mode, over HTTP and HTTPS. We tested the scripts against sample data only. Nothing on this page is tested on a PHP server. 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 the PHP project or F5 changes its advisory.