Ejercicios Practicos: Crackmes y Samples para Aprender ASM

Aprender ensamblador leyendo no es suficiente

Los articulos anteriores de esta serie cubren la teoria: registros, instrucciones, patrones de malware, herramientas, cifrado. Pero la habilidad de leer ensamblador solo se desarrolla con practica deliberada. Necesitas sentarte frente a un binario desconocido, navegar el desensamblado, identificar funciones, renombrar variables y resolver el puzzle.

Este articulo organiza recursos de practica en una progresion logica, desde crackmes triviales hasta muestras de malware reales.

Nivel 1: crackmes basicos

Que son los crackmes

Los crackmes son programas disenados como retos de ingenieria inversa. El objetivo tipico: encontrar la contrasena correcta, generar un serial valido, o parchear el binario para que acepte cualquier input.

Son el equivalente a los kata en artes marciales: ejercicios controlados que desarrollan habilidades fundamentales sin riesgo.

Plataformas de crackmes

crackmes.one: la mayor coleccion de crackmes de la comunidad. Filtrable por dificultad (1 a 6 estrellas), plataforma (Windows, Linux, Android) y lenguaje. Empieza con dificultad 1-2 estrellas en la plataforma que uses.

begin.re: sitio educativo con crackmes progresivos acompanados de tutoriales paso a paso. Ideal para principiantes absolutos.

reversing.kr: challenges clasificados por dificultad. Algunos incluyen anti-debugging y tecnicas mas avanzadas.

Ejercicio tipo: crackme de comparacion directa

El crackme mas simple compara tu input con una contrasena hardcodeada:

; Pseudocodigo en ensamblador x86
call  read_input           ; lee la contrasena del usuario
lea   esi, [user_input]
lea   edi, [correct_pass]  ; "s3cr3tP4ss"
mov   ecx, 10              ; longitud
repe  cmpsb                ; comparar byte a byte
jne   wrong_password
; ... acceso concedido

En Ghidra o IDA:

1. Busca strings en el binario. Encuentra "Wrong password" o "Access granted".
2. Xrefs a esos strings te llevan a la funcion de verificacion.
3. Antes de la comparacion, ves la contrasena en claro o la logica para derivarla.

Solucion: la contrasena esta visible en el string referenciado por LEA EDI.

Ejercicio tipo: XOR simple

La contrasena esta cifrada con XOR de un byte:

; Descifrar la contrasena en runtime
    lea  esi, [encrypted_pass]
    mov  ecx, 8
    mov  al, 0x37
.decrypt_loop:
    xor  byte [esi], al
    inc  esi
    dec  ecx
    jnz  .decrypt_loop
; Ahora encrypted_pass contiene la contrasena en claro

Solucion: extraer los bytes cifrados, XOR con 0x37, obtener la contrasena.

Metodologia para resolver crackmes basicos

1. Cargar en Ghidra o IDA.
2. Buscar strings reveladores ("correct", "wrong", "serial", "valid").
3. Seguir xrefs hasta la funcion de verificacion.
4. Leer el decompilador para entender la logica.
5. Si hay cifrado, identificar algoritmo y clave.
6. Verificar la solucion ejecutando el crackme con la contrasena encontrada.

Nivel 2: crackmes intermedios

Anti-debugging

Crackmes de nivel medio incluyen tecnicas anti-debugging:

IsDebuggerPresent: la API de Windows mas simple para detectar un debugger.

call  IsDebuggerPresent
test  eax, eax
jnz   exit_program         ; si hay debugger, salir

Solucion: NOP la llamada o parchear JNZ a JMP (siempre continuar).

PEB check: acceso directo al Process Environment Block para leer el flag BeingDebugged sin usar la API.

mov   eax, fs:[0x30]       ; PEB en x86
movzx eax, byte [eax+2]    ; PEB.BeingDebugged
test  eax, eax
jnz   anti_debug_triggered

Timing checks: mide el tiempo entre instrucciones. Si tarda demasiado (porque estas en un debugger), detecta el analisis.

