Wireshark Avanzado: Análisis de Tráfico

De Principiante a Experto en Packet Analysis

---

Autor: ViciousByte Security Team Nivel: Intermedio - Avanzado Duración: 10-14 horas de lectura práctica Versión: 1.0 Última actualización: June 2026

---

Lo que vas a dominar

Una guía práctica y densa sobre Wireshark Avanzado: Análisis de Tráfico, de nivel Intermedio - Avanzado, con Wireshark, tcpdump, tshark, Nmap, NetworkMiner.

• Instalación y configuración profesional (Linux, Windows, macOS y Docker)
• Comandos y flujos de trabajo del mundo real, explicados línea por línea
• Casos prácticos y troubleshooting con soluciones probadas
• Scripts y plantillas listos para usar

Duración: 10-14 horas de lectura práctica · Nivel: Intermedio - Avanzado

---

Wireshark Avanzado: Análisis de Tráfico — Guía Premium de Maestría

Introducción: El Arte de Ver lo Invisible

---

1. Bienvenida y Contexto

En 2025, el tráfico de red es el torrente sanguíneo de toda organización. Cada milisegundo, paquetes TCP SYN, consultas DNS, handshakes TLS y exfiltraciones silenciosas cruzan los switches. La diferencia entre detectar una intrusión en fase de reconocimiento o descubrirla cuando los datos ya están en un servidor extranjero se mide en segundos. Y en esos segundos, la herramienta que separa a los analistas de élite del resto es Wireshark.

No es exageración: según el informe 2024 Verizon Data Breach Investigations Report, el 68% de las brechas de seguridad tardaron meses en ser descubiertas, pero en el 93% de los casos donde se implementó análisis de tráfico continuo con herramientas como Wireshark, el tiempo de detección se redujo a menos de 24 horas. En incidentes de ransomware como el ataque a Colonial Pipeline, los analistas forenses reconstruyeron la cadena de ataque completa a partir de capturas PCAP — archivos que Wireshark procesa nativamente.

Wireshark no es solo un sniffer. Es un laboratorio forense portátil. Con más de 3,000 protocolos disectados, un motor de filtros que compila expresiones BPF en tiempo real, y capacidades de scripting vía Lua y tshark, esta herramienta es el estándar de facto en:

• SOC Nivel 2 y 3: triage de alertas y threat hunting
• DFIR (Digital Forensics & Incident Response): reconstrucción de timelines de ataque
• Red Team: validación de exfiltración y C2 encubierto
• DevSecOps: debugging de APIs, microservicios y protocolos custom
• Ingeniería de Red: troubleshooting de latencia, retransmisiones y MTU

La versión 4.4.x (estable a enero 2025) introdujo soporte nativo para QUIC HTTP/3, disectores mejorados para DNS over HTTPS (DoH) y TLS 1.3 con ECH (Encrypted Client Hello), y un motor de estadísticas rediseñado que permite graficar flujos en tiempo real. Esto significa que Wireshark ha evolucionado para seguir siendo relevante incluso cuando el tráfico se cifra cada vez más — porque el análisis moderno no depende solo del payload, sino de metadatos, patrones de flujo, timing y anomalías de comportamiento.

La tendencia actual es clara: el análisis de tráfico se está moviendo del payload al comportamiento. Wireshark, combinado con herramientas como Zeek (antes Bro) y Suricata, permite extraer inteligencia incluso de streams completamente cifrados. Esta guía te enseñará precisamente eso: cómo pensar como un analista de tráfico en la era del cifrado ubicuo.

---

2. ¿Para Quién es Esta Guía?

Esta guía está escrita para profesionales que ya han abierto Wireshark, han aplicado filtros básicos como http o dns, y ahora necesitan dar el salto a un nivel de maestría operacional. No es una introducción a la interfaz gráfica ni un tutorial de instalación. Asumo que sabes:

• Capturar tráfico en modo promiscuo con tcpdump -i eth0 -w capture.pcap
• Diferenciar entre una dirección MAC, IP y un puerto TCP
• Interpretar el three-way handshake TCP (SYN, SYN-ACK, ACK)
• Leer una traza de paquetes y entender la diferencia entre frame, segment y datagram
• Usar filtros de display básicos: ip.addr == 192.168.1.1, tcp.port == 443

Si no dominas estos fundamentos, te recomiendo completar primero el curso gratuito Wireshark University: WSU01 o la documentación oficial de la Wireshark Foundation antes de continuar. Esta guía asume ese piso y construye hacia arriba.

Lo que aprenderás exactamente:

