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

Analyse approfondie

Analyse approfondie

PHP-FPM : contrebande de requêtes RCE, corrigée en 8.5.13 (CVE-2026-129289)

Des corps de requête non lus permettent de glisser une requête FastCGI au-delà du frontend et d'exécuter PHP comme worker ; corrigé en 8.5.13 à 8.2.36.

En bref

  • PHP-FPM ne vidait pas les octets non lus du corps de requête avant de réutiliser une connexion FastCGI. CVE-2026-129289 permet à un attaquant de placer une seconde requête FastCGI dans ces octets et d'exécuter PHP comme worker. Le projet PHP a publié l'avis le 2026-11-19.
  • La faille touche PHP 8.2 à 8.5 avant les versions corrigées, sur les déploiements dont le frontend maintient les connexions FastCGI ouvertes et dont l'application ouvre php://input sans le lire.
  • Aucun exploit public n'est lié. La Cybersecurity and Infrastructure Security Agency (CISA) ne relève ni exploitation ni automatisation, et CVE-2026-129289 n'est pas dans le catalogue Known Exploited Vulnerabilities (KEV) au 2026-11-19.
  • Mettez à jour vers PHP 8.5.13, 8.4.28, 8.3.37 ou 8.2.36, publiés le 2026-11-19. Si vous ne pouvez pas, désactivez la réutilisation des connexions backend, comme expliqué dans « Comment corriger ? ».

Suis-je concerné ?

Vous êtes exposé lorsque PHP-FPM exécute une branche affectée, que le frontend maintient la connexion FastCGI ouverte et que l'application ouvre php://input sans le lire. Toutes ces conditions doivent être réunies :

  • Les requêtes atteignent PHP via PHP-FPM. Un déploiement CLI uniquement ou mod_php n'utilise pas la connexion FastCGI qui transporte la requête forgée.
  • PHP est en 8.2.0 à 8.2.35, 8.3.0 à 8.3.36, 8.4.0 à 8.4.27 ou 8.5.0 à 8.5.12.
  • Le frontend maintient les connexions backend ouvertes. L'avis cite nginx avec fastcgi_keep_conn on, Apache mod_proxy_fcgi avec enablereuse=on, les configurations HAProxy FastCGI qui conservent les connexions backend, et LSAPI.
  • L'application ouvre php://input et ne le lit pas jusqu'à la fin avant la fin de la requête. Les frameworks qui créent le flux d'entrée avant le routage ou l'authentification le font.
  • L'attaquant peut envoyer un corps multipart malformé qui arrête l'analyseur à une position prévisible, et peut nommer un script PHP existant sur le serveur.

LSAPI partage le défaut de nettoyage de la requête, mais l'avis le relie à une désynchronisation et à une perturbation du flux, pas à la chaîne de paramètres FastCGI qui exécute du code. Les configurations nginx et Apache standard qui ferment la connexion FastCGI après chaque requête ne sont pas touchées par l'attaque PHP-FPM démontrée. PHP 8.6.0, publié le même jour, est hors des plages affectées.

W3Techs rapporte que PHP est utilisé par 68,1 % de tous les sites dont il peut identifier le langage côté serveur, vérifié le 2026-11-19. La faille atteint les déploiements PHP-FPM qui maintiennent aussi les connexions backend ouvertes.

Branche Versions affectées Version corrigée
PHP 8.6 Non affectée 8.6.0
PHP 8.5 8.5.0 à 8.5.12 8.5.13
PHP 8.4 8.4.0 à 8.4.27 8.4.28
PHP 8.3 8.3.0 à 8.3.36 8.3.37
PHP 8.2 8.2.0 à 8.2.35 8.2.36
PHP 8.1 et antérieurs Fin du support par le projet PHP Aucune version PHP ; consultez la distribution ou le fournisseur

Vérifiez le runtime qui sert le trafic, pas celui d'un fichier de build :

php -v
php-fpm -v
php-fpm -i 2>/dev/null | grep -E 'Server API|Loaded Configuration File'
dpkg -l 2>/dev/null | grep -E 'php[0-9.]*-fpm'
rpm -qa 2>/dev/null | grep php-fpm

