Web et développement

Comment détecter les modifications non autorisées de fichiers sur votre site Web avec PHP

How to Detect Unauthorized File Changes on Your Website with PHP

Apprenez à détecter les changements inattendus des fichiers PHP de votre site Web à l'aide d'un moniteur de l'intégrité de fichiers léger. Créez un scanner PHP pratique, comparez les instantanés fiables et identifiez les fichiers modifiés, ajoutés ou supprimés sans Composer.

Imaginez que vous ouvriez votre site Web un matin et découvriez que quelque chose a changé. Une page redirige les visiteurs, un fichier PHP contient du code inconnu, ou une extension se comporte différemment malgré l'absence de mise à jour planifiée.

Quels fichiers ont changé ? Vérifier des centaines manuellement est irréaliste. La surveillance de l'intégrité des fichiers (FIM) compare le système de fichiers actuel à un instantané de confiance. Ce tutoriel construit un petit scanner PHP pour sites personnalisés, extensions et hébergements mutualisés, sans Composer ni base de données.

1. Qu'est-ce que la surveillance de l'intégrité des fichiers ?

Un moniteur enregistre les chemins et les hachages cryptographiques des fichiers sélectionnés, puis les vérifie à nouveau. Il signale les fichiers AJOUTÉS, MODIFIÉS et SUPPRIMÉS. Ces différences sont des pistes d'investigation, pas la preuve d'une attaque : les déploiements normaux modifient également les fichiers.

Par exemple :

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

Une analyse ultérieure pourrait signaler :

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

L'exigence cruciale est une ligne de base de confiance. Si un site était compromis avant l'instantané initial, les fichiers malveillants peuvent déjà être enregistrés comme normaux.

2. Construire un scanner ou utiliser un outil existant ?

Avant de coder, vérifiez votre plateforme. Sur WordPress, WP-CLI vérifie les fichiers principaux par rapport aux sommes de contrôle officielles :

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

La commande pour les plugins couvre principalement les plugins hébergés dans le dépôt WordPress.org ; les plugins personnalisés et commerciaux nécessitent une autre référence. Sur Joomla, des extensions établies telles que Akeeba Admin Tools offrent la surveillance des modifications de fichiers. Les applications gérées par Git peuvent également comparer les artefacts déployés par rapport à une version approuvée.

Situation Point de départ
WordPress core et plugins du dépôt Vérification des sommes de contrôle WP-CLI
Joomla avec besoins de sécurité continus Extension de sécurité établie
Site PHP personnalisé ou extensions personnalisées Petit scanner d'intégrité PHP
Plusieurs serveurs nécessitant des alertes centralisées Plateforme de surveillance dédiée
Déploiement avec contrôle de version Artefact de build ou de release de confiance

Un script personnalisé est précieux lorsque vous avez besoin d'une vérification ciblée pour votre propre code et pouvez maintenir sa ligne de base et ses alertes.

3. Pourquoi SHA-256 ?

PHP fournit hash_file() :

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

Le résultat est un résumé hexadécimal de 64 caractères du contenu du fichier. Un fichier modifié produira presque certainement un résumé différent. Nous pouvons donc stocker une correspondance compacte de chemins relatifs vers des valeurs SHA-256 au lieu de dupliquer chaque fichier.

Un résumé correspondant prouve la cohérence avec la référence, pas que la référence ou le fichier est digne de confiance. Établissez l'instantané initial à partir d'un déploiement connu comme bon, de préférence vérifié par rapport au contrôle de source ou à un paquet de version approuvé.

4. Construire un scanner d'intégrité de fichiers PHP léger

Créez integrity-check.php en dehors du répertoire web public, aux côtés d'une ligne de base JSON protégée :

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

Le script a deux commandes : baseline crée l'instantané initial et scan le compare. Il signale les différences sans supprimer ni remplacer les fichiers du site Web. Cette version génère également le journal formaté et la sortie compatible cron décrite dans la section 7.

Script PHP complet (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);
}

Le scanner ignore les liens symboliques et les répertoires générés courants. Examinez attentivement les exclusions : un répertoire accessible en écriture contenant du PHP exécutable peut être important à surveiller. La ligne de base et les journaux doivent être inaccessibles au serveur web et protégés contre les écritures non autorisées.

