Aller au contenu

Php2shell : analyse de référence de la crise mondiale RCE du cœur PHP (CVE-2026-109618 & CVE-2026-109619)

Densité :
Métrique / PropriétéSpécification Technique & Évaluation
Identifiants CVECVE-2026-109618 & CVE-2026-109619
Score CVSS 4.0 / 3.19.2 (CVSS:4.0) / 9.8 (CVSS:3.1) (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H)
Hermes Threat Score (HTS)98 / 100 (Vélocité maximale : exploitation automatisée en cours d’industrialisation)
Hermes asset severity (HASS)94 / 100 (Menace systémique sur l’infrastructure web globale)
Écosystèmes ciblesWordPress, Drupal, Joomla, MediaWiki (Wikipédia), PrestaShop, Magento, Nextcloud, Laravel, Symfony
Versions vulnérablesToutes versions de PHP 5.4.0 à 8.4 (PHP 5.x, 7.x, 8.0, 8.1, 8.2 $\le 8.2.26$, 8.3 $\le 8.3.14$, 8.4 $\le 8.4.1$)
Versions corrigéesPHP 8.4.27, PHP 8.3.36, PHP 8.2.35, PHP 8.5.12
Découverte & coordinationCalif (Patch the Planet / OpenAI), Wiz Research, Quarkslab, The PHP Foundation, Cloudflare

2. Le Point d’inflexion de l’IA dans l’ingénierie offensive

Section intitulée « 2. Le Point d’inflexion de l’IA dans l’ingénierie offensive »

Pendant plus de 14 ans, les vulnérabilités sous-jacentes à PHP2Shell sont demeurées enfouies dans le code source de PHP sans être détectées ni militarisées par des chercheurs humains. Leur exploitation exigeait une séquence d’étapes d’une complexité vertigineuse : manipuler les slabs de l’allocateur mémoire Zend (emalloc/efree), survivre aux cycles de requêtes du moteur FastCGI/PHP-FPM, et synchroniser des états partagés entre workers.

graph TD
A["Recherche Traditionnelle (Humaine)"] -->|"Blocage de complexité"| B["Failles dormantes pendant 14 ans<br/>(depuis PHP 5.4.0)"]
C["Modèles Frontières d'IA<br/>(GPT-5.6 Sol & Gemini 4 Argon)"] -->|"Analyse sémantique + Fuzzing ciblé"| D["Modélisation automatique des layouts mémoire"]
D --> E["Adaptation multi-cibles en quelques heures<br/>(WordPress, Drupal, Joomla)"]
E --> F["Militarisation de PHP2Shell"]

L’avènement des modèles frontières d’IA (GPT-5.6 Sol mobilisé par Calif dans l’initiative Patch the Planet d’OpenAI, et Gemini 4 Argon intégré à la plateforme Wiz Atlas de Wiz Research) a brisé ce plafond de complexité :

  1. Hypothèses automatisées sur les collisions de mémoire : L’IA a modélisé les comportements de réallocation de mémoire cross-requêtes en quelques minutes, tâche qui requérait autrefois des mois d’expérimentation laborieuse sous GDB.
  2. Génération d’exploits polymorphes : L’IA a automatisé l’adaptation de la charge utile aux différents alignements mémoire et drapeaux de compilation selon les systèmes d’exploitation (Debian, Alpine, RHEL).
  3. Réduction de la barrière économique : un seul chercheur assisté par un modèle frontière a réalisé en quelques jours ce qu’une équipe d’élite mettait des mois à concevoir.

3. Analyse technique approfondie : les 4 primitives d’exploitation

Section intitulée « 3. Analyse technique approfondie : les 4 primitives d’exploitation »

La recherche conjointe menée par Wiz, Calif et OpenAI révèle que PHP2Shell ne repose pas sur une simple erreur de syntaxe, mais sur quatre bogues d’ingénierie mémoire majeurs regroupés sous les deux CVEs :

Bug 1 : use-after-free dans le désérialiseur d’upload-progress (BG(unserialize))

Section intitulée « Bug 1 : use-after-free dans le désérialiseur d’upload-progress (BG(unserialize)) »

CVE-2026-109618 — Vecteur RCE sur WordPress, Drupal et Joomla

