¿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
¿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
Básicos de microprocesadores
Encargado de realizar los cálculos de los equipos de cómputo.
ok, ok... mejor lean Wikipedia ;)
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
Registros
“Secciones de memoria” que se usan internamente en el procesador para almacenar información.
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
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.
AT&T vs NASM
AT&T NASM
CMD <origen>,<destino> # <comentario> CMD <destino>,<origen> ; comentario
%eax eax
$0x80 0x80
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
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
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
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
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]
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
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
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
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á!
OllyBDG
Immunity DBG
IDA Pro
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>
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>
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
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
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
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>
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
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>
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
Ingeniería en reversa en C#
Ingeniería en reversa en Java
¿Dónde aprender?
Programming from the ground upJonathan Bartleet
Reversing: secrets of reverse engineeringEldan Eilam
Tutorial de crackingRicardo Narvaja