Jak mogę wywołać przepełnienie bufora?

Question

Mam zadanie domowe z prośbą o wywołanie funkcji bez wyraźnie nazywając ją przy użyciu przepełnienie bufora. Kod jest w zasadzie następujący:

#include <stdio.h> 
#include <stdlib.h> 

void g() 
{ 
    printf("now inside g()!\n"); 
} 


void f() 
{ 
    printf("now inside f()!\n"); 
    // can only modify this section 
    // cant call g(), maybe use g (pointer to function) 
} 

int main (int argc, char *argv[]) 
{ 
    f(); 
    return 0; 
} 

Chociaż nie jestem pewien, jak postępować. Zastanawiałem się nad zmianą adresu zwrotnego dla licznika programu, aby przejść bezpośrednio do adresu g(), ale nie jestem pewien, jak uzyskać do niego dostęp. W każdym razie wskazówki będą świetne.

Answer 1

Podstawowym założeniem jest to, aby zmienić adres powrotu z funkcji tak, że gdy funkcja zwraca jest nadal wykonywać w nowej hakera adres. Wykonane przez Nils w jednej z odpowiedzi, można zadeklarować kawałek pamięci (zwykle tablicy) i przelewać je w taki sposób, że adres zwrotny jest nadpisane jak również.

Proponuję Ci nie ślepo wziąć dowolny z programów podanych tutaj bez faktycznego zrozumienia jak one działają. Ten artykuł jest bardzo dobrze napisany, a znajdziesz to bardzo przydatne:

A step-by-step on the buffer overflow vulnerablity

Answer 2

Spróbuj tego:

void f() 
{ 
    void *x[1]; 
    printf("now inside f()!\n"); 
    // can only modify this section 
    // cant call g(), maybe use g (pointer to function) 
    x[-1]=&g; 
} 

czy to jedno:

void f() 
{ 
    void *x[1]; 
    printf("now inside f()!\n"); 
    // can only modify this section 
    // cant call g(), maybe use g (pointer to function) 
    x[1]=&g; 
} 

Answer 3

To kompilator zależne, więc żadna odpowiedź może być udzielona.

Poniższy kod będzie robić to, co chcesz na gcc 4.4.1. Skompilować z optymalizacje wyłączona

#include <stdio.h> 
#include <stdlib.h> 

void g() 
{ 
    printf("now inside g()!\n"); 
} 


void f() 
{ 
    int i; 
    void * buffer[1]; 
    printf("now inside f()!\n"); 

    // can only modify this section 
    // cant call g(), maybe use g (pointer to function) 

    // place the address of g all over the stack: 
    for (i=0; i<10; i++) 
    buffer[i] = (void*) g; 

    // and goodbye.. 
} 

int main (int argc, char *argv[]) 
{ 
    f(); 
    return 0; 
} 

Output (ważne!):

nils@doofnase:~$ gcc overflow.c 
nils@doofnase:~$ ./a.out 
now inside f()! 
now inside g()! 
now inside g()! 
now inside g()! 
now inside g()! 
now inside g()! 
now inside g()! 
Segmentation fault 

Answer 4

Ponieważ jest to praca domowa, chciałbym echo codeaddict's suggestion zrozumienia jak przepełnienie bufora faktycznie działa.

Nauczyłem się tej techniki, czytając znakomity (jeśli nieco przestarzały) artykuł/samouczek na temat wykorzystania luk w przepełnieniu bufora: Smashing The Stack For Fun And Profit.

Answer 5

Chociaż to rozwiązanie nie wykorzystuje technikę przepełnienia nadpisać adres powrotu z funkcji na stosie, to nadal powoduje g() aby uzyskać nazywane od f() w drodze powrotnej do main() tylko przez modyfikację f() i niestawienie g() bezpośrednio.

Function epilogue -jak zespół rolki dodaje f() zmodyfikować wartość adresu powrotu w stos tak, że f() powróci przez g().

#include <stdio.h> 

void g() 
{ 
    printf("now inside g()!\n"); 
} 

void f() 
{ 
    printf("now inside f()!\n"); 
    // can only modify this section 
    // cant call g(), maybe use g (pointer to function) 

    /* x86 function epilogue-like inline assembly */ 
    /* Causes f() to return to g() on its way back to main() */ 
    asm(
     "mov %%ebp,%%esp;" 
     "pop %%ebp;" 
     "push %0;" 
     "ret" 
     : /* no output registers */ 
     : "r" (&g) 
     : "%ebp", "%esp" 
     ); 
} 

int main (int argc, char *argv[]) 
{ 
    f(); 
    return 0; 
}

Zrozumienie, jak ten kod działa może prowadzić do lepszego zrozumienia jak stos ramka funkcją jest ustawienie dla danej architektury, która tworzy podstawę technik przepełnienia bufora.