Verificando ciertos temas recientes en los que he participado en gran parte

Reto para los Hackers

duda al seguir texto "Smashing The Stack For Fun And Profit"

No puedo sobrescribir EIP (Linux)

He decidido hacer un manual del uso del gdb para el reconocimiento de vulnerabilidades, y el mejor conocimiento de lo que hace nuestro hardware.

Aclarando no soy un experto en la materia, sin embargo tengo experiencia con estas cosas y la verdad que me gusta ayudar.

Bueno lo principal hay que hacer antes que nada es conseguir la documentacion oficial

http://sourceware.org/gdb/documentation/

Cabe mencionar tambien la existencia de verciones modificadas de GDB, las cuales puenden hacer que este trabajo se vea mas facil o bonito cabe mencionar algunos de los mas populares:

• cgdb gdb en terminal, pero con colores usando ncurses
• xxgdb gdb en modo Grafico sencillo y carismatico

Alguna duda de como Instalarlos me avisan y lo pongo en otro post


El siguente texto es esencial muchos manuales se basan en el, y el analisis de las Vulnerabilidades son casi exactamente lo mismo que otros textos de Lectura Obligada, que hay por la red asi que leer el siguiete texto

Smashing The Stack For Fun And Profit

Lo siguente esta realizado sobre una Maquina con FreeBSD, con arquitectura x86 clasica, y es muy parecido a los resultados que nos mostraria cualquier distro de linux, o cualquier sistema "like UNIX".

Todo lo aqui mostrado varia dependiendo del Sistema, Version del (kernel/gcc/gdb) que usemos.

Primeramente para los que no saben mucho del tema recomiendo buscar informacion sobre el mismo, no es un post de ensamblador ni mucho menos. solo es como usar el gdb (para/y) (analizar/el analisis) ( /de) programas vulnerables.

---

Importante
Hay que mencionar que la mayoria de los códigos aqui mostrados se compilan para que incluyan informacion de depuracion


o con lo mismo pero con las funciones llamadas compiladas estaticamente

---

Bien primeramente veremos como reconocer que es normal y que no es normal.

xgdb_001.c

int main()	{
	return 0;
}

ejecutamos gdb con el archivo binario como parametro


Despues de esto ejutamos un disassemble, o mas abreviado un disas, sinceramente no tengo la mas remota idea de porque en mi FreeBSD hace un chingo de madres despues del prologo, procedure prolog



para mi hubiese bastado con lo siguente, sin embargo que mas le hacemos!



Bien lo que nos hubiese dado el disas main, es lo normal que nos debe de aparecer, en nuestro sistema.

Analizare aqui, algunos códigos de Smashing The Stack For Fun And Profit, y otros mas sencillos y complejos para verificar lo aprendido.

Primeramente en el sistema donde estemos debemos de identificar las zonas de memoria en las que vamos a trabajar.

Code
Data
Stack
Heap

ya en ejecucion hay poca diferencia entre la 4, solo es neceario identificar 2 tipos de regiones, y tratar de subdividirlas mentalmente o por lo menos tenerlas presentes..

xgdb_001.c

char *cadena="Variable Global, definida";
 
int main()	{
	int a;
	return 0;
}

Bien, en nuestro sistema, como en el de la mayoria de ustedes, la region del stack esta claramene en el rango de memorias que nos dio, generalmente < 0xbfffffff por ejemplo 0xbfbfe924, Estas direccions son las direcciones que nos ofrece el sistema operativo, mas no son direcciones fisicas...

El code, data, y el heap generalemen > 0x8000000, por ejemplo 0x80481b4 etc en mi caso.

He estado en equipos con muchas medidas de seguridad instaladas como la ejecucucion desde la pila desabilidada, y librerias como libsafe entre otras, esto es bueno, sin embargo si tu las tienes instaladas es posible que no te aparescan los mismos resultados que ami.

Bien ya conocidas los tipos de direcciones que tenemos disponibles podemos analizar ya nuestros códigos.

pintar.c

#include<stdio.h>
 
int main(int argc,char **argv)  {
        if(argc<2)      {
                printf("Se esperaban Parametros!!\nUso:\n\t%s <algo>\n",argv[0]);
                exit(0);
        }
        else    {
                char cadena[1024];
                strcpy(cadena,argv[1]);
                printf("Usted paso como parametro lo siguiente:\n\n%s\n",cadena);
        }
        return 0;
}

El clasico BOF, el cual use para poner un reto hace unos dias descrito en el post Reto para los Hackers

Muchas veces con solo ver un código sencillo en este caso es sufuciente para ver si es o no vulnerable. Sin embargo para los usuarios que usaron el gdb sin exito o con el, lo analizare aqui para mostrar que es lo que se busca exactamente.



