Nginx HTTP/2 RCE: la complejidad es la superficie de ataque
Los RCE de HTTP/2 en Nginx prueban que los parsers de protocolos con estado esconden bugs críticos. Qué revisar en tu stack.

El código más peligroso de internet no es tu aplicación. Es el parser de protocolo con estado que está delante de ella, escrito en C, y que todos dan por hecho que está a prueba de balas. Las nuevas vulnerabilidades RCE en HTTP/2 de Nginx (CVE-2026-123633 y CVE-2026-123007, ambas sin autenticación y ambas con puntuación 9.2) son la prueba más limpia de esa afirmación en años. Una de ellas permitió a unos investigadores conseguir una shell en un Nginx estándar que solo servía archivos estáticos. Sin aplicación backend, sin módulos de terceros, sin bug de aplicación. Solo Nginx, HTTP/2 y un integer underflow que llevaba en el código desde la versión 1.9.5 de 2015.
Aquí va la parte contraintuitiva: dedicamos un esfuerzo enorme a auditar nuestro propio código y casi nada a razonar sobre la puerta de entrada. Y sin embargo, la puerta de entrada es donde un bug de corrupción de memoria de diez años puede entregar a un desconocido sin autenticar ejecución de código en la máquina que termina tu TLS y ve todo el tráfico.
Por qué HTTP/2 en Nginx fue siempre una apuesta arriesgada
HTTP/1.1 es un protocolo de texto. Es simple, verboso, y su modelo de parsing encaja bastante bien con el patrón «leer bytes hasta el delimitador, validar, despachar». Se han encontrado bugs en parsers de HTTP/1 (el request smuggling es todo un género), pero la máquina de estados es lo bastante pequeña como para que un ingeniero cuidadoso la tenga en la cabeza.
HTTP/2 es otra historia. Usa framing binario, multiplexación y tiene estado que atraviesa toda la conexión. Una sola conexión TCP transporta decenas de streams concurrentes. El control de flujo se lleva por stream y por conexión con ventanas deslizantes de créditos. Los streams pueden abrirse, cerrarse a medias, resetearse y repriorizarse en cualquier orden que al cliente se le antoje. La compresión de cabeceras con HPACK implica que el parser mantiene una tabla dinámica compartida que muta a medida que llegan los frames. Cada una de esas características es estado mutable que debe mantenerse consistente ante entrada adversarial, y el cliente controla toda la entrada.
Nginx heredó toda esa maquinaria de estado cuando añadió su módulo de HTTP/2, y lo hizo en C, en una arquitectura orientada a eventos donde las conexiones y los streams son objetos en el heap cuyo ciclo de vida se gestiona a mano. Esa combinación (estado rico y transversal más gestión manual de memoria) es exactamente el caldo de cultivo de use-after-free y de integer underflows. Las dos CVE de aquí son casi caricaturas del género: una es un objeto de conexión que sigue en una lista de «seguro para cerrar» mientras una petición lo está usando; la otra es una contabilidad de control de flujo que da la vuelta por debajo de cero y produce una copia de memoria inválida.
Ya he defendido antes, en el contexto de la brecha entre especificación e implementación, que los bugs se concentran donde los invariantes implícitos de una especificación se encuentran con código que no los hace cumplir. HTTP/2 es un caso de estudio. La RFC 7540 (y ahora la 9113) especifica cómo son los flujos cuando están bien formados. El espacio peligroso es todo lo que la especificación no prohíbe pero que la implementación nunca probó: frames parciales, transiciones de estado en órdenes raros, ventanas manipuladas en valores límite.
El use-after-free: reutilizable mientras está ocupado
CVE-2026-123633 es la más elegante de las dos y merece una lectura atenta. Nginx mantiene una lista de conexiones que considera «reutilizables», es decir, seguras para cerrar cuando necesita huecos para nuevas conexiones. Una conexión HTTP/2 entra en esa lista cuando no tiene streams de petición activos. Hasta aquí, todo sensato.
El fallo está en cómo una conexión sale de la lista, o más bien en que no sale. Envía solo una parte de un frame HEADERS. Nginx ve un frame incompleto, marca la conexión como reutilizable y espera. Ahora envía el resto del frame. El handler crea un nuevo stream de petición e incrementa el contador de procesamiento de la conexión, pero nunca la saca de la lista de reutilizables. Ahora tienes una conexión que procesa una petición en vivo y a la vez está marcada como desechable. Si los slots de conexión escasean, Nginx recorre esa lista, libera la conexión, y la petición en curso se queda apuntando a memoria liberada. Un use-after-free clásico, alcanzable por cualquier cliente sin autenticar que pueda hablar HTTP/2 con un proxy inverso.
Fíjate en lo que hace falta para encontrar esto leyendo código: hay que seguir la pertenencia de un objeto a una estructura de datos a lo largo de dos transiciones de estado disparadas por entrada de red dividida en varios paquetes. Eso no es un bug que detecte un linter. Ni siquiera es uno que los fuzzers encuentren fácilmente, porque requiere una interacción específica de dos pasos (frame parcial, espera, frame completo) más presión de memoria para disparar el cierre. Es el tipo de cosa que estuvo oculta casi seis años pese a que Nginx es de los códigos más leídos del planeta.
El integer underflow: una década a la vista
CVE-2026-123007 es más antigua y en cierto sentido peor. El control de flujo de HTTP/2 funciona concediendo a cada stream y a cada conexión una ventana de envío, un saldo de créditos que el emisor decrementa al transmitir y el receptor repone con frames WINDOW_UPDATE. Si la contabilidad de esa ventana sale mal, puedes acabar calculando un tamaño de copia a partir de un valor que dio la vuelta, y de pronto estás haciendo memcpy desde o hacia memoria que no deberías tocar.
Los investigadores demostraron ejecución remota de código a partir de esta primitiva en una configuración casi por defecto: Nginx sirviendo archivos estáticos por HTTPS en un sistema de 64 bits. ASLR no salvó la situación, porque ambas vulnerabilidades funcionan también como primitivas de lectura de memoria antes de escalar a ejecución de código. Filtras punteros, neutralizas la aleatorización y luego escribes. Es artesanía de explotación moderna estándar, pero conviene interiorizarlo: mitigaciones como ASLR encarecen la explotación, no la impiden, y cualquier bug que te dé lectura más corrupción es, en la práctica, game over.
El underflow se publicó en Nginx 1.9.5 en 2015. Once años. Durante ese tiempo el código fue revisado por miles de ingenieros, desplegado por millones de operadores, escaneado por todos los analizadores estáticos comerciales del mercado y sometido a fuzzing (Nginx sí se somete a fuzzing). Sobrevivió a todo. Si eso no recalibra tu fe en que «el open source maduro es seguro porque hay muchos ojos», nada lo hará.

