security-maand-4Het beveiligen van een Joomla! website is geen makkelijke en/of eenmalige taak. Er moet constant geupdate worden (Joomla! core updates en gebruikte componenten) en er is veel verstand van zaken nodig (DB aanpassingen, UNIX rechten, etc). Daarnaast is er ook nog sprake van een inherente handicap voor beveiligers: een aanvaller hoeft namelijk maar 1 gat te vinden terwijl de verdediger zijn hele "omheining" in de gaten moet houden.

Het is daarom verstandig om rekening te houden met het feit dat er vroeg of laat een probleem zal optreden. Na een hack, worden er in 9 van de 10 gevallen, een of meer van de volgende aanpassingen aan een site gemaakt:

Al deze veranderingen hebben gemeenschappelijk dat de broncode van de site verandert. Als we dus dit soort veranderingen zouden kunnen detecteren dan is het mogelijk deze hacks tijdig te herkennen.

Hoe Werkt Het

De meest gebruikte manier om een bestand op veranderingen te controleren is de zogenaamde hash functie. Een hash functie is een speciale functie die als eigenschap heeft dat een kleine verandering in de input, een groot effect heeft op de output. Een andere eigenschap van een hash functie is dat deze maar een kleine waarde oplevert (de zogenaamde hash) ongeacht de lengte van de invoer.

Door de inhoud van een bestand in een hash-functie te stoppen, kunnen we dus een kleine waarde uitrekenen (een hash) die verandert als de inhoud verandert. Als we dus op 2 verschillende tijdstippen een hash uitrekenen, en deze vergelijken, dan kunnen we gemakkelijk zien of er veranderingen zijn aangebracht in de tussentijd. Immers een kleine verandering in de invoer (het bestand) heeft een groot effect op de uitvoer (de hash). Als er veranderingen zijn aangebracht in de tussentijd dan zijn de hashes verschillend.

Dit principe laat zich gemakkelijk generaliseren tot hele directories. Neem van elke bestand een hash en plak deze achter elkaar. Maak van deze lang string zelf weer een hash en sla deze op. Als 1 van de bestanden verandert zal de hash van dat bestand veranderen. Hierdoor verandert de grote string en dit zorgt ervoor dat de uiteindelijke hash ook weer verandert. Dit werkt, want een van de eigenschappen van de hash functie is dat een kleine verandering in de invoer een groot effect heeft op de uitvoer. Hierdoor zorgt een eventuele verandering voor een waterval van veranderingen die ervoor zorgt dat als er ook maar 1 teken verandert is, er een totaal andere hash uitkomt.

De scripts

monitoringEen simpel hash controle systeem, dat op de hierboven geschetste manier werkt, zou kunnen bestaan uit 2 losse scripts. Een "Check" script dat in de te controleren sites staat en een centraal "Monitoring" script dat voor ons alle sites afgaat en de check scripts uitvoert (zie afbeelding). Hierdoor kunnen we vanuit een centrale locatie, meerdere sites in de gaten houden.

Het monitor script loop alle sites na en vergelijkt hun huidige hash met de vorige hash en rapporteert eventuele veranderingen. Uiteindelijk slaat het "monitor" script de laatst ingelezen hashes op zodat we deze de volgende keer kunnen gebruiken voor de vergelijking.

Het check script werkt door alle bestanden van 1 site af te lopen en voor elk bestand een hash waarde te berekenen. Al deze hashes worden gecombineerd tot 1 uiteindelijke hash en dit wordt als antwoord teruggegeven. Het script zal gebruik maken van de standaard PHP hash functie sha1.

Het is belangrijk dat het monitor script zelf niet "in het bereik" van een check script staat (d.w.z. in een directory staat onder de directory waarin het check script draait). Er treedt dan een probleem op met de tijdelijke opslag van de vorige resultaten, immers dit verandert elke keer! De scripts mogen dus wel op dezelfde server staan maar moeten wel in gescheiden stukken van het bestandssysteem staan.

Het Check Script

Het check script werkt door alle bestanden in een Joomla! instantie af te lopen en hiervan een hash te berekenen. Deze deel-hashes worden tot een eind-hash gecombineerd en dit wordt als antwoord opgeleverd. Niet alle bestanden en directories zijn interessant om mee te nemen in de check, bv. de logs en cache mappen zijn elke keer anders. We willen ook niet elke keer dat er een nieuwe plaatje is geüpload een melding krijgen. Het script moet dus de mogelijkheid hebben om bepaalde mappen en bestanden te negeren.