Lors du démarrage d’une requête HTTP, PHP traite les corps multipart/form-data via main/rfc1867.c dans une phase de pré-initialisation de la SAPI, bien avant que les modules normaux ne soient instanciés.

  • Si le suivi de progression d’upload est activé (session.upload_progress.enabled = 1), le module Session décode des données de session pendant cette fenêtre précoce.
  • Le décodeur stocke les métadonnées internes appartenant à la requête dans la variable globale BG(unserialize).
  • En envoyant des délimitations de frontières (boundary markers) spécialement calculées, l’attaquant provoque une erreur fatale de dépassement de mémoire (Out-Of-Memory, OOM).
  • Cette erreur OOM interrompt brutalement l’exécution et détruit le tas de la requête courante (zend_mm_shutdown()), mais omet de réinitialiser la variable globale BG(unserialize).
  • Lors d’une requête ultérieure traitée par le même worker PHP-FPM, PHP consomme la mémoire réallouée par l’attaquant comme s’il s’agissait de structures internes de désérialisation valides, conférant un contrôle total sur l’exécution d’instructions.

Bug 2 : fuite de mémoire de processus à distance (heartbleed-style)

Section intitulée « Bug 2 : fuite de mémoire de processus à distance (heartbleed-style) »

CVE-2026-109618 — Divulgation de données sensibles sans authentification

Cette primitive permet à un attaquant distant d’extraire des pans entiers de la mémoire du worker PHP sans nécessiter d’exécution de code :

  1. Au cours de la phase de démarrage RFC 1867, le gestionnaire de progression publie l’identifiant de session dans PS(id).
  2. Une erreur d’allocation mémoire avorte la requête avant que le nettoyage standard ne soit opéré. Le tas de la requête est libéré, laissant PS(id) pointer vers un bloc de mémoire affranchi (dangling pointer).
  3. Une requête multipart suivante, prise en charge par ce même worker, atteint le chemin de nettoyage de l’upload-progress avant que l’initialisation classique de session n’ait réinitialisé PS(id).
  4. Le moteur PHP fait confiance à ce pointeur obsolète, le traite comme une chaîne zend_string active et encode le contenu de la mémoire du tas réallouée dans l’en-tête de réponse HTTP Set-Cookie: PHPSESSID=....
  5. L’attaquant reçoit en clair des fragments de mémoire contenant des mots de passe, clés d’API cloud (AWS/GCP), jetons JWT et données d’autres requêtes web traitées par le serveur, et ce même si l’application PHP n’utilise jamais session_start().

Bug 3 : use-after-free sur la trace de pile d’erreur fatale (EG(last_fatal_error_backtrace))

Section intitulée « Bug 3 : use-after-free sur la trace de pile d’erreur fatale (EG(last_fatal_error_backtrace)) »

CVE-2026-109619 — RCE non authentifiée démontrée sur Drupal

Dans les versions non corrigées, le moteur PHP conserve la trace de pile (backtrace) de la dernière erreur fatale dans le registre global de l’exécuteur EG(last_fatal_error_backtrace).

  • Lorsqu’une erreur OOM fatale survient, le tas de la requête est détruit, mais la valeur globale de l’exécuteur n’est pas remise à zéro.
  • Le worker survit avec un pointeur pointant vers la mémoire de la requête précédente détruite.
  • Dès que le même worker émet un avertissement ou diagnostic au début de la requête suivante, il tente d’accéder à ce pointeur.
  • L’attaquant ayant préalablement rempli ce segment de mémoire via une requête forgée (heap spraying), PHP suit les structures frelatées, aboutissant à une corruption mémoire exploitable pour détourner le flux d’exécution.

Bug 4 : confusion de types cross-workers dans OPcache (CG(map_ptr_last))

Section intitulée « Bug 4 : confusion de types cross-workers dans OPcache (CG(map_ptr_last)) »

CVE-2026-109619 — RCE non authentifiée démontrée sur WordPress

OPcache stocke les structures précompilées en mémoire partagée (SHM) et distribue des index dans des tables de pointeurs d’exécution par worker :

  • Durant l’appel à zend_accel_script_persist(), PHP avance la frontière locale du processus CG(map_ptr_last).
  • La frontière globale partagée n’est publiée qu’à la fin de la persistance.
  • Si un échec d’allocation intervient entre ces deux étapes, l’incrément local subsiste, laissant des objets partiellement persistés pointant vers des emplacements que l’état partagé considère toujours comme libres.
  • Lorsqu’un autre worker réutilise ces emplacements pour un type d’objet distinct, les métadonnées partagées désynchronisées résolvent un pointeur vers un type de structure erroné (confusion de types).
  • Cette corruption d’état partagé permet d’écrire du code arbitraire directement dans le bytecode partagé exécuté par tous les workers du serveur.

4. Télémétrie en temps réel & déroulement de la crise (heures 0 à 12)

