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

Analyse approfondie

Analyse approfondie

phpAfterShell : exécution de code via les fichiers de session PHP (CVE-2026-126714)

Une écriture de session PHP interrompue peut fusionner deux sessions et injecter des objets à session_start() ; corrigé de 8.2.36 à 8.5.13.

En bref

  • Le gestionnaire de session files de PHP réécrit le fichier de session actif sur place. Si le processus meurt pendant l'écriture, des octets de la nouvelle session et de l'ancienne peuvent partager un même fichier et être décodés comme une troisième session choisie par l'attaquant.
  • PHP 8.2 à 8.2.35, 8.3 à 8.3.36, 8.4 à 8.4.27 et 8.5 à 8.5.12 sont concernés lorsque le gestionnaire files stocke une session que l'attaquant peut influencer.
  • L'enregistrement CVE note la faille CVSS v4.0 9,2 Critique. Aucune exploitation dans la nature n'est connue et la CVE n'est pas dans le catalogue KEV de la CISA au 2026-11-20. Le chercheur a publié une analyse technique complète et une démonstration de bout en bout.
  • Mettez à niveau vers 8.2.36, 8.3.37, 8.4.28, 8.5.13 ou 8.6.0. Sinon, désactivez la progression des téléversements et cessez de stocker de longues chaînes contrôlées par l'attaquant dans les sessions.

Suis-je concerné ?

Toutes ces conditions doivent être réunies :

  • PHP utilise le gestionnaire de session files, qui est celui par défaut.
  • Le sérialiseur de session est php, également celui par défaut.
  • Un attaquant peut influencer les données stockées dans une session, par exemple avec PHP_SESSION_UPLOAD_PROGRESS ou une application qui stocke une longue chaîne fournie par l'utilisateur.
  • L'attaquant peut interrompre une écriture de session au bon moment, ou le déploiement utilise une version qui tronque après l'écriture.
  • Une chaîne d'exécution de code exige une chaîne de gadgets définie par l'application ou une chaîne d'objets native de PHP que l'attaquant peut atteindre après session_start().

L'avis de PHP indique que la faille ne se limite pas à la progression des téléversements ni à PHP 8.6. Le défaut du gestionnaire files existe dans toutes les branches concernées. Les applications qui ne stockent que de petites valeurs de confiance dans les sessions sont beaucoup plus difficiles à exploiter, car l'attaquant a besoin d'une longue chaîne porteuse et du contrôle des données de remplacement.

Branche Versions concernées Version corrigée
PHP 8.6 versions candidates de 8.6.0 8.6.0
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érieur hors support par le projet PHP aucune version PHP ; consultez la distribution ou le fournisseur

Vérifiez le moteur, le gestionnaire et le sérialiseur sur chaque hôte et dans chaque conteneur qui sert PHP :

php -v
php -i | grep -E 'session.save_handler|session.serialize_handler|session.upload_progress.enabled'
php-fpm -i 2>/dev/null | grep -E 'session.save_handler|session.serialize_handler'
docker exec <container> php -i | grep -E 'session.save_handler|session.serialize_handler'

Les valeurs par défaut sont session.save_handler=files et session.serialize_handler=php. Si les deux sont réglées ainsi, le chemin de stockage est celui décrit par l'avis. Un gestionnaire Redis, base de données ou personnalisé sort de ce défaut d'écriture de fichier, mais chaque backend a ses propres questions d'atomicité.

Comment corriger ?

Mettez à niveau vers la version de sécurité du 2026-11-19 de votre branche : PHP 8.2.36, 8.3.37, 8.4.28 ou 8.5.13. PHP 8.6.0, sorti le même jour, contient aussi le correctif.

# 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 à niveau chaque paquet qui porte le moteur PHP : la CLI, FPM et le module Apache.
  2. Redémarrez le service qui sert les requêtes. Les vérifications en CLI ne rechargent pas un pool FPM en cours d'exécution.
  3. Reconstruisez et recréez les conteneurs à partir de l'image corrigée. Télécharger l'image seule ne modifie pas un conteneur en cours d'exécution.
  4. Confirmez que le service en cours indique la version corrigée avec php -v et les contrôles de la section « Suis-je concerné ? ».

