Web e sviluppo

Come rilevare modifiche non autorizzate ai file sul tuo sito web con PHP

How to Detect Unauthorized File Changes on Your Website with PHP

Scopri come rilevare modifiche impreviste ai file PHP del tuo sito web utilizzando un monitor di integrità dei file leggero. Crea un pratico scanner PHP, confronta snapshot attendibili e identifica i file modificati, aggiunti o eliminati senza Composer.

Come rilevare modifiche non autorizzate ai file del tuo sito web con PHP

Immagina di aprire il tuo sito web una mattina e scoprire che qualcosa è cambiato. Una pagina reindirizza i visitatori, un file PHP contiene codice sconosciuto o un plugin si comporta diversamente nonostante nessun aggiornamento programmato.

Quali file sono cambiati? Controllarne centinaia manualmente è irrealistico. Il monitoraggio dell'integrità dei file (FIM) confronta il filesystem corrente con uno snapshot affidabile. Questo tutorial costruisce un piccolo scanner PHP per siti personalizzati, estensioni e hosting condiviso, senza Composer o database.

1. Cos'è il monitoraggio dell'integrità dei file?

Un monitor registra percorsi e hash crittografici dei file selezionati, poi li ricontrolla. Segnala file AGGIUNTI, MODIFICATI ed ELIMINATI. Queste differenze sono indizi per l'indagine, non prove di un attacco: i normali deployment cambiano anche i file.

Per esempio:

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

Una scansione successiva potrebbe segnalare:

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

Il requisito cruciale è una baseline affidabile. Se un sito era compromesso prima dello snapshot iniziale, i file malevoli potrebbero già essere registrati come normali.

2. Costruire uno scanner o usare uno strumento esistente?

Prima di programmare, controlla la tua piattaforma. Su WordPress, WP-CLI verifica i file core rispetto ai checksum ufficiali:

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

Il comando plugin copre principalmente i plugin ospitati nel repository WordPress.org; plugin personalizzati e commerciali richiedono un altro riferimento. Su Joomla, estensioni consolidate come Akeeba Admin Tools offrono il monitoraggio delle modifiche ai file. Le applicazioni gestite con Git possono anche confrontare gli artifact deployati con una release approvata.

Situazione Punto di partenza
WordPress core e plugin del repository Verifica checksum WP-CLI
Joomla con esigenze di sicurezza continue Estensione di sicurezza consolidata
Sito PHP personalizzato o estensioni personalizzate Piccolo scanner di integrità PHP
Diversi server che richiedono alert centralizzati Piattaforma di monitoraggio dedicata
Deployment versionato Build o artifact di release affidabile

Uno script personalizzato è utile quando hai bisogno di un controllo mirato per il tuo codice e puoi mantenere la sua baseline e gli alert.

3. Perché SHA-256?

PHP fornisce hash_file():

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

Il risultato è un digest esadecimale di 64 caratteri del contenuto del file. Un file modificato produrrà quasi certamente un digest diverso. Possiamo quindi memorizzare una mappa compatta di percorsi relativi a valori SHA-256 invece di duplicare ogni file.

Un digest corrispondente dimostra coerenza con il riferimento, non che il riferimento o il file siano affidabili. Stabilisci lo snapshot iniziale da un deployment noto-buono, preferibilmente verificato rispetto al controllo sorgente o a un pacchetto di release approvato.

4. Costruire uno scanner leggero di integrità file PHP

Crea integrity-check.php fuori dalla directory web pubblica, accanto a una baseline JSON protetta:

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

Lo script ha due comandi: baseline crea lo snapshot iniziale e scan lo confronta. Segnala le differenze senza eliminare o sostituire file del sito. Questa versione genera anche il log formattato e l'output compatibile con cron descritto nella sezione 7.

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

Lo scanner salta i link simbolici e le directory generate comuni. Rivedi attentamente le esclusioni: una directory scrivibile contenente PHP eseguibile potrebbe essere importante da monitorare. La baseline e i log devono essere inaccessibili al server web e protetti da scritture non autorizzate.

5. Eseguire la prima scansione

Modifica $siteRoot e $baselinePath per adattarli al tuo account hosting. Assicurati che la directory privata esista e sia scrivibile dall'utente CLI.

Dopo aver verificato che il sito corrisponde a una release nota-buona, crea la baseline:

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

Esempio:

Baseline created: 428 files

Esegui un confronto:

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

Senza modifiche, la scansione esce con successo e resta silenziosa. Modifica un file PHP innocuo su un'installazione di staging ed esegui di nuovo. Lo scanner genererà un report che identifica il file modificato.

6. Capire i risultati

  • AGGIUNTO: un file monitorato esiste ora ma non nella baseline.
  • MODIFICATO: lo stesso percorso esiste in entrambi gli snapshot, ma il suo digest SHA-256 differisce.
  • ELIMINATO: un file registrato nella baseline è mancante.

Controlla prima la cronologia di deployment e aggiornamenti delle estensioni. Se una differenza è inspiegabile, confronta il file con la sua revisione Git approvata o il pacchetto di release. Indaga tempestivamente il codice sensibile, come le integrazioni di pagamento. Conserva le prove rilevanti invece di sostituire ciecamente i file di produzione.

7. Automatizzare i controlli di integrità e ricevere alert via email

I controlli manuali aiutano durante lo sviluppo. Una scansione programmata è più utile quando salva un report leggibile e lo invia via email solo quando qualcosa cambia.

La maggior parte dei pannelli di controllo hosting offre cron job. Lo script completo nella sezione 4 implementa già il comportamento necessario:

  1. Calcola gli hash dei file correnti.
  2. Confronta con la baseline protetta.
  3. Se non ci sono differenze, esce silenziosamente.
  4. Altrimenti, salva un report formattato nella directory privata logs/.
  5. Stampa lo stesso report su standard output così un cron mailer configurato può consegnarlo.

