¿Cuál es la mejor distribución para análisis de malware Linux?

REMnux es la distro de referencia. Basada en Ubuntu, viene preinstalada con más de 100 herramientas de análisis de malware: Ghidra, radare2, YARA, Volatility, oletools, pefile, y muchas más. Ideal como VM de análisis.

¿Puedo analizar malware Linux en una máquina Windows?

Sí, parcialmente. Ghidra e IDA Pro abren ELFs en Windows para análisis estático. Pero el análisis dinámico (strace, GDB, ejecución controlada) requiere un entorno Linux. Usar una VM con REMnux o Ubuntu Server es lo recomendado.

¿GDB es suficiente como debugger para malware?

GDB con extensiones (GEF, pwndbg, peda) es poderoso pero tiene curva de aprendizaje alta. Para analistas que vienen de x64dbg (Windows), la transición requiere adaptarse a la interfaz de línea de comandos. GEF es la extensión más recomendada para análisis de malware.

¿Cómo ejecuto malware Linux de forma segura?

Opciones: (1) VM aislada sin red (snapshot before, revert after), (2) Docker container sin capacidades de red, (3) QEMU/KVM con red aislada. Para malware IoT (ARM, MIPS): QEMU user-mode emulation permite ejecutar binarios de otras arquitecturas en x86.

¿Cómo analizo malware para ARM/MIPS (IoT) en mi PC x86?

QEMU user-mode emulation: qemu-arm-static o qemu-mips-static ejecutan binarios de otras arquitecturas en x86 traduciendo instrucciones. Para análisis dinámico completo, QEMU system emulation emula un sistema completo con la arquitectura objetivo.

IntermedioLinuxherramientasanálisislaboratorioGhidraREMnux

Análisis de Malware en Linux: Herramientas Esenciales y Metodología

Guía práctica de herramientas y metodología para análisis de malware en Linux. Análisis estático (readelf, Ghidra, CAPA), dinámico (strace, GDB, Docker sandboxing), y forense (Volatility, LiME). Setup de laboratorio y workflow completo.

MalwareIntel Research·21 de mayo de 2026·8 min lectura

Serie: Malware en Linux — Parte 2

El toolkit del analista de malware Linux

El análisis de malware Linux difiere del de Windows en herramientas, pero no en metodología. El flujo es el mismo: triage, análisis estático, análisis dinámico, documentación. Las herramientas cambian: en vez de pestudio usas readelf, en vez de x64dbg usas GDB, en vez de Process Monitor usas strace.

Este artículo es una guía de referencia de herramientas organizadas por fase de análisis, con ejemplos prácticos y configuración de laboratorio.

Setup de laboratorio

Opción 1: REMnux (recomendada)

REMnux es la distribución de referencia para análisis de malware, mantenida por Lenny Zeltser (SANS):

# Instalar como VM (OVA disponible)
# O instalar sobre Ubuntu existente:
wget https://remnux.org/remnux-cli
chmod +x remnux-cli
sudo mv remnux-cli /usr/local/bin/
sudo remnux install

Herramientas incluidas: Ghidra, radare2, YARA, Volatility, FLOSS, CAPA, oletools, pefile, binwalk, strace, ltrace, GDB + GEF, y 100+ más.

Opción 2: Docker para análisis aislado

# Container desechable para análisis de muestras
docker run --rm -it --network none \
  -v $(pwd)/samples:/samples:ro \
  remnux/remnux-distro:focal bash

# --network none: sin acceso a red
# --rm: eliminar container al salir
# -v: montar directorio de muestras como read-only

Opción 3: QEMU para malware IoT (ARM/MIPS)

# Instalar QEMU user-mode
sudo apt install qemu-user-static binfmt-support

# Ejecutar binario ARM en x86
qemu-arm-static ./mirai_arm_sample

# Ejecutar con strace
qemu-arm-static -strace ./mirai_arm_sample 2> trace.txt

# Con GDB remoto
qemu-arm-static -g 1234 ./mirai_arm_sample &
gdb-multiarch -ex "target remote :1234" ./mirai_arm_sample

Precauciones de seguridad

Regla	Motivo
VM sin conexión a red (o red aislada)	Evitar que el malware contacte C2 o se propague
Snapshot antes de ejecutar	Poder revertir al estado limpio
No analizar en tu sistema host	El malware puede escalar privilegios
Deshabilitar shared folders	El malware puede intentar acceder al host via shares
Usar usuario no-root para análisis estático	Limitar daño si algo sale mal
Root solo para análisis dinámico controlado	Algunos malware requieren root para mostrar comportamiento completo

Herramientas de análisis estático

Triage rápido

# 1. Identificar el archivo
file sample
# ELF 64-bit LSB executable, x86-64, version 1, statically linked, stripped

# 2. Hashes
sha256sum sample
md5sum sample

# 3. Tamaño
ls -la sample