Section intitulée « 4. Télémétrie en temps réel & déroulement de la crise (heures 0 à 12) »
  • 20 Octobre 2026, 15:20 UTC : fuite initiale anonyme sur Hacker News révélant l’existence d’une faille RCE dans le cœur PHP.
  • 20 Octobre 2026, 18:00 UTC : confirmation publique par le cabinet d’audit watchTowr, qui valide la reproductibilité de la CVE-2026-109618.
  • 21 Octobre 2026, 07:43 UTC : Premières sondes détectées dans la nature. Les sondes télémétriques de Cloudflare interceptent des vagues de requêtes multipart/form-data anormales cherchant à forcer des crashs mémoire OOM.
  • 21 Octobre 2026, 08:48 UTC : remi Collet (mainteneur des dépôts PHP pour RHEL/CentOS) annonce qu’aucun binaire ne pourra être mis à disposition immédiatement, laissant des millions de parcs sous Linux d’entreprise sans correctif prêt à l’emploi.
  • 21 Octobre 2026, 10:35 UTC : Blackout préventif aux Pays-Bas : Le Parlement néerlandais (Tweede Kamer), le NCSC-NL et les médias technologiques Tweakers.net et Security.NL éteignent leurs sites web publics ou désactivent tout formulaire.
  • 21 Octobre 2026, 14:00 UTC : publication officielle des versions corrigées (PHP 8.4.27, 8.3.36, 8.2.35, 8.5.12) et coordination d’urgence avec les CDN et hébergeurs (Cloudflare, AWS, Akamai, Google Cloud, Vercel, Automattic).

Pourquoi les WAF traditionnels échouent : la nécessité de la « full transaction detection »

Section intitulée « Pourquoi les WAF traditionnels échouent : la nécessité de la « full transaction detection » »

Les chercheurs ont démontré qu’une simple règle WAF inspectant l’en-tête de requête est facilement contournable par polymorphisme :

  • Les attaquants fragmentent les délimitations MIME (boundaries) ou injectent des en-têtes MIME exotiques supportés par rfc1867.c mais ignorés par les analyseurs de paquets HTTP classiques.
  • La riposte de cloudflare (« full transaction detection ») : pour neutraliser l’attaque, Cloudflare a activé une inspection bidirectionnelle en temps réel. Le pare-feu corrèle la requête entrante avec la réponse du serveur d’origine : si une requête multipart suspecte est immédiatement suivie d’une réponse d’erreur 500 ou d’un cookie PHPSESSID dont la taille excède la longueur normale d’un hachage (32 caractères), la réponse est immédiatement interceptée et bloquée avant d’atteindre l’attaquant, empêchant ainsi la fuite de mémoire.

5. Guide forensique DFIR : détection de compromission sur vos serveurs

Section intitulée « 5. Guide forensique DFIR : détection de compromission sur vos serveurs »

Pour les équipes de réponse à incident (CSIRT/CERT/SOC), voici les artefacts et méthodologies de recherche pour déterminer si un serveur a été la cible d’une exploitation PHP2Shell :

1. Analyse des journaux web (access.log Nginx / Apache)

Section intitulée « 1. Analyse des journaux web (access.log Nginx / Apache) »

Recherchez les anomalies de requêtes POST multipart sur des points d’accès qui n’acceptent habituellement pas de téléversements :

Fenêtre de terminal
# Recherche de requêtes POST multipart à haute fréquence avec code retour 500 ou 502
grep -E 'POST .* HTTP/[0-9.]+" (500|502)' /var/log/nginx/access.log | grep -i "multipart"
# Détection de requêtes avec en-têtes ou corps disproportionnés
awk '($9 ~ /500/ && $10 > 50000) {print $1, $4, $7, $9, $10}' /var/log/nginx/access.log

2. Détection de fuite mémoire dans les logs applicatifs

Section intitulée « 2. Détection de fuite mémoire dans les logs applicatifs »

Vérifiez si des cookies PHPSESSID anormalement longs ont été émis par vos serveurs :

Fenêtre de terminal
# Recherche de cookies de session suspects dépassant 64 caractères hexadécimaux
grep -E 'Set-Cookie:.*PHPSESSID=[a-zA-Z0-9%_-]{64,}' /var/log/nginx/access.log /var/log/apache2/access.log

3. Examen des journaux d’erreurs PHP-FPM (php-fpm.log)

Section intitulée « 3. Examen des journaux d’erreurs PHP-FPM (php-fpm.log) »

Les tentatives d’exploitation provoquent presque systématiquement des épuisements de mémoire et des crashs de workers par violation d’accès :