Een andere eigenschap die bepalend is voor het script is de zogenaamde open_basedir restrictie die vaak aanstaat. Deze restrictie zorgt ervoor dat een script alleen maar mag lezen in de directory waarin het is opgestart, en in de directories eronder. Het script zal dus moeten werken vanuit de root van de site die we in de gaten willen gaan houden.

Het check script begint daarom als volgt:

    // lijst van bestand/directory namen die niet moeten worden meegenomen
// NB als bv. de vermelding cache word opgenomen en deze zou 2x voorkomen
// als '/cache' en '/admin/cache' dan zouden deze allebij worden uitgesloten!
// NB2 '.', en '..' moeten worden opgenomen zodat de functie "omhoog" loopt en
// "vader" directories meeneemt
$except = array(
'.',
'..',
'images',
'cache',
'logs',
'tmp'
);
// de directory waarin dit script wordt aangeroepen
$root = dirname(__FILE__).'/';
// deze constante bepaalt hoe groot de tussentijdse hash mag worden
$MAX_HASH_SIZE = 2048;

We definiëren allereerst een array met daarin bestands- en directory- namen die niet hoeven worden meegenomen in de check ($except), hierna lezen we de huidige directory in ($root) en definiëren we een maximale tussentijdse hash size ($MAX_HASH_SIZE). Vervolgens definiëren we een hulp-functie die de lijst met bestandsnamen gaat uitrekenen door recursief alle directories en sub-directories af te lopen.

    // een recursieve functie die alle bestands namen oplevert in een directory en zijn
// subdirectories
function listFiles($directory, $except = array('.','..')) {
// de tussentijdse lijst met bestanden
$result = array();
// open de aangeleverde directory
$handle = opendir($directory);
// lees de directory in
while($resource = readdir($handle)) {
if($resource === false)
// deze directory is volledig ingelezen
break;
// als de bestands naam NIET voorkomt in de except array
if(!in_array(strtolower($resource), $except)) {
// verwerk en let niet op evt. meldingen (openbasedir)
if(@is_dir($directory . $resource . '/'))
// lees recursief de subdirectory in en voeg deze
// samen met de huidge tussentijdse lijst
$result = array_merge($result, listFiles($directory . $resource . '/', $except));
else
// sla de directory + bestandsnaam op in de tussentijdse lijst
$result[] = $directory . $resource;
}
}
// sluit de geopende directory weer netjes af
closedir($handle);
return $result;
}

De recursieve listFiles functie gebruikt standaard PHP functies om de meegegeven directory ($directory) door te lopen. Voor elk item, dat niet in de $except array voorkomt, wordt er gekeken of het een file of een directory is: is het een file dan wordt het opgeslagen in de tussentijdse lijst met bestandsnamen, is het een directory dan wordt de listFiles functie (recursief) aangeroepen op de sub-directory. Daarna wordt het resultaat van de recursieve aanroep (alle bestanden in die subdirectory en eronder) meteen samengevoegd met de tussentijdse lijst. Als alle bestanden en sub-directories opgesomd zijn dan wordt de lijst opgeleverd als het eindresultaat.

Nu zijn we toe aan het maken van de uiteindelijke hash. Eerst vragen we de lijst met bestanden in de huidige directory op ( $files) en lopen hier vervolgens doorheen. We lezen dan voor elke file de inhoud in en rekenen hier een sha1 hash van uit. Deze hash wordt achter de tussentijdse hash geplakt.

    // lees alle bestanden in
$files = listFiles($root, $except);
// de uiteindelijke hash
$hash = '';
foreach($files as $file) {
// lees het bestand in zijn geheel in en hash de inhoud
// mocht dit mislukken zeur er dan niet over
$hash .= sha1(@file_get_contents($file));
// als de tussentijdse hash groter is geworden dan MAX_HASH_SIZE
if(strlen($hash) >= MAX_HASH_SIZE) {
// hash de tussentijdse hash zelf
$hash = sha1($hash);
}
}
// hash de tussentijdse hash zelf naar een hash
$hash = sha1($hash);
// geef de hash terug
echo $hash;