5. Exécuter la première analyse

Modifiez $siteRoot et $baselinePath pour qu'ils correspondent à votre compte d'hébergement. Assurez-vous que le répertoire privé existe et est accessible en écriture par l'utilisateur CLI.

Après avoir vérifié que le site Web correspond à une version connue comme bonne, créez la ligne de base :

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

Exemple :

Baseline created: 428 files

Exécutez une comparaison :

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

Sans modifications, l'analyse se termine avec succès et reste silencieuse. Modifiez un fichier PHP inoffensif sur une installation de staging et relancez-la. Le scanner générera un rapport identifiant le fichier modifié.

6. Comprendre les résultats

  • AJOUTÉ : un fichier surveillé existe maintenant mais pas dans la ligne de base.
  • MODIFIÉ : le même chemin existe dans les deux instantanés, mais son résumé SHA-256 diffère.
  • SUPPRIMÉ : un fichier enregistré dans la ligne de base est manquant.

Vérifiez d'abord l'historique des déploiements et des mises à jour d'extensions. Si une différence est inexpliquée, comparez le fichier avec sa révision Git approuvée ou son paquet de version. Enquêtez rapidement sur le code sensible, tel que les intégrations de paiement. Préservez les preuves pertinentes au lieu de remplacer aveuglément les fichiers de production.

7. Automatiser les vérifications d'intégrité et recevoir des alertes par e-mail

Les vérifications manuelles aident pendant le développement. Une analyse planifiée est plus utile lorsqu'elle enregistre un rapport lisible et l'envoie par e-mail uniquement en cas de changement.

La plupart des panneaux de contrôle d'hébergement offrent des tâches cron. Le script complet de la section 4 implémente déjà le comportement nécessaire :

  1. Calculer les hachages des fichiers actuels.
  2. Comparer avec la ligne de base protégée.
  3. S'il n'y a pas de différences, sortir silencieusement.
  4. Sinon, enregistrer un rapport formaté sous le répertoire privé logs/.
  5. Afficher le même rapport sur la sortie standard pour qu'un cron mailer configuré puisse le livrer.

Exemple de rapport en texte brut

========================================
 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.
========================================

Le journal enregistré pourrait être :

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

Ce rapport fonctionne aussi bien dans un éditeur de texte, un e-mail de notification cron ou un ticket d'incident.

Planifier le scanner

Une entrée crontab traditionnelle pour une analyse quotidienne à 3 h du matin :

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

Remplacez l'adresse et les chemins par les vôtres. Le comportement MAILTO de cron dépend de l'implémentation cron et d'un transport de messagerie fonctionnel ; certains hébergeurs mutualisés fournissent plutôt les notifications par e-mail dans leur panneau de contrôle. Le script n'envoie pas d'e-mail lui-même. Il imprime un rapport pour que l'ordonnanceur le livre.

Les codes de sortie sont utiles pour les futures intégrations :

Code Signification
0 Analyse propre ; aucune sortie
1 Erreur du scanner ; message sur la sortie d'erreur standard
2 Différences détectées ; rapport sur la sortie standard

Un cron mailer conventionnel envoie généralement un e-mail lorsqu'un travail produit une sortie, pas simplement parce que son statut de sortie est non nul. C'est pourquoi le script n'imprime que lors de changements ou d'erreurs.

Maîtriser les journaux

Une différence non résolue réapparaît à chaque analyse, ce qui peut générer des rapports répétés. Définissez une période de rétention raisonnable (par exemple, 30 jours) à l'aide de vos outils de maintenance habituels, et envisagez la déduplication d'alertes si vous étendez le scanner. Le script d'exemple enregistre les rapports mais n'implémente pas le nettoyage automatique des journaux.

Ne mettez jamais à jour la ligne de base automatiquement pour faire taire les alertes : enquêtez d'abord.

Tester la notification

En staging, créez une ligne de base de confiance, modifiez un fichier PHP inoffensif, lancez l'analyse et confirmez qu'un journal apparaît. Ensuite, déclenchez la tâche planifiée et vérifiez l'e-mail. Restaurez le fichier de test et confirmez que le scanner revient à un état propre.