[21-Oct-2026 07:44:12] WARNING: [pool www] child 14208 exited on signal 11 (SIGSEGV) after 1.204512 seconds from start
[21-Oct-2026 07:44:15] ERROR: [pool www] child 14210 said into stderr: "PHP Fatal error: Allowed memory size of 134217728 bytes exhausted (tried to allocate 67108864 bytes) in Unknown on line 0"
[21-Oct-2026 07:44:18] WARNING: [pool www] server reached pm.max_children setting (50), consider raising it

Indicateurs clés :

  • Erreur OOM survenue sur Unknown on line 0 (indique un crash survenu pendant la phase de parsing C RFC 1867 avant le chargement d’un script).
  • Crashs en chaîne avec signal 11 (SIGSEGV) ou signal 6 (SIGABRT).

Si votre serveur Linux génère des coredumps (/var/lib/systemd/coredump/ ou /tmp/), inspectez la trace de pile du crash :

Fenêtre de terminal
# Analyse de la pile d'exécution du crash PHP-FPM
gdb /usr/sbin/php-fpm /tmp/core.php-fpm.* -ex "bt" -ex "quit"

Signature dans la pile GDB : Présence de trames dans php_rfc1867_callback, multipart_buffer_read, zend_mm_alloc_small ou _php_session_rfc1867_callback.

5. Surveillance de la création de processus fils anormaux

Section intitulée « 5. Surveillance de la création de processus fils anormaux »

PHP-FPM ne doit en aucun cas engendrer d’interpréteur de commandes système ou d’outils de téléchargement :

Fenêtre de terminal
# Commande d'audit en direct sur les hôtes de production
ps -eo pid,ppid,user,args | awk '$2 ~ /^[0-9]+$/ {cmd="ps -p "$2" -o comm="; cmd | getline pcomm; close(cmd); if (pcomm ~ /php-fpm|apache2|httpd/) print $0}'

Tout processus fils tel que /bin/sh, /bin/bash, python3, curl, wget, nc ou socat issu de php-fpm atteste d’une compromission RCE active.


6. Règles de détection prêtes à l’emploi (engineering detections)

Section intitulée « 6. Règles de détection prêtes à l’emploi (engineering detections) »

Règle Suricata : détection des en-têtes PHPSESSID anormaux (fuite mémoire)

Section intitulée « Règle Suricata : détection des en-têtes PHPSESSID anormaux (fuite mémoire) »

Cette règle inspecte le trafic HTTP sortant pour bloquer ou alerter sur la fuite de mémoire de processus PHP2Shell :

alert http any any -> any any ( msg:"HERMES CTI - PHP2Shell Memory Leak Detected (Oversized PHPSESSID)"; flow:established,to_client; http.response_header; content:"Set-Cookie|3A|"; nocase; content:"PHPSESSID="; distance:0; pcre:"/PHPSESSID=[a-zA-Z0-9%_-]{128,}/"; threshold:type limit, track by_src, count 1, seconds 60; classtype:attempted-recon; sid:2026109618; rev:1; )

Règle Suricata : détection des requêtes multipart abusives

Section intitulée « Règle Suricata : détection des requêtes multipart abusives »
alert http any any -> any any ( msg:"HERMES CTI - PHP2Shell Malformed Multipart Exhaustion Attempt"; flow:established,to_server; http.method; content:"POST"; http.header; content:"multipart/form-data"; nocase; pcre:"/boundary=["']?[^
]{70,}/i"; classtype:web-application-attack; sid:2026109619; rev:1; )

Règle Sigma : échecs en cascade et crashs de workers PHP-FPM

Section intitulée « Règle Sigma : échecs en cascade et crashs de workers PHP-FPM »
title: PHP2Shell Post-Exploitation Memory Exhaustion and Worker Crash
id: c4f2e968-382a-4bc1-9011-php2shell001
status: critical
description: Détecte les erreurs mémoires fatales pré-applicatives et les sorties anormales de workers consécutives à une tentative PHP2Shell.
logsource:
product: linux
service: php-fpm
detection:
selection_oom:
message|contains:
- 'PHP Fatal error: Allowed memory size of'
- 'exhausted (tried to allocate'
- 'in Unknown on line 0'
selection_sigsegv:
message|contains:
- 'child'
- 'exited on signal 11 (SIGSEGV)'
timeframe: 1m
condition: selection_oom or (selection_sigsegv | count() > 5)
falsepositives:
- Traitements batch massifs légitimes mal configurés
level: critical
tags:
- attack.initial_access
- attack.t1190

Règle YARA : signature mémoire et fichiers stagers php2shell

