Méthodologie de Base pour l'Exploitation Binaire

Reading time: 8 minutes

Informations de Base sur ELF

Avant de commencer à exploiter quoi que ce soit, il est intéressant de comprendre une partie de la structure d'un binaire ELF :

ELF Basic Information

Outils d'Exploitation

Exploiting Tools

Méthodologie de Débordement de Pile

Avec tant de techniques, il est bon d'avoir un schéma pour savoir quand chaque technique sera utile. Notez que les mêmes protections affecteront différentes techniques. Vous pouvez trouver des moyens de contourner les protections dans chaque section de protection, mais pas dans cette méthodologie.

Contrôle du Flux

Il existe différentes manières de contrôler le flux d'un programme :

• Débordements de Pile en écrasant le pointeur de retour de la pile ou le EBP -> ESP -> EIP.
• Peut nécessiter d'abuser d'un Débordement d'Entier pour provoquer le débordement.
• Ou via Écritures Arbitraires + Écrire Quoi Où pour l'Exécution.
• Chaînes de Format: Abuser de printf pour écrire du contenu arbitraire à des adresses arbitraires.
• Indexation de Tableaux : Abuser d'une indexation mal conçue pour pouvoir contrôler certains tableaux et obtenir une écriture arbitraire.
• Peut nécessiter d'abuser d'un Débordement d'Entier pour provoquer le débordement.
• bof à WWW via ROP : Abuser d'un débordement de tampon pour construire un ROP et pouvoir obtenir un WWW.

Vous pouvez trouver les techniques Écrire Quoi Où pour l'Exécution dans :

Write What Where 2 Exec

Boucles Éternelles

Un point à prendre en compte est que généralement une seule exploitation d'une vulnérabilité peut ne pas suffire à exécuter un exploit réussi, surtout certaines protections doivent être contournées. Par conséquent, il est intéressant de discuter de certaines options pour rendre une seule vulnérabilité exploitable plusieurs fois dans la même exécution du binaire :

• Écrire dans une chaîne ROP l'adresse de la fonction main ou l'adresse où la vulnérabilité se produit.
• En contrôlant une chaîne ROP appropriée, vous pourriez être en mesure d'effectuer toutes les actions dans cette chaîne.
• Écrire à l'adresse exit dans GOT (ou toute autre fonction utilisée par le binaire avant de se terminer) l'adresse pour revenir à la vulnérabilité.
• Comme expliqué dans .fini_array, stocker 2 fonctions ici, une pour rappeler la vulnérabilité et une autre pour appeler __libc_csu_fini qui rappellera à nouveau la fonction de .fini_array.

Objectifs d'Exploitation

Objectif : Appeler une Fonction Existante

• ret2win : Il y a une fonction dans le code que vous devez appeler (peut-être avec des paramètres spécifiques) afin d'obtenir le flag.
• Dans un bof régulier sans PIE et canary, vous devez simplement écrire l'adresse dans l'adresse de retour stockée dans la pile.
• Dans un bof avec PIE, vous devrez le contourner.
• Dans un bof avec canary, vous devrez le contourner.
• Si vous devez définir plusieurs paramètres pour appeler correctement la fonction ret2win, vous pouvez utiliser :
• Une chaîne ROP s'il y a suffisamment de gadgets pour préparer tous les paramètres.
• SROP (au cas où vous pouvez appeler ce syscall) pour contrôler de nombreux registres.
• Gadgets de ret2csu et ret2vdso pour contrôler plusieurs registres.
• Via un Écrire Quoi Où, vous pourriez abuser d'autres vulnérabilités (pas de bof) pour appeler la fonction win.
• Redirection de Pointeurs : Dans le cas où la pile contient des pointeurs vers une fonction qui va être appelée ou vers une chaîne qui va être utilisée par une fonction intéressante (system ou printf), il est possible d'écraser cette adresse.
• ASLR ou PIE peuvent affecter les adresses.
• Variables Non Initialisées : On ne sait jamais.

Objectif : RCE

Via shellcode, si nx désactivé ou mélangeant shellcode avec ROP :

• (Stack) Shellcode : Cela est utile pour stocker un shellcode dans la pile avant ou après avoir écrasé le pointeur de retour et ensuite sauter vers lui pour l'exécuter :
• Dans tous les cas, s'il y a un canary, dans un bof régulier, vous devrez le contourner (leak).
• Sans ASLR et nx, il est possible de sauter à l'adresse de la pile car elle ne changera jamais.
• Avec ASLR, vous aurez besoin de techniques telles que ret2esp/ret2reg pour y sauter.
• Avec nx, vous devrez utiliser un ROP pour appeler memprotect et rendre une page rwx, afin de pouvoir ensuite stocker le shellcode là-dedans (en appelant read par exemple) et ensuite y sauter.
• Cela mélangera le shellcode avec une chaîne ROP.

Via syscalls

• Ret2syscall : Utile pour appeler execve pour exécuter des commandes arbitraires. Vous devez être capable de trouver les gadgets pour appeler le syscall spécifique avec les paramètres.
• Si ASLR ou PIE sont activés, vous devrez les contourner afin d'utiliser les gadgets ROP du binaire ou des bibliothèques.
• SROP peut être utile pour préparer le ret2execve.
• Gadgets de ret2csu et ret2vdso pour contrôler plusieurs registres.

Via libc

• Ret2lib : Utile pour appeler une fonction d'une bibliothèque (généralement de libc) comme system avec des arguments préparés (par exemple, '/bin/sh'). Vous avez besoin que le binaire charge la bibliothèque avec la fonction que vous souhaitez appeler (libc généralement).
• Si compilé statiquement et sans PIE, l'adresse de system et /bin/sh ne changera pas, donc il est possible de les utiliser statiquement.
• Sans ASLR et en connaissant la version de libc chargée, l'adresse de system et /bin/sh ne changera pas, donc il est possible de les utiliser statiquement.
• Avec ASLR mais sans PIE, en connaissant la libc et avec le binaire utilisant la fonction system, il est possible de ret à l'adresse de system dans le GOT avec l'adresse de '/bin/sh' dans le paramètre (vous devrez le découvrir).
• Avec ASLR mais sans PIE, en connaissant la libc et sans que le binaire utilise la system :
• Utilisez ret2dlresolve pour résoudre l'adresse de system et l'appeler.
• Contourner ASLR et calculer l'adresse de system et '/bin/sh' en mémoire.
• Avec ASLR et PIE et sans connaître la libc : Vous devez :
• Contourner PIE.
• Trouver la version de libc utilisée (leak quelques adresses de fonction).
• Vérifier les scénarios précédents avec ASLR pour continuer.

Via EBP/RBP

• Pivot de Pile / EBP2Ret / Chaînage EBP : Contrôler l'ESP pour contrôler RET via le EBP stocké dans la pile.
• Utile pour les débordements de pile off-by-one.
• Utile comme une alternative pour finir par contrôler EIP tout en abusant d'EIP pour construire la charge utile en mémoire et ensuite sauter vers elle via EBP.

Divers

• Redirection de Pointeurs : Dans le cas où la pile contient des pointeurs vers une fonction qui va être appelée ou vers une chaîne qui va être utilisée par une fonction intéressante (system ou printf), il est possible d'écraser cette adresse.
• ASLR ou PIE peuvent affecter les adresses.
• Variables Non Initialisées : On ne sait jamais.