# 4. Strings (ASCII + Unicode)
strings -a sample | wc -l        # Cuantas strings
strings -a sample | sort -u > strings.txt

# 5. Buscar strings interesantes
grep -iE '(http|https|ftp|ssh|\.onion|bitcoin|monero)' strings.txt
grep -iE '([0-9]{1,3}\.){3}[0-9]{1,3}' strings.txt   # IPs
grep -iE '(password|passwd|login|token|key|secret)' strings.txt

# 6. Entropia
binwalk -E sample   # Grafico de entropia

# 7. UPX check
upx -t sample 2>/dev/null

# 8. Mitigaciones
checksec --file=sample

# 9. YARA scan
yara -r /path/to/rules/ sample

readelf / objdump

# ELF header
readelf -h sample

# Secciones
readelf -S sample

# Program headers (segments)
readelf -l sample

# Simbolos dinamicos (imports/exports)
readelf --dyn-syms sample

# Tabla de simbolos completa (si no esta stripped)
readelf -s sample

# Librerias necesarias
readelf -d sample | grep NEEDED
# (NEEDED) Shared library: [libc.so.6]
# (NEEDED) Shared library: [libpthread.so.0]

# Disassembly
objdump -d sample | less
objdump -d -M intel sample | less   # Sintaxis Intel

Ghidra

Ghidra de NSA es el decompilador gratuito más potente para ELF:

# Abrir Ghidra
ghidraRun

# Workflow:
# 1. File > Import File > seleccionar sample
# 2. Ghidra detecta arquitectura automaticamente
# 3. Analyze > Auto Analyze (aceptar defaults)
# 4. Ir al entry point (simbolo "entry" o direccion de e_entry)
# 5. Navegar funciones en el Function Browser
# 6. Decompiler window muestra C pseudocode

Plugins útiles para malware:

Plugin	Uso
FindCrypt	Identifica constantes criptográficas
GoReSym	Recupera símbolos en binarios Go
Ghidra-BinExport	Exportar para BinDiff (comparación de binarios)
GhidraOllvm	Deobfuscación de OLLVM (obfuscated LLVM)

CAPA

# Deteccion automatica de capacidades
capa sample

# Output ejemplo:
# +-----------------------------+-------------------------------------------+
# | ATT&CK Tactic               | ATT&CK Technique                         |
# |-----------------------------+-------------------------------------------|
# | EXECUTION                    | T1059.004 Command and Scripting: Unix     |
# | PERSISTENCE                  | T1053.003 Cron                            |
# | DEFENSE EVASION              | T1070.004 File Deletion                   |
# | DISCOVERY                    | T1083 File and Directory Discovery        |
# | COMMAND AND CONTROL          | T1071.001 Web Protocols                   |
# +-----------------------------+-------------------------------------------+

FLOSS (FLARE Obfuscated String Solver)

# Extraer strings ofuscadas (stack strings, decoded strings)
floss sample

# FLOSS encuentra strings que strings(1) no puede:
# - Stack strings (construidas caracter a caracter)
# - Strings descifradas en runtime
# - Strings de binarios empaquetados

Herramientas de análisis dinámico

strace (syscalls)

# Trazar todas las syscalls
strace -f ./sample 2> strace.txt

# Solo syscalls de red
strace -f -e trace=network ./sample

# Solo syscalls de archivos
strace -f -e trace=file ./sample

# Con timestamps
strace -f -tt ./sample

# Seguir forks/threads
strace -ff ./sample

# Output a archivo por PID
strace -ff -o trace ./sample
# Genera: trace.1234, trace.1235, etc.

ltrace (library calls)

# Trazar llamadas a librerias
ltrace -f ./sample 2> ltrace.txt

# Solo funciones especificas
ltrace -f -e connect+socket+send+recv ./sample

GDB con GEF

GEF (GDB Enhanced Features) transforma GDB en un debugger moderno:

# Instalar GEF
bash -c "$(curl -fsSL https://gef.blah.cat/sh)"

# Debugging basico
gdb ./sample
gef> info functions           # Listar funciones
gef> break main               # Breakpoint en main
gef> break *0x400a30          # Breakpoint en direccion
gef> run                      # Ejecutar
gef> ni                       # Next instruction
gef> si                       # Step into
gef> c                        # Continue
gef> x/20x $rsp              # Examinar memoria (stack)
gef> x/s 0x402000            # Examinar string
gef> vmmap                    # Memory map
gef> got                      # GOT entries
gef> heap chunks              # Heap inspection

Networking: capturar tráfico del malware

# Capturar trafico con tcpdump
sudo tcpdump -i any -w malware_traffic.pcap &
./sample
# Ctrl+C en tcpdump

# Analizar con tshark
tshark -r malware_traffic.pcap -Y "dns" | head
tshark -r malware_traffic.pcap -Y "http.request" | head
tshark -r malware_traffic.pcap -Y "tcp.flags.syn==1" | head

