soit l'attaque est réalisee en local, à l'aide d'un shell sur la machine

soit à distance (remote), à l'aide d'une connexion réseau

Mauvaise gestion d'un buffer :

for (i = 0; i < sizeof(dest_buf); i++)
{
   ...
    i++;
   ...
}
dest_buf[i] = '\0';
        

Mauvaise utilisation de fonctions standard :

strncpy(buf, input_buffer, sizeof(buf)); /* Cela ne copie pas le null byte de fin de chaîne si strlen(input_buffer) > sizeof(buf) */

strncat(buf, input_buffer, sizeof(buf) - strlen(buf)); /* ERREUR: strncat copie le null byte de fin de chaîne */
        

Mauvaise condition avec des valeurs signées :

void   foo(int size)
{
  char buf[4096];

  if (size > sizeof(buf))   /* ERREUR: si size > 0x80000000 alors le test ne marche pas */ 
    return ;
    ...
}
        

Erreur de conception qui peuvent aboutir à de mauvaises manipulations.

Les adresses de retour des fonctions sur la stack sont les valeurs de prédilection pour un pirate ! En effet, si il arrive a modifier cette adresse, alors il peut rediriger l'execution du programme vers du code arbitraire

La sauvegarde du stack frame pointeur est elle aussi dangereuse, elle permet de repositioner la stack à la fin d'une fonction. Si elle est modifiée, alors le retour de fonction de la fonction appellante ne sera pas bon (cf bullet ci-dessus)

Les structures de gestion du mémory allocator sont elles aussi dangereuses. Il est tout à fait possible de manipuler free() ou malloc() afin de lui faire écrire une ou deux valeurs là ou il faut !

Les entrée de la Global Offset Table (GOT). C'est un tableau qui est utilisé pour résoudre les addresse dynamique, tel que les adresses des fonctions partagée (libc par exemple). Si l'entrée d'une fonction qui va être appelé est remplacé par l'adresse d'un shellcode, alors il sera éxécuté lors de l'appel de cette fonction. objdump -R pour avoir l'adresse du tableau

Les destructeur (DTOR) de la libc. C'est aussi un tableau de pointeur de fonctions qui sera éxécuté à la fin du programme.

Via les parametres d'un programme

Via un file descripteur (entré standard, socket réseau)

Via les données manipulées par un programme (fichiers)

-----------------  0xffffffff
|               |
|               |
|  KernelLand   |
|               |
|               |
----------------|  0xbfffffff
|               |
|               |
|  UserLand     |
|               |
|               |
----------------   0x00000000
	

|----------------| 0xbfffffff
||--------------||
|| Path         ||
|| (/home/...)  ||
||--------------||
|| Env star     ||
||(PATH=...)    ||
||--------------||
|| Argc star    ||
||(/home/...)   ||
||--------------||
|| Envp[]       ||
||              ||
||--------------||
|| Argv[]       |--> La stack 
||              ||
||--------------||
|| Vars locals  --->  Des fonctions avant celle du main
||              ||
||--------------||
|| *Envp[]      ||
||--------------||
|| *Argv[]      ||
||--------------||
|| Argc         ||
||--------------||
|| Return addr  --->  Adresse de l'instruction suivant le call de main (cf C calling convention)
||--------------||
||    Ebp       --->  Base Pointer address de la fonction appelante
||______________||
|| Variables    ||
|| locales      ||
||   de main    ||
||______________||
|                |
|                |
|               --->  Grande zone non-allouee
|                |
|                |
|                |
||--------------||
||mmap()        |->  Librairies chargées dynamiquement par le programme
||______________||
|                |
||--------------||
||lib.so        |->  Librairies partagées
||--------------||
|                |
|                |
|                |
||--------------||
||              ||
||              |->  Le tas qui contient les zones allouées par malloc en autre.
||  Heap        ||
||______________||
|                |
|                |
||--------------||
||  Exécutable  ||
||______________||
|________________| 0x0