Esempio report in testo semplice

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

Il log salvato potrebbe essere:

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

Questo report funziona ugualmente bene in un editor di testo, un'email di notifica cron, o un ticket di incidente.

Programmare lo scanner

Una voce crontab tradizionale per una scansione giornaliera alle 3 AM:

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

Sostituisci indirizzo e percorsi con i tuoi. Il comportamento MAILTO di cron dipende dall'implementazione cron e da un trasporto mail funzionante; alcuni host condivisi forniscono invece notifiche email nel loro pannello di controllo. Lo script non invia email da solo. Stampa un report per lo scheduler da consegnare.

I codici di uscita sono utili per future integrazioni:

Codice Significato
0 Scansione pulita; nessun output
1 Errore scanner; messaggio su standard error
2 Differenze rilevate; report su standard output

Un cron mailer convenzionale generalmente invia email quando un job produce output, non solo perché il suo stato di uscita è non-zero. Per questo lo stampa solo su cambiamenti o errori.

Mantenere i log sotto controllo

Una differenza irrisolta riappare a ogni scansione, generando report ripetuti. Imposta un periodo di ritenzione sensato (per esempio, 30 giorni) usando i tuoi normali strumenti di manutenzione, e considera la deduplicazione degli alert se estendi lo scanner. Lo script di esempio salva i report ma non implementa la pulizia automatica dei log.

Non aggiornare mai la baseline automaticamente per silenziare gli alert: indaga prima.

Testare la notifica

Su staging, crea una baseline affidabile, modifica un file PHP innocuo, esegui la scansione e conferma che appare un log. Poi attiva l'attività programmata e controlla l'email. Ripristina il file di test e conferma che lo scanner torna a uno stato pulito.

Se un log esiste ma non arriva email, controlla le impostazioni di notifica cron dell'host e la consegna mail. La scansione file e il trasporto email sono indipendenti.

8. Gestire aggiornamenti legittimi senza falsi allarmi

Un deployment normale può modificare decine di file. Lo scanner dovrebbe segnalare quei cambiamenti, ma non dovresti trattarli come un'intrusione.

Un flusso di lavoro sicuro è: deploya una release approvata, verifica i suoi contenuti rispetto alla sorgente affidabile, preserva la baseline precedente, crea una nuova baseline, poi riprendi i controlli programmati.

Lo script di esempio rifiuta deliberatamente di sovrascrivere una baseline esistente. Per sostituirla dopo una release approvata, archivia il vecchio riferimento in modo sicuro prima di creare il nuovo.

Per progetti gestiti con Git, un'opzione più forte è generare gli hash file attesi da una build approvata o artifact CI/CD e consegnare quel riferimento indipendentemente dal server di produzione.

9. Conoscere i limiti

Le scansioni periodiche mancano cambiamenti temporanei. Un file alterato e ripristinato tra un controllo e l'altro può passare inosservato.

La baseline può essere attaccata. Un intruso con accesso sufficiente per alterare sia file che dati di riferimento può nascondere modifiche. Mantieni una copia affidabile indipendente per siti importanti.

La copertura è selettiva. Il nostro esempio monitora file PHP, JS, CSS e .htaccess, ma non database, account utenti, configurazione cron o ogni possibile tipo di file. Le sue esclusioni necessitano revisione deliberata.

Il monitoraggio d'integrità non è analisi malware. Un hash modificato dice che un file differisce, non se il cambiamento è malevolo.

Combina controlli d'integrità con aggiornamenti, accessi ristretti, backup, log applicativi e strumenti di sicurezza adeguati.

10. Quando scegliere una soluzione professionale

Uno scanner PHP personalizzato è compatto, auditabile e facile da integrare nel processo di deployment di un'applicazione personalizzata. Ma sei responsabile per baseline affidabili, esclusioni, consegna alert, ritenzione log e indagine.

Prodotti di monitoraggio consolidati possono fornire dashboard, storico alert, reportistica centralizzata e funzionalità di incident-response più ampie. Per WordPress e Joomla, inizia revisionando le capacità già disponibili tramite la tua piattaforma ed estensioni di sicurezza.

Scegli la soluzione affidabile più piccola che copre le tue esigenze operative.

11. Checklist pratica

  • [ ] Verifica i file iniziali contro una release affidabile prima di creare la baseline.
  • [ ] Memorizza script, riferimento e report fuori dalla directory web pubblica.
  • [ ] Rivedi estensioni monitorate ed directory escluse.
  • [ ] Usa permessi filesystem restrittivi.
  • [ ] Testa file aggiunti, modificati ed eliminati su staging.
  • [ ] Conferma esecuzione cron e consegna email effettiva.
  • [ ] Mantieni log e monitora errori dello scanner.
  • [ ] Ricostruisci la baseline solo dopo un deployment approvato.
  • [ ] Indaga cambiamenti inaspettati invece di eliminare file automaticamente.

Conclusione: sapere cosa è cambiato prima di indagare perché

Uno scanner di integrità file aiuta gli sviluppatori a identificare rapidamente cambiamenti inaspettati del sito web. Le funzioni native di hashing di PHP rendono il confronto semplice; il vero valore sta in una baseline affidabile, controlli regolari, alert leggibili e un flusso di lavoro di deployment controllato.

Per siti PHP personalizzati ed estensioni, lo script leggero sopra è un utile punto di partenza senza Composer o database. Per WordPress e Joomla, strumenti di verifica e sicurezza consolidati potrebbero essere una scelta migliore iniziale.

Riferimenti ufficiali