Wie kann ich einen Pufferüberlauf auslösen?

Ich habe eine Hausaufgabe bekommen, in der ich aufgefordert wurde, eine Funktion aufzurufen, ohne sie explizit aufzurufen, indem ich einen Pufferüberlauf verwende. Der Code ist im Grunde dieser:

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

Obwohl ich nicht sicher bin, wie ich vorgehen soll. Ich habe darüber nachgedacht, die Rückkehradresse für den Programmzähler so zu ändern, dass er direkt zur Adresse von g() weitergeht, aber ich bin mir nicht sicher, wie ich darauf zugreifen soll. Wie auch immer, Tipps werden großartig sein.

Die Grundidee besteht darin, die Rückkehradresse der Funktion so zu ändern, dass sie bei Rückkehr der Funktion an einer neuen gehackten Adresse weiter ausgeführt wird. Wie von Nils in einer der Antworten getan, können Sie ein Stück Speicher (normalerweise ein Array) deklarieren und es so überlaufen lassen, dass die Rücksendeadresse ebenfalls überschrieben wird.

Ich würde Ihnen vorschlagen, keines der hier angegebenen Programme blind zu nehmen, ohne tatsächlich zu verstehen, wie sie funktionieren. Dieser Artikel ist sehr gut geschrieben und Sie werden ihn sehr nützlich finden:

Eine Schritt-für-Schritt-Anleitung zur Pufferüberlauf-Schwachstelle

Das ist Compiler-abhängig, daher kann keine einzelne Antwort gegeben werden.

Der folgende Code wird das tun, was Sie für gcc 4.4.1 wollen. Mit deaktivierten Optimierungen kompilieren (wichtig!)

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

Ausgabe:

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

Da dies Hausaufgaben sind, möchte ich wiederholen Codesüchtiger Vorschlag zu verstehen, wie ein Pufferüberlauf tatsächlich funktioniert.

Ich habe die Technik gelernt, indem ich den ausgezeichneten (wenn auch etwas veralteten) Artikel/Tutorial zum Ausnutzen von Pufferüberlauf-Schwachstellen gelesen habe Zerschmettere den Stack für Spaß und Profit.

Probier diese:

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

oder dieses:

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

Obwohl diese Lösung keine Überlauftechnik verwendet, um die Rückkehradresse der Funktion auf dem Stapel zu überschreiben, verursacht sie dennoch g() von angerufen zu werden f() auf dem Rückweg nach main() nur durch modifizieren f() und nicht anrufen g() direkt.

Epilog der Funktion-ähnliche Inline-Assembly wird hinzugefügt f() um den Wert der Rücksendeadresse auf dem Stack so zu ändern f() wird durch zurückkehren 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;
}

Wenn Sie verstehen, wie dieser Code funktioniert, können Sie besser verstehen, wie der Stapelrahmen einer Funktion für eine bestimmte Architektur eingerichtet ist, die die Grundlage für Pufferüberlauftechniken bildet.