Bonsoir ou bonjours les développeurs!

Actuellement, j'expérimente avec gcc et gdb afin d'étudier plus en profondeur les éventuels problêmes que peuvent amener des buffers overflows, off-by-one et autre.
Je fais cette démarche dans un but purement éducatif. En effet, je pense que le meilleur moyen de fiabiliser, de sécuriser, ...... son application, c'est de connaître les dangers que peuvent amener les erreurs de programmation qui peuvent paraître banal pour le non initiés.

Dans cette quête éducative, je m'aperçois évidemment que gcc intègre des mécanismes de protection tel que la protection de la pile avec StackGuard et autres (depuis la 2.95 apparemment).
J'ai donc décider de désactiver ces protections pour approfondir mon étude.
Malheureusement, je me rends compte que gcc re-ordonne la pile.

Exemple sans re-arrangement de la pile :

Un code tel que :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
 
void proc (int a)
{
     char buffer[256];
     int i;
 
     // code
}
Donnerait une pile comme suit :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
-------------------    |       ^
|        a        |    |       |
-------------------    |       |
|       ret       |    |       |
-------------------    |       |
|       sfp       |    |       |
-------------------    |       |
|   buffer[255]   |    |       |
-------------------    |       |
|   buffer[254]   |    |       |
-------------------    |       |
|     ......      |    |       |
-------------------    |       |
|   buffer[0]     |    |       |
-------------------    |       |
|      i          |    |       |
-------------------    |       |
                       V       |
                     PUSH     POP
Alors que le code suivant :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
 
void proc (int a)
{
     int i;
     char buffer[256];
 
     // code
}
donnerait la pile suivante :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
-------------------    |       ^
|        a        |    |       |
-------------------    |       |
|       ret       |    |       |
-------------------    |       |
|       sfp       |    |       |
-------------------    |       |
|        i        |    |       |
-------------------    |       |
|   buffer[255]   |    |       |
-------------------    |       |
|     ......      |    |       |
-------------------    |       |
|   buffer[0]     |    |       |
-------------------    |       |
                       V       |
                     PUSH     POP

"Le problême" est qu'avec le re-arrangement de la pile par gcc, les deux codes donnent la deuxième pile (ceci est mis en place afin de protéger les variables importantes un minimum).

La commande utilisée pour compiler le code est la suivante :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
gcc -o vuln main.c -fno-stack-protector -mpreferred-stack-boundary=2
L'option -fno-stack-protector permet de désactiver certaines protections de la pile (StackGuard notament) mais pas toutes. L'option -fno-stack-protector-all n'a plus l'air de fonctionner dans les dernières versions de gcc (4.3.x).
L'option -mpreferred-stack-boundary permet de supprimer le padding que GCC ajoute (à quoi peut servir ce padding à part pour aligner les adresses?).

La question est donc la suivante :
Comment désactiver cette protection de GCC?
Y-a-t'il d'autres protection que GCC intègre si oui lesquel? et comment les désactiver?

Par ailleurs, une des documentation dans laquelle j'ai dû chercher mais pas trouver la solution à mon problême :
Gcc Option Summary

Je vous remerci d'avance pour vos réponses.

Cordialement,

kurapix