Stack Smashing est un terme fantaisiste utilisé pour les débordements de tampon de pile. Il fait référence à des attaques qui exploitent des bogues dans le code permettant des débordements de tampon. Auparavant, il était de la seule responsabilité des programmeurs/développeurs de s'assurer qu'il n'y avait aucune possibilité de débordement de tampon dans leur code, mais avec le temps, les compilateurs comme gcc ont des drapeaux pour s'assurer que les problèmes de débordement de tampon ne sont pas exploités par des pirates pour endommager un système ou un programme.
J'ai pris connaissance de ces drapeaux lorsque j'essayais de reproduire un débordement de tampon sur mon Ubuntu 12.04 avec la version gcc 4.6.3. Voici ce que j'essayais de faire :
#include <stdio.h>
#include <string.h>
int main(void)
{
int len = 0;
char str[10] = {0};
printf("\n Enter the name \n");
gets(str); // Used gets() to cause buffer overflow
printf("\n len = [%d] \n", len);
len = strlen(str);
printf("\n len of string entered is : [%d]\n", len);
return 0;
} Dans le code ci-dessus, j'ai utilisé gets() pour accepter une chaîne de l'utilisateur. puis calculé la longueur de cette chaîne et imprimé sur stdout. L'idée ici est d'entrer une chaîne dont la longueur est supérieure à 10 octets. Étant donné que gets() ne vérifie pas les limites du tableau, il essaiera donc de copier l'entrée dans le tampon str et de cette façon, un débordement de tampon aura lieu.
Voici ce qui s'est passé lorsque j'ai exécuté le programme :
$ ./stacksmash Enter the name TheGeekStuff len = [0] len of string entered is : [12] *** stack smashing detected ***: ./stacksmash terminated ======= Backtrace: ========= /lib/i386-linux-gnu/libc.so.6(__fortify_fail+0x45)[0xb76e4045] /lib/i386-linux-gnu/libc.so.6(+0x103ffa)[0xb76e3ffa] ./stacksmash[0x8048548] /lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xf3)[0xb75f94d3] ./stacksmash[0x8048401] ======= Memory map: ======== 08048000-08049000 r-xp 00000000 08:06 528260 /home/himanshu/practice/stacksmash 08049000-0804a000 r--p 00000000 08:06 528260 /home/himanshu/practice/stacksmash 0804a000-0804b000 rw-p 00001000 08:06 528260 /home/himanshu/practice/stacksmash 0973a000-0975b000 rw-p 00000000 00:00 0 [heap] b75af000-b75cb000 r-xp 00000000 08:06 787381 /lib/i386-linux-gnu/libgcc_s.so.1 b75cb000-b75cc000 r--p 0001b000 08:06 787381 /lib/i386-linux-gnu/libgcc_s.so.1 b75cc000-b75cd000 rw-p 0001c000 08:06 787381 /lib/i386-linux-gnu/libgcc_s.so.1 b75df000-b75e0000 rw-p 00000000 00:00 0 b75e0000-b7783000 r-xp 00000000 08:06 787152 /lib/i386-linux-gnu/libc-2.15.so b7783000-b7784000 ---p 001a3000 08:06 787152 /lib/i386-linux-gnu/libc-2.15.so b7784000-b7786000 r--p 001a3000 08:06 787152 /lib/i386-linux-gnu/libc-2.15.so b7786000-b7787000 rw-p 001a5000 08:06 787152 /lib/i386-linux-gnu/libc-2.15.so b7787000-b778a000 rw-p 00000000 00:00 0 b7799000-b779e000 rw-p 00000000 00:00 0 b779e000-b779f000 r-xp 00000000 00:00 0 [vdso] b779f000-b77bf000 r-xp 00000000 08:06 794147 /lib/i386-linux-gnu/ld-2.15.so b77bf000-b77c0000 r--p 0001f000 08:06 794147 /lib/i386-linux-gnu/ld-2.15.so b77c0000-b77c1000 rw-p 00020000 08:06 794147 /lib/i386-linux-gnu/ld-2.15.so bfaec000-bfb0d000 rw-p 00000000 00:00 0 [stack] Aborted (core dumped)
Eh bien, cela a été une agréable surprise que l'environnement d'exécution soit en quelque sorte capable de détecter qu'un dépassement de mémoire tampon pourrait se produire dans ce cas. Dans la sortie, vous pouvez voir que le bris de pile a été détecté. Cela m'a incité à explorer comment le dépassement de mémoire tampon a été détecté.
En cherchant la raison, je suis tombé sur un drapeau gcc '-fstack-protector'. Voici la description de ce drapeau (à partir de la page de manuel) :
-fstack-protecteur
Émettez du code supplémentaire pour vérifier les dépassements de mémoire tampon, tels que les attaques par écrasement de pile. Cela se fait en ajoutant une variable de garde aux fonctions avec des objets vulnérables. Cela inclut les fonctions qui appellent alloca et les fonctions avec des tampons supérieurs à 8 octets. Les gardes sont initialisées à l'entrée d'une fonction puis vérifiées à la sortie de la fonction. Si un contrôle de garde échoue, un message d'erreur est imprimé et le programme se termine.
REMARQUE :dans Ubuntu 6.10 et les versions ultérieures, cette option est activée par défaut pour C, C++, ObjC, ObjC++, si aucun des paramètres -fno-stack-protector, -nostdlib ou -ffreestanding n'est trouvé.
Vous voyez donc que gcc a cet indicateur qui émet du code supplémentaire pour vérifier les débordements de tampon. Maintenant, la question suivante qui m'est venue à l'esprit était que je n'avais jamais inclus cet indicateur lors de la compilation, puis comment cette fonctionnalité était activée. Ensuite, j'ai lu les deux dernières lignes qui disaient que pour Ubuntu 6.10, cette fonctionnalité est activée par défaut.
Ensuite, à l'étape suivante, j'ai décidé de désactiver cette fonctionnalité en utilisant le drapeau "-fno-stack-protector" lors de la compilation, puis d'essayer d'exécuter le même cas d'utilisation que je faisais plus tôt.
Voici comment j'ai procédé :
$ gcc -Wall -fno-stack-protector stacksmash.c -o stacksmash $ ./stacksmash Enter the name TheGeekStuff len = [26214] len of string entered is : [12]
Nous voyons donc qu'une fois le code compilé avec ce drapeau puis avec la même entrée, l'environnement d'exécution n'a pas été en mesure de détecter le débordement de tampon qui s'est réellement produit et a corrompu la valeur de la variable 'len'.
De plus, si vous débutez avec gcc, vous devez comprendre les options du compilateur gcc les plus fréquemment utilisées dont nous avons parlé précédemment.