Come evitare Stack Smashing Attack con GCC

Stack smashing è un termine di fantasia usato per gli overflow del buffer dello stack. Si riferisce ad attacchi che sfruttano i bug nel codice che abilitano gli overflow del buffer. In precedenza era esclusiva responsabilità dei programmatori/sviluppatori assicurarsi che non ci fosse la possibilità di un buffer overflow nel loro codice, ma con il tempo i compilatori come gcc hanno dei flag per assicurarsi che i problemi di buffer overflow non vengano sfruttati dai cracker per danneggiare un sistema o un programma.

Sono venuto a conoscenza di questi flag quando stavo cercando di riprodurre un buffer overflow sul mio Ubuntu 12.04 con la versione gcc 4.6.3. Ecco cosa stavo cercando di fare :

#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;
}

Nel codice sopra, ho usato gets() per accettare una stringa dall'utente. e quindi calcolata la lunghezza di questa stringa e ristampata su stdout. L'idea qui è di inserire una stringa la cui lunghezza è superiore a 10 byte. Poiché gets() non controlla i limiti dell'array, quindi proverà a copiare l'input nel buffer str e in questo modo si verificherà un overflow del buffer.

Questo è quello che è successo quando ho eseguito il programma:

$ ./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)

Bene, questa è stata una piacevole sorpresa che l'ambiente di esecuzione sia stato in qualche modo in grado di rilevare che in questo caso potrebbe verificarsi un overflow del buffer. Nell'output puoi vedere che è stato rilevato lo stack smashing. Questo mi ha spinto a esplorare come è stato rilevato l'overflow del buffer.

Durante la ricerca del motivo, mi sono imbattuto in un flag gcc "-fstack-protector". Ecco la descrizione di questo flag (dalla pagina man) :

$ gcc -Wall -fno-stack-protector stacksmash.c -o stacksmash
$ ./stacksmash 

 Enter the name
TheGeekStuff

 len = [26214] 

 len of string entered is : [12]