Impossibile sovrascrivere il rip con l'indirizzo nel buffer overflow semplice (Ubuntu x64)

1

Ho scritto un semplice programma c per testare un buffer overflow. Il mio obiettivo è sovrascrivere lo strappo in modo che punti all'inizio del buffer.

Il codice:

#include <stdio.h>
#include <string.h>
#include <stdlib.h> 
int main(int argc, char **argv) {  
char buffer[256];   
strcpy(buffer, argv[1]);
printf("INPUT: %s\n", argv[1]);  
return 0;  
}

Quando scrivo r python -c 'print "A"*264 + "BBBBBB"' in gdb lo strappo viene sovrascritto correttamente con:

RIP: 0x424242424242 ('BBBBBB')

L'inizio del buffer è a 0x7ffffffede20. Quindi ho provato r python -c 'print "A"*264 + "\x20\xde\xfe\xff\xff\x7f"' in gdb per sovrascrivere lo strappo ma non funziona più. Questo è il contenuto di rip (copiato da gdb):

RIP: 0x7fffff050800 (<__libc_start_main+192>:                                         
add    al,BYTE PTR [rax])

Perché funziona con "BBBBBB" ma non con l'indirizzo? E ho anche provato

r 'python -c 'print "\x90"*264 + "\x08\xde\xfe\xff\xff\x7f"''

E per qualche strano motivo questo funziona di nuovo con l'indirizzo 0x7ffffffedf08. Ma non solo con quello di cui ho bisogno.

(Compilation: gcc mybof.c -fno-stack-protector -z execstack -o mybof)

    
posta Raphael Göldner 19.11.2018 - 16:06
fonte

1 risposta

0

Spiegare cosa intendi con "non funziona". Non sono in grado di commentare a causa della mia reputazione.

Ho provato a eseguire il tuo programma e ho utilizzato lo stesso exploit. L'exploit funziona bene.

Sono in grado di pensare a 2 ragioni del perché potrebbe non funzionare.

  1. Spero che tu abbia disabilitato ASLR. Anche se è disabilitato, a volte, gli indirizzi cambiano. Ma il cambiamento non sarà casuale quando ASLR è attivo. Quindi, assicurati di prenderti cura di questo.

  2. Un altro motivo per cui ritieni che non funzioni potrebbe essere il seguente:

Questo è il codice exploit nello stack (buffer):

0x7ffffffede20: 0x90909090...................9090-0x20-0xde-0xfe-0xff-0xff-0x7f-0x00-0x00

I primi 264 byte sono byte NOP. Gli 8 byte seguenti sono l'indirizzo del buffer.

Il valore RIP sarà l'indirizzo del buffer e quindi il controllo verrà trasferito all'inizio del buffer.

Ora, tutti i NOP vengono eseguiti uno dopo l'altro. Quando incontra i byte 0x20-0xde-0xfe-0xff-0xff-0x7f-0x00-0x00, questo non è più un indirizzo. Questo è solo 8 byte che saranno eseguiti . Spero che tu abbia capito questo punto. Verranno eseguiti solo se sono valide istruzioni. Se non sono validi, il programma SegFaults.

Questo è ciò che il processore ha interpretato quegli 8 byte come: (output di gdb-peda)

[-------------------------------------code-------------------------------------]
    0x7fffffffd975: nop
    0x7fffffffd976: nop
    0x7fffffffd977: nop
 => 0x7fffffffd978: jo     0x7fffffffd952
    0x7fffffffd97a: (bad)  
    0x7fffffffd97b: (bad)  
    0x7fffffffd97c: (bad)  
    0x7fffffffd97d: jg     0x7fffffffd97f
                                                             JUMP is NOT taken

Proseguendo, il programma è stato ucciso a causa dell'istruzione SIGILL - (cattiva).

Quando viene eseguito normalmente senza un debugger, viene visto come Segfault.

Questo può o non può essere il motivo.

Sarebbe davvero di grande aiuto se mostrassi un risultato di ciò che sta accadendo, perché non funziona. Possiamo scavare più a fondo e trovare la causa.

    
risposta data 29.12.2018 - 07:47
fonte

Leggi altre domande sui tag