Salta al contenuto principale
Dal blog

PHP2Shell: pipeline per aggiornare PHP, analizzare i log e proteggere con WAF

PHP2Shell: pipeline per aggiornare PHP su Ubuntu, Debian e RHEL-like, verificare il runtime web, analizzare intrusioni nei log e usare il WAF.

Foto profilo di Alessandro IannaconeAlessandro Iannacone

PHP2Shell non è una vulnerabilità di WordPress, Drupal o Joomla: è un problema nel runtime PHP. Le due vulnerabilità critiche CVE-2026-109618 e CVE-2026-109619, entrambe valutate CVSS v4.0 9.2 dal progetto PHP, possono portare a esecuzione di codice da remoto senza autenticazione in installazioni PHP che servono richieste web.

Le versioni upstream corrette, pubblicate il 21 ottobre 2026, sono PHP 8.5.12, 8.4.27, 8.3.36 e 8.2.35. Il progetto PHP è molto chiaro: non esiste una mitigazione completa alternativa all'aggiornamento. Il WAF può ridurre l'esposizione durante la finestra di patching, ma non deve diventare una scusa per rimandare la correzione.

La situazione richiede inoltre qualcosa in più di un semplice apt upgrade o dnf upgrade: Amazon Threat Intelligence ha rilevato tentativi di sfruttamento già il 17 ottobre 2026, quattro giorni prima della disclosure pubblica. Se un server PHP vulnerabile era raggiungibile da Internet, quindi, dopo la patch ha senso eseguire anche una fase di hunting e incident response.

In questo articolo propongo una pipeline concreta:

inventario → preservazione dei log → WAF → patch canary → restart → verifica del runtime web → smoke test → rollout → log hunting → monitoraggio.

Regola operativa: un server non è considerato sanato perché php -v mostra un numero apparentemente corretto. La pipeline è verde solo quando il pacchetto è conforme all'advisory del vendor, i processi web sono stati riavviati, il runtime realmente usato dal sito è quello corretto e i test applicativi sono passati.


Cosa sono CVE-2026-109618 e CVE-2026-109619

Le due vulnerabilità riguardano la gestione della memoria e dello stato interno di PHP.

CVE-2026-109618: corruzione durante un out-of-memory

PHP utilizza meccanismi di bailout per interrompere l'elaborazione quando una richiesta supera determinati limiti di memoria. In alcune condizioni, l'interruzione può avvenire mentre strutture interne sono solo parzialmente inizializzate.

La fase di cleanup successiva può quindi trattare memoria non inizializzata come valida. Il risultato può andare dal crash del worker alla corruzione della memoria fino, nelle condizioni dimostrate dai ricercatori, alla Remote Code Execution.

CVE-2026-109619: stato globale che sopravvive alla richiesta

La seconda vulnerabilità riguarda riferimenti interni che possono sopravvivere alla richiesta che li ha creati.

Dopo un errore fatale, un worker persistente può mantenere riferimenti verso memoria già liberata. Una richiesta successiva gestita dallo stesso processo può riutilizzare quello stato obsoleto, generando una condizione di use-after-free.

Il problema è particolarmente delicato perché i worker PHP vengono normalmente riutilizzati proprio per servire molte richieste.

Perché mod_php è considerato più rischioso

Il progetto PHP considera Apache con mod_php la configurazione a rischio più elevato: è stato dimostrato un percorso di sfruttamento che può avvenire prima dell'esecuzione del codice applicativo.

Anche PHP-FPM è interessato e deve essere aggiornato. Red Hat evidenzia che, nelle configurazioni FPM standard, alcuni percorsi di sfruttamento sono più difficili rispetto a mod_php perché il worker può terminare prima di raggiungere le strutture corrotte. Questo cambia l'exploitability pratica, non lo stato di vulnerabilità.

Sono da considerare nel perimetro anche php-cgi, LiteSpeed/LSAPI, FrankenPHP e altri ambienti che espongono PHP a richieste HTTP.


Le versioni corrette upstream

Per installazioni che seguono direttamente le release PHP:

Ramo PHPVersione corretta
PHP 8.58.5.12 o successiva
PHP 8.48.4.27 o successiva
PHP 8.38.3.36 o successiva
PHP 8.28.2.35 o successiva
PHP 8.1 e precedentiEOL upstream: usare patch del vendor/LTS oppure migrare

