El 18 de noviembre de 2026 nginx publicó la versión 1.31.9 (mainline) y la 1.30.7 (stable) con diez CVE corregidos en una sola entrega. Cuatro figuran como major en nginx.org, y los dos fallos de HTTP/2 que están en el centro —CVE-2026-123007 y CVE-2026-123633— llevan una puntuación CVSS 4.0 de 9,2 en los registros de F5. El mismo día apareció una entrada de Wiz y un envío a Hacker News que llegó a 1.103 puntos y 494 comentarios.
Lo interesante no es la gravedad. Es lo pequeño que resulta el parche y cuánto de la narrativa publicada no sobrevive a una lectura del historial de commits.
Este artículo hace tres cosas. Lee los parches reales (seis líneas añadidas para un fallo, dos para el otro). Reproduce el estado roto sobre compilaciones instrumentadas de 1.31.8 y 1.31.9 con HTTP/2 en claro, usando un cliente de tramas escrito a mano y ningún exploit. Y documenta un comportamiento del binario corregido que no aparece en ningún aviso, blog de proveedor ni registro CVE: un residuo de 8.192 bytes en un contador nuevo que hace que 1.31.9 sea más estricto de lo que exige el protocolo.
Qué se publicó exactamente
| Dato | Valor |
|---|---|
| Versiones | nginx 1.31.9 (mainline) y 1.30.7 (stable), ambas del 2026-11-18 |
| Hora del release en GitHub | 1.31.9 a las 15:54 UTC, 1.30.7 a las 15:56 UTC |
| CVE corregidos en 1.31.9 | 10 |
| Etiquetas de gravedad en nginx.org | 4 × major, 4 × medium, 2 × minor |
| Puntuación de F5 (CVE-2026-123007) | CVSS 4.0 9,2 crítica; CVSS 3.1 8,1 alta; CWE-191 + CWE-787 |
| Puntuación de F5 (CVE-2026-123633) | CVSS 4.0 9,2 crítica; CVSS 3.1 8,1 alta; CWE-416 |
| Diff completo, 1.31.8 → 1.31.9 | 37 archivos, 743 inserciones, 128 borrados |
| Hacker News | 1.103 puntos, 494 comentarios, enviado a las 15:19 UTC — 35 minutos antes del release |
| Repositorio | 32.162 estrellas, 942 watchers, 8.406 forks, BSD-2-Clause |
Diez CVE en una entrega no es lo habitual en nginx. Al agrupar el índice de avisos por versión corregida, 1.31.9 es el lote más grande de la rama 1.31; el máximo anterior era 1.31.0 con seis. La versión 1.31.7 del 14 de octubre traía cinco.
El envío a HN de las 15:19 UTC merece atención por sí solo: el blog y los registros CVE eran públicos aproximadamente media hora antes de que aparecieran los tarballs corregidos en GitHub. Quien leyera el hilo primero y parcheara después tuvo una ventana de 35 minutos en la que el único consejo disponible era «desactiva HTTP/2».
El parche, en el orden en que se escribió
Dos commits concentran los fallos críticos. Ambos son de Roman Arutyunyan.
CVE-2026-123007 — seis líneas, tres archivos
Commit e27f5fa8, HTTP/2: account for queued frames when validating WINDOW_UPDATE, 3 archivos, +6/−2:
- if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
+ if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window - h2c->send_queued) {
h2c->send_window -= frame_size;
+ h2c->send_queued += frame_size;
h2c->send_window += window;
+ h2c->send_queued -= window;
Tres ediciones más lo completan: un campo size_t send_queued en ngx_http_v2_connection_t, un send_queued -= frame->length en el manejador de tramas de datos, y una guarda en el bucle de devolución para que solo se devuelvan tramas de datos:
- window += frame->length;
+ if (frame->handler == ngx_http_v2_data_frame_handler) {
+ window += frame->length;
+ }
El mensaje del commit describe el fallo sin matices:
When a stream is terminated, its unsent payload length is refunded back to the connection flow control. Previously, this could increase the flow control beyond NGX_HTTP_V2_MAX_WINDOW, if it was increased by the client after the stream frames were queued and before the stream was terminated. This eventually resulted in broken buffer size control in ngx_http_v2_send_chain() followed by memory corruption and a possible segmentation fault.
Y acredita a un solo investigador: Reported by Xint.io.
CVE-2026-123633 — dos líneas, un archivo
Commit 2df48a50, HTTP/2: reset reusable connection status on stream creation, 1 archivo, +2:
h2c->processing++;
+ ngx_reusable_connection(h2c->connection, 0);
El mensaje contiene la reproducción más corta de toda la divulgación, y no está en ningún blog de proveedor:
Having an HTTP/2 connection with streams registered as reusable became possible after 76672e650. A connection with no streams and a partial frame read from client was registered as reusable to avoid DoS attacks. So if a client sends only the first HEADERS frame byte, the connection becomes reusable. Later, when the remaining HEADERS bytes are received and a new stream is created, the reusable status is not reset until the connection becomes idle.
76672e65 está fechado el 2021-02-11, HTTP/2: reuse of connections with incomplete frames, de Maxim Dounin, «Prodded by Taewoo Kim». Entre el commit que creó la precondición y el que la eliminó pasaron 5 años y 9 meses.
Este acredita a otro investigador: Reported by Albert @ Vexera AI.
Qué acredita el changelog y qué reclaman los blogs
| Fuente | CVE-2026-123007 | CVE-2026-123633 |
|---|---|---|
CHANGES de la versión | «Thanks to Xint.io.» | «Thanks to Albert of Vexera AI.» |
| Mensaje del commit | «Reported by Xint.io.» | «Reported by Albert @ Vexera AI.» |
| Blog de Wiz | Wiz Research, con Ikotas Labs, Metnir, Rapid7 y Xint como descubridores independientes | Wiz dice haberlo reportado el 21 de octubre; «F5 confirms that another research team had previously reported the same vulnerability» |
| Blog de Xint | Xint, dentro de un conjunto de cinco CVE llamado nginx2root | Xint no reclama CVE-2026-123633 en absoluto |
La propia cronología de Wiz explica la discrepancia que no resuelve: reportó el use-after-free el 21 de octubre y F5 respondió que otro equipo lo había reportado antes. El proyecto acreditó a Vexera AI. Un blog nombra a cinco equipos, el otro nombra a uno, y el código dice dos nombres en total.
Nada de esto cambia lo que debe hacer un lector: parchear. Sí cambia qué significa «lo encontramos» en una divulgación donde un escaneo totalmente automatizado halló cuatro de los cinco fallos, como dice Xint sin adornos: «a fully automated Xint scan found the other four without human guidance».
El laboratorio: dos compilaciones, un cliente, ningún exploit
Para comprobar los parches y no la prosa, compilé ambas versiones desde los tarballs oficiales en Debian 13 con gcc:
./configure --prefix=... --without-http_rewrite_module \
--without-http_gzip_module --with-http_v2_module --with-cc-opt="-O1 -g"
Añadí tres llamadas ngx_log_error(NGX_LOG_ERR, ...) con prefijo INSTR en ngx_http_v2.c y ngx_http_v2_filter_module.c: una tras h2c->processing++ que informa h2c->connection->reusable, otra tras cada WINDOW_UPDATE de conexión aceptado que informa h2c->send_window, y otra al final de ngx_http_v2_filter_cleanup() con la devolución y la ventana resultante.
El cliente son unas 200 líneas de Python que escriben tramas crudas en un socket: preface, SETTINGS, HEADERS, WINDOW_UPDATE, RST_STREAM. Sin TLS, sin ALPN, sin librerías. nginx lo acepta porque listen 8081 http2; habilita HTTP/2 en claro (h2c): el mismo código de parseo de tramas, control de flujo y cola de salida, con otro transporte debajo.
Lo que este montaje puede demostrar: que el estado de protocolo que los parches existen para impedir es alcanzable, qué contadores cambian exactamente, y si una compilación corregida sigue aceptando los mismos bytes.
Lo que no puede demostrar: ejecución remota de código. Tanto Wiz como Xint sitúan la copia fuera de límites final en ngx_ssl_send_chain(), la ruta de envío TLS. Un listener en claro no pasa por ahí. No compilé nginx contra OpenSSL, así que el laboratorio se detiene en el invariante, no en la copia.
Experimento A: 28 bytes activan un flag que nunca debería estar activo
La afirmación del commit 2df48a50 se comprueba de una vez. Envía exactamente un byte de una trama HEADERS —el primer byte de la cabecera de 9 bytes—, espera 0,6 s y envía los 27 restantes.
RESULT test=reusable sent=1+27 bytes
| Compilación | create_stream ve connection->reusable |
|---|---|
| 1.31.8 | 1 |
| 1.31.9 | 0 |
Esa es toda la precondición de CVE-2026-123633, reproducida en 28 bytes y una pausa. La conexión no tiene streams, así que nginx la marca como reutilizable para evitar un DoS de cliente lento; el resto de la trama HEADERS crea luego un stream, y en 1.31.8 la conexión sigue en la lista de drenaje mientras procesa ese stream. Todo lo demás —la conexión al upstream, ngx_drain_connections(), el GOAWAY fallido, el pool liberado— es alcanzable desde este estado sin ningún truco de protocolo nuevo.
No fui más lejos. El drenaje exige presión sobre worker_connections y un upstream con proxy_pass; es una configuración que el lector puede razonar desde el mensaje del commit, y habría producido un fallo en vez de una medición.
Experimento B: tres tramas más allá del máximo
El fallo de control de flujo es aritmética, así que se mide en lugar de discutirse. La secuencia vulnerable es:
- Subir la ventana de conexión hasta exactamente
NGX_HTTP_V2_MAX_WINDOW(2.147.483.647) mientras no existe ningún stream: nada puede consumir el crédito a tus espaldas. - Pedir un archivo grande. nginx encola tramas DATA y resta su carga útil de
h2c->send_window. - Enviar un WINDOW_UPDATE pequeño. Es legal, porque la comprobación compara el incremento con
MAX_WINDOW - send_window, y las tramas encoladas ya redujeronsend_window. - Resetear el stream.
ngx_http_v2_filter_cleanup()devuelve la carga útil encolada encima de la ventana que acabas de subir.
Ejecutando esto contra un archivo estático de 64 MiB, sin que el cliente lea nunca para mantener saturados los búferes del socket, en 1.31.8:
step1 base_send_window=1071161343
step2 topped_to=2147483647 (target 2147483647)
step3 final_send_window=2147487743 max=2147483647 delta=4096
step4 probe_alive=True send_window_after_probe=4294971390
El log del worker, en orden:
INSTR window_update_accepted: inc=1073741824 send_window=1073807359
INSTR cleanup_refund: sid=1 refund=40960 send_window=1071161343 max=2147483647
INSTR window_update_accepted: inc=1076322304 send_window=2147483647
INSTR window_update_accepted: inc=4096 send_window=2147422207
INSTR cleanup_refund: sid=3 refund=65536 send_window=2147487743 max=2147483647
INSTR window_update_accepted: inc=2147483647 send_window=4294971390
Hay que leer las tres últimas líneas juntas. send_window vale 2.147.487.743: 4.096 bytes por encima del máximo del protocolo. El siguiente WINDOW_UPDATE pide otros 2.147.483.647, el mayor incremento que cabe en una trama, y 1.31.8 lo acepta, llevando el contador a 4.294.971.390. Eso es 2³² más 4.094. La comprobación no queda debilitada: queda muerta, porque MAX_WINDOW - send_window desbordó hacia un valor sin signo enorme.
El exceso es exactamente el tamaño del incremento que envié en el paso 3. Esa es la forma del fallo: la devolución retorna un crédito que el WINDOW_UPDATE del cliente ya había retornado, y nada compara el resultado con el máximo.
El análisis de Xint describe los mismos cuatro valores de contador con las mismas etiquetas (Wmax, Wmax − Q, Wmax, Wmax + Q) y una técnica que no necesité: primero una ráfaga de tramas PING, porque nginx encola las respuestas de control por delante de los DATA pendientes y los ACK llenan los búferes TLS/TCP antes de que se encole el DATA. Así consiguen que Q sea grande. Mi Q fue de 65.536 bytes, suficiente para cruzar el máximo y no para llegar a una disposición de heap interesante.
El mismo script contra 1.31.9
step1 base_send_window=1071161343
step2 topped_to=1073807359 (target 2147483647)
FAIL top-up did not land on MAX
INSTR cleanup_refund: sid=1 refund=40960 send_window=1071161343 send_queued=8192 max=2147483647
[info] client violated connection flow control: received WINDOW_UPDATE frame
with window increment 1076322304 not allowed for window 1071169535
El paso que 1.31.8 aceptaba se rechaza y la conexión se cierra con FLOW_CTRL_ERROR. 1071169535 es 1071161343 + 8192: la nueva comprobación resta también send_queued, de modo que el crédito del cliente se mide contra las tramas que todavía no ha recibido. Eso es el parche, y funciona.
También deja un residuo.
La parte no documentada: send_queued no vuelve a cero
Mira el número otra vez. Después de resetear el stream y descartar sus tramas encoladas, send_queued marca 8.192, no 0. La devolución restó 40.960 a un contador al que se le habían cargado 49.152.
No es un artefacto de redondeo; es estructural. El bucle de limpieza elimina y devuelve las tramas que cumplen frame->stream == stream && !frame->blocked. Las tramas bloqueadas se omiten y quedan en la cola, y cuando finalmente se descartan no se restan de send_queued. El contador del parche solo puede bajar por rutas que nunca ven esos bytes.
Consecuencia medida: en 1.31.9 la ventana utilizable de la conexión es permanentemente 8.192 bytes menor de lo que cree el cliente. En mi ejecución la diferencia bastó para convertir un incremento que 1.31.8 acepta en una desconexión por FLOW_CTRL_ERROR. Un cliente que lleva la ventana de conexión estrictamente contra el máximo del protocolo —que es exactamente lo que hace una librería bien escrita tras recibir los SETTINGS del servidor— puede ser desconectado por enviar una trama que la especificación permite.
Cuánto importa esto en producción es otra pregunta, y no voy a exagerarlo. El déficit de 8 KiB se acumula por cada stream reseteado en una conexión dada; una conexión con muchas cancelaciones puede perder más. La mayoría de los clientes reales nunca llevan la ventana hasta el máximo exacto, y por eso esto no ha generado una oleada de reportes en las primeras doce horas. Pero es un cambio de comportamiento sin nota de versión, sin mención en ninguno de los dos análisis de proveedor y sin prueba: el commit añade un contador y nunca verifica que vuelva a su valor inicial.
La afirmación es fácil de comprobar y prefiero decir sus límites: medido aquí en dos resets dentro de una conexión, en una compilación, con -O1 -g, sobre h2c. Una compilación con otros tamaños de búfer puede dejar un residuo distinto.
Donde los dos análisis publicados no coinciden
Más allá de la autoría, las fuentes no cuadran en varias cifras que un equipo de parcheo podría usar para decidir.
| Afirmación | Wiz | Xint | Aviso de nginx.org |
|---|---|---|---|
| CVE-2026-123634, primera versión afectada | 0.6.18 | 1.13.4 | 0.6.18 |
| CVE-2026-113425, primera versión afectada | 0.5.33 | 0.5.15 | 0.5.33 |
| Gravedad de CVE-2026-123633 | Crítica, CVSS 4.0 9,2 | «critical», sin puntuación | medium |
| Gravedad de CVE-2026-123634 | Crítica, 9,2 | sin puntuación | medium |
| CVE en la entrega | 10 | 5 de nginx + 1 del kernel | 10 |
| Corrección en la rama stable | 1.30.7 | no la menciona | 1.30.7 |
| Exposición | «>225 million websites» | 56,7 M hosts en Shodan, 11,94 M con versión (21,1 %), 98,9 % en rango | — |
La fila más consecuente es la tercera. nginx.org etiqueta el use-after-free de HTTP/2 como Severity: medium mientras el registro CVE de F5 para el mismo identificador dice 9,2 crítica / CWE-416. Ambos son oficiales. Un equipo que prioriza desde el índice de avisos y otro que prioriza desde el feed de CVE ordenarán su trabajo de forma distinta el mismo día.
Las cifras de exposición necesitan el mismo cuidado que Xint aplica en la frase siguiente: «These numbers are based on reported version strings and don’t confirm that a server is vulnerable.» El 98,9 % de los hosts con versión cae en el rango afectado, pero el rango empieza en 1.9.5, once años de versiones. La fracción que además tiene HTTP/2 activo y es alcanzable desde internet no la publica nadie.
Lo que un equipo debería verificar de verdad
El consejo publicado es «actualiza a 1.31.9» y «o desactiva HTTP/2». Ambos son correctos. Ninguno basta como comprobación, porque ninguno de estos cinco documentos dice qué está ejecutando tu servidor.
1. La cadena de versión no demuestra el estado del parche. Ubuntu 22.04 traía 1.18.0; tras USN-8955-1 el paquete es 1.18.0-6ubuntu14.22 mientras nginx -v sigue imprimiendo 1.18.0. Compara la versión completa del paquete, no la de upstream.
2. http2 on; en un archivo de configuración no demuestra que HTTP/2 sea alcanzable. Comprueba ALPN contra el puerto público:
openssl s_client -connect host:443 -alpn h2 </dev/null 2>/dev/null | grep "ALPN protocol"
Un 200 por HTTPS tampoco demuestra nada en ningún sentido: el navegador cae a HTTP/1.1 en silencio.
3. Un reload no sustituye el binario. nginx -s reload mantiene vivos los workers antiguos hasta que drenan. Xint lo dice explícitamente: reinicia o haz una actualización de binario en vivo, y luego confirma que los workers antiguos terminaron.
4. Comprobaciones de configuración por CVE — las que deciden de verdad si estás expuesto:
| CVE | Necesita | ¿Lo bloquea desactivar HTTP/2? |
|---|---|---|
| CVE-2026-123007 | HTTP/2 activo, cualquier contenido (archivos estáticos incluidos) | Sí |
| CVE-2026-123633 | HTTP/2 + proxy_pass a un upstream + presión sobre los slots de conexión | Sí |
| CVE-2026-123634 | resolver + proxy_pass derivado de la petición + una subpetición (mirror con mirror_request_body off, o SSI) | No |
| CVE-2026-121810 | HTTP/3 + upstream | No |
| CVE-2026-113425 | proxy de correo con proxy on y auth_http | No |
La columna «No» es la parte que casi todos los resúmenes omiten. Desactivar HTTP/2 te compra dos de cinco, y el fallo del resolver es alcanzable desde HTTP plano en el puerto 8080: la propia tabla de validación de Xint lo lista como punto de entrada.
5. Lee el commit, no el resumen, para tu propia compilación. Si empaquetas nginx o mantienes un fork, git log --oneline release-1.31.8..release-1.31.9 -- src/http/v2/ devuelve cinco commits. Aplica los que necesites; el resto del diff de 743 líneas es endurecimiento no relacionado.
Preguntas frecuentes
¿Mi nginx es vulnerable si está detrás de un CDN? Probablemente menos expuesto, no a salvo. Wiz señala que los CDN y WAF que terminan HTTP/2 «may mitigate parts of the exploit by not reflecting the exact payload back to the underlying NGINX server», y añade que eso «depends on implementation». Si el CDN reenvía h2 a tu origen, el origen sigue parseando las tramas.
¿Afecta a servidores solo con HTTP/1.1? No. Ninguno de los dos fallos críticos es alcanzable sin tramas HTTP/2. Pero la entrega corrige otros ocho CVE, y CVE-2026-118899 (bucle infinito al leer el cuerpo de una petición sobre TLS 1.3) no necesita HTTP/2 en absoluto.
¿Por qué el parche es tan pequeño si el fallo tiene una década? Porque el fallo no está en una funcionalidad: está en una regla de contabilidad. Seis líneas añaden un contador y lo restan en tres sitios. Encontrarlo exigía entender que la devolución y el WINDOW_UPDATE del cliente pueden retornar el mismo crédito, y eso es un problema de razonamiento, no de volumen de código. Xint atribuye cuatro de sus cinco hallazgos a un escaneo automatizado.
¿Puedo detectar la explotación en los logs?
Solo de forma débil. Wiz sugiere vigilar conexiones HTTP/2 de larga duración que envían grandes cantidades de datos, que es también el aspecto de una subida legítima. La sección 3.2 de Xint propone comparar la suma de $request_length por conexión con bytes_received de ss: un cliente cuyo recuento de bytes crece mientras sus longitudes de petición registradas no lo hacen está enviando tramas, no peticiones. Xint también advierte que son indicios generales, no firmas.
¿El parche tiene efectos secundarios que deba probar?
Uno medido aquí: tras un reset de stream, el nuevo contador send_queued de 1.31.9 no vuelve a cero (8.192 bytes en mi ejecución), así que la ventana de conexión queda permanentemente más pequeña que el modelo del cliente, y un cliente estricto puede ser desconectado con FLOW_CTRL_ERROR. Prueba tus clientes HTTP/2 contra 1.31.9 con tráfico intensivo en cancelaciones: deadlines de gRPC, búsqueda en vídeo, cualquier cosa que envíe RST_STREAM.
¿1.30.7 es equivalente a 1.31.9?
Para nueve de los diez CVE, sí: el aviso lista ambas versiones. CVE-2026-120993 (desreferencia de puntero nulo con PROXY protocol v2) dice Not vulnerable: 1.31.9+ solo, porque se introdujo en 1.31.4 y nunca llegó a la rama stable.
El patrón que conviene recordar
Un RCE de nueve y pico en el servidor web más desplegado del mundo se corrigió con ocho líneas en dos commits, uno de los cuales es una sola llamada que resetea un booleano. Nada de eso es raro en trabajo de seguridad de memoria: lo mismo pasó en el análisis de Java4Shell de la semana pasada, donde el parche eran cuatro líneas y el disparador exigía una compilación JIT nueva.
Lo raro es el tamaño de la brecha entre el código y el relato. Cuatro equipos, dos blogs y una divulgación coordinada produjeron dos primeras versiones afectadas distintas para el mismo CVE, dos escalas de gravedad distintas para el mismo identificador y dos relatos distintos de quién encontró qué. El código, mientras tanto, es inequívoco: send_queued existe, ngx_reusable_connection(h2c->connection, 0) se llama, y el contador que introduce no siempre vuelve a cero.
Si ejecutas nginx con HTTP/2, actualiza y reinicia. Después, antes de cerrar el ticket, ejecuta los dos experimentos de arriba contra tu propia compilación: el de 28 bytes tarda un segundo y te dice si el binario que desplegaste es el que crees.
El parche de instrumentación, el cliente de tramas y el log completo de ambas compilaciones son reproducibles con los pasos de este artículo; los únicos cambios locales son tres llamadas ngx_log_error y una línea de configure con --with-http_v2_module. Para ver cómo se comportó un parche igual de pequeño bajo medición en otra pila, la auditoría de Java4Shell aplica el mismo método a un intrínseco JIT.