El documento describe una charla sobre ingeniería inversa. Explica brevemente qué es la ingeniería inversa, los componentes básicos de los microprocesadores como los registros, y algunas instrucciones y conceptos básicos del lenguaje ensamblador como mov, add, push y pop. También menciona herramientas como OllyDBG, Immunity Debugger e IDA Pro que se usan comúnmente para ingeniería inversa.

1. Workshop: Reverse engineering
Carlos A. Lozano Vargas
augusto@bluemammut.com

2. ¿Quienes somos y qué hacemos?
Empresa altamente especializada en el desarrollo,
implementación y aseguramiento de tecnologías de
información.
Análisis de vulnerabilidades
Pruebas de penetración internas y
externas.
Revisión de aplicaciones (black box/white
box/cristal box)
Revisión de aplicaciones móviles (iPhone/
Android/BB)
PIA
Desarrollo Web / móvil

3. ¿Qué es la ingeniería inversa?
“Es el proceso de extraer información o pistas sobre el
diseño de algo hecho por el hombre”
- Eldad Eilam

4. Básicos de microprocesadores
Encargado de realizar los cálculos de los equipos de
cómputo.
ok, ok... mejor lean Wikipedia ;)

5. Evolución de microprocesadores Intel
Tipo de procesador Carácteristicas
Registros de 16 bits, 1 MB de 63 KB de
8088, 8086 segmentos de memoria
Modo protegido de 16 bits, 16 MB de 64KB de
80286 segmentos de memoria. Nuevas instrucciones
añadidas a 8088, 8086
Registros de 32 bits. Modo protegido de 32
80386 bits. 4GB de memoria direccionable
Muchas versiones: 486, Pentium, Xenon,
80x86 velocidad de procesamiento aumentada
Itanium Procesador de 64 bits

6. Registros
“Secciones de memoria” que se usan internamente en
el procesador para almacenar información.

7. Categorías de registros
Categoría Nombre Propósito
EAX, EBX, ECX, EDX, AX,
Utilizados para manipular
Registros generales BX, CX, DX, AH, BH, CH, DH,
datos
AL, BL, CL, DL
Punteros en el código, la
Registros de
CS, SS, DS, ES, FS, GS pila y segmentos de datos
segmentos adicionales
Indica el desplazamiento de
Registros de
EBP, ESI, EDI, ESP la memoria durante la
desplazamiento ejecución de un programa
Usados por el CPU para
Registros especiales ZF, IF, SF, EIP registrar los resultados de
las operaciones

8. Lenguaje ensamblador
Lenguaje de programación de bajo nivel. Al hacer el
reversing, en el mejor de los casos, será el lenguaje de
programación que veremos.

9. AT&T vs NASM
AT&T NASM
CMD <origen>,<destino> # <comentario> CMD <destino>,<origen> ; comentario
%eax eax
$0x80 0x80

10. Instrucciones básicas de ASM (1)
Sintaxis NASM Ejemplo NASM Ejemplo AT&T
mov <destino>,<origen> mov eax, 51h mov $51h, %eax
add <destino>,<origen> add eax, 51h addl $51h, %eax
sub <destino>,<origen> sub eax, 51h sub $51h, %eax
push <valor> push eax push %eax
pop <destino> pop eax popl %eax
xor <destino>,<origen> xor eax, eax xor %eax,%eax

11. Instrucciones básicas de ASM (2)
Sintaxis NASM Ejemplo NASM Ejemplo AT&T
jnz <destino> / jne
jne inicio jne inicio
<destino>
jz <destino> / je <destino> jz bucle jz bucle
jmp <destino> jmp fin jmp fin
call <destino> call subrutina1 call subrutina1
ret ret ret
inc <destino> inc eax inc %eax

12. Instrucciones básicas de ASM (3)
Sintaxis NASM Ejemplo NASM Ejemplo AT&T
dec <destino> dec eax dec %eax
lea <destino>,<origen> lea eax,[dsi+4] leal 4(%dsi),%eax
int <valor> int 0x80 int $0x80

13. Modos de asignación (1)
Modo de asignación Descripción Ejemplo
Los registros guardan la
información que se ha de
Registro manipular. No hay interacción mov ebx, edx
con la memoria. Ambos registros
han de tener el mismo tamaño.
El operando de origen es
un valor numérico. Se
Inmediato mov eax, 1234h
asume el valor decimal. Se
utiliza h para hex
El primer operando es la
dirección de memoria que
Directo mov [4321h], eax
se ha de manipular. Está
marcada con corchetes

