Web & Entwicklung

Wie man unautorisierte Dateänderungen auf Ihrer Website mit PHP erkennt

How to Detect Unauthorized File Changes on Your Website with PHP

Erfahren Sie, wie Sie unerwartete Änderungen an den PHP-Dateien Ihrer Website mithilfe eines leichtgewichtigen Dateiintegritätsmonitors erkennen können. Erstellen Sie einen praktischen PHP-Scanner, vergleichen Sie vertrauenswürdige Schnappschüsse und identifizieren Sie geänderte, hinzugefügte oder gelöschte Dateien ohne Composer.

Wie man nicht autorisierte Dateiänderungen auf Ihrer Website mit PHP erkennt

Stellen Sie sich vor, Sie öffnen eines Morgens Ihre Website und stellen fest, dass sich etwas geändert hat. Eine Seite leitet Besucher um, eine PHP-Datei enthält unbekannten Code oder ein Plugin verhält sich anders, obwohl kein Update geplant war.

Welche Dateien wurden geändert? Die manuelle Überprüfung von hunderten Dateien ist unrealistisch. Die Dateiintegritätsüberwachung (FIM) vergleicht das aktuelle Dateisystem mit einem vertrauenswürdigen Snapshot. Dieses Tutorial baut einen kleinen PHP-Scanner für individuelle Websites, Erweiterungen und Shared Hosting, ohne Composer oder Datenbank.

1. Was ist Dateiintegritätsüberwachung?

Ein Monitor speichert Pfade und kryptographische Hashes ausgewählter Dateien und prüft sie erneut. Er meldet HINZUGEFÜGT, GEÄNDERT und GELÖSCHTE Dateien. Diese Unterscheidungen sind Anhaltspunkte für Untersuchungen, kein Beweis für einen Angriff: auch normale Deployments ändern Dateien.

Zum Beispiel:

website/
├── index.php
├── includes/
│   ├── bootstrap.php
│   └── database.php
└── plugins/
    └── payment/gateway.php

Ein späterer Scan könnte melden:

MODIFIED  includes/bootstrap.php
ADDED     plugins/payment/debug-shell.php
DELETED   includes/database.php

Die entscheidende Voraussetzung ist ein vertrauenswürdiger Ausgangswert. Wenn eine Website bereits vor dem initialen Snapshot kompromittiert war, könnten schädliche Dateien bereits als normal registriert sein.

2. Einen Scanner bauen oder ein bestehendes Tool nutzen?

Bevor Sie programmieren, prüfen Sie Ihre Plattform. Bei WordPress überprüft WP-CLI die Core-Dateien gegen offizielle Checksummen:

wp core verify-checksums
wp plugin verify-checksums --all

Das Plugin-Command deckt hauptsächlich Plugins ab, die im WordPress.org-Repository gehostet werden; individuelle und kommerzielle Plugins benötigen einen anderen Referenzpunkt. Bei Joomla bieten etablierte Erweiterungen wie Akeeba Admin Tools Dateiänderungsüberwachung. Git-verwaltete Anwendungen können auch deployierte Artefakte mit einem genehmigten Release vergleichen.

Situation Ausgangspunkt
WordPress Core und Repository-Plugins WP-CLI Checksummen-Verifizierung
Joomla mit anhaltenden Sicherheitsbedürfnissen Etablierte Sicherheitserweiterung
Individuelle PHP-Website oder individuelle Erweiterungen Kleiner PHP-Integritätsscan
Mehrere Server mit zentralisierten Warnungen Dediziertes Überwachungsplattform
Versionenkontrolliertes Deployment Vertrauenswürdiges Build- oder Release-Artefakt

Ein individuelles Skript ist wertvoll, wenn Sie eine fokussierte Prüfung für eigenen Code benötigen und dessen Baseline und Warnungen pflegen können.

3. Warum SHA-256?

PHP stellt hash_file():

$hash = hash_file('sha256', '/path/to/file.php');

Das Ergebnis ist ein 64-Zeichen-hexadezimaler Digest der Dateiinhalte. Eine geänderte Datei wird fast sicher einen anderen Digest liefern. Wir können daher eine kompakte Zuordnung relativer Pfade zu SHA-256-Werten speichern, anstatt jede Datei zu duplizieren.

Ein übereinstimmender Digest beweist Konsistenz mit dem Referenzwert, nicht dass der Referenzwert oder die Datei vertrauenswürdig sind. Legen Sie den initialen Snapshot von einem known-good Deployment an, preferably geprüft gegen Quellkontrolle oder ein genehmigtes Release-Paket.