Si vous ne pouvez pas mettre à niveau immédiatement, réduisez la surface d'attaque :

  1. Réglez session.upload_progress.enabled=0 dans php.ini ou la configuration du pool FPM. N'utilisez pas ini_set() ni .user.ini, car ils s'appliquent après le démarrage de la requête.
  2. Cessez de stocker de longues chaînes contrôlées par l'attaquant dans les sessions, ou limitez leur longueur avant session_write_close().
  3. Déplacez les sessions vers un backend qui remplace les enregistrements de façon atomique, comme une base de données ou Redis avec une écriture transactionnelle.
  4. Redémarrez chaque processus PHP pour que la configuration prenne effet.

Désactiver la progression des téléversements supprime un moyen de contrôler les données stockées. Cela ne corrige pas les applications qui placent elles-mêmes des chaînes non fiables dans les sessions, et cela ne rend pas l'écriture du gestionnaire files atomique. Traitez ce réglage comme un contrôle temporaire et mettez à niveau.

Quelle est la cause racine ?

ps_files_write() dans ext/session/mod_files.c écrit la session sérialisée dans l'inode existant avec pwrite() à l'offset zéro. Il ne tronque le fichier que lorsque le remplacement est plus court que la taille mise en cache à l'ouverture du fichier. Le code vulnérable de PHP 8.5.12 est :

/* Truncate file if the amount of new data is smaller than the existing data set. */
if (ZSTR_LEN(val) < data->st_size) {
    php_ignore_value(ftruncate(data->fd, 0));
}

#ifdef HAVE_PWRITE
n = pwrite(data->fd, ZSTR_VAL(val), ZSTR_LEN(val), 0);

Lorsque le remplacement est au moins aussi long que l'ancienne valeur, l'ancien inode reste en place et pwrite() écrase depuis le début. Le noyau peut copier le nouveau tampon par parties.

Si le processus meurt après avoir copié k octets, le fichier contient new[0:k] suivi de old[k:]. Le verrou de fichier empêche une autre opération de session d'entrer pendant l'écriture, mais il n'annule pas les octets quand le processus disparaît.

Le fichier de session n'est pas un bloc opaque. Avec session.serialize_handler=php, c'est une suite d'enregistrements key|serialized_value. Le décodeur cherche le premier pipe, puis passe les octets suivants à php_var_unserialize(). Une fois cette valeur terminée, l'octet suivant commence un autre enregistrement. Il n'y a ni longueur de fichier, ni somme de contrôle, ni marqueur de validation.

Ce format transforme le fichier mixte en problème de parseur. La session porteuse contient les octets de l'objet de l'attaquant dans une chaîne délimitée par une longueur, où ils sont inertes. La session de remplacement contient un champ de longueur plus court pour la même chaîne. Après la fusion, le décodeur lit la chaîne courte, puis traite les octets d'objet restants comme un nouvel enregistrement de premier niveau.

Les deux sessions sources sont valides. La troisième session, mixte, n'existe qu'au niveau du stockage.

Comment la faille est-elle exploitée ?

  1. L'attaquant obtient ou choisit un identifiant de session. Avec session.use_strict_mode désactivé, PHP accepte un identifiant non émis ; avec le mode strict, l'attaquant visite l'application une fois et conserve l'identifiant.
  2. L'attaquant écrit une session porteuse qui contient une longue chaîne, avec les futurs octets d'objet à l'intérieur. La progression des téléversements est un moyen de faire écrire cette session par PHP avant l'exécution de l'application.
  3. L'attaquant écrit une session de remplacement avec un champ de longueur plus court pour la même chaîne. Le remplacement est au moins aussi long que la session porteuse, donc la troncature préalable ne s'exécute pas.
  4. L'attaquant interrompt le pwrite(). Une limite de mémoire atteinte dans un conteneur peut arrêter le processus pendant la copie. Sur une version qui tronque après l'écriture, un délai entre pwrite() et ftruncate() produit la même queue conservée.
  5. L'attaquant envoie une requête normale avec le même identifiant de session. session_start() lit le fichier mixte, décode les octets restants comme un objet et appelle ses méthodes de désérialisation.
  6. Une chaîne de gadgets ou une chaîne d'objets native de PHP transforme cet objet en exécution de code avec les droits du processus PHP. Sans chaîne, l'attaquant peut tout de même réécrire l'état de session, comme l'identité, l'autorisation, le jeton CSRF ou le panier.

L'analyse de Depthfirst décrit un calibrage à distance du point d'interruption. Elle utilise des requêtes multipart maintenues pour approcher la limite de mémoire d'un conteneur dans la famille d'écriture partielle, et la profondeur des crochets multipart pour déplacer un délai entre l'écriture et la troncature dans l'autre famille. La démonstration publique utilise un objet stdClass inoffensif comme oracle et une chaîne native distincte pour l'exécution de code, que les chercheurs ont gardée privée.

