Nginx HTTP/2 RCE: la complessità è la superficie d'attacco
Le falle RCE di Nginx HTTP/2 mostrano dove si nascondono i bug critici: nei parser di protocolli stateful. Perché e cosa verificare nello stack.

Il codice più pericoloso di internet non è la tua applicazione. È il parser di protocollo stateful che sta davanti ad essa, scritto in C, che tutti danno per scontato sia a prova di bomba. Le nuove vulnerabilità RCE di Nginx HTTP/2 — CVE-2026-123633 e CVE-2026-123007, entrambe non autenticate, entrambe con punteggio 9.2 — sono la prova più limpida di questa affermazione da anni. Una delle due ha permesso ai ricercatori di ottenere una shell su un Nginx standard che serviva solo file statici. Nessuna applicazione backend, nessun modulo di terze parti, nessun bug applicativo. Solo Nginx, HTTP/2 e un integer underflow presente nel codice dalla versione 1.9.5 del 2015.
Qui sta la parte controcorrente: spendiamo enormi energie per auditare il nostro codice e quasi nessuna a ragionare sulla porta d'ingresso. Eppure è proprio lì che un bug di corruzione di memoria vecchio di dieci anni può consegnare a un estraneo non autenticato l'esecuzione di codice sulla macchina che termina il tuo TLS e vede tutto.
Perché HTTP/2 in Nginx è sempre stata una scommessa rischiosa
HTTP/1.1 è un protocollo testuale. È semplice, verboso, e il suo modello di parsing si mappa abbastanza naturalmente su 'leggi byte fino al delimitatore, valida, smista'. Sono stati trovati bug nei parser di HTTP/1 — il request smuggling è un intero filone — ma la macchina a stati è abbastanza piccola da poter essere tenuta a mente da un ingegnere attento.
HTTP/2 è tutt'altra bestia. Ha un framing binario, è multiplexato e stateful in modi che attraversano l'intera connessione. Una singola connessione TCP trasporta decine di stream concorrenti. Il controllo di flusso è tracciato per stream e per connessione tramite finestre scorrevoli di crediti. Gli stream possono essere aperti, semichiusi, resettati e riprioritizzati in qualsiasi ordine il client desideri. La compressione degli header tramite HPACK significa che il parser mantiene una tabella dinamica condivisa che muta man mano che arrivano i frame. Ognuna di queste funzionalità è uno stato mutabile che deve restare coerente sotto input ostili — e il client controlla completamente l'input.
Nginx ha ereditato tutta questa macchineria di stato quando ha aggiunto il suo modulo HTTP/2, e lo ha fatto in C, in un'architettura event-driven in cui connessioni e stream sono oggetti sull'heap, con cicli di vita gestiti a mano. Questa combinazione — stato ricco e trasversale più gestione manuale della memoria — è esattamente il terreno in cui prosperano use-after-free e integer underflow. Le due CVE qui sono quasi caricature del genere: una riguarda un oggetto connessione lasciato in una lista 'sicura da chiudere' mentre una richiesta lo sta usando attivamente; l'altra è una contabilità del controllo di flusso che va sotto zero e produce una copia di memoria non valida.
Ho già sostenuto, parlando di il divario tra specifica e implementazione, che i bug si concentrano dove gli invarianti impliciti di una specifica incontrano codice che non li fa rispettare. HTTP/2 ne è un caso di studio. La RFC 7540 (e ora la 9113) specifica come appaiono i flussi quando sono ben formati. Lo spazio pericoloso è tutto ciò che la specifica non vieta ma che l'implementazione non ha mai testato — frame parziali, transizioni di stato in ordini strani, finestre manipolate ai valori limite.
Use-after-free: riutilizzabile mentre è occupato
CVE-2026-123633 è il più elegante dei due bug, e ripaga una lettura attenta. Nginx mantiene una lista di connessioni considerate 'riutilizzabili' — sicure da chiudere quando servono slot per nuove connessioni. Una connessione HTTP/2 finisce in quella lista quando non ha stream di richieste attivi. Finora, nulla di strano.
Il difetto sta in come una connessione esce dalla lista — o meglio, in come non ne esce. Invia solo una parte di un frame HEADERS. Nginx vede un frame incompleto, marca la connessione come riutilizzabile e aspetta. Ora invia il resto del frame. Il gestore crea un nuovo stream di richiesta e incrementa il contatore di elaborazione della connessione — ma non la rimuove dalla lista dei riutilizzabili. Ora hai una connessione che sta elaborando una richiesta attiva ed è contemporaneamente marcata come eliminabile. Se gli slot di connessione scarseggiano, Nginx pesca nella lista, libera la connessione, e la richiesta in corso resta puntata a memoria liberata. Classico use-after-free, raggiungibile da qualsiasi client non autenticato che sappia parlare HTTP/2 con un reverse proxy.
Nota cosa serve per trovarlo leggendo il codice: devi tracciare l'appartenenza di un oggetto a una struttura dati attraverso due transizioni di stato diverse, innescate da input di rete spezzato su più pacchetti. Non è un bug che un linter trova. Non è nemmeno un bug che la maggior parte dei fuzzer trova facilmente, perché richiede una specifica interazione in due passi — frame parziale, attesa, frame completo — più pressione sulla memoria per innescare la chiusura. È il tipo di cosa rimasta nascosta per quasi sei anni nonostante Nginx sia uno dei codebase più letti del pianeta.
L'integer underflow: un decennio alla luce del sole
CVE-2026-123007 è più vecchia e per certi versi peggiore. Il controllo di flusso di HTTP/2 funziona concedendo a ogni stream e connessione una finestra di invio — un saldo di crediti che il mittente decrementa mentre trasmette e il ricevitore ricarica con frame WINDOW_UPDATE. Se la contabilità di questa finestra va storta, puoi ritrovarti a calcolare una dimensione di copia da un valore andato in overflow, e all'improvviso stai facendo memcpy da o verso memoria che non dovresti toccare.
I ricercatori hanno dimostrato l'esecuzione di codice remoto partendo da questa primitiva in una configurazione quasi predefinita — Nginx che serve file statici via HTTPS su un sistema a 64 bit. ASLR non ha salvato la situazione, perché entrambe le vulnerabilità funzionano anche come primitive di lettura della memoria prima di passare all'esecuzione di codice. Leggi i puntatori, aggiri la randomizzazione, poi scrivi. È un'artigianato di exploit moderno e standard, ma vale la pena interiorizzarlo: mitigazioni come ASLR alzano il costo dello sfruttamento, non lo impediscono, e qualsiasi bug che ti dà una lettura più una corruzione equivale in pratica a partita persa.
L'underflow è arrivato in Nginx 1.9.5 nel 2015. Undici anni. In questo periodo il codice è stato revisionato da migliaia di ingegneri, distribuito da milioni di operatori, analizzato da ogni analizzatore statico commerciale sul mercato, e sottoposto a fuzzing — Nginx viene effettivamente sottoposto a fuzzing. È sopravvissuto a tutto. Se questo non ricalibra la tua fiducia nel 'l'open source maturo è sicuro perché ci sono molti occhi', niente lo farà.