PHP 8.2 raggiungerà inoltre l'end of life upstream il 31 dicembre 2026. Se stai facendo ora un intervento strutturale, conviene già pianificare il passaggio a un ramo con una finestra di supporto più lunga.

Ma c'è un dettaglio fondamentale: questa tabella non può essere usata alla cieca sulle distribuzioni Linux.


Non confrontare solo php -v: i vendor fanno backport

Questo è probabilmente il punto che crea più confusione.

Ubuntu 24.04, per esempio, distribuisce PHP 8.3.6 ma Canonical ha backportato le correzioni PHP2Shell nel pacchetto:

8.3.6-0ubuntu0.24.04.13

Ubuntu 22.04 usa addirittura PHP 8.1, ormai EOL upstream, ma Canonical ha pubblicato il pacchetto corretto:

8.1.2-1ubuntu2.28

Allo stesso modo Red Hat mantiene rami PHP più vecchi e applica le patch di sicurezza senza necessariamente trasformare il pacchetto nella release upstream più recente.

Perciò:

php -v

è utile per l'inventario, ma non è sufficiente per decidere se il sistema è vulnerabile.

Devi confrontare il pacchetto installato con l'advisory della distribuzione.


La pipeline di aggiornamento che userei in produzione

Stage 0 — Inventario: dove gira davvero PHP?

Prima di aggiornare devi sapere cosa stai toccando.

Su un server Linux partirei da:

php -v
php --ini

Poi cercherei Apache con mod_php:

apachectl -M 2>/dev/null | grep -i php || true

e i pool PHP-FPM:

ps -eo pid,ppid,user,args | grep '[p]hp-fpm'

Per vedere i servizi presenti:

systemctl list-units --type=service --all \
  | grep -E 'php.*fpm|apache2|httpd|nginx'

Se sul server convivono più versioni PHP, controllerei anche i binari FPM:

for bin in /usr/sbin/php-fpm*; do
  [ -x "$bin" ] && "$bin" -v | head -n 1
done

Attenzione alla CLI

È possibile avere:

  • php -v che mostra PHP 8.4;
  • Apache che carica un modulo PHP diverso;
  • Nginx che inoltra le richieste a un pool PHP-FPM 8.3;
  • più socket FPM dedicati a siti differenti.

Quindi l'inventario deve collegare:

virtual host → socket/processo PHP → pacchetto → versione/advisory.

GO: sai quale runtime serve ogni applicazione esposta.
NO-GO: hai verificato solo il binario /usr/bin/php.


Stage 1 — Prima della patch, preserva le evidenze

Dato che sono stati osservati tentativi di sfruttamento già dal 17 ottobre, eviterei di cancellare o ruotare i log prima di averli conservati.

Individua almeno:

  • access/error log Nginx o Apache;
  • log PHP-FPM;
  • journal di systemd;
  • log del WAF/CDN;
  • auditd/EDR, se presenti;
  • log applicativi;
  • eventi di autenticazione e process execution.

Per una raccolta iniziale:

mkdir -p /root/php2shell-ir

journalctl --since '2026-10-17 00:00:00' --no-pager \
  > /root/php2shell-ir/journal.log

cp -a /var/log/nginx /root/php2shell-ir/ 2>/dev/null || true
cp -a /var/log/apache2 /root/php2shell-ir/ 2>/dev/null || true
cp -a /var/log/httpd /root/php2shell-ir/ 2>/dev/null || true

Su un sistema realmente sospetto farei una raccolta forense più rigorosa, calcolando hash e copiando i dati su uno storage esterno o immutabile.

Non aspettare l'analisi completa per patchare un server esposto. Preserva prima le evidenze essenziali, poi riduci immediatamente la superficie di attacco.


Stage 2 — Metti il WAF davanti al problema, ma consideralo uno scudo temporaneo

Cloudflare ha distribuito protezioni gestite per PHP2Shell prima della disclosure pubblica e AWS ha pubblicato regole specifiche per ridurre l'esposizione.

Il principio è corretto: durante il rollout della patch voglio che la maggior quantità possibile di traffico malevolo venga fermata prima di raggiungere PHP.

