Captura de Paquetes - El Lenguaje Oculto de la RED

Cuando los logs no alcanzan, las capturas de paquetes hablan. Son el testimonio crudo y directo del comportamiento de la red, sin interpretación previa. Cada bit, cada encabezado, cada carga útil puede revelar desde una simple conexión legítima hasta una exfiltración quirúrgica o el primer susurro de un malware.

🔍 ¿Qué es una captura de paquetes y por qué importa?

Una captura de paquetes (o packet capture – PCAP) es una fotografía completa del tráfico que circula por un punto de la red. A diferencia de los logs que te dicen "algo ocurrió", una captura te muestra exactamente qué ocurrió, cómo ocurrió y cuándo. Es la autopsia forense digital más precisa que existe.

Mientras que el SIEM agrega y presenta resúmenes y alertas, el análisis de paquetes te lleva directamente a las vísceras del tráfico. Aquí no hay falsos positivos ni suposiciones: sólo la verdad de los datos en tránsito.

⚙️ Cómo se capturan y procesan los paquetes

En la mayoría de las infraestructuras, no se puede capturar todo el tráfico de forma continua: la cantidad de datos sería colosal. Por eso se implementan sensores estratégicamente (como en un SPAN port o un TAP), y se capturan:

Sólo los paquetes que activan alertas de IDS/IPS.
O bien los encabezados de tráfico (sin payload).
O, en entornos con alto presupuesto, todo el tráfico completo (Network Forensics).

El SIEM se encarga de almacenar eventos clave. Si se integra con herramientas como Suricata o Zeek, puedes pivotar desde una alerta directamente hacia el PCAP completo.

🛠️ Herramientas principales para capturar y analizar

Wireshark → el estándar para análisis en profundidad.
tcpdump → versión en línea de comandos, ideal para scripting.
tshark → versión CLI de Wireshark, poderosa para automatizar filtrados.
Arkime → plataforma de captura masiva y visualización tipo Kibana.
Zeek → IDS pasivo que no sólo genera alertas, sino logs ricos y estructurados.
Security Onion → distribución completa con Zeek + Suricata + Arkime.

🧠 ¿Qué puedes descubrir analizando paquetes?

🎯 Manipulación de protocolos

Los atacantes disfrazan tráfico malicioso como tráfico legítimo (por ejemplo, ocultando comandos en peticiones DNS o HTTP).

¿Ves una petición HTTP que no corresponde con un navegador? Posible herramienta automatizada o malware.
¿Tráfico DNS con payloads excesivamente largos? Posible DNS tunneling.

🛑 Comandos encubiertos

Desde Wireshark puedes inspeccionar una conexión a example.com/admin.php y encontrar strings como:

ini
cmd=whoami

Aquí ya no estás infiriendo una amenaza, la estás leyendo en tiempo real.

📤 Exfiltración

Si un usuario está cargando ficheros a servicios sospechosos (Mega, anonfiles, GDrive), puedes capturar:

El archivo completo.
El nombre del archivo.
La URL de subida.
El agente HTTP usado.
Esto es oro puro para incident response y hunting.

🧬 Malware vivo

Un atacante envía un archivo .exe cifrado por HTTP. Lo detectas, lo exportas desde la captura y lo mandas a análisis estático/dinámico. Ahora sabes qué malware era, qué hacía y a quién llamó.

✨ Poderes especiales del análisis de paquetes

Puedes reconstruir una conversación TCP completa: desde el SYN inicial hasta el cierre de sesión. Es como leer un chat secreto entre el atacante y la víctima.
Puedes detectar tráfico cifrado sin SNI, usado frecuentemente para evadir detección.
Puedes ver tráfico enviado a C2 que no ha sido bloqueado por el firewall o el EDR.
Y lo más importante: puedes comprobar la veracidad de una alerta sin depender de terceros.

💡 Ejemplo de uso en hunting real:

Una alerta de EDR muestra ejecución de PowerShell. Desde el SIEM pivotas al log Zeek de conexión. Aparece una IP sospechosa. Desde ahí, accedes al PCAP capturado por Suricata.
En Wireshark, reconstruyes la petición HTTP: es una descarga de un script .ps1 desde una URL ofuscada.
Abres el contenido del payload: ves comandos de persistencia, beaconing a intervalos regulares y comandos codificados en Base64. Confirmado: ataque activo en curso.

Parte 2 — Capturas de paquetes: Técnicas de análisis avanzado para Threat Hunting

Mientras que en la Parte 1 cubrimos el qué y el cómo básico, ahora vamos a adentrarnos en el análisis táctico y estratégico de capturas, aplicando conocimientos de TTP (tácticas, técnicas y procedimientos) del atacante, decodificación de tráfico, detección de evasiones y extracción de IOCs en crudo.

🔎 1. Detección de evasiones y comportamiento anómalo

Los atacantes cada vez usan más técnicas para ocultar sus pasos. Las capturas de paquetes bien configuradas te permiten detectar:

📌 Evasión de EDR/SIEM:

Uso de protocolos no estándares (por ejemplo, datos encubiertos en ICMP o DNS).
Modificación de user-agent en conexiones HTTP (indicador de automatización).
Tráfico cifrado sin SNI (Server Name Indication): habitual en malware que intenta evitar la inspección profunda TLS.

📌 Reconocimiento silencioso:

Uso de Nmap con -sS o -sN que solo generan paquetes incompletos o no convencionales (puedes detectarlo con Wireshark buscando flags TCP raros, como paquetes sin ACK o con URG/SYN sin sentido).

🧰 2. Filtros y expresiones avanzadas en Wireshark

Para cazar en tráfico real necesitas saber aplicar los filtros correctos:

http.request.method == "POST"
tcp.port == 4444
dns.qry.name contains "exfil"
frame contains "powershell"
tcp.analysis.retransmission
tls.handshake.extensions_server_name contains "suspiciousdomain"

Cada uno de estos filtros apunta a una TTP específica: exfiltración, C2, actividad automatizada, evasión o anomalías de red.

🐚 3. Análisis manual de tráfico cifrado

Aunque TLS cifra los datos, el handshake inicial aún revela patrones:

¿Qué SNI aparece?
¿Qué ciphersuites se negocian?
¿La longitud de los paquetes es uniforme? → Esto puede indicar túneles encapsulados o beacons regulares.
¿Hay uso de certificados autofirmados, expirados o comunes en malware?

Herramientas como Wireshark o Zeek permiten ver estos detalles sin necesidad de romper el cifrado.

🧪 4. Extracción de binarios y scripts maliciosos

Wireshark permite exportar:

Archivos transferidos por HTTP o FTP.
Cargas útiles dentro de POST o PUT.
Fragmentos binarios para análisis manual o envío a sandbox.

Esto permite descubrir:

.exe, .js, .ps1, .vbs, .doc con macros, ZIPs cifrados…
Scripts ofuscados que puedes decodificar con CyberChef.

📈 5. Reconstrucción de sesiones y líneas temporales

El hunting avanzado requiere conectar los puntos. A partir del tráfico capturado puedes:

Reconstruir sesiones TCP completas.
Visualizar líneas de tiempo de actividad sospechosa: inicio de conexión, autenticación, ejecución, exfiltración.
Correlacionar eventos entre múltiples IPs: ¿quién fue primero?, ¿quién respondió?, ¿cuánto duró la sesión?

Esto es esencial para entender el kill chain de un ataque y aplicar contención estratégica.

📡 6. Integración con inteligencia de amenazas

Puedes comparar IOCs extraídos con:

VirusTotal (hashes de archivos descargados).
AbuseIPDB (IPs de conexión).
ThreatFox o MISP (dominios, URLs).
YARA + CyberChef para análisis del payload.

También puedes cargar PCAPs directamente en:

NetworkMiner (extrae artefactos automáticamente).
Brim/ZEEK logs (para visión cronológica y contextual).
Arkime (para búsqueda masiva en históricos de red).

🔐 7. Técnicas específicas de hunting en PCAPs

Técnica Indicador

DNS Tunneling Muchas queries TXT o A hacia dominios con subdominios largos y variables
C2 vía HTTPS Tráfico TLS regular, bajo volumen, conexiones periódicas (beaconing)
Escaneo sigiloso Muchos SYN sin ACK/FIN, múltiples puertos, múltiples hosts
Upload sospechoso HTTP POST con tamaños grandes, sin headers típicos
Exfiltración lenta Tráfico saliente constante hacia el mismo dominio con JSON, TXT, XML

💣 Ejemplo práctico

Un endpoint alerta sobre PowerShell ofuscado.

Desde el SIEM pivotas al PCAP de Suricata. Filtro en Wireshark:
sql: http.request.uri contains "ps1" Resultado: tráfico hacia https://185.82.126.123/payload.ps1.
Exportas el archivo → análisis estático revela código de persistencia y ejecución de mshta.
Pivotas en el tráfico hacia esa IP → detectas beacons regulares vía TLS.
Fin: detectas C2 activo, IP maliciosa, persistencia y vector inicial.

🔍 ANÁLISIS DE PCAPS: TÁCTICAS MUY AVANZADAS DE THREAT HUNTING

🧨 1. Detección de Tácticas de Comando y Control (C2) Invisibles

🧿 Beaconing encubierto

Tiempos exactos de conexión (por ejemplo, cada 60.000 ms).
Paquetes pequeños, unidireccionales, en TLS o HTTP.
Header TLS/SNI válido pero tráfico de cliente sospechoso (uso de JA3 hash poco frecuente).

Herramienta sugerida:

Zeek con script intel/beaconing.zeek
JA3/JA3S fingerprinting
RITA para análisis estadístico de C2

🛠️ 2. Inspección de Payloads Cifrados sin Romper TLS

A veces, no hace falta romper el TLS para cazar:

Extraer longitud, frecuencia, y patrón de paquetes → detectar exfiltración lenta.
Analizar el handshake TLS → buscar certificados autofirmados, fechas inválidas, rarezas en el issuer o CN.
Detección de conexiones TLS con SNI vacío o genérico, lo cual suele ser evasivo.

Script útil (Zeek):

zeekCopiarevent ssl_established(c: connection) { if (c$ssl?$server_name && c$ssl$server_name == "") { print fmt("⚠️ TLS sin SNI: %s", c$id$resp_h); } }

🧬 3. Hunting por Protocolos Abusados

Detectar cuando se abusa de protocolos legítimos para exfiltración:

Protocolo Técnica de abuso Indicador
DNS Túnel vía TXT o A (dns2tcp, iodine) Subdominios largos, TTLs altos
HTTP/S Exfiltración de datos via POST Tamaños de POST anómalos
ICMP Ping tunneling (ptunnel, Loki) Tráfico ICMP de tamaño uniforme
SMB Comms C2 dentro de shares ocultas Tráfico SMB desde hosts no válidos

Herramienta ideal: Zeek con módulos específicos (DNS, SMB, HTTP).

🔓 4. Extracción de Binarios y Análisis Estático Dinámico

Extracción con Wireshark:

shCopiarFile > Export Objects > HTTP

Análisis siguiente paso:

CyberChef: decodifica base64, gzip, XOR...
Strings + file + upx + binwalk → para ver si está ofuscado o embebido.
VirusTotal o análisis en sandbox (Cuckoo, Any.run).

📦 5. Análisis de Flujos NetFlow / IPFIX (en lugar de paquetes)

Cuando no hay PCAPs completos pero sí flujos:

Detectar:
- Bytes salientes excesivos
- Comunicación persistente entre dos IPs sin motivo aparente
- Múltiples conexiones hacia puertos no estándar

Flujos sospechosos comunes:

C2 en puertos raros: tcp.port == 4433 || 8443
Backdoors reversos: tcp.flags == SYN && ip.dst == <rango externo>

Herramientas top: nfdump, SiLK, FlowPlotter

📜 6. Reconstrucción de Timeline Multicapa del Ataque

Correlacionar:

PCAP + Sysmon logs + Eventos del SIEM
Crear un timeline forense real:

[10:24:01] Descarga desde https://abc.com/payload.exe
[10:24:02] Escritura en disco C:\Users\user\payload.exe
[10:24:03] Inyección a explorer.exe
[10:24:05] Beacon TLS a c2.evilserver.ru:443

Esto permite armar:

TTPs completas
Reglas de Sigma/YARA personalizadas
Contención específica por IOC o por comportamiento

💡 7. Indicadores Oscuros Avanzados (Heurísticos)

Indicador: Interpretación

Payload cifrado en HTTP sin TLS Encubrimiento manual de malware
DNS con base32 en subdominios DGA o exfiltración por DNS
Conexiones entrantes breves desde muchos países Escaneo masivo o backdoor P2P
TLS sin ALPN (Application Layer Protocol Negotiation) Malware usando TLS personalizado
JA3 + JA3S muy raros o inexistentes Clientes personalizados (malware)

🔥 BONUS — Check rápido para C2 y exfiltración

1. ¿SNI sospechoso?

zeek
cat ssl.log | grep -Ei ".*(dynamicdns|duckdns|no-ip|zapto|servehttp).*"

2. ¿Transferencias POST grandes en HTTP?

zeek
cat http.log | awk '$9=="POST" && $10 > 100000 { print $0 }'

3. ¿Tráfico periódico exacto? (beaconing)

sh
rita analyze --beacons --beacon-threshold 0.99

CURIOSIDADES AVANZADAS DE UN THREAT HUNTER

🧬 1. El tráfico en silencio a veces grita más que los logs ruidosos

🔍 Lo que no se conecta puede ser más interesante que lo que sí lo hace.

Cuando un endpoint deja de comunicarse repentinamente con un dominio activo, puede significar que fue bloqueado… o que el atacante ha cambiado a otro canal.
Hay campañas de APT que solo lanzan payloads si el tráfico DNS no devuelve resolución válida, para evitar sandboxing.

📦 2. Los ZIP, PNG o PDF pueden contener malware sin ejecutar nada

📎 Muchas campañas de spear phishing esconden payloads en documentos "inocentes" sin macros.

Algunos PNG tienen código embebido en los "chunks" no estándar como zTXt, iTXt o incluso LSBs (least significant bits).
CyberChef + binwalk puede revelar cargas ocultas dentro de un archivo que, visualmente, parece inofensivo.
Se han reportado C2 a través de EXIF en JPG (malware Stegosploit, por ejemplo).

🧠 3. Los atacantes usan herramientas de Red Team más de lo que crees

🩸 Cobalt Strike, Empire, Sliver, Brute Ratel... Todos disponibles en foros underground.

Los forks de herramientas legítimas son ligeramente modificados para evitar detección.
Muchos C2 tienen opciones de evasión integradas:
- Sleep jitter
- TLS personalizado
- DNS tunneling
¿La ironía? Algunas detecciones son posibles sólo si el hunter también ha jugado en el Red Team.

⛓️ 4. Los IDS tradicionales no detectan cadenas de ataque encadenadas

🧪 Una sola alerta de IDS no sirve si no ves el contexto.

Ataques reales vienen fragmentados en 5–10 fases distintas: reconocimiento pasivo, phishing, LNK, dropper, persistence, beaconing…
Un solo paquete puede parecer benigno, pero si está precedido por command-and-control o precede un RDP lateral, es parte de la kill chain.

🦠 5. El malware moderno no siempre tiene comportamiento malicioso

🧊 Muchos binarios maliciosos esperan... días, semanas.

