Nett og utvikling

Hvordan oppdage uautoriserte filendringer på nettstedet ditt med PHP

How to Detect Unauthorized File Changes on Your Website with PHP

Lær hvordan du kan oppdage uventede endringer i PHP-filene på nettstedet ditt ved hjelp av en lett filintegritetsmonitor. Bygg en praktisk PHP-skanner, sammenlign pålitelige øyeblikksbilder, og identifiser modifiserte, lagt til eller slettede filer uten Composer.

Tenk deg at du en morgen åpner nettstedet ditt og oppdager at noe er endret. En side omdirigerer besøkende, en PHP-fil inneholder ukjent kode, eller en plugin oppfører seg annerledes selv om ingen oppdatering var planlagt.

Hvilke filer er endret? Det er urealistisk å sjekke hundrevis manuelt. Filintegritetsovervåking (FIM) sammenligner det gjeldende filsystemet med et klarert øyeblikksbilde. Denne veiledningen bygger en liten PHP-skanner for tilpassede nettsteder, utvidelser og delt hosting, uten Composer eller en database.

1. Hva er filintegritetsovervåking?

En overvåker registrerer baner og kryptografiske hasher for utvalgte filer, og sjekker dem deretter på nytt. Den rapporterer ADDED, MODIFIED og DELETED filer. Disse forskjellene er spor å undersøke, ikke bevis på et angrep: normale utrullinger endrer også filer.

For eksempel:

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

En senere skanning kan rapportere:

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

Det avgjørende kravet er et klarert referansegrunnlag. Hvis et nettsted ble kompromittert før det første øyeblikksbildet, kan ondsinnede filer allerede være registrert som normale.

2. Bygge en skanner eller bruke et eksisterende verktøy?

Før du koder, sjekk plattformen din. På WordPress verifiserer WP-CLI kjernefiler mot offisielle checksummer:

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

Plugin-kommandoen dekker først og fremst plugins som ligger i WordPress.org-repositoriet; tilpassede og kommersielle plugins krever en annen referanse. På Joomla tilbyr etablerte utvidelser som Akeeba Admin Tools overvåking av filendringer. Git-administrerte applikasjoner kan også sammenligne utrullede artefakter mot en godkjent utgivelse.

Situasjon Utgangspunkt
WordPress-kjerne og plugins fra repositoriet WP-CLI-checksumverifisering
Joomla med løpende sikkerhetsbehov Etablert sikkerhetsutvidelse
Tilpasset PHP-nettsted eller tilpassede utvidelser Liten PHP-integritetsskanner
Flere servere som krever sentraliserte varsler Dedikert overvåkingsplattform
Versjonskontrollert utrulling Klarert build eller utgivelsesartefakt

Et tilpasset skript er verdifullt når du trenger en fokusert sjekk av din egen kode og kan vedlikeholde referansegrunnlaget og varslene.

3. Hvorfor SHA-256?

PHP tilbyr hash_file():

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

Resultatet er et 64 tegn langt heksadesimalt sammendrag av filinnholdet. En endret fil vil nesten helt sikkert gi et annet sammendrag. Vi kan derfor lagre et kompakt kart over relative baner til SHA-256-verdier i stedet for å duplisere hver fil.

Et samsvarende sammendrag beviser samsvar med referansen, ikke at referansen eller filen er til å stole på. Etabler det første øyeblikksbildet fra en kjent god utrulling, helst kontrollert mot kildekontroll eller en godkjent utgivelsespakke.

4. Bygg en lett PHP-skanner for filintegritet

Opprett integrity-check.php utenfor den offentlige webkatalogen, sammen med et beskyttet JSON-referansegrunnlag:

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

Skriptet har to kommandoer: baseline oppretter det første øyeblikksbildet, og scan sammenligner det. Det rapporterer forskjeller uten å slette eller erstatte nettstedfiler. Denne versjonen genererer også den formaterte loggen og cron-vennlige utdataene som er beskrevet i del 7.

Komplett 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);
}

Skanneren hopper over symbolske lenker og vanlige genererte kataloger. Gå nøye gjennom ekskluderingene: en skrivbar katalog som inneholder kjørbar PHP, kan være viktig å overvåke. Referansegrunnlaget og loggene må være utilgjengelige for webserveren og beskyttet mot uautoriserte skrivinger.