Omdat elke hash uit 40 tekens bestaat wordt de tussentijdse hash al snel erg groot. Als de totale hash langer wordt dan $MAX_HASH_SIZE dan rekenen we hier zelf weer een hash van uit. Hierdoor wordt de totale hash 40 tekens lang en gebruiken we niet teveel geheugen. Als we alle bestanden gehashed hebben, dan hashen nog 1 keer de tussentijdse hash (om er netjes 40 tekens van te maken) en sturen deze als antwoord op.

Het Monitor Script

Het centrale monitor script stelt ons in staat om eenvoudige meerdere websites te checken en bespaart ons het nodige administratieve werk. We beginnen met het definiëren van een lijst met alle sites die we zouden willen checken. Deze lijst bevat simpelweg het URL (van de root, waar dus het check.php script staat) van de websites die we willen checken. Vervolgens definiëren we een functie die via de cURL bibliotheek het antwoord van het check script ophaalt en teruggeeft.

<html>
<head>
<title>Website Integriteits Check</title>
</head>
<body>
<?php
// deze array bevat een lijst met sites die moeten worden geverifieerd
// NB deze urls moeten eindigen met een '/'
$sites = array(
...
);

// deze functie haalt met curl een 'check.php' hash op
function check($url) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url . 'check.php');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_FAILONERROR, true);
$result = curl_exec($ch);
$error = curl_errno($ch);
if($error != CURL_OK)
return null;
curl_close($ch);
return $result;
}

Vervolgens lezen we de vorige hashes van de harde schijf en lezen deze in ($previous).

    // lees de vorige hashes in
$hashes = file_get_contents('hashes.dat');
// hebben we al eens eerder een verificatie gedaan?
if($hashes == '')
// er is nog nooit een check uitgevoerd, geef dit aan met null
// zodat we straks een database zullen opbouwen
$previous = null;
else
// lees de opgeslagen php array in en maak er een echte php array van
$previous = unserialize($hashes);

Deze stap wordt bemoeilijkt door het feit, dat als het script voor het eerst draait, er nog geen hashes database is opgebouwd. We signaleren dit door $previous null te maken. Vervolgens lopen we langs alle sites in de $sites lijst en vragen de hash van die site op ($current).

    // de huidige hash resultaten
$current = array();
// haal voor alle sites een hash op
foreach($sites as $site) {
$hash = check($site);
if($hash == null)
// de hash word niet opgeslagen omdat er iets fout ging
// NB hierdoor word hij ook niet in het eindresultaat meegenomen
echo "Error: $site<br/>";
else
// sla de huidige hash op onder het url van de site
$current[$site] = $hash;
}

Nu kunnen we de vorige resultaten vergelijken met de huidige. Wat weer wordt bemoeilijkt door het feit dat de 1e keer dat het script draait, er nog geen database is. De variabele die de vorige resultaten zou moeten bevatten is dan null gemaakt. Als we merken dat er geen resultaten zijn ($previous == null), dan slaan we de huidige resultaten op alsof het allemaal goed is gegaan. In dit geval zijn we meteen klaar.

    // is dit de eerste keer?
if($previous == null) {
// sla onze huidige resultaten op, we hebben nog niks om mee te vergelijken
file_put_contents('hashes.dat', serialize($current));
// meld het resultaat van deze check
echo "First Time: hash database built";
return;
} else {
// controleer onze huidige resultaten met die van de vorige keer
$ok = 0; // er zijn 0 sites hetzelfde gebleven
$new = 0; // er zijn 0 nieuwe sites (waar nog geen hash waarde voor is)
// controleer de hash waarde voor alle site, hash paren die ingelezen konden worden
foreach($current as $site => $hash) {
// als de site nog niet bestond dan hebben we een nieuwe site erbij gekregen
if(!isset($previous[$site])) {
$new++;
echo "New Site: $site - $hash<br/>";
} else {
if($hash != $previous[$site]) {
// er is iets veranderd
echo "**ALERT** Change Detected: $site<br/>";
} else {
// site is hetzelfde gebleven
$ok++;
}
}
}
}