Si un journal existe mais qu'aucun e-mail n'arrive, vérifiez les paramètres de notification cron de l'hébergeur et la livraison des e-mails. L'analyse de fichiers et le transport d'e-mails sont indépendants.

8. Gérer les mises à jour légitimes sans fausses alertes

Un déploiement normal peut modifier des dizaines de fichiers. Le scanner doit signaler ces changements, mais vous ne devez pas les traiter comme une intrusion.

Un flux de travail sûr consiste à : déployer une version approuvée, vérifier son contenu par rapport à la source de confiance, conserver la ligne de base précédente, créer une nouvelle ligne de base, puis reprendre les vérifications planifiées.

Le script d'exemple refuse délibérément d'écraser une ligne de base existante. Pour la remplacer après une version approuvée, archivez l'ancienne référence de manière sécurisée avant de créer la nouvelle.

Pour les projets gérés par Git, une option plus forte consiste à générer les hachages de fichiers attendus à partir d'un build approuvé ou d'un artefact CI/CD et à fournir cette référence indépendamment du serveur de production.

9. Connaître les limites

Les analyses périodiques manquent les changements temporaires. Un fichier modifié et restauré entre deux vérifications peut passer inaperçu.

La ligne de base peut être attaquée. Un intrus ayant un accès suffisant pour modifier à la fois les fichiers et les données de référence peut masquer les changements. Conservez une copie de confiance indépendante pour les sites importants.

La couverture est sélective. Notre exemple surveille les fichiers PHP, JS, CSS et .htaccess, mais pas les bases de données, les comptes utilisateurs, la configuration cron ou tous les types de fichiers possibles. Ses exclusions nécessitent un examen délibéré.

La surveillance d'intégrité n'est pas une analyse de logiciels malveillants. Un hachage modifié indique qu'un fichier diffère, pas si le changement est malveillant.

Combinez les vérifications d'intégrité avec les mises à jour, les accès restreints, les sauvegardes, les journaux d'application et les outils de sécurité appropriés.

10. Quand choisir une solution professionnelle

Un scanner PHP personnalisé est compact, auditable et facile à intégrer dans le processus de déploiement d'une application personnalisée. Mais vous êtes responsable des lignes de base de confiance, des exclusions, de la livraison des alertes, de la rétention des journaux et de l'investigation.

Les produits de surveillance établis peuvent fournir des tableaux de bord, l'historique des alertes, les rapports centralisés et des fonctionnalités de réponse aux incidents plus larges. Pour WordPress et Joomla, commencez par examiner les capacités déjà disponibles via votre plateforme et vos extensions de sécurité.

Choisissez la plus petite solution fiable qui couvre vos besoins opérationnels.

11. Liste de contrôle pratique

  • [ ] Vérifier les fichiers initiaux par rapport à une version de confiance avant de créer la ligne de base.
  • [ ] Stocker le script, la référence et les rapports en dehors du répertoire web public.
  • [ ] Examiner les extensions surveillées et les répertoires exclus.
  • [ ] Utiliser des permissions de système de fichiers restreintes.
  • [ ] Tester les fichiers ajoutés, modifiés et supprimés en staging.
  • [ ] Confirmer l'exécution du cron et la livraison effective des e-mails.
  • [ ] Conserver les journaux et surveiller les erreurs du scanner.
  • [ ] Reconstruire la ligne de base uniquement après un déploiement approuvé.
  • [ ] Enquêter sur les changements inattendus au lieu de supprimer automatiquement les fichiers.

Conclusion : savoir ce qui a changé avant d'enquêter sur la raison

Un scanner d'intégrité de fichiers aide les développeurs à identifier rapidement les changements inattendus du site Web. Les fonctions de hachage natives de PHP simplifient la comparaison ; la vraie valeur réside dans une ligne de base de confiance, des vérifications régulières, des alertes lisibles et un flux de travail de déploiement contrôlé.

Pour les sites PHP personnalisés et les extensions, le script léger ci-dessus est un point de départ utile sans Composer ni base de données. Pour WordPress et Joomla, les outils de vérification et de sécurité établis peuvent être un meilleur premier choix.

Références officielles