I controlli più utili sono:

  • bloccare o ispezionare richieste multipart/form-data dove l'applicazione non usa upload;
  • intercettare richieste anomale collegate a PHP_SESSION_UPLOAD_PROGRESS;
  • applicare limiti coerenti alla dimensione dei body;
  • rate-limitare POST ripetitivi e anomali;
  • monitorare incremento di 5xx;
  • usare managed rules aggiornate dal provider.

Perché il WAF non basta

Un WAF vede la richiesta HTTP, ma non vede lo stato della memoria del worker PHP.

AWS sottolinea inoltre che:

  • l'ispezione del body ha limiti dimensionali;
  • alcune tecniche possono amplificare l'uso di memoria con strutture multipart che non sembrano enormi sulla rete;
  • parte di CVE-2026-109619 dipende da stato e configurazioni server-side che il WAF non può osservare.

Cloudflare ha dovuto introdurre anche una logica di full transaction detection, correlando request e response, proprio perché la sola firma sulla richiesta non era sufficiente in tutti i casi.

Quindi:

WAF = defense in depth. Patch PHP = remediation.

Se non puoi patchare immediatamente un servizio Internet-facing ad alto rischio, la misura più sicura resta rimuoverlo temporaneamente dall'esposizione pubblica o limitarne drasticamente l'accesso.


Stage 3 — Patch su Ubuntu

Canonical ha pubblicato aggiornamenti per le release supportate.

Al 21 ottobre 2026 le versioni corrette principali sono:

UbuntuPHPPacchetto corretto
26.108.58.5.9-0ubuntu2.1
26.04 LTS8.58.5.4-0ubuntu1.5
24.04 LTS8.38.3.6-0ubuntu0.24.04.13
22.04 LTS8.18.1.2-1ubuntu2.28

Per inventariare i pacchetti:

dpkg-query -W 'php*' 2>/dev/null | sort

Poi:

sudo apt update
sudo apt upgrade

Dopo l'upgrade verifica il pacchetto effettivamente installato, per esempio:

dpkg-query -W php8.3-fpm php8.3-common 2>/dev/null
apt-cache policy php8.3-fpm

Su 22.04:

dpkg-query -W php8.1-fpm php8.1-common 2>/dev/null

Ubuntu 20.04 e versioni precedenti richiedono attenzione al canale Ubuntu Pro/ESM se vuoi ricevere il backport ufficiale.

Restart obbligatorio

Installare il pacchetto non significa che i vecchi worker siano spariti.

Per FPM:

sudo systemctl restart php8.3-fpm

adattando la versione.

Con mod_php:

sudo systemctl restart apache2

Se non sei sicuro di quali processi abbiano ancora librerie vecchie aperte, un reboot programmato è il controllo più semplice e deterministico.


Stage 4 — Patch su Debian

Per Debian 13 Trixie la correzione è arrivata con:

php8.4 8.4.27-1~deb13u1

Per Debian 12 Bookworm il ramo PHP 8.2 è stato corretto con:

php8.2 8.2.35-1~deb12u1

Inventario:

dpkg-query -W 'php*' 2>/dev/null | sort

Aggiornamento:

sudo apt update
sudo apt upgrade

Verifica:

apt-cache policy php8.4-fpm php8.4-common 2>/dev/null
apt-cache policy php8.2-fpm php8.2-common 2>/dev/null

Quindi riavvia il servizio realmente utilizzato:

sudo systemctl restart php8.4-fpm

oppure:

sudo systemctl restart php8.2-fpm

Se usi Apache con modulo PHP, riavvia Apache.


Stage 5 — Patch su RHEL, AlmaLinux e Rocky Linux

Nel mondo RHEL-like la verifica deve tenere conto degli AppStream/module stream.

Prima controlla cosa è installato:

rpm -qa 'php*' | sort

e quali stream sono disponibili o attivi:

dnf module list php

Poi verifica gli update di sicurezza:

dnf updateinfo info --cves=CVE-2026-109618,CVE-2026-109619

Applica gli aggiornamenti del vendor:

sudo dnf upgrade --refresh 'php*'

e riavvia PHP-FPM o Apache:

sudo systemctl restart php-fpm

oppure:

sudo systemctl restart httpd

