Overflow (Basico) By Taul

Iniciado por ANTRAX, Marzo 30, 2012, 12:28:13 PM

Tema anterior - Siguiente tema

0 Miembros y 1 Visitante están viendo este tema.

bueno les intentare explicar simple,pero entendible como funciona un exploit overflow en la pila.

overflow: es el desbordamiento del buffer...un ejemplo...guardamos espacio para un nombre de 8
letras...pero luego le metemos 14 letras...el buffer solo almacena 8 letras lo demas desborda
y sobrescribe la pila..probocando la posibilidad de ejecutar codigo arbitrario.

lo primero es lo primero "LA PILA": (stack)
Es facil de entender solo presten atencion...
olvidense de la pila que conocen aca no existe ninguna duracell ni everedy.
es simplemente un lugar que le permite a los sistemas operativos manejarse..van entendiendo?
por ejemplo si yo quiero sumar 2 numeros el 8 + 4 entra en accion la pila...de este modo:

numero 8 es = "argumento 1"
numero 4 es = "argumento 2"

La pila...."ultimo en entrar primero en salir".

ESP     | RET ADDRESS   |  EBP <---despues de ejecutar la suma sigue esto (mostrar por pantalla)
ESP     | argumento 1   |  EBP
ESP     | argumento 2   |  EBP

como vemos en la pila entro el argumento 2 primero y luego el argumento 1.y despues llama a suma.
(en este caso con el resultado solo lo mostrara por pantalla).(retorna).
ahora les explico detalladamente que es cada cosa

ESP <----significa la cima de la pila.
EBP <----es la base de la pila (el fondo).
EIP <----proximo a ejecutar.(lo aclaro por las dudas).

bien ya sabemos como trabaja la pila ahora vamos a aprobecharnos.jejeje.

por empesar vemos la pila (suponiendo que use un programa y que lo cerre).

ESP     | (programa que use)                      | EBP
ESP     | RET ADDRESS                             | EBP <--el EBP esta aqui
ESP     | argumento 1 de suma                     | EBP
ESP     | argumento 2 de suma                     | EBP

espero que vayan entendiendo.

*******************
*EXPLOIT OVERFLOW:*
*******************

#include <stdio.h>

int main (int argc, char **argv){

   char buffer[64];
   if (argc < 2){
      printf ("Introduzca un argumento al programa\n");
      return 0;
        }
   strcpy (buffer, argv[1]);

   return 0;
}


continuemos...ahora empesemos a analisar lo que hace el exploit.
1)..........................................................................................
#include <stdio.h>  // librería stdio.h

2)..........................................................................................
int main (int argc, char **argv){  // La función "principal"

3)..........................................................................................
char buffer[24];//declaramos un array de 24 bytes...(guarda espacio en la pila).

ESP     | (bytes guardados)      | EBP <--guarda 24 bytes.
ESP     | (programa que use)     | EBP
ESP     | RET ADDRESS            | EBP 
ESP     | argumento 1 de suma    | EBP
ESP     | argumento 2 de suma    | EBP

4)..........................................................................................
if (argc < 2){  //argumentos menores que 2.

5)..........................................................................................
printf ("Introduzca un argumento al programa\n"); //argumentos que le meteremos

6)..........................................................................................
return 0;  // y retornamos 0 a la función main,(hasta aca es normal).
}

7)..........................................................................................
strcpy (buffer, argv[1]); //gracias a esta amada y hermosa funcion se proboca el overflow.
return 0;  // Devolvemos 0 a main, y se termina el programa.
}

y ahora les explico porque...en el paso 3 guardamos 24 bytes en la pila.
osea que podemos meter 24 caracteres en el buffer y no pasara nada.
pero que pasaria si llegaramos a meter mas de 24 bytes?
un ejemplo: si metieramos un argumeto TAULLLLLLLLLLLLLLLLLLLLLLLLLLLLL.
en el buffer entraria solamente TAULLLLLLLLLLLLLLLLLLLLL <---osea 24 caracteres.
pero que pasaria con las LLLLLLLL? pues sobrescribiran la pila...probocando un overflow.
y quien es la maquina que mete los argumentos al buffer?
la tan amada funcion "" strcpy (buffer, argv[1]);"".

bien...si metemos TAULLLLLLLLLLLLLLLLLLLLLLLLLLLLL a la pila se veria asi.

ESP   | TAULLLLLLLLLLLLLLLLLLLLL | EBP <-- se ocupan los 24 caracteres.
ESP   | (programa que use) LLLL  | EBP <-- las LLLL sobrescribieron la pila.
ESP   | RET ADDRESS    LLLL      | EBP <-- las ultimas 4 LLLL terminaron sobrescribiendo el retorno.
ESP   | argumento 1              | EBP
ESP   | argumento 2              | EBP

siiiiiiii....¡¡¡¡¡¡logramos lo que queriamos sobrescribir el retorno...
ahora nos saldra error cuando lo ejecutemos...porque intentara ejecutar las LLLL...xD.
que locura no queremos eso verdad??? queremos que ejecute una shell "cmd.exe".
pues este texto es solo para entender los overflow...luego hare otro texto sobre como sacar la
shellcode (opcode) + offset para crear un exploit util.espero que hayan entendido
y sino le entendieron me dicen y les hago una obra de teatro xD.

PD: no espesifique los bytes en la pila por que es un ejemplo para que entiendan
y no se le haga tanto lio.

SALUDOS...taul.


Voy entendiendo un poco mas sobre esto, gracias.
Saludos 4L3X.