Section intitulée « Règle YARA : signature mémoire et fichiers stagers php2shell »
rule Exploit_PHP2Shell_Calif_Payload {
meta:
author = "Hermes Codex Threat Intelligence"
description = "Détecte les motifs caractéristiques des charges utiles et stagers de l'exploit framework PHP2Shell"
reference = "CVE-2026-109618 / CVE-2026-109619"
date = "2026-10-21"
severity = "CRITICAL"
strings:
$header_boundary = "---------------------------php2shell" ascii
$zend_spray_1 = { 48 89 E5 48 83 EC ?? 48 8B 05 ?? ?? ?? ?? 48 85 C0 74 }
$rfc1867_target = "upload_progress_" ascii
$str_corrupt = "BG(unserialize)" ascii wide
condition:
2 of them or ($header_boundary and $rfc1867_target)
}

Règle Falco (détection d’exécution en conteneur / Kubernetes)

Section intitulée « Règle Falco (détection d’exécution en conteneur / Kubernetes) »
- rule: PHP Worker Spawned System Shell or Download Utility
desc: Détecte l'exécution d'un shell ou d'un outil de transfert par un worker PHP suite à une RCE PHP2Shell
condition: >
spawned_process and
(proc.pname in (php-fpm, apache2, httpd, php-cgi)) and
(proc.name in (sh, bash, dash, zsh, curl, wget, nc, python, python3, perl))
output: >
Alerte Critique PHP2Shell RCE: Processus suspect instancié par %proc.pname
(commande=%proc.cmdline utilisateur=%user.name pid=%proc.pid conteneur=%container.id)
priority: CRITICAL
tags: [security, rce, php2shell, mitre_execution]

7. Matrice de remédiation complète & directives T0

Section intitulée « 7. Matrice de remédiation complète & directives T0 »

Plan d’action d’urgence immédiat (délai : moins de 2 heures)

Section intitulée « Plan d’action d’urgence immédiat (délai : moins de 2 heures) »
  1. Étape 1 : neutralisation au mandataire inverse (WAF / reverse-proxy) : Si vous ne pouvez pas appliquer immédiatement les paquets mis à jour sur vos serveurs, bloquez le téléversement multipart non indispensable :

    Sur Nginx :

    # Bloquer tout POST multipart sur les zones non indispensables
    if ($http_content_type ~* "multipart/form-data") {
    return 403;
    }

    Sur Apache HTTPD :

    RewriteEngine On
    RewriteCond %{HTTP:Content-Type} multipart/form-data [NC]
    RewriteRule ^ - [F]
  2. Étape 2 : durcissement du moteur PHP (php.ini) : Désactivez immédiatement la fonctionnalité d’upload-progress sur l’ensemble de vos parcs (cette directive désamorce la primitive UAF principale sans impacter le traitement normal des formulaires applicatifs) :

    ; /etc/php/*/fpm/php.ini ou /etc/php/*/cli/php.ini
    session.upload_progress.enabled = 0
    session.upload_progress.cleanup = 1
    session.use_strict_mode = 1

    Pensez à redémarrer les services php-fpm (systemctl restart php*-fpm).

  3. Étape 3 : application des correctifs officiels : Mettez à niveau votre runtime PHP vers les versions corrigées :

    • Rameau PHP 8.4 : Version 8.4.27
    • Rameau PHP 8.3 : Version 8.3.36
    • Rameau PHP 8.2 : Version 8.2.35
    • Rameau PHP 8.5 : Version 8.5.12
  4. Étape 4 : gestion des versions obsolètes (PHP 5.x, 7.x, 8.0, 8.1) : Pour les parcs patrimoniaux dont les versions sont en fin de vie (EOL) :

    • Aucun correctif officiel n’est publié par The PHP Foundation.
    • Isolez impérativement ces serveurs dans un VLAN sans accès WAN direct.
    • Forcez l’accès derrière un reverse-proxy avec filtrage strict ou WAF managé (Cloudflare, AWS WAF, Fastly).

PHP2Shell est l’incident de sécurité majeur de cette décennie pour l’écosystème web, au même titre que Heartbleed (2014) ou Log4Shell (2021). Il marque un tournant historique où l’intelligence artificielle a transformé des vulnérabilités théoriques de corruption mémoire vieilles de 14 ans en armes cybernétiques prêtes à l’emploi en quelques heures.

Les équipes de sécurité doivent abandonner la croyance selon laquelle des WAFs applicatifs ou des frameworks modernes suffisent à protéger des serveurs lorsque la défaillance réside dans le cœur même du moteur d’exécution en C. La résilience passe désormais par le sandboxing systématique au niveau du noyau (namespaces Linux, seccomp-bpf, politiques SELinux/AppArmor strictes) et par l’observation continue des anomalies mémoires.