# nginx2root: Five critical nginx vulnerabilities (incl. unauthenticated RCE) plus Linux kernel SCTP use-after-free enabling root chain (CVE-2026-123007, CVE-2026-123634, CVE-2026-123633, CVE-2026-121810, CVE-2026-113425)

> Xint researchers disclosed five nginx memory-corruption flaws (one HTTP/2 integer overflow with out-of-bounds heap write and four use-after-free bugs in the resolver/mirror, HTTP/2, HTTP/3 and mail proxy code) that let an unauthenticated remote attacker run commands as the nginx worker. Chained with an unpatched Linux kernel SCTP send-path use-after-free (no CVE, present since Linux 4.15), any one of them yields root on the host, including from a Docker container. Fixed in nginx 1.31.9 (mainline) and 1.30.7 (stable); no exploitation in the wild has been reported.

- **Published:** 2026-11-18T18:51:44Z
- **Last reviewed:** 2026-11-18T20:38:44.686Z
- **Canonical:** https://intel.threadlinqs.com/threat/TL-2026-6363
- **ID:** TL-2026-6363
- **Severity:** CRITICAL (CVSS 9.2)
- **Category:** VULNERABILITY
- **Status:** MONITORING
- **Detections:** 9 (1 shown free below) · **IOCs:** 31 (3 shown free below)
- **CVEs:** CVE-2026-123007, CVE-2026-123634, CVE-2026-123633, CVE-2026-121810, CVE-2026-113425

## Description

On 2026-11-18 Xint (reported to F5 via HackerOne on 2026-10-16) and Aikido Security published 'nginx2root'. It covers five nginx vulnerabilities and one Linux kernel flaw. Each nginx bug lets an unauthenticated attacker run commands on the server. The authors withheld the final exploit steps and published demo videos (AWS, GCP, Azure, bare metal) at nginx2root.com. No public exploit code is stated.

CVE-2026-123007 (HTTP/2 flow control) is the most widely reachable. When a queued stream is cancelled, cleanup returns its deducted credit to the connection-level send window without checking the HTTP/2 maximum (2^31-1). ngx_http_v2_state_window_update() then computes its remaining-capacity check with unsigned arithmetic that wraps. The window grows past its valid range and, read as a signed off_t, goes negative. That produces an oversized memcpy length and an out-of-bounds heap write, used for address disclosure and then a cleanup function-pointer overwrite to execute commands with worker privileges. It affects every official release from 1.9.5 (2015) through 1.31.8 (1.9.5-1.30.6 and 1.31.0-1.31.8 per the Wiz-based report). It needs only HTTP/2 enabled and leaves little in access logs, because WINDOW_UPDATE and RST_STREAM frames are not logged as requests. Wiz reportedly demonstrated code execution on a plain static-file server. Xint validated it on AWS, GCP and Azure over a public HTTPS endpoint.

CVE-2026-123634 (resolver/mirror) is a use-after-free. When a request and its mirror subrequest wait on the same resolver node, a failed lookup can end the main request. Cleanup frees the mirror's resolver context while the resolver loop still holds a pointer to it, so the loop uses the freed context. Heap reclamation gives control of 'next' and 'handler'. It requires a resolver, a request-derived proxy_pass (e.g. proxy_pass http://$host;), mirror with mirror_request_body off, and a resolver that can reach the attacker's authoritative DNS server. It affects releases from 1.13.4. Other subrequest features such as SSI may reach the same bug, and disabling mirror alone does not make a server safe.

CVE-2026-123633 (HTTP/2 upstream) is a use-after-free. An HTTP/2 connection with an incomplete frame is put on the reusable-connection queue and never removed by the read handler. If the completed request opens an upstream connection and triggers connection draining, the drain closes the same connection and frees the request pool while the upstream code keeps running on the freed request. Heap grooming points the upstream connection at an attacker address, and a fake request reclaims the memory with a read handler set to execv(). It needs nginx to forward HTTP/2 requests upstream and to be able to open a TCP connection to the attacker. It affects releases from 1.19.7. The vendor-linked report says the worker must also be low on available connections. ingress-nginx is vulnerable and will not be patched (AIKIDO-2026-17300).

CVE-2026-121810 (HTTP/3 QUIC) follows the same pattern. Stream creation briefly removes the parent QUIC connection from the reusable queue and re-queues it before the stream is in the parent's stream tree, so a later drain closes the parent while an upstream connect is running. It affects releases from 1.25.0.

CVE-2026-113425 (mail proxy) is a use-after-free in auth_http. If a client sends a login and resets the TCP connection in the same event-loop iteration, the client connection and pool are destroyed while the auth connection still points to the freed session. A later event uses the freed context pointer, and an IMAP LOGIN can reclaim the memory with a fake session carrying an attacker-controlled handler. No authentication is required. It affects releases from 0.5.15 with 'proxy on' and auth_http.