rdtsc                       ; lee timestamp counter
mov   ebx, eax              ; guardar valor inicial
; ... codigo normal ...
rdtsc                       ; leer otra vez
sub   eax, ebx              ; diferencia
cmp   eax, 0x100000         ; umbral
ja    debugger_detected     ; demasiado tiempo = debugger

Algoritmos custom

Los crackmes intermedios implementan algoritmos de verificacion propios que requieren analisis mas profundo:

// Decompilador muestra algo como:
int verify(char *serial)
{
    int sum = 0;
    for (int i = 0; serial[i] != 0; i++) {
        sum = sum * 31 + serial[i];
    }
    return sum == 0x12345678;
}

Aqui necesitas entender el algoritmo y calcular un input que produzca el hash esperado (o determinar que es computacionalmente inviable y buscar otra via).

Recursos para nivel 2

Challenges de Flare-On (Mandiant): challenges anuales de reverse engineering con dificultad creciente. Los primeros niveles de cada edicion son accesibles para intermedios. Cada ano se publican las soluciones despues del evento.

Malware Traffic Analysis (malware-traffic-analysis.net): capturas de red con malware real. No son crackmes, pero practicas analisis de trafico de malware, que complementa el RE.

Nivel 3: CTF challenges de reverse engineering

Que son los CTF

Capture The Flag (CTF) son competiciones de ciberseguridad con categorias como reverse engineering, pwn (explotacion), web, crypto y forensics. La categoria "reverse" incluye binarios que debes analizar para extraer una flag (cadena de texto secreta).

Plataformas permanentes

picoCTF: orientado a estudiantes. La categoria reverse tiene challenges desde nivel basico. Gratis y siempre disponible.

Hack The Box: seccion Challenges tiene binarios de RE clasificados por dificultad. Algunos simulan malware real.

TryHackMe: rutas de aprendizaje con challenges guiados. La ruta "Malware Analysis" combina teoria y practica.

OverTheWire: wargames por SSH. "Narnia" y "Behemoth" son relevantes para RE y explotacion basica.

root-me.org: amplia coleccion de challenges de RE en multiples plataformas (Windows, Linux, Android, ARM).

Ejercicio tipo: CTF reverse con anti-tampering

// Decompilado tipico de CTF reverse
void check_flag(char *input)
{
    char expected[32];
    // Genera expected[] con operaciones sobre una constante
    for (int i = 0; i < 32; i++) {
        expected[i] = (table[i] ^ 0x42) + (i * 3);
    }
    if (memcmp(input, expected, 32) == 0) {
        puts("Correct flag!");
    }
}

Solucion: replicar el algoritmo de generacion en Python:

table = [0x2a, 0x1f, ...]  # extraer de IDA/Ghidra
expected = []
for i in range(32):
    expected.append((table[i] ^ 0x42) + (i * 3) & 0xFF)
flag = bytes(expected).decode()
print(f"Flag: {flag}")

Nivel 4: muestras de malware real (controlado)

Preparacion del laboratorio

Antes de tocar malware real, necesitas un entorno aislado:

Maquina virtual: Windows 10/11 en VirtualBox o VMware. Snapshot limpio antes de cada analisis.

Red aislada: la VM no debe tener acceso a Internet real. Usa INetSim o FakeNet-NG para simular servicios de red y capturar las comunicaciones del malware.

Herramientas instaladas: Ghidra o IDA Free, x64dbg, Process Monitor, Process Hacker, Wireshark (escuchando en la red simulada), PE-bear, DIE (Detect It Easy).

Reglas de seguridad: nunca montar carpetas compartidas con el host. No copiar muestras al host sin cifrar con contrasena (zip con password "infected"). No ejecutar muestras fuera de la VM.

Donde obtener muestras

MalwareBazaar (bazaar.abuse.ch): repositorio de muestras con tags de familia, hashes, y metadatos. Busca por familia conocida para empezar con algo documentado.