4. Einen leichten PHP-Dateiintegritätsscan bauen

Erstellen Sie integrity-check.php außerhalb des öffentlichen Webverzeichnisses, neben einem geschützten JSON-Baseline:

/home/account/
├── private/
│   ├── integrity-check.php
│   └── integrity-baseline.json
└── public_html/
    ├── index.php
    ├── includes/
    └── plugins/

Das Skript hat zwei Befehle: baseline erstellt den initialen Snapshot und scan vergleicht es. Es meldet Unterscheidungen, ohne Website-Dateien zu löschen oder zu ersetzen. Diese Version erzeugt auch den formatierten Log und cron-freundlichen Ausgabe, wie in Abschnitt 7 beschrieben.

Komplettes PHP-Skript (PHP 7.4+)

<?php
declare(strict_types=1);

/**
 * Lightweight file integrity scanner.
 * Run from PHP CLI, outside the public web directory.
 */
$siteRoot = '/home/account/public_html';
$baselinePath = '/home/account/private/integrity-baseline.json';

$extensions = ['php', 'js', 'css'];
$excludedDirectories = [
    'cache',
    'tmp',
    'logs',
    'node_modules',
    'vendor',
];

function collectFiles(
    string $siteRoot,
    array $extensions,
    array $excludedDirectories
): array {
    $files = [];
    $directory = new RecursiveDirectoryIterator(
        $siteRoot,
        FilesystemIterator::SKIP_DOTS
    );
    $filter = new RecursiveCallbackFilterIterator(
        $directory,
        static function ($item) use ($excludedDirectories): bool {
            if ($item->isLink()) {
                return false;
            }
            if ($item->isDir()) {
                return !in_array(
                    $item->getFilename(),
                    $excludedDirectories,
                    true
                );
            }
            return $item->isFile();
        }
    );
    $iterator = new RecursiveIteratorIterator($filter);

    foreach ($iterator as $file) {
        $filename = $file->getFilename();
        $extension = strtolower(pathinfo($filename, PATHINFO_EXTENSION));
        if (
            !in_array($extension, $extensions, true)
            && $filename !== '.htaccess'
        ) {
            continue;
        }
        $fullPath = $file->getPathname();
        $relativePath = str_replace(
            DIRECTORY_SEPARATOR,
            '/',
            substr($fullPath, strlen($siteRoot) + 1)
        );
        $hash = hash_file('sha256', $fullPath);
        if ($hash === false) {
            throw new RuntimeException('Unable to hash: ' . $relativePath);
        }
        $files[$relativePath] = $hash;
    }
    ksort($files, SORT_STRING);
    return $files;
}

function loadBaseline(string $baselinePath): array
{
    if (!is_file($baselinePath)) {
        throw new RuntimeException('Baseline not found. Run baseline first.');
    }
    $json = file_get_contents($baselinePath);
    if ($json === false) {
        throw new RuntimeException('Unable to read baseline.');
    }
    $data = json_decode($json, true, 512, JSON_THROW_ON_ERROR);
    if (
        !is_array($data)
        || ($data['version'] ?? null) !== 1
        || !isset($data['files'])
        || !is_array($data['files'])
    ) {
        throw new RuntimeException('Invalid baseline format.');
    }
    return $data['files'];
}