14. Modos de asignación (2)
Modo de asignación Descripción Ejemplo
El primer operando es un
registro entre corchetes
Registro indirecto mov [di], ecx
que guarda la dirección que
se ha de manipular
La dirección efectiva que se
ha de manipular se calcula
Relativo de base mov edx, 20[ebx]
utilizando ebx o ebp como
valor de desplazamiento
El mismo que Relativo de
base, pero se hace uso de
Relativo indexado mov ecx, 20[esi]
EDI y ESI para mantener el
desplazamiento

15. Modos de asignación (3)
Modo de asignación Descripción Ejemplo
La dirección efectiva se
encuentra combinando los
Relativo indexado de base mov eax, [bx][si]+1
métodos de base e
indexado

16. Básicos de GDB (1)
Comando Descripción
b función Configura un breakpoint en una función
Configura un breakpoint en una dirección
b *mem
de memoria
Muestra información sobre los puntos de
info b
interrupción
delete b Elimina un breakpoint
Ejecuta el programa con los argumentos
run <args>
dados
Muestra información acerca del estado
info reg
del registro

17. Básicos de GDB (2)
Comando Descripción
stepi / si Ejecuta una instrucción máquina
next / n Ejecuta una función
Comando de retroceso que muestra los
bt
nombres de los stack frames
Se desplaza hacia arriba y hacia abajo
up / down
por los stack frames
Imprime una variable / Imprime un
print var / print $<reg>
registro
Examina la memoria en la que N=número de unidades
a mostrar, T=tipo de datos a motrar (x:hexs, d:dec,
x /NT A c:car, s:cadena, i:instrucción), A=dirección absoluta o
nombre simbollico como principal

18. Básicos de GDB (3)
Comando Descripción
Examina la memoria en la que N=número
de unidades a mostrar, T=tipo de datos a
x /NT A motrar (x:hexs, d:dec, c:car, s:cadena,
i:instrucción), A=dirección absoluta o
nombre simbollico como principal
quit ¡Alohá!

19. OllyBDG

20. Immunity DBG

21. IDA Pro

22. Hello world!
0x08048414 <+0>: push %ebp
0x08048415 <+1>: mov %esp,%ebp
0x08048417 <+3>: and $0xfffffff0,%esp
0x0804841a <+6>: sub $0x10,%esp
0x0804841d <+9>: movl $0x8048500,(%esp)
0x08048424 <+16>: call 0x804833c <puts@plt>
0x08048429 <+21>: movl $0x0,(%esp)
0x08048430 <+28>: call 0x804834c <exit@plt>

23. exit()
0x080483e4 <+0>: push %ebp
0x080483e5 <+1>: mov %esp,%ebp
0x080483e7 <+3>: and $0xfffffff0,%esp
0x080483ea <+6>: sub $0x10,%esp
0x080483ed <+9>: movl $0x0,(%esp)
0x080483f4 <+16>: call 0x8048318 <exit@plt>

24. if()
0x080483e4 <+0>: push %ebp
0x080483e5 <+1>: mov %esp,%ebp
0x080483e7 <+3>: and $0xfffffff0,%esp
0x080483ea <+6>: sub $0x20,%esp
0x080483ed <+9>: movl $0x0,0x1c(%esp)
0x080483f5 <+17>: cmpl $0x0,0x1c(%esp)
0x080483fa <+22>: jne 0x804840a <main+38>
0x080483fc <+24>: movl $0x80484f0,(%esp)
0x08048403 <+31>: call 0x8048318 <puts@plt>
0x08048408 <+36>: jmp 0x804842b <main+71>
0x0804840a <+38>: cmpl $0x1,0x1c(%esp)
0x0804840f <+43>: jne 0x804841f <main+59>
0x08048411 <+45>: movl $0x80484fa,(%esp)
0x08048418 <+52>: call 0x8048318 <puts@plt>
0x0804841d <+57>: jmp 0x804842b <main+71>
0x0804841f <+59>: movl $0x8048503,(%esp)
0x08048426 <+66>: call 0x8048318 <puts@plt>
0x0804842b <+71>: leave
0x0804842c <+72>: ret

25. for()
0x080483e4 <+0>: push %ebp
0x080483e5 <+1>: mov %esp,%ebp
0x080483e7 <+3>: and $0xfffffff0,%esp
0x080483ea <+6>: sub $0x20,%esp
0x080483ed <+9>: movl $0x0,0x1c(%esp)
0x080483f5 <+17>: jmp 0x8048411 <main+45>
0x080483f7 <+19>: mov $0x80484e0,%eax
0x080483fc <+24>: mov 0x1c(%esp),%edx
0x08048400 <+28>: mov %edx,0x4(%esp)
0x08048404 <+32>: mov %eax,(%esp)
0x08048407 <+35>: call 0x804831c <printf@plt>
0x0804840c <+40>: addl $0x1,0x1c(%esp)
0x08048411 <+45>: cmpl $0xa,0x1c(%esp)
0x08048416 <+50>: jle 0x80483f7 <main+19>
0x08048418 <+52>: leave
0x08048419 <+53>: ret

