PHP2Shell a fondo: cómo un error de memoria termina en ejecución remota de código

Análisis técnico de CVE-2026-109618 y CVE-2026-109619: la causa en el motor de PHP, por qué mod_php es el caso más expuesto, qué cambia el parche y cómo endurecer y vigilar un servidor que todavía no se puede actualizar.

Equipo Hornero Studio13 min de lectura
Frente de un servidor con discos y luces de estado verdes
Foto: Domaintechnik en Unsplash

Esta es la versión técnica. Si buscás qué hacer en tu empresa sin entrar en detalles, empezá por la nota para no técnicos. Acá vamos a la causa: qué pasa dentro del motor de PHP, qué configuraciones están expuestas y qué se puede hacer en un servidor que no se puede actualizar hoy.

El 21 de octubre de 2026 el equipo de seguridad de PHP publicó dos avisos, GHSA-w8hw-w9fx-j79w (CVE-2026-109618) y GHSA-6wmf-4rv5-p3rp (CVE-2026-109619). Los dos tienen el mismo vector CVSS 4.0, AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H: se atacan por red, sin usuario y sin interacción, pero con complejidad alta (AC:H) y requisitos previos (AT:P). Eso explica por qué el puntaje es 9,2 y no 10, y también por qué todavía no hay explotación masiva: armar el ataque completo es difícil. Difícil no quiere decir imposible.

El problema de fondo: un pedido se corta a la mitad, el proceso sigue vivo y el pedido siguiente lee memoria que ya fue liberada.
El problema de fondo: un pedido se corta a la mitad, el proceso sigue vivo y el pedido siguiente lee memoria que ya fue liberada.

Dos fallas de la misma familia

Un proceso de PHP no atiende un solo pedido: en Apache con mod_php y en PHP-FPM, cada proceso atiende muchos, uno detrás de otro. Entre pedido y pedido el motor libera la memoria del pedido anterior y "limpia" las variables globales que apuntaban a ella. Las dos vulnerabilidades atacan ese momento: logran que un pedido se corte antes de que esa limpieza ocurra o después de que la memoria quedó a medio armar. El pedido siguiente, en el mismo proceso, encuentra punteros a memoria que ya no le pertenece.

Técnicamente son use-after-free y acceso a punteros sin inicializar (CWE-416 y CWE-824 en los avisos). Lo que las vuelve graves es que se disparan antes de que corra el código de la aplicación: no importa si el sistema está bien programado, alcanza con que PHP procese el pedido.

CVE-2026-109618: el error de memoria que sale con longjmp

Cuando un pedido supera el memory_limit, PHP corta la ejecución con un "bailout": un longjmp() que salta hasta el punto de recuperación más cercano. El aviso explica que hay momentos del arranque del pedido en que una estructura ya es accesible pero todavía no terminó de inicializarse. Si la memoria se agota justo ahí, el salto deja esa estructura a medio armar y el cierre del pedido la lee o decide en base a ella. La asignación que falla ni siquiera tiene que estar relacionada con la estructura que queda corrupta.

Lo interesante es cómo se llega al límite de memoria sin pasar el post_max_size. El aviso describe varios caminos, todos en el procesamiento de formularios multipart/form-data:

  • Un pedido multipart sin un largo declarado utilizable pasa el control inicial de post_max_size y sigue entregando datos.
  • Una sola parte del multipart puede traer una cantidad ilimitada de encabezados, que en memoria ocupan mucho más que en el cable.
  • Los campos de archivo vacíos no cuentan para max_file_uploads, pero igual crean los arreglos con los datos del archivo.
  • Los nombres de campo anidados (a[b][c][d]…) multiplican ese trabajo.

CVE-2026-109619: estado global que sobrevive al pedido

PHP guarda parte del estado de cada pedido en variables globales del proceso: el último error, los datos de sesión, objetos, estado de extensiones. Todo eso tiene que resetearse antes de liberar la memoria del pedido. Si un error fatal o un agotamiento de memoria corta el pedido antes del reset, las globales quedan apuntando a memoria liberada. El aviso lo organiza en "productores" (lo que deja el estado colgado) y "consumidores" (lo que lo lee demasiado temprano en el pedido siguiente):