La parte incómoda: la IA encontró lo que el fuzzing no
Este es el detalle que debería quitarle el sueño a los equipos de seguridad. Wiz encontró ambos bugs con un arnés de escaneo de código asistido por IA y luego usó modelos de frontera para validar la explotabilidad. Y no estaban solos: Ikotas Labs, Metnir, Rapid7 y Xint reportaron de forma independiente los mismos fallos a F5 dentro de la misma ventana de divulgación. Cinco equipos, dos bugs de hace una década, convergiendo en el mismo momento.
Eso no es casualidad. Es un cambio de fase. La barrera práctica que antes protegía a estos bugs antiguos de seguridad de memoria no era que fueran imposibles de encontrar en principio, sino que seguir el estado a través de decenas de caminos de código costaba mucha atención humana. Los modelos son ahora lo bastante buenos justo en ese tipo de razonamiento multi-salto como para que el coste se haya desplomado. Hemos visto el mismo patrón hace poco con Java4Shell, donde 65 bytes se convirtieron en RCE: otro fallo de larga duración sacado a la luz por herramientas que siguen interacciones sutiles mejor que humanos cansados.
Se derivan dos implicaciones, y voy a ser directo con ambas. Primera: cada equipo defensivo tiene ahora acceso a la misma capacidad de descubrimiento, así que ejecútala sobre tu propio stack antes de que lo haga otro. Segunda, y aquí es donde concedo los límites de mi afirmación inicial: los atacantes también la tienen, y la ventana entre «el bug se vuelve encontrable» y «el bug se explota» se está comprimiendo. La discusión en Hacker News sacó a la luz un detalle feo: el parche de una de las CVE estuvo en el repositorio público una semana antes de la divulgación, con un mensaje de commit que nombraba a la firma de seguridad que lo reportó. Quien revisara los commits buscando arreglos de seguridad (una técnica black-hat conocida) tuvo ventaja. Los procesos de divulgación coordinada se diseñaron para un mundo donde el descubrimiento era raro. Ese mundo ya no existe.
Lecciones para hacer fuzzing de parsers de protocolo
Si mantienes cualquier parser expuesto a la red (y muchos lo hacemos, en proxies, API gateways, service meshes y protocolos propios), estos bugs son una checklist de dónde es probable que tus pruebas estén flojas.
- Haz fuzzing de secuencias, no solo de mensajes. Ambas CVE requieren interacciones de varios pasos: frames parciales, conexiones pausadas, actualizaciones de ventana en valores límite. Un fuzzer que muta frames sueltos nunca encontrará un bug que necesita el frame A, una espera y luego el frame B. Usa fuzzing con estado o consciente de la gramática que modele el ciclo de vida de la conexión.
- Prueba el ciclo de vida de los objetos bajo presión de recursos. El UAF solo se dispara cuando Nginx necesita recuperar slots de conexión. Tus pruebas deberían ejecutarse con límites de recursos artificialmente bajos para que se ejecuten las rutas de desalojo.
- Afirma invariantes en cada transición de estado. «Si processing > 0, la conexión no debe estar en la lista de reutilizables» se comprueba con una sola aserción. Los invariantes baratos atrapan los bugs que la revisión de código se pierde.
- Haz que falle ante desbordamientos de enteros en builds de depuración. El wrapping con signo y sin signo en la aritmética de control de flujo es exactamente lo que produjo CVE-2026-123007. Los sanitizers (UBSan) más fuzzing habrían dado la alarma hace años.
- Revisa los commits de tu upstream buscando arreglos de seguridad silenciosos. Los defensores pueden jugar la misma partida que los atacantes. Vigilar commits con forma de parche te da días de ventaja.
Y una nota de proceso, aprendida de cubrir divulgación tras divulgación: los plazos de divulgación cada vez más cortos existen porque la brecha entre parche y exploit no deja de reducirse. Tu proceso de respuesta (inventario, priorización, despliegue por fases) importa más que cualquier arreglo individual.
Qué hacer con tus despliegues de Nginx ahora mismo
La remediación es aburrida, y eso es una buena noticia. Actualiza Nginx OSS a 1.30.7 stable o 1.31.9 mainline; los clientes de Nginx Plus necesitan las versiones parcheadas R33/R37. Si no puedes actualizar esta semana, desactiva HTTP/2: en la 1.25.1 y posteriores basta con http2 off; en los server blocks afectados, y en versiones anteriores quita el parámetro http2 de las directivas listen. Luego recarga y confirma que los workers antiguos han terminado. Es una mitigación contundente: pierdes multiplexación y compresión de cabeceras, y las aplicaciones sensibles a la latencia lo notarán. Pero cierra por completo ambos bugs y es un cambio de configuración, no de código.
Para detección, la respuesta honesta es que son difíciles de ver en los logs: la explotación tiene pinta de secuencias de frames HTTP/2 raras y, con el tiempo, de caídas inesperadas de workers o de workers de Nginx que lanzan procesos que nunca deberían lanzar. Los workers que entran en bucle de caídas en un Nginx expuesto a internet con HTTP/2 activo merecen investigación, no solo un reinicio del supervisor.
Una precisión más sobre el alcance: HTTP/2 no está activado por defecto en Nginx, y las encuestas sitúan su uso en torno al 12 % de los servidores. A escala de internet siguen siendo millones de instancias, pero comprueba antes de entrar en pánico, y revisa también tus balanceadores de carga y los orígenes de tu CDN, porque el Nginx que olvidaste detrás del ingress gestionado es el que acaba comprometido.
La complejidad nunca fue una frontera de seguridad. Era solo una cola, y ahora la cola avanza más deprisa.
La lección mayor para la infraestructura crítica
Si haces zoom out, el patrón está claro: los bugs que más importan ahora viven en implementaciones de protocolos con estado y sin seguridad de memoria, en infraestructura que todos compartimos. Esta divulgación por sí sola trajo diez CVE de Nginx: UAF en HTTP/2, un UAF en HTTP/3, un UAF en el resolver DNS y otro en el proxy de correo. El hilo común no es la falta de cuidado; la base de código de Nginx es disciplinada según los estándares de C. El hilo común es que la gestión manual del ciclo de vida en máquinas de estado asíncronas e impulsadas por atacantes supera lo que cualquier equipo puede verificar a ojo.
¿Y entonces qué? No hace falta «reescribirlo todo en Rust», por tentador que sea ese mantra; aunque las reescrituras con seguridad de memoria de los parsers de mayor exposición son una idea genuinamente buena, y la industria lo está haciendo poco a poco. Más inmediato: trata tus proxies de borde como el objetivo de auditoría de mayor valor de tu stack, exige fuzzing con estado y sanitizers a los proyectos de los que dependes, y crea la musculatura operativa para parchear o mitigar en cuestión de días. Se acabó la era en la que un bug de once años podía esperar tranquilamente a que un humano lo notara. Ahora las máquinas leen la cola, en ambos bandos.



