Attaque par Buffer Overflow - Historique des versions

Sthioul : /* Exemple d'attaque */

2018-11-26T01:24:23Z

Exemple d'attaque

← Version précédente		Version du 26 novembre 2018 à 01:24
Ligne 59 :		Ligne 59 :
	Il est à noter que strcpy ne vérifie pas la taille du buffer lors de la copie. On va donc choisir une chaîne de caractères plus longue que celle du buffer, comme 200 octets.		Il est à noter que strcpy ne vérifie pas la taille du buffer lors de la copie. On va donc choisir une chaîne de caractères plus longue que celle du buffer, comme 200 octets.

			Le principe de l'exemple va etre la mise en place d'un shellcode,
	Si on tente d'afficher la chaîne de caractères, elle s'affichera correctement mais il y aura une erreur de segmentation car on essaie d'écrire dans une zone mémoire non autorisée en écriture.
			c'est à dire executer un code machine qui lance un shell.

			[[Fichier:EtatPileAvant.png]]

			Si, on regarde la pile, on a tout en bas, les variables de la fonction main: ici le pointeur args, haut dessus, la sauvegarde eip, qu'on va vouloir remplacer, puis la sauvegarde epb dessus. Dessus, on arrive cette fois-ci sur l'espace dédié à lafonction func, avec en bas de cette espace, notre buffer.

			[[Fichier:Shellcode.png]]

			On peut deviner la taille de notre buffer (puisque ce que c'est ce qui déborde), on sait donc que on doit entrer un texte de la longueur du buffer, plus un octet pour remplir sebp, concaténer a l’adresse de ce qu'on veut exécuter.

			Le contenu du texte contiendra le shellcode, qu'on met à la fin pour plus de facilité, et on complète au début avec des \x90, car c'est l'instruction qui, en assembleur, signifie "passer à l'instruction suivante".

			on met une des adresse de la zone des x90 (l'avantage est qu'on a pas besoin d’être très précis), les x90 vont donc s’exécuter jusqu’à arriver au début du shellcode.

			A savoir que si le buffer est trop petit pour le code à exécuter, on peut déborder encore plus, dans la mémoire de main, pour placer notre shellcode après seip.

	= Attaques références =		= Attaques références =

Sthioul : /* Solutions pour éviter l'attaque */

2018-11-25T23:33:39Z

Solutions pour éviter l'attaque

← Version précédente		Version du 25 novembre 2018 à 23:33
Ligne 91 :		Ligne 91 :
	* [https://fr.wikipedia.org/wiki/Address_space_layout_randomization address space layout randomization (ASLR)]: technique de placement aléatoire des différents éléments de la mémoire virtuelle.		* [https://fr.wikipedia.org/wiki/Address_space_layout_randomization address space layout randomization (ASLR)]: technique de placement aléatoire des différents éléments de la mémoire virtuelle.
	* NX protection: technique qui consiste à ne pas donner les droits d’exécution qu'à la zone mémoire contenant les instructions du programme		* NX protection: technique qui consiste à ne pas donner les droits d’exécution qu'à la zone mémoire contenant les instructions du programme
	* Stack-Smashing Protector: ajoute une valeur aléatoire prés de la zone mémoire critique. Ainsi, si la valeur a changer, c'est qu'il y a eu un dépassement, et on peut lever une erreur		* Stack-Smashing Protector: ajoute une valeur aléatoire prés de la zone mémoire critique. Ainsi, si la valeur à changer, c'est qu'il y a eu un dépassement, et on peut lever une erreur

	=Sources=		=Sources=

Sthioul : /* Solutions pour éviter l'attaque */

2018-11-25T23:33:18Z

Solutions pour éviter l'attaque

← Version précédente		Version du 25 novembre 2018 à 23:33
Ligne 91 :		Ligne 91 :
	* [https://fr.wikipedia.org/wiki/Address_space_layout_randomization address space layout randomization (ASLR)]: technique de placement aléatoire des différents éléments de la mémoire virtuelle.		* [https://fr.wikipedia.org/wiki/Address_space_layout_randomization address space layout randomization (ASLR)]: technique de placement aléatoire des différents éléments de la mémoire virtuelle.
	* NX protection: technique qui consiste à ne pas donner les droits d’exécution qu'à la zone mémoire contenant les instructions du programme		* NX protection: technique qui consiste à ne pas donner les droits d’exécution qu'à la zone mémoire contenant les instructions du programme
	* Stack-Smashing Protector: ajoute une valeur aléatoire		* Stack-Smashing Protector: ajoute une valeur aléatoire prés de la zone mémoire critique. Ainsi, si la valeur a changer, c'est qu'il y a eu un dépassement, et on peut lever une erreur

	=Sources=		=Sources=

Millon : /* Technique */

2018-11-25T22:27:40Z

Technique

← Version précédente		Version du 25 novembre 2018 à 22:27
Ligne 47 :		Ligne 47 :

	On remarque que toutes les adresses entre celles de l'EBP et l'ESP sont remplies, mais aussi celles de l'EBP et de l'EIP (adresse de l'instruction courante). Dans ce cas, lorsque le programme va se terminer et qu'on va passer par l'instruction correspondant à la valeur de retour du programme, l'EIP va donc pointer vers l'adresse AAAA qui, en hexadécimal, est 0x41414141. La probabilité de pouvoir accéder à cette adresse mémoire est quasi nulle, il se peut même que cette adresse ne soit pas mappée. Il est donc inévitable de se retrouver face à une erreur de segmentation.		On remarque que toutes les adresses entre celles de l'EBP et l'ESP sont remplies, mais aussi celles de l'EBP et de l'EIP (adresse de l'instruction courante). Dans ce cas, lorsque le programme va se terminer et qu'on va passer par l'instruction correspondant à la valeur de retour du programme, l'EIP va donc pointer vers l'adresse AAAA qui, en hexadécimal, est 0x41414141. La probabilité de pouvoir accéder à cette adresse mémoire est quasi nulle, il se peut même que cette adresse ne soit pas mappée. Il est donc inévitable de se retrouver face à une erreur de segmentation.

			Pour exploiter cette faille, l'idée serait de rediriger l'adresse de l'EIP vers une partie du programme que l'on souhaiterai exécuter (en général, programme injecté dans la pile d'exécution). Il serait alors possible de faire presque tout ce qu'on voudrait sur la machine victime de l'attaque, comme par exemple ouvrir un shell et s'approprier tous les droits.

	== Exemple d'attaque ==		== Exemple d'attaque ==

Millon : /* Technique */

2018-11-25T22:24:19Z

Technique

← Version précédente		Version du 25 novembre 2018 à 22:24
Ligne 45 :		Ligne 45 :

	[[Fichier:Stack3.png]]		[[Fichier:Stack3.png]]

			On remarque que toutes les adresses entre celles de l'EBP et l'ESP sont remplies, mais aussi celles de l'EBP et de l'EIP (adresse de l'instruction courante). Dans ce cas, lorsque le programme va se terminer et qu'on va passer par l'instruction correspondant à la valeur de retour du programme, l'EIP va donc pointer vers l'adresse AAAA qui, en hexadécimal, est 0x41414141. La probabilité de pouvoir accéder à cette adresse mémoire est quasi nulle, il se peut même que cette adresse ne soit pas mappée. Il est donc inévitable de se retrouver face à une erreur de segmentation.

	== Exemple d'attaque ==		== Exemple d'attaque ==

Millon : /* Technique */

2018-11-25T22:16:36Z

Technique

← Version précédente		Version du 25 novembre 2018 à 22:16
Ligne 43 :		Ligne 43 :
	La pile d'exécution ne semble pas avoir de dysfonctionnement, les valeurs de la variables sont stockées entre l'adresse de l'ESP et l'adresse de l'EBP.		La pile d'exécution ne semble pas avoir de dysfonctionnement, les valeurs de la variables sont stockées entre l'adresse de l'ESP et l'adresse de l'EBP.
	Si on souhaite maintenant passer en paramètre du programme une chaîne de taille supérieure à 24 caractères, le schéma suivant représenterait l'état de la pile d'exécution :		Si on souhaite maintenant passer en paramètre du programme une chaîne de taille supérieure à 24 caractères, le schéma suivant représenterait l'état de la pile d'exécution :


	[[Fichier:Stack3.png]]		[[Fichier:Stack3.png]]

Millon : /* Technique */

2018-11-25T22:16:24Z

Technique

← Version précédente		Version du 25 novembre 2018 à 22:16
Ligne 37 :		Ligne 37 :
	== Technique ==		== Technique ==

	Le principe est de créer une erreur (ou un crash) du programme en cours d'exécution. Pour cela, on va exploiter la mémoire du programme et en particulier la pile d’exécution. Un programme simple alloue 24 caractères dans un tableau et copie la chaîne de caractères passée en paramètre du programme dans ce tableau. La variable sera alors copiée dans la pile à partir de ~~la valeur~~ de l'ESP, qui est l'adresse mémoire correspondant au sommet de la pile. Si on choisit de mettre 24 fois la lettre A dans cette variable, on pourrait représenter l'état de la pile d’exécution avec le schéma suivant :		Le principe est de créer une erreur (ou un crash) du programme en cours d'exécution. Pour cela, on va exploiter la mémoire du programme et en particulier la pile d’exécution. Un programme simple alloue 24 caractères dans un tableau et copie la chaîne de caractères passée en paramètre du programme dans ce tableau. La variable sera alors copiée dans la pile à partir de l'adresse de l'ESP, qui est l'adresse mémoire correspondant au sommet de la pile. Si on choisit de mettre 24 fois la lettre A dans cette variable, on pourrait représenter l'état de la pile d’exécution avec le schéma suivant :

	[[Fichier:Stack2.png]]		[[Fichier:Stack2.png]]

			La pile d'exécution ne semble pas avoir de dysfonctionnement, les valeurs de la variables sont stockées entre l'adresse de l'ESP et l'adresse de l'EBP.
			Si on souhaite maintenant passer en paramètre du programme une chaîne de taille supérieure à 24 caractères, le schéma suivant représenterait l'état de la pile d'exécution :


	[[Fichier:Stack3.png]]		[[Fichier:Stack3.png]]

Millon : /* Technique */

2018-11-25T22:10:47Z

Technique

← Version précédente		Version du 25 novembre 2018 à 22:10
Ligne 36 :		Ligne 36 :

	== Technique ==		== Technique ==

			Le principe est de créer une erreur (ou un crash) du programme en cours d'exécution. Pour cela, on va exploiter la mémoire du programme et en particulier la pile d’exécution. Un programme simple alloue 24 caractères dans un tableau et copie la chaîne de caractères passée en paramètre du programme dans ce tableau. La variable sera alors copiée dans la pile à partir de la valeur de l'ESP, qui est l'adresse mémoire correspondant au sommet de la pile. Si on choisit de mettre 24 fois la lettre A dans cette variable, on pourrait représenter l'état de la pile d’exécution avec le schéma suivant :

	[[Fichier:Stack2.png]]		[[Fichier:Stack2.png]]

Millon : /* Technique */

2018-11-25T21:58:55Z

Technique

← Version précédente		Version du 25 novembre 2018 à 21:58
Ligne 36 :		Ligne 36 :

	== Technique ==		== Technique ==

			[[Fichier:Stack2.png]]

			[[Fichier:Stack3.png]]

	== Exemple d'attaque ==		== Exemple d'attaque ==

Millon : /* Technique */

2018-11-25T21:55:19Z

Technique

← Version précédente		Version du 25 novembre 2018 à 21:55
Ligne 36 :		Ligne 36 :

	== Technique ==		== Technique ==

	D'un point de vue plus technique, la pile (stack en anglais) est une partie de la mémoire utilisée par l'application pour stocker ses variables locales. Nous allons utiliser l'exemple d'une architecture Intel (32 bits). Lors d'un appel à une sous-routine, le programme empile (push) le pointeur d'instruction (EIP) sur la pile (stack) et saute au code de la sous-routine pour l'exécuter. Après l'exécution, le programme dépile (pop) le pointer d'instruction et retourne juste après l'endroit où a été appelée la sous-routine, grâce à la valeur d'EIP. En effet, comme EIP pointe toujours vers l'instruction suivante, lors de l'appel de la sous-routine il pointait déjà vers l'instruction suivante, autrement dit l'instruction à exécuter après la sous-routine (= adresse de retour).

	D'autre part, lors de l'appel de la sous-routine, celle-ci va dans la majorité des cas créer sa propre pile dans la pile (pour éviter de gérer des adresses compliquées). Pour cela elle va empiler la valeur de la base de la pile (EBP) et affecter la valeur du pointeur de pile (ESP) à celle de la base (EBP).


	[[Fichier:EBP-ESP.PNG]]
	* ESP : pointeur du sommet de la pile.
	* EBP : (Extended Base Pointer) pointeur de la base de la pile
	* ESP : (Extended Stack Pointer) pointeur du sommet de la pile

	En résumé, on sauvegarde la valeur originale de la base et on décale le tout ensuite. Lors du retour de la sous-routine, on dépile EBP et réaffecte sa valeur originale pour restaurer la pile initiale.

	Voici pour le déroulement "normal" des opérations. Un point intéressant à citer est le fait que dans notre architecture, les zones mémoires allouées dans la stack se remplissent dans le sens croissant des adresses (de 0..0H à F..FH) ce qui semble logique. Par contre, l'empilement sur la stack s'effectue dans le sens décroissant! C'est-à-dire que l'ESB originale est l'adresse la plus grande et que le sommet est 0..0H. De là naît la possibilité d'écraser des données vitales et d'avoir un buffer overflow.
	En effet, si notre buffer se trouve dans la pile d'une sous-routine et si nous le remplissons jusqu'à déborder sa taille allouée, nous allons écrire par-dessus les données qui se trouvent à la fin du buffer, c'est-à-dire les adresses qui ont été empilées précédemment : EBP, EIP... Une fois la routine terminée, le programme va dépiler EIP et sauter à cette adresse pour poursuivre son exécution. Le but est donc d'écraser EIP avec une adresse différente que nous pourrons utiliser pour accéder à une partie de code qui nous appartient. (par exemple le contenu du buffer)
	Un problème à ce stade est de connaitre l'adresse exacte de la stack (surtout sous Windows) pour pouvoir sauter dedans. On utilise généralement des astuces propres à chaque système (librairies, etc..) qui vont permettre -indirectement- d'atteindre notre stack et d'exécuter notre code. Cela nécessite un débogage intensif qui n'est pas à la portée de tout le monde...

	== Exemple d'attaque ==		== Exemple d'attaque ==

Attaque par Buffer Overflow - Historique des versions

Sthioul : /* Exemple d'attaque */

Sthioul : /* Solutions pour éviter l'attaque */

Sthioul : /* Solutions pour éviter l'attaque */

Millon : /* Technique */

Millon : /* Technique */

Millon : /* Technique */

Millon : /* Technique */

Millon : /* Technique */

Millon : /* Technique */

Millon : /* Technique */

Sthioul : /* Exemple d'attaque */

Sthioul : /* Solutions pour éviter l'attaque */

Sthioul : /* Solutions pour éviter l'attaque */

Millon : /* Technique */

Millon : /* Technique */

Millon : /* Technique */

Millon : /* Technique */

Millon : /* Technique */

Millon : /* Technique */

Millon : /* Technique */