Deja estado colgadoLo lee temprano en el pedido siguiente
Errores fatales: de compilación, excepciones sin capturar, require que falla, tiempo máximo de ejecuciónAvisos de configuración (INI) emitidos antes de iniciar el pedido, aunque no se muestren ni se registren
Agotamiento de memoria después de publicar estado de error, sesión u objetosEl progreso de subida de sesión (session.upload_progress), que corre antes de la sesión normal
Avisos no fatales durante el cierre, que vuelven a cargar el estado de error ya limpiado—

Los dos casos confirmados por PHP son el estado de los backtraces de errores fatales en PHP 8.5 (requiere fatal_error_backtraces, y es la base del RCE confirmado en mod_php) y el ciclo del progreso de subida de sesión, disparado por un agotamiento de memoria mientras se procesa la entrada, validado tanto en mod_php como en FPM. Un detalle que importa: cambiar error_reporting, usar @ o apagar display_errors no evita el problema. El aviso es explícito en que el estado se publica igual.

Por qué mod_php es el peor caso

No todas las formas de correr PHP están igual de expuestas. Según los avisos:

Forma de correr PHPCVE-2026-109618CVE-2026-109619
Apache + mod_phpConfirmado: RCE completo por HTTP con límites por defecto y prefork normalAfectado vía .htaccess y directivas php_value / php_flag aplicadas antes del arranque del pedido
PHP-FPMSusceptible según el análisis del código; sin exploit completo demostradoCamino de sesión validado con un pool dinámico normal; otros casos si el frontend pasa PHP_VALUE
FrankenPHPProbablemente susceptible: ejecuta el cierre siempreSin consumidor temprano en la configuración por defecto, "no por eso inmune"
LSAPI (LiteSpeed)Modelado como FPM: probable, sin validarCandidato condicional

La diferencia de fondo está en qué hace cada uno cuando el arranque de un pedido falla. En mod_php el cierre del pedido corre aunque el arranque haya fallado, y el procesamiento automático del cuerpo puede agotar la memoria justo en el arranque. FPM, en cambio, termina el proceso hijo si el arranque falla, lo que corta parte del camino, aunque no todo.

De la falla a la shell

No vamos a publicar una receta, pero sí conviene entender por qué es explotable. Imperva, con datos de los investigadores, describe cinco técnicas demostradas. Tres usan el progreso de subida de sesión como disparador remoto, justamente porque corre antes que la aplicación. Estas son las más ilustrativas:

  • Use-after-free en el decodificador de sesión: armar una sesión grande con el progreso de subida, forzar el agotamiento de memoria al decodificarla y dejar referencias a memoria ya liberada.
  • Puntero obsoleto en la caché de clases de OPcache: un bailout deja un lugar reservado sin publicar; al reutilizarlo, una operación de archivos puede quedar redirigida. Resultado: lectura de archivos con los permisos del proceso.
  • Puntero obsoleto al ID de sesión: memoria controlada por el atacante se lee como un texto enorme y vuelve en el encabezado Set-Cookie: PHPSESSID. Imperva cita alrededor de 67 KB de memoria del proceso filtrados en una respuesta.
  • Use-after-free en el backtrace de errores fatales (PHP 8.5 con fatal_error_backtraces).

Para llegar a ejecutar código, un pedido posterior tiene que caer en el mismo proceso y ubicar datos preparados en la memoria liberada. Si el tiempo o la ubicación no coinciden, el resultado es una caída del proceso o una respuesta normal. Esa es la "complejidad alta" del CVSS. En la práctica, también quiere decir que un intento de ataque deja rastros: procesos que se caen y errores de memoria en los registros.

Qué cambia el parche

La corrección de CVE-2026-109618 cambia cómo PHP maneja el agotamiento de memoria:

  • Elimina el longjmp() para los errores de memoria.
  • Agrega un "soft OOM": el error se dispara en forma ordenada en el próximo punto seguro de la máquina virtual, no en medio de una inicialización.
  • Agrega un "hard OOM": si el uso de memoria llega a un segundo umbral más alto, el proceso termina en el acto con _exit().