The Linux kernel SCTP bug has no CVE ID. A waiting send operation can continue after its association is transferred to another socket and then free the transferred association, giving a use-after-free or double free. It was introduced in Linux 4.15 (2018). It gives a KASLR-defeating memory disclosure and an arbitrary kernel function call. In testing it gave root from an nginx worker and a root shell on the host from a Docker container running nginx. Reachability depends on kernel, modules and container restrictions. No kernel patch existed at publication, and exploit details are withheld until one is available.

Exposure: Shodan returned 56.7 million hosts for product:nginx on 2026-11-10. Of the 11.94 million (21.1%) that reported a version, 98.9% fell in the CVE-2026-123007 range. These are reported versions, not confirmed vulnerability. Distro packages may backport fixes without changing the 'nginx -v' string (for example Ubuntu 22.04 1.18.0-6ubuntu14.22). The vendor-linked report rates CVE-2026-123633 and CVE-2026-123007 at CVSS 4.0 9.2. Per-CVE scores for the other three are not stated.

## MITRE ATT&CK

- T1190 Exploit Public-Facing Application
- T1203 Exploitation for Client Execution
- T1059.004 Unix Shell
- T1611 Escape to Host
- T1499.004 Application or System Exploitation
- T1068 Exploitation for Privilege Escalation

## Free detection (Splunk SPL, Microsoft KQL, Sigma)

**nginx2root: Shell Spawned by nginx Worker Process (Post-Exploitation RCE Outcome)** (`TL-2026-6363-SPL-001`)

Detects /bin/sh, /bin/bash or another shell executed by the nginx worker UID (execve/execveat). Per Xint this is the clearest sign of successful exploitation of the nginx2root bugs (CVE-2026-123007 HTTP/2 integer overflow/OOB write, CVE-2026-123634 resolver/mirror UAF, CVE-2026-123633 HTTP/2 upstream UAF, CVE-2026-121810 HTTP/3 UAF, CVE-2026-113425 mail auth_http UAF), where a cleanup function pointer or read handler is overwritten with execv(). A web server worker should essentially never start a shell.

- **Languages:** Splunk SPL, Microsoft KQL, Sigma
- **ATT&CK:** T1190, T1059.004, T1203
- **Data sources:** auditd, linux_audit, sysmon_for_linux, defender_for_endpoint_linux
- **Severity:** critical
- **Confidence:** high

### Splunk SPL

```spl
index=linux sourcetype="linux:audit" type=SYSCALL key="nginx_worker_exec" (syscall=59 OR syscall=322) (exe="/bin/sh" OR exe="/bin/bash" OR exe="/bin/dash" OR exe="/bin/ash" OR exe="/usr/bin/sh" OR exe="/usr/bin/bash" OR exe="/usr/bin/dash" OR exe="/bin/busybox" OR exe="/usr/bin/busybox") | stats count min(_time) as first_seen max(_time) as last_seen values(exe) as spawned_shell values(comm) as comm values(ppid) as parent_pid values(auid) as login_uid by host, uid | eval first_seen=strftime(first_seen,"%Y-%m-%d %H:%M:%S"), last_seen=strftime(last_seen,"%Y-%m-%d %H:%M:%S"), detection="TL-2026-6363 nginx2root shell spawned by nginx worker (CVE-2026-123007, CVE-2026-123633, CVE-2026-123634, CVE-2026-121810, CVE-2026-113425)" | table first_seen last_seen host uid spawned_shell comm parent_pid login_uid count detection
```

### Microsoft KQL

```kql
DeviceProcessEvents
| where Timestamp > ago(24h)
| where InitiatingProcessFileName =~ "nginx"
| where InitiatingProcessCommandLine has "worker process"
| where FileName in~ ("sh", "bash", "dash", "ash", "zsh", "busybox")
| project Timestamp, DeviceName, AccountName, FileName, ProcessCommandLine, InitiatingProcessFileName, InitiatingProcessCommandLine, InitiatingProcessParentFileName, ReportId
| order by Timestamp desc
```

### Sigma

```yaml
title: nginx2root - Shell Spawned by nginx Worker Process
id: 7c1a4e52-3b8d-4f6a-9e21-0d5b8a6c3f11
status: experimental
description: Detects a shell started by an nginx worker process, the clearest sign of successful exploitation of the nginx2root vulnerabilities (CVE-2026-123007 and related) per Xint
references:
    - https://www.aikido.dev/blog/nginx2root-critical-nginx-rce-vulnerabilities
    - https://xint.io/blog/nginx2root-remote-code-execution
author: Threadlinqs Team
date: 2026/11/18
tags:
    - attack.initial-access
    - attack.t1190
    - attack.execution
    - attack.t1059.004
    - attack.t1203
    - cve.2026.123007
    - cve.2026.123634
    - cve.2026.123633
    - cve.2026.121810
    - cve.2026.113425
logsource:
    category: process_creation
    product: linux
detection:
    selection_parent:
        ParentImage|endswith: '/nginx'
    selection_child:
        Image|endswith:
            - '/sh'
            - '/bash'
            - '/dash'
            - '/ash'
            - '/zsh'
            - '/busybox'
    condition: selection_parent and selection_child
falsepositives:
    - Custom CGI/exec wrappers or lua/njs modules that deliberately shell out from nginx (rare, should be allow-listed by command line)
    - Administrators running nginx reload via a wrapper script that reports nginx as parent
level: critical

```

