Teoria BOF

Posted on 18:30 by Xianur0

Conceptos:

EIP: es el registro que almacena la direcci0n de la siguiente instruccion que debe ejecutar el procesador. IP por instruction pointer (puntero a instruccion)


EBP: puntero a base (base pointer), apunta al elemento mas alto de la pila. la pila (stack) es una estructura de datos que utiliza el procesador para ayudarse en la o de los programas.


OllyDbg: Debugger que utilizaremos.


shellcode: es una tira de instrucciones escritas en ASM y codificadas en hexadecimal, que es usualmente lo que queremos que se ejecute una vez producida la falla.


NOP: (0x90 o \x90)instruccion en ASM que significa no operational, es decir, que no haga nada. lo nico que hace es incrementar en uno el registro de siguiente instruccion (EIP) y ejecute lo que alla­ se encuentre. En nuestro caso sirve para que el procesador examine la memoria hasta que se encuentre con nuestra shellcode.



Teoria:
Antes de Comenzar a Programar tenemos que saber la teoria:

  • Tener claro la cantidad de bytes del programa
  • Llenar el buffer y el EBP con NOPs y la shellcode
  • Identificar la direccion de retorno para ubicarla en el EIP

Primero que nada necesitamos saber el tama;o del buffer:

Citar
char buffer[58];

En este caso podemos notar que es de 58 bytes.
Por ello si se sobrepasa este numero, podria haber problemas giño...


Core Dump
Citar
Core Dump o Volcado de Memoria, es un registro no estructurado del contenido de la memoria en un momento concreto, generalmente utilizado para depurar un programa que ha finalizado su ejecucion incorrectamente. Actualmente se refiere a un archivo que contiene una imagen en memoria de un proceso determinado, pero originalmente consistir­a en un listado impreso de todo el contenido de la memoria.

Un volcado de memoria es toda la memoria utilizada por el programa instalado escrita a un archivo. El tama;o del volcado dependera del programa instalado (es igual al valor de ws_BaseMemSize en la estructura del Esclavo). Un volcado de memoria puede ser creado si la DebugKey es presionada durante la ejecucion o luego de un error si el boton CoreDump es presionado. El nombre del volcado de memoria creado sera ".whdl_memory". La ubicacion por defecto es "PROGDIR:" pero puede ser cambiada con la opcion CoreDumpPath. Cualquier fichero existente con el mismo nombre siempre sera sobrescrito. Si el programa instalado utiliza Memoria Fast adicional, sera salvada bajo el nombre ".whdl_expmem".

En otras palabras seria lo que ocurriria si sobrepasamos el tamao del buffer de la aplicacion vulnerable, que en este caso es de 58 bytes, es decir no es muy grande por lo cual con introducir 58 bytes en el char buffer causaria un core dumper.

Vamos al grano

Programe un exe con solo 10 bytes de buffer, asi que comenzemos a divertirnos:



Como podran darse cuenta el programa se murio :D, esto fue probocado ya que introduje mas bytes, que los que el buffer soportaba, por enden esto proboco un core dumper.

Sources del Programa Vulnerable:

Código:
#include 
#include 
#include 

void funcion(char *ax);

int main (int argc, char *argv[])

{
if(argc<2)
{
printf("Uso: %s cadena\x0a", argv[0]);
return 0;
}
funcion (argv[1]);
return (0);
}

void funcion (char *ax)

{
char buffer[10];
strcpy (buffer, ax);
printf ("Cadena:\n%s\n", buffer);
}

Cargamos el Archivo vulnerable con el OllyDbg:



Argumentos: AAAAAAAAAAAAAAAAAAAAAAAAAAAAA.

Le damos en



29 Caracteres y sobre escribimos 4 del EBP y 1 del EIP, es decir que se desbordo con 24.

¿Como sabemos que los sobreescribimos?
Es simple, por que A en hexadecimal es 41 giño.

Bueno el buffer se lleno con 24, el ebp se llena con 4, y el EIP tambien, por enden, serian 32 para sobrescribir el EIP en totalidad, para corroborar utilizemos otra letra:

Argumentos: AAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB



y observaremos que en el eip nos resulta 42, B en hexadecimal es 42, por enden esto corrobora que sobrescribimos el eip correctamente :D.

Lo que nos queda saber es la direccion de retorno, la direccion de retorno es a donde queremos que salte nuestro shellcode, es decir la direccion siguiente que se ejecutara en la pila.

Localizamos el Push EBP, anotamos su direccion de memoria y la invertimos, es decir en caso de ser: bffff9d0 quedar­a: d0f9ffbf y pasado a array C: \xd0\xf9\xff\xbf (en el ejemplo de una pila linux).

Ahora vamos a la accion:


Suponiendo que el buffer y el EBP se llenan con 1028 (dando un ejemplo) y que es un shellcode de 23 tendran que ser 1005 NOPs...

En orden los datos serian: 1005 NOPs, 23 shellcode, Direccion de Retorno.

Gracias Zodiac por las definiciones

0 comentarios:

Publicar un comentario

Suscribirse a: Enviar comentarios (Atom)