Algunos cargan DLLs sin ejecutarlas hasta que detectan:
- Dirección IP corporativa
- Que el host no esté en una sandbox
- Presencia de usuarios humanos (movimiento de ratón o teclado)
Esto hace que las sandbox tradicionales fallen. Un buen hunter caza en memoria, red y correlación de eventos entre días distintos.

🕳️ 6. Wireshark muestra solo la superficie

🐍 El buen hunter no usa solo Wireshark. Lo mezcla con Zeek, Tshark, tcpdump, Suricata y CyberChef.

Wireshark no detecta:
- Beaconing periódico
- JA3 fingerprint
- Payloads cifrados con XOR/ROT13/Base64
Un hunter verdadero no solo mira: extrae, decodifica, reconstruye.

🎭 7. El tráfico HTTPS también canta

🔐 Aunque esté cifrado, puedes saber mucho sin romper TLS:

JA3 / JA3S: hashes únicos del handshake → cada C2 tiene su fingerprint.
ALPN ausente o incorrecto = sospecha.
Certificados autofirmados, o válidos pero con nombres raros, como mail-app-push2-update.shop...
SNI sin relación con el certificado → desfase = probable evasión.

💀 8. Los atacantes ya no te atacan directamente

🕷️ Bienvenido al siglo XXI: la mayoría de los ataques empiezan en endpoints de terceros.

Supply chain, extensiones de navegador, NPM/PyPi infectados, updates de software, CDNs comprometidos.
Ejemplo: el malware SolarWinds o los ataques vía 3CX VoIP.
Solución: auditoría constante de tráfico de terceros confiables, listas allowlist vigiladas.

🧠 9. A veces, los mejores IOC son… los errores del atacante

🪓 ¿Sabías que muchos grupos APT han sido expuestos por metadatos, errores en scripts o malas configuraciones?

Scripts mal hechos que no eliminan logs (powershell -enc sin limpiar).
Archivos .rar con nombres mal traducidos o codificados mal.
Certificados TLS con fechas vencidas o errores de compilación.
Comentarios dentro del código con pseudónimos, IPs o paths internos del atacante.

🚨 10. El hunter avanzado no busca solo "lo malo", sino lo "anómalo"

🎯 Piensa como cazador, no como antivirus.

Buscar lo desconocido con comportamiento raro, no solo lo conocido con firma.
Técnica:
- "¿Por qué este endpoint se comunica con un dominio en Uzbekistán cada 12 minutos?"
- "¿Por qué este ejecutable firma un PDF pero se comunica por ICMP?"
- "¿Por qué este .msi pesa 40 MB pero no instala nada?"

👉 Ese "por qué" es lo que separa al observador del verdadero Threat Hunter.

🕵️‍♀️ 11. Los atacantes usan Discord, Slack y Telegram como C2

📡 Ya no necesitan un servidor web sospechoso si pueden camuflarse en el chat.

Bots de Telegram que reciben comandos cifrados en chats privados.
C2 embebido en canales privados de Discord usando webhooks.
Malware que se comunica vía Slack usando tokens válidos de API.

🔎 Cómo detectarlo:
Busca tráfico HTTPS con destinos a cdn.discordapp.com, slack.com/api/, api.telegram.org… desde procesos que no deberían hacer eso (ej: powershell.exe, explorer.exe).

🧪 12. El malware que no escribe en disco no deja casi rastro

🐍 Bienvenido a los ataques fileless: viven en memoria.

PowerShell o WMI descargan cargas útiles directamente en RAM (Invoke-Expression, Reflective DLL Injection).
Algunas variantes usan Living Off The Land Binaries (LOLBins) como mshta.exe, regsvr32.exe, rundll32.exe.

🧠 Lo curioso: no verás archivos, pero el tráfico C2, los procesos sospechosos y los eventos de ETW (Event Tracing for Windows) sí están.

🦠 13. Algunos malware se esconden como procesos válidos… pero solo visualmente

🪞 Proceso real, ruta falsa. Ruta real, proceso falso.