Una consecuencia práctica: después de actualizar, ante tráfico abusivo vas a ver procesos que terminan en lugar de seguir corriendo con memoria corrupta. Es el comportamiento esperado. Conviene que el monitoreo lo sepa para no confundirlo con una falla nueva.

Versiones y cómo verificar

RamaAfectadasCorregida
8.5< 8.5.128.5.12
8.4< 8.4.278.4.27
8.3< 8.3.368.3.36
8.2< 8.2.358.2.35
8.1 y anterioresProbablemente afectadas desde 5.4 (no todas probadas)Sin versión oficial; Fastly informa parches de código mínimos para 7.4, 8.0 y 8.1

Ojo con las distribuciones: Debian, Ubuntu y RHEL suelen aplicar el parche sin cambiar el número de versión. php -v puede decir 8.1 y estar corregido, o decir 8.3.x y no estarlo. Lo confiable es el registro de cambios del paquete:

bash# la versión que atiende la web, no la de la terminal
php-fpm8.3 -v            # o: apache2ctl -M | grep php

# Debian / Ubuntu: ¿el paquete instalado trae el parche?
apt-get changelog php8.3-fpm | grep -E "CVE-2026-10961[89]"

# RHEL / Alma / Rocky
rpm -q --changelog php-fpm | grep -E "CVE-2026-10961[89]"

# después de actualizar: reiniciar TODOS los procesos
sudo systemctl restart php8.3-fpm   # o: sudo systemctl restart apache2

El reinicio no es un detalle: un proceso que arrancó antes de la actualización sigue corriendo el binario viejo hasta que muere. Un reload o un graceful deja procesos viejos atendiendo mientras terminan sus pedidos.

Si hoy no podés actualizar

Los avisos son claros: no hay una configuración que cierre todo. Lo que sigue reduce la exposición mientras se planifica la actualización. Combiná varias capas.

En PHP

ini; php.ini (o php_admin_value en el pool de FPM)
; reiniciar todos los procesos después de cambiarlo

session.upload_progress.enabled = 0  ; corta el camino de sesión demostrado
fatal_error_backtraces = 0           ; solo PHP 8.5: saca el productor confirmado

; acotar lo que un pedido puede hacer crecer
post_max_size = 8M                   ; lo más bajo que permita la aplicación
max_input_vars = 1000
max_input_nesting_level = 16
max_file_uploads = 5
max_multipart_body_parts = 200

Sobre memory_limit: el aviso de CVE-2026-109618 menciona fijar memory_limit=-1 como la principal mitigación de configuración, con dos advertencias. Es incompleta (si mmap() falla, el longjmp() igual puede ocurrir) y deja a PHP sin límite propio, así que el tope tiene que ponerlo el sistema. Para eso no uses ulimit -v ni otros límites RLIMIT_AS / RLIMIT_DATA: hacen fallar mmap() y disparan exactamente el camino vulnerable. La alternativa es un límite de cgroup (memory.max), con el cuidado de que matar el grupo no se lleve al proceso maestro y a todos los hijos juntos.

En PHP-FPM

ini; /etc/php/8.3/fpm/pool.d/www.conf
pm = dynamic
pm.max_requests = 1          ; temporal: un pedido por proceso
php_admin_value[session.upload_progress.enabled] = 0

Con pm.max_requests = 1 cada proceso atiende un solo pedido y muere. El estado colgado nunca llega al pedido siguiente, que es la base de CVE-2026-109619. El costo es rendimiento: se crea un proceso por pedido. Sirve como medida de emergencia en sistemas con poco tráfico, no como configuración permanente.