Als we al wel een keer uitgevoerd zijn, en er dus resultaten zijn om te vergelijken, dan lopen we door alle huidige resultaten heen. We kiezen voor de huidige (en niet de oude) lijst want op die manier zullen nieuwe sites die zijn toegevoegd sinds de laatste keer, automatisch worden meegenomen.

Vervolgens kijken we voor elke hash die we opgehaald hebben of het een nieuwe of een oude site is. Als de site de vorige keer ook al bestond dan vergelijken we het huidige resultaat en het vorige. Als de 2 hashes overeenkomen dan is alles ok en zijn er geen veranderingen aangebracht in de broncode. Is de hash wel anders dan is er iets veranderd en geven we meteen een melding. Was de site nog niet bekend de vorige keer, dan hebben we nog niks om te vergelijken en slaan we de site simpelweg over.

Tot slot slaan we de huidige hashes op en geven we alle resultaten nog een keer netjes weer in een klein overzichtje.

    // bewaar de huidige resultaten voor de volgende keer
file_put_contents('hashes.dat', serialize($current));
// toon een simpel raport
echo "Ok: $ok<br/>";
echo "New: $new<br/>";
?>
</body>
</html>

Verbeteringen

De scripts vormen de basis van een heel simpel check systeem dat op veel verschillende manieren kan worden uitgebreid. Er kan een wachtwoord aan het check script worden toegevoegd zodat niet iedereen zomaar een check kan uitvoeren. Het check script zou ook sommige database tabellen kunnen meenemen zoals bv. jos_users. Ook is het mischien interresant om niet een eind antwoord uit te rekenen maar alle tussentijdse hashes gewoon op te slaan, hierdoor wordt het mogelijk om te zien in welk bestand precies een verandering is opgetreden.

Het monitor script kan natuurlijk naar believen worden uitgebreid: meer user interface, meer geschiedenis, etc. Ook zou het monitor script met een al bestaand management console kunnen worden geintegreerd. Het monitor script kan natuurlijk ook middels een cron job periodiek worden uitgevoerd.

Ook kan het systeem uitgebreid worden met een simpel protocol dat het mogelijk maakt om fouten in het check.php script op te sporen. Zo is het in het huidige check script mogelijk dat wegens rechten problemen, geen enkele file echt ingelezen kan worden. Door het gebruik van @ is dit moeilijk te detecteren want het script zal wel degelijk een hash opleveren (allemaal hashes van een lege string). Een soortgelijk probleem kan zich ook voordoen bij de directories. Een simpel protocol en wat extra veiligheidschecks zouden het mogelijk maken deze problemen naar het monitoring script te sturen, die deze dan zou kunnen rapporteren.

Tot slot, stel ik alle code in dit artikel vrijelijk beschikbaar, maar het gebruik ervan is op eigen verantwoordelijkheid.

Download het monitor script. Download het check script.

Jillis ter Hove is mens sinds 1981 en programmeur sinds 1999. Als hij niet oude vrouwtjes de straat helpt over steken dan is hij plannen aan het maken om de wereld te veroveren. Volg Jillis op twitter of bezoek zijn website.

10 reacties