**Known false positives:**

- Custom modules (njs, lua, fcgiwrap-style helpers) that intentionally spawn a shell from the nginx worker
- Administrative reload scripts launched under the nginx UID

**Tuning notes:** Install the auditd rule first (auditctl -a always,exit -F arch=b64 -S execve,execveat -F uid=<nginx_worker_uid> -k nginx_worker_exec); events exist only after installation. Adjust the uid and audit key to your environment, add arch=b32 where relevant, and allow-list known wrapper commands by full command line rather than excluding nginx wholesale. Alert at critical severity and isolate the host; also check for a later root shell (see the SCTP/privilege-escalation detections).

### 8 more detection rules (Splunk SPL, Microsoft KQL, Sigma), unlock with TL Creds

- nginx2root: HTTP/2 Connection Churn Against nginx Listener (CVE-2026-123007 Trigger) (locked: unlock with TL Creds)
- nginx2root: Reverse-Shell or Download Tooling Launched by nginx Worker (locked: unlock with TL Creds)
- nginx2root: nginx Resolver Queries to Unapproved DNS Server (CVE-2026-123634) (locked: unlock with TL Creds)
- nginx2root: Root-Owned Process Spawned by nginx Worker (Privilege Escalation) (locked: unlock with TL Creds)
- nginx2root: SCTP Kernel Module Load or Autoload Request (modprobe sctp / net-pf-proto-132) (locked: unlock with TL Creds)
- nginx2root: nginx Worker Outbound Connection to Unapproved Public Address (Upstream Hijack / C2) (locked: unlock with TL Creds)
- nginx2root: Repeated nginx Worker Crashes (Failed Heap-Corruption Exploitation) (locked: unlock with TL Creds)
- nginx2root: SCTP Socket Creation (Linux Kernel SCTP UAF Root Chain) (locked: unlock with TL Creds)

Sign up free to unlock the detection rules: https://threadlinqs.com/?modal=signup

## Sample indicators (3 of 31)

Defanged, TLP:CLEAR.

- Domain: `nginx2root[.]com`
- URL: `hxxps://github[.]com/sfewer-r7/CVE-2026-123007`
- File hash: `b89c4100bf6762a45e4a6463eaf4b70368277c94`

Full set of 31 indicators unlocks with TL Creds: https://threadlinqs.com/tl-creds

## Sources

- [nginx2root: Critical nginx vulnerabilities, including one RCE (Aikido Security)](https://www.aikido.dev/blog/nginx2root-critical-nginx-rce-vulnerabilities)
- [nginx2root: Remote Code Execution (Xint technical write-up)](https://xint.io/blog/nginx2root-remote-code-execution)
- [NGINX2Root, found by Xint](https://nginx2root.com/)
- [CyberSecurityNews: nginx HTTP/2 vulnerabilities (fixed versions, CVSS 4.0, Wiz findings)](https://cybersecuritynews.com/nginx-http-2-vulnerabilities/)
- [Aikido advisory CVE-2026-123007](https://intel.aikido.dev/cve/AIKIDO-2026-34427)
- [Aikido advisory CVE-2026-123634](https://intel.aikido.dev/cve/AIKIDO-2026-739747)
- [Aikido advisory CVE-2026-123633](https://intel.aikido.dev/cve/AIKIDO-2026-297703)
- [Aikido advisory CVE-2026-121810](https://intel.aikido.dev/cve/AIKIDO-2026-711316)
- [Aikido advisory CVE-2026-113425](https://intel.aikido.dev/cve/AIKIDO-2026-415384)
- [Aikido advisory ingress-nginx (unpatched CVE-2026-123633)](https://intel.aikido.dev/cve/AIKIDO-2026-17300)

## Full data

The other 8 detection rules (Splunk SPL / Microsoft KQL / Sigma) unlock with TL Creds; a free account includes daily creds: https://threadlinqs.com/?modal=signup
Indicator values unlock with TL Creds, at a lower price on Red and Purple; AI agents can query rules and IOCs through the Threadlinqs MCP server (Purple): https://intel.threadlinqs.com/mcp

Canonical: https://intel.threadlinqs.com/threat/TL-2026-6363