try {
    if (PHP_SAPI !== 'cli') {
        throw new RuntimeException('CLI execution only.');
    }
    $command = $argv[1] ?? '';
    if (!in_array($command, ['baseline', 'scan'], true)) {
        throw new RuntimeException(
            'Usage: php integrity-check.php baseline|scan'
        );
    }
    $siteRoot = realpath($siteRoot);
    if ($siteRoot === false || !is_dir($siteRoot)) {
        throw new RuntimeException('Invalid website directory.');
    }
    $current = collectFiles(
        $siteRoot,
        $extensions,
        $excludedDirectories
    );

    if ($command === 'baseline') {
        if (file_exists($baselinePath)) {
            throw new RuntimeException(
                'Baseline already exists. Replace it only after '
                . 'validating a trusted deployment.'
            );
        }
        $payload = [
            'version' => 1,
            'created_at' => gmdate('c'),
            'files' => $current,
        ];
        $json = json_encode(
            $payload,
            JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR
        );
        if (file_put_contents($baselinePath, $json . PHP_EOL, LOCK_EX) === false) {
            throw new RuntimeException('Unable to write baseline.');
        }
        chmod($baselinePath, 0600);
        echo 'Baseline created: ' . count($current) . ' files' . PHP_EOL;
        exit(0);
    }

    $baseline = loadBaseline($baselinePath);
    $added = array_diff_key($current, $baseline);
    $deleted = array_diff_key($baseline, $current);
    $modified = [];
    foreach (array_intersect_key($current, $baseline) as $path => $hash) {
        if ($hash !== $baseline[$path]) {
            $modified[$path] = $hash;
        }
    }
    $changes = count($added) + count($modified) + count($deleted);
    if ($changes === 0) {
        exit(0);
    }

    $report = [
        '========================================',
        ' WEBSITE FILE INTEGRITY REPORT',
        '========================================',
        'Site: ' . $siteRoot,
        'Date: ' . gmdate('Y-m-d H:i:s') . ' UTC',
        'Files checked: ' . count($current),
        'Status: CHANGES DETECTED',
        '',
        'SUMMARY',
        '----------------------------------------',
        'Added:       ' . count($added),
        'Modified:    ' . count($modified),
        'Deleted:     ' . count($deleted),
        'Total:       ' . $changes,
        '',
        'DETAILS',
        '----------------------------------------',
    ];
    foreach (array_keys($added) as $path) {
        $report[] = '[ADDED]     ' . $path;
    }
    foreach (array_keys($modified) as $path) {
        $report[] = '[MODIFIED]  ' . $path;
    }
    foreach (array_keys($deleted) as $path) {
        $report[] = '[DELETED]   ' . $path;
    }
    $report[] = '';
    $report[] = '========================================';
    $report[] = 'ACTION REQUIRED';
    $report[] = 'Review unexpected changes against the';
    $report[] = 'last approved deployment.';
    $report[] = '========================================';

    $reportText = implode(PHP_EOL, $report) . PHP_EOL;
    $logDirectory = dirname($baselinePath) . '/logs';
    if (!is_dir($logDirectory)) {
        if (!mkdir($logDirectory, 0700, true) && !is_dir($logDirectory)) {
            throw new RuntimeException('Unable to create log directory.');
        }
    }
    $logPath = $logDirectory . '/integrity-' . gmdate('Y-m-d-His') . '.log';
    if (file_put_contents($logPath, $reportText, LOCK_EX) === false) {
        throw new RuntimeException('Unable to write integrity log.');
    }
    chmod($logPath, 0600);

    // A cron mailer can deliver this standard output.
    echo $reportText;
    exit(2);

} catch (Throwable $exception) {
    fwrite(STDERR, 'ERROR: ' . $exception->getMessage() . PHP_EOL);
    exit(1);
}

Der Scanner überspringt symbolische Links und übliche generierte Verzeichnisse. Prüfen Sie die Ausschlüsse sorgfältig: ein schreibbares Verzeichnis mit ausführbaren PHP-Dateien könnte wichtig zu überwachen sein. Die Baseline und Logs müssen für den Webserver unzugänglich und vor unbefugtem Schreiben geschützt sein.

5. Den ersten Scan ausführen

Bearbeiten Sie $siteRoot und $baselinePath, um Ihr Hosting-Konto anzupassen. Stellen Sie sicher, dass das private Verzeichnis existiert und für den CLI-Benutzer schreibbar ist.

Nachdem Sie bestätigt haben, dass die Website einem known-good Release entspricht, erstellen Sie die Baseline:

php /home/account/private/integrity-check.php baseline

Beispiel:

Baseline created: 428 files

Führen Sie einen Vergleich aus:

php /home/account/private/integrity-check.php scan

Ohne Änderungen beendet der Scan erfolgreich und schweigt. Ändern Sie eine harmlose PHP-Datei auf einer Staging-Installation und führen Sie ihn erneut aus. Der Scanner generiert einen Bericht, der die geänderte Datei identifiziert.

6. Die Ergebnisse verstehen

  • HINZUGEFÜGT: eine überwachte Datei existiert jetzt, aber nicht in der Baseline.
  • GEÄNDERT: derselbe Pfad existiert in beiden Snapshots, aber der SHA-256-Digest unterscheidet sich.
  • GELÖSCHTE: eine in der Baseline registrierte Datei fehlt.

Prüfen Sie zuerst Deployments und Erweiterungsaktualisierungen. Wenn eine Abweichung nicht erklärt werden kann, vergleichen Sie die Datei mit dem genehmigten Git-Revision oder Release-Paket. Untersuchen Sie sensiblen Code, wie Zahlungsintegrationen, sofort. Bewahren Sie relevante Beweise anstatt blindly Produktionsdateien zu ersetzen.

