Worum es geht
Ein Docker-Image kapselt eine bestimmte PHP-Version zum Zeitpunkt des Builds. Wird das Image nicht neu gebaut, bleibt die Version eingefroren, auch wenn die Upstream-Maintainer längst einen Sicherheitspatch veröffentlicht haben. Das betrifft nicht nur offizielle Images, sondern auch selbst gebaute Dockerfiles, die eine PHP-Version per Paketmanager fixieren.
Die Herausforderung ist technisch simpel: Man muss pro Container die laufende PHP-Version auslesen und gegen eine Referenzliste bekannter Patch-Level prüfen. Organisatorisch ist das schwieriger, weil die Anzahl der Container mit der Zeit wächst und manuelle Checks dann nicht mehr skalieren. Genau hier hilft die Automatisierung: ein Collector, der regelmäßig alle Container abfragt, ein Speicher für den Verlauf und eine Benachrichtigung bei Abweichungen.
Anforderungen
Bevor du ein Audit-Script in eine Pipeline integrierst, lohnt sich ein Blick auf die Anforderungen. Erstens: Der Collector muss Zugriff auf die Docker-Engine haben, entweder über den Unix-Socket oder über die Docker-API. Zweitens: Du brauchst eine Referenzliste mit aktuellen Patch-Versionen pro PHP-Minor-Release, die du selbst pflegst oder aus einer vertrauenswürdigen Quelle bezieht.
Drittens solltest du den Zustand über die Zeit speichern, nicht nur den aktuellen Snapshot. Ohne Historie lässt sich nicht nachvollziehen, seit wann ein Container verwundbar ist oder ob ein Update tatsächlich gegriffen hat. Eine einfache SQLite-Datenbank reicht dafür vollkommen aus und vermeidet den Betriebsaufwand eines externen Datenbankservers.
Viertens brauchst du eine Klassifikationslogik, die entscheidet, ob eine gefundene Version als sicher oder verwundbar einzustufen ist. Das kann ein einfacher Versionsvergleich sein oder, bei komplexeren Fällen, ein Abgleich gegen eine CVE-Liste über ein lokales Modell. Fünftens: eine Benachrichtigung, die nur bei tatsächlicher Veränderung des Zustands anschlägt, nicht bei jedem Lauf erneut.
Möglichkeiten im Vergleich
Es gibt grundsätzlich drei Wege, PHP-Versionen in Containern zu prüfen. Der erste Weg ist ein manuelles Script, das du bei Bedarf startest, wie im Ausgangsfall beschrieben. Das funktioniert für eine einmalige Bestandsaufnahme gut, liefert aber keine Kontinuität. Sobald ein neuer Container hinzukommt oder ein Image aktualisiert wird, musst du dich aktiv erinnern, erneut zu prüfen.
Der zweite Weg ist ein Cronjob oder systemd-Timer, der das Script periodisch ausführt und das Ergebnis in eine Datei schreibt. Das ist bereits deutlich robuster, bleibt aber reaktiv: Jemand muss die Logdatei lesen, um eine Verschlechterung zu bemerken. Bei fünf Containern ist das noch machbar, bei zwanzig oder mehr wird es mühsam.
Der dritte Weg integriert die Prüfung in eine bestehende Watch-and-Alert-Pipeline mit Collector, Speicher, Klassifikation und Benachrichtigung. Dieser Ansatz erfordert initial mehr Aufwand, zahlt sich aber aus, sobald mehrere Prüfungen (PHP-Version, aber auch andere Container-Metadaten) über denselben Mechanismus laufen. Die Entscheidung hängt von der Anzahl der zu überwachenden Container und der gewünschten Reaktionsgeschwindigkeit ab.
Umsetzung
Die folgende Referenzarchitektur nutzt einen Collector, der die Docker-Engine über den lokalen Socket abfragt, die Ergebnisse in SQLite ablegt, eine einfache Versionsklassifikation durchführt und bei Abweichungen eine Benachrichtigung auslöst. Der Collector läuft über einen täglichen systemd-Timer oder Cronjob.
"""Collector: prüft PHP-Versionen in laufenden Docker-Containern."""
from __future__ import annotations
import logging
import sqlite3
import subprocess
from dataclasses import dataclass
from pathlib import Path
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("php_audit")
DB_PATH = Path("php_audit.db")
# Beispielhafte Referenzliste gepatchter Minor-Versionen.
# Diese Liste muss regelmäßig von Hand aktualisiert werden.
PATCHED_VERSIONS: dict[str, str] = {
"8.4": "8.4.17",
"8.3": "8.3.32",
"8.2": "8.2.26",
}
@dataclass
class ContainerResult:
name: str
php_version: str | None
vulnerable: bool
def init_db(db_path: Path) -> sqlite3.Connection:
conn = sqlite3.connect(db_path)
conn.execute(
"""
CREATE TABLE IF NOT EXISTS audit_log (
id INTEGER PRIMARY KEY AUTOINCREMENT,
container_name TEXT NOT NULL,
php_version TEXT,
vulnerable INTEGER NOT NULL,
checked_at TEXT DEFAULT CURRENT_TIMESTAMP
)
"""
)
conn.commit()
return conn
def list_running_containers() -> list[str]:
result = subprocess.run(
["docker", "ps", "--format", "{{.Names}}"],
capture_output=True,
text=True,
check=True,
)
return [line.strip() for line in result.stdout.splitlines() if line.strip()]
def get_php_version(container: str) -> str | None:
try:
result = subprocess.run(
["docker", "exec", container, "php", "-r", "echo PHP_VERSION;"],
capture_output=True,
text=True,
timeout=10,
check=True,
)
version = result.stdout.strip()
return version or None
except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
logger.debug("Kein PHP in Container %s gefunden", container)
return None
def is_vulnerable(version: str) -> bool:
major_minor = ".".join(version.split(".")[:2])
patched = PATCHED_VERSIONS.get(major_minor)
if patched is None:
# Unbekannte Minor-Version: vorsichtig als unklar behandeln.
logger.warning("Keine Referenz für PHP %s hinterlegt", major_minor)
return False
return _version_tuple(version) < _version_tuple(patched)
def _version_tuple(version: str) -> tuple[int, ...]:
return tuple(int(part) for part in version.split("."))
def audit_containers() -> list[ContainerResult]:
results: list[ContainerResult] = []
for name in list_running_containers():
version = get_php_version(name)
if version is None:
continue
vulnerable = is_vulnerable(version)
results.append(ContainerResult(name, version, vulnerable))
return results
def store_results(conn: sqlite3.Connection, results: list[ContainerResult]) -> None:
for r in results:
conn.execute(
"INSERT INTO audit_log (container_name, php_version, vulnerable) "
"VALUES (?, ?, ?)",
(r.name, r.php_version, int(r.vulnerable)),
)
conn.commit()
def notify_if_vulnerable(results: list[ContainerResult]) -> None:
vulnerable = [r for r in results if r.vulnerable]
if not vulnerable:
logger.info("Keine verwundbaren Container gefunden.")
return
lines = [
f"{r.name}: PHP {r.php_version} veraltet" for r in vulnerable
]
message = "PHP-Audit meldet veraltete Versionen:\n" + "\n".join(lines)
logger.warning(message)
# An dieser Stelle würdest du ntfy, Telegram oder E-Mail aufrufen.
# Beispiel: send_ntfy(message) oder send_telegram(message)
def main() -> None:
conn = None
try:
conn = init_db(DB_PATH)
results = audit_containers()
store_results(conn, results)
notify_if_vulnerable(results)
except Exception:
logger.exception("Audit-Lauf fehlgeschlagen")
finally:
if conn is not None:
conn.close()
if __name__ == "__main__":
main()
Dieser Collector trennt klar zwischen Datensammlung, Speicherung und Benachrichtigung. Für die Klassifikation reicht hier ein einfacher Versionsvergleich. Bei komplexeren Fragestellungen, etwa wenn du zusätzlich prüfen willst, ob ein bestimmtes PHP-Modul aktiv ist, lohnt sich ein Zwischenschritt über ein lokales Modell via Ollama, das den Kontext (Modulliste, Konfiguration) interpretiert, bevor die Benachrichtigung ausgelöst wird.
Der systemd-Timer für den täglichen Lauf sieht in der Praxis wie folgt aus: Eine Service-Unit startet das Python-Script, eine Timer-Unit löst es einmal pro Tag aus. Das ist robuster als ein klassischer Cronjob, weil systemd Fehlschläge protokolliert und bei Bedarf Wiederholungen konfigurierbar macht.
Typische Fallstricke
Der größte Fallstrick ist eine veraltete Referenzliste. Wenn PATCHED_VERSIONS nicht gepflegt wird, meldet das Script nach einiger Zeit falsche Sicherheit, weil neue Patches nicht erfasst sind. Diese Liste gehört in eine eigene Konfigurationsdatei, die getrennt vom Code aktualisiert wird, idealerweise mit einem Datum der letzten Prüfung.
Ein weiterer Fallstrick ist der direkte Aufruf von docker exec ohne Timeout. Hängt ein Container in einem fehlerhaften Zustand, blockiert das gesamte Audit, bis ein manueller Eingriff erfolgt. Der Timeout-Parameter in subprocess.run ist deshalb keine Kosmetik, sondern notwendig für den stabilen Betrieb der Pipeline.
Container ohne PHP-Binary im Pfad liefern einen Fehler statt einer Version. Das Script muss diesen Fall explizit abfangen, sonst bricht der gesamte Lauf wegen eines einzelnen nicht-PHP-Containers ab. Die Catch-Klausel für CalledProcessError und TimeoutExpired deckt das ab, sollte aber nicht zu einem stillschweigenden Verschlucken aller Fehler ausgeweitet werden.
Schließlich: Die Benachrichtigung sollte nicht bei jedem Lauf erneut feuern, wenn sich der Zustand nicht geändert hat. Ohne einen Vergleich mit dem letzten gespeicherten Zustand ermüdet die tägliche Meldung schnell, und echte neue Vorfälle gehen in der Masse der Wiederholungen unter.
Wann sich das lohnt (und wann nicht)
Eine automatisierte Prüfung lohnt sich, sobald du mehr als eine Handvoll Container mit PHP-Anwendungen betreibst und diese nicht alle über denselben Update-Mechanismus laufen. Sobald Images aus unterschiedlichen Quellen stammen, Community-Images, selbst gebaute Dockerfiles oder ältere Snapshots, steigt das Risiko, dass eine Version unbemerkt veraltet.
Für ein einzelnes Setup mit wenigen, zentral verwalteten Containern, die über ein einheitliches Deployment-System regelmäßig neu gebaut werden, ist der Aufwand einer eigenen Pipeline möglicherweise nicht gerechtfertigt. Hier reicht häufig schon ein automatisiertes Image-Rebuild mit aktueller Base-Image-Version.
Der Aufwand für Collector, SQLite-Speicher und Benachrichtigung zahlt sich vor allem aus, wenn du diese Infrastruktur bereits für andere Zwecke nutzt, etwa für das Monitoring von Zertifikaten oder Diensten. Die PHP-Versionsprüfung wird dann zu einem weiteren Collector-Modul in einer bestehenden Pipeline, statt ein isoliertes Script zu bleiben, das irgendwann in Vergessenheit gerät.