33
Workshop: Reverse engineering Carlos A. Lozano Vargas [email protected]

Workshop reversing

Embed Size (px)

DESCRIPTION

Workshop about reversing ;) Presented at BugCON 2012 and ENLi 2012

Citation preview

Page 1: Workshop reversing

Workshop: Reverse engineeringCarlos A. Lozano Vargas

[email protected]

Page 2: Workshop reversing

¿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

Page 3: Workshop reversing

¿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

Page 4: Workshop reversing

Básicos de microprocesadores

Encargado de realizar los cálculos de los equipos de cómputo.

ok, ok... mejor lean Wikipedia ;)

Page 5: Workshop reversing

Evolución de microprocesadores Intel

Tipo de procesador Carácteristicas

8088, 8086 Registros de 16 bits, 1 MB de 63 KB de segmentos de memoria

80286Modo protegido de 16 bits, 16 MB de 64KB de segmentos de memoria. Nuevas instrucciones

añadidas a 8088, 8086

80386 Registros de 32 bits. Modo protegido de 32 bits. 4GB de memoria direccionable

80x86 Muchas versiones: 486, Pentium, Xenon, velocidad de procesamiento aumentada

Itanium Procesador de 64 bits

Page 6: Workshop reversing

Registros

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

Page 7: Workshop reversing

Categorías de registros

Categoría Nombre Propósito

Registros generalesEAX, EBX, ECX, EDX, AX,

BX, CX, DX, AH, BH, CH, DH, AL, BL, CL, DL

Utilizados para manipular datos

Registros de segmentos

CS, SS, DS, ES, FS, GSPunteros en el código, la

pila y segmentos de datos adicionales

Registros de desplazamiento

EBP, ESI, EDI, ESPIndica el desplazamiento de

la memoria durante la ejecución de un programa

Registros especiales ZF, IF, SF, EIPUsados por el CPU para

registrar los resultados de las operaciones

Page 8: Workshop reversing

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.

Page 9: Workshop reversing

AT&T vs NASM

AT&T NASM

CMD <origen>,<destino> # <comentario> CMD <destino>,<origen> ; comentario

%eax eax

$0x80 0x80

Page 10: Workshop reversing

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

Page 11: Workshop reversing

Instrucciones básicas de ASM (2)

Sintaxis NASM Ejemplo NASM Ejemplo AT&T

jnz <destino> / jne <destino> jne inicio jne inicio

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

Page 12: Workshop reversing

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

Page 13: Workshop reversing

Modos de asignación (1)

Modo de asignación Descripción Ejemplo

Registro

Los registros guardan la información que se ha de

manipular. No hay interacción con la memoria. Ambos registros han de tener el mismo tamaño.

mov ebx, edx

Inmediato

El operando de origen es un valor numérico. Se

asume el valor decimal. Se utiliza h para hex

mov eax, 1234h

Directo

El primer operando es la dirección de memoria que se ha de manipular. Está marcada con corchetes

mov [4321h], eax

Page 14: Workshop reversing

Modos de asignación (2)

Modo de asignación Descripción Ejemplo

Registro indirecto

El primer operando es un registro entre corchetes

que guarda la dirección que se ha de manipular

mov [di], ecx

Relativo de base

La dirección efectiva que se ha de manipular se calcula utilizando ebx o ebp como valor de desplazamiento

mov edx, 20[ebx]

Relativo indexado

El mismo que Relativo de base, pero se hace uso de EDI y ESI para mantener el

desplazamiento

mov ecx, 20[esi]

Page 15: Workshop reversing

Modos de asignación (3)

Modo de asignación Descripción Ejemplo

Relativo indexado de base

La dirección efectiva se encuentra combinando los

métodos de base e indexado

mov eax, [bx][si]+1

Page 16: Workshop reversing

Básicos de GDB (1)

Comando Descripción

b función Configura un breakpoint en una función

b *mem Configura un breakpoint en una dirección de memoria

info b Muestra información sobre los puntos de interrupción

delete b Elimina un breakpoint

run <args> Ejecuta el programa con los argumentos dados

info reg Muestra información acerca del estado del registro

Page 17: Workshop reversing

Básicos de GDB (2)

Comando Descripción

stepi / si Ejecuta una instrucción máquina

next / n Ejecuta una función

bt Comando de retroceso que muestra los nombres de los stack frames

up / down Se desplaza hacia arriba y hacia abajo por los stack frames

print var / print $<reg> Imprime una variable / Imprime un registro

x /NT AExamina la memoria en la que N=número de unidades a mostrar, T=tipo de datos a motrar (x:hexs, d:dec, c:car, s:cadena, i:instrucción), A=dirección absoluta o

nombre simbollico como principal

Page 18: Workshop reversing

Básicos de GDB (3)

Comando Descripción

x /NT A

Examina la memoria en la que N=número de unidades a mostrar, T=tipo de datos a

motrar (x:hexs, d:dec, c:car, s:cadena, i:instrucción), A=dirección absoluta o nombre simbollico como principal

quit ¡Alohá!

Page 19: Workshop reversing

OllyBDG

Page 20: Workshop reversing

Immunity DBG

Page 21: Workshop reversing

IDA Pro

Page 22: Workshop reversing

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>

Page 23: Workshop reversing

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>

Page 24: Workshop reversing

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

Page 25: Workshop reversing

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

Page 26: Workshop reversing

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

Page 27: Workshop reversing

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>

Page 28: Workshop reversing

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

Page 29: Workshop reversing

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>

Page 30: Workshop reversing

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

Page 31: Workshop reversing

Ingeniería en reversa en C#

Page 32: Workshop reversing

Ingeniería en reversa en Java

Page 33: Workshop reversing

¿Dónde aprender?

Programming from the ground upJonathan Bartleet

Reversing: secrets of reverse engineeringEldan Eilam

Tutorial de crackingRicardo Narvaja