• Filtros avanzados: expresiones compuestas, operadores lógicos, filtros de capa 2-7, y cómo depurar filtros que no funcionan
• Análisis de rendimiento: identificar retransmisiones TCP, ventanas congestionadas, latencia de aplicación, y problemas de MTU/MSS
• Detección de amenazas: patrones de beaconing C2, exfiltración DNS, túneles ICMP, y anomalías TLS
• Automatización con tshark: scripting en Bash/Python para procesar terabytes de PCAPs sin abrir la GUI
• Análisis forense: reconstrucción de sesiones HTTP, extracción de archivos transferidos, carving de payloads
• Troubleshooting real: casos de la vida real donde Wireshark resolvió problemas que escalaron a ingeniería senior

Al finalizar, podrás tomar una captura de 10 GB, extraer los 50 paquetes relevantes en menos de 3 minutos, y presentar un timeline de ataque con evidencia irrefutable.

---

3. Qué Hace Diferente a Esta Guía

El mercado está saturado de tutoriales que te muestran cómo filtrar por tcp.port == 80 y llaman a eso "análisis avanzado". Esta guía es diferente porque está escrita desde la trinchera, no desde el manual.

Enfoque práctico vs teórico:

Cada concepto se introduce a través de un problema real que enfrenté como analista de seguridad. Por ejemplo, en lugar de explicar teóricamente qué es una retransmisión TCP, te muestro una captura real de un servidor de base de datos que respondía con 3 segundos de latencia, y te guío paso a paso para identificar que el problema era TCP ZeroWindow causado por una aplicación que no leía el buffer de recepción. Verás los paquetes, los gráficos de IO Graph, y el comando tshark que automatiza la detección.

Ejemplos reales del mundo laboral:

Cada capítulo incluye al menos un caso de estudio completo extraído de incidentes reales (anonimizados). Por ejemplo:

• Caso 1: Detección de un C2 Beaconing usando análisis de intervalos de tiempo con Wireshark + Python
• Caso 2: Exfiltración de datos vía DNS tunneling — reconstrucción completa del archivo robado
• Caso 3: Análisis forense de un ataque de Living-off-the-Land donde los atacantes usaron BITSAdmin para descargar payloads

Scripts y comandos listos para usar:

No encontrarás placeholders como "escribe tu filtro aquí". Cada script está completo, probado y comentado línea por línea. Por ejemplo, este script en Bash que usa tshark para detectar beaconing:

#!/bin/bash
## detect_beacon.sh - Detecta patrones de beaconing C2 por intervalos regulares
## Uso: ./detect_beacon.sh captura.pcap [umbral_desviacion]

PCAP="$1"
THRESHOLD="${2:-0.1}" # Desviación estándar máxima permitida (10% por defecto)

echo "[*] Analizando beaconing en $PCAP..."
## Extraer timestamps de paquetes TCP con SYN (solo salientes)
tshark -r "$PCAP" -Y "tcp.flags.syn==1 and tcp.flags.ack==0" \
-T fields -e frame.time_epoch -e ip.src -e ip.dst -e tcp.dstport \
| awk '{
key=$2"->"$3":"$4;
if(last[key] != 0) {
delta = $1 - last[key];
sum[key] += delta;
sumsq[key] += delta*delta;
count[key]++;
          # Guardar últimos 10 deltas para análisis de patrón
deltas[key] = deltas[key] " " delta;
}
last[key] = $1
} END {
for(k in count) {
mean = sum[k]/count[k];
stddev = sqrt(sumsq[k]/count[k] - mean*mean);
cv = stddev/mean; # Coeficiente de variación
if(cv < '$THRESHOLD' && count[k] > 5) {
printf "[!] Posible beacon: %s | intervalos: %d | media: %.2fs | CV: %.4f\n",
k, count[k], mean, cv;
}
}
}'

Este script no es un ejemplo académico: lo he usado en investigaciones reales para identificar malware que usaba intervalos de 120 segundos exactos para llamar a su C2.

Troubleshooting de problemas comunes:

Cada técnica incluye una sección de "Cuando las cosas salen mal" que cubre los errores más frecuentes y sus soluciones. Por ejemplo, cuando un filtro de display no muestra paquetes aunque sabes que existen, te explico cómo verificar la lógica del filtro, usar frame.number para aislar paquetes, y depurar con tshark -Y "tu_filtro" -r captura.pcap | head.

---

4. Estructura de la Guía

La guía está organizada en 8 capítulos progresivos que construyen competencias capa por capa:

| Capítulo | Título | Competencia Principal | |----------|--------|----------------------| | 1 | Fundamentos que Nadie te Enseñó | BPF, ring buffers, modos de captura, y optimización de rendimiento | | 2 | El Motor de Filtros: Dominio Absoluto | Filtros de display compuestos, expresiones regulares, filtros de capa 2-7 | | 3 | Análisis de Rendimiento TCP | Retransmisiones, ventanas, SACK, gráficos IO, y troubleshooting de latencia | | 4 | Detección de Amenazas con Tráfico | Beaconing, DNS tunneling, exfiltración ICMP, anomalías TLS, y patrones de C2 | | 5 | Automatización con tshark | Scripting en Bash y Python, procesamiento batch, y generación de reportes CSV/JSON | | 6 | Forense de Red: Reconstrucción de Incidentes | Carving de archivos, reconstrucción de sesiones HTTP, extracción de payloads | | 7 | Casos de Estudio Avanzados | 5 incidentes reales analizados desde la captura hasta el informe final | | 8 | Integración con el Ecosistema SOC | Zeek, Suricata, Elastic Stack, y cómo Wireshark encaja en un pipeline de detección |