ANY.RUN: sandbox publico. Puedes ver ejecuciones de otros analistas y descargar las muestras (cuenta gratuita con limites).

VirusTotal: con cuenta premium, descarga muestras por hash. La cuenta gratuita permite analizar pero no descargar.

theZoo (GitHub): repositorio de muestras organizado por familia. Los archivos estan protegidos con contrasena "infected". Incluye documentacion de cada familia.

VX-Underground: repositorio masivo de muestras historicas y recientes. Requiere precaucion adicional.

Muestras recomendadas para empezar

Empieza con familias bien documentadas donde puedas comparar tu analisis con reports publicos:

Droppers simples: busca samples tagged como "dropper" en MalwareBazaar. Son binarios que extraen y ejecutan un payload, sin logica compleja.

RATs basicos: AsyncRAT, QuasarRAT y NjRAT tienen codigo fuente publico. Puedes comparar el desensamblado con el fuente para entender como el compilador traduce C# a IL y como se ve en un binario nativo.

Infostealers: RedLine y Vidar tienen reports detallados de multiples vendors. Analiza la configuracion cifrada, las APIs de sistema que usan para robar credenciales, y la comunicacion con el C2.

Ejercicio guiado: analisis de un dropper

Progresion recomendada para tu primer analisis de malware real:

Paso 1: triage (10 minutos)

# Identificar tipo de archivo
file sample.exe
# PE32 executable (GUI) Intel 80386, for MS Windows

# Hashes para buscar en VT
sha256sum sample.exe

# Entropia por secciones
python3 -c "import pefile; pe = pefile.PE('sample.exe'); [print(s.Name.decode().strip('\x00'), s.get_entropy()) for s in pe.sections]"

Paso 2: analisis estatico en Ghidra (30 minutos)

1. Importar el binario.
2. Revisar imports: buscar VirtualAlloc, CreateProcess, WriteFile.
3. Revisar strings: URLs, rutas, comandos sospechosos.
4. Navegar al entry point y seguir el flujo principal.

Paso 3: identificar funcionalidad (30 minutos)

1. Buscar la funcion que extrae el payload (XOR, RC4 sobre un recurso embebido).
2. Identificar como se ejecuta el payload (CreateProcess, shellcode en memoria).
3. Documentar la cadena: extraccion, descifrado, ejecucion.

Paso 4: extraer IOCs

1. Descifrar el payload (script Python).
2. Analizar el payload descifrado (puede ser otro PE, shellcode, o un script).
3. Extraer URLs, IPs, dominios del payload.

Nivel 5: muestras avanzadas

Tecnicas que encontraras

A medida que avanzas a muestras mas sofisticadas:

Packing: el binario esta comprimido o cifrado con un packer (UPX, Themida, VMProtect). Necesitas desempaquetar antes de analizar. UPX es trivial (upx -d), los comerciales requieren analisis dinamico.

Process hollowing: el malware crea un proceso legitimo suspendido, vacia su memoria, escribe el payload y resume la ejecucion. Necesitas volcar el proceso en memoria para analizar el payload real.

Inyeccion de DLL: el malware inyecta una DLL en otro proceso. El binario principal puede parecer inocuo; la funcionalidad maliciosa esta en la DLL que se inyecta.

Codigo de maquina virtual: malware protegido con VM propia (como lo que genera VMProtect). Las instrucciones reales se traducen a un bytecode custom que un interprete embebido ejecuta. El analisis requiere entender el interprete primero.

Reports publicos como referencia

Cuando analices una muestra avanzada, busca reports de:

• Mandiant (ahora Google Cloud)
• CrowdStrike
• Secureworks
• ESET
• Kaspersky GReAT
• Check Point Research
• Palo Alto Unit 42
• Cisco Talos

Estos reports documentan familias con detalle tecnico: cadena de infeccion, algoritmos de cifrado, protocolo C2, IOCs. Compara tu analisis con el suyo para validar tus hallazgos.

