CVE-2026-129496 habe ich nicht gefunden, weil ich danach gesucht hätte. Nach PHP2Shell habe ich aufgeschrieben, was dessen zwei Fehler gemeinsam haben, und zwar als Regel, die ein Programm prüfen kann: Ist eine Anfrage vorbei, darf nichts, was sie überlebt, noch in ihren Speicher zeigen. Zwei Wochen nach dem PHP2Shell-Release stürzte ein Lauf, der einen mir schon bekannten Fehler bestätigen sollte, an der falschen Stelle ab, und die Prüfung dieser Regel nannte die verantwortliche Variable beim Namen.
Die Sicherheitslücke ist ein Use after free (CWE-416) Bug im Zeitzonen-Cache der Date-Extension von PHP. Sie ist mit 9,2 von 10 bewertet und kann zu Remote Code Execution führen. PHP 8.2.36, 8.3.37, 8.4.28 und 8.5.13 beheben sie und sind heute erschienen. Wenn du PHP betreibst, aktualisiere.
PHP2Shell war eine Klasse von Fehlern, und eine Klasse lässt sich als Regel aufschreiben
Am 21. Oktober 2026 hat das PHP-Projekt zwei kritische Sicherheitslücken behoben, die unter dem Namen PHP2Shell bekannt wurden:
- Bei CVE-2026-109618 geht es um das, was zurückbleibt, wenn der Speicher ausgeht: PHP verlässt die Anfrage mit einem
longjmp(), und der Code, der die Anfrage später aufräumt, liest, was in diesem Moment halb aufgebaut war. - Bei CVE-2026-109619 geht es um globale Variablen der Engine und ihrer Extensions, die nach dem Ende einer Anfrage noch in deren Speicher zeigen, und um Code, der sie benutzt, bevor die nächste Anfrage sie neu initialisiert hat.
Nach diesem Release wollte ich wissen, ob sich diese Klasse von Fehlern systematisch finden lässt statt Fall für Fall. Das zweite Advisory beschreibt eine Eigenschaft, die jeder korrekte Build von PHP hat und deren Prüfung kein Wissen darüber voraussetzt, wo ein Fehler steckt: Am Ende einer Anfrage darf kein Wort in dem Speicher, der die Anfrage überlebt, eine Adresse im Heap der Anfrage enthalten, den PHP gerade freigegeben hat.
Eine solche Regel ist ein Test Oracle. Sie kommt ohne erwartete Ausgabe für eine bestimmte Eingabe aus. Sie braucht einen Zeitpunkt, zu dem sie gelten muss, und den hat PHP nach jeder Anfrage.
Die Werkzeuge von php-src konnten diese Klasse nicht sehen
php-src hat mehr als 20.000 Testdateien, einen Fuzzing Harness und CI-Jobs, die die Tests unter dem AddressSanitizer (ASan) ausführen. Bevor ich etwas gebaut habe, habe ich vier Annahmen darüber aufgeschrieben, warum nichts davon einen Fehler dieser Klasse gemeldet hatte. Die Läufe, die ich unten beschreibe, haben jede von ihnen bestätigt.
| Was die Werkzeuge tun | Was dadurch verborgen bleibt |
|---|---|
| Der Fuzzing Harness führt pro Eingabe eine Anfrage aus, nimmt keinen Zustand in eine zweite Anfrage mit und beendet den Durchlauf, wenn der Speicher ausgeht. | Ein hängender Zeiger richtet nichts an, solange ihm nichts folgt, und dafür braucht es eine zweite Anfrage im selben Prozess. Ohne Folgeanfragen haben meine Läufe keinen einzigen Fall des zweiten Advisorys gefunden. |
| Die ASan-Jobs in der CI verwenden Debug Builds, einer davon ist threadsicher. | Ein Debug Build nimmt nie den Fast Shutdown, den die Produktion nimmt, und ein threadsicherer Build hält seine globalen Variablen an anderer Stelle. Auf einem Debug Build trat der stärkste Fall des zweiten Advisorys nicht auf. |
| Die Speicherverwaltung von PHP prüft das Speicherlimit nur, wenn sie einen neuen Chunk oder einen besonders großen Block braucht. | Ein Fuzzer, der sich von Code Coverage leiten lässt, bringt den Speicher selten bei einer ganz bestimmten Allokation zum Ausgehen. Jeder Fall in meinen Läufen kam dadurch zustande, dass die scheiternde Allokation ausdrücklich gewählt wurde. |
| Der Allokator, der unter ASan verwendet wird, gibt nicht frei, was am Ende einer sauberen Anfrage übrig ist. | Einen Zeiger in Speicher, der nie freigegeben wurde, kann ASan nicht melden. Sobald am Ende der Anfrage alles freigegeben wird, wie es die Speicherverwaltung von PHP in Produktion tut, werden die hängenden Zeiger sichtbar. |
Alle vier sind Unterschiede zwischen dem Prozess im Test und dem Prozess in Produktion. Darauf komme ich zurück, denn mein eigener Aufbau hatte, wie sich zeigte, einen fünften.
Jede Allokation scheitern lassen und dann nachsehen, was die Anfrage hinterlassen hat
Das erste, was ich gebaut habe, lässt eine gewählte Allokation so scheitern, wie es das Speicherlimit von PHP täte, und zwar an jeder Stelle zwischen dem Ende einer Anfrage und dem Ende der nächsten. Dazu gehören die Phasen, in denen kein Skript läuft: die INI-Einstellungen pro Verzeichnis, die ein Webserver anwendet, der Start der Anfrage und ihr Ende. Danach gehen weitere Anfragen an denselben Prozess.
Das zweite ist eine PHP-Extension, die die Regel prüft. Kurz bevor PHP den Heap einer Anfrage freigibt, hält die Extension Adresse und Größe jeder Allokation fest, die noch lebt. Nach der Freigabe liest sie jedes 8-Byte-Wort in den beschreibbaren Datensegmenten von PHP und seinen Extensions und meldet jedes Wort, das eine Adresse innerhalb einer dieser Allokationen enthält. Die Debug-Informationen des Binaries machen aus einem solchen Wort einen Namen, zum Beispiel executor_globals.last_fatal_error_backtrace. Einmal gibt PHP auch vor der ersten Anfrage einen Heap frei, nämlich am Ende von php_module_startup(), und auch dort prüft die Extension.
Eine solche Meldung besagt, dass eine globale Variable in freigegebenen Speicher zeigt. Ob diesem Zeiger jemals etwas folgt, ist eine andere Frage. Um sie zu beantworten, kann die Extension jedes hängende Wort mit der Adresse einer Speicherseite überschreiben, auf die nicht zugegriffen werden darf, eine Seite pro Wort. Folgt die nächste Anfrage dem Zeiger, endet der Prozess mit einem Speicherzugriffsfehler, und die Adresse des Fehlers verrät, welche Variable es war.
An den bekannten Fehlern trennte die Regel den verwundbaren vom behobenen Stand
Bevor ich einer Prüfung zutraue, etwas Unbekanntes zu finden, will ich sehen, dass sie etwas Bekanntes findet. Beide Techniken liefen deshalb gegen PHP 8.5.11 und 8.4.26, die die beiden Sicherheitslücken enthalten, und gegen 8.5.12 und 8.4.27, die sie nicht mehr enthalten. Die Werkzeuge waren vor den Läufen eingefroren, und die Commits, die die Lücken beheben, wurden erst gelesen, nachdem der letzte Lauf beendet war. Der Entwurf kannte allerdings, was die beiden Advisories beschreiben. Das Ergebnis zeigt also, dass die Techniken diese Fehler finden können, und es zeigt nicht, dass ich sie ohne dieses Wissen so entworfen hätte.
Die Prüfung am Ende jeder Anfrage lief über die Testsuite von php-src, auf dem 8.5-Branch waren das 16.403 Tests. Vierzehn Zeiger hingen im selben Test auf dem verwundbaren Build und auf dem behobenen nicht, und jeder von ihnen ist eine Variable, die der Fix zurücksetzt. Auf dem 8.4-Branch waren es zwölf von zwölf.
Die gezielt scheiternden Allokationen fanden beide Sicherheitslücken auf beiden Branches. Auf 8.5.11 brauchten 93.120 Fälle mit einem Fehlschlag vor oder während des Starts der Anfrage 155 CPU-Stunden auf einer Maschine mit sechs Kernen und führten zu 13 verschiedenen Funden. Dieselbe Kampagne auf 8.5.12 führte zu keinem. Jeder Fall hinter diesen Ergebnissen wurde anschließend in Apache mit mod_php oder in php-fpm wiederholt, auf dem verwundbaren und auf dem behobenen Build.
Der Fund war eine Bestätigung, die mit dem falschen Absturz scheiterte
Eine dieser Wiederholungen gehörte zu einem Fall des zweiten Advisorys, in dem der Upload-Fortschritt der Session-Extension einem hängenden Zeiger folgt. Erwartet hatte ich auf PHP 8.5.11 einen Absturz im Decoder der Session während der zweiten Anfrage und auf 8.5.12 keinen Absturz. In Apache stürzte der Prozess schon während der ersten Anfrage ab, bei der Suche nach einem Schlüssel in einer Hashtabelle, und auf 8.5.12 tat er das ebenfalls. Bis dahin war jeder wiederholte Fall auf dem behobenen Build sauber gewesen.
Ein Absturz, der den Fix für PHP2Shell übersteht, musste etwas anderes sein. Der Zugriffsfehler lag an der Adresse 0x703480000010. Die Extension hatte ihre gesperrten Seiten ab 0x703480000000 reserviert, der Prozess war also dem ersten hängenden Zeiger auf der Liste gefolgt und hatte 16 Bytes tief in etwas gelesen, das er für eine Hashtabelle hielt. Der erste Eintrag der Liste war date_globals.tzcache, festgehalten am Ende von php_module_startup(), vor jeder Anfrage. Es war die einzige globale Variable, die an dieser Stelle in den Heap zeigte, den PHP gerade freigegeben hatte.
Auf der Liste standen außerdem sechs Wörter aus dem Zustand des INI-Scanners, die in Speicher zeigten, der schon früher während des Starts freigegeben worden war. Ihnen ist in diesen Läufen nichts gefolgt.
Keine der Kampagnen hatte diesen Absturz gemeldet. Er trat erst bei der Wiederholung in Apache auf, und auf den wahrscheinlichen Grund komme ich weiter unten.
Eine Logzeile beim Start hinterlässt einen Zeiger, dem die erste Anfrage folgt
Der Rest des Stack Trace zeigte, woher die Suche in der Hashtabelle kam: PHP schrieb gerade eine Zeile in sein Fehlerprotokoll und brauchte für den Zeitstempel die Zeitzone. Wenn PHP in die Datei protokolliert, die error_log benennt, beginnt jede Zeile mit der lokalen Zeit, und php_log_err_with_severity() formatiert sie mit php_format_date(). Dieser Aufruf endet in php_date_parse_tzfile() der Date-Extension, die einmal gelesene Zeitzonendaten in einer Hashtabelle aufbewahrt:
static timelib_tzinfo *php_date_parse_tzfile(const char *formal_tzname, const timelib_tzdb *tzdb)
{
timelib_tzinfo *tzi;
int dummy_error_code;
if(!DATEG(tzcache)) {
ALLOC_HASHTABLE(DATEG(tzcache));
zend_hash_init(DATEG(tzcache), 4, NULL, _php_date_tzinfo_dtor, 0);
}
if ((tzi = zend_hash_str_find_ptr(DATEG(tzcache), formal_tzname, strlen(formal_tzname))) != NULL) {
return tzi;
}
tzi = timelib_parse_tzfile(formal_tzname, tzdb, &dummy_error_code);
if (tzi) {
zend_hash_str_add_ptr(DATEG(tzcache), formal_tzname, strlen(formal_tzname), tzi);
}
return tzi;
}
ALLOC_HASHTABLE() nimmt den Speicher für die Tabelle aus dem Heap der Anfrage, und DATEG(tzcache) ist eine globale Variable der Extension. Die Extension setzt sie auf NULL zurück, wenn eine Anfrage beginnt:
PHP_RINIT_FUNCTION(date)
{
if (DATEG(timezone)) {
efree(DATEG(timezone));
}
DATEG(timezone) = NULL;
DATEG(tzcache) = NULL;
DATEG(last_errors) = NULL;
return SUCCESS;
}
Das ist in Ordnung, solange der Cache nur entsteht, während eine Anfrage läuft. Eine Logzeile, die schon während php_module_startup() geschrieben wird, bricht diese Annahme. In der php.ini der Wiederholung stand session.use_only_cookies=0, wofür die Session-Extension beim Start von PHP eine Deprecation protokolliert. Der Zeitstempel dieser Zeile hat den Cache auf dem Heap angelegt, den PHP während des Starts verwendet, und php_module_startup() endet damit, diesen Heap freizugeben:
module_startup = false;
/* Don't leak errors from startup into the per-request phase. */
clear_last_error();
shutdown_memory_manager(1, 0);
DATEG(tzcache) setzt hier niemand zurück, ein Incomplete Cleanup (CWE-459). Von dieser Zeile an zeigt die Variable auf eine Hashtabelle, die es nicht mehr gibt. Das Zurücksetzen in PHP_RINIT_FUNCTION(date) würde das reparieren, kommt in der ersten Anfrage aber eine Zeile zu spät:
php_hash_environment();
zend_activate_modules();
PG(modules_activated)=1;
php_hash_environment() baut aus den Eingabedaten der Anfrage die superglobalen Variablen auf, und erst zend_activate_modules() ruft die RINIT-Funktionen der Extensions auf. Was PHP protokolliert, während es die Eingabedaten verarbeitet, formatiert seinen Zeitstempel mit einem Cache, der schon vor Beginn der Anfrage freigegeben wurde.
php_module_startup() gibt den Heap frei, auf dem er liegt (rot). Rechts, in der ersten Anfrage: Eine Logzeile während der Verarbeitung der Eingabedaten durchsucht den Cache über den hängenden Zeiger (rot), bevor die Date-Extension ihn zurücksetzt (blau).
In der Wiederholung kam die Logzeile der ersten Anfrage von der gezielt scheiternden Allokation. Eine gewöhnliche Anfrage kann sie ebenfalls auslösen: Bringt sie mehr Eingabevariablen mit, als max_input_vars erlaubt, protokolliert PHP an derselben Stelle eine Warnung. Damit waren die scheiternde Allokation und die Extension nicht mehr nötig. Ein unveränderter ASan-Build von PHP, ausgeführt so, wie ihn der Test Runner von php-src unter ASan ausführt, meldet den Fehler von selbst:
ERROR: AddressSanitizer: heap-use-after-free on address 0x6d3136dfe690
READ of size 8 at 0x6d3136dfe690 thread T0
#0 zend_hash_str_find_bucket Zend/zend_hash.c:942
#1 zend_hash_str_find Zend/zend_hash.c:2922
#2 zend_hash_str_find_ptr Zend/zend_hash.h:962
#3 php_date_parse_tzfile ext/date/php_date.c:507
#4 get_timezone_info ext/date/php_date.c:574
#5 php_format_date ext/date/php_date.c:891
#6 php_log_err_with_severity main/main.c:991
...
#12 php_default_treat_data main/php_variables.c:583
...
0x6d3136dfe690 is located 16 bytes inside of 56-byte region
freed by thread T0 here:
...
#2 zend_mm_shutdown Zend/zend_alloc.c:2580
#3 php_module_startup main/main.c:2512
...
previously allocated by thread T0 here:
...
#2 php_date_parse_tzfile ext/date/php_date.c:503
...
#11 OnUpdateUseOnlyCookies ext/session/session.c:883
...
#13 zm_startup_session ext/session/session.c:3008
Der Lesezugriff liegt 16 Bytes tief in der freigegebenen Tabelle, dieselben 16 Bytes wie in der Adresse des Absturzes in Apache. Ich habe das auf PHP 8.5.12, 8.5.11, 8.4.27 und 8.4.26 sowie auf dem PHP-8.6-Branch und auf master mit Stand vom 4. November reproduziert. Ein threadsicherer Build zeigte den Fehler nicht: Dort formatiert php_log_err_with_severity() den Zeitstempel während des Starts ohnehin in UTC, wofür keine Zeitzonendaten nötig sind.
Mein Bericht endete beim Use after free, und ich hatte nicht untersucht, was ein Angreifer damit anfangen kann. Das hat das Security-Team von PHP getan. Laut Advisory erben die Worker von php-fpm und von Apache mit mod_php den hängenden Zeiger von ihrem Elternprozess und behalten ihn, bis sie ihre erste normale Anfrage abgeschlossen haben, und das gilt auch für jeden Worker, der später gestartet wird. Eine präparierte HTTP-Anfrage bringt einen frischen Worker von php-fpm mit dem Standardwert von max_input_vars zum Absturz. Der freigegebene Speicher kann zu diesem Zeitpunkt schon Daten aus der Anfrage enthalten, und das Team hat in php-fpm und in mod_php gezeigt, dass sich Befehle ausführen lassen: lokal, mit bekannten Speicheradressen und unter weiteren Bedingungen, die das Advisory aufführt.
Mein Harness hatte denselben blinden Fleck wie die Werkzeuge von php-src
Die Kampagnen liefen nicht in Apache. Um Zehntausende Fälle zu schaffen, führten sie ein kleines Programm von mir aus, das gegen PHP gelinkt ist und die Schritte einer Anfrage in der Reihenfolge durchläuft, in der mod_php oder php-fpm es täten. Dieser Harness startet PHP einmal, forkt für jeden Fall einen Kindprozess und setzt error_log erst im Kindprozess. Während der Elternprozess php_module_startup() durchläuft, ist keine Logdatei konfiguriert. Die Deprecation geht ohne Zeitstempel auf die Standardfehlerausgabe, und niemand fragt nach der Zeitzone. In den Wiederholungen bekamen Apache und php-fpm error_log aus der php.ini, die Einstellung galt also schon, während PHP startete.
Das ist der wahrscheinliche Grund dafür, dass die Kampagnen nichts gemeldet haben, und geprüft habe ich ihn nicht. Bei einem Fund, der noch nicht offengelegt ist, stelle ich jede Arbeit ein, die der Bericht nicht braucht.
Weiter oben habe ich vier Unterschiede zwischen dem Prozess im Test von php-src und dem Prozess in Produktion aufgezählt. Der Zeitpunkt, zu dem mein Harness eine einzige INI-Einstellung anwendet, war ein fünfter, in meinen eigenen Werkzeugen, und wenn meine Erklärung stimmt, hat er eine mit 9,2 bewertete Sicherheitslücke aus jeder Kampagne herausgehalten. Die Wiederholung in den echten Servern hatte ich als Bestätigung von Ergebnissen geplant, die ich schon hatte. Bei diesem Fehler war sie der einzige Schritt, der ein Ergebnis liefern konnte.
Aktualisiere, und räume bis dahin auf, was PHP beim Start meldet
PHP 8.2.36, 8.3.37, 8.4.28 und 8.5.13 enthalten den Fix. Außerhalb einer vollständig initialisierten Anfrage formatiert PHP die Zeitstempel seines Fehlerprotokolls jetzt in UTC und fasst den Zeitzonen-Cache nicht an.
Laut Advisory lässt sich der Fehler auslösen, wenn drei Dinge zusammenkommen: PHP protokolliert beim Start eine geeignete Meldung, PHP schreibt sein Fehlerprotokoll in eine Datei, und ein frischer Worker protokolliert früh in einer Anfrage eine Meldung. Das erste wird leicht übersehen. Als Beispiele bestätigt das Advisory einen ungültigen Wert für date.timezone sowie eine Warnung oder Deprecation, die von der Konfiguration der Sessions herrührt, und PHP kennzeichnet solche Meldungen im Protokoll mit PHP Startup. Das Fehlerprotokoll von php-fpm selbst zählt nicht, nur die Datei, die die Einstellung error_log von PHP benennt.
Wenn du heute nicht aktualisieren kannst, nennt das Advisory zwei Übergangsmaßnahmen. Korrigiere die Konfigurationsfehler und veralteten Einstellungen, die PHP beim Start meldet, und starte danach den Master-Prozess und alle Worker neu. Oder schicke die Fehler von PHP an syslog, denn dieser Weg führt nicht durch den Code, der den Zeitstempel formatiert. Den Umgang mit $_REQUEST oder mit Cookies zu ändern, wie es die Bedingungen eines der gezeigten Exploits nahelegen könnten, ist keine vollständige Gegenmaßnahme.
Wer einen Fehler findet, schuldet dem Projekt die Methode
Am 4. November habe ich dem Security-Team von PHP zwei E-Mails geschickt. Die erste enthielt den Bericht über das Experiment zu PHP2Shell und den Quelltext von allem, was ich hier beschrieben habe, verbunden mit der Frage, ob sich etwas davon lohnt, für die CI von php-src nutzbar gemacht zu werden. Die zweite meldete den Use after free und hielt fest, dass er mit dem Ansatz aus der ersten gefunden wurde. Ich halte das für die richtige Reihenfolge.
In einem Interview im Oktober habe ich gesagt, dass das Finden von Sicherheitslücken billiger wird, während die Menschen, die sie bewerten und beheben, der Engpass bleiben. Mit diesem Fund stehe ich auf der billigen Seite dieses Satzes. Der Bericht kam von mir, und die Bewertung der Auswirkungen, der Fix und das koordinierte Release von vier Versionen fielen dem Security-Team zu, zwei Wochen nachdem es den Fix für PHP2Shell ausgeliefert hatte. Wer einen Fehler einer Klasse findet, schuldet einem solchen Projekt die Mittel, mit denen sich die anderen finden lassen, und nicht nur den einen Fall.
Ob das Projekt diese Mittel annehmen kann, ist eine andere Frage, und sie ist offen. Was ich gebaut habe, ist ein Prototyp, in dessen Skripten Pfade meiner Maschine stehen. Ihn ernsthaft zu betreiben, bedeutet einen weiteren CI-Job mit einem Release Build unter ASan, CPU-Zeit in der Größenordnung, die ich oben für eine einzige Version genannt habe, und jemanden, der liest, was er meldet, und ihn am Laufen hält, während sich die Engine ändert. Dieser Jemand käme aus derselben kleinen Gruppe, die diese Sicherheitslücke behoben hat. Ich bespreche mit dem PHP-Team noch, wie aus dem Prototyp etwas werden kann, das es nutzen kann.
Fuzzing ist ein Thema, mit dem ich mich gerade beschäftige und zu dem ich forsche. Dabei ist rattle entstanden, ein Fuzzer für PHP-Code, und mit ihm habe ich GHSA-hwfg-qwvh-2wfx in Symfony entdeckt. Das ist aber eine Geschichte für ein anderes Mal.