Projet de Fin d'Etudes : Etude technique de l'attaque de Buffer Overflow

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 MATIERESIntroduction 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

IntroductionDans 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 programmeQuand 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.

2


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

3


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 registresLa 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

4


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.

5


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 principePour 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

6


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 OverflowIl 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).

7


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 OverflowCet 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


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 : push %ebp 0x0804851c : mov %esp, %ebp 0x0804851e : sub $0x1c, %esp 0x08048521 : movl $0x804867b,(%esp) 0x08048528 : call 0x80483f0 0x0804852d : lea 0xa (%ebp), %eax 0x08048530 : mov %eax,0x4(%esp) 0x08048534 : movl $0x8048686, (%esp) 0x0804853b : call 0x80483e0 0x08048540 : movl $0x8048689, 0x4(%esp) 0x08048548 : lea 0xa(%ebp),%eax 0x0804854b : mov %eax,(%esp) 0x0804854e : call 0x8048410

Documents

Projet de Fin d'Etudes : Etude technique de l'attaque de Buffer Overflow