Crear tu propio laboratorio de practica

Binarios para RE basico

Compila tus propios programas en C con distintas opciones y analizalos:

// password_check.c
#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
    char password[] = "MalwareIntel2026";
    if (argc != 2) {
        printf("Usage: %s password\n", argv[0]);
        return 1;
    }
    if (strcmp(argv[1], password) == 0) {
        printf("Access granted!\n");
        return 0;
    }
    printf("Wrong password.\n");
    return 1;
}

Compilalo con distintas opciones y observa las diferencias en el desensamblado:

# Sin optimizacion (facil de leer)
gcc -O0 -o check_O0 password_check.c

# Con optimizacion (mas realista)
gcc -O2 -o check_O2 password_check.c

# Con strip (sin simbolos, como malware real)
gcc -O2 -s -o check_stripped password_check.c

# Estaticamente enlazado (simula malware con librerias embebidas)
gcc -O2 -static -o check_static password_check.c

Analizar tus propios binarios te ensena como el compilador traduce C a ensamblador, y por que el decompilador a veces produce resultados extravagantes.

Malware educativo

Proyectos disenados explicitamente para aprendizaje:

SANS Malware Analysis exercises: challenges del curso FOR610 disponibles parcialmente online.

Practical Malware Analysis book samples: los ejercicios del libro de Sikorski y Honig estan disponibles y cubren desde nivel basico hasta avanzado.

RPISEC/Malware: curso universitario de RE con labs publicos.

Plan de practica semanal

Una progresion realista para desarrollar habilidades:

Semanas 1-2: fundamentos

• 1 crackme basico por dia (crackmes.one, dificultad 1-2)
• Objetivo: fluidez navegando Ghidra/IDA, reconocer comparaciones y XOR

Semanas 3-4: consolidacion

• 1 crackme intermedio cada 2 dias (dificultad 3)
• 1 CTF reverse challenge por semana (picoCTF)
• Objetivo: anti-debugging, algoritmos custom, scripting basico

Semanas 5-6: transicion a malware

• Configurar laboratorio de analisis
• 1 dropper o RAT simple por semana de MalwareBazaar
• Documentar cada analisis como un mini-report

Semanas 7-8: practica avanzada

• Muestras con packing (empezar con UPX)
• Muestras con cifrado RC4 o AES
• Comparar tu analisis con reports publicos de la familia

Continuo

• Participar en CTFs cuando haya competiciones activas
• Seguir los writeups de Flare-On de cada ano
• Leer un report de malware publico por semana y reproducir partes del analisis

Errores comunes y como evitarlos

Saltar directamente a malware real: sin los fundamentos de crackmes, el analisis de malware real es frustrante. Los crackmes te dan victorias rapidas que consolidan las habilidades basicas.

No documentar: cada analisis que hagas, documentalo. Aunque sea un crackme trivial. El habito de documentar es tan importante como la habilidad tecnica.

Analizar sin objetivo: antes de abrir un binario, define que quieres responder. Tiene C2? Que cifrado usa? Como persiste? Un objetivo concreto evita perderse en detalles irrelevantes.

No usar el decompilador: algunos analistas insisten en leer solo ensamblador como prueba de habilidad. En la practica profesional, el decompilador te hace mas productivo. Usalo como primera aproximacion y baja a ensamblador cuando sea necesario.

No comparar con reports: cuando analices malware conocido, busca reports de otros analistas. Comparar te ensena tecnicas que no habrias descubierto solo.

Conclusion de la serie

Esta serie de 13 articulos ha cubierto desde las bases del ensamblador x86/x64 hasta ejercicios practicos con malware real. El camino de leer ensamblador a analizar malware profesionalmente requiere practica consistente, no talento innato.

Empieza con los crackmes. Documenta todo. Sube de nivel cuando te sientas comodo, no cuando te aburras. Y recuerda: cada funcion que renombras, cada algoritmo que identificas, cada clave que extraes, te acerca un paso mas a ser un analista competente.