Uno de los trabajos, en mi opinión, más coñazos es la recuperación/reconstrucción de código C a partir de un binario dado. Para x86 se tiene una muy buena opción como es Hex-Rays, pero no todo es x86, en muchos casos puede que querramos reconstruir un código C creado para una procesador MIPS para entender mejor un algoritmo, copiarlo, extenderlo, etc… En esos casos en los que no tenemos un decompilador maravilloso que dando F5 «nos lo hace todo» auto-mágicamente no nos queda más remedio que hacerlo a manopla y el siguiente post se va a referir a estos casos. Yo me voy a basar en MIPS pero es perfectamente aplicable a cualquier otra plataforma de procesador, como por ejemplo ARM.

Introducción

Y ahora vamos al lío. Cuando voy a reconstruir código de un procesador nuevo estos son los pasos que yo sigo:

• Obtener los manuales oficiales del fabricante del procesador para aprender como funciona la arquitectura.
• Crearme u obtener un compilador cruzado (GCC) para dicha arquitectura.
• Crear códigos en C muy básicos para empezar a averiguar como se genera el código ensamblador, es decir, las construcciones más habituales.

El tema de crear un compilador cruzado no es totalmente necesario pero si que ayuda mucho, porque de este modo sabemos exactamente como debe de quedar el resultado final y aprender a ajustarlo/corregirlo, especialmente si tenemos acceso al mismo compilador que se ha utilizado para compilar el binario a recuperar 😉 Sea como sea, lo que debemos de identificar y comprender como funciona son los siguientes aspectos y, en mi opinión, por este orden:

1. Prólogos y epílogos de función.
2. Cómo se crean variables locales, de heap y globales (cómo se reserva memoria para las variables locales, etc…).
3. Cómo se llama a funciones y como se pasan los argumentos a dichas funciones (si existen diferentes convenciones de llamadas, como funciona cada una de ellas, como y cuando se arregla la pila en caso de ser utilizada, etc…).
4. Cómo se construyen las sentencias condicionales (IF && ELSE).
5. Cómo se construyen los switches (al menos los más típicos).
6. Cómo se construyen los bucles (FOR y WHILE).

Muy breve introducción a la arquitectura MIPS

Los procesadores MIPS son RISC (Reduced Instruction Set Computer) y existen versiones de 32 y 64 bits. Los registros que se utilizan son los siguientes (extraído del artículo en wikipedia):

De esta tabla podemos aprender que los argumentos a funciones se suelen pasar por registro ($a0-$a3), que el stack pointer se representa por $sp, el frame pointer como $fp y la dirección de retorno como $ra. Además sabemos que registros del procesador son preservados cuando se llama a una función. Veamos ahora ya un código C básico y como queda su correspondiente código ensamblador:

Y el siguiente es el código ensamblador generado por un compilador cruzado para MIPS Big Endian de 32 bits:

Con este código tan básico ya hemos aprendido lo siguiente:

• Cómo se pasan los argumentos a una función (registros $a0, $a1, etc…).
• Cómo se reserva espacio para variables locales (addiu $sp, -0x30) y cuanto espacio se reserva para variables locales, por lo cual, podemos saber el tamaño de las variables locales. Excluyendo el espacio utilizado para guardar la dirección de retorno ($ra) y el framepointer ($fp).

El caso es que lo que se necesita identificar siempre, indiferentemente del procesador, es lo siguiente:

• Prólogo de la función para saber cuanto espacio se va a reservar para variables locales. También para saber que código hay que ignorar (el que no nos vale para reconstruir el código C).
• Epílogo de la función (para saber hasta donde hay que decompilar, osea, que otra parte hay que ignorar).
• Cómo se pasan los argumentos a función, como se llaman a las funciones y como se devuelve el valor retornado por la función llamada.

