Manual Avanzado de Programación en Ensamblador para Cracking

1. Introducción al ASM para Cracking

El ensamblador (ASM) es fundamental para el cracking ya que permite:

• Analizar el flujo de ejecución a bajo nivel
• Modificar instrucciones directamente en memoria
• Entender y manipular mecanismos de protección
• Crear patches y keygens

1.1 Arquitecturas comunes

2. Fundamentos de ASM para Cracking

2.1 Registros clave

EAX ; Acumulador (valor de retorno)
EBX ; Base (datos)
ECX ; Contador (bucles)
EDX ; Datos (operaciones I/O)
ESI ; Índice fuente (operaciones con cadenas)
EDI ; Índice destino (operaciones con cadenas)
ESP ; Stack pointer
EBP ; Base pointer (marco de stack)
EIP ; Instruction pointer (¡CRÍTICO para cracking!)

2.2 Instrucciones esenciales

mov eax, ebx   ; ebx -> eax
cmp eax, 1234    ; Compara eax con 1234 (afecta flags)
jz loc_401000    ; Salta si Zero Flag=1 (resultado fue cero)
jnz loc_401000   ; Salta si Zero Flag=0
call sub_401050   ; Llama a función (push EIP + jump)
retn             ; Retorna de función (pop EIP)
push eax         ; Guarda eax en el stack
pop ebx          ; Recupera valor del stack a ebx
nop              ; No operation (útil para parches)

3. Técnicas de Reversing para Cracking

3.1 Análisis de strings

; Buscar referencias a strings clave:
; "Invalid license", "Registration", "Wrong serial", etc.
; En OllyDbg: Ctrl+B -> buscar string

; Ejemplo típico de comparación de serial:
mov eax, [ebp+serial_user]
mov ecx, [ebp+serial_correcto]
call strcmp
test eax, eax
jz serial_correcto

3.2 Puntos de ruptura estratégicos

• BPX MessageBoxA: Para diálogos de error
• BPX GetDlgItemTextA: Captura de input de usuario
• BPX strcmp/memcmp: Comparaciones de seriales
• BPX CreateFileA: Lectura de archivos de licencia

3.3 Tracing de ejecución

; Técnicas comunes:
; - Step into (F7 en OllyDbg): Ejecuta instrucción entrando en calls
; - Step over (F8): Ejecuta instrucción saltando calls
; - Run trace (Ctrl+F11): Registra toda la ejecución
; - Conditional logging: Registra valores específicos

4. Bypass de Protecciones Comunes

4.1 Serial checks

; Parche común para saltar verificación:
jz loc_fail      ; Original: Salta si serial incorrecto
jmp loc_success  ; Modificado: Siempre salta a éxito
; O reemplazar con NOPs:
nop
nop

4.2 Keyfile protection

; Ejemplo de bypass para verificación de keyfile:
call ds:CreateFileA  ; Intenta abrir keyfile
cmp eax, -1         ; ¿Falló?
jnz short loc_keyfile_ok
; Parchear para simular keyfile existente:
mov eax, 1        ; Siempre devuelve handle válido
jmp loc_keyfile_ok

4.3 Time trials

; Bypass para tiempo de prueba:
call ds:GetTickCount  ; Obtiene tiempo desde inicio
sub eax, startTime
cmp eax, trialPeriod
jl short loc_trial_ok
; Parchear para siempre considerar tiempo válido:
jmp loc_trial_ok

; Bypass para IsDebuggerPresent:
call ds:IsDebuggerPresent
test eax, eax
jz short loc_no_debugger
; Parchear para siempre retornar 0:
xor eax, eax
retn

5. Técnicas Avanzadas de Cracking

5.1 Keygenning

; Ejemplo de algoritmo de serial típico:
mov eax, [nombre_usuario]
xor eax, 12345678h
add eax, 87654321h
ror eax, 4
not eax
mov [serial_correcto], eax

; Keygen en C equivalente:
unsigned int generate_serial(const char* username) {
    unsigned int hash = 0;
    for(int i = 0; username[i]; i++) {
        hash = (hash << 3) + username[i];
    }
    hash ^= 0x12345678;
    hash += 0x87654321;
    hash = (hash >> 4) | (hash << (32-4));
    return ~hash;
}