26. while()
0x080483e4 <+0>: push %ebp
0x080483e5 <+1>: mov %esp,%ebp
0x080483e7 <+3>: and $0xfffffff0,%esp
0x080483ea <+6>: sub $0x20,%esp
0x080483ed <+9>: movl $0x0,0x1c(%esp)
0x080483f5 <+17>: jmp 0x8048411 <main+45>
0x080483f7 <+19>: mov $0x80484e0,%eax
0x080483fc <+24>: mov 0x1c(%esp),%edx
0x08048400 <+28>: mov %edx,0x4(%esp)
0x08048404 <+32>: mov %eax,(%esp)
0x08048407 <+35>: call 0x804831c <printf@plt>
0x0804840c <+40>: addl $0x1,0x1c(%esp)
0x08048411 <+45>: cmpl $0xa,0x1c(%esp)
0x08048416 <+50>: jle 0x80483f7 <main+19>
0x08048418 <+52>: leave
0x08048419 <+53>: ret

27. meet.c - main(1)
0x080484e6 <+0>: push %ebp
0x080484e7 <+1>: mov %esp,%ebp
0x080484e9 <+3>: and $0xfffffff0,%esp
0x080484ec <+6>: sub $0x10,%esp
0x080484ef <+9>: mov 0xc(%ebp),%eax
0x080484f2 <+12>: add $0x8,%eax
0x080484f5 <+15>: mov (%eax),%edx
0x080484f7 <+17>: mov 0xc(%ebp),%eax
0x080484fa <+20>: add $0x4,%eax
0x080484fd <+23>: mov (%eax),%eax
0x080484ff <+25>: mov %edx,0x4(%esp)
0x08048503 <+29>: mov %eax,(%esp)
0x08048506 <+32>: call 0x8048474 <greeting>

28. meet.c - main(2)
0x0804850b <+37>: mov 0xc(%ebp),%eax
0x0804850e <+40>: add $0x8,%eax
0x08048511 <+43>: mov (%eax),%ecx
0x08048513 <+45>: mov 0xc(%ebp),%eax
0x08048516 <+48>: add $0x4,%eax
0x08048519 <+51>: mov (%eax),%edx
0x0804851b <+53>: mov $0x804860c,%eax
0x08048520 <+58>: mov %ecx,0x8(%esp)
0x08048524 <+62>: mov %edx,0x4(%esp)
0x08048528 <+66>: mov %eax,(%esp)
0x0804852b <+69>: call 0x8048398 <printf@plt>
0x08048530 <+74>: leave
0x08048531 <+75>: ret

29. meet.c - greeting(1)
0x08048474 <+0>: push %ebp
0x08048475 <+1>: mov %esp,%ebp
0x08048477 <+3>: sub $0x1c8,%esp
0x0804847d <+9>: mov 0x8(%ebp),%eax
0x08048480 <+12>: mov %eax,-0x1ac(%ebp)
0x08048486 <+18>: mov 0xc(%ebp),%eax
0x08048489 <+21>: mov %eax,-0x1b0(%ebp)
0x0804848f <+27>: mov %gs:0x14,%eax
0x08048495 <+33>: mov %eax,-0xc(%ebp)
0x08048498 <+36>: xor %eax,%eax
0x0804849a <+38>: mov -0x1b0(%ebp),%eax
0x080484a0 <+44>: mov %eax,0x4(%esp)
0x080484a4 <+48>: lea -0x19c(%ebp),%eax
0x080484aa <+54>: mov %eax,(%esp)
0x080484ad <+57>: call 0x8048388 <strcpy@plt>

30. meet.c - greeting(2)
0x080484b2 <+62>: mov $0x8048600,%eax
0x080484b7 <+67>: lea -0x19c(%ebp),%edx
0x080484bd <+73>: mov %edx,0x8(%esp)
0x080484c1 <+77>: mov -0x1ac(%ebp),%edx
0x080484c7 <+83>: mov %edx,0x4(%esp)
0x080484cb <+87>: mov %eax,(%esp)
0x080484ce <+90>: call 0x8048398 <printf@plt>
0x080484d3 <+95>: mov -0xc(%ebp),%edx
0x080484d6 <+98>: xor %gs:0x14,%edx
0x080484dd <+105>: je 0x80484e4 <greeting+112>
0x080484df <+107>: call 0x80483a8 <__stack_chk_fail@plt>
0x080484e4 <+112>: leave
0x080484e5 <+113>: ret

31. Ingeniería en reversa en C#

32. Ingeniería en reversa en Java

33. ¿Dónde aprender?
Programming from the ground up
Jonathan Bartleet
Reversing: secrets of reverse engineering
Eldan Eilam
Tutorial de cracking
Ricardo Narvaja