Delante de PHP (proxy o WAF)

  • Si la aplicación no recibe formularios con archivos, bloqueá multipart/form-data en el proxy para las rutas de PHP. Es la recomendación del propio aviso.
  • Limitá el tamaño del cuerpo en el frente, no solo en PHP.
  • Con Nginx, dejá fastcgi_request_buffering activado (es el valor por defecto): Nginx recibe el cuerpo completo y le pasa a PHP un largo declarado, que es lo que post_max_size necesita para controlar.
  • Si la aplicación no usa el progreso de subida, descartá los campos PHP_SESSION_UPLOAD_PROGRESS (el nombre por defecto de session.upload_progress.name).
  • Cloudflare, Fastly e Imperva publicaron reglas para los vectores conocidos. Ayudan, pero son parches virtuales: no reemplazan la actualización.
nginx# nginx delante de PHP-FPM
client_max_body_size 8m;

location ~ \.php$ {
    # solo si la aplicación no recibe formularios con archivos
    if ($content_type ~* "multipart/form-data") { return 415; }

    fastcgi_request_buffering on;   # valor por defecto, que quede explícito
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.3-fpm.sock;
}

Detección

Como el ataque necesita varios intentos para acertar la memoria, deja señales antes de tener éxito. Qué mirar:

  • Procesos de PHP que se caen: Segmentation fault (11) en el log de Apache, o exited on signal 11 (SIGSEGV) en el de PHP-FPM, sobre todo en ráfagas.
  • Ráfagas de Allowed memory size of … exhausted que coinciden con esas caídas.
  • Respuestas con un PHPSESSID enorme en Set-Cookie: por defecto un ID de sesión de PHP tiene 32 caracteres, no miles.
  • Pedidos multipart anómalos: muchísimos campos, partes con decenas de encabezados, nombres de campo muy anidados.
  • Lo que CISA pide vigilar: procesos de PHP que abren una terminal (sh, bash) o descargan herramientas (curl, wget). CISA publicó una regla SIGMA en su repositorio de GitHub.
bash# caídas de procesos (Apache / FPM)
grep -E "Segmentation fault|exited on signal 11" /var/log/apache2/error.log /var/log/php*-fpm.log

# agotamiento de memoria (usá el error_log que tenga configurado PHP)
grep -c "Allowed memory size" /var/log/apache2/error.log /var/log/php*.log

# procesos hijos de PHP que no deberían existir
ps -eo pid,ppid,user,cmd --forest | grep -A3 -E "php-fpm|apache2|httpd" | grep -E "sh -c|bash|curl|wget|nc "

# registrar toda ejecución de programas del usuario web (33 = www-data en Debian/Ubuntu)
sudo auditctl -a always,exit -F arch=b64 -S execve -F euid=33 -k php_exec

El tercer aviso: CVE-2026-115560

El 23 de octubre PHP informó una tercera falla que no se corrige con las versiones del 21. Solo afecta a aplicaciones que cambian el serializador de sesiones a php en tiempo de ejecución, y PHP la considera de riesgo bajo. La mitigación es la misma que ya está arriba: session.upload_progress.enabled = 0. Es una razón más para dejar esa opción apagada aunque ya hayas actualizado, si la aplicación no la usa (el propio aviso de CVE-2026-109619 lo recomienda).

Cronología

FechaQué pasó
17/10/2026Según la prensa especializada, la red de señuelos de Amazon registra un intento de explotación
20/10/2026Se filtran detalles técnicos antes de la fecha prevista de publicación
21/10/2026PHP publica 8.5.12, 8.4.27, 8.3.36 y 8.2.35 y los dos avisos. CISA emite su alerta
23/10/2026CISA actualiza la alerta con una regla SIGMA de detección. PHP informa CVE-2026-115560

Lo que deja

PHP2Shell no es una falla de una aplicación mal hecha: está en el motor y se dispara antes que el código propio. Las empresas que la van a pasar sin problemas son las que saben qué versión de PHP corre en cada servidor, quién la actualiza y cómo se reinicia. Si esa pregunta no tiene respuesta clara en tu equipo, el problema no termina con este parche.

Fuentes

#PHP#PHP2Shell#CVE-2026-109618#CVE-2026-109619#use-after-free#PHP-FPM#mod_php#hardening
Compartir

¿Tenés un proyecto en mente?