Bien en primera instancia, con list, se puede obtener el código fuente.


con break 10, de decimos al programa que ponga un breakpoint. en determiada linea del código.


El programa lo ejecutamos con un parametro de 1024 bytes, justo el espacioque tiene el buffer.



Si verificamos la que hay de interesante en la pila con bt y vemos que solo estan las direcciones del parametro que pasamos, y cerca de ahi esta el sp, y el ret, el cual nos interesa sobrescribir.


Depues de ejecutar next nos informa que esta por ejecutar el printf, lo que nos indica que ya se ejecuto el strcpy, vemos nuevamente la pila, y todo sigue bien, ya que el buffer que le metimos no sobrescrio nada.


Bien vemos que esto esta bien, y no salio error.



Ahora vemos que nuestro breakpoint sigue activo, y ademas que le hemos paso 1600 bytes como parametro.


Vemos que sobreescribimos un monton de datos... xD


Sin embargo si solo mandamos 1600 bytes por que en la posicion  0xbfbfe510, todavia encontramos nuestras letras A, bueno eso sera otro tema.


Lo interante es que hemos sobre escrito el retorno con mucho exito. y el programa trato de saltar a la dieccion de memoria 0x41414141, el cual nos informa que es una direccion incorrecta.
tendriamos que insertar la direccion del código que queramos ejecutar.

Pues como vemos sobre escribimos el ret de main y un muchos datos mas, bueno por hoy le dejo.

Bien, para seguir con el uso de GBD vamos a analizar una version modificada de un codigo que hice para probar una idea loca que se me vino a la mente en ese momento para mas informacion ver  BoF en inet_network(), afecta a Servidor DNS: BIND.

El codigo es el siguiente:

int main()	{
	unsigned long prueba;
	long i;
	prueba = 1;
	i = 0;
	while(i < 32)	{
		printf("Prueba[%i]: %u\n",i+1,prueba);
		i++;
		prueba = (prueba << 1);
	}
	return 0;
}
 

Como vemos es una aplicaion sencilla sin embargo tiene lo necesario para poder identificar ciertos valores y funciones.


En los ejemplo posteriores no pondre ya el comando list, el cual nos lista el codigo Fuente de un archivo binario en caso de que este este compilado con la opcion -ggdb

Cabe mencionar que vamos a tener un reencuentro con el Ensamblador para verlo paso por paso.


Bien desensamblamos la funcion main, que es Practicamente toda nuestra funcion xD.

Olvidandonos del Procedure Prolog y Procedure Epilog. que ya lo vimos en un post Anterior a este

Ahora el siguente codigo sinceramente no se por que lo hace pero me imagino que es para alinear la pila o algo asi :/ asi que si alguien lo puede explicar recibiremos su aporte con gusto, en caso contrario yo lo explicare cuando pueda.


Nos quedamos con un codigo en ASM en Modalidad AT&T, ya saben de eso me imagino y si no buscar en google.

prueba = 1;

i = 0;

Esta es la comparacion que se realiza en el while (i < 32)

En caso de que no se cumpla saltamos a esa direccion. al return 0;


Esta accion reserva 4 bytes a la Pila para despues meter las variables usadas en por el printf

Ponemos en la pila, el valor de la Variable Prueba

El valor de la variable i es pasado a un registro del microprocesaro y posteriormente Incrementado.

Una vez Incrementado lo Agregamos a la Pila

Ingresamos la Direccion de la Cadena "Prueba[%i]: %u\n" en la pila.

Llamamos a printf con todos los parametros metidos en la pila.

Recuperamos parte del espacio que reservamos en la pila

asignamos a eax la direccion en memoria de la variable i

Incrementamos el valor en 1.

asignamos a eax la direccion en memoria de la variable Prueba

recorrimiento de bits a la derecha de una variable long

Regresamos a la compracion para que si sea un while

Movemos 0 al registro eax, para que se cumpla el return 0;

Si vemos el valo de la variable Prueba, vemos que este aumenta en potencias de 2 en cada iteracion.
Si lo vemos en binario veriamos algo asi

00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000100
...
10000000000000000000000000000000

Bueno como lo mensione antes este ejemplo lo realize con la intencion de ver si al hacer el recorrimiento de bits era capaz de sobreescribir en la memoria que no le correspondia a la variable, pero inmediatamente despues recorde que esto se hace en el micro uno esta deseperado por ideas a la hora de tratar de encontrar un bug. Sin embargo se me hizo buen ejemplo para ponerlo aqui y ver paso un ejemplo sencillo de programacion.