Este post es un poco más técnico que los anteriores, pero mucho más divertido. ¿Nunca te ha pasado estar jugando al Quake en red y que algunos jugadores siempre te machaquen sin remedio de forma inmisericorde? Probablemente sea porque saben exactamente dónde estás y cuándo doblarás la esquina con tu ridícula escopeta. Estos jugadores inyectan sus propios parches al juego para, por ejemplo, hacer las paredes transparentes y recibir alertas cuando otro jugador les acecha por la retaguardia.
En este post voy a darte una orientación sobre cómo hacer ingeniería inversa de aplicaciones de terceros escritas originalmente en C/C++, de las que sólo tienes en tu poder el ejecutable. Voy a introducirte a las herramientas básicas para indagar en el binario y averiguar su flujo de ejecución, y luego vamos a escribir juntos un simple pache en ansi C para interponer algunas funciones estándar en cualquier aplicación.
Este post tiene fines didácticos, pero espero que al final se te hayan ocurrido aplicaciones mucho más interesantes.
¿Que necesitamos para empezar?
Necesitamos un ordenador con una distribución de Linux y tener instalado el compilador GCC. Pero no te preocupes...
Prometo escribir otro post lo antes posible sobre el mismo tema pero en entornos Mac. Si estás interesado sobre este tema en entorno Windows, te sugiero que te dirijas aquí.
¿Que aplicación vamos a interceptar?
En linux existe una aplicación de consola muy curiosa, llamada fortune, que imprime por pantalla una cita famosa al azar. Vamos a indagar y reemplazar tres funciones de este programita para saber la memoria que reserva y los ficheros que abre. Si no tienes fortune en tu distro, instálalo. Pero tampoco te apures mucho, el parche que vamos a desarrollar es genérico y funcionará en cualquier ejecutable desarrollado en C/C++.
arturo@firecracker $ fortune
Así como los ojos de los murciélagos se ofuscan a la luz del día, de la misma manera a la inteligencia de nuestra alma la ofuscan las cosas evidentes.
-- Aristóteles. (384-322 A.C.) Filósofo griego.
Herramientas útiles
Las siguientes herramientas son muy útiles para hacer ingeniería inversa de un ejecutable. No vamos a utilizarlas todas para nuestro ejemplo pero me gustaría presentártelas para que puedas juguetear con ellas de ahora en adelante. Si tomas el hábito de inspeccionar aplicaciones como quien se fija en chicas por la calle, aprenderás mucho y tu curiosidad crecerá cada vez más.
- strace es una utilidad de línea de comandos que permite monitorizar las llamadas al sistema que realiza un determinado proceso y que encontrarás disponible en cualquier distribución de Linux. Lo normal es arrancarlo junto al programa que queremos inspeccionar. Por ejemplo, para tracear fortune, lo ejecutaríamos de la siguiente manera:
arturo@firecracker$ strace /usr/games/fortune
- strings es una utilidad muy práctica que examina un fichero en busca de cadenas de texto, algo que es mucho más practico de lo que parece. Muy a menudo, cadenas 'secretas', nombres de funciones, constantes o literales importantes se revelarán a sí mismos como un exhibicionista delante de una colegiala. Inspeccionamos fortune de la siguiente manera:
arturo@firecracker$ strings /usr/games/fortune
- nm es una utilidad que imprime por pantalla todos los símbolos encontrados en un binario. Esto incluye nombres de funciones, compartidas o integradas, y en algunos casos las constantes de la aplicación. En este caso, fortune no tiene simbolos, pero otras muchas aplicaciones sí y es muy practico conocer esta herramienta.
- gdb el debuggeador de proyectos de GNU está muy equipado para la ingeniería inversa. Puedes lanzar una aplicación desde GDB y poner puntos de ruptura o incluso examinar estructuras de datos en tiempo de ejecución, pero no es la herramienta más fácil de usar de todas las que tenemos disponibles.
¿Que vamos a hacer?
Si has ejecutado la traza y strings para fortune, habrás visto que hace múltiples llamadas que podemos interceptar, entre ellas las siguientes:
- malloc reserva memoria operativa.
- free libera memoria operativa.
- open abre un fichero.
Pues bien, vamos a programar un módulo en C y a lanzar este mismo proceso con nuestro parche adherido, de forma que podamos imprimir por pantalla qué direcciones de memoria utiliza o liberay con qué ficheros trabaja a lo largo de su ejecución. Para ello, vamos a utilizar una librería de enlazado dinámico de memoria, conocida como dlsym.
¿Qué es dlsym y qué vamos a hacer con él?
El código fuente de un programa debe compilarse para generar un ejecutable y el proceso de compilación lo que hace es asignar a cada una de tus constantes y funciones -entre otras cosas- una dirección de memoria única con la que luego trabaja dentro de un espacio de ejecución delimitado. En un ejecutable, tus constantes y funciones dejan de llamarse como tal y pasan a llamarse símbolos: asociaciones de direcciones de memoria que podemos averiguar y tratar con dlsym.
Con dlsym podemos saber la dirección de memoria de un determinado símbolo, por ejemplo la función malloc(), y también podemos modificar esa dirección de memoria para que llame a nuestra propia versión de la función malloc(), que además, si queremos, puede llamar a la función malloc() original porque hemos almacenado su dirección de memoria previamente. A este proceso se le denomina interposición de funciones, y es lo que vamos a hacer a continuación.
Dicho de forma más coloquial, vamos a secuestrar la llamada de una función original del ejecutable y a espíar que parámetros recibe antes de que se ejecute. Nuestra función hará de puente entre la llamada original y la función que debería procesar esa llamada, reservándonos nosotros el derecho de conocer información que como usuarios no deberíamos saber y a tomar decisiones en función de esa información para alterar la ejecución del programa, normalmente hacia derroteros que harían al arquitecto original tirarse de los pelos.
¿Que aplicaciones tiene esto?
Tiene muchísimas utilidades además de la benévola depuración. Tantas como te puedas imaginar si te mojas un poco. Por ejemplo, si la aplicación destino fuese de mensajería, a lo mejor podríamos espíar los mensajes que están intercambiando dos personas, evitar que cierta persona reciba mensajes o incluso envíar mensajes fraudulentos haciéndonos pasar por alguien sin que ningún inocente usuario sospechase nada (en concreto, interceptar mensajes de texto suele ser muy sencillo porque es costumbre común utilizar la librería de cadenas de C para tratarlas).
Si estuviéramos jugando a un videojuego en red como Quake o Counter Strike, podríamos inyectar un parche que nos permitiese ver a través de las paredes y destrozar a nuestros oponentes. O que lanzase una alarma sonora cuando alguien se nos acerque por la espalda e incluso, para los más imaginativos, podríamos manipular qué mensajes envía nuestro cliente al servidor del juego.
Evidentemente, hay aplicaciones mucho más lucrativas e interesantes, como por ejemplo programar un motor para jugar de forma óptima al póker e inyectárselo a un cliente de juego de póker 'online'. El límite está en la imaginación de cada uno: por regla general, puedes atacar a cualquier aplicación que se ejecute en tu máquina.
Programación e inyección de nuestro parche
1.- Escribimos el código fuente de módulo
A continuación está el código fuente del módulo, es corto y lo único que hace es interponerse entre las funciones malloc(), free() y open(). De forma que abre tu editor de código favorito y escribe o pega el siguiente código. Como verás, para interponer una función tan solo debemos conocer su prototipo. Y recuerda que los programadores que no utilizan Vim van al infierno.
Esta funcionalidad se puede implementar de muchas maneras, pero la más sencilla es la siguiente.
Fichero: pi.c
#define _GNU_SOURCE
#include stdint.h
#include stdio.h
#include stdarg.h
#include dlfcn.h
/**
* Interponemos nuestra funcion open
*
* @param char* filename
* @param int flags
*/
int open(char* filename, int flags)
{
// Cojo la direccion de memoria de la funcion original y le asigno un nombre
static int (*real_open)(char*, int) = NULL;
if (!real_open)
real_open = dlsym(RTLD_NEXT, "open");
// Ejecuto el original, imprimo resultado por pantalla y devuelvo el resultado
int p = real_open(filename, flags);
fprintf(stderr, "Abrimos %s) = %i\n", filename, flags);
return p;
}
/**
* Interponemos nuestra funcion malloc
*
* @param size_t size
*/
void* malloc(size_t size)
{
// Cojo la direccion de memoria de la funcion original y le asigno un nombre
static void* (*real_malloc)(size_t) = NULL;
if (!real_malloc)
real_malloc = dlsym(RTLD_NEXT, "malloc");
// Ejecuto el original, imprimo resultado por pantalla y devuelvo el resultado
void *p = real_malloc(size);
fprintf(stderr, "Reserva de memoria (%d) = %p\n", size, p);
return p;
}
/**
* Interponemos nuestra funcion free
*
* @param size_t size
*/
void* free(void* ptr)
{
// Cojo la direccion de memoria de la funcion original y le asigno un nombre
static void* (*real_free)(void*) = NULL;
if (!real_free)
real_free = dlsym(RTLD_NEXT, "free");
// Ejecuto el original, imprimo resultado por pantalla y devuelvo el resultado
int *p = real_free(ptr);
fprintf(stderr, "Libero memoria (%p)\n", ptr);
return p;
}
2.- Compilamos el modulo
Compilamos el módulo con la siguiente instrucción. Verás que escupe un 'warning' porque reescribimos el nombre de una función estándar, pero eso no nos importa.
arturo@firecracker $ gcc -Wall -O2 -fpic -shared -ldl -o pi.so pi.c
Si todo ha ido bien, la compilación nos ha creado un objeto compartido llamado pi.so que vamos a inyectar a un programa a continuación.
3. Ejecución de una aplicación con nuestro parche
En entornos Linux, la directiva LD_PRELOAD permite lanzar un proceso obligando al sistema operativo a cargar un objeto compartido antes de la ejecución. Esto nos permite adherir nuestro parche a cualquier aplicación que queramos interceptar. Hay que tener cuidado y facilitar la ruta completa del objeto compartido, de lo contrario no funcionará. A continuación ejecuto nuestro ejemplo y de paso echamos un ojo a la salida que produce.
Verás que la salida en realidad es mucho más larga, he seleccionado solo el último segmento de la salida, que tiene todos los elementos que hemos interceptado.
arturo@firecracker $ LD_PRELOAD=/home/arturo/pi.so /usr/games/fortune
Reserva de memoria (39) = 0x8911c70
Libero memoria (0x8911c70)
Reserva de memoria (392) = 0x8911d48
Reserva de memoria (11) = 0x8911ed8
Reserva de memoria (11) = 0x8911ee8
Reserva de memoria (11) = 0x8911ef8
Libero memoria ((nil))
Reserva de memoria (19) = 0x8911f08
Reserva de memoria (19) = 0x8911f20
Reserva de memoria (6) = 0x8911f38
Libero memoria (0x8911f38)
Reserva de memoria (12) = 0x8911f38
Libero memoria (0x8911f38)
Reserva de memoria (2248) = 0x8911f38
Libero memoria (0x8911f38)
Libero memoria (0x8911f20)
Libero memoria (0x8911f08)
Abrimos /usr/share/games/fortunes/familia.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/proverbios.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/varios.fortunes-pre.dat) = 0
Abrimos /usr/share/games/fortunes/famosos.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/vida.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/refranes.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/sabiduria.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/informatica.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/humanos.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/asimov.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/leydemurphy.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/lao-tse.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/ciencia.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/poder.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/nietzsche.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/varios.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/amistad.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/arte.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/deprimente.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/sentimientos.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/pintadas.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/verdad.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/filosofia.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/libertad.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/schopenhauer.fortunes.dat) = 0
Abrimos /usr/share/games/fortunes/refranes.fortunes.dat) = 0
Reserva de memoria (352) = 0x8911f38
Reserva de memoria (52) = 0x8911d10
Reserva de memoria (44) = 0x8911c70
Reserva de memoria (44) = 0x89120a0
Libero memoria (0x8911c70)
Libero memoria (0x89120a0)
Libero memoria (0x8911d10)
Cuando el español canta, o tiene mala leche o poco le falta.
Libero memoria (0x89120d0)
Libero memoria (0x8912808)
Libero memoria (0x890e8f8)
Como verás, la ejecución normal va acompañada de nuestros mensajes de traza que nos indican todo lo que queremos saber:
Qué direcciones de memoria reserva y en qué orden. Qué direcciones de memoria libera y en qué orden. Qué ficheros abre a lo largo de la ejecución del proceso.
Sólo hemos interceptado esas tres funciones, pero podríamos haber interceptado varios cientos con la misma facilidad. Tan sólo necesitamos saber el prototipo o cabecera de la función para poder escribir nuestra propia versión y que la llamada sea transparente. Para más información sobre funciones estándar, te recomiendo que visites la referencia de C++.
Enlaces de interés:
- Inyección de código en la Wikipedia
- Documentación de Dlsym
- Como construí un bot de poker - Muy inspiracional
- Hacks de Counter StrikeReferencia C++ - Todas las funciones compartidas son interceptables facilmente
http://www.elmundo.es/blogs/elmundo/totalsiessoloapretarunboton/2011/04/01/inyeccion-de-codigo-para-dummies.html