Red Hat ha pubblicato advisory per RHEL 8, 9 e 10. Un caso interessante è RHEL 8, dove esiste una correzione anche per il modulo PHP 7.4: il pacchetto viene mantenuto dal vendor pur essendo quel ramo EOL per il progetto PHP upstream.

Rocky Linux e AlmaLinux hanno pubblicato gli aggiornamenti corrispondenti ai rispettivi stream, inclusi i pacchetti PHP 8.2 e 8.3.

Non cambiare stream durante l'emergenza senza motivo

Non trasformerei un aggiornamento di sicurezza in una migrazione applicativa non pianificata.

Se il vendor fornisce la patch per lo stream in uso:

  1. applica la patch;
  2. verifica;
  3. chiudi l'emergenza;
  4. pianifica separatamente l'eventuale migrazione a un ramo PHP più recente.

Ridurre le variabili durante un incidente è una regola DevOps semplice ma importante.


Stage 6 — Riavvia i worker e verifica il runtime web

Questa fase è il punto in cui molte patch apparentemente riuscite falliscono.

Dopo l'aggiornamento:

ps -eo pid,lstart,args | grep '[p]hp-fpm'

Controlla che i processi abbiano un'ora di avvio successiva all'installazione della patch.

Per Apache:

apachectl -M 2>/dev/null | grep -i php || true
systemctl status apache2 2>/dev/null || systemctl status httpd

Per FPM:

systemctl --type=service --state=running --no-pager | grep -E 'php.*fpm' || true
systemctl status php-fpm --no-pager 2>/dev/null || true

Il controllo migliore resta però verificare il runtime raggiunto dal web server, non soltanto la CLI.

In un ambiente di staging puoi predisporre temporaneamente un endpoint interno che restituisca solo:

<?php
echo PHP_VERSION . ' ' . PHP_SAPI;

Proteggilo per IP o autenticazione, interrogalo dalla rete di management e rimuovilo immediatamente dopo il test.

Non pubblicare phpinfo() su Internet: espone molte più informazioni del necessario.


Stage 7 — Smoke test applicativo

Una patch di sicurezza riuscita ma con il sito rotto non è un rollout completato.

Io separerei i test in tre livelli.

Runtime

curl -fsS https://example.com/health

Applicazione

Controlla almeno:

  • homepage;
  • login;
  • API principali;
  • upload, se previsto;
  • pagine che usano sessione;
  • code/cron;
  • connessione al database;
  • cache;
  • invio email;
  • funzioni che usano estensioni PHP native.

Errori

Subito dopo il restart:

journalctl --since '-10 minutes' --no-pager \
  | grep -Ei 'php|apache|httpd|nginx'

Se hai aggiornato un canary dietro load balancer, lascialo ricevere una percentuale controllata di traffico prima di estendere il rollout.

GO: pacchetto corretto, worker nuovi, health check verde, nessun aumento anomalo di 5xx o crash.
NO-GO: la versione CLI è corretta ma non sai quale FPM serve il sito, oppure il runtime web genera errori.


Uno script finale da usare come gate della pipeline

Questo script non decide da solo se il pacchetto è corretto: quella verifica resta legata all'advisory del vendor.

Serve invece come gate post-patch per verificare che servizi, worker e applicazione siano tornati operativi.

Salvalo come /usr/local/sbin/php-post-patch-gate.sh:

#!/usr/bin/env bash
set -u

HEALTH_URL="${HEALTH_URL:-https://example.com/health}"
PHP_SERVICE="${PHP_SERVICE:-php8.3-fpm}"
WEB_SERVICE="${WEB_SERVICE:-nginx}"

fail=0

ok() {
  printf '[OK] %s\n' "$1"
}

ko() {
  printf '[FAIL] %s\n' "$1"
  fail=1
}

echo "== PHP post-patch gate =="

if command -v php >/dev/null 2>&1; then
  php -v | head -n 1
  ok "PHP CLI disponibile"
else
  ko "PHP CLI non trovato"
fi

if systemctl is-active --quiet "$PHP_SERVICE"; then
  ok "$PHP_SERVICE attivo"
else
  ko "$PHP_SERVICE non attivo"
fi

if systemctl is-active --quiet "$WEB_SERVICE"; then
  ok "$WEB_SERVICE attivo"
else
  ko "$WEB_SERVICE non attivo"
fi