5. Kjør den første skanningen

Rediger $siteRoot og $baselinePath slik at de passer til hostingkontoen din. Sørg for at den private katalogen finnes og er skrivbar for CLI-brukeren.

Etter å ha verifisert at nettstedet samsvarer med en kjent god utgivelse, opprett referansegrunnlaget:

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

Eksempel:

Baseline created: 428 files

Kjør en sammenligning:

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

Uten endringer avsluttes skanningen med suksess og er stille. Endre en ufarlig PHP-fil på en staging-installasjon og kjør den igjen. Skanneren vil generere en rapport som identifiserer den endrede filen.

6. Forstå resultatene

  • ADDED: en overvåket fil finnes nå, men ikke i referansegrunnlaget.
  • MODIFIED: samme bane finnes i begge øyeblikksbildene, men SHA-256-sammendraget er forskjellig.
  • DELETED: en fil som er registrert i referansegrunnlaget, mangler.

Sjekk først utrullings- og utvidelsesoppdateringshistorikken. Hvis en forskjell er uforklart, sammenlign filen med dens godkjente Git-revisjon eller utgivelsespakke. Undersøk sensitiv kode, for eksempel betalingsintegrasjoner, raskt. Ta vare på relevante bevis i stedet for å blindt erstatte produksjonsfiler.

7. Automatiser integritetssjekker og motta e-postvarsler

Manuelle sjekker er nyttige under utvikling. En planlagt skanning er mer nyttig når den lagrer en lesbar rapport og sender den på e-post bare når noe endres.

De fleste hostingkontrollpaneler tilbyr cron-jobber. Det komplette skriptet i del 4 implementerer allerede den nødvendige atferden:

  1. Beregn gjeldende filhasher.
  2. Sammenlign med det beskyttede referansegrunnlaget.
  3. Hvis det ikke er forskjeller, avslutt uten utdata.
  4. Ellers lagre en formatert rapport under den private logs/-katalogen.
  5. Skriv ut samme rapport til standardutdata slik at en konfigurert cron-mailer kan levere den.

Eksempel på rapport i ren tekst

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

Den lagrede loggen kan se slik ut:

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

Denne rapporten fungerer like godt i en tekstbehandler, en cron-varsel-e-post eller en hendelsessak.

Planlegg skanneren

En tradisjonell crontab-oppføring for en daglig skanning kl. 03:00:

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

Erstatt adressen og banene med dine egne. Crons MAILTO-atferd avhenger av cron-implementasjonen og en fungerende e-posttransport; noen delte hoster tilbyr i stedet e-postvarsler i kontrollpanelet. Skriptet sender ikke e-post selv. Det skriver ut en rapport som planleggeren kan levere.

Avslutningskodene er nyttige for fremtidige integrasjoner:

Kode Betydning
0 Ren skanning; ingen utdata
1 Skannerfeil; melding til standardfeil
2 Forskjeller oppdaget; rapport til standardutdata

En vanlig cron-mailer sender normalt e-post når en jobb produserer utdata, ikke bare fordi avslutningsstatusen er ulik null. Derfor skriver skriptet bare ut ved endringer eller feil.

Hold loggene under kontroll

En uløst forskjell dukker opp igjen ved hver skanning, så den kan generere gjentatte rapporter. Sett en fornuftig oppbevaringsperiode (for eksempel 30 dager) med dine vanlige vedlikeholdsverktøy, og vurder deduplisering av varsler hvis du utvider skanneren. Eksempelskriptet lagrer rapporter, men implementerer ikke automatisk opprydding av logger.

Oppdater aldri referansegrunnlaget automatisk for å stilne varsler: undersøk først.

Test varslingen

På staging oppretter du et klarert referansegrunnlag, endrer en ufarlig PHP-fil, kjører skanningen og bekrefter at en logg vises. Deretter utløser du den planlagte oppgaven og sjekker e-posten. Gjenopprett testfilen og bekreft at skanneren går tilbake til en ren tilstand.

