El pasado 21 de octubre saltaron todas las alarmas en la comunidad con el parche de emergencia de PHP. Como suele pasar con cada fallo crítico que lleva una etiqueta de CVSS 9.2, Internet se inundó en cuestión de horas del ruido de siempre: hilos alarmistas en redes, capturas de escáneres automáticos y artículos clónicos diciendo que el ochenta por ciento de la web se venía abajo.
Cerré las pestañas del ruido y me fui directo a lo único que dice la verdad: el código fuente en C del motor Zend y el diff de los commits de seguridad.
Lo que hay detrás del bautizado como PHP2Shell no es una inyección SQL descuidada ni una mala configuración de un desarrollador. Es una cadena quirúrgica de corrupción de memoria en dos tiempos (CVE-2026-109618 y CVE-2026-109619) que se ejecuta en el núcleo del intérprete, mucho antes de que tu aplicación o tu CMS lleguen siquiera a oler la petición HTTP.
Vamos a bajar al fango del código, entender qué pasa en el heap de memoria y probarlo en el laboratorio interactivo que tenéis integrado más abajo.
El punto ciego: la fase pre-RINIT
Para entender la gravedad del fallo hay que mirar cómo atiende PHP una petición entrante.
Cuando un servidor web como Apache con mod_php recibe un paquete HTTP, el motor de PHP arranca una fase previa a la inicialización de la petición de usuario, conocida internamente en el código C como fase pre-RINIT. En esta etapa, el intérprete procesa datos crudos del protocolo: cabeceras, cookies y el cuerpo de las peticiones multipart/form-data.
Aquí entra en juego una funcionalidad activada por defecto en casi todas las instalaciones estándar: session.upload_progress.
Esta característica permite a los scripts monitorizar en tiempo real el porcentaje de subida de un archivo. Para lograrlo sin obligar al usuario a programar nada en PHP, el propio motor en C intercepta la petición en cuanto detecta el campo oculto PHP_SESSION_UPLOAD_PROGRESS, crea una sesión al vuelo y va actualizando un array global $_SESSION con los bytes recibidos.
El problema fundamental es la jerarquía: este procesamiento ocurre antes de cualquier lógica de aplicación. Si tienes un WAF por software dentro de PHP, un middleware de autenticación o directivas en tu código para rechazar la petición, da exactamente igual. El motor de PHP ya está parseando y reservando memoria en C antes de que tu código exista.
El primer golpe: OOM forzado y el bailout de Zend (CVE-2026-109618)
El gestor de memoria de PHP (zend_mm_heap) trabaja con límites estrictos definidos por la directiva memory_limit. Si una petición intenta reservar más memoria de la permitida, el allocator no se limita a devolver un puntero nulo; invoca directamente una macro interna llamada zend_bailout().
En C, zend_bailout() ejecuta un longjmp() que corta de raíz la ejecución normal de la pila de llamadas y salta a un manejador de excepciones de bajo nivel para abortar la petición:
/* main/rfc1867.c - Fragmento conceptual del parseo multipart */
if (php_rfc1867_encoding_translation()) {
/* Si el buffer de cabeceras excede el límite asignado */
if (total_bytes > zend_memory_limit) {
php_error_docref(NULL, E_ERROR, "Allowed memory size exhausted");
zend_bailout(); /* Corte abrupto de ejecucion */
}
}
El fallo crítico (CVE-2026-109618) reside en qué ocurre cuando ese longjmp() se dispara en mitad del parseo de session.upload_progress.
Durante la subida, PHP va reservando estructuras zval y tablas hash para registrar el progreso. Si un atacante envía cabeceras multipart anormalmente infladas o anidadas de forma maliciosa, puede forzar que el allocator agote la memoria en el instante exacto en que una estructura interna está a medio rellenar.
Al saltar abruptamente con longjmp(), la rutina de limpieza de la petición (RSHUTDOWN) no sabe qué campos estaban completos y cuáles no. El recolector limpia los bloques principales, pero la rutina del módulo de sesiones no desvincula el puntero del identificador de sesión global: la variable interna PS(id) queda huérfana en el contexto del worker.
El segundo golpe: el puntero huérfano y Use-After-Free (CVE-2026-109619)
Aquí es donde entra la trampa mortal de arquitecturas basadas en procesos persistentes, como los workers prefork de Apache.
Cuando la primera petición revienta por falta de memoria con un error 500, el proceso worker no se destruye. Se queda vivo en segundo plano, listo para atender la siguiente conexión HTTP que llegue al servidor.
Y en la memoria de ese worker ha quedado una bomba de relojería:
La memoria de la primera petición fue marcada como liberada por el allocator de Zend.
Sin embargo, el puntero PS(id) del módulo de sesión sigue apuntando a esa misma dirección de memoria física.
Tenemos un escenario clásico de Use-After-Free (UAF) entre peticiones consecutivas en el mismo proceso.
Cuando el atacante lanza la segunda petición inmediatamente después, el allocator de PHP reutiliza exactamente los mismos bloques de memoria recién liberados para almacenar los datos entrantes de la nueva petición.
El atacante tiene ahora el control del contenido del bloque donde PS(id) todavía apunta. Al alinear los bytes con precisión matemática en el cuerpo de la segunda petición, se puede falsificar una estructura _zend_string o un zval falso. Cuando el motor intenta leer el identificador de sesión para continuar el ciclo, en lugar de leer una cadena legítima, salta a la dirección de memoria inyectada, logrando redirigir el puntero de instrucción hacia funciones internas como zif_system y ejecutando comandos en el sistema operativo bajo los privilegios del servidor web.
Laboratorio interactivo en vivo
Y ahora llega mi parte favorita: la de romper cosas.
Para no quedarnos en la teoría abstracta, he preparado este simulador interactivo que replica el comportamiento interno del heap y las dos fases del exploit.
Writeup rápido para explotarlo paso a paso
Si quieres seguir el flujo de ataque ordenado:
Paso 01 (Línea base): Dale a ENVIAR PETICIÓN con la subida normal. Verás cómo el worker de PHP responde 200 OK y en el visor del heap el bloque 0x7ffb4a0140 se libera limpiamente sin dejar nada roto.
Paso 02 (El gatillo OOM): Selecciona el Paso 02. El payload mete cabeceras desmedidas para saturar la memoria. Pulsa ENVIAR PETICIÓN: el servidor revienta con un 500 por memory_limit exhausted. Fíjate en el visor del heap: el bloque 0x7ffb4a0080 ha quedado marcado en rojo como CORRUPTED. El puntero PS(id) está huérfano y el worker sigue vivo.
Paso 03 (Secuestro de flujo y RCE): Cambia al Paso 03. Enviamos la segunda petición al mismo worker con la estructura falseada apuntando a zif_system(). Pulsa ENVIAR PETICIÓN: la llamada secuestra la ejecución, lee el archivo .env ficticio y te escupe la flag del reto.
Dentro de cada etapa tienes también una pestaña desplegable de pistas por si quieres trastear con el cuerpo de la petición:
Nota sobre el entorno: Este laboratorio corre de forma totalmente simulada y segura en tu navegador con datos ficticios. Si estás leyendo esto desde el foro o un lector RSS, entra en la versión web para interactuar con la terminal.
La solución real: qué cambia en el parche
La corrección que el equipo de desarrollo de PHP implementó en las versiones 8.2.35, 8.3.36, 8.4.27 y 8.5.12 ataca la raíz del problema en dos frentes:
Gestión segura de estado en bailouts: Se modificó la rutina de aborto en ext/session/session.c para garantizar que cualquier puntero global al identificador de sesión (PS(id)) se ponga explícitamente a NULL antes de ceder el control al manejador de OOM, impidiendo que sobreviva al ciclo de vida de la petición.
Validación estricta de estructuras a medio inicializar: El parser multipart en main/rfc1867.c ahora comprueba la integridad de los nodos antes de registrar el progreso de subida, cancelando el seguimiento si detecta anomalías en las cabeceras previas a la reserva de memoria.
Si administras servidores con PHP en entornos de procesos compartidos, la prioridad absoluta es actualizar los paquetes del intérprete a las versiones parcheadas. Y si por motivos de legado no puedes actualizar inmediatamente, deshabilitar temporalmente el seguimiento de subidas en tu php.ini mitiga el vector de entrada:
session.upload_progress.enabled = Off
El conocimiento técnico de cómo rompen las cosas por dentro es lo que nos permite defenderlas de verdad. Sin atajos, sin humo y yendo siempre hasta el último byte.