php-fpm -v affiche la version du binaire FPM. php -v peut différer lorsque les paquets CLI et FPM sont sur des branches différentes. La ligne Server API de php-fpm -i indique FPM/FastCGI lorsque le binaire est FPM. Les commandes de paquets montrent la branche installée par la distribution.

Vérifiez ensuite si le frontend réutilise la connexion backend. Pour nginx :

sudo nginx -T 2>/dev/null | grep -n 'fastcgi_keep_conn'

Un résultat vide signifie que la directive est absente, et nginx utilise sa valeur par défaut off. Une ligne avec on signifie que nginx demande à FPM de garder la connexion ouverte. Pour Apache :

sudo apachectl -M 2>/dev/null | grep proxy_fcgi
sudo apachectl -S 2>/dev/null | grep -i 'fcgi'

Apache mod_proxy_fcgi désactive la réutilisation de connexion par défaut. Cherchez enablereuse=on dans la configuration ProxyPass. Pour un conteneur, exécutez les mêmes vérifications dans le conteneur en cours d'exécution :

docker exec <container> php-fpm -v
docker exec <container> php-fpm -i 2>/dev/null | grep 'Server API'

La seconde condition est du code applicatif qui ouvre php://input. Une recherche dans l'arborescence de l'application trouve les candidats :

grep -R --include='*.php' "php://input" /var/www 2>/dev/null

Un résultat est une piste, pas une preuve. L'application doit ouvrir le flux sans le lire jusqu'à la fin sur un chemin qu'un attaquant peut atteindre.

Comment corriger ?

Mettez à jour PHP-FPM vers la version corrigée de votre branche. PHP a publié 8.5.13, 8.4.28, 8.3.37 et 8.2.36 le 2026-11-19 à 14:00 UTC, et 8.6.0 le même jour.

  1. Sur Debian ou Ubuntu, mettez à jour chaque paquet PHP qui sert les requêtes, puis redémarrez FPM : bash sudo apt update sudo apt install --only-upgrade php8.5-fpm php8.5-cli sudo systemctl restart php8.5-fpm Ajoutez libapache2-mod-php8.5 si Apache sert PHP via mod_php. Remplacez 8.5 par la branche que vous utilisez. Si la distribution n'a pas encore publié le paquet corrigé, attendez sa mise à jour de sécurité et utilisez le contournement jusque-là.
  2. Sur RHEL, Fedora, AlmaLinux ou Rocky Linux, mettez à jour les paquets PHP et redémarrez le service : bash sudo dnf upgrade 'php*' sudo systemctl restart php-fpm
  3. Sur Alpine, mettez à jour les paquets PHP et redémarrez FPM : bash sudo apk upgrade 'php*' sudo rc-service php-fpm83 restart Remplacez php-fpm83 par le nom du service de votre branche.
  4. Reconstruisez et recréez chaque conteneur à partir d'une image corrigée. Tirer l'image ne change pas le conteneur en cours d'exécution.
  5. Confirmez le service en cours d'exécution avec php-fpm -v et php-fpm -i | grep 'Server API'.

Le journal des modifications de 8.5.13 liste 17 autres correctifs CVE. Six autres sont notés CVSS v4.0 9,2 Critique :

  • CVE-2026-129474, une utilisation après libération dans les traces des méthodes magiques.
  • CVE-2026-129481, une utilisation après libération après un arrêt de session interrompu.
  • CVE-2026-129496, une utilisation après libération du cache de fuseaux horaires.
  • CVE-2026-126714, des fichiers de session partiellement réécrits.
  • CVE-2026-115560, une incohérence de sérialiseur de session traitée dans notre article précédent.
  • CVE-2026-129182, le repeuplement de la globale last_fatal_error_backtrace après l'arrêt.

Mettez à jour vers la version corrigée même si votre frontend ne réutilise pas les connexions FastCGI.

Si vous ne pouvez pas mettre à jour immédiatement, désactivez la réutilisation des connexions backend. La requête forgée n'est analysée comme une nouvelle requête que lorsque le frontend conserve la connexion.

  1. Dans nginx, laissez fastcgi_keep_conn à sa valeur par défaut off, et supprimez toute directive keepalive sur l'amont FPM. Rechargez nginx.
  2. Dans Apache mod_proxy_fcgi, laissez enablereuse à sa valeur par défaut off sur chaque ProxyPass qui cible FPM. Rechargez Apache.
  3. Dans HAProxy ou un autre frontend FastCGI, fermez la connexion backend après chaque requête.
  4. N'exposez pas l'écouteur FPM directement à un réseau non fiable.