Hvis en logg finnes, men ingen e-post kommer frem, sjekk vertens cron-varselinnstillinger og e-postlevering. Filskanning og e-posttransport er uavhengige.

8. Håndter legitime oppdateringer uten falske alarmer

En normal utrulling kan endre dusinvis av filer. Skanneren bør rapportere disse endringene, men du bør ikke behandle dem som et inntrengningsforsøk.

En trygg arbeidsflyt er: rull ut en godkjent utgivelse, verifiser innholdet mot den klarerte kilden, ta vare på det forrige referansegrunnlaget, opprett et nytt referansegrunnlag og gjenoppta deretter de planlagte sjekkene.

Eksempelskriptet nekter bevisst å overskrive et eksisterende referansegrunnlag. For å erstatte det etter en godkjent utgivelse, arkiver den gamle referansen sikkert før du oppretter den nye.

For Git-administrerte prosjekter er et sterkere alternativ å generere de forventede filhashene fra en godkjent build eller et CI/CD-artefakt og levere den referansen uavhengig av produksjonsserveren.

9. Kjenn begrensningene

Periodiske skanninger går glipp av midlertidige endringer. En fil som endres og gjenopprettes mellom sjekker, kan forbli uoppdaget.

Referansegrunnlaget kan angripes. En inntrenger med nok tilgang til å endre både filer og referansedata kan skjule endringer. Oppbevar en uavhengig klarert kopi for viktige nettsteder.

Dekningen er selektiv. Eksempelet vårt overvåker PHP-, JS-, CSS- og .htaccess-filer, men ikke databaser, brukerkontoer, cron-konfigurasjon eller alle mulige filtyper. Ekskluderingene må gjennomgås bevisst.

Integritetsovervåking er ikke skadevareanalyse. En endret hash sier at en fil er forskjellig, ikke om endringen er ondsinnet.

Kombiner integritetssjekker med oppdateringer, begrenset tilgang, sikkerhetskopier, applikasjonslogger og egnede sikkerhetsverktøy.

10. Når du bør velge en profesjonell løsning

En tilpasset PHP-skanner er kompakt, reviderbar og enkel å integrere i en tilpasset applikasjons utrullingsprosess. Men du er ansvarlig for klarerte referansegrunnlag, ekskluderinger, varsellevering, loggoppbevaring og undersøkelser.

Etablerte overvåkingsprodukter kan tilby dashbord, varselhistorikk, sentralisert rapportering og bredere funksjoner for hendelseshåndtering. For WordPress og Joomla bør du starte med å gjennomgå funksjoner som allerede er tilgjengelige gjennom plattformen og sikkerhetsutvidelsene dine.

Velg den minste pålitelige løsningen som dekker driftsbehovene dine.

11. Praktisk sjekkliste

  • [ ] Verifiser de opprinnelige filene mot en klarert utgivelse før du oppretter referansegrunnlaget.
  • [ ] Lagre skriptet, referansen og rapportene utenfor den offentlige webkatalogen.
  • [ ] Gå gjennom overvåkede utvidelser og ekskluderte kataloger.
  • [ ] Bruk begrensede filsystemtillatelser.
  • [ ] Test lagt til, endrede og slettede filer på staging.
  • [ ] Bekreft cron-kjøring og faktisk e-postlevering.
  • [ ] Behold logger og overvåk skannerfeil.
  • [ ] Bygg referansegrunnlaget på nytt bare etter en godkjent utrulling.
  • [ ] Undersøk uventede endringer i stedet for å slette filer automatisk.

Konklusjon: finn ut hva som er endret før du undersøker hvorfor

En filintegritetsskanner hjelper utviklere med å raskt identifisere uventede endringer på nettsteder. PHPs innebygde hashfunksjoner gjør sammenligningen enkel; den virkelige verdien ligger i et klarert referansegrunnlag, regelmessige sjekker, lesbare varsler og en kontrollert utrullingsarbeidsflyt.

For tilpassede PHP-nettsteder og -utvidelser er det lette skriptet ovenfor et nyttig utgangspunkt uten Composer eller en database. For WordPress og Joomla kan etablerte verifiserings- og sikkerhetsverktøy være et bedre førstevalg.

Offisielle referanser