La parte scomoda: l'AI ha trovato ciò che il fuzzing non aveva trovato
Ecco il dettaglio che dovrebbe tenere svegli i team di sicurezza. Wiz ha trovato entrambi i bug con un harness di scansione del codice assistito da AI, poi ha usato modelli di frontiera per validarne lo sfruttamento. E non erano soli — Ikotas Labs, Metnir, Rapid7 e Xint hanno segnalato indipendentemente gli stessi difetti a F5 nella stessa finestra di divulgazione. Cinque team, due bug vecchi di un decennio, convergenti nello stesso momento.
Non è una coincidenza. È un cambio di fase. La barriera pratica che un tempo proteggeva i vecchi bug di sicurezza della memoria non era che fossero impossibili da trovare in linea di principio — era che tracciare lo stato attraverso decine di percorsi di codice costava troppa attenzione umana. I modelli ora sono abbastanza bravi proprio in quel tipo di ragionamento multi-hop che il costo è crollato. Abbiamo visto lo stesso schema di recente con Java4Shell, dove 65 byte si sono trasformati in RCE — un altro difetto di lunga data emerso grazie a strumenti capaci di seguire interazioni sottili meglio di esseri umani stanchi.
Ne discendono due implicazioni, e sarò diretto su entrambe. Primo, ogni team difensivo ha ora accesso alla stessa capacità di scoperta, quindi esegui questa analisi sul tuo stack prima che lo faccia qualcun altro. Secondo — ed è qui che concedo i limiti della mia affermazione iniziale — anche gli attaccanti ce l'hanno, e la finestra tra 'il bug diventa individuabile' e 'il bug viene sfruttato' si sta riducendo. La discussione su Hacker News ha fatto emergere un dettaglio preoccupante: la correzione di una CVE è rimasta nel repository pubblico per una settimana prima della divulgazione, con un messaggio di commit che nominava la società di sicurezza che l'aveva segnalata. Chi analizza i diff dei commit alla ricerca di fix di sicurezza — una tecnica black-hat nota — ha avuto un vantaggio. I processi di divulgazione coordinata sono stati progettati per un mondo in cui le scoperte erano rare. Quel mondo non esiste più.
Lezioni per il fuzzing dei parser di protocollo
Se mantieni un parser di rete — e in parecchi lo facciamo, in proxy, API gateway, service mesh e protocolli personalizzati — questi bug sono una checklist dei punti in cui i tuoi test sono probabilmente deboli.
- Fai fuzzing sulle sequenze, non solo sui messaggi. Entrambe le CVE richiedono interazioni in più passi: frame parziali, connessioni in pausa, aggiornamenti di finestra a valori limite. Un fuzzer che muta singoli frame non troverà mai un bug che richiede frame A, un'attesa, poi frame B. Usa fuzzing stateful o grammar-aware che modelli il ciclo di vita della connessione.
- Testa il ciclo di vita degli oggetti sotto pressione di risorse. La UAF scatta solo quando Nginx deve recuperare slot di connessione. I test dovrebbero girare con limiti di risorse artificialmente bassi, così da eseguire i percorsi di eviction.
- Asserisci gli invarianti a ogni transizione di stato. 'Se processing > 0, la connessione non deve trovarsi nella lista dei riutilizzabili' si verifica con una sola asserzione. Gli invarianti economici catturano i bug che la code review non vede.
- Fai scattare un trap sull'overflow di interi nelle build di debug. L'aritmetica con segno e senza segno nel controllo di flusso è esattamente ciò che ha prodotto CVE-2026-123007. Sanitizer (UBSan) insieme al fuzzing avrebbero segnalato il problema anni fa.
- Analizza i commit upstream alla ricerca di fix di sicurezza silenziosi. I difensori possono giocare la stessa partita degli attaccanti. Osservare i commit con forma di fix ti fa guadagnare giorni.
E una nota di processo, maturata coprendo divulgazione dopo divulgazione: le scadenze di divulgazione sempre più corte esistono perché il divario tra patch e exploit continua a ridursi. Il tuo processo di risposta — inventario, prioritizzazione, rollout a stadi — conta più di qualsiasi singola correzione.
Cosa fare subito con i tuoi deployment Nginx
La soluzione è noiosa, ed è una buona notizia. Aggiorna Nginx OSS alla 1.30.7 stable o alla 1.31.9 mainline; i clienti Nginx Plus devono passare alle release corrette R33/R37. Se non puoi aggiornare questa settimana, disabilita HTTP/2 — dalla versione 1.25.1 in poi basta http2 off; nei server block interessati, e nelle versioni precedenti rimuovi il parametro http2 dalle direttive listen — poi ricarica e verifica che i worker vecchi siano usciti. È una mitigazione drastica: perdi il multiplexing e la compressione degli header, e le app sensibili alla latenza se ne accorgeranno. Ma chiude completamente entrambi i bug, ed è una modifica di configurazione, non di codice.
Per il rilevamento, la risposta onesta è che sono difficili da individuare nei log — lo sfruttamento appare come sequenze di frame HTTP/2 strane e, alla fine, come crash inattesi dei worker o come worker Nginx che generano processi che non dovrebbero mai generare. I worker che entrano in crash loop su un Nginx esposto a internet con HTTP/2 attivo meritano un'indagine, non solo un riavvio da parte del supervisor.
Una precisazione sul perimetro: HTTP/2 non è abilitato di default in Nginx, e le statistiche indicano un utilizzo intorno al 12% dei server. Su scala internet sono ancora milioni di istanze, ma verifica prima di farti prendere dal panico — e controlla anche i load balancer e le origini CDN, perché il Nginx che hai dimenticato dietro l'ingress gestito è quello che viene compromesso.
La complessità non è mai stata un confine di sicurezza. Era solo una coda — e ora la coda si muove più in fretta.
La lezione più grande per le infrastrutture critiche
Allargando lo sguardo, lo schema è chiaro: i bug che contano di più oggi vivono in implementazioni di protocolli stateful e con gestione manuale della memoria, in infrastrutture che tutti condividono. Questa sola divulgazione ha portato dieci CVE su Nginx — UAF in HTTP/2, una UAF in HTTP/3, una nel resolver DNS, una nel proxy mail. Il filo comune non è la sciatteria; il codebase di Nginx è disciplinato per gli standard del C. Il filo comune è che la gestione manuale del ciclo di vita attraverso macchine a stati asincrone e guidate dall'attaccante supera ciò che qualsiasi team può verificare a occhio.
Dove ci porta tutto questo? Non a 'riscrivere tutto in Rust', per quanto tentante sia questo ritornello — anche se le riscritture memory-safe dei parser più esposti sono un'ottima idea, e l'industria le sta lentamente facendo. Più nell'immediato: tratta i tuoi proxy di frontiera come il bersaglio di audit a più alto valore del tuo stack, pretendi fuzzing stateful e sanitizer dai progetti da cui dipendi, e costruisci la capacità operativa di applicare patch o mitigazioni nell'arco di giorni. L'era in cui un bug di undici anni poteva aspettare tranquillamente che un umano se ne accorgesse è finita. Ora le macchine leggono la coda, da entrambi i lati.