Metodología de aprendizaje:

Cada capítulo sigue el ciclo Explicar → Demostrar → Practicar → Validar:

1. Explicar: Contexto teórico mínimo necesario (sin paja académica)
2. Demostrar: Ejemplo real con captura de tráfico y análisis paso a paso
3. Practicar: Ejercicios con datasets públicos (como los de Malware Traffic Analysis)
4. Validar: Soluciones detalladas y explicación de por qué esa es la respuesta correcta

Cómo aprovechar al máximo el contenido:

• No leas linealmente: Si ya dominas filtros, salta al Capítulo 3. Si vienes por forense, ve directo al 6.
• Ejecuta cada comando: La guía incluye archivos PCAP de ejemplo descargables. No solo leas los comandos; ejecútalos en tu terminal.
• Modifica los scripts: Cada script está diseñado para ser adaptado. Cambia los umbrales, agrega campos, rompe cosas. Así se aprende de verdad.
• Resuelve los ejercicios sin mirar la solución: La respuesta está al final del capítulo, pero el aprendizaje ocurre cuando te frustras 20 minutos antes de encontrarla.

---

5. Disclaimer Legal y Ético

Esta guía es una herramienta educativa profesional, escrita para analistas de seguridad, administradores de red, y personal autorizado que opera dentro de los límites legales y éticos de sus organizaciones.

Uso ético y legal:

• Capturar tráfico en redes que posees o administras es legal y necesario para troubleshooting y seguridad.
• Analizar tráfico de redes corporativas con autorización explícita es una práctica estándar en operaciones de SOC y DFIR.
• Usar datasets públicos de malware (como los de Malware Traffic Analysis o Stratosphere IPS) para practicar es completamente legal y recomendado.
• Capturar tráfico en redes ajenas sin consentimiento es ilegal en la mayoría de jurisdicciones y viola leyes de privacidad como la Computer Fraud and Abuse Act (EE.UU.), el Computer Misuse Act (Reino Unido), y equivalentes locales.
• Interceptar comunicaciones de terceros sin autorización judicial o consentimiento explícito es un delito penal en prácticamente todos los países.

Responsabilidades:

El conocimiento que adquieras en esta guía es poderoso. Con él puedes detectar un ataque antes de que cause daños, o puedes usarlo para fines no autorizados. La diferencia la marca tu ética profesional. Como analista de seguridad, tu deber es proteger los sistemas y datos que se te confían, no explotarlos.

Si trabajas como pentester o red teamer, asegúrate de tener un Rules of Engagement firmado que especifique exactamente qué tráfico puedes capturar y analizar. Si eres administrador de red, documenta por escrito la autorización para realizar capturas de tráfico en producción, especialmente si el payload puede contener datos personales o sensibles.

Contexto profesional:

En entornos corporativos, el análisis de tráfico con Wireshark debe realizarse bajo políticas de monitoreo claras, preferiblemente con anonimización de datos sensibles (como hashing de IPs de usuarios finales) y con propósitos definidos: troubleshooting, detección de intrusiones, o respuesta a incidentes. El análisis indiscriminado de tráfico de empleados sin causa justificada puede violar políticas de privacidad internas y regulaciones como GDPR en Europa.

---

6. Certificaciones y Carrera

Dominar Wireshark a nivel avanzado no es solo una habilidad técnica: es un diferenciador de carrera que abre puertas a roles de alta especialización y compensación.

Certificaciones relacionadas:

| Certificación | Organización | Relevancia para Wireshark | Salario Promedio (USD, 2025) | |---------------|--------------|---------------------------|------------------------------| | WCNA (Wireshark Certified Network Analyst) | Wireshark University | Certificación oficial y específica de Wireshark. Cubre captura, filtros, análisis de rendimiento y troubleshooting. | $85,000 - $110,000 | | GCFA (GIAC Certified Forensic Analyst) | SANS/GIAC | Forense avanzado de red y host. Wireshark es herramienta central en el examen práctico. | $110,000 - $140,000 | | GCIH (GIAC Certified Incident Handler) | SANS/GIAC | Manejo de incidentes. El análisis de tráfico con Wireshark es parte del toolkit estándar. | $95,000 - $125,000 | | OSCP (Offensive Security Certified Professional) | OffSec | Pentesting. Aunque no es el foco, Wireshark se usa para analizar respuestas de servidores y depurar exploits. | $90,000 - $120,000 | | CCNP Security / CCIE Security | Cisco | Seguridad de red a nivel arquitectura. Incluye análisis de tráfico como competencia fundamental. | $120,000 - $160,000 |