# Fake DNS/HTTP con INetSim (REMnux incluye)
sudo inetsim
# Responde a todas las queries DNS con la IP local
# Responde a todos los HTTP requests con contenido dummy

Docker como sandbox

# Ejecutar malware en container aislado
docker run --rm -it --network none --cap-drop ALL \
  -v $(pwd)/sample:/sample:ro \
  ubuntu:22.04 bash

# Dentro del container:
apt update && apt install -y strace ltrace
strace /sample 2> /tmp/trace.txt
cat /tmp/trace.txt

Memory forensics en Linux

LiME (Linux Memory Extractor)

# Compilar LiME para el kernel actual
git clone https://github.com/504ensicsLabs/LiME
cd LiME/src
make

# Capturar memoria
sudo insmod lime-$(uname -r).ko "path=/tmp/memory.lime format=lime"

Volatility 3 para Linux

# Listar procesos
vol3 -f memory.lime linux.pslist

# Listar conexiones de red
vol3 -f memory.lime linux.sockstat

# Listar modulos del kernel cargados
vol3 -f memory.lime linux.lsmod

# Buscar inyeccion en procesos
vol3 -f memory.lime linux.malfind

# Bash history en memoria
vol3 -f memory.lime linux.bash

Workflow completo de análisis

Fase 1: triage (5-10 minutos)

file sample && sha256sum sample
strings -a sample | grep -iE '(http|[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+|\.onion)' | head
readelf -h sample | grep -E '(Class|Machine|Type|Entry)'
checksec --file=sample
upx -t sample 2>/dev/null

Decisión: ¿es malware conocido? (buscar hash en VT). ¿Está empaquetado? ¿Qué arquitectura?

Fase 2: análisis estático (30-60 minutos)

# Si UPX: desempaquetar primero
upx -d sample -o sample_unpacked

# Strings completo
strings -a sample_unpacked > strings.txt
floss sample_unpacked >> strings.txt

# Imports y simbolos
readelf --dyn-syms sample_unpacked > imports.txt
readelf -s sample_unpacked > symbols.txt

# CAPA
capa sample_unpacked > capabilities.txt

# Ghidra: decompilacion y analisis manual

Fase 3: análisis dinámico (1-4 horas)

# En VM aislada o Docker
# 1. Activar captura de trafico
sudo tcpdump -i any -w traffic.pcap &

# 2. strace
strace -f -o strace.txt ./sample_unpacked

# 3. Si necesario: GDB para debugging interactivo
gdb ./sample_unpacked

# 4. Analizar trafico
tshark -r traffic.pcap

Fase 4: documentación

Documentar:

Hashes (MD5, SHA1, SHA256)
Tipo de malware (botnet, miner, ransomware, backdoor)
C2 (IPs, dominios, puertos, protocolos)
Persistencia (cron, systemd, rc.local)
Comportamiento (qué hace, en qué orden)
IOCs extraídos
MITRE ATT&CK mapping
Reglas YARA/Sigma

Tabla resumen: herramienta por tarea

Tarea	Herramienta Linux	Equivalente Windows
Identificar formato	file, readelf	DIE, pestudio
Strings	strings, FLOSS	strings, FLOSS
Disassembly	objdump, radare2	IDA, x64dbg
Decompilación	Ghidra, IDA	Ghidra, IDA
Debugging	GDB + GEF	x64dbg, WinDbg
Syscall tracing	strace	API Monitor, Procmon
Library tracing	ltrace	API Monitor
Network capture	tcpdump, Wireshark	Wireshark, Fiddler
Memory forensics	Volatility + LiME	Volatility + WinPmem
Packer detection	DIE, UPX -t	DIE, Exeinfo PE
Capabilities	CAPA	CAPA
Sandbox	Docker, QEMU, VM	Sandbox (ANY.RUN, CAPE)

Fuentes y referencias

Zeltser, L. "REMnux: Linux Toolkit for Malware Analysis." https://remnux.org/
Andriesse, D. "Practical Binary Analysis." No Starch Press, 2018.
O'Neill, R. "Learning Linux Binary Analysis." Packt Publishing, 2016.
Mandiant. "CAPA." https://github.com/mandiant/capa
Mandiant. "FLOSS." https://github.com/mandiant/flare-floss
NSA. "Ghidra." https://ghidra-sre.org/
GEF. "GDB Enhanced Features." https://github.com/hugsy/gef
LiME. "Linux Memory Extractor." https://github.com/504ensicsLabs/LiME
Volatility Foundation. "Volatility 3." https://github.com/volatilityfoundation/volatility3
QEMU. "QEMU User Mode Emulation." https://www.qemu.org/docs/master/user/index.html

Preguntas frecuentes

Libros recomendados

Practical Binary Analysis (Andriesse)

Amazon (enlace afiliado)

Learning Linux Binary Analysis (Elfmaster)