Foro de elhacker.net

Buenas a todos, compañeros foreros, estoy trabajando este programa, al cual intento inyectar una shellcode:

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
 
void premio() {
	printf("El flujo de código ha sido modificado.\n");
}
 
int main(int argc, char **argv) {
	char buffer[64];
	gets(buffer);
}
 

Y genero shellcode con el siguiente comando:


Y usando el pattern match de msf, me dice que la return address está en un offset de 76 a partir del buffer. Por tanto hago lo siguiente:

[28 NOPS] + [48 PAYLOAD] + [4 RTN ADDRESS]

Para calcular la RTN address, he hecho lo siguiente (la dirección de mi buffer):

Por tanto me queda así el buffer que mando, sabiendo que la address del buffer es 0xbffff490:

Pero solamente obtengo un "Violación del segmento".

Para asegurarme que el buffer está bien calculado en tamaño, hago lo siguiente:

Sabiendo que la dirección de premio() es 0x0804844c, que he conseguido gracias a objdump.

Qué estoy haciendo mal? Abordando el problema usando la ADDR de premio(), llego a la conclusión de que la dirección de salto es incorrecta o que el payload está mal generado?

Estoy cómo loco y no sé que diablos me pasa...

Que sepas que, llevando 2 años justos sin entrar en el foro, no he podido evitar entrar al ver este post jajajaj. A mí también me comió un poco la cabeza... pero te explico lo mejor que pueda.
Lo que estás buscando con este código es sobreescribir la dirección de retorno de una función que... no tienes. A ver, que me lío. Creo que el problema es cómo lo estás enfocando. Para hacer lo que tú quieres hacer, lo que yo he hecho toda la vida ha sido sobreescribir la dirección de retorno a main () de una función llamada desde main ()... un código como:

#include <stdio.h>
 
void welldone ()
{ printf ("Campeon!!\n"); return; }
 
int yo (char *entrada)
{ char buffer [48]; strcpy (buffer, entrada); return 0;
}
 
int main (int argc, char *argv [])
{ yo (argv [1]); return 0; }
 

Main llama a yo () y le pasa el 1º argumento. Entonces yo () lo copia a un buffer con un tamaño limitado con la función strcpy () (había otra por ahí mejor que strcpy () por este tema, porque te limitaba el tamaño de las cadenas y evitaba estos problemas, pero no recuerdo cómo se llamaba...) y vuelve a main (). Ahí está la clave. Lo primero que yo hacía era sustituir la dirección de retorno a main () por la dirección de welldone (), y luego me las ingeniaba para meter de por medio la shellcode...
Espero que se entienda. Si puedo, subiré un ejemplo en un ratillo... Y el lunes subo el tutorial que dejé a medias (¿¿¿¿con 13 años????) sobre esto. No sé si realmente main () tiene ninguna dirección de retorno que sustituir! Habría que verlo... pero creo que no. Al menos no lo recuerdo así. Voy a por ese ejemplo. A ver si te vale ;)
Sagrini

Lo que te vendría muy muy bien sería echarle un vistazo (estudiártelo ENTERITO, es perfecto) a un libro que se llama "Hacking. Técnicas fundamentales" de Jon Erickson. En cualquier biblioteca estará. Te va a servir muchísimo.

_______________________________________
MODIFICO:
Aquí lo tienes. Es un post antiguo, ya me sonaba a mí de algo el problema.
http://foro.elhacker.net/bugs_y_exploits/first_bof_linux_attack_sagrini_2010_elhackernet_funciona-t317514.0.html;msg1578503#msg1578503
En ese link tienes la respuesta completa con el ejemplo para lo de llevar el flujo de la ejecución a una función que no se invoca... y en la página siguiente el ejemplo con shellcode ;)

Puede ser que haya una pequeña diferencia entre las direcciones dentro de gdb y fuera. A mi me pasó probando con kali linux. Puedes jugar con este código para ir testeando con gdb y sin él.

int reg_esp ;
 
__asm__ __volatile__ ("mov %%esp, %0"  : "=g"(reg_esp));
printf("ESP value before function: %p\n", (void *) reg_esp);
 
premio();
 
__asm__ __volatile__ ("mov %%esp, %0"  : "=g"(reg_esp));
printf("ESP value after function: %p\n", (void *) reg_esp);
 

Otra cosa que puedes probar es poner un bp en gets() e ir mirando la pila.

Muchas gracias por vuestras respuestas. De veras :P
En cuanto consiga algo, os informo a ver qué tal :P

Saludos

Comienza con Start y ve mirando la pila, esto empieza en el main, con step vas instruccion a instruccion,  a ver si lo sacamos..

(gdb) Start

(gdb) x/20x $esp

PD. Como segunda opción puedes poner un bp en gets y en el ret del gets y mirar la pila

(gdb) break gets
(gdb) disass gets
(gdb) break *address

Me he fijado que hay caracteres que no entran, por el tema de badchars. Quiero creer que estoy fallando por eso, pues como calculaba el offset donde debía caer mi rtn address modificada, al comerse parte del buffer ya no cae donde tiene que caer.

Saludos

Lo has compilado sin protecciones? puedes checkearlo con este script http://www.trapkit.de/tools/checksec.html (http://www.trapkit.de/tools/checksec.html) ./checksec.sh --file ejecutable

PD. Tienes dos epilogos de función seguidos y con esto con solo pisar un byte de EBP puedes explotarlo (a no ser que esté la cookie antes). Tienes que poner en EBP un address - 4 de la pila donde se encuentre el offset apuntando a la shellcode, porque al hacer pop %ebp, esp incrementa en 4. Un ejemplo en pequeño..

Epilogo ->  mov %ebp, %esp
                 pop %ebp
                 ret

Con el primer epilogo en pop %ebp, coges lo sobreescrito y con el segundo epilogo mueves ebp a esp. Espero que se entienda..

   shellcode            0xbfffff00                          ebp=0xbfffff04                      ret
+----------------+----------------------------------+---------------------------------+---------------+
   0xbfffff00             0xbfffff08                          0xbfffff0C