Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

Reconociendo estructuras comunes en ingeniería reversa [Parte I]

  • 3 Respuestas
  • 5413 Vistas

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

Desconectado LucaSthefano

  • *
  • Underc0der
  • Mensajes: 399
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« en: Marzo 13, 2014, 07:21:25 pm »

Cuando realizamos reversing sobre una posible amenaza tenemos que acostumbrarnos a la idea de que vamos a revisar cientos de líneas de código en un lenguaje de bajo nivel, tan solo para comprender una parte del funcionamiento. Esto puede sonar fatal y desanimar a aquellos que se están iniciando; después de todo, a mí me ocurrió cuando empecé a aprenderlo. Sin embargo, uno no tarda en darse cuenta que con un poco de práctica y las herramientas adecuadas, la ingeniería reversa no tiene por qué ser una experiencia desagradable. Por ello, en este post compartiremos una introducción a ciertos patrones que suelen verse al realizar reversing en arquitecturas x86, lo cual nos permitirá ubicarnos rápidamente y comprender mejor el código.

Sin embargo, imaginemos que ha llegado el momento de desensamblar un archivo ejecutable. ¿Ahora qué hacemos? Conocemos las instrucciones, pero… ¿empezamos a leer cada línea secuencialmente, interpretando lo que hace cada instrucción?


En la imagen anterior vemos cómo un desensamblador (IDA, en este caso) no solo nos muestra el código, sino que además nos estructura el flujo de ejecución de forma gráfica. De esta forma, resulta mucho más sencillo seguir los saltos condicionales y los posibles escenarios de ejecución dentro de una subrutina. Adicionalmente, puede accederse a un diagrama con la interconexión y jerarquía de las diversas funciones o subrutinas en el ejecutable. Esto se observa en la imagen a continuación:


Pero más allá de todas las facilidades que brindan las herramientas, hay ciertas situaciones que se repiten en la ingeniería reversa y que vale la pena destacar. Para comenzar, analizaremos el siguiente programa:


Puede observarse que es muy sencillo: el programa recibe un argumento que se almacena como número entero en una variable local y se llama a la subrutina sub con esa variable local y el conteo de argumentos en argc. Esta subrutina simplemente retorna la suma de esos dos valores. Al desensamblar el ejecutable producido por estas líneas de código, se obtiene lo siguiente:


En color rojo se marcan unas líneas que aparecen al inicio de cada rutina (main y sub) y que en general deberíamos encontrar al inicio de cualquier rutina, ya que realizan tareas de inicialización de la sección de la pila o stack correspondiente. Cuando main invoca a sub, sub debe realizar el cambio de la sección del stack de main a la sección propia de sub, guardando el valor base de main para poder restablecerlo luego; este hecho se traduce en push ebp. Luego, mov ebp, esp realiza el cambio a la sección del stack de sub. También con color rojo se marcan las líneas que invierten ese proceso una vez que la rutina ha terminado de ejecutarse: mov esp, ebp retrocede el stack pointer hasta la base, limpiando así las variables locales o cualquier otro dato innecesario que haya quedado en la pila; mientras que pop ebp restablece el puntero base a la rutina previa. Se observa que sub sólo incluye pop ebp dado que no cuenta con variables locales u otros datos que limpiar del stack. En definitiva, si vemos estas instrucciones ahora, podemos saber dónde empieza y termina una rutina, y nos resultará particularmente útil si en algún momento nos perdemos en el código.

Por último, cabe destacar que en la imagen se han resaltado distintos patrones con otros colores, que están relacionados con limpieza del stack, convenciones de llamadas a subrutinas, asignación de espacio para variables locales y manipulación de parámetros y variables. No obstante, cubriremos estas cuestiones, y otras, en la segunda parte.

Agradecimientos: Matias Porolli, Laboratorios ESET.

Saludos a todos!
« Última modificación: Marzo 13, 2014, 07:32:57 pm por Sthefano02 »

Conectado ANTRAX

  • *
  • Administrator
  • Mensajes: 5609
  • Actividad:
    100%
  • País: ar
  • Reputación 37
  • ANTRAX
    • Ver Perfil
    • Underc0de
    • Email
  • Skype: underc0de.org
  • Twitter: @Underc0de
« Respuesta #1 en: Marzo 13, 2014, 07:27:51 pm »
Que buen aporte Sthefano! y que bueno verte otra vez en el foro!
Me dejas poner este post en el blog con tus creditos?

Saludos!
ANTRAX


Desconectado LucaSthefano

  • *
  • Underc0der
  • Mensajes: 399
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« Respuesta #2 en: Marzo 13, 2014, 07:33:42 pm »
Que buen aporte Sthefano! y que bueno verte otra vez en el foro!
Me dejas poner este post en el blog con tus creditos?

Saludos!
ANTRAX

Claro que si amigo, no hay ningún problema.
Aca voy a andar.. Compartiendo un par de cosas.

Conectado Stuxnet

  • *
  • Underc0der
  • Mensajes: 261
  • Actividad:
    10%
  • Reputación 2
    • Ver Perfil
    • Devel Security
  • Twitter: _stuxnet
« Respuesta #3 en: Marzo 25, 2014, 11:10:40 am »
 :-X Excelente aporte

Esto me cae como anillo al dedo

saludos :-*

 

¿Te gustó el post? COMPARTILO!



Malware Analysis "Policia Federal" primer parte

Iniciado por torrescrack

Respuestas: 0
Vistas: 4188
Último mensaje Junio 09, 2013, 08:23:02 pm
por torrescrack
Gray Hat Python: Programación en Python para hacking e ingeniería inversa

Iniciado por dracko.rx

Respuestas: 5
Vistas: 9174
Último mensaje Abril 04, 2016, 01:55:09 pm
por noxonsoftwares
INGENIERIA INVERSA BASICA I ("Aprediendo sobre los programas")

Iniciado por CronuX

Respuestas: 0
Vistas: 2635
Último mensaje Marzo 21, 2010, 07:25:53 pm
por CronuX
Taller de Cracking desde 0 [Parte 1]

Iniciado por ANTRAX

Respuestas: 0
Vistas: 3279
Último mensaje Febrero 20, 2010, 02:34:08 am
por ANTRAX
Protección del software (Parte I)

Iniciado por CronuX

Respuestas: 7
Vistas: 5065
Último mensaje Marzo 21, 2010, 07:06:02 pm
por CronuX