7. Automatisieren Sie Integritätsüberwachungen und erhalten Sie E-Mail-Benachrichtigungen

Manuelle Checks helfen während der Entwicklung. Ein geplanter Scan ist nützlicher, wenn er einen lesbaren Bericht speichert und per E-Mail sendet, nur wenn sich etwas geändert hat.

Die meisten Hosting-Control-Panels boten Cron-Jobs. Das komplette Skript in Abschnitt 4 implementiert bereits das notwendige Verhalten:

  1. Aktuelle Datei-Hashes berechnen.
  2. Mit der geschützten Baseline vergleichen.
  3. Wenn keine Unterschiede existieren, still beenden.
  4. Andernfalls einen formatierten Bericht im privaten logs/-Verzeichnis speichern.
  5. Den gleichen Bericht auf Standardausgabe ausdrucken, damit ein konfigurierter Cron-Mailer es liefern kann.

Beispiel für Plain-Text-Bericht

========================================
 WEBSITE FILE INTEGRITY REPORT
========================================
Site: /home/account/public_html
Date: 2026-11-19 03:00:00 UTC
Files checked: 428
Status: CHANGES DETECTED

SUMMARY
----------------------------------------
Added:       1
Modified:    2
Deleted:     1
Total:       4

DETAILS
----------------------------------------
[ADDED]     plugins/payment/debug.php
[MODIFIED]  includes/bootstrap.php
[MODIFIED]  plugins/payment/gateway.php
[DELETED]   includes/legacy.php

========================================
ACTION REQUIRED
Review unexpected changes against the
last approved deployment.
========================================

Der gespeicherte Log könnte sein:

/home/account/private/logs/integrity-2026-11-19-030000.log

Dieser Bericht funktioniert gleichermaßen in einem Texteditor, einer Cron-Benachrichtigungs-E-Mail oder einem Incident-Ticket.

Planen Sie den Scanner

Ein traditioneller Crontab-Eintrag für täglichen Scan um 3 Uhr morgens:

Technical workflow illustration
MAILTO=admin@example.com
0 3 * * * /usr/bin/php /home/account/private/integrity-check.php scan

Ersetzen Sie die Adresse und Pfade mit Ihren eigenen. Das Verhalten von Cron MAILTO hängt von der Cron-Implementierung und einem funktionierenden Mail-Transport ab; einige Shared-Hosts bieten stattdessen E-Mail-Benachrichtigungen in ihrem Control-Panel an. Das Skript sendet keine E-Mail selbst. Es druckt einen Bericht, den der Scheduler liefern kann.

Die Exit-Codes sind für zukünftige Integrationen nützlich:

Code Bedeutung
0 Sauberer Scan; keine Ausgabe
1 Scanner-Fehler; Nachricht auf Standardfehler
2 Unterschiede erkannt; Bericht auf Standardausgabe

Ein konventioneller Cron-Mailer sendet im Allgemeinen eine E-Mail, wenn ein Job Ausgabe erzeugt, nicht nur weil sein Exit-Status ungleich Null ist. Deshalb druckt das Skript nur bei Änderungen oder Fehlern.

Halten Sie Logs unter Kontrolle

Ein ungelöstes Problem erscheint bei jedem Scan wieder und kann wiederholte Berichte erzeugen. Legen Sie einen sinnvollen Aufbewahrungszeitraum (z.B. 30 Tage) mit Ihren normalen Wartungstools fest und in Betracht Alert-Deduplikation, wenn Sie den Scanner erweitern. Das Beispiel-Skript speichert Berichte, implementiert aber keine automatische Log-Bereinigung.

Aktualisieren Sie niemals die Baseline automatisch, um Warnungen zu unterdrücken: untersuchen Sie zuerst.

Testen Sie die Benachrichtigung

Auf Staging erstellen Sie eine vertrauenswürdige Baseline, ändern eine harmlose PHP-Datei, führen den Scan aus und bestätigen, dass ein Log erscheint. Triggeren Sie dann den geplanten Task und prüfen Sie die E-Mail. Stellen Sie die Testdatei wieder her und bestätigen, dass der Scanner in einen sauberen Zustand zurückkehrt.

Wenn ein Log existiert, aber keine E-Mail ankommt, prüfen Sie die Cron-Benachrichtigungseinstellen und Mail-Delivery des Hosts. Datei-Scanning und E-Mail-Transport sind unabhängig.

8. Legitime Updates ohne Fehlalarme handhaben

Ein normales Deployment kann dutzende Dateien ändern. Der Scanner sollte diese Änderungen melden, aber Sie sollten sie nicht als Einbruch bewerten.