if curl -fsS --max-time 10 "$HEALTH_URL" >/dev/null; then
  ok "health check HTTP"
else
  ko "health check HTTP"
fi

recent_errors="$(
  journalctl --since '-10 minutes' --no-pager 2>/dev/null \
    | grep -Ei \
      'segfault|signal 11|core dumped|Allowed memory size exhausted|malloc.*corrupt|php.*child.*exited' \
    || true
)"

if [ -z "$recent_errors" ]; then
  ok "nessun crash PHP evidente negli ultimi 10 minuti"
else
  printf '%s\n' "$recent_errors"
  ko "rilevati errori da analizzare nel journal"
fi

if [ "$fail" -eq 0 ]; then
  echo "RESULT=PASS"
  exit 0
fi

echo "RESULT=FAIL"
exit 1

Esempio:

HEALTH_URL='https://staging.example.com/health' \
PHP_SERVICE='php8.3-fpm' \
WEB_SERVICE='nginx' \
/usr/local/sbin/php-post-patch-gate.sh

La pipeline CI/CD, Jenkins, Ansible o il sistema di orchestrazione può usare direttamente l'exit code:

  • 0 → rollout consentito;
  • 1 → stop del batch successivo.

Stage 8 — Hunting: come cercare tentativi di PHP2Shell nei log

La patch chiude la vulnerabilità, ma non cancella ciò che può essere successo prima.

Amazon ha osservato un tentativo già il 17 ottobre 2026 e successivamente più attività da infrastrutture anonimizzate. Non userei quindi la data di disclosure come inizio automatico della finestra investigativa.

1. Errori PHP e crash dei worker

Cerca:

  • Allowed memory size exhausted;
  • segfault;
  • signal 11;
  • core dump;
  • worker PHP-FPM terminati in modo inatteso;
  • errori fatali ripetuti;
  • restart anomali di Apache/PHP-FPM.

Esempio:

journalctl --since '2026-10-17 00:00:00' --no-pager \
  | grep -Ei \
    'Allowed memory size exhausted|segfault|signal 11|core dumped|php.*child.*exited|malloc.*corrupt'

Su log PHP separati:

grep -RhiE \
  'Allowed memory size exhausted|segfault|signal 11|core dumped|fatal error' \
  /var/log/php* 2>/dev/null

Un OOM non dimostra automaticamente uno sfruttamento: applicazioni legittime possono esaurire la memoria. Diventa molto più interessante quando coincide con POST anomali, crash, file nuovi o processi inattesi.


2. POST anomali e picchi di 5xx

Nei log Nginx:

zgrep -hE '"POST .*" 5[0-9]{2} ' /var/log/nginx/access.log* 2>/dev/null

Su Apache Debian/Ubuntu:

zgrep -hE '"POST .*" 5[0-9]{2} ' /var/log/apache2/access.log* 2>/dev/null

Su RHEL-like:

zgrep -hE '"POST .*" 5[0-9]{2} ' /var/log/httpd/access_log* 2>/dev/null

Poi correla:

  • stesso IP;
  • stesso endpoint;
  • richieste ripetute;
  • risposte 500, 502, 503;
  • tempi di risposta anomali;
  • dimensioni delle richieste insolite;
  • upload su endpoint che normalmente non li accettano.

Limite importante degli access log

I normali access log Nginx/Apache non registrano il body completo della POST.

Quindi cercare la stringa PHP_SESSION_UPLOAD_PROGRESS nell'access log standard può non trovare nulla anche se la richiesta l'ha contenuta.

Quella ricerca è molto più utile nei:

  • log WAF;
  • log reverse proxy con request inspection;
  • IDS/IPS;
  • PCAP;
  • telemetry EDR/NDR.

Evita di attivare indiscriminatamente il logging dei body in produzione: potresti registrare password, token, dati personali o file caricati.


3. Cerca PHP_SESSION_UPLOAD_PROGRESS dove hai visibilità sul body

AWS indica esplicitamente questo elemento come uno dei segnali da cercare nelle richieste multipart.

Se il tuo WAF esporta log JSON puoi cercare, adattando il path:

grep -Rhi 'PHP_SESSION_UPLOAD_PROGRESS' /var/log/waf/ 2>/dev/null

Un match non prova da solo una compromissione, perché la funzione è legittima in PHP. Ma su un'applicazione che non la usa normalmente è un segnale ad alta priorità da correlare.


