Français - Ht
HackTricks TrainingTwitterLinkedinSponsor

Stack Overflow

Apprenez le piratage AWS de zéro à héros avec htARTE (Expert en équipe rouge AWS de HackTricks)!

Autres façons de soutenir HackTricks :

Qu'est-ce qu'un débordement de pile

Un débordement de pile est une vulnérabilité qui se produit lorsqu'un programme écrit plus de données sur la pile qu'il n'est alloué pour en contenir. Ces données excédentaires vont écraser l'espace mémoire adjacent, entraînant la corruption de données valides, la perturbation du flux de contrôle et potentiellement l'exécution de code malveillant. Ce problème survient souvent en raison de l'utilisation de fonctions non sécurisées qui ne vérifient pas les limites des entrées.

Le principal problème de cet écrasement est que les pointeurs EIP et EBP pour revenir à la fonction précédente sont stockés dans la pile. Par conséquent, un attaquant pourra les écraser et contrôler le flux d'exécution du programme.

La vulnérabilité survient généralement parce qu'une fonction copie à l'intérieur de la pile plus d'octets que la quantité qui lui est allouée, ce qui lui permet d'écraser d'autres parties de la pile. Certaines fonctions courantes vulnérables à cela sont : strcpy, strcat, sprintf, gets, fgets...

Par exemple, les fonctions suivantes pourraient être vulnérables :

void vulnerable() {
char buffer[128];
printf("Enter some text: ");
gets(buffer); // This is where the vulnerability lies
printf("You entered: %s\n", buffer);
}

Trouver les débordements de pile

La manière la plus courante de trouver les débordements de pile est de fournir une entrée très grande de As (par exemple python3 -c 'print("A"*1000)') et d'attendre un Segmentation Fault indiquant que l'adresse 0x41414141 a été tentée d'être accédée.

De plus, une fois que vous avez trouvé qu'il y a une vulnérabilité de débordement de pile, vous devrez trouver le décalage jusqu'à ce qu'il soit possible de écraser le pointeur EIP, pour cela on utilise généralement une séquence de De Bruijn. Qui, pour un alphabet donné de taille k et des sous-séquences de longueur n, est une séquence cyclique dans laquelle chaque sous-séquence possible de longueur _n_** apparaît exactement une fois** en tant que sous-séquence contiguë.

De cette manière, au lieu de devoir déterminer manuellement quel décalage écrase l'EIP, il est possible d'utiliser l'une de ces séquences comme rembourrage, puis de trouver le décalage des octets qui ont fini par l'écraser.

Il est possible d'utiliser pwntools pour cela:

from pwn import *

# Generate a De Bruijn sequence of length 1000 with an alphabet size of 256 (byte values)
pattern = cyclic(1000)

# This is an example value that you'd have found in the EIP/IP register upon crash
eip_value = p32(0x6161616c)
offset = cyclic_find(eip_value)  # Finds the offset of the sequence in the De Bruijn pattern
print(f"The offset is: {offset}")

ou GEF :

#Patterns
pattern create 200 #Generate length 200 pattern
pattern search "avaaawaa" #Search for the offset of that substring
pattern search $rsp #Search the offset given the content of $rsp

Exploiter les débordements de pile

Lors d'un débordement (en supposant que la taille du débordement est suffisamment grande), vous pourrez écraser les valeurs d'autres variables à l'intérieur de la pile jusqu'à atteindre l'EBP et l'EIP (ou même plus). La manière la plus courante d'exploiter ce type de vulnérabilité est en modifiant le pointeur EIP afin que lorsque la fonction se termine, le flux de contrôle soit redirigé où l'utilisateur l'a spécifié dans ce pointeur.

Cependant, dans d'autres scénarios, peut-être que simplement écraser les valeurs de certaines variables dans la pile pourrait suffire pour l'exploitation (comme dans les défis CTF faciles).

Ret2win

Dans ce type de défis CTF, il y a une fonction à l'intérieur du binaire qui n'est jamais appelée et que vous devez appeler pour gagner. Pour ces défis, vous devez simplement trouver le décalage pour écraser l'EIP et trouver l'adresse de la fonction à appeler (généralement ASLR serait désactivé) afin que lorsque la fonction vulnérable retourne, la fonction cachée sera appelée :

Ret2win

Shellcode de pile

Dans ce scénario, l'attaquant pourrait placer un shellcode dans la pile et exploiter l'EIP contrôlé pour aller au shellcode et exécuter le code de l'attaquant :

Stack Shellcode

ROP

Cette technique est le cadre fondamental pour contourner la principale protection de la technique précédente : Pas de pile exécutable. Et elle permet d'exécuter plusieurs autres techniques (ret2lib, ret2syscall...) qui finiront par exécuter des commandes arbitraires en exploitant des instructions existantes dans le binaire :

ROP - Return Oriented Programing

Types de protections

Il existe plusieurs protections visant à empêcher l'exploitation des vulnérabilités, consultez-les ici :

Common Binary Protections & Bypasses
Apprenez le piratage AWS de zéro à héros avec htARTE (HackTricks AWS Red Team Expert)!

Autres façons de soutenir HackTricks :

PreviousLinux Exploiting (Basic) (SPA)NextROP - Return Oriented Programing

Last updated