[C] Buffer Overflow

[-Slash]

Ciao a tutti

Sto cercando di capire come funzionano gli stack buffer overflow. Sulla rete ho trovato questo link che sembra spiegare per bene come funziona il tutto. Ad un certo punto mette questo esempio:

void function(int a, int b, int c) {
   char buffer1[5];
   char buffer2[10];
   int *ret;

   ret = buffer1 + 12;
   (*ret) += 8;
}

void main() {
  int x;

  x = 0;
  function(1,2,3);
  x = 1;
  printf("%d\n",x);
}

Secondo lui (o meglio secondo quello che ho capito) il risultato della printf dovrebbe essere 0, perchè è stato modificato il puntatore all'indirizzo di ritorno della funzione in modo da saltare l'istruzione x=1. Tuttavia a me non funziona e ritorna 1 normalmente, presumo perchè il codice è scritto per una architettura x86 mentre invece siamo passati ai 64 bit, e quindi lo sfasamento di ret è diverso. La domanda è: qual è questo sfasamento?

Prima lui diceva che buffer1 occupava 8 byte (presumo per mantenere allineato alla word il resto dello stack) ed il frame pointer occupava 4 byte. Ora teoricamente penso che buffer1 abbia la stessa dimensione, ma il frame pointer occupi 8 byte essendo l'architettura a 64 bit. Tuttavia mettendo 16 continua a non funzionare quindi deve esserci qualcosa che mi sfugge..

Su macosx inoltre il programma viene eseguito correttamente mentre su windows ritorna 1 e poi si chiude dando un errore...

[clockover]

Guarda se non mi sbaglio i compilatori riconoscono il rischio di buffer overflow e quindi ottimizzano il codice... comunque per avere una visione migliore di quello che succede genera il codice assembler e dacci uno sguardo...fallo sia per il codice compilato su win che su mac

[-Slash]

Originariamente inviato da clockover

Guarda se non mi sbaglio i compilatori riconoscono il rischio di buffer overflow e quindi ottimizzano il codice... comunque per avere una visione migliore di quello che succede genera il codice assembler e dacci uno sguardo...fallo sia per il codice compilato su win che su mac

Hai ragione, infatti bisogna usare l'opzione -fno-stack-protector per disabilitare la protezione dello stack.. Ciononostante non riesco a far funzionare nessun esempio che trovo online. Prendendo ad esempio questo codice:

#include <string.h>
 
void foo (char *bar)
{
   char  c[12];
 
   strcpy(c, bar);
}
 
int main (int argc, char **argv)
{
   foo(argv[1]); 
}

In questo semplice esempio lo stack dovrebbe essere composto da:

c - ebp - return address

Tuttavia non saprei come mettere l'input per modificare il return address e cambiare effettivamente l'istruzione in esecuzione... Forse mi sarebbe utile un debugger che mi faccia vedere lo stack passo passo come avanza (e gli indirizzi dello stack quali sono)... Esiste un qualcosa del genere?

[clockover]

Cavolo c'è gdb che è un qualcosa veramente di eccezionale anche se non proprio immediato da usare.
Comunque per come la vedo io la cosa migliore da fare è prendere il codice assembler e studiarselo per capire ancora meglio. Poi certo vedere i numeretti degli indirizzi di memoria aiuta... ma tutto sta a partire dall'assembler