ASM Y Buffer Overflows

-[ 0x08 ]--------------------------------------------------------------------

-[ ASM y Buffer Overflows ]--------------------------------------------------

-[ by Doing ]---------------------------------------------------------SET-21-

Asm y buffer overflows

------------------------

By Doing

------------------------

<jdoing@hotmail.com>

Bueno, por fin me he decidido a escribir un articulo para SET, espero que

lo encontreis interesante. Seguro que muchos de los hackers newbies que

ahora estan descubriendo el mundo del hacking habran oido hablar de los

tan famosos exploits, pero todavia no saben que hacen, ni como funcionan;

pues para eso escribo este co~azo.

Para entender esto te ayudara saber algo de C o ensamblador pero no es

indispensable. Voy a empezar explicando que #"@% es eso del stack.

==> El stack (o pila) <==

El stack es una region de memoria que las funciones usan para guardar sus

variables locales y para guadar temporalmente el contenido de los registros

del procesador (por ejemplo, cuando se llama a una funcion, los parametros

se pasan por el stack). El segmento de stack se guarda en un registro del

procesador, el SS. Tambien existe un registro que apunta al lugar en donde

se encuentra la "pila". La pila se usa para guardar temporalmente el

contenido de los registros (eso ya lo he dicho antes). Para guardar el

contenido de un registro en la pila se usa la instruccion push, y para

recuperar el ultimo dato almacenado en la pila su usa la instruccion pop.

Vamos a poner un ejemplo:

Esto es un segmento de stack:

0x00 0xFFFFFFFF

SS ==> [0000000000000000000000000[VAR1][VAR2][SBP][RET][ARGV1][ARGV2]...]

^

STACK POINTER

Como veis, nada mas llamar a una funcion, el ESP se encuentra justo detras

de la ultima variable declarada. Cuando usamos push, guardamos el dato desde

la posicion del ESP hacia ATRAS, y el ESP de decrementa en tantos bytes como

tenga nuestro dato.

Vamos a suponer que guardamos en la pila el reg EAX (4 BYTES)

pushl %eax (La "l" despues de push quiere decir que el operando ocupa 32 bits)

El segmento de antes quedaria asi:

0x00 0xFFFFFFFF

SS ==> [000000000000000000000[EAX][VAR2][VAR1][SBP][RET][ARGV1][ARGV2]...]

^

STACK POINTER

Ahora vamos a recuperarlo en otro registro:

popl %ebx

En este momento el ESP se incrementa en tantos bytes como tenga nuestro dato,

asi que se queda como al principio, usease, como antes de hacer el ultimo

push. Con esto se puede deducir una cosa: los datos que vas sacando de la

pila salen en orden inverso al que fueron introducidos. En jerga "tesnica"

se dice que la pila es una estructura LIFO (Last In, First Out).

Acabais de ver como el procesador accede a la pila, creo haber dicho que el

stack tambien se usa para acceder a las variables locales, pero, comorr?.

Para acceder a memoria necesitamos dos cosas: segmento y despazamiento. Bien,

el segmento ya lo tenemos, el SS, y el offset (NOTA: offset = desplazamiento)

se guarda (seguro que ya lo habeis adivinado ;) en otro registro, el EBP.

El EBP apunta al comienzo de la primera variable declarada.

Volvamos otra vez al segmento de antes:

0x00 0xFFFFFFFF

SS ==> [0000000000000000000000000[VAR2][VAR1][SBP][RET][ARGV1][ARGV2]...]

^ ^

ESP EBP

Vamos a poner otro ejemplo:

void ejemplo(char *argumento){

char buff[4];

}

void main()

{

char *VAR_MAIN;

ejemplo(VAR_MAIN);

}

Compilemos el codigo:

$ gcc ejem.c -o ejem

...