Custom

Premier exemple de binaire personnalisé (Pdmenu/exim) :

Téléchargez la machine pluck

Le premier exemple se concentre sur l'exploitation du binaire légitime exim-4.84-7, qui présente une vulnérabilité identifiée sous le nom de CVE-2016-1531. Cette vulnérabilité permet à un attaquant d'exécuter des commandes avec des privilèges en abusant de certaines variables d'environnement.

• Dans ce cas, lorsque nous accédons à l'utilisateur Paul, un Pdmenu lui est attribué avec certaines fonctionnalités (liste de répertoires, édition de fichiers, lancement de ping, etc.) :

• Pour échapper à ce menu, nous éditons un fichier, par exemple (etc/host) :

• Dans ce cas, vi est utilisé comme éditeur de texte :

• En consultant gtfobins, si nous filtrons par vi, nous obtenons les commandes pour sortir de Pdmenu et exécuter un shell :

• Nous filtrons les fichiers SUID et en trouvons un appelé exim :

• Avec l'outil searchsploit, nous recherchons d'éventuelles vulnérabilités pour ce binaire :

• Nous téléchargeons le script et le mettons en écoute avec python3 pour qu'il soit téléchargé depuis la machine compromise :

• Nous exécutons le script et effectivement la vulnérabilité de ce binaire est exploitée, nous obtenons ainsi un accès root :

  

Deuxième exemple (Buffer Overflow):

Téléchargez la machine Ubuntu vulnérable

Installez l'outil Peda

Le deuxième exemple concerne un dépassement de tampon (Buffer Overflow) dans un binaire personnalisé sur une machine Linux 32 bits avec des protections actives et l'ASLR activé. Dans ce cas, nous nous concentrerons sur l'exploitation d'un ret2libc dans un binaire qui a des permissions SUID et dont le propriétaire est root. À travers le dépassement de tampon, nous démontrerons comment injecter des commandes privilégiées et, par conséquent, élever les privilèges de l'utilisateur.

• Le dépassement de tampon (Buffer Overflow) consiste à écraser certains registres du système, et comme le binaire est créé par l'utilisateur et appartient au groupe root, il s'exécutera en tant qu'utilisateur privilégié :

• Le binaire appelé "custom" attend une entrée de type chaîne de caractères et lors de son exécution, rien ne se passe :

• Mais si nous introduisons une chaîne très longue, il renvoie une erreur (core dumped) :

Nous envoyons une chaîne courte de AAAAAAAA et aucune erreur n'apparaît :

• Pour analyser le binaire en profondeur, nous utiliserons l'outil gdb-peda.

• Mais si nous envoyons beaucoup de caractères, nous obtenons l'erreur suivante :

1. La première chose à faire est de déterminer le nombre total de chaînes nécessaires pour écraser le registre (EIP).

   • La première méthode consiste à utiliser un motif (pattern) qui crée une chaîne conçue spatialement (dans ce cas, 300 caractères) que nous exécutons dans le binaire :

• Dans la réponse d'EIP, nous voyons que la dernière chaîne visible est "AA8A" :

• La façon automatique de le faire est avec la commande pattern offset $eip :

• Pour vérifier cela, nous utilisons python3 en envoyant 112 caractères A plus ensuite 4B finaux :

r $(python3 -c 'print("A"*112 + "B"*4)')

• En effet, nous confirmons la taille grâce à EIP qui détecte les 4 derniers B :

1. Une fois que nous connaissons le nombre maximal de chaînes, nous vérifions l'ASLR qui va déterminer s'il y a une aléatoire dans les adresses de mémoire ou non :

   - Avec la commande suivante, nous filtrons les chaînes qui nous intéressent précisément pour exécuter le binaire 10 fois afin de voir s'il change à chaque fois et de voir si la bibliothèque C est aléatoire ou non :

Il est effectivement "aléatoire"

1. Le problème de ces binaires de 32 bits est souvent que si nous exécutons par exemple maintenant 1000 fois A et filtrons par une chaîne fixe, nous voyons qu'à chaque fois, il se répétera au moins une fois :

1. L'objectif maintenant est d'abord de trouver EIP des chaînes (system + exit + bin_sh), qui seront toujours fixes et nécessaires pour exécuter un Bash en tant que root comme dans l'exemple suivant mais en Python :

   

• Nous créons un point d'arrêt (breakpoint) pour que le flux du programme s'arrête à main :

• Nous injectons les EIP de (system/exit/bin_sh) :

  

1. Une fois que nous avons tous les éléments nécessaires, essayons d'exécuter le dépassement de tampon (Buffer Overflow), mais comme nous avons vu qu'il y a une aléatoire, nous devrons utiliser la force brute jusqu'à ce que la base_libc_addr soit égale à la valeur souhaitée :

   - Avec le suivant, nous verrons les bibliothèques qui sont en cours d'exécution (dans ce cas, libc.so) :

• Avec readelf, nous filtrons par la bibliothèque et recherchons les variables injectées avant, qui sont (exit et system) avec leurs codes :

• Et pour trouver la chaîne /bin/sh, nous faisons ce qui suit, en ajoutant un 0x00 au début :

Le script Python3 suivant va automatiser toute la force brute jusqu'à ce que base_libc_addr soit la même :

#!/usr/bin/python3

import subprocess
from struct import pack 
import sys 

offset = 112
before_eip = b"A" * 112

# ret2libc -> system + exit + bin_sh

base_libc_addr = 0xb7595000

system_addr_off = 0xb7d86db0
exit_addr_off = 0xb7d7a9e0
bin_sh_addr_off = 0xb7ea7b2b

system_addr = pack("<L", base_libc_addr + system_addr_off)
exit_addr = pack("<L", base_libc_addr + exit_addr_off)
bin_sh_addr = pack("<L", base_libc_addr + bin_sh_addr_off)

payload = before_eip + system_addr + exit_addr + bin_sh_addr

while True:
    result = subprocess.run(["sudo", "/usr/bin/custom", payload])

    if result.returncode == 0:
        print("\n\n [+] Exiting...\n")
        sys.exit(0)