everythingsfine.io

runbook / 006 · Tailwind Resource Group · Customer advisory · Disclosed November 18, 2026

Find which of the ten NGINX issues of November 18, 2026 apply to you, and protect NGINX until you install 1.30.7 or 1.31.9

On November 18, 2026, F5 announced ten security issues in NGINX Open Source and NGINX Plus. Five are Critical. Install NGINX 1.30.7 or 1.31.9, or the NGINX Plus release in each F5 article. Until then, this page shows which issues apply to your configuration and what decreases your risk.

Applies to
NGINX Open Source and NGINX Plus
Fix
1.30.7 or 1.31.9
F5 articles
10: 5 Critical, 1 High, 4 Medium
Interim
1 check script, 6 F5 mitigations, 3 protocol changes
  1. Summary

    On November 18, 2026, F5 published an out-of-band security notification, F5 article K000164058. It has ten articles for NGINX Open Source and NGINX Plus.

    • By the CVSS v4.0 scores that F5 gives, 5 are Critical, 1 is High and 4 are Medium.
    • For the 5 Critical issues, F5 says that an attacker can stop or corrupt an NGINX worker process. F5 also says that the attacker can run code if Address Space Layout Randomization (ASLR) is disabled or the attacker can bypass it.
    • The High issue can put a worker in an endless loop. The worker then stops serving.
    • Of the Medium issues, two stop a worker, one lets a client skip the client certificate check in stream, and one can send a stream connection to the wrong backend.
    • Each issue needs a specific module or configuration. A configuration that does not have it is not affected by that issue.

    NGINX released 1.30.7 (stable) and 1.31.9 (mainline) on November 18, 2026. They correct all the issues that apply to their branch.

    Install NGINX Open Source 1.30.7 or 1.31.9, or the NGINX Plus release in each F5 article. This is the only complete correction. Until your change window, the check script in this page tells you which issues apply to your configuration. For six issues, F5 gives a mitigation. For the other four, the only interim step is to turn off the protocol that the issue needs. We tested the script, each F5 mitigation and each interim step on NGINX Open Source 1.30.6, 1.30.7, 1.31.8 and 1.31.9. We did not test NGINX Plus.

    The same notification has twelve BIG-IP and BIG-IQ issues. This page does not include them: see F5 article K000164058.

  2. Does this apply to you?

    You have more exposure if one or more of these statements is true:

    • You use NGINX Open Source 1.30.6 or older, or 1.31.0 to 1.31.8.
    • You use NGINX Plus R34 to R36, 37.0.x before 37.0.8.1, or 37.1.x or 37.2.x before 37.3.0.1.
    • Your configuration has the condition for one of the issues. See "Conditions".
    • Clients that you do not trust can connect to the listener that the condition applies to.

    Versions and severity

    These are the versions and scores that F5 gives. NGINX Open Source 1.30.7 and 1.31.9 have the fix for all ten. A version older than the first version in the range is not affected.

    CVE F5 article F5 severity (CVSS v4.0) Open Source versions affected (F5)
    CVE-2026-123634 K000163925 Critical 9.2 0.6.18 to 1.30.6, 1.31.0 to 1.31.8
    CVE-2026-123007 K000163926 Critical 9.2 1.9.5 to 1.30.6, 1.31.0 to 1.31.8
    CVE-2026-121810 K000163927 Critical 9.2 1.25.0 to 1.30.6, 1.31.0 to 1.31.8
    CVE-2026-123633 K000163928 Critical 9.2 1.19.7 to 1.30.6, 1.31.0 to 1.31.8
    CVE-2026-113425 K000163931 Critical 9.2 0.5.33 to 1.30.6, 1.31.0 to 1.31.8
    CVE-2026-118899 K000163930 High 8.7 1.13.0 to 1.30.6, 1.31.0 to 1.31.8 (NGINX, see the note)
    CVE-2026-120993 K000163932 Medium 6.9 1.30.6, 1.31.0 to 1.31.8 (see the note)
    CVE-2026-125283 K000163933 Medium 6.9 0.9.6 to 1.30.6, 1.31.0 to 1.31.8
    CVE-2026-120967 K000163934 Medium 6.3 1.25.5 to 1.30.6, 1.31.0 to 1.31.8
    CVE-2026-123640 K000163935 Medium 6.9 1.15.2 to 1.30.6, 1.31.0 to 1.31.8

    Two notes on this table:

    • CVE-2026-118899. On November 18, 2026, F5 article K000163930 gives only "1.13.0" for NGINX Open Source, and no fix. The NGINX security advisories page and the NGINX change log give 1.13.0 to 1.31.8, with the fix in 1.30.7 and 1.31.9. This page uses the NGINX range until F5 updates the article. On November 18, 2026, we asked F5 to confirm the range and the fix. We have no answer yet.
    • CVE-2026-120993. F5 lists 1.30.6. The NGINX security advisories page lists only 1.31.4 to 1.31.8, and the 1.30.7 change log does not name this CVE. In our lab, 1.30.6 and 1.30.7 refuse proxy_protocol v2; with "invalid value", so the condition cannot be configured on 1.30.x. Our analysis: 1.30.x is not affected by this issue. On November 18, 2026, we asked F5 if 1.30.6 is in the article in error. We have no answer yet.

    Conditions

    The conditions are from the F5 articles. The third column is what the check script looks for in the output of nginx -T.

    CVE Condition (F5) What the script looks for F5 mitigation
    CVE-2026-123634 A proxy with variables in the proxied server name, and an SSI or mirror subrequest to a location that resolves the same name resolver, proxy_pass with a $ variable, and ssi on or mirror Yes
    CVE-2026-123007 HTTP/2 in use http2 on or listen ... http2 None
    CVE-2026-121810 HTTP/3 in use listen ... quic None
    CVE-2026-123633 HTTP/2 for clients, a proxy to a backend, and a worker low on worker_connections HTTP/2 and a *_pass directive None
    CVE-2026-113425 NGINX is a mail proxy A mail block with a listen Yes
    CVE-2026-118899 listen ... ssl in the http block with TLSv1.3 enabled listen ... ssl with TLSv1.3 in the effective ssl_protocols None
    CVE-2026-120993 stream with dynamic certificate loading, proxy_protocol v2, and an abbreviated (resumed) handshake ssl_certificate with a variable, proxy_protocol v2, and session reuse not off Yes
    CVE-2026-125283 try_files and alias with a map variable that uses regex captures A location with alias and try_files that uses a map variable with unnamed captures Yes
    CVE-2026-120967 ssl_verify_client on; in a stream server that is not the default server of a shared listen socket The same Yes
    CVE-2026-123640 ssl_preread on; with routing on $ssl_preread_* variables ssl_preread on and a $ssl_preread_ variable Yes

    Defaults that matter when a directive is absent:

    • http2 is off and listen has no http2 unless you set it.
    • ssl_protocols is TLSv1.2 TLSv1.3 in NGINX 1.23.4 and later. A listen ... ssl with no ssl_protocols therefore has TLSv1.3.
    • In stream, ssl_session_tickets is on and ssl_session_cache is none. Session reuse is therefore on unless you set both to off.
    • ssi is off. The mirror directive is not set.
    • worker_connections is 512.

    The nginx -V output shows which modules your build has: --with-http_v2_module, --with-http_v3_module, --with-mail, --with-stream, --with-stream_ssl_module and --with-stream_ssl_preread_module. The SSI, mirror, map and try_files modules are in every build unless --without-... removes them. A directive that is in your configuration is in your build, because nginx -t fails for a directive that the build does not have.

    Other F5 products

    • Seven F5 articles also list other NGINX products as vulnerable: K000163925 (CVE-2026-123634), K000163930 (CVE-2026-118899), K000163931 (CVE-2026-113425), K000163932 (CVE-2026-120993), K000163933 (CVE-2026-125283), K000163934 (CVE-2026-120967) and K000163935 (CVE-2026-123640). The products are NGINX Instance Manager 2.19.0 to 2.24.1 (fixed in 2.25.0), F5 WAF for NGINX 5.9.0 to 5.16.1 (fixed in 5.16.2 and 5.14.4), NGINX App Protect WAF 4.12.0 to 4.16.0 and 5.4.0 to 5.8.0 (no fix), F5 DoS for NGINX 4.8.0 to 4.12.0 (fixed in 4.13.0), NGINX App Protect DoS 4.5.0 to 4.7.0 (no fix), NGINX Gateway Fabric 1.5.0 to 1.6.2 (no fix) and 2.0.0 to 2.8.1 (fixed in 2.9.0), and NGINX Ingress Controller 3.7.1 to 3.7.2 and 4.0.0 to 4.0.1 (no fix), 5.0.0 to 5.7.1 (fixed in 5.8.0) and 2026-lts-r1 to 2026-lts-r10 (fixed in 2026-lts-r11). K000163925 does not list NGINX App Protect WAF or NGINX App Protect DoS. K000163930 starts the NGINX Ingress Controller LTS range at 2026-lts-r3.
    • For the other three issues, CVE-2026-123007, CVE-2026-121810 and CVE-2026-123633, F5 lists only NGINX Plus and NGINX Open Source as vulnerable.
    • In all ten articles, F5 lists "NGINX (all other products)" as not vulnerable.
    • F5 Distributed Cloud and NGINX One Console: F5 is still researching nine of the ten issues. For CVE-2026-123640, F5 lists both as not vulnerable.
    • BIG-IP, BIG-IQ, F5OS, F5 Insight and F5 AI Gateway: F5 lists them as not vulnerable to these ten issues.

    Who is not affected

    • A build that does not have the configuration for an issue. Run the check script to find out.
    • For CVE-2026-120993, NGINX built with BoringSSL or AWS-LC (F5). The first line of the check script output shows the SSL library.
    • F5 did not evaluate third-party builds that include NGINX code, for example OpenResty, Angie, Tengine, or the NGINX packages of an operating system. F5 makes no statement about them. Ask the supplier.

    Distribution packages

    A distribution package can have the fix with an older version number. For example, Debian 12 has NGINX 1.22.1 with Debian patches. For these packages, the VERSION column of the check script is not enough: look at the security tracker of your distribution. On November 18, 2026, the Debian security tracker listed CVE-2026-123007 and CVE-2026-123633 as not fixed in bookworm, trixie, forky and sid, and had no entry for the other eight. See ## References.

    1. Run the check script on each NGINX host. It reads nginx -V and nginx -T and prints one line for each CVE. Start with the hosts that clients you do not trust can connect to.
    2. Schedule the upgrade. Install NGINX Open Source 1.30.7 or 1.31.9. For NGINX Plus, install the release that each F5 article gives. F5 has no fix for NGINX Plus R34 to R36: upgrade to 37.x.
    3. Use the F5 mitigation for each PRESENT line that has one. Six issues have one. Each is a configuration change, in the steps below.
    4. Decide on the interim step for the four issues with no mitigation. The only step is to turn off HTTP/2, HTTP/3 or TLS 1.3. Each has a cost for your clients. This is our analysis, not an F5 mitigation.
    5. Monitor for worker crashes and stuck workers. See ## What to monitor.
    6. After the upgrade, run the check script again. Each VERSION column must show FIXED. Then remove the interim steps that you no longer need.
  3. Find which issues apply to your configuration

    The script compares one NGINX installation with the ten issues. It runs nginx -V and nginx -T and reads their output. It does not change the configuration, writes no files, and prints no line of the configuration. It prints the version, the SSL library and one line for each CVE.

    nginx -T tests the configuration like nginx -t, then prints it. Like nginx -t, it opens the log files that the configuration names. Run the script as the user that can run nginx -t, usually root.

    Run the script

    Copy the script to the host. Run it with the nginx in your PATH, or give the binary and the configuration file:

    shell
    sh nginx_nov2026_check.sh
    shell
    sh nginx_nov2026_check.sh -b /usr/sbin/nginx -c /etc/nginx/nginx.conf

    To examine a host where you cannot copy the script, save the two outputs there and run the script on a different system:

    shell
    nginx -V > nginx-V.txt 2>&1; nginx -T > nginx-T.txt
    shell
    sh nginx_nov2026_check.sh -V nginx-V.txt -T nginx-T.txt

    The nginx -T output contains your whole configuration. Treat nginx-T.txt as a secret and delete it after use.

    Read the result

    This is the result for a lab configuration with HTTP/2 and a proxy, on NGINX 1.31.8:

    Example result
    Show all 13 linesHide 13 lines
    nginx 1.31.8, Open Source, SSL library OpenSSL
    CVE              VERSION       CONFIG   CONDITION THE SCRIPT LOOKS FOR
    CVE-2026-123634  AFFECTED      ABSENT   resolver, proxy_pass with a variable, and ssi on or mirror
    CVE-2026-123007  AFFECTED      PRESENT  HTTP/2 (http2 on, or listen ... http2)
    CVE-2026-121810  AFFECTED      ABSENT   HTTP/3 (listen ... quic); worker_connections 512
    CVE-2026-123633  AFFECTED      PRESENT  HTTP/2 and a proxy to a backend; worker_connections 512
    CVE-2026-113425  AFFECTED      ABSENT   mail proxy server
    CVE-2026-118899  AFFECTED      PRESENT  http listen ... ssl with TLSv1.3 in ssl_protocols
    CVE-2026-120993  AFFECTED      ABSENT   stream: ssl_certificate with a variable, proxy_protocol v2, session reuse on
    CVE-2026-125283  AFFECTED      ABSENT   location with alias and try_files that uses a map variable with unnamed regex captures
    CVE-2026-120967  AFFECTED      ABSENT   stream: ssl_verify_client on in a server that is not the default on a shared listen socket
    CVE-2026-123640  AFFECTED      ABSENT   stream: ssl_preread on and a $ssl_preread_ variable
    Note: VERSION compares the upstream version number only. A distribution package can have the fix with an older number.
    • VERSION. AFFECTED: the version number is in the vulnerable range. FIXED: the version has the fix. NOT AFFECTED: the version is older than the range. CHECK: NGINX Plus or an unknown version. Compare it with the F5 article.
    • CONFIG. PRESENT: the configuration has the condition. ABSENT: the script did not find it.
    • Exit status. 1 if a line is AFFECTED and PRESENT, 0 if not, 2 on an error.

    A line that is AFFECTED and PRESENT needs the upgrade, the F5 mitigation, or the interim step. For CVE-2026-123633 and CVE-2026-121810, the line also shows worker_connections. A worker that is low on connections is part of the condition. See ## What to monitor.

    ABSENT is not a statement that the system is safe. The script reads the directives that the F5 articles name. It does not find a condition that a module or a Lua or njs script makes at run time. For CVE-2026-113425, the mitigation does not remove the condition, so the line stays PRESENT. The line shows if a mail listener uses all addresses.

    The check script

    nginx_nov2026_check.shDownload
    Show all 327 linesHide 327 lines
    #!/bin/sh
    # Copyright 2026 Tailwind Resource Group
    # SPDX-License-Identifier: Apache-2.0
    # Provided as is, with no warranty. License: https://everythingsfine.io/license/
    #
    # nginx_nov2026_check.sh
    #
    # Purpose: compare one NGINX installation with the ten NGINX issues in F5
    # article K000164058, Out-of-band Security Notification (November 18, 2026).
    #
    # The script runs "nginx -V" and "nginx -T" and reads their output. It
    # changes nothing, writes no files and prints no line of the configuration.
    # Run it as the user that can run "nginx -t", usually root.
    #
    #   sh nginx_nov2026_check.sh                      use nginx from PATH
    #   sh nginx_nov2026_check.sh -b /usr/sbin/nginx   use this binary
    #   sh nginx_nov2026_check.sh -c /etc/nginx/nginx.conf
    #   sh nginx_nov2026_check.sh -V v.txt -T t.txt    read saved output
    #
    # Result: one line for each CVE.
    #   VERSION  AFFECTED      the version number is in the vulnerable range
    #            FIXED         the version number has the fix
    #            NOT AFFECTED  the version number is older than the range
    #            CHECK         NGINX Plus or an unknown version: see the article
    #   CONFIG   PRESENT       the configuration has the condition from the article
    #            ABSENT        the script did not find the condition
    # Exit status: 1 if a line is AFFECTED and PRESENT, 0 if not, 2 on error.
    #
    # This script is not from F5. ABSENT is not a statement that the system is
    # safe. A distribution package can have the fix with an older version
    # number. Tested on NGINX Open Source only.
    
    NGINX_BIN=nginx
    CONF=
    VFILE=
    TFILE=
    
    usage() {
        echo "usage: $0 [-b nginx-binary] [-c nginx.conf] [-V nginx-V.txt] [-T nginx-T.txt]" >&2
    }
    
    while getopts b:c:V:T:h opt; do
        case $opt in
            b) NGINX_BIN=$OPTARG ;;
            c) CONF=$OPTARG ;;
            V) VFILE=$OPTARG ;;
            T) TFILE=$OPTARG ;;
            *) usage; exit 2 ;;
        esac
    done
    
    if [ -n "$VFILE" ]; then
        NGX_V=$(cat -- "$VFILE") || exit 2
    else
        NGX_V=$("$NGINX_BIN" -V 2>&1) || {
            echo "error: could not run $NGINX_BIN -V" >&2; exit 2; }
    fi
    
    if [ -n "$TFILE" ]; then
        NGX_T=$(cat -- "$TFILE") || exit 2
    elif [ -n "$CONF" ]; then
        NGX_T=$("$NGINX_BIN" -T -q -c "$CONF" 2>/dev/null) || {
            echo "error: nginx -T failed. Run nginx -t to see why." >&2; exit 2; }
    else
        NGX_T=$("$NGINX_BIN" -T -q 2>/dev/null) || {
            echo "error: nginx -T failed. Run nginx -t to see why." >&2; exit 2; }
    fi
    
    export NGX_V
    printf '%s\n' "$NGX_T" | awk '
    function vnum(v,    a, n) {
        n = split(v, a, ".")
        return (a[1] + 0) * 1000000 + (a[2] + 0) * 1000 + (a[3] + 0)
    }
    function verdict(start) {
        if (plus || ver == "") return "CHECK"
        if (V < vnum(start)) return "NOT AFFECTED"
        if (V >= vnum("1.32.0")) return "FIXED"
        if (V >= vnum("1.31.9")) return "FIXED"
        if (V >= vnum("1.30.7") && V < vnum("1.31.0")) return "FIXED"
        return "AFFECTED"
    }
    function glob2re(g,    i, c, r) {
        r = "^"
        for (i = 1; i <= length(g); i++) {
            c = substr(g, i, 1)
            if (c == "*") r = r "[^/]*"
            else if (c == "?") r = r "[^/]"
            else if (c == "[" || c == "]") r = r c
            else if (c == "^") r = r "\\^"
            else if (c == "\\") r = r "\\\\"
            else if (index(".+$()|{}", c)) r = r "[" c "]"
            else r = r c
        }
        return r "$"
    }
    function has_unnamed(rx,    i, c, n, cls) {
        n = length(rx); cls = 0
        for (i = 1; i <= n; i++) {
            c = substr(rx, i, 1)
            if (c == "\\") { i++; continue }
            if (cls) { if (c == "]") cls = 0; continue }
            if (c == "[") { cls = 1; continue }
            if (c == "(" && substr(rx, i + 1, 1) != "?") return 1
        }
        return 0
    }
    function emit() { w[++nw] = tok; tok = ""; intok = 0 }
    function parse_file(f,    s, n, i, c, q, j, rest) {
        if (++seen[f] > 20) return
        s = content[f]; n = length(s); q = ""; tok = ""; intok = 0; invar = 0
        for (i = 1; i <= n; i++) {
            c = substr(s, i, 1)
            if (q != "") {
                if (c == "\\") { tok = tok c substr(s, i + 1, 1); i++; continue }
                if (c == q) { q = ""; emit(); continue }
                tok = tok c; continue
            }
            if (c == "#" && !intok) {
                rest = substr(s, i); j = index(rest, "\n")
                if (j == 0) break
                i = i + j - 1; continue
            }
            if (c == " " || c == "\t" || c == "\n" || c == "\r") {
                if (intok) emit()
                continue
            }
            if (c == "{" && intok && substr(tok, length(tok), 1) == "$") {
                tok = tok c; invar = 1; continue
            }
            if (c == "}" && invar) { tok = tok c; invar = 0; continue }
            if (c == ";") { if (intok) emit(); stmt(); continue }
            if (c == "{") { if (intok) emit(); block_open(); continue }
            if (c == "}") { if (intok) emit(); block_close(); continue }
            if ((c == "\"" || c == "\047") && !intok) { q = c; intok = 1; continue }
            if (c == "\\") { tok = tok substr(s, i + 1, 1); i++; intok = 1; continue }
            tok = tok c; intok = 1
        }
        if (intok) emit()
    }
    function do_include(pat,    re, k, list, nl, x) {
        if (substr(pat, 1, 1) != "/") pat = prefix "/" pat
        re = glob2re(pat); nl = 0
        for (k = 1; k <= nf; k++) if (order[k] ~ re) list[++nl] = order[k]
        nw = 0
        for (x = 1; x <= nl; x++) parse_file(list[x])
    }
    function scan_args(    k) {
        for (k = 1; k <= nw; k++)
            if (index(w[k], "$ssl_preread_")) prereadvar = 1
    }
    function eff(arr, s, def) {
        if ((s, "set") in arr) return arr[s]
        if ((0, "set") in arr) return arr[0]
        return def
    }
    function setv(arr, s, v) { arr[s] = v; arr[s, "set"] = 1 }
    function stmt(    mod, typ, s, l, k, a, key, rx) {
        if (nw == 0) return
        if (w[1] == "include") { do_include(w[2]); nw = 0; return }
        mod = M[depth]; typ = T[depth]; s = S[depth]; l = L[depth]
        scan_args()
        if (typ == "map") {
            key = w[1]
            if (key ~ /^~/) {
                rx = key; sub(/^~\*?/, "", rx)
                if (has_unnamed(rx)) mapcap[curmap] = 1
            }
            nw = 0; return
        }
        if (typ == "types" || typ == "geo" || typ == "split_clients" || typ == "upstream" || typ == "match") {
            nw = 0; return
        }
        if (w[1] == "worker_connections") wc = w[2]
        if (mod == "http") {
            if (w[1] == "resolver") h_resolver = 1
            if (w[1] == "proxy_pass") { h_pass = 1; if (index(w[2], "$")) h_proxyvar = 1 }
            if (w[1] ~ /^(grpc|fastcgi|uwsgi|scgi|memcached)_pass$/) h_pass = 1
            if (w[1] == "ssi" && w[2] == "on") h_ssi = 1
            if (w[1] == "mirror" && w[2] != "off") h_mirror = 1
            if (w[1] == "http2" && w[2] == "on") h_h2 = 1
            if (w[1] == "listen" && s) {
                for (k = 2; k <= nw; k++) {
                    if (w[k] == "http2") h_h2 = 1
                    if (w[k] == "quic") h_h3 = 1
                    if (w[k] == "ssl") hssl[s] = 1
                }
            }
            if (w[1] == "ssl_protocols") {
                a = ""
                for (k = 2; k <= nw; k++) a = a " " w[k]
                if (s) hproto[s] = a; else { h_proto = a; h_proto_set = 1 }
            }
            if (l && w[1] == "alias") { lalias[l] = 1; largs[l] = largs[l] " " w[2] }
            if (l && w[1] == "try_files") {
                ltry[l] = 1
                for (k = 2; k <= nw; k++) largs[l] = largs[l] " " w[k]
            }
        }
        if (mod == "stream") {
            if (w[1] == "listen" && s) {
                a = w[2]
                if (a ~ /^[0-9]+$/) a = "*:" a
                sub(/^0\.0\.0\.0:/, "*:", a)
                for (k = 3; k <= nw; k++) if (w[k] == "udp") a = a "/udp"
                for (k = 3; k <= nw; k++) if (w[k] == "default_server") sdef[a] = s
                if (!((a, s) in lsrv)) {
                    lsrv[a, s] = 1; lcount[a]++; lnth[a, lcount[a]] = s
                    if (!(a in lseen)) { lseen[a] = 1; laddr[++nla] = a }
                }
            }
            if (w[1] == "ssl_verify_client") setv(svc, s, w[2])
            if (w[1] == "ssl_certificate") setv(scv, s, index(w[2], "$") ? 1 : 0)
            if (w[1] == "proxy_protocol") setv(spp, s, w[2])
            if (w[1] == "ssl_session_tickets") setv(stk, s, w[2])
            if (w[1] == "ssl_session_cache") setv(sch, s, w[2])
            if (w[1] == "ssl_preread" && w[2] == "on") preread = 1
        }
        if (mod == "mail" && s && w[1] == "listen") {
            mailsrv = 1
            a = w[2]
            if (a ~ /^[0-9]+$/ || a ~ /^\*:/ || a ~ /^0\.0\.0\.0:/ || a ~ /^\[::\]:/) mailwild = 1
        }
        nw = 0
    }
    function block_open(    name, mod) {
        name = w[1]; scan_args()
        depth++
        T[depth] = name; M[depth] = M[depth - 1]; S[depth] = S[depth - 1]; L[depth] = L[depth - 1]
        if (name == "http" || name == "stream" || name == "mail") { M[depth] = name; S[depth] = 0; L[depth] = 0 }
        if (name == "server") { S[depth] = ++nsrv; smod[nsrv] = M[depth]; L[depth] = 0 }
        if (name == "location") L[depth] = ++nloc
        if (name == "map") {
            curmap = w[3]
            if (M[depth] == "http") hmap[curmap] = 1
        }
        nw = 0
    }
    function block_close() { if (depth > 0) depth--; nw = 0 }
    function line(cve, start, cond, text) {
        vd = verdict(start)
        printf "%-16s %-13s %-8s %s\n", cve, vd, cond ? "PRESENT" : "ABSENT", text
        if (vd == "AFFECTED" && cond) hit = 1
    }
    BEGIN {
        vtext = ENVIRON["NGX_V"]
        if (match(vtext, /nginx\/[0-9]+\.[0-9]+\.[0-9]+/))
            ver = substr(vtext, RSTART + 6, RLENGTH - 6)
        plus = (vtext ~ /nginx-plus/)
        V = vnum(ver)
        lib = "unknown"
        if (vtext ~ /built with OpenSSL/) lib = "OpenSSL"
        if (vtext ~ /BoringSSL/) lib = "BoringSSL"
        if (vtext ~ /AWS-LC/) lib = "AWS-LC"
        if (vtext ~ /LibreSSL/) lib = "LibreSSL"
        nf = 0
    }
    /^# configuration file .*:$/ {
        cur = substr($0, 22, length($0) - 22)
        if (!(cur in content)) { order[++nf] = cur; content[cur] = "" }
        else cur = ""
        next
    }
    { if (cur != "") content[cur] = content[cur] $0 "\n" }
    END {
        if (nf == 0) { print "error: no configuration in the nginx -T output" > "/dev/stderr"; exit 2 }
        prefix = order[1]; sub(/\/[^\/]*$/, "", prefix)
        depth = 0; T[0] = "main"; M[0] = ""; S[0] = 0; L[0] = 0
        parse_file(order[1])
        if (wc == "") wc = "512 (default)"
    
        c1 = h_resolver && h_proxyvar && (h_ssi || h_mirror)
    
        defproto = (V >= vnum("1.23.4")) ? " TLSv1.2 TLSv1.3" : " TLSv1 TLSv1.1 TLSv1.2"
        c6 = 0
        for (s = 1; s <= nsrv; s++) {
            if (smod[s] != "http" || !hssl[s]) continue
            p = (s in hproto) ? hproto[s] : (h_proto_set ? h_proto : defproto)
            if (p ~ /TLSv1\.3/) c6 = 1
        }
    
        c7 = 0
        if (lib != "BoringSSL" && lib != "AWS-LC")
            for (s = 1; s <= nsrv; s++) {
                if (smod[s] != "stream") continue
                if (eff(scv, s, 0) && eff(spp, s, "off") == "v2" &&
                    !(eff(stk, s, "on") == "off" && eff(sch, s, "none") == "off")) c7 = 1
            }
    
        c8 = 0
        for (l = 1; l <= nloc; l++) {
            if (!lalias[l] || !ltry[l]) continue
            for (m in mapcap) if ((m in hmap) && index(largs[l], m)) c8 = 1
        }
    
        c9 = 0
        for (i = 1; i <= nla; i++) {
            a = laddr[i]
            if (lcount[a] < 2) continue
            d = (a in sdef) ? sdef[a] : lnth[a, 1]
            if (eff(svc, d, "off") == "on") continue
            for (k = 1; k <= lcount[a]; k++) {
                s = lnth[a, k]
                if (s != d && eff(svc, s, "off") == "on") c9 = 1
            }
        }
    
        c10 = preread && prereadvar
    
        printf "nginx %s, %s, %s\n", (ver == "" ? "unknown version" : ver), (plus ? "NGINX Plus" : "Open Source"), "SSL library " lib
        printf "%-16s %-13s %-8s %s\n", "CVE", "VERSION", "CONFIG", "CONDITION THE SCRIPT LOOKS FOR"
        line("CVE-2026-123634", "0.6.18", c1, "resolver, proxy_pass with a variable, and ssi on or mirror")
        line("CVE-2026-123007", "1.9.5", h_h2, "HTTP/2 (http2 on, or listen ... http2)")
        line("CVE-2026-121810", "1.25.0", h_h3, "HTTP/3 (listen ... quic); worker_connections " wc)
        line("CVE-2026-123633", "1.19.7", h_h2 && h_pass, "HTTP/2 and a proxy to a backend; worker_connections " wc)
        line("CVE-2026-113425", "0.5.33", mailsrv, "mail proxy server" (mailsrv ? (mailwild ? "; a listener on all addresses" : "; listeners on specific addresses") : ""))
        line("CVE-2026-118899", "1.13.0", c6, "http listen ... ssl with TLSv1.3 in ssl_protocols")
        line("CVE-2026-120993", "1.30.6", c7, "stream: ssl_certificate with a variable, proxy_protocol v2, session reuse on" ((lib == "BoringSSL" || lib == "AWS-LC") ? "; " lib " is not affected" : ""))
        line("CVE-2026-125283", "0.9.6", c8, "location with alias and try_files that uses a map variable with unnamed regex captures")
        line("CVE-2026-120967", "1.25.5", c9, "stream: ssl_verify_client on in a server that is not the default on a shared listen socket")
        line("CVE-2026-123640", "1.15.2", c10, "stream: ssl_preread on and a $ssl_preread_ variable")
        if (!plus && (V == vnum("1.30.6") || (V >= vnum("1.31.0") && V < vnum("1.31.4"))))
            print "Note: for CVE-2026-120993, F5 lists 1.30.6 and 1.31.0 to 1.31.8; nginx.org lists only 1.31.4 to 1.31.8."
        print "Note: VERSION compares the upstream version number only. A distribution package can have the fix with an older number."
        if (plus) print "Note: for NGINX Plus, compare your release with each F5 article. This script was not tested on NGINX Plus."
        exit hit
    }'
  4. Install the fixed version

    NGINX Open Source

    Install 1.30.7 if you use the stable branch, or 1.31.9 if you use the mainline branch. A branch older than 1.30 has no fix: move to 1.30.7.

    • Packages from the NGINX repository. Update the nginx package with your package manager.
    • Distribution packages. Install the update from your distribution when it is available. Look at the security tracker of your distribution for each CVE.
    • Built from source. Build 1.30.7 or 1.31.9 with the same configure arguments that nginx -V shows. Check the PGP signature of the source archive.

    A reload (nginx -s reload) does not start a new binary. After the upgrade, restart the service, or do the binary upgrade that the NGINX documentation describes. Then confirm the version:

    shell
    nginx -v

    In our lab, each test configuration on this page loaded and served with no change on 1.30.7 and 1.31.9. The exception is proxy_protocol v2;, which 1.30.x does not accept on any version.

    NGINX Plus

    We did not test NGINX Plus. This table is from the F5 articles. F5 has no fix for NGINX Plus R34 to R36: upgrade to 37.x.

    CVE NGINX Plus 37.1.x and 37.2.x NGINX Plus 37.0.x
    CVE-2026-123634 Fixed in 37.3.0.1 Fixed in 37.0.8.1
    CVE-2026-123007 Fixed in 37.3.0.1 Fixed in 37.0.8.1
    CVE-2026-121810 Fixed in 37.3.0.1 Fixed in 37.0.8.1
    CVE-2026-123633 Fixed in 37.2.0.1 Fixed in 37.0.7.1
    CVE-2026-113425 Fixed in 37.3.0 Fixed in 37.0.8
    CVE-2026-118899 Fixed in 37.3.0.1 Fixed in 37.0.8.1
    CVE-2026-120993 Fixed in 37.3.0 (only 37.2.0 is affected) Not listed
    CVE-2026-125283 Fixed in 37.3.0 Fixed in 37.0.8
    CVE-2026-120967 Fixed in 37.3.0 Fixed in 37.0.8
    CVE-2026-123640 Fixed in 37.2.0.1 (only 37.1.0 is affected) Fixed in 37.0.7.1

    Our analysis of this table: NGINX Plus 37.3.0.1 and 37.0.8.1 have the fixes for all ten issues.

  5. Use the F5 mitigations

    Six issues have an F5 mitigation. Each one is a configuration change. Use it only if the check script shows the issue as AFFECTED and PRESENT. After each change, test and reload:

    shell
    nginx -t && nginx -s reload

    Then run the check script again. Except for CVE-2026-113425, the line must show ABSENT. We tested each change on 1.30.6, 1.30.7, 1.31.8 and 1.31.9 (1.31.x only for CVE-2026-120993).

    CVE-2026-123634: a proxied server name with no variables

    F5 says: do not use SSI or mirror, and do not use variables in the proxied server name. One of the two is enough to remove the condition. The change that keeps SSI and mirror working is to put the backend in an upstream block. Replace this:

    nginx
    location /up/ {
        set $backend_host "backend.example.com";
        proxy_pass http://$backend_host:9001;
    }

    with this, in the http block:

    nginx
    upstream backend_up {
        server backend.example.com:9001;
    }

    and this, in the server block:

    nginx
    location /up/ {
        proxy_pass http://backend_up;
    }

    NGINX resolves a name in an upstream block when it loads the configuration, not for each request. If the name changes, a reload is necessary. In our lab, the SSI page included the backend response after the change. The other choice is ssi off; and no mirror directive. That stops the SSI or mirror function.

    CVE-2026-113425: mail listeners on trusted networks only

    F5 says: restrict listeners to trusted networks. The mail module has no allow and deny directives. Put each mail listener on an internal address, and block the port at the firewall for all other networks. Replace listen 25; with the internal address:

    nginx
    mail {
        server {
            listen 192.0.2.10:25;
            protocol smtp;
        }
    }

    In our lab, after this change the listener answered on the internal address and refused connections on the other addresses of the host. We did not test a firewall rule. The condition is still present after this change: a client on the trusted network can still connect.

    CVE-2026-120993: PROXY protocol v1, or no session reuse

    F5 gives two choices. Use one of them in each stream server that has ssl_certificate with a variable and proxy_protocol v2;.

    The first choice: send PROXY protocol version 1, if the backend accepts it, or no PROXY protocol:

    nginx
    proxy_protocol on;

    The second choice: turn off abbreviated handshakes. Both directives are necessary:

    nginx
    ssl_session_tickets off;
    ssl_session_cache off;

    In our lab on 1.31.8 and 1.31.9, proxy_protocol on; sent the client address to a backend that has listen ... proxy_protocol. Before the change, a client that offered its saved session resumed it ("Reused"), with TLS 1.2 and TLS 1.3. With tickets and cache off, the TLS 1.2 handshake gave the client no session to save, and a TLS 1.3 client that offered a session got a full handshake ("New"). In our lab, ssl_session_tickets off; with ssl_session_cache none; also gave full handshakes, but F5 names off: use off. The check script follows F5. The cost of the second choice: each connection does a full handshake, which uses more CPU.

    CVE-2026-125283: named captures in the map

    F5 says: use named captures, not unnamed ones, and do not use the same capture variable in other regex matches. Replace the unnamed capture (.*) and $1:

    nginx
    map $uri $file_name {
        ~^/files/(.*)$  $1;
        default         "";
    }

    with a named capture:

    nginx
    map $uri $file_name {
        ~^/files/(?<fname>.*)$  $fname;
        default                 "";
    }

    Use a capture name that no other regex in the configuration uses. In our lab, the location with alias and try_files $file_name served the same files after the change.

    CVE-2026-120967: client certificates on the default server too

    F5 gives two choices. The first: set ssl_verify_client on; in the default server of the shared listen socket too:

    nginx
    Show all 16 linesHide 16 lines
    stream {
        server {
            listen 9444 ssl default_server;
            server_name a.example.com;
            ssl_verify_client on;
            ssl_client_certificate /etc/nginx/ca.crt;
            proxy_pass 127.0.0.1:9001;
        }
        server {
            listen 9444 ssl;
            server_name b.example.com;
            ssl_verify_client on;
            ssl_client_certificate /etc/nginx/ca.crt;
            proxy_pass 127.0.0.1:9002;
        }
    }

    The cost: all clients of the default server must then send a client certificate. In our lab, a client with no certificate got no data from either server after this change.

    The second choice: give the server that needs client certificates its own address and port:

    nginx
    Show all 14 linesHide 14 lines
    stream {
        server {
            listen 9444 ssl default_server;
            server_name a.example.com;
            proxy_pass 127.0.0.1:9001;
        }
        server {
            listen 9445 ssl;
            server_name b.example.com;
            ssl_verify_client on;
            ssl_client_certificate /etc/nginx/ca.crt;
            proxy_pass 127.0.0.1:9002;
        }
    }

    The cost: clients of that server must use the new port or address. A client that still connects to the old port with that server name gets the default server. In our lab, port 9445 refused a client with no certificate, and port 9444 served the default server to all clients.

    CVE-2026-123640: terminate TLS on NGINX, not ssl_preread

    F5 says: remove ssl_preread and terminate TLS on NGINX, then route on $ssl_server_name. This configuration routes on the server name that the client sends in the ClientHello, before TLS:

    nginx
    Show all 11 linesHide 11 lines
    stream {
        map $ssl_preread_server_name $backend {
            internal.example.com  127.0.0.1:9002;
            default               127.0.0.1:9001;
        }
        server {
            listen 9443;
            ssl_preread on;
            proxy_pass $backend;
        }
    }

    This is the F5 replacement. NGINX does the TLS handshake and routes on the server name of the handshake. proxy_ssl on; and the two lines after it are necessary only if the backends still expect TLS:

    nginx
    Show all 16 linesHide 16 lines
    stream {
        map $ssl_server_name $backend {
            internal.example.com  127.0.0.1:9002;
            default               127.0.0.1:9001;
        }
        server {
            listen 9443 ssl;
            ssl_certificate     /etc/nginx/ssl/fullchain.pem;
            ssl_certificate_key /etc/nginx/ssl/privkey.pem;
            ssl_protocols       TLSv1.2 TLSv1.3;
            proxy_pass $backend;
            proxy_ssl on;
            proxy_ssl_server_name on;
            proxy_ssl_name $ssl_server_name;
        }
    }

    The costs: NGINX must have a certificate and key for each name that clients use, and it sees the decrypted traffic. Client certificate authentication between the client and the backend no longer works, because the TLS session ends on NGINX. In our lab, before and after the change, the name of the privileged backend went to that backend, and other names and connections with no name went to the public backend.

  6. Interim steps for the four issues with no mitigation

    F5 gives no mitigation for CVE-2026-123007, CVE-2026-121810, CVE-2026-123633 and CVE-2026-118899. The only interim step is to remove the condition: turn off the protocol that the issue needs. This is our analysis, not an F5 mitigation. Each step has a cost for your clients. Use it only where the check script shows the issue as AFFECTED and PRESENT, and only until you upgrade.

    Turn off HTTP/2 (CVE-2026-123007 and CVE-2026-123633)

    Remove each http2 on; and each http2 parameter of listen. Or set it off in the http block, and remove it from each server:

    nginx
    http2 off;

    What a client sees: in our lab, curl --http2 got HTTP/1.1. A client that offers only h2, with no http/1.1, failed the handshake with "no application protocol". Browsers offer both and use HTTP/1.1. The costs: browsers open more connections and pages can load more slowly. gRPC clients need HTTP/2 and stop working. If a load balancer in front of NGINX speaks HTTP/2 to it, change it to HTTP/1.1 first.

    Turn off HTTP/3 (CVE-2026-121810)

    Remove each listen ... quic line, and the Alt-Svc header that announces HTTP/3:

    nginx
    listen 443 ssl;

    What a client sees: in our lab, no UDP listener was left, our HTTP/3 test client got no answer before its time limit, and HTTPS over TCP still worked. The cost: clients use HTTP/2 or HTTP/1.1. A browser that saved the Alt-Svc header tries HTTP/3 first until the ma time ends. It then uses TCP after a delay. Block UDP to the port at the firewall too, so that those clients fail fast.

    Turn off TLS 1.3 on TCP listeners (CVE-2026-118899)

    Set the protocols in the http block, and remove ssl_protocols from each server, or set it to the same value there:

    nginx
    ssl_protocols TLSv1.2;

    F5 names only listen ... ssl for this issue. HTTP/3 always uses TLS 1.3, and NGINX refuses a listen ... quic in a server whose ssl_protocols does not have TLSv1.3. To keep HTTP/3, put the quic listener in its own server block:

    nginx
    server {
        listen 443 ssl;
        server_name www.example.com;
        add_header Alt-Svc 'h3=":443"; ma=86400';
    }
    server {
        listen 443 quic reuseport;
        ssl_protocols TLSv1.3;
        server_name www.example.com;
    }

    Each server block also needs its ssl_certificate, ssl_certificate_key and location blocks. The 1.30.7 and 1.31.9 corrections make the same change in the HTTP/3 request body code. NGINX describes that change as "for the sake of correctness" and does not say that HTTP/3 is affected. We found no evidence that it is: in the source, the QUIC receive code does not get into the state that the TCP correction removes.

    What a client sees: in our lab, openssl s_client -tls1_3 failed with "alert protocol version", and TLS 1.2 clients worked as before. With the two server blocks, our HTTP/3 test client still got a response. The costs: clients that offer only TLS 1.3 cannot connect. Policies that require TLS 1.3 fail. Make sure that ssl_ciphers gives TLS 1.2 clients forward secrecy (ECDHE).

    Estimate: more worker_connections (CVE-2026-123633 and CVE-2026-121810)

    This is an estimate. It is not a mitigation. The F5 article for CVE-2026-123633, and the NGINX change log for both issues, say that the issue occurs when a worker does not have enough worker_connections. A higher value can make that state less likely:

    nginx
    events {
        worker_connections 4096;
    }

    The value must stay below the open file limit of the worker (worker_rlimit_nofile). An attacker who can open many connections can still use all of them. A statement from F5 or NGINX that this decreases the risk would confirm it. We did not test it against the issue.

  7. What to monitor

    • A worker that stops on a signal. Seven of the issues can stop a worker. The error log shows an alert line worker process <pid> exited on signal 11, often with (core dumped). The kernel log shows a segfault line for nginx (journalctl -k), and coredumpctl list nginx shows the core files. The master process starts a new worker, so the service can look normal. In our lab, the master started a new worker at once after we stopped a worker with kill -KILL. Search the error log of each host:
    shell
    grep -E 'exited on signal|worker_connections are not enough|could not cancel' /var/log/nginx/error.log
    • A worker that stops serving. CVE-2026-118899 can put a worker in an endless loop. The worker uses 100% of one CPU and its connections stop. NGINX writes no log line for it. Look for an nginx: worker process at 100% CPU (top, or ps -o pid,pcpu,etime,cmd -C nginx). To stop that worker, use kill -KILL <pid>. If it is a current worker, the master process starts a new one. In our lab, a reload started new workers and the service answered again, but the old worker stayed until kill -KILL. We modeled a worker that stopped with SIGSTOP, not with the issue.
    • No free connections. CVE-2026-123633 and CVE-2026-121810 need a worker that is low on connections. The error log shows an alert line <n> worker_connections are not enough, or a warn line <n> worker_connections are not enough, reusing connections.
    • The resolver alert. Our analysis of the 1.30.7 correction for CVE-2026-123634: before the fix, NGINX writes an alert line could not cancel <name> resolving to the error log. The fixed versions write it only at debug level. On a version that is not fixed, this line shows that the code of this issue ran. It is not a proof of an attack.
    • Stream connections that go to the wrong backend (CVE-2026-123640). Log the server name and the backend in stream, as in the F5 article. A privileged backend that gets connections with a server name that you do not expect is a sign. Compare the stream log with the access log of the backend.
    • Stream clients with no client certificate (CVE-2026-120967). Log $ssl_client_verify and $status for each stream server that has ssl_verify_client on;. Put these two lines in the stream block:
    nginx
    log_format cv "$ssl_server_name $server_port verify=$ssl_client_verify status=$status sent=$bytes_sent";
    access_log /var/log/nginx/stream-verify.log cv;

    In our lab, a client with no certificate that NGINX refused gave verify=NONE status=500 sent=0, and a client with a certificate gave verify=SUCCESS status=200. A line for a server that requires certificates with status=200 and a verify value other than SUCCESS is a sign that the check did not occur.

    • Mail proxy (CVE-2026-113425). Look for connections to the mail listeners from networks that you do not expect, and for the worker crashes above.
  8. References

  9. About this advisory

    This page gives the results of our analysis. It is not a statement from F5 or NGINX. F5 has confirmed the conditions, the versions, the fixes and the mitigations that this page attributes to F5. The interim steps for the four issues with no F5 mitigation, the monitoring signs that are not in the F5 articles, and the check script are our work. We tested them on NGINX Open Source 1.30.6, 1.30.7, 1.31.8 and 1.31.9, built from source with OpenSSL 3.0. We did not test NGINX Plus, distribution packages or third-party builds, and we did not test any attack. 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. On November 18, 2026, we asked F5 about the two places where this page does not agree with the F5 articles: the NGINX Open Source versions for CVE-2026-118899 and for CVE-2026-120993. We will update this page when F5 answers or updates the articles, and when F5 gives the status of F5 Distributed Cloud and NGINX One Console.