Le contournement bloque le chemin FPM démontré, mais il ne répare pas la logique d'arrêt de la requête. Il ne couvre pas non plus les autres failles de la version. Lire php://input jusqu'à la fin dans le code applicatif réduit la condition. L'avis le juge peu fiable seul, car les chemins d'erreur, les limites de ressources et l'arrêt peuvent terminer la requête plus tôt.

Quelle est la cause racine ?

PHP traitait l'existence d'un flux php://input comme la preuve que le corps de la requête avait été consommé. L'arrêt de la requête sautait donc le vidage qui empêche les octets non lus de rester dans une connexion FastCGI réutilisée. L'erreur se trouve dans sapi_deactivate_module() dans main/SAPI.c à php-8.5.12, lignes 502 à 517 :

SAPI_API void sapi_deactivate_module(void)
{
    zend_llist_destroy(&SG(sapi_headers).headers);
    if (SG(request_info).request_body) {
        SG(request_info).request_body = NULL;
    } else if (SG(server_context)) {
        if (!SG(post_read)) {
            /* make sure we've consumed all request input data */
            char dummy[SAPI_POST_BLOCK_SIZE];
            size_t read_bytes;

            do {
                read_bytes = sapi_read_post_block(dummy, SAPI_POST_BLOCK_SIZE);
            } while (SAPI_POST_BLOCK_SIZE == read_bytes);
        }
    }

request_body est l'objet de flux créé lorsque le code applicatif appelle fopen('php://input', 'r'). Le simple fait d'ouvrir le flux définit le pointeur, tandis que post_read enregistre si la SAPI a réellement consommé le corps. Lorsque le pointeur est défini, la branche else if ne s'exécute jamais, donc la boucle de vidage est sautée même lorsque post_read est faux. Les octets que l'analyseur multipart n'a pas consommés restent dans la connexion FastCGI.

Le côté FastCGI conservait son propre état incomplet. fcgi_read_request() dans main/fastcgi.c remettait req->in_len à zéro au début de chaque appel. Il ne vérifiait pas d'abord si la requête précédente était encore dans un enregistrement FCGI_STDIN :

static int fcgi_read_request(fcgi_request *req)
{
    fcgi_header hdr;
    int len, padding;
    unsigned char buf[FCGI_MAX_LENGTH+8];

    req->keep = 0;
    req->ended = 0;
    req->in_len = 0;
    req->out_hdr = NULL;
    req->out_pos = req->out_buf;

Le champ in_len indique combien il reste de l'enregistrement STDIN courant. Le remettre à zéro indiquait à l'analyseur qu'aucun enregistrement partiel n'existait, donc les octets suivants sur la connexion étaient lus comme une nouvelle requête FastCGI.

PHP a introduit la gestion paresseuse de php://input dans PHP 5.6.0, et l'avis rattache la faille à ce changement. Le commit de correction est e0b8eb8ace3c, écrit le 2026-10-29 par Jakub Zelenka.

Comment la faille est-elle exploitée ?

Un attaquant envoie une seule requête HTTP et utilise les octets laissés par l'application comme seconde requête vers PHP-FPM. Les étapes sont :

  1. Envoyer une requête POST avec Content-Type: multipart/form-data et un corps conçu pour que l'analyseur multipart s'arrête à une position prévisible, avant la fin du corps.
  2. Atteindre un chemin applicatif qui ouvre php://input et ne lit pas le flux jusqu'à la fin. Le framework peut créer le flux avant le routage ou l'authentification, même lorsque le point de terminaison choisi n'utilise jamais le corps.
  3. Laisser la requête se terminer. sapi_deactivate_module() voit request_body défini et saute le vidage, donc les octets non lus restent dans la connexion.
  4. Le frontend garde la connexion FastCGI ouverte parce que FCGI_KEEP_CONN est défini. FPM lit les octets restants comme le début d'une autre requête.
  5. Les octets de l'attaquant forment des enregistrements FastCGI BEGIN_REQUEST, PARAMS et STDIN. Les PARAMS forgés définissent SCRIPT_FILENAME sur un script PHP existant, REMOTE_ADDR sur une valeur choisie par l'attaquant, et PHP_ADMIN_VALUE sur allow_url_include=1 et auto_prepend_file=php://input.
  6. FPM accepte la requête forgée. Le frontend ne l'a jamais créée et ne lui a jamais appliqué ses règles de routage ou d'authentification.
  7. L'entrée de la requête forgée est incluse comme PHP et s'exécute avec les privilèges du worker FPM. Les paramètres PHP définis via PHP_ADMIN_VALUE peuvent rester actifs pour les requêtes suivantes servies par le même worker.

L'attaque franchit la frontière de confiance entre HTTP et le backend PHP avec une seule requête client. Elle ne nécessite ni corruption de mémoire, ni fuite d'adresse mémoire, ni condition de course.

Comment se déroule l'attaque ?

Un corps multipart malformé laisse des octets non lus sur une connexion FastCGI maintenue, et FPM analyse ces octets comme une seconde requête qui exécute du PHP attaquant.

flowchart LR A["Corps multipart malformé"] --> B["L'application ouvre php://input sans le lire"] B --> C["L'arrêt de la requête saute le vidage"] C --> D["Les octets non lus restent sur la connexion FastCGI maintenue"] D --> E["FPM analyse une seconde requête FastCGI"] E --> F["SCRIPT_FILENAME et PHP_ADMIN_VALUE forgés"] F --> G["Le PHP de l'attaquant s'exécute comme worker"]

Le vidage manquant à l'arrêt de la requête est l'étape qui transforme de simples restes d'analyseur en seconde requête.

Que peut faire un attaquant ?

Un attaquant qui termine la chaîne exécute du code PHP comme worker FPM, sans interaction d'un autre utilisateur et sans paramètre PHP non par défaut. L'avis indique cet impact directement. La requête forgée peut exécuter du PHP contrôlé par l'attaquant. L'attaquant n'a pas besoin d'une exécution de code au niveau applicatif ni du contrôle de PHP_VALUE ou PHP_ADMIN_VALUE avant l'attaque.

La même requête forgée peut faire plus que d'exécuter le code de l'attaquant :

  • Dispatcher un script PHP existant que le frontend n'expose pas via ses routes.
  • Fournir un REMOTE_ADDR forgé aux contrôles d'accès applicatifs qui font confiance à l'adresse du client.
  • Définir des paramètres PHP de niveau administrateur pour les requêtes suivantes traitées par le même worker.

Chaque impact nécessite les conditions de « Suis-je concerné ? » :

  • L'attaquant atteint un chemin applicatif qui ouvre php://input sans le consommer.
  • Le frontend garde la connexion FastCGI ouverte.
  • L'attaquant connaît un chemin de script sur le serveur.

L'avis n'établit pas d'exécution de code via LSAPI. Là, le même défaut de nettoyage peut désynchroniser le flux de requêtes et perturber les requêtes suivantes.

Pourquoi le correctif fonctionne-t-il ?

Le correctif rend le vidage indépendant du flux php://input et fait refuser au parseur FastCGI une nouvelle requête tant qu'un enregistrement STDIN est incomplet.

--- a/main/SAPI.c
+++ b/main/SAPI.c
@@ -504,7 +504,8 @@ SAPI_API void sapi_deactivate_module(void)
    zend_llist_destroy(&SG(sapi_headers).headers);
    if (SG(request_info).request_body) {
        SG(request_info).request_body = NULL;
-   } else if (SG(server_context)) {
+   }
+   if (SG(server_context)) {
        if (!SG(post_read)) {
            /* make sure we've consumed all request input data */
            char dummy[SAPI_POST_BLOCK_SIZE];

--- a/main/fastcgi.c
+++ b/main/fastcgi.c
@@ -1039,6 +1039,10 @@ static int fcgi_read_request(fcgi_request *req)
    int len, padding;
    unsigned char buf[FCGI_MAX_LENGTH+8];

+   if (UNEXPECTED(req->in_len != 0)) {
+       return 0;
+   }
+
    req->keep = 0;
    req->ended = 0;
    req->in_len = 0;
@@ -1300,6 +1304,8 @@ void fcgi_close(fcgi_request *req, int force, int destroy)
        req->nodelay = 0;
 #endif
        req->fd = -1;
+       /* a partially read STDIN record does not outlive its connection */
+       req->in_len = 0;

        req->hook.on_close();
    }

Transformer le else if en if séparé signifie que PHP vide le corps de la requête chaque fois que post_read est faux, même lorsque le code applicatif a ouvert php://input. La garde dans fcgi_read_request() empêche FPM de démarrer une nouvelle requête lorsque in_len indique que l'enregistrement STDIN précédent n'a été que partiellement consommé. La remise à zéro de in_len dans fcgi_close() empêche un compteur obsolète de survivre à la connexion.

Le correctif couvre le chemin d'arrêt de la requête et le parseur FastCGI. LSAPI dépend du changement de vidage plutôt que de la garde FastCGI. Le commit ajoute deux tests de régression, un pour une connexion maintenue et un pour un enregistrement STDIN partiel.

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

PHP n'a publié aucun indicateur de compromission pour CVE-2026-129289, donc il n'y a ni nom de fichier, ni adresse, ni chaîne de requête à rechercher. Une tentative échouée peut ne laisser aucune trace au-delà des journaux de requêtes de l'application.

Si la journalisation d'accès de PHP-FPM est activée, comparez ses entrées avec le journal d'accès du frontend. Une exécution de script dans le journal FPM sans requête correspondante dans le journal nginx ou Apache est une piste : la requête forgée n'a jamais traversé le frontend. Traitez un résultat comme une raison d'inspecter l'historique des processus du worker et le script exécuté, pas comme une preuve de compromission.

Vérifiez si le worker exécute encore un binaire affecté. Vérifiez aussi si le frontend réutilise les connexions backend :

php-fpm -v
sudo nginx -T 2>/dev/null | grep -n 'fastcgi_keep_conn'
sudo apachectl -S 2>/dev/null | grep -i 'fcgi'

Notez l'heure de démarrage du worker FPM et la version du paquet avant et après la mise à jour. Un worker antérieur à la mise à jour exécute encore le code vulnérable.

Chronologie

  • 2026-10-29 : Jakub Zelenka écrit le commit de correction e0b8eb8ace3c, qui vide les corps de requête non lus et durcit le parseur FastCGI.
  • 2026-11-13 : le projet PHP réserve CVE-2026-129289.
  • 2026-11-18 : PHP pré-annonce une version de sécurité pour le 2026-11-19 entre 14:00 et 14:30 UTC, avec la sévérité maximale CRITICAL.
  • 2026-11-19 14:00 UTC : PHP publie 8.5.13, 8.4.28, 8.3.37 et 8.2.36 ; 8.6.0 suit à 14:01 UTC.
  • 2026-11-19 14:44 UTC : le projet PHP publie CVE-2026-129289 et l'avis GHSA-qc49-hpvq-g2w6.
  • 2026-11-19 : aucune exploitation dans la nature et aucune entrée dans le KEV de la CISA.

Le correctif a été écrit 21 jours avant la publication des versions corrigées.

Le correctif a été écrit 21 jours avant la publication des versions corrigées
Figure 1 : Du commit de correction aux versions corrigées. Source : avis PHP, commit de correction et enregistrement CVE, vérifiés le 19 novembre 2026

FAQ

La faille touche-t-elle mod_php ou la CLI PHP ?

Non, l'attaque démontrée nécessite une connexion FastCGI maintenue. mod_php et la CLI n'utilisent pas FastCGI, donc le chemin de requête forgée ne s'applique pas. Mettez à jour quand même, car la même version corrige d'autres failles critiques qui les touchent.

Une installation nginx ou Apache par défaut est-elle exposée ?

Non, les valeurs par défaut courantes ferment la connexion backend. nginx définit fastcgi_keep_conn off par défaut, et Apache mod_proxy_fcgi désactive la réutilisation de connexion par défaut. L'attaque s'applique lorsqu'un opérateur active le keepalive, ou lorsqu'une configuration HAProxy FastCGI conserve les connexions backend.

Existe-t-il un proof of concept public ?

Aucun code d'exploit public n'est lié depuis l'avis ou l'enregistrement CVE. L'avis décrit une chaîne démontrée. L'évaluation Stakeholder-Specific Vulnerability Categorization (SSVC) de la CISA indique une exploitation « none » et une automatisation « no ». Cette évaluation ne rend pas la faille inoffensive : l'impact technique est enregistré comme « total ».

PHP 8.6.0 est-il affecté ?

Non, 8.6.0 est hors des plages affectées de l'avis. PHP l'a publié le 2026-11-19, le même jour que les versions de sécurité, et il contient le correctif. Les applications qui peuvent passer à 8.6.0 obtiennent la correction sans rester sur une branche plus ancienne.

Qu'en est-il des autres failles corrigées le 2026-11-19 ?

Le journal des modifications de 8.5.13 liste 17 autres correctifs CVE, dont six autres notés 9,2 Critique. « Comment corriger ? » les liste, et nomme l'incohérence de sérialiseur de session dans CVE-2026-115560 que nous avons traitée séparément.

Lire php://input jusqu'à la fin règle-t-il le problème ?

Non, cela supprime la condition démontrée mais ce n'est pas un correctif complet. L'avis indique que les chemins d'erreur, l'épuisement des ressources et l'arrêt de l'application peuvent encore terminer une requête avec une entrée non lue. Mettez à jour PHP-FPM et, jusque-là, désactivez la réutilisation des connexions backend.

Trouvez les versions de PHP de vos images avec Ostorlab

L'analyse de composition logicielle et la numérisation SBOM d'Ostorlab inventorient le runtime PHP et les paquets dans vos images, afin que vous voyiez quels déploiements portent encore 8.5.12 ou une version antérieure avant de les reconstruire.

Références

  • Avis de sécurité PHP GHSA-qc49-hpvq-g2w6, « PHP-FPM request smuggling through an unread HTTP request body », publié le 2026-11-19 : https://github.com/php/php-src/security/advisories/GHSA-qc49-hpvq-g2w6 (consulté le 19 novembre 2026)
  • Enregistrement CVE-2026-129289, CNA PHP, publié le 2026-11-19 : https://www.cve.org/CVERecord?id=CVE-2026-129289 (consulté le 19 novembre 2026)
  • Commit de correction e0b8eb8ace3c, « Fix GHSA-qc49-hpvq-g2w6: Drain unread request bodies », écrit le 2026-10-29 : https://github.com/php/php-src/commit/e0b8eb8ace3c6301e6d2499a9e4229eef54c5eb2 (consulté le 19 novembre 2026)
  • Annonce de PHP 8.5.13, 2026-11-19 : https://www.php.net/archive/2026.php#2026-11-19-4 (consulté le 19 novembre 2026)
  • Journal des modifications de PHP 8.5 pour 8.5.13, listant les correctifs CVE, 2026-11-19 : https://www.php.net/ChangeLog-8.php#8.5.13 (consulté le 19 novembre 2026)
  • Pré-annonce PHP de la version de sécurité du 2026-11-19, 2026-11-18 : https://www.php.net/archive/2026.php#2026-11-18-1 (consulté le 19 novembre 2026)
  • Directive nginx fastcgi_keep_conn, valeur par défaut off : https://nginx.org/en/docs/http/ngx_http_fastcgi_module.html#fastcgi_keep_conn (consulté le 19 novembre 2026)
  • Documentation Apache mod_proxy_fcgi, réutilisation de connexion désactivée par défaut : https://httpd.apache.org/docs/2.4/mod/mod_proxy_fcgi.html (consulté le 19 novembre 2026)
  • Flux JSON des vulnérabilités exploitées connues de la CISA, catalogVersion 2026.11.18 : https://raw.githubusercontent.com/cisagov/kev-data/develop/known_exploited_vulnerabilities.json (consulté le 19 novembre 2026)
  • W3Techs, part d'utilisation de PHP : https://w3techs.com/technologies/details/pl-php (consulté le 19 novembre 2026)