svch0st.exe (cero en vez de "o"), lsasss.exe, chrome32.exe, explorer1.exe…
Todos lucen normales en un listado casual.

🔍 Herramientas como:
Process Hacker, Sysinternals, PE-sieve, Autoruns, y revisa el path completo, el hash y el parent PID.
💡 Parent process analysis = clave de oro.

💉 14. Algunos ataques solo viven 2 segundos

🧬 ¿No ves nada? Tal vez fue muy rápido. O tal vez no estabas mirando.

Hay malware que se ejecuta, exfiltra y se borra en segundos.
¿Cómo detectarlos?:
- Revisar registros WMI, Sysmon, EDR, o capturas de red en buffer continuo.
- Usar Process Creation Events, ScriptBlockLogging y ETW.

📈 15. Beaconing no es solo cada 5 minutos

⏱️ Los C2 modernos aplican timing aleatorio, para evitar detección por patrones.

Algunos se comunican:
- Solo fuera del horario laboral.
- Solo si detectan un proceso humano (movimiento de mouse o teclado).
- Con jitter aleatorio: cada 6.03 min, luego 8.55, luego 5.2…

🧠 Lo que ayuda a detectarlos:

Grafos de comunicación, análisis de entropy, detección de outliers en DNS o HTTP.

🧛‍♂️ 16. Hay malware que se clona y luego borra el original

🧬 Ejecuta un script que se replica como otro nombre, luego borra el inicial.

El proceso final no tiene el nombre que tú analizaste.
Muy usado en ransomware y droppers.
También popular entre APT y RATs personalizados.

🔎 ¿Cómo se ve?

Creación de procesos en cadena (PID tree anormal).
cmd.exe → powershell.exe → newprocess.exe → delete file.

🔐 17. Las credenciales robadas no siempre van a un C2

📦 A veces son guardadas localmente y exfiltradas días después.

Malware roba con Mimikatz, LSASS dump o keyloggers, y guarda en .tmp, .dat, o .zip.
Luego usa canales como FTP, HTTPS, o incluso correo saliente con scripts como blat.exe.

💡 Clave para cazarlos:

Revisa carpetas temporales.
Busca archivos comprimidos nuevos fuera de horario laboral.
Monitorea tráfico saliente a servidores poco comunes o SMTP externos.

🧿 18. Muchos C2 ahora usan DNS, pero no para comandos

📡 Usan peticiones DNS para saber si estás conectado, o si estás en una sandbox.

Malware que hace peticiones tipo:
- checkin.mysid.12345.attacker.com
- ping.laptopcorp.internal.attacker.com

👀 El subdominio es el mensaje.
Revisa tus logs de DNS hacia dominios dinámicos, extraños, o que cambian con cada host.

🌐 19. Un hunting real combina red + host + correlación temporal

⚖️ Ver red sin host es como mirar solo una cámara. Ver host sin red es como leer solo los subtítulos.

💡 El verdadero threat hunter:

Ve un proceso anómalo (ej: winword.exe ejecuta PowerShell)
Correlaciona con tráfico (ej: conexión HTTPS hacia raw.githubusercontent.com)
Revisa si hay archivos, persistencia, beaconing
Traza el árbol de procesos, los cambios en el registro, y los eventos del firewall

🧰 20. El arsenal real de un Threat Hunter incluye:

Tipo de herramienta: Ejemplos

Análisis de Red: Wireshark, Zeek, Suricata, Tshark
Decodificación: CyberChef, base64 decoder, XOR analyzer
Sistema: Sysmon, Process Hacker, Autoruns
EDR / SIEM: SentinelOne, Defender ATP, Splunk, ELK
Sandbox: Any.Run, Cuckoo, Hybrid Analysis
Reversing: Ghidra, IDA Free, PEStudio, Detect It Easy
OSINT: VirusTotal, AbuseIPDB, Shodan, URLScan.io
Threat Intelligence: MISP, Maltrail, ThreatFox, OpenCTI