4. Cerca processi figli sospetti

Dopo una RCE, ciò che conta è capire cosa ha fatto il processo web.

Verifica l'albero dei processi:

ps -eo pid,ppid,user,lstart,args --sort=lstart

e cerca processi inattesi eseguiti dagli utenti del web server, per esempio:

ps -eo pid,ppid,user,args \
  | grep -E 'www-data|apache|nginx' \
  | grep -E 'sh|bash|curl|wget|python|perl|nc|socat' \
  | grep -v grep

Questa è una ricerca euristica: molti software possono invocare legittimamente utility di sistema. Va correlata con log, parent PID e comportamento dell'applicazione.

Se hai EDR o auditd, la telemetria di process execution è molto più affidabile dello snapshot ottenuto con ps.


5. Cerca file creati o modificati dopo l'inizio della finestra

Per un primo triage:

find /var/www /tmp /var/tmp \
  -xdev -type f -newermt '2026-10-17 00:00:00' \
  -printf '%TY-%Tm-%Td %TH:%TM:%TS %u %m %p\n' \
  2>/dev/null | sort

Cerca in particolare:

  • file PHP nuovi;
  • file nascosti;
  • modifiche in directory di upload;
  • eseguibili in /tmp o /var/tmp;
  • cron o unit systemd inattese;
  • chiavi SSH aggiunte;
  • file modificati dall'utente del web server.

Ricorda che mtime non è una prova forense assoluta: può essere alterato.

Per applicazioni versionate, il confronto migliore è contro un artefatto o repository conosciuto:

git status --short
git diff --name-status

Su WordPress puoi aggiungere anche:

wp core verify-checksums --include-root

Se vuoi approfondire il caso WordPress, ho già trattato separatamente wp2shell e l'analisi dei log: wp2shell e PHP2Shell sono vulnerabilità differenti e non vanno confuse.


6. Cerca connessioni di rete inattese

Controllo puntuale:

ss -plant

Se disponibile:

lsof -nP -i

Su un web server che normalmente accetta richieste HTTP e parla con database/cache noti, connessioni outbound verso host insoliti meritano verifica.

Non limitarti però agli IOC pubblicati: Amazon ha precisato che gli IP osservati appartenevano anche a infrastrutture di anonimizzazione condivise. Sono un punto di investigazione, non una blacklist affidabile.


Quando il problema diventa incident response

Se trovi una combinazione credibile di:

  • richieste sospette;
  • crash o anomalie PHP;
  • processi figli non previsti;
  • file modificati;
  • connessioni outbound sconosciute;
  • credenziali o chiavi esposte;
  • webshell o persistenza;

non considererei più l'attività un semplice patching.

La sequenza diventa:

  1. isola il nodo dal traffico;
  2. preserva le evidenze;
  3. acquisisci log e timeline;
  4. identifica l'account e i privilegi del processo compromesso;
  5. ruota credenziali, token, password database e secret accessibili dal processo PHP;
  6. verifica lateral movement;
  7. ricostruisci da immagine o baseline affidabile quando necessario;
  8. ripristina solo dati e configurazioni verificati;
  9. rimetti il servizio online dietro WAF e monitoraggio rafforzato.

Aggiornare PHP su una macchina già compromessa non rimuove automaticamente l'attaccante.


Stage 9 — Rollout a lotti

Su una flotta di server non aggiornerei tutto contemporaneamente, a meno che l'esposizione non renda il rischio di attesa maggiore del rischio operativo.

Un rollout ragionevole:

WAF / protezione edge
        ↓
1 canary
        ↓
package check
        ↓
restart worker
        ↓
health + smoke + error rate
        ↓
10-20% della flotta
        ↓
osservazione
        ↓
50%
        ↓
100%
        ↓
hunting + monitoraggio

Per ogni batch salva almeno:

  • host;
  • distro;
  • package version prima/dopo;
  • SAPI;
  • orario patch;
  • orario restart;
  • esito health check;
  • esito log gate;
  • eventuali anomalie.

In questo modo hai un audit trail utilizzabile anche dopo l'emergenza.


Il rollback non deve riportarti a PHP vulnerabile

Questo è un punto che inserirei direttamente nel runbook.