5.2 Patching

; Ejemplo de parche común (cambiar jz por jmp):
; Original: 74 0A (jz +10)
; Modificado: EB 0A (jmp +10)

; Herramientas para parchear:
; - OllyDbg: Ctrl+E para editar
; - x64dbg: Parchear directamente
; - HxD: Editor hexadecimal

5.3 IAT Hooking

; Manipulación de Import Address Table para redirigir funciones:
; 1. Localizar IAT (Import Address Table)
; 2. Encontrar entrada de la función a hookear (ej. MessageBoxA)
; 3. Cambiar dirección por nuestra función

; Ejemplo de hook para MessageBoxA:
int WINAPI MyMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType) {
    // Cambiar mensaje de error
    if(strstr(lpText, "Invalid")) {
        return MessageBoxA(hWnd, "Valid License!", lpCaption, uType);
    }
    return MessageBoxA(hWnd, lpText, lpCaption, uType);
}

; Ejemplo de code cave que salta a nuestra función:
pushad                  ; Guarda registros
call my_new_function    ; Llama a nuestro código
popad                   ; Restaura registros
jmp original_function  ; Vuelve al flujo original

6. Herramientas Esenciales

7. Tratamiento con Packers y Ofuscadores

7.1 Packers comunes

• UPX (fácil de desempacar)
• ASPack, UPack
• Themida, VMProtect (avanzados)

7.2 Técnicas de unpacking

; Método OEP (Original Entry Point) común:
1. Buscar punto de entrada empaquetado
2. Poner breakpoint en acceso a memoria de código
3. Seguir ejecución hasta salto a OEP
4. Volcar proceso desempacado

; Herramientas específicas:
- UPX: upx -d archivo.exe
- OllyDbg: plugins como OllyDump

; Estrategias para packers avanzados:
- Análisis estático del stub de unpacking
- Memory dumping en momento preciso
- Reconstrucción manual de IAT
- Uso de emuladores como QEMU

8. Ética y Consideraciones Legales

8.2 Uso ético

Usa estas técnicas solo para:

• Investigación en seguridad
• Pruebas en software propio
• Análisis de malware
• Recuperación de acceso legítimo

9. Recursos de Aprendizaje

9.1 Libros recomendados

• "Reversing: Secrets of Reverse Engineering" - Eldad Eilam
• "The IDA Pro Book" - Chris Eagle
• "Practical Malware Analysis" - Michael Sikorski

9.2 Comunidades

• Reverse Engineering Stack Exchange
• Tuts4You
• Woodmann's Reverse Engineering Forum

9.3 CTFs y retos

• Crackmes.one
• Reverse Engineering challenges en Hack The Box
• CTFtime.org

10. Ejemplo Completo: Crackme Básico

10.1 Análisis inicial

; Comportamiento observado:
- Pide nombre de usuario y serial
- Muestra "Correct!" o "Wrong serial"

; Strings encontradas:
- "Enter your name:"
- "Enter serial:"
- "Correct!"
- "Wrong serial"

10.2 Reversing del algoritmo

; Desensamblado clave:
mov eax, [nombre]      ; Carga primer carácter
imul eax, 41C64E6Dh    ; Multiplica por constante
add eax, 3039h        ; Suma constante
mov [serial_valido], eax ; Guarda como serial válido

; Comparación:
mov eax, [serial_usuario]
cmp eax, [serial_valido]
jz correcto

10.3 Keygen

#include <stdio.h>

int main() {
    char name[32];
    printf("Enter name: ");
    scanf("%31s", name);
    
    unsigned int serial = name[0];
    serial *= 0x41C64E6D;
    serial += 0x3039;
    
    printf("Valid serial: %u\n", serial);
    return 0;
}

10.4 Patch

; Cambiar:
74 0A ; jz +10 (Wrong serial)
; Por:
90 90 ; nop nop (siempre continúa)

; O cambiar por:
EB 0A ; jmp +10 (siempre salta a Correct!)