Ein sicheres Workflow ist: Deployen Sie ein genehmigtes Release, überprüfen Sie dessen Inhalt gegen die vertrauenswürdige Quelle, speichern Sie die vorherige Baseline, erstellen Sie eine neue Baseline, dann setzen Sie die geplanten Checks fort.

Das Beispiel-Skript verweigert bewusst das Überschreiben einer bestehenden Baseline. Um sie nach einem genehmigten Release zu ersetzen, archivieren Sie den alten Referenzwert sicher, bevor Sie die neue erstellen.

Für Git-verwaltete Projekte ist eine stärkere Option, die erwarteten Datei-Hashes aus einem genehmigten Build- oder CI/CD-Artefakt zu generieren und diesen Referenzwert unabhängig vom Produktions-Server zu liefern.

9. Die Grenzen kennen

Periodische Scans verpassen temporäre Änderungen. Eine Datei, die zwischen Checks geändert und wiederhergestellt wird, könnte unerkannt bleiben.

Die Baseline kann angegriffen werden. Ein Angreifer mit ausreichenden Rechten, um sowohl Dateien als auch Referenzdaten zu ändern, kann Änderungen verbergen. Halten Sie eine unabhängige, vertrauenswürdige Kopie für wichtige Websites bereit.

Die Abdeckung ist selektiv. Unser Beispiel überwacht PHP-, JS-, CSS- und .htaccess-Dateien, aber nicht Datenbanken, Benutzerkonten, Cron-Konfiguration oder jeden möglichen Dateityp. Die Ausschlüsse müssen sorgfältig geprüft werden.

Integritätsüberwachung ist keine Malware-Analyse. Ein geänderter Hash sagt, dass eine Datei sich unterscheidet, nicht ob die Änderung bösartig ist.

Kombinieren Sie Integritätschecks mit Updates, eingeschränktem Zugriff, Backups, Anwendungs-Logs und geeigneten Sicherheitstools.

10. Wann ein professionelles Lösung wählen

Ein individuelles PHP-Skript ist kompakt, überprüfbar und leicht in den Deploy-Prozess einer individuellen Anwendung zu integrieren. Sie sind jedoch für vertrauenswürdige Baselines, Ausschlüche, Warn-Zustellung, Log-Aufbewahrung und Untersuchung verantwortlich.

Etablierte Überwachungsprodukte können Dashboards, Warnverlauf, zentrale Berichterstattung und breitere Incident-Response-Funktionen bieten. Für WordPress und Joomla beginnen Sie mit der Überprüfung der Fähigkeiten, die bereits über Ihre Plattform und Sicherheitserweiterungen verfügbar sind.

Wählen Sie die kleinste zuverlässige Lösung, die Ihre operativen Bedürfnisse abdeckt.

11. Praktische Checkliste

  • [ ] Überprüfen Sie die initialen Dateien gegen ein vertrauenswürdiges Release, BEFORE Sie die Baseline erstellen.
  • [ ] Speichern Sie Skript, Referenz und Berichte außerhalb des öffentlichen Webverzeichnisses.
  • [ ] Überprüfen Sie überwachte Erweiterungen und ausgeschlossene Verzeichnisse.
  • [ ] Nutzen Sie eingeschränkte Dateisystemberechtigungen.
  • [ ] Testen Sie hinzugefügte, geänderte und gelöschte Dateien auf Staging.
  • [ ] Bestätigen Sie Cron-Ausführung und tatsächliche E-Mail-Zustellung.
  • [ ] Bewahren Sie Logs auf und überwachen Sie Scanner-Fehler.
  • [ ] Erstellen Sie die Baseline nur nach einem genehmigten Deployment neu.
  • [ ] Untersuchen Sie unerwartete Änderungen, anstatt Dateen automatisch zu löschen.

Schluss: Wissen Sie, was sich geändert hat, bevor Sie untersuchen, warum

Ein Dateiintegritätsscan hilft Entwicklern, unerwartete Website-Änderungen schnell zu erkennen. PHPs native Hashing-Funktionen machen den Vergleich einfach; der eigentliche Wert liegt in einem vertrauenswürdigen Baseline, regelmäßigen Checks, lesbaren Warnungen und kontrollierten Deployments.

Für individuelle PHP-Websites und Erweiterungen ist das oben gezeigte leichte Skript ein guter Ausgangspunkt, ohne Composer oder Datenbank. Für WordPress und Joomla sind etablierte Verifizierungs- und Sicherheitstools möglicherweise eine bessere erste Wahl.

Offizielle Referenzen