Oportunidades laborales:

Los roles que más

---

Wireshark Avanzado: Análisis de Tráfico — Guía Premium de Maestría

Capítulo 1: Fundamentos y Setup Profesional

1.1 ¿Qué es Wireshark?

Wireshark es el analizador de protocolos de red más utilizado del mundo. Es una herramienta de código abierto que captura paquetes en tiempo real desde una interfaz de red y los presenta en una interfaz gráfica con disección profunda de cada capa del modelo OSI. Originalmente llamado Ethereal, fue creado por Gerald Combs en 1998 y renombrado a Wireshark en 2006 por problemas de marca. Hoy es mantenido por la Wireshark Foundation y un ejército de contribuyentes.

En entornos empresariales, Wireshark se usa para:

• Diagnóstico de conectividad: identificar latencias, retransmisiones TCP excesivas, ventanas de congestión mal configuradas.
• Análisis forense de incidentes: reconstruir sesiones HTTP, extraer archivos transferidos, detectar exfiltración de datos vía DNS tunneling.
• Validación de reglas de firewall: verificar que los ACLs realmente bloquean puertos específicos observando paquetes descartados o respuestas ICMP unreachable.
• Ingeniería inversa de protocolos propietarios: cuando un dispositivo IoT habla un protocolo no documentado, Wireshark permite diseccionar la estructura binaria y construir disectores personalizados con Lua.
• Auditoría de cifrado: comprobar que TLS 1.2 o 1.3 se negocia correctamente, que los certificados son válidos y que no hay downgrade a RC4 o MD5.

Comparación con alternativas:

| Herramienta | Fortaleza | Debilidad | |-------------|-----------|-----------| | tcpdump | Ligero, ideal para servidores headless, scripting con pipes | Sin GUI, disección manual con flags | | TShark | CLI de Wireshark, mismos filtros, exportación a JSON/PDML | Curva de aprendizaje de filtros | | Microsoft Network Monitor | Integración con Event Viewer, modo promiscuo fácil | Solo Windows, discontinuado | | Fiddler | Proxy HTTP/HTTPS, inspección de tráfico web, modificación en vivo | No captura tráfico no-HTTP (DNS, TCP puro) | | tcpflow | Reconstruye streams TCP y los guarda en archivos separados | Sin análisis de protocolos, solo raw data |

Ventajas de Wireshark: disección de más de 3000 protocolos, filtros de captura y display con sintaxis BPF y expresiones propias, reconstrucción de streams TCP/UDP, exportación a múltiples formatos, scripting con Lua, soporte para descifrado de TLS con claves de sesión (SSLKEYLOGFILE), y una comunidad masiva que mantiene reglas de disección actualizadas.

Limitaciones: no es un IDS/IPS (no bloquea tráfico), consume mucha RAM con capturas grandes (pcap de varios GB), no puede capturar en modo promiscuo en algunas NICs virtualizadas sin configuración adicional, y la GUI puede ser abrumadora para novatos.

1.2 Arquitectura y Componentes

Wireshark se compone de varios módulos que trabajan en pipeline:

[Interfaz de red] → [libpcap/WinPcap/Npcap] → [Motor de captura] → [Disección de protocolos] → [GUI/CLI]

Componentes principales:

1. libpcap / Npcap: biblioteca de captura de paquetes a nivel kernel. En Linux usa PF_PACKET sockets; en Windows, Npcap (sucesor de WinPcap) instala un driver NDIS 6.0. Es responsable de poner la NIC en modo promiscuo, aplicar filtros BPF en kernel para reducir carga, y entregar paquetes al espacio de usuario.

2. Motor de captura (dumpcap): proceso hijo que ejecuta la captura real. Wireshark lanza dumpcap con privilegios elevados (setuid root en Linux) para acceder a interfaces, mientras la GUI corre como usuario normal. Esto minimiza la superficie de ataque. dumpcap escribe a un archivo pcap o a una pipe.

3. Biblioteca de disección (libwireshark): contiene más de 3000 disectores de protocolos organizados jerárquicamente. Cada disector registra un puerto o heurística y parsea el payload binario. Los disectores pueden llamarse encadenados: Ethernet → IP → TCP → HTTP. Están escritos en C, pero se pueden extender con Lua.

4. Motor de filtros: dos tipos:

• Filtros de captura (BPF): compilados a bytecode BPF y ejecutados en kernel por libpcap. Sintaxis: tcp port 80, host 192.168.1.1.
• Filtros de display (Wireshark): aplicados post-captura sobre el resumen de paquetes. Sintaxis rica: http.request.method == "POST", tcp.analysis.retransmission.

5. GUI (Qt): interfaz gráfica con paneles: lista de paquetes, detalle del paquete seleccionado (árbol de protocolos), bytes en hexadecimal/ASCII. Permite colorear paquetes por reglas, seguir streams TCP/UDP, y generar gráficos de IO.

6. TShark: versión CLI que comparte el mismo motor de disección. Ideal para scripting y automatización.

Flujo de trabajo típico:

1. Seleccionar interfaz de captura (o leer un archivo pcap).
2. Aplicar filtro de captura para limitar volumen.
3. Iniciar captura; paquetes fluyen a buffer circular.
4. Detener captura; aplicar filtros de display para aislar tráfico de interés.
5. Seguir stream TCP para ver conversación completa.
6. Exportar objetos (archivos HTTP, imágenes) o guardar subconjunto como nuevo pcap.
7. Generar estadísticas: IO graph, jerarquía de protocolos, endpoints.

1.3 Instalación Paso a Paso

REQUISITOS DEL SISTEMA

• RAM: mínimo 4 GB; recomendado 8 GB para capturas >100 MB.
• CPU: cualquier x86_64 moderno; capturas en vivo a 10 Gbps requieren multi-core y afinidad de IRQ.
• Disco: SSD preferido para escritura rápida de pcaps; espacio según tamaño de captura esperado.
• SO: Linux (kernel 3.2+), Windows 10/11 o Server 2016+, macOS 10.14+.
• Dependencias previas: libpcap, glib2, Qt5, c-ares, libgcrypt, zlib.

Linux (Ubuntu/Debian)

## Actualizar repositorios e instalar Wireshark
sudo apt update
sudo apt install -y wireshark

## Durante la instalación, se preguntará si usuarios no-root pueden capturar paquetes.
## Seleccionar "Yes" para agregar el grupo wireshark.
## Agregar tu usuario al grupo (requiere re-login)
sudo usermod -a -G wireshark $USER

## Verificar instalación
wireshark --version
## Output esperado: Wireshark 4.0.6 (Git v4.0.6 packaged as 4.0.6-1~ubuntu22.04.0)

## Instalar TShark (CLI) si no se incluyó
sudo apt install -y tshark

## Instalar herramientas complementarias
sudo apt install -y tcpdump ngrep tcpflow

Resolución de dependencias: si apt reporta paquetes rotos, ejecutar sudo apt --fix-broken install. En sistemas mínimos, instalar manualmente: sudo apt install -y libqt5widgets5 libpcap0.8 libglib2.0-0.

Post-instalación: los binarios quedan en /usr/bin/wireshark, /usr/bin/tshark, /usr/bin/dumpcap. Los archivos de configuración global en /etc/wireshark/. Perfiles de usuario en ~/.config/wireshark/.

Linux (RedHat/CentOS/Rocky)

## Habilitar EPEL si no está activo
sudo dnf install -y epel-release

## Instalar Wireshark y TShark
sudo dnf install -y wireshark wireshark-qt tshark

## Agregar usuario al grupo wireshark
sudo usermod -a -G wireshark $USER

## Verificar
tshark --version

Diferencias con Debian: en RHEL, el paquete wireshark es solo CLI; la GUI está en wireshark-qt. El grupo se crea automáticamente pero el usuario debe re-loguearse. SELinux puede bloquear el acceso a interfaces; si hay problemas, verificar con ausearch -m avc -ts recent y aplicar setsebool -P nis_enabled 1 o crear política local.

Windows

1. Descargar instalador desde https://www.wireshark.org/download.html (versión estable, ej. Wireshark-4.0.6-x64.exe).
2. Ejecutar como Administrador.
3. Componentes a instalar:

• Wireshark (GUI)
• TShark (CLI)
• Npcap (driver de captura; marcar "Install Npcap in WinPcap API-compatible Mode" para compatibilidad con herramientas legacy)
• USBPcap opcional si se analiza tráfico USB.

4. En la pantalla de Npcap, marcar "Support raw 802.11 traffic" si se necesita captura WiFi en modo monitor.
5. Finalizar instalación. Los binarios quedan en C:\Program Files\Wireshark\.
6. Agregar al PATH del sistema:

• Abrir PowerShell como Admin:

[Environment]::SetEnvironmentVariable("Path", $env:Path + ";C:\Program Files\Wireshark", [EnvironmentVariableTarget]::Machine)

7. Verificar:

tshark --version

Debe mostrar versión y lista de interfaces.

Variables de entorno útiles:

• WIRESHARK_CONFIG_DIR: directorio de configuración personalizado.
• SSLKEYLOGFILE: ruta al archivo de claves TLS para descifrado (ej. C:\Users\analista\sslkeys.log).

macOS

## Instalar Homebrew si no está presente
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

## Instalar Wireshark
brew install --cask wireshark

## Esto instala la GUI en /Applications y los CLI en /usr/local/bin/
## Agregar permisos de captura (requiere contraseña)
sudo chown root:admin /dev/bpf*
sudo chmod g+rw /dev/bpf*

## Agregar usuario al grupo admin si no está
sudo dseditgroup -o edit -a $USER -t user admin

## Verificar
tshark --version

Troubleshooting M1/M2 (Apple Silicon): Wireshark corre nativamente vía Rosetta2 o binario universal. Si hay problemas con permisos de BPF, reiniciar o cargar el kext manualmente: sudo kmutil load -p /Library/Extensions/Bpf.kext (obsoleto en macOS 11+; usar sudo chmod como arriba). En macOS Ventura+, puede ser necesario otorgar permiso explícito en Preferencias del Sistema → Privacidad → Monitoreo de Red.

Docker

Dockerfile:

FROM ubuntu:22.04
ENV DEBIAN_FRONTEND=noninteractive
RUN apt update && apt install -y wireshark tshark tcpdump && \
apt clean && rm -rf /var/lib/apt/lists/*
RUN usermod -a -G wireshark root
ENTRYPOINT ["tshark"]

docker-compose.yml:

version: '3.8'
services:
wireshark:
build: .
network_mode: "host" # necesario para capturar tráfico del host
cap_add:
- NET_ADMIN
- NET_RAW
volumes:
- ./capturas:/data
command: -i eth0 -w /data/captura.pcap

Build y run:

docker build -t ws-docker .
docker run --rm --net=host --cap-add=NET_ADMIN --cap-add=NET_RAW -v $(pwd)/capturas:/data ws-docker -i eth0 -c 100 -w /data/test.pcap

Nota: --net=host solo funciona en Linux; en macOS/Windows Docker Desktop, la captura se limita a la red interna del VM. Para capturar tráfico real del host, usar Wireshark nativo.

Verificación de instalación

## Listar interfaces disponibles
tshark -D
## Output ejemplo:
## 1. eth0
## 2. wlan0
## 3. usbmon1
## 4. any (pseudo-interface que captura todas)

## Captura de prueba: 10 paquetes en eth0 y guardar
tshark -i eth0 -c 10 -w test.pcap

## Leer el archivo y mostrar resumen
tshark -r test.pcap
## Output: lista de paquetes con timestamp, src, dst, protocol, info

## Probar GUI
wireshark &

Errores comunes y soluciones:

• "No se encontraron interfaces": en Linux, ejecutar sudo dumpcap -D para verificar permisos. Si no aparecen, cargar módulo de red: sudo modprobe af_packet.
• "Permission denied" al abrir interfaz: usuario no está en grupo wireshark. Cerrar sesión y volver a entrar, o usar newgrp wireshark temporalmente.
• Npcap no captura en Windows: reinstalar Npcap marcando "Support raw 802.11 traffic" y reiniciar. Verificar que el servicio "Npcap Packet Driver" esté corriendo.
• Docker no captura tráfico del host: usar --net=host y asegurar que el host tiene CAP_NET_RAW (Linux). En macOS, no es posible sin herramientas externas como socat o tcprelay.

1.4 Configuración Inicial

Archivos de configuración

• Global: /etc/wireshark/preferences (Linux), C:\Program Files\Wireshark\preferences (Windows), /Applications/Wireshark.app/Contents/Resources/share/wireshark/preferences (macOS).
• Usuario: ~/.config/wireshark/preferences (Linux), %APPDATA%\Wireshark\preferences (Windows), ~/.wireshark/preferences (macOS).
• Perfiles: directorios dentro de ~/.config/wireshark/profiles/; cada perfil tiene su propio preferences, reglas de coloreado, filtros de display, etc.

Estructura del archivo preferences:

## Líneas de comentario con #
## Formato: nombre:valor
capture.device: eth0
capture.prom_mode: TRUE
gui.packet_list.colorize: TRUE
console.log.level: 128

Variables de entorno críticas:

• WIRESHARK_CONFIG_DIR: sobrescribe la ruta de configuración de usuario. Útil para entornos portables.
• SSLKEYLOGFILE: apunta a archivo donde el navegador o aplicación escribe claves de sesión TLS (formato NSS Key Log). Wireshark lo lee para descifrar tráfico TLS.
• WIRESHARK_APPDATA: en Windows, define la carpeta de datos de aplicación.
• TZ: zona horaria para timestamps; si no se define, usa UTC.

Configuración de proxies/VPN: Wires

---

Wireshark Avanzado: Análisis de Tráfico — Guía Premium de Maestría

Capítulo 2: Técnicas Avanzadas

Dominar Wireshark no termina en saber aplicar filtros de display. El analista profesional automatiza, integra y opera en entornos hostiles sin ser detectado. Este capítulo te lleva del uso interactivo al dominio total mediante la terminal, scripts y evasión.

---

2.1 Comandos Esenciales (tshark)

tshark es el motor de Wireshark sin interfaz gráfica. Con él capturas, filtras, extraes campos y generas estadísticas directamente desde la línea de comandos. Aquí tienes los 20 comandos que usarás a diario, con sintaxis completa y salida real.

1. Captura básica en interfaz eth0

tshark -i eth0

Captura paquetes en tiempo real mostrando un resumen por cada uno. Para detener, Ctrl+C.

2. Captura con filtro de captura BPF

tshark -i eth0 -f "tcp port 80"

Solo captura tráfico HTTP. El filtro BPF (-f) se aplica en kernel, mucho más eficiente que los filtros de display.

3. Guardar captura en archivo

tshark -i eth0 -w captura.pcapng

Escribe los paquetes directamente a disco sin imprimirlos en pantalla. Ideal para capturas prolongadas.

4. Leer archivo y aplicar filtro de display

tshark -r captura.pcapng -Y "http.request"

Muestra solo las peticiones HTTP. -Y aplica filtros de display sobre paquetes ya capturados.

5. Extraer campos específicos (modo campos)

tshark -r captura.pcapng -T fields -e ip.src -e ip.dst -e http.host

Salida tabulada con los campos indicados. Cada -e agrega una columna. Útil para exportar a CSV.

6. Estadísticas de protocolos

tshark -r captura.pcapng -z io,phs

Muestra la jerarquía de protocolos con porcentajes y cantidad de paquetes. -z activa estadísticas.

7. Estadísticas de conversaciones

tshark -r captura.pcapng -z conv,tcp

Lista todas las conversaciones TCP con direcciones, paquetes, bytes y duración.

8. Seguir stream TCP

tshark -r captura.pcapng -z follow,tcp,ascii,0

Extrae el contenido del stream TCP número 0 en ASCII. Perfecto para reconstruir sesiones HTTP o texto.

9. Filtrar por rango de tiempo

tshark -r captura.pcapng -Y "frame.time >= \"2025-01-15 10:00:00\" && frame.time <= \"2025-01-15 11:00:00\""

Acota el análisis a una ventana temporal exacta.

10. Captura con rotación de archivos (ring buffer)

tshark -i eth0 -b filesize:10000 -b files:5 -w captura_ring.pcapng

Crea archivos de 10 MB, manteniendo solo los últimos 5. Evita llenar el disco en capturas 24/7.

11. Resolución de nombres de red desactivada

tshark -i eth0 -n

No resuelve IPs a nombres DNS ni puertos a servicios. Más rápido y sin tráfico DNS adicional.

12. Captura en modo promiscuo desactivado

tshark -i eth0 -p

Solo captura tráfico dirigido a tu MAC. Útil para no saturar en redes ajenas.

13. Imprimir paquetes en hex y ASCII

tshark -r captura.pcapng -x

Muestra el volcado hexadecimal y ASCII de cada paquete, como en el panel "Packet Bytes" de Wireshark.

14. Filtrar por número de paquete

tshark -r captura.pcapng -Y "frame.number >= 100 && frame.number <= 200"

Analiza un rango específico de paquetes.

15. Decodificar como protocolo específico

tshark -r captura.pcapng -d tcp.port==4444,http

Fuerza la decodificación del puerto 4444 como HTTP aunque no sea el estándar.

16. Exportar objetos HTTP (archivos descargados)

tshark -r captura.pcapng --export-objects http,/tmp/exportados

Extrae todos los archivos transferidos por HTTP (imágenes, PDFs, ejecutables) al directorio indicado.

17. Estadísticas de expertos (errores y advertencias)

tshark -r captura.pcapng -z expert

Muestra anomalías detectadas por el motor de Wireshark: retransmisiones, checksums inválidos, secuencias rotas.

18. Captura con snapshot length limitado

tshark -i eth0 -s 96

Captura solo los primeros 96 bytes de cada paquete. Reduce tamaño de archivo cuando solo necesitas cabeceras.

19. Inyectar paquetes desde archivo (reproducción)

tshark -r captura.pcapng -Y "icmp" -w icmp.pcapng && tcpreplay --intf1=eth0 icmp.pcapng

Aunque tshark no inyecta, puedes filtrar y luego usar tcpreplay para reenviar tráfico real a una red de prueba.

20. Salida JSON para integración

tshark -r captura.pcapng -T jsonraw

Genera un array JSON con todos los paquetes y sus campos disecados. Ideal para alimentar pipelines de análisis.

Salida real del comando #5:

192.168.1.100 93.184.216.34 example.com
192.168.1.100 93.184.216.34 example.com
192.168.1.101 142.250.185.46 www.google.com

Cada línea es un paquete; las columnas corresponden a los -e solicitados. Puedes redirigir a CSV con > archivo.csv.

---

2.2 Automatización con Scripts

El análisis manual no escala. Automatizar capturas, filtrado y generación de reportes te convierte en un analista multiplicado. Aquí tienes implementaciones reales en Bash y Python, listas para producción.

2.2.1 Script Bash: Captura programada con filtro y reporte

Este script captura tráfico HTTP durante 60 segundos, extrae los hosts visitados y genera un reporte con timestamp.

#!/bin/bash
## captura_http_report.sh - Captura tráfico HTTP y genera reporte de hosts
INTERFAZ="eth0"
DURACION=60
ARCHIVO_CAPTURA="/tmp/captura_http_$(date +%Y%m%d_%H%M%S).pcapng"
REPORTE="/tmp/reporte_hosts_$(date +%Y%m%d_%H%M%S).txt"

echo "[*] Iniciando captura en $INTERFAZ por $DURACION segundos..."
tshark -i $INTERFAZ -f "tcp port 80" -a duration:$DURACION -w $ARCHIVO_CAPTURA 2>/dev/null

if [ ! -f "$ARCHIVO_CAPTURA" ]; then
echo "[!] Error: no se generó el archivo de captura."
exit 1
fi

echo "[*] Extrayendo hosts HTTP..."
tshark -r $ARCHIVO_CAPTURA -Y "http.request" -T fields -e http.host 2>/dev/null | sort | uniq -c | sort -nr > $REPORTE

echo "[+] Reporte generado: $REPORTE"
cat $REPORTE

Salida típica:

[*] Iniciando captura en eth0 por 60 segundos...
[*] Extrayendo hosts HTTP...
[+] Reporte generado: /tmp/reporte_hosts_20250115_143022.txt
15 example.com
8 www.google.com
3 api.github.com
1 cdn.cloudflare.com

Automatización con cron: Para ejecutar cada hora:

0 * * * * /usr/local/bin/captura_http_report.sh >> /var/log/capturas.log 2>&1

2.2.2 Script Python con PyShark: Análisis de sesiones TCP y detección de anomalías

PyShark es un wrapper de tshark para Python que permite iterar sobre paquetes como objetos. Este script analiza una captura, calcula la duración de cada sesión TCP y alerta sobre conexiones superiores a 30 segundos (posibles túneles o exfiltración lenta).

#!/usr/bin/env python3
"""
analisis_sesiones_tcp.py - Detecta sesiones TCP largas y genera alertas.
Uso: python3 analisis_sesiones_tcp.py captura.pcapng
"""
import pyshark
import sys
from collections import defaultdict
from datetime import datetime

def analizar_sesiones(archivo):
cap = pyshark.FileCapture(archivo, keep_packets=False)
sesiones = defaultdict(dict) # { (ip_src, ip_dst, puerto_src, puerto_dst): { inicio, fin, paquetes } }

print(f"[*] Analizando {archivo}...")
for pkt in cap:
try:
if 'TCP' in pkt:
ip_src = pkt.ip.src
ip_dst = pkt.ip.dst
puerto_src = pkt.tcp.srcport
puerto_dst = pkt.tcp.dstport
clave = (ip_src, ip_dst, puerto_src, puerto_dst)
timestamp = float(pkt.sniff_timestamp)

if 'inicio' not in sesiones[clave]:
sesiones[clave]['inicio'] = timestamp
sesiones[clave]['paquetes'] = 0
sesiones[clave]['fin'] = timestamp
sesiones[clave]['paquetes'] += 1
except AttributeError:
continue

cap.close()
print(f"[+] Sesiones TCP encontradas: {len(sesiones)}")
alertas = []
for clave, datos in sesiones.items():
duracion = datos['fin'] - datos['inicio']
if duracion > 30:
alertas.append((clave, duracion, datos['paquetes']))
print(f"[!] ALERTA: Sesión larga {clave[0]}:{clave[2]} -> {clave[1]}:{clave[3]} - {duracion:.1f}s, {datos['paquetes']} paquetes")

if not alertas:
print("[+] No se detectaron sesiones anómalas.")
else:
print(f"[!] Total alertas: {len(alertas)}")

if __name__ == "__main__":
if len(sys.argv) != 2:
print(f"Uso: {sys.argv[0]} <archivo.pcapng>")
sys.exit(1)
analizar_sesiones(sys.argv[1])

Ejemplo de ejecución:

$ python3 analisis_sesiones_tcp.py captura_http.pcapng
[*] Analizando captura_http.pcapng...
[+] Sesiones TCP encontradas: 47
[!] ALERTA: Sesión larga 192.168

---

## 🔍 Wireshark Avanzado: Análisis de Tráfico — Guía Premium de Maestría



---

## 💎 Contenido Premium

Los siguientes capítulos están disponibles en la versión completa:

- Capítulo 3: Análisis de Casos Reales
- Capítulo 4: Ejercicios Prácticos Guiados
- Capítulo 5: Troubleshooting y FAQs
- Capítulo 6: Recursos y Certificaciones
- Scripts completos y plantillas
- Soporte técnico incluido

[ Desbloquear Contenido Completo](https://viciousbyte.com/checkout)