Ottenere l'affidabilità di exploit quando si usa off con una sovrascrittura di framepointer su linux

13

Abbiamo un programma vulnerabile a una sovrascrittura del puntatore a un frame di un byte. Lo stack è contrassegnato come eseguibile, la macchina Linux ha disabilitato aslr, i cookie di stack sono disabilitati ed è un po 'endian standard x86.

Potremmo eseguire:

buf[256];

for(int i=0; i <=256; i++)
  buf[i] = argv[1][i];

Tuttavia, voglio mettere il mio shellcode in buf e poi saltare ad esso. Se usassi un normale overflow dello stack, potrei ottenere l'affidabilità di exploit andando in una libreria caricata che ha l'istruzione jmp $esp da qualche parte codificata, e poi metto il mio shellcode dove sono gli argomenti della funzione e così via. Ma questo non è possibile qui.

Quindi cosa fai se si tratta di un processo remoto (non puoi hardcode i valori dell'indirizzo) e hai bisogno di sfruttare l'affidabilità? L'unica cosa che mi è venuta in mente è l'allineamento dello stack in cui potremmo essere in grado di prevedere i bit bassi (forse 2 o 3 bit?).

Ho solo bisogno di conoscere il basso byte del puntatore del frame in modo da poterlo sovrascrivere con un piccolo valore di controllo eip per puntare a jmp esp e all'istruzione di esp sarebbe come un salto breve -0x80 o qualcosa del genere che.

Ho diminuito il frame pointer = > ret viene eseguito = > control eip = > point eip to jmp esp instruction = > la prossima istruzione è il salto breve -0xsomevalue execution = > il carico utile viene eseguito.

Ho pensato ad altre euristiche come scrivere il puntatore a jmp esp più e più volte nel buffer in modo che sia più probabile ottenere il controllo di eip, ma in questo modo il mio metodo di jmp -0xsomevalue non funzionerebbe più.

    
posta Rob 06.04.2013 - 00:25
fonte

2 risposte

1

Ho avuto un problema di compiti estremamente simile che ho avuto in una classe di sicurezza. L'affidabilità del tuo exploit dipende dalla grandezza del buffer. Se stai sovraccaricando un buffer particolarmente grande, allora il tuo exploit avrà maggiori possibilità di funzionare.

Ecco come dovrebbe essere strutturato il tuo sandwich di exploit:

[NOPS][Shellcode (usually about ~60 bytes)][FP overwrite]

Come sai, sarai in grado di sovrascrivere solo l'ultimo paio di bit di Frame Pointer . Questo farà sì che l'EIP punti alla tua slitta se sei abbastanza fortunato. Se hai un buffer di dimensioni 265 come nel tuo esempio, ecco come apparirebbe un buon sandwhich:

[NOPS * 150][Shellcode][FP overwrite] << FP Overwrite MUST be at index 256

Ora come ho detto, l'affidabilità del tuo exploit si baserà sulla dimensione della slitta che puoi produrre. Se il tuo buffer è di 1024 byte, allora il tuo exploit sarà molto efficiente.

Se ottieni un buon valore per la sovrascrittura di Frame Pointer, avrai molto più successo con il tuo exploit. Anche la creazione della più grande slitta possibile sarà fondamentale anche qui. Per questo exploit, è probabilmente sicuro da usare:

NOPS = (size of exploited buffer + 1) - length of shellcode - 1

semplicemente:

NOPS = (size of exploited buffer) - length of shellcode

Questo ti darà il più grande cambiamento possibile di atterraggio nella tua slitta NOP. Ora gioca solo con il valore di sovrascrittura FP e trova un valore abbastanza coerente.

informazioni utili sugli errori off-by-one:

Come funziona una nop slitta:

Ecco l'articolo che ho dovuto leggere per la mia classe, è stato davvero utile:

risposta data 16.04.2014 - 01:33
fonte
0

Creare exploit affidabili richiede tempo e pazienza e molto debugging.

Penso che quello che stai cercando sia uno slittino NOP o uno scorrevole NOP. Quando esegui il salto corto devi atterrarlo nel mezzo della diapositiva NOP, quindi l'esecuzione scorre poi attraverso i NOP al tuo shellcode.

Controlla questo sito per un'analisi dettagliata della scrittura degli exploit.

    
risposta data 24.03.2014 - 07:40
fonte

Leggi altre domande sui tag