CVE-2026-42945 - Analisi e riproduzione della vulnerabilità NGINX Rift

Panoramica

CVE-2026-42945 (nome in codice "NGINX Rift") è una vulnerabilità heap buffer overflow nel modulo ngx_http_rewrite_module di NGINX, con punteggio CVSS v4 9.2 (Critico).

La vulnerabilità è stata scoperta dal team di ricerca di sicurezza depthfirst nell'aprile 2026 ed è rimasta latente per 18 anni dall'introduzione in NGINX versione 0.6.27 nel 2008.

Impatto

• NGINX Open Source 0.6.27 ~ 1.30.0
• NGINX Plus R32 ~ R36
• NGINX Instance Manager 2.16.0 ~ 2.21.1
• F5 WAF for NGINX 5.9.0 ~ 5.12.1
• NGINX App Protect WAF 4.9.0 ~ 4.16.0 e 5.1.0 ~ 5.8.0
• NGINX Gateway Fabric 1.3.0 ~ 1.6.2 e 2.0.0 ~ 2.5.1
• NGINX Ingress Controller 3.5.0 ~ 3.7.2, 4.0.0 ~ 4.0.1, 5.0.0 ~ 5.4.1

Versioni corrette

• NGINX 1.31.0 (rilasciato il 13 maggio 2026)

Condizioni di attivazione

La vulnerabilità richiede il seguente modello di configurazione NGINX per essere attivata:

location ~ ^/api/(.*)$ {
    rewrite ^/api/(.*)$ /internal?migrated=true;
    set $original_endpoint $1;
}

Condizioni chiave:

1. La stringa di sostituzione della direttiva rewrite contiene ? (punto interrogativo)
2. La successiva direttiva set fa riferimento a un gruppo di cattura di espressioni regolari (es. $1)
3. L'URI della richiesta contiene caratteri escapabili (es. +, &, % ecc.)

Analisi della causa principale

Elaborazione in due fasi del motore di script

Il motore di script di NGINX utilizza un'elaborazione in due fasi per eseguire le direttive rewrite/set:

1. Prima fase (calcolo della lunghezza): calcola la dimensione di memoria necessaria per la stringa finale
2. Seconda fase (copia dei dati): scrive i dati effettivi nel buffer allocato

Incoerenza di stato che causa overflow

Il nucleo della vulnerabilità risiede nell'incoerenza dello stato del motore tra le due fasi:

Fase 1: la direttiva rewrite imposta il flag is_args

Quando la stringa di sostituzione della direttiva rewrite contiene ?, la funzione ngx_http_script_start_args_code imposta:

void ngx_http_script_start_args_code(ngx_http_script_engine_t *e)
{
    e->is_args = 1;  // impostato in modo permanente, mai resettato!
    e->args = e->pos;
    e->ip += sizeof(uintptr_t);
}

Fase 2: il calcolo della lunghezza della direttiva set utilizza un nuovo sotto-motore

Quando la successiva direttiva set fa riferimento a un gruppo di cattura, ngx_http_script_complex_value_code crea un sotto-motore azzerato:

void ngx_http_script_complex_value_code(ngx_http_script_engine_t *e)
{
    ngx_http_script_engine_t le;
    // ...
    ngx_memzero(&le, sizeof(ngx_http_script_engine_t)); // le.is_args = 0
    le.ip = code->lengths->elts;

Fase 3: divergenza tra calcolo della lunghezza e copia effettiva

Calcolo della lunghezza (utilizza il sotto-motore le, is_args=0):

// ngx_http_script_copy_capture_len_code
if ((e->is_args || e->quote) && (e->request->quoted_uri || e->request->plus_in_uri))
{
    // is_args=0, condizione falsa, ramo else
    return cap[n + 1] - cap[n];  // restituisce la lunghezza originale (non escaped)
}

Copia effettiva (utilizza il motore principale e, is_args=1):

// ngx_http_script_copy_capture_code
if ((e->is_args || e->quote) && (e->request->quoted_uri || e->request->plus_in_uri))
{
    // is_args=1, condizione vera, ramo if
    e->pos = (u_char *) ngx_escape_uri(pos, &p[cap[n]],
                                        cap[n + 1] - cap[n],
                                        NGX_ESCAPE_ARGS);
    // ogni carattere escapabile viene espanso da 1 byte a 3 byte!
}

Dimensione dell'overflow

• Dimensione del buffer allocato: raw_size (lunghezza originale della cattura)
• Dimensione effettivamente scritta: raw_size + 2 * N (N = numero di caratteri escapabili)
• Overflow = 2 * N byte

Ad esempio, se l'URI contiene 100 +, l'overflow è di 200 byte.

Metodi di sfruttamento

1. DoS (Denial of Service)

Il metodo più semplice: inviare una richiesta contenente molti caratteri escapabili causa il crash del processo worker:

GET /api/+++++++++++++++++++++++++++++++++++ HTTP/1.1
Host: target.com

2. RCE (Remote Code Execution)

Catena di sfruttamento RCE completa (richiede ASLR disattivato o bypassato):

1. Controllo del layout heap: controlla il layout heap di ngx_pool_t attraverso l'ordine delle connessioni
2. Overflow per sovrascrivere il puntatore cleanup: overflow nella struttura del memory pool adiacente
3. Spray di strutture cleanup falsificate: inietta strutture contraffatte contenenti l'indirizzo di system() tramite il corpo della richiesta POST
4. Attivazione dell'esecuzione: chiude la connessione vittima, innescando ngx_destroy_pool che attraversa la lista di cleanup

L'architettura multi-processo di NGINX rende lo sfruttamento più affidabile: dopo il crash del worker, il master fa un fork di un nuovo worker con esattamente la stessa disposizione di memoria.

Descrizione dei file

• README.md - Questo file, documento di analisi della vulnerabilità
• Dockerfile - Costruisce un ambiente NGINX vulnerabile
• nginx.conf - Configurazione NGINX che attiva la vulnerabilità
• poc_crash.py - PoC DoS (innesca il crash del worker)
• docker-compose.yml - Avvia l'ambiente di test con un solo comando

Riproduzione rapida

# 1. Build e avvia NGINX vulnerabile
docker-compose up -d

# 2. Esegui il PoC DoS
python3 poc_crash.py

# 3. Controlla i log degli errori di NGINX per confermare il crash
docker-compose logs nginx

Riferimenti

• NGINX CHANGES ufficiali - Annuncio di correzione
• Rapporto di ricerca depthfirst - Analisi tecnica dello scopritore originale della vulnerabilità
• Bollettino di sicurezza F5 K000160932 - Bollettino di sicurezza ufficiale

Dichiarazione di non responsabilità

Questo materiale è destinato esclusivamente a scopi di ricerca sulla sicurezza e didattici. Non utilizzare queste informazioni per attacchi non autorizzati.