Se dopo la patch l'applicazione presenta incompatibilità:

non riportare il nodo vulnerabile nel load balancer soltanto per ripristinare il servizio.

Le alternative sono:

  • togliere il nodo dal pool;
  • correggere l'applicazione;
  • ripristinare una configurazione applicativa compatibile mantenendo PHP patchato;
  • spostare temporaneamente il traffico su nodi già sanati;
  • usare un ambiente isolato per riprodurre il problema.

Il rollback a un runtime vulnerabile può trasformare un problema di compatibilità in un incidente di sicurezza.


Pipeline riassuntiva GO / NO-GO

StageGate
Inventarioruntime web, SAPI e pacchetto identificati
Evidenzelog principali preservati
WAFmanaged rules/mitigazioni attive dove disponibili
Packageversione conforme all'advisory del vendor
Restartnessun vecchio worker vulnerabile attivo
Runtime websito realmente servito dal PHP corretto
Smoke testfunzioni critiche operative
Error gatenessun crash/restart storm anomalo
Rolloutcanary verde prima del batch successivo
Huntingfinestra almeno dal 17 ottobre analizzata
IRhost isolato se emergono indicatori credibili

WAF: cosa terrei anche dopo la patch

Dopo aver sanato PHP non disattiverei automaticamente tutte le protezioni.

Terrei almeno:

  • managed rules del provider;
  • rate limiting sugli endpoint sensibili;
  • limiti ragionevoli agli upload;
  • alert sui picchi di 5xx;
  • logging WAF centralizzato;
  • alert su pattern di exploit noti;
  • protezione specifica delle route di amministrazione.

Il WAF non è soltanto una toppa temporanea: è un livello della strategia defense in depth. La differenza è che, dopo la patch, non gli stai più chiedendo di compensare un runtime vulnerabile.


FAQ

PHP 8.5.11 è vulnerabile?

Sì, se parli della release upstream PHP 8.5.11. La correzione è nella 8.5.12.

Sulle distribuzioni Linux devi però verificare il pacchetto del vendor: una versione apparentemente più vecchia può contenere un backport ufficiale della patch.

PHP-FPM è al sicuro perché il PoC più semplice riguarda mod_php?

No. PHP-FPM è interessato e deve essere aggiornato. Alcuni percorsi sono più difficili da sfruttare rispetto a mod_php, ma non è una mitigazione sufficiente.

Aggiornare WordPress, Drupal o Joomla corregge PHP2Shell?

No. La vulnerabilità è nel runtime PHP. Aggiornare CMS e plugin è buona pratica, ma non sostituisce l'aggiornamento dell'interprete.

Cloudflare o un altro WAF mi rende sicuro senza patch?

No. Le protezioni WAF riducono la superficie e possono bloccare attacchi noti, ma il progetto PHP considera l'aggiornamento l'unica remediation completa.

PHP 8.1 è sempre vulnerabile?

Upstream PHP 8.1 è EOL e non ha ricevuto una nuova release ufficiale. Tuttavia alcuni vendor hanno applicato backport: Ubuntu 22.04, per esempio, ha corretto il proprio PHP 8.1 con il pacchetto 8.1.2-1ubuntu2.28. Devi quindi verificare l'advisory della distribuzione.

Dopo la patch devo comunque controllare i log?

Sì. Il primo tentativo osservato da Amazon risale al 17 ottobre, prima della disponibilità pubblica delle patch. La patch impedisce nuovi sfruttamenti della vulnerabilità, ma non esclude che il server sia stato compromesso in precedenza.


Fonti e approfondimenti

Fonti ufficiali

Distribuzioni Linux

Ricerca, threat intelligence e WAF


Se devi gestire molti server PHP

Su una singola macchina l'aggiornamento è relativamente semplice. Il problema cambia quando devi sanare decine o centinaia di virtual host, più versioni PHP, pool FPM diversi, CMS legacy e server che non possono essere riavviati tutti insieme.

In questi casi posso aiutarti con inventario della superficie PHP, pipeline di patching, analisi dei log, configurazione WAF, hardening e incident response, costruendo un rollout con canary e gate verificabili invece di aggiornare i server alla cieca.

Contattami se vuoi fare un assessment dell'infrastruttura o verificare se ci sono indicatori di compromissione dopo PHP2Shell.