
nginx2root: anatomia celor cinci vulnerabilități din nginx și a escaladării la root prin kernelul Linux
- Ungureanu Călin Petru
- Securitate,Infrastructura
- 21 Nov, 2026
Pe 18 noiembrie 2026, echipa Xint din cadrul Theori a publicat un pachet de cinci vulnerabilități în nginx, însoțite de o a șasea problemă, de data aceasta în kernelul Linux. Fiecare dintre cele cinci are un exploit demonstrat, iar cea mai gravă permite execuție de cod de la distanță fără autentificare pe orice server nginx care are HTTP/2 activat. Combinată cu defectul din kernel, lanțul ajunge la root pe gazdă, inclusiv dintr-un container Docker.
Materialul de față nu este o rescriere a comunicatului de presă. Este o trecere prin codul și prin aritmetica din spatele fiecărui defect, cu accent pe ce trebuie să verifice și să repare o echipă de infrastructură.
Sursă: cercetarea și exploiturile aparțin echipei Xint (Theori). Analiza de mai jos se bazează pe writeup-ul lor tehnic și pe materialele publicate pe nginx2root.com.
1. Ce este, de fapt, „nginx2root”
Numele este bun pentru presă și prost pentru ingineri, pentru că sugerează un singur exploit care duce direct la root. Realitatea este mai nuanțată și, din punct de vedere operațional, mai importantă:
- Sunt cinci vulnerabilități independente în nginx. Nu trebuie înlănțuite între ele. Fiecare are propriul vector și propria configurație vulnerabilă.
- Fiecare duce la execuție de cod cu privilegiile procesului worker nginx, de obicei utilizatorul
nginxsauwww-data. - escaladarea la
rootpe gazdă necesită un al doilea bug, separat, în subsistemul SCTP din kernelul Linux, prezent în kernel din 2018. - În testele Xint, lanțul a funcționat pe AWS, GCP, Azure și bare-metal, atât din interiorul serverului, cât și prin rețea privată și prin IP public, și a evadat dintr-un container Docker pentru a obține
rootpe host.
Chiar și fără partea de kernel, un RCE ca utilizatorul worker este un incident de severitate maximă. Procesul worker are acces la configurația încărcată în memorie, la upstream-uri, la headerele și cookie-urile clienților, la secretele injectate prin variabile de mediu în mediile containerizate și la rețeaua internă a VPC-ului. Într-o arhitectură tipică în care nginx stă în fața aplicațiilor Node.js, Python sau Go, compromiterea lui înseamnă compromiterea suprafeței de intrare a întregului sistem.
2. Suprafața de atac, în cifre
Cifrele contează pentru prioritizare, dar trebuie citite corect.
- Într-un snapshot Shodan din 10 noiembrie 2026,
product:nginxreturna 56,7 milioane de gazde. Dintre acestea, 11,94 milioane (21,1%) raportau o versiune identificabilă. - Din cele cu versiune identificabilă, 98,9% rulau o versiune din intervalul afectat de CVE-2026-123007 (1.9.5 – 1.31.8).
- 88,6% dintre companiile din Fortune 500 folosesc nginx.
- W3Techs estimează că nginx deservește aproximativ 30% din site-urile web cu server identificabil.
Atenție la interpretare: procentul de 98,9% descrie prevalența versiunilor, nu numărul de endpoint-uri exploatabile. Pentru ca un server să fie vulnerabil la CVE-2026-123007 trebuie să îndeplinească simultan cinci condiții: versiune în interval, modulul HTTP/2 compilat, listener activ cu HTTP/2, negociere h2 accesibilă din exterior și lipsa unui backport de securitate.
3. Harta celor șase defecte
| CVE | Clasă de defect | Configurație necesară | Prima versiune afectată | Neutralizat de http2 off? |
|---|---|---|---|---|
| CVE-2026-123007 | integer overflow → out-of-bounds write pe heap | HTTP/2 activat | 1.9.5 | Da |
| CVE-2026-123634 | use-after-free | resolver, proxy_pass cu destinație derivată din request, mirror cu mirror_request_body off | 1.13.4 | Nu |
| CVE-2026-123633 | use-after-free | HTTP/2 cu cereri forwardate către un upstream | 1.19.7 | Da |
| CVE-2026-121810 | use-after-free | HTTP/3 (QUIC) cu cereri forwardate către un upstream | 1.25.0 | Nu |
| CVE-2026-113425 | use-after-free | mail proxy cu proxy on și auth_http | 0.5.15 | Nu |
| Kernel Linux SCTP | use-after-free / double free | kernel ≥ 4.15, SCTP disponibil | 4.15 | Nu se aplică |
Două observații care contează pentru planificare:
http2 offrezolvă doar două din cinci. Este cea mai răspândită mitigație de urgență și, în același timp, cea mai frecvent interpretată greșit ca „suntem în siguranță”.- CVE-2026-123634 nu se rezolvă prin oprirea
mirror. Directivamirroreste doar configurația pe care Xint a testat-o. Orice mecanism care creează subcereri (SSI, de exemplu) poate atinge același defect. Cauza reală esteresolver-ul care face lookup DNS la momentul request-ului.
4. CVE-2026-123007: aritmetica ferestrelor de flow control
Acesta este defectul care merită înțeles în detaliu, pentru că explică de ce un bug de „contabilitate” ajunge să fie un RCE pre-auth.
4.1 Modelul de flow control în nginx
HTTP/2 multiplexează mai multe cereri pe o singură conexiune TCP. Fiecare pereche cerere/răspuns folosește un stream cu un identificator propriu (1, 3, 5, …). Flow control-ul previne situația în care serverul trimite mai multe date decât poate clientul să consume.
nginx ține două tipuri de ferestre de trimitere:
- una per stream (
stream->send_window), - una per conexiune (
h2c->send_window), pe care o numim fereastra h2c.
Serverul poate trimite DATA pe un stream doar dacă ambele ferestre au credit. Clientul suplimentează creditul cu cadre WINDOW_UPDATE: Stream ID 0 actualizează fereastra h2c, un Stream ID nenul actualizează doar stream-ul respectiv.
/* src/http/v2/ngx_http_v2.h */
#define NGX_HTTP_V2_MAX_WINDOW ((1U << 31) - 1)
#define NGX_HTTP_V2_DEFAULT_WINDOW 65535
Când un răspuns intră în coada de ieșire, nginx deduce lungimea din ambele ferestre:
/* ngx_http_v2_filter_module.c, ngx_http_v2_send_chain() */
ngx_http_v2_queue_frame(h2c, frame);
h2c->send_window -= frame_size;
stream->send_window -= frame_size;
stream->queued++;
Dacă stream-ul este anulat înainte ca datele să fie trimise, rutina de curățare scoate cadrele din coadă și returnează creditul în fereastra de conexiune:
/* ngx_http_v2_filter_module.c, ngx_http_v2_filter_cleanup() */
if (frame->stream == stream && !frame->blocked) {
*fn = frame->next;
window += frame->length;
}
h2c->send_window += window;
Ambele operații sunt corecte luate separat. Problema este ce se poate întâmpla între ele.
4.2 Dubla returnare a creditului
Atacatorul construiește următoarea secvență, cu o cantitate cunoscută Q:
- Ridică fereastra h2c la maxim (
Wmax) printr-unWINDOW_UPDATEpe Stream ID 0. - Setează
SETTINGS_INITIAL_WINDOW_SIZE = 0. Astfel nginx poate emite cadre HEADERS, dar nu poate trimite DATA — corpurile răspunsurilor rămân în coadă. - Nu mai citește din socket și trimite un burst de cadre
PING. nginx pune răspunsurile de control înaintea datelor pending, umplând bufferele TLS și TCP. - Trimite pentru fiecare stream suficient credit pentru întregul corp al răspunsului. nginx pune DATA în coadă și deduce
Qdin fereastra h2c. - Adaugă
Qînapoi de două ori: o dată printr-unWINDOW_UPDATEpe Stream ID 0, apoi prinRST_STREAM, care declanșează curățarea și returnează același credit.
Fereastra h2c trece prin patru valori:
Wmax (WINDOW_UPDATE -> maxim)
Wmax - Q (DATA intră în coadă)
Wmax (WINDOW_UPDATE pe Stream ID 0)
Wmax + Q (cleanup returnează Q a doua oară, fără verificare de limită superioară)
Concluzia importantă: nu dimensiunea răspunsurilor contează, ci faptul că aceeași cantitate cunoscută Q este adăugată de două ori, iar a doua adunare nu are nicio verificare.
4.3 Sub-underflow-ul din verificarea ferestrei
Următorul WINDOW_UPDATE este validat astfel:
/* ngx_http_v2.c, ngx_http_v2_state_window_update() */
if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
}
h2c->send_window += window;
Verificarea funcționează doar cât timp fereastra este sub Wmax. h2c->send_window are tipul nesemnat size_t, iar pasul anterior l-a dus la Wmax + Q. Expresia devine Wmax - (Wmax + Q), care aritmetic este negativă, dar în aritmetică nesemnată se rotește într-o valoare foarte mare. nginx o interpretează ca spațiu disponibil și continuă să accepte WINDOW_UPDATE-uri valide conform specificației. Prin repetare, fereastra poate fi împinsă la orice valoare pe 64 de biți.
4.4 De la fereastră uriașă la lungime de copiere
Aici apare conversia care transformă un contor într-un write out-of-bounds. h2c->send_window este size_t. La valoarea 2^64 - d, ca nesemnat pare uriașă; convertită la off_t semnat devine -d.
/* ngx_http_v2_filter_module.c, ngx_http_v2_send_chain() */
if (limit == 0 || limit > (off_t) h2c->send_window) {
limit = h2c->send_window;
}
if ((off_t) frame_size > limit) {
frame_size = (size_t) limit;
}
Un limit pozitiv este mai mare decât -d, deci prima condiție este adevărată și limit devine -d. Și un frame_size pozitiv este mai mare decât -d, deci a doua condiție este la fel de adevărată, iar conversia înapoi la size_t produce 2^64 - d. O dimensiune normală de cadru DATA devine o dimensiune absurdă.
Valoarea ajunge în rest și apoi în ngx_http_v2_filter_get_shadow():
rest = frame_size;
cl = ngx_http_v2_filter_get_shadow(stream, in->buf, offset, rest);
static ngx_chain_t *
ngx_http_v2_filter_get_shadow(ngx_http_v2_stream_t *stream, ngx_buf_t *buf,
off_t offset, off_t size)
{
chunk->last = chunk->pos + size;
}
Cu size = -d ca off_t, chunk->last ajunge înaintea lui chunk->pos. Mai departe, calea de ieșire TLS calculează lungimea ca diferență de pointeri:
/* ngx_event_openssl.c */
ssize_t size;
size = in->buf->last - in->buf->pos;
ngx_memcpy(buf->last, in->buf->pos, size);
last - pos este -d, dar argumentul de lungime al memcpy() este size_t, deci 2^64 - d.
4.5 De ce nu crapă: memcpy-ul „înapoi” din glibc
O copiere de 2^64 - d octeți ar trebui să treacă de capătul heap-ului și să omoare worker-ul. Nu se întâmplă, din cauza implementării memcpy din glibc pe x86-64.
Implementarea nu copiază de la început spre sfârșit. Încarcă începutul și sfârșitul sursei, apoi copiază mijlocul de la coadă spre început. Structura este prezentă din glibc 2.24 (2016):
head = load128(src)
tail = load32(src + size - 32)
end = (dest + size) mod 2^64
cursor = align_down(end - 129, 32)
do {
copy128(dst=cursor, src=src + (cursor - dest))
cursor -= 128
} while (cursor > dest)
store128(dst=dest, data=head)
store32(dst=end - 32, data=tail)
Cu size = 2^64 - d, adresa dest + size se rotește în spațiul de adresare 64-bit și devine dest - d, adică sub dest. Cum sfârșitul este acum înaintea începutului, bucla se oprește după o singură iterație. Rezultatul: se copiază doar primii 128 de octeți și ultimii 160, iar regiunea intermediară este sărită complet.
4.6 Poziționarea exactă a copiei
Clientul controlează unde cade dest pentru că poate controla cât de multe răspunsuri de control emite nginx înainte de corp. Un cadru HTTP/2 are header de 9 octeți, un PING ACK are 17 octeți (9 + 8), un SETTINGS ACK are 9 octeți. Pentru p cadre PING și s cadre SETTINGS, poziția de start a următorului corp este:
P = 17p + 9s + 9
dest = TLS + P
Atacatorul ajustează fereastra cu WINDOW_UPDATE astfel încât d = P - 64. Capătul copiei, dest - d, devine TLS + 64, iar regiunea de 160 de octeți acoperă 96 de octeți înaintea bufferului TLS și primii 64 de octeți din interiorul lui.
Primii 96 de octeți suprascriu câmpul de dimensiune al metadata-ului de heap de dinaintea bufferului TLS. Restul de 64 de octeți sunt trimiși înapoi în răspunsul TLS, scurgând pointeri din imaginea nginx și din heap. O singură copie malformată produce simultan un write out-of-bounds și un leak de adrese — exact combinația necesară pentru a ocoli ASLR.
4.7 Range + Cookie: cum se umplu cei 160 de octeți
Sursa copiei, src, trebuie să fie o zonă controlabilă. Xint folosește un detaliu elegant: un request cu mai multe intervale Range determină nginx să construiască un răspuns multipart, iar boundary-ul este alocat din pool-ul request-ului:
/* ngx_http_range_filter_module.c */
ctx->boundary_header.data = ngx_pnalloc(r->pool, size);
b->pos = ctx->boundary_header.data;
Acest b->pos devine in->buf->pos pe calea de ieșire, deci devine src.
Cei 160 de octeți de sub src - d sunt modelați prin câmpuri Cookie. Când un request conține mai multe astfel de câmpuri, nginx calculează lungimea totală adăugând câte doi octeți per separator și stochează lungimea și adresa bufferului în structura de header:
/* ngx_http_v2.c */
len += vals[i].len + 2;
len -= 2;
h->key.data = cookie.data;
h->value.len = len;
h->value.data = buf;
Structura conține astfel o lungime controlată de atacator și pointeri în imaginea nginx și în heap. Alocările mici din request pool sunt plasate consecutiv (bump allocation), deci numărul și lungimile cookie-urilor controlează direct conținutul și poziția:
Source: [96 octeți cu valoarea pentru câmpul size][64 octeți de pointeri cod + heap]
Destination: [96 octeți înaintea bufferului TLS, metadata heap][primii 64 octeți din bufferul TLS]
Ultimul pas al exploit-ului, pe care Xint îl omite intenționat din writeup, este suprascrierea unui pointer de funcție de cleanup, apelat la închiderea conexiunii, astfel încât execve() să ruleze comenzi cu privilegiile worker-ului, iar output-ul să fie livrat pe conexiunea deja deschisă.
5. CVE-2026-123634: use-after-free în resolver
Al doilea defect are o cauză complet diferită: lista de așteptare a resolver-ului.
nginx poate face reverse proxying către un upstream ales la momentul request-ului, de exemplu proxy_pass http://$host;. Dacă e nevoie de DNS, rezolvarea este asincronă, iar fiecare lookup are un context (ngx_resolver_ctx_t) cu stare, rezultat și handler. Dacă același nume este deja în curs de rezolvare, nginx nu trimite o a doua interogare, ci pune contextul nou în capul listei de așteptare a nodului respectiv.
Când sosește răspunsul, lista este detașată și parcursă:
/* ngx_resolver.c */
next = rn->waiting;
rn->waiting = NULL;
...
while (next) {
ctx = next;
ctx->state = code;
ctx->valid = ngx_time() + (r->valid ? r->valid : 10);
next = ctx->next;
ctx->handler(ctx);
}
Dacă un handler eliberează un context aflat mai jos în listă, variabila next rămâne un pointer către memorie eliberată. Între două request-uri diferite acest lucru nu se poate întâmpla, pentru că terminarea unui request eliberează doar contextele proprii. Deci bug-ul există doar dacă cele două contexte aparțin aceluiași request.
Xint a găsit o singură configurație care creează două contexte pentru același request: mirror, care copiază request-ul către o a doua locație ca subcerere. Dacă request-ul principal și oglinda folosesc același nume de upstream, contextele lor așteaptă în același nod.
Secvența:
- Lookup-ul DNS eșuează, iar handler-ul principal încearcă să trimită un
502. - Clientul a resetat conexiunea TCP, deci scrierea eșuează și
ngx_http_terminate_request()termină request-ul principal. - Cleanup-ul request-ului principal include și cleanup-ul upstream-ului pentru oglindă, deci rulează și pentru oglindă, deși rezultatul DNS nu fusese procesat:
/* ngx_http_upstream.c */
if (u->resolved && u->resolved->ctx) {
ngx_resolve_name_done(u->resolved->ctx);
u->resolved->ctx = NULL;
}
ngx_resolve_name_done()încearcă să dezlege contextul din lista de așteptare, dar lista a fost deja detașată (rn->waiting == NULL). Nu găsește nimic, loghează un ALERT și eliberează contextul oricum.- Bucla resolver-ului revine la
next, adică exact la contextul eliberat, și scriectx->state,ctx->valid, citeștectx->nextși apeleazăctx->handler(ctx).
Dacă o altă alocare revendică memoria eliberată, atât next cât și handler devin controlate de atacator. Detaliul interesant este că vulnerabilitatea se folosește pe ea însăși pentru leak: pointerul de free-list din glibc suprascrie câmpul next, iar handler-ul controlat poate fi direcționat către gettimeofday() din vsyscall, aflat la o adresă fixă pe amd64. Alături de un chunk de heap falsificat și pointeri plasați într-o interogare DNS trimisă către serverul autoritativ al atacatorului, rezultă un disclosure de adrese. Apoi lanțul este dus către un context fals plasat în corpul unui request pending, cu handler = system(), ceea ce duce la execuție de comenzi.
Condiția de rețea este importantă: resolver-ul recursiv al nginx trebuie să poată ajunge la serverul DNS autoritativ al atacatorului.
6. CVE-2026-123633: drain-ul de conexiuni și propriul request
Fiecare worker are un număr fix de sloturi de conexiune, worker_connections, partajate între conexiunile clienților și cele către upstream. Când sloturile se apropie de epuizare, nginx închide conexiuni inactive considerate refolosibile, proces numit draining:
/* ngx_connection.c */
if (cycle->free_connection_n > cycle->connection_n / 16
|| cycle->reusable_connections_n == 0)
{
return;
}
...
n = ngx_max(ngx_min(32, cycle->reusable_connections_n / 8), 1);
for (i = 0; i < n; i++) {
...
q = ngx_queue_last(&cycle->reusable_connections_queue);
c = ngx_queue_data(q, ngx_connection_t, queue);
...
c->close = 1;
c->read->handler(c->read);
}
Defectul pornește de la ordinea verificărilor în ngx_http_v2_handle_connection(): conexiunea este marcată refolosibilă înainte de a se verifica dacă ultima citire s-a oprit la mijlocul unui cadru.
/* ngx_http_v2.c */
if (h2c->last_out || h2c->processing) {
return;
}
...
ngx_reusable_connection(c, 1);
if (h2c->state.incomplete) {
return;
}
O conexiune inactivă normală primește ngx_http_v2_idle_handler(), care o scoate din coada de refolosibile la sosirea de date. În schimb, când funcția iese devreme din cauza unui cadru incomplet, conexiunea păstrează handler-ul normal de citire, care nu o scoate din coadă.
Secvența de atac:
- Clientul trimite începutul unui cadru HEADERS — conexiunea intră în coada de refolosibile.
- Clientul trimite restul cadrului — se deschide un stream.
- Dacă request-ul deschide o conexiune upstream,
ngx_event_connect_peer()cheamăngx_get_connection(), care rulează drain-ul. Conexiunea HTTP/2 din coadă poate fi selectată pentru închidere. - Handler-ul de citire vede
c->closeși încearcă să trimită GOAWAY; dacă clientul a resetat deja TCP, scrierea eșuează șingx_http_v2_finalize_connection()închide conexiunea și stream-urile. - Închiderea stream-ului cheamă
ngx_http_free_request(), care distruge pool-ul request-ului — inclusiv structurilerșiuale upstream-ului. - Drain-ul revine, iar nginx continuă să ruleze codul upstream-ului eliberat: se conectează, trimite request-ul proxy și gestionează evenimente prin
rșiuinvalide.
Pentru control, Xint folosește heap grooming astfel încât un header de largebin din glibc să cadă peste u, iar câmpul bk_nextsize peste u->peer.sockaddr, direcționând conexiunea upstream către serverul atacatorului. Bypass-ul ASLR vine din faptul că, la conectare, nginx trimite bufferul request-ului eliberat, care conține pointeri; worker-ul crapă, dar înlocuitorul lui are același layout de adrese. Execuția de comenzi se obține printr-un al doilea grooming, care revendică request-ul eliberat cu un request fals al cărui read handler este execv().
7. CVE-2026-121810: aceeași clasă, alt mecanism, HTTP/3
HTTP/3 transportă mai multe stream-uri de request pe o singură conexiune QUIC, dar nginx alocă intern un ngx_connection_t pentru conexiunea QUIC și încă unul pentru fiecare stream. Toate provin din același pool de sloturi.
ngx_quic_create_stream() scoate conexiunea părinte din coada de refolosibile înainte de a aloca slotul, tocmai pentru a evita ca drain-ul să închidă părintele în timpul alocării:
/* ngx_event_quic_streams.c */
reusable = c->reusable;
ngx_reusable_connection(c, 0);
sc = ngx_get_connection(c->fd, log);
Problema este că noul stream intră în arborele părintelui abia după alocare:
ngx_rbtree_insert(&qc->streams.tree, &qs->node);
Dacă drain-ul închide un stream inactiv existent pe același părinte, verificarea ngx_quic_can_shutdown() rulează fără să vadă stream-ul care se creează în acel moment și poate concluziona că părintele poate fi închis, re-introducându-l în coada de refolosibile. Conectarea upstream a noului stream cere încă un slot, poate rula din nou drain-ul, iar ngx_quic_close_connection() → ngx_quic_close_streams() termină request-ul aflat în curs de conectare. Urmează același tipar: pool-ul este distrus, u este eliberat, iar ngx_event_connect_peer() continuă să folosească u->peer.
8. CVE-2026-113425: mail proxy și auth_http
Aici vectorul este cel mai vechi (prima versiune afectată: 0.5.15) și, probabil, cel mai puțin verificat în inventarele echipelor.
Când un client se autentifică prin IMAP, POP3 sau SMTP, nginx întreabă un serviciu HTTP configurat prin auth_http dacă credențialele sunt valide. Pe durata lookup-ului există două conexiuni: cea a clientului și cea către serviciul de autentificare. Conexiunea de autentificare împrumută sesiunea și pool-ul clientului:
/* ngx_mail_auth_http_module.c */
ctx->peer.connection->data = s;
ctx->peer.connection->pool = s->connection->pool;
s->connection->read->handler = ngx_mail_auth_http_block_read;
ctx->peer.connection->read->handler = ngx_mail_auth_http_read_handler;
ctx->peer.connection->write->handler = ngx_mail_auth_http_write_handler;
Eroarea: handler-ul de scriere al clientului rămâne ngx_mail_send(), iar calea lui de eroare închide conexiunea clientului și distruge pool-ul, fără să curețe conexiunea de autentificare. Dacă în aceeași iterație a event loop-ului sunt procesate comanda de login și un TCP reset, se ajunge la:
/* ngx_mail_handler.c */
if (n == NGX_ERROR) {
ngx_mail_close_connection(c);
return;
}
...
ngx_close_connection(c);
ngx_destroy_pool(pool);
Sesiunea s și array-ul de contexte ale modulelor erau alocate din pool-ul tocmai distrus. Conexiunea de autentificare rămâne deschisă, cu data indicând în continuare spre s. Următorul eveniment (răspuns, timeout sau completare) rulează un handler care ia s->ctx din memoria eliberată — și, dacă atacatorul a revendicat acea memorie, s->ctx poate indica un context fals, cu ctx->handler controlat.
Bypass-ul ASLR folosește chiar timeout-ul conexiunii de autentificare: memoria eliberată ajunge să conțină o comandă IMAP parțială de pe altă conexiune, este revendicată de o alocare care conține pointeri de heap, iar nginx îi trimite înapoi în răspuns. Execuția se obține reluând trigger-ul pe un worker nou: un LOGIN IMAP cu parolă controlată revendică sesiunea eliberată, s->ctx indică un context fals, iar ngx_mail_auth_http_read_handler() ajunge să apeleze system(s).
9. Partea de kernel: SCTP
Escaladarea la root nu vine din nginx. Xint a găsit un zero-day în subsistemul SCTP: pe calea de trimitere, o operație aflată în așteptare poate avea asocierea transferată către alt socket, după care poate elibera asocierea transferată. În funcție de ce face celălalt socket, rezultă un use-after-free sau un double free.
Pe un kernel construit cu KASAN, simptomul arată astfel:
BUG: KASAN: double-free in sctp_[...]
Free of addr ffff8880021b0880 by task t306/838
Call Trace:
kfree+0x170/0x490
sctp_[...]
sctp_[...]
Bug-ul este introdus în Linux v4.15 (2018) și a supraviețuit mai bine de opt ani. Cele două primitive obținute sunt un disclosure de memorie de kernel (care anulează KASLR) și un apel de funcție arbitrar în kernel. Într-un container, toate containerele de pe gazdă partajează același kernel, deci compromiterea kernelului înseamnă control asupra gazdei și a tuturor containerelor ei.
Pentru gazdele care nu au nevoie de SCTP, Xint recomandă blocarea încărcării modulului:
# /etc/modprobe.d/nginx2root-sctp.conf
install sctp /bin/false
Atenție la limite: măsura împiedică încărcarea prin modprobe, dar nu descarcă un modul deja încărcat și nu dezactivează un SCTP compilat direct în kernel.
10. Cum verifici expunerea, concret
Un server este afectat de CVE-2026-123007 dacă rulează o versiune nepatch-uită, are modulul HTTP/2 compilat și are HTTP/2 activat pe un listener accesibil.
Versiunea:
nginx -v 2>&1
1.9.5–1.31.8: codul vulnerabil este prezent; continuă verificările.1.9.4sau mai vechi: fără suport HTTP/2, neafectat de acest CVE.1.31.9sau mai nou: probabil patch-uit; confirmă totuși changelog-ul build-ului.
Modulul HTTP/2:
nginx -V 2>&1 | grep -q -- '--with-http_v2_module' \
&& echo 'HTTP2_MODULE=present' \
|| echo 'HTTP2_MODULE=absent'
Configurația activă (atenție: nginx -T citește configurația de pe disc, nu starea din memorie):
sudo nginx -T 2>&1 \
| sed 's/#.*//' \
| grep -nE 'listen[[:space:]].*http2|^[[:space:]]*http2[[:space:]]+on[[:space:]]*;'
Negocierea h2 din exterior, rulată de pe o mașină din afara rețelei:
openssl s_client -connect {HOST}:443 -servername {HOST} -alpn h2 </dev/null 2>&1 \
| grep -E 'ALPN protocol:|No ALPN negotiated|Connection refused|connect:errno|handshake failure'
Interpretarea combinată:
| Rezultat | Evaluare |
|---|---|
1.9.5–1.31.8 + modul prezent + ALPN protocol: h2 pe portul nginx | Vulnerabil și expus extern — acțiune imediată |
| 1.9.5–1.31.8 + modul prezent + HTTP/2 dezactivat | Cod vulnerabil prezent, dar calea de atac cunoscută este închisă |
| 1.9.4 sau mai vechi, ori modul absent | Neafectat de CVE-2026-123007 |
| 1.31.9 sau fix confirmat prin backport | Patch-uit |
| Eșec de conexiune, TLS sau stare de patch incertă | Inconcludent — investighează |
Verifică separat celelalte patru CVE-uri, după tabelul din secțiunea 3. Și, foarte important, nu te baza pe nginx -v pentru pachetele de distribuție: Ubuntu 24.04 livra 1.24.0, Ubuntu 22.04 livra 1.18.0, Debian 12 livra 1.22.1, iar distribuțiile fac backport de securitate fără să schimbe versiunea raportată. Pe Ubuntu 22.04, pachetul a trecut de la 1.18.0-6ubuntu14 la 1.18.0-6ubuntu14.22, în timp ce nginx -v a rămas 1.18.0. Compară versiunea completă de pachet cu advisory-ul distribuției.
11. Remediere și mitigații de urgență
11.1 Actualizare
Ținta este nginx 1.31.9. Pentru nginx Plus, urmează advisory-ul F5 și nu presupune că numărul de versiune al ediției tale este suficient pentru a demonstra patch-ul.
După instalare:
nginx -s reloadnu încarcă binarul nou. Este cea mai frecventă greșeală operațională din acest incident. Este nevoie desystemctl restart nginxsau de un live binary upgrade suportat.- Un reload aplică noua configurare doar conexiunilor noi. Conexiunile deja deschise rămân pe worker-ii vechi, vizibili în
pscanginx: worker process is shutting down. Dacă rămân după reload, repornește serviciul, acceptând întreruperea conexiunilor în curs.
11.2 Dacă nu poți aplica patch-ul imediat
Dezactivează HTTP/2 (CVE-2026-123007 și CVE-2026-123633). Pentru nginx 1.25.1+:
listen 443 ssl;
http2 off;
Pentru nginx 1.9.5 – 1.25.0, elimină parametrul http2 din directiva listen. Verifică toate blocurile server care partajează aceeași adresă și port. Clienții HTTP/1.1 nu sunt afectați; serviciile care depind de HTTP/2 nativ, cum ar fi gRPC, vor fi.
Elimină lookup-urile DNS la momentul request-ului (CVE-2026-123634). Dacă proxy_pass conține o variabilă (de exemplu proxy_pass http://$host;) și folosești mirror, mută proxy_pass pe un grup upstream fix. Setarea mirror_request_body on a oprit exploit-ul testat, dar nu repară bug-ul din resolver — nu te baza pe ea singură.
Dezactivează HTTP/3 (QUIC) (CVE-2026-121810): scoate listener-ele quic, setează http3 off și înlocuiește header-ul Alt-Svc cu Alt-Svc 'clear'. Verifică apoi că nimic nu mai ascultă UDP pe 443:
sudo ss -lunp 'sport = :443'
Restrânge accesul la mail proxy (CVE-2026-113425): dacă folosești proxy on cu auth_http, limitează listener-ele IMAP/POP3/SMTP la loopback sau prin firewall la IP-uri de încredere. Atacatorul nu are nevoie de credențiale valide — bug-ul se declanșează în timpul autentificării, indiferent de rezultatul ei.
11.3 Ce nu înlocuiește patch-ul
Un WAF, limite de conexiuni sau un CDN în față nu sunt echivalente cu patch-ul. Dacă nginx stă în spatele unui CDN, traficul HTTP/2 este terminat la marginea CDN-ului, dar serverele de origin rămân vulnerabile dacă sunt accesibile direct — iar IP-urile de origin scăpate în DNS istoric, în certificate sau în scanări sunt o realitate operațională.
12. Detectare și răspuns la incident
Un atac prin CVE-2026-123007 lasă puține urme în access log-urile obișnuite: cadrele WINDOW_UPDATE și RST_STREAM nu sunt logate ca request-uri, iar TLS le criptează în tranzit. Xint propune patru locuri de verificat.
Statistici de conexiune. Rulează de două ori, la interval scurt, și compară creșterile:
sudo ss -tinp state established '( sport = :443 )'
Semnale care apar împreună în atacul testat: aceeași sursă externă menține o conexiune deschisă minute întregi, bytes_received crește foarte rapid, bytes_sent este mult mai mic decât volumul primit, iar aceeași sursă creează multe conexiuni TLS scurte.
Request-uri pe conexiune. Formatul implicit de log nu arată conexiunea. Adaugă în blocul http:
log_format h2_hunt '$time_iso8601 src=$remote_addr conn=$connection '
'requests=$connection_requests proto=$server_protocol '
'status=$status request_length=$request_length '
'bytes_sent=$bytes_sent request_time=$request_time';
access_log /var/log/nginx/h2-hunt.log h2_hunt;
Apoi compară suma request_length per conexiune cu bytes_received din ss. Dacă volumul primit crește mult în timp ce lungimile logate rămân mici, clientul trimite date care nu apar niciodată ca request-uri — exact profilul unui flood de cadre de control.
Execuții de procese de către worker. Un worker nginx normal nu lansează programe externe. Cu auditd:
ps -eo uid,user,pid,ppid,args | grep '[n]ginx: worker process'
sudo auditctl -a always,exit -F arch=b64 -S execve,execveat \
-F euid=NGINX_UID -k nginx_worker_exec
sudo ausearch -k nginx_worker_exec -ts recent -i
Regula înregistrează doar execuțiile de după instalare, deci un rezultat gol nu exclude o compromitere anterioară.
Ieșiri anormale ale worker-ilor.
sudo grep -Ei 'worker process.*exited|signal 11|segfault' /var/log/nginx/error.log
sudo coredumpctl list nginx
Ierarhia dovezilor: un program lansat de un worker nginx este semnalul cel mai clar de compromitere. Restul — trafic inbound susținut, multe conexiuni de la aceeași sursă, diferență între bytes primiți și request-uri logate, worker-i care mor repetat — sunt semnale slabe individual, dar împreună, fără explicație legitimă, justifică blocarea sursei și investigație.
13. Ce înseamnă pentru echipele din România
Două lucruri ies în evidență din acest incident, dincolo de CVE-uri.
Primul: disciplina de patch la nivel de binar, nu de configurare. Diferența dintre reload și restart, diferența dintre versiunea raportată de nginx -v și versiunea completă de pachet, verificarea ALPN din exterior și inventarul configurațiilor (HTTP/2, HTTP/3, mirror, resolver, mail proxy) sunt exact elementele care decid dacă un incident de acest tip se rezolvă în ore sau în săptămâni. Pentru organizațiile acoperite de NIS2, aceste elemente sunt și dovezi de gestionare a riscului, nu doar bune practici.
Al doilea: ritmul descoperirii s-a schimbat. În 2025, lista de advisory-uri nginx a înregistrat două vulnerabilități noi. Până pe 17 noiembrie 2026, înregistrase 26, fără nginx2root, mai multe fiind corupții de memorie. Patru din cele cinci CVE-uri au fost găsite de un scan automat, fără îndrumare umană: un cercetător a îndreptat platforma către aproximativ 50 000 de linii de cod nginx, iar în 90 de minute au apărut probleme de severitate înaltă cu pași de reproducere suficient de exacți încât să devină exploit funcțional în mai puțin de 10 minute. Dacă descoperirea automată accelerează, fereastra dintre publicarea unui advisory și apariția primelor scanări de exploatare se comprimă la fel de mult.
Un checklist minim, în ordine:
- Inventariază toate instanțele nginx, inclusiv cele din containere, appliance-uri și produse care încorporează nginx.
- Pentru fiecare, notează: versiune completă de pachet, prezența modulului HTTP/2, configurațiile din tabelul din secțiunea 3, accesul extern real.
- Aplică 1.31.9 și repornește procesul, nu doar configurația.
- Dacă nu poți imediat, aplică mitigațiile potrivite configurației — nu doar
http2 off. - Blochează modulul SCTP pe gazdele care nu îl folosesc.
- Instrumentează detectarea: formatul de log cu
conn,request_lengthșiconnection_requests, plus o regulăauditdpentruexecvesub UID-ul worker-ului. - Verifică istoricul: conexiuni lungi cu trafic inbound disproporționat, worker-i care au murit, procese lansate de worker.
Vulnerabilitatea din HTTP/2 a stat nedescoperită în nginx mai bine de un deceniu, iar cea din SCTP din 2018. Ambele proiecte rulează aproape peste tot și au trecut prin ani de revizuire. Asta nu este un argument împotriva auditului, ci împotriva ideii că un audit trecut garantează ceva despre starea de azi.
Referințe
Cercetarea originală, exploiturile și demonstrațiile video aparțin echipei Xint (Theori). Sursa principală: Xint — NGINX2Root: New Remote Code Execution Vulnerabilities in nginx.
- Xint (Theori) — NGINX2Root: New Remote Code Execution Vulnerabilities in nginx Require Urgent Patching: xint.io
- nginx2root — pagină tehnică, verificări de expunere și ghid de răspuns: nginx2root.com
- nginx 1.31.9 — release notes: github.com/nginx/nginx
- W3Techs — cota de piață a serverelor web: w3techs.com