Análisis dinámico

El análisis dinámico consiste en ejecutar el binario y observar su comportamiento en tiempo real: qué ficheros abre, qué conexiones de red hace, qué llamadas al sistema realiza, cómo cambia la memoria, y qué hace realmente (no solo lo que parece hacer en el código). Complementa al estático (Análisis estático): lo que es difícil de seguir leyendo el desensamblado —código ofuscado, cifrado en runtime, lógica dependiente de la entrada— se ve claro ejecutándolo bajo observación. Es esencial para analizar malware y para desempacar binarios protegidos.

Qué observar y con qué

# llamadas a sistema y a librería (comportamiento de alto nivel)
strace ./binario           # syscalls (open, connect, execve, read/write...)
ltrace ./binario           # llamadas a funciones de librería (strcmp, malloc, printf...)
# ficheros, red, procesos
lsof / inotifywait         # ficheros abiertos / cambios en el FS
tcpdump / wireshark        # tráfico de red generado (ver net-sniffing)
# estado interno (paso a paso)
gdb + pwndbg/GEF           # registros, memoria, flujo (ver rev-debug)

ltrace es oro en crackmes: si el programa hace strcmp(tu_input, "password_correcta"), ltrace te muestra directamente la contraseña esperada.

El caso del cifrado/ofuscación en runtime

Mucho código (malware, protecciones) solo revela su lógica real al ejecutarse: strings cifradas que se descifran en memoria, código que se desempaca. El estático no lo ve; el dinámico sí:

# strings descifradas en memoria -> volcar la memoria del proceso en ejecución
gdb -> dump memory out.bin 0x... 0x...   ; strings out.bin
# o parar justo después del descifrado y leer la memoria (rev-debug)
# packers: ejecutar hasta que el código real está desempacado en memoria -> dumpear

Desempacar (unpacking)

# un packer comprime/cifra el ejecutable; el código real aparece solo en runtime
1. ejecutar bajo debugger hasta el "OEP" (Original Entry Point, tras desempacar)
2. volcar la memoria del proceso (el binario ya desempacado)
3. reconstruir un ejecutable (importrec, etc.) para análisis estático
# herramientas: x64dbg + plugins (Windows), Scylla, upx -d (si es UPX estándar)

Instrumentación y tracing avanzado

# registrar TODAS las instrucciones ejecutadas (trace completo)
# frameworks de instrumentación dinámica:
Frida          hooking en runtime (también móvil, ver mob-frida)
Pin / DynamoRIO / Qiling   instrumentación/emulación a nivel de instrucción
# ejecución simbólica (explorar caminos automáticamente):
angr           resolver crackmes automáticamente encontrando la entrada que llega a "win"

angr (ejecución simbólica) puede resolver muchos crackmes solo: le dices “quiero llegar a la dirección que imprime ‘Correct’” y calcula la entrada necesaria.

Entorno seguro (malware)

El análisis dinámico ejecuta el código, así que con malware es imprescindible aislar:

# VM dedicada, aislada de la red (o red simulada), con snapshots
# INetSim / FakeNet: simular Internet para ver qué intenta contactar el malware sin exponerte
# nunca ejecutar malware en tu máquina real (ver malware)

Para la defensa (lo que el malware hace para evitarlo)

El código protegido intenta detectar que está siendo observado (debugger, VM, sandbox) y cambiar su comportamiento o abortar — se cubre en rev-antidebug. El analista lo sortea (parchear detecciones, VMs más sigilosas, hooking).

Checklist de prueba

strace/ltrace para ver syscalls/llamadas (comportamiento)
Monitorizar ficheros/red/procesos
GDB para el estado interno paso a paso (Depuración con GDB)
Volcar memoria para ver strings/código descifrado en runtime
Desempacar binarios protegidos (OEP + dump)
Instrumentación (Frida) / emulación (Qiling) si hace falta
Ejecución simbólica (angr) para crackmes
Malware: entorno aislado con red simulada