Empecemos a generar código C para esta función. Lo primero, sabemos que los argumentos se reciben y se pasan vía $an. También sabemos que para llamar a una función se utiliza la instrución JAL (Jump And Link) y que las variables de stack se reservan con ADDIU (Add Immediate Unsigned). El tamaño reservado para la única variable local es de 0x20 tal y como nos lo muestra el IDA. De todos modos, en MIPS, se alinea todo a 8 bytes y, si lo necesitásemos, podemos sacar el espacio real reservado para variables restando 16 (decimal) al tamaño total que se reserva (0x30-0x10 = 0x20). Bueno, ya sabemos todo lo que necesitamos para descompilar a manopla esta función tan simple, que queda como sigue:

Este código que hemos creado, aunque perfectamente válido, no es el mismo código que ha escrito el programador ya que, por ejemplo, los tipos no coinciden. Viendo la función a la que se llama podemos sacar los tipos así que, corregimos la función:

Ahora es un poco más acertado el código 😉 De hecho, quitando los nombres de variables, el código es exactamente el mismo excepto por otro leve detalle: El tamaño de la variable de stack no coincide. El motivo es que todo se alinea a 8 bytes y 20 (decimal) no es un tamaño divisible por 8 por lo que el compilador lo alinea, quedando el tamaño de la variable a otro diferente del que ha puesto el programador.

Vamos al siguiente ejemplo. En el anterior caso habíamos visto como se reservaba espacio para una variable de stack con un programita de juguete que tenía un overflow como una casa. Ahora vamos a ver ese mismo programa calcado pero con un puntero:

Para reconstruir código, por lo general, tanto el prólogo como el epílogo nos dan un poco igual (nos interesa para saber cuanto espacio se reserva para variables locales y poco más), así que, ignoramos el prólogo y empezamos donde está el código que escribió el programador. En este caso, a diferencia del anterior, se carga la dirección de la variable «var_10» en el registro «$a0» (primer argumento a función) en vez de utilizar la instrucción ADDI («add immediate») como en el caso anterior, la instrucción LW es la utilizada para esta acción, lo cual nos indica que es un puntero. Después de esto, se establece arg_0 como el 2º argumento a función y se hace un «JUMP AND LINK» a la función strcpy. Con esto ya podemos reconstruir un poquito de código:

Ala! Así de difícil ha sido esta vez. De momento ya sabemos identificar prólogos y epílogos, como se pasan argumentos a función así como identificar variables de stack y punteros. Lo que todavía no tenemos claro es como se retornan valores y demás. Vamos a ello:

En esta función en C, copiamos un buffer con un tamaño máximo y devolvemos el tamaño de la cadena. Su código ensamblador MIPS sería el siguiente:

Ahora que vamos viendo como funciona esto podemos ver que, aunque hay más código, la diferencia no es para echar cohetes: Es más de lo mismo. Se reservan 0x20 bytes de espacio para una variable de stack, se llama a la función strncpy pasándole 3 argumentos que son, respectivamente, la variable local, el primer argumento a función y el segundo argumento a función. Después, se llama a otra función (strlen) pasándole la variable de stack que habíamos creado antes. Después, simplemente restaura la pila y se pira de la función. Empecemos a crear pseudo-código aplicando ya los tipos que las funciones utilizadas nos indican que tienen que tener las variables y argumentos:

Este código es «casi» el que escribió el programador. ¿Qué es lo que falta aquí? ¿Qué es lo que no cuadra? Que se está llamando a una función (strlen) y no se hace nada con su valor de retorno. ¿O si se hace? Si volvemos a la tabla de registros que he puesto en la introducción del artículo vemos que el valor de retorno es guardado en $v0 así que, en $v0, es donde se deja el valor de retorno de una función. Pero, ¿Y dónde se está poniendo ese valor de retorno en nuestra función? Respuesta: En ninguna parte, es en la función strlen donde se está poniendo (de hecho, en los ejemplos anteriores, el valor de retorno es el de la última a llamada a una función). Sabido esto, ya podemos cambiar nuestro código C:

Este código si que es «casi» exactemente el que escribió el programador, exceptuando temas cosméticos como indentaciones y nombres de variables, claro está.

Bueno, pues hasta aquí la parte I que ya se hace demasiado largo el post. En el siguiente, sentencias condicionales, bucles y switches. Espero que os haya gustado!