EasyDiscuss Avatar
Thijmen
Met het monitorscript krijg ik dit als ik het script aanroep:<br />Error: http://filterlog.nl/fledermauzen/<br />First Time: hash database built<br /><br />En het check script laadt heel lang, en geeft een witte pagina terug.<br /><br />PHP versie:<br />PHP 5.2.9 (cli) (built: Jul 8 2009 06:03:36)<br />Copyright (c) 1997-2009 The PHP Group<br />Zend Engine v2.2.0, Copyright (c) 1998-2009 Zend Technologies
EasyDiscuss Avatar
sc00zy
Doet Eyesite eigenlijk niet hetzelfde als het script hierboven? http://extensions.joomla.org/extensions/access-a-security/site-security/9149
EasyDiscuss Avatar
iGniSz
@Thijmen He, ik heb voor het inregelen een verwijzing naar een werkend (mijn eigen) script laten staan! Je mag hier wat mee spelen maar het is natuurlijk de bedoeling dat je ipv: http://filterlog.nl/fledermauzen/ je eigen urls invoert. <br /><br />Het check script kan er idd lang over doen! Het loop immers elk bestand af.. Staat je max. executie tijd niet te kort? Mischien moet je wat grote directories excluden zoals (evt.) JoomlaPack! <br /><br />De timeout is te detecteren en is mischien wel een goeie voor eventuele uitbreiding van het script! Bedankt voor de tip..<br /><br />@scoozy: Ja je hebt gelijk, EyeSite doe iets dergelijks, maar wel op een dusdanig andere manier dat de eigenschappen eigenlijk best wel anders zijn! Eyesite slaat dingen op in de (eigen) database en die kan ik zelf aanpasssen (na een hack), ook is het makkelijk te ontdekken dat eyesite gebruikt wordt (het is immers een module die gewoon in het lijstje staat). Voorts is het ook zo dat mijn oplossing meer bedoelt is om veel sites te checken vanaf 1 centrale locatie, terwijl je voor eyesite overal apart moet inloggen..
EasyDiscuss Avatar
Thijmen
@Ignisz:<br /><br />Werkt ook niet, link aangepast naar mijn site:<br /><br />Error: http://blog.thijmen.co.uk/<br />First Time: hash database built<br /><br />Max. executie tijd is standaard 30 seconden.
EasyDiscuss Avatar
iGniSz
@thijmen He! Klopt, en 30 seconden zou meer dan genoeg moeten zijn!!<br /><br />Wat je het beste kan doen is de error onderdrukking uitzetten, en dan kijken welke errors er gegeven worden! Dit kan je doen door bovenaan het check script<br /><br />error_report ing(E_ALL); <br /><br />te zetten en vervolgens alle @'s uit het script te halen (het zijn er 2, rgl 37 en 58). Op die manier zie je precies wat er fout gaat! De '@' operator onderdrukt foutmeldingen (staat ook in de comments beschreven).<br /><br />Ik vermoed een rechtenkwestie.. maar dat zien we dan vanzelf!
EasyDiscuss Avatar
sc00zy
Bedankt voor het artikel en de extra toelichting :-)
EasyDiscuss Avatar
Rajah
Ziet er indrukwekkend uit Jillis! Ondanks je uitvoerige uitleg ben ik bang dat ik dat niet ga snappen zonder een ingevuld voorbeeld. Zo loop ik meteen vast bij het begin. Geen idee wat ik daarmee moet doen. Is het mogelijk een "ingevuld" voorbeeld te downloaden?<br /><br />Bij $except = array(<br />'.',<br />'..',<br />'images',<br />'cache',<br />'logs',<br />'tmp',<br />'check.php',<br />'hashes.dat'<br />);
EasyDiscuss Avatar
iGniSz
Hallo Rajah,<br /><br />De 2 scripts die je kan downloaden zijn direct te gebruiken,.. in die zin zijn ze dus ingevuld! Ik vraag me verder af of je wel het goede kennis niveau hebt om de script te gaan aanpassen, want als je al vastloopt bij een variabele definitie dan denk ik dat je niet goed weet hoe PHP werkt en daar kan ik je niet mee helpen!<br /><br />Je kan de 2 script gewoon gebruiken als volgt: zet het check script in de root van de site die je in de gaten wil houden en zet het url daarvan in het lijstje bovenaan monitor.php. Deze zet je dan op een Andere site en dan kan je door hem op te vragen zien of de 1e site veranderd is. Zo werkt het..
EasyDiscuss Avatar
Rajah
Bedankt Ignisz / Jillis<br />Inderdaad 0,02 verstand van php. Toch voldoende om met de aanwijzingen en proberen het werkend te krijgen.<br />Geweldig dus!<br />Toch nog een vraag en verzoek.<br />Ik heb de map public_html moeten wijzigen in 707 en de monitor.php in 707 (normaal toch hooguit 666?)<br /><br />En dan natuurlijk heeeel graag, wat je zelf al aangaf:<br />Ook is het mischien interresant om niet een eind antwoord uit te rekenen maar alle tussentijdse hashes gewoon op te slaan, hierdoor wordt het mogelijk om te zien in welk bestand precies een verandering is opgetreden
EasyDiscuss Avatar
Rajah
public_html weer op 755 gezet en monitor.php op 644.<br />Werkt prima.Waarschijnlijk heeft de opwinding mij parten gespeeld! :D

Reageer

1000 Resterende tekens