Comment se déroule l'attaque ?

Une session porteuse contrôlée par l'attaquant et une session de remplacement partagent un même inode, une écriture interrompue laisse un préfixe du remplacement suivi de l'ancienne queue, et le session_start() suivant transforme les octets restants en objet.

flowchart LR A["Session porteuse avec une longue chaîne"] --> B["Session de remplacement avec une longueur plus courte"] B --> C["pwrite() est interrompu pendant la copie"] C --> D["préfixe nouveau + suffixe ancien dans sess_"] D --> E["session_start() décode le fichier mixte"] E --> F["les octets restants deviennent un objet"] F --> G["une chaîne de gadgets ou native exécute du code"]

PHP a corrigé le gestionnaire de fichiers le 2026-11-19, le jour même de la publication de la CVE et de l'analyse technique
Figure 1 : la CVE, les versions corrigées et la recherche publique sont toutes arrivées le 2026-11-19. Source : avis PHP et recherche Depthfirst, vérifié le 20 novembre 2026

Que peut faire un attaquant ?

L'impact démontré est l'exécution de code avec l'utilisateur qui exécute le processus PHP. Il faut trois éléments réunis : une influence sur les données de session stockées, une interruption au bon moment de l'écriture et une chaîne de désérialisation adaptée dans l'application. L'avis énonce ces conditions. Sans chaîne, l'attaquant peut tout de même corrompre ou remplacer des valeurs de session et modifier l'état de l'application.

L'attaque peut être distante. L'avis et la recherche utilisent des requêtes multipart non authentifiées pour faire écrire la session par PHP avant l'exécution du script cible. Les exigences d'authentification dépendent de la façon dont l'application expose les opérations de session concernées.

La faille corrompt aussi l'état de session à elle seule. Une écriture partielle peut déconnecter des utilisateurs, fusionner l'état de deux utilisateurs ou laisser un fichier de session impossible à décoder. Cette corruption n'est pas une preuve d'exploitation, mais des échecs de décodage répétés autour des mêmes identifiants de session méritent une enquête.

Pourquoi le correctif fonctionne-t-il ?

Le correctif tronque le fichier à zéro avant chaque écriture et s'arrête si la troncature échoue :

-   /* Truncate file if the amount of new data is smaller than the existing data set. */
-   if (ZSTR_LEN(val) < data->st_size) {
-       php_ignore_value(ftruncate(data->fd, 0));
+   if (ftruncate(data->fd, 0) != 0) {
+       php_error_docref(NULL, E_WARNING, "ftruncate() failed: %s (%d)", strerror(errno), errno);
+       return FAILURE;
    }

Avec le fichier vide avant le début de pwrite(), une écriture interrompue peut laisser un préfixe de la nouvelle session, mais il n'y a plus d'ancienne queue à fusionner. Le fichier peut perdre des données de session, ce qui est un problème de disponibilité, mais il ne peut pas contenir deux sessions valides avec une troisième signification. Le contrôle sur ftruncate() arrête aussi l'écriture au lieu de continuer silencieusement quand le système de fichiers refuse la troncature.

L'étiquette finale 8.5.13 contient cette troncature préalable, comme 8.4.28, 8.3.37, 8.2.36 et 8.6.0. Le tableau des versions de Depthfirst, daté du 2026-11-17, décrit l'ordre des versions candidates, où la troncature avait lieu après l'écriture ; les versions publiées que nous avons vérifiées utilisent l'ordre corrigé. Le correctif couvre le gestionnaire files. Les autres gestionnaires sortent de ce défaut, même si leur propre comportement en cas d'écriture interrompue doit être examiné séparément.

Comment vérifier si j'ai été compromis ?

PHP ne publie aucun indicateur pour cette CVE. Ces contrôles cherchent le chemin d'entrée et les fichiers corrompus que la technique laisse derrière elle :

# Upload-progress requests, one documented way to control the session data
grep -Ei 'PHP_SESSION_UPLOAD_PROGRESS' /var/log/nginx/access.log /var/log/apache2/access.log

# Session files that contain a top-level object record
grep -aE '\|(O|C):[0-9]+:"' /var/lib/php/sessions/sess_* 2>/dev/null

# PHP decode failures around the same session IDs
grep -Ei 'Failed to decode session object|session_start\(\): Failed to decode' /var/log/php*.log /var/log/nginx/error.log /var/log/apache2/error.log

Une application légitime peut stocker des objets dans les sessions, donc un résultat sur O: ou C: est une piste, pas une preuve. Comparez-le au format de session de l'application. Une tentative échouée peut ne laisser qu'une ligne de journal d'accès, et l'avis ne publie ni hachages de fichiers, ni domaines, ni adresses IP.

Chronologie

  • 2026-11-11 : réservation de CVE-2026-126714.
  • 2026-11-19 14:00 UTC : sortie de PHP 8.2.36, 8.3.37, 8.4.28, 8.5.13 et 8.6.0 avec le correctif.
  • 2026-11-19 : publication de CVE-2026-126714.
  • 2026-11-19 : publication de la recherche phpAfterShell et de la démonstration de bout en bout par Depthfirst.

FAQ

  • PHP 8.6.0 est-il concerné ? Non. La version 8.6.0 contient le correctif et l'étiquette finale tronque avant l'écriture. Les versions candidates figurent dans la plage concernée.
  • Est-ce la même faille que CVE-2026-115560 ? Non. CVE-2026-115560 est un décalage de sérialiseur entre l'écrivain de progression des téléversements et un changement à l'exécution. CVE-2026-126714 est une écriture de fichier interrompue qui fusionne deux sessions valides. La même version du 2026-11-19 corrige les deux.
  • Faut-il la progression des téléversements ? Non. C'est un moyen de contrôler les données de session. Une application qui stocke une longue chaîne fournie par l'attaquant dans une session donne la même primitive.
  • La chaîne de gadgets doit-elle être dans mon code ? Une chaîne d'objets native de PHP fonctionne aussi. Les chercheurs ont utilisé une chaîne native et ont gardé les étapes finales privées. Une chaîne de gadgets applicative est l'autre chemin.
  • Les sessions Redis ou base de données sont-elles concernées ? Ce défaut précis est dans l'écriture sur place du gestionnaire files. Les autres gestionnaires n'utilisent pas ps_files_write(), mais chaque backend a son propre comportement d'atomicité que cet avis ne couvre pas.
  • La faille a-t-elle été exploitée dans la nature ? Aucune exploitation n'est connue, et la CVE n'est pas dans le catalogue KEV de la CISA au 2026-11-20. La technique est publique, donc l'exposition peut évoluer rapidement.

Inventorier votre moteur PHP avec Ostorlab

L'inventaire SCA/SBOM d'Ostorlab identifie les bibliothèques et les versions de moteur dans une image d'application, ce qui aide à trouver les versions de PHP qui ont encore besoin de la mise à jour du 2026-11-19 : https://www.ostorlab.co/product/sca_sbom

Références

  • Avis PHP GHSA-fm2m-fjf5-v3cp : https://github.com/php/php-src/security/advisories/GHSA-fm2m-fjf5-v3cp (vérifié le 20 novembre 2026)
  • Enregistrement CVE-2026-126714 : https://www.cve.org/CVERecord?id=CVE-2026-126714 (vérifié le 20 novembre 2026)
  • Commit du correctif : https://github.com/php/php-src/commit/e2d3cee9ad4b0b739f4a8ebe6a69c938399b7da6 (vérifié le 20 novembre 2026)
  • Journal des modifications de PHP 8.5.13 : https://www.php.net/ChangeLog-8.php#8.5.13 (vérifié le 20 novembre 2026)
  • Archive de la version PHP du 2026-11-19 : https://www.php.net/archive/2026.php#2026-11-19-4 (vérifié le 20 novembre 2026)
  • Recherche Depthfirst phpAfterShell : https://depthfirst.com/research/phpaftershell (vérifié le 20 novembre 2026)
  • mod_files.c dans PHP 8.5.12 : https://github.com/php/php-src/blob/php-8.5.12/ext/session/mod_files.c (vérifié le 20 novembre 2026)
  • mod_files.c dans PHP 8.5.13 : https://github.com/php/php-src/blob/php-8.5.13/ext/session/mod_files.c (vérifié le 20 novembre 2026)
  • Utilisation de PHP selon W3Techs : https://w3techs.com/technologies/details/pl-php (vérifié le 20 novembre 2026)
  • Catalogue KEV de la CISA : https://www.cisa.gov/known-exploited-vulnerabilities-catalog (vérifié le 20 novembre 2026)