Modifica il codice C con vulnerabilità di buffer overflow per saltare il codice

7

Sto cercando di trovare un modo per sfruttare la vulnerabilità del buffer overflow nel seguente codice sorgente in modo che la linea, printf ("x is 1") venga saltata:

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

void func(char *str) {
     char buffer[24];
     int *ret;
     strcpy(buffer,str);
}

int main(int argc, char **argv) {
    int x;
    x = 0;
    func(argv[1]);
    x = 1;
    printf("x is 1");
    printf("x is 0");
    getchar();
}

Per fare ciò, voglio modificare la funzione "func". So che avrò bisogno di usare la variabile ret per modificare l'indirizzo di ritorno appena oltre la linea che voglio saltare, ma non sono sicuro di come farlo realmente.

Usando gdb, sono riuscito a trovare le seguenti chiamate nella funzione principale:

Temporary breakpoint 1, 0x00000000004005ec in main ()
(gdb) x/20i $pc
=> 0x4005ec <main+4>:   sub    $0x20,%rsp
   0x4005f0 <main+8>:   mov    %edi,-0x14(%rbp)
   0x4005f3 <main+11>:  mov    %rsi,-0x20(%rbp)
   0x4005f7 <main+15>:  movl   $0x0,-0x4(%rbp)
   0x4005fe <main+22>:  mov    -0x20(%rbp),%rax
   0x400602 <main+26>:  add    $0x8,%rax
   0x400606 <main+30>:  mov    (%rax),%rax
   0x400609 <main+33>:  mov    %rax,%rdi
   0x40060c <main+36>:  callq  0x4005ac <func>
   0x400611 <main+41>:  movl   $0x1,-0x4(%rbp)
   0x400618 <main+48>:  mov    $0x4006ec,%edi
   0x40061d <main+53>:  mov    $0x0,%eax
   0x400622 <main+58>:  callq  0x400470 <printf@plt>
   0x400627 <main+63>:  mov    $0x4006f3,%edi
   0x40062c <main+68>:  mov    $0x0,%eax
   0x400631 <main+73>:  callq  0x400470 <printf@plt>
   0x400636 <main+78>:  callq  0x400490 <getchar@plt>
   0x40063b <main+83>:  leaveq
   0x40063c <main+84>:  retq
   0x40063d:    nop

Anche se, sono confuso da dove andare da qui. So che la funzione tornerà alla linea di 0x400611 e che ho bisogno di farlo saltare a 0x400631, ma non sono sicuro di come determinare quanti bit saltare. Ho cercato di seguire l'esempio 3 da insecure.org/stf/smashstack.html, ma mi sono perso quando ho capito quanti bit aggiustare la mia variabile. Qualche aiuto?

    
posta user2276280 16.04.2015 - 03:36
fonte

2 risposte

4

Come hai già identificato dovrai tornare all'indirizzo 0x400631. Quando rompi lo stack con il tuo argomento, dovresti controllare EIP. Vale a dire:

./a.out AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Dovresti vedere EIP di 0x41414141. Ora è necessario determinare in quale punto della pila di A si trovano i 4 byte che diventano EIP. Puoi usare strumenti come metrile_create.rb / pattern_offset.rb di metasploit o dato che è un buffer così piccolo che puoi farlo manualmente:

./a.out AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPPQQQQRRRRSSSSTTTT

E in base all'indirizzo di EIP ora puoi determinare se è A (x41), B (x42), C (x43), ecc. Questo ti dirà quanti byte devi mettere prima di \ x31 \ x06 \ x40 \ X00. Questo non è certo un exploit affidabile in quanto l'indirizzo di ritorno è hardcoded, ma sarà sufficiente per il tuo esempio di apprendimento.

    
risposta data 16.04.2015 - 06:07
fonte
-2

mentre non sono d'accordo con il tuo piano,

il modo per saltare un'istruzione è modificare il valore del registro pc dei chiamanti, che viene salvato nello stack delle funzioni chiamate

Quindi saltare un'istruzione è piuttosto semplice, perché le dimensioni dell'istruzione (nelle moderne CPU) è relativamente coerente.

Tuttavia saltare una riga di codice C è un problema completamente diverso perché la linea potrebbe contenere un numero qualsiasi di istruzioni.

Un numero di istruzioni che possono cambiare in base ai parametri del compilatore come il livello di ottimizzazione.

    
risposta data 16.04.2015 - 05:21
fonte

Leggi altre domande sui tag