El análisis de red con Wireshark te da visibilidad completa sobre lo que ocurre en tu red a nivel de paquete. Cuando las aplicaciones no logran conectarse, el rendimiento se degrada de forma inexplicable o necesitas verificar que el tráfico fluye como se espera, Wireshark captura cada paquete y te permite profundizar en los detalles de protocolo que ninguna otra herramienta expone. Esta guía cubre el uso práctico de Wireshark desde la instalación hasta el filtrado avanzado y escenarios reales de troubleshooting que los ingenieros de red y administradores de sistemas enfrentan a diario.

Requisitos Previos

  • Una estación de trabajo con Linux, macOS o Windows (Wireshark funciona en los tres)
  • Acceso administrativo o root para la captura de paquetes (o membresía en el grupo wireshark en Linux)
  • Conocimientos básicos de redes TCP/IP (direcciones IP, puertos, protocolos)
  • Una interfaz de red para capturar (Ethernet, Wi-Fi o loopback)

Instalación de Wireshark

Linux

# Debian / Ubuntu
sudo apt install wireshark
# Durante la instalación, selecciona "Yes" para permitir la captura a usuarios sin root

# Si te perdiste el prompt, reconfigura:
sudo dpkg-reconfigure wireshark-common
sudo usermod -aG wireshark $USER
# Cierra sesión y vuelve a entrar para que la membresía de grupo tenga efecto

# RHEL / Fedora
sudo dnf install wireshark wireshark-cli

# Arch Linux
sudo pacman -S wireshark-qt

En Linux, el grupo wireshark otorga acceso a la interfaz de captura. Sin él, debes ejecutar Wireshark como root, lo cual representa un riesgo de seguridad y no es recomendable.

macOS

# Usando Homebrew
brew install --cask wireshark

También puedes descargarlo desde el sitio oficial. macOS requiere el helper ChmodBPF para capturar sin root.

Windows

Descarga el instalador desde el sitio web de Wireshark. El instalador incluye Npcap (el driver de captura de paquetes para Windows). Acepta los valores predeterminados de Npcap durante la instalación.

Alternativa en línea de comandos: tshark

Wireshark incluye tshark, su contraparte en línea de comandos, que resulta muy útil para servidores remotos y scripts:

# Capturar 100 paquetes en eth0
tshark -i eth0 -c 100

# Capturar con un display filter
tshark -i eth0 -Y "http.request" -c 50

# Leer un archivo de captura
tshark -r capture.pcapng -Y "dns"

Captura de Tráfico de Red

Iniciar una captura básica

Abre Wireshark y verás una lista de interfaces de red disponibles con gráficas sparkline que muestran la actividad. Haz doble clic en una interfaz para iniciar la captura inmediatamente.

Desde la línea de comandos:

# Listar las interfaces disponibles
tshark -D

# Iniciar la captura en una interfaz específica
tshark -i eth0

# Capturar a un archivo
tshark -i eth0 -w /tmp/capture.pcapng

# Capturar con un ring buffer (5 archivos de 100 MB cada uno)
tshark -i eth0 -b filesize:102400 -b files:5 -w /tmp/rolling.pcapng

El ring buffer es indispensable para capturas de larga duración en sistemas en producción. Evita el agotamiento del espacio en disco sobrescribiendo el archivo más antiguo cuando se alcanza el límite.

Capture Filters (sintaxis BPF)

Los capture filters utilizan la sintaxis Berkeley Packet Filter (BPF), la misma que usa tcpdump. Se aplican antes de que los paquetes lleguen a Wireshark, lo que reduce el tamaño del archivo de captura.

# Capturar solo el tráfico hacia/desde un host específico
host 192.168.1.100

# Capturar solo tráfico HTTP y HTTPS
port 80 or port 443

# Capturar tráfico entre dos hosts específicos
host 10.0.0.1 and host 10.0.0.2

# Capturar solo paquetes TCP SYN (nuevas conexiones)
tcp[tcpflags] & (tcp-syn) != 0 and tcp[tcpflags] & (tcp-ack) == 0

# Capturar solo tráfico DNS
port 53

# Capturar tráfico en una subred específica
net 192.168.1.0/24

# Excluir tráfico SSH (útil al capturar en un servidor remoto)
not port 22

Configura los capture filters en el diálogo de opciones de captura de Wireshark (Ctrl+K) o con el flag -f de tshark:

tshark -i eth0 -f "host 192.168.1.100 and port 443" -w /tmp/https_traffic.pcapng

Regla fundamental: Siempre configura un capture filter al capturar en redes con mucho tráfico. Una captura sin filtrar en un enlace gigabit puede generar cientos de megabytes por minuto.

Permisos de captura y seguridad

# Verificar que tu usuario está en el grupo wireshark (Linux)
groups $USER | grep wireshark

# Verificar las capacidades de captura
getcap /usr/bin/dumpcap
# Debería mostrar: /usr/bin/dumpcap cap_net_admin,cap_net_raw=eip

Nunca ejecutes Wireshark como root. La GUI analiza datos de protocolo complejos y cualquier vulnerabilidad del parser se convierte en un exploit de root. En su lugar, dumpcap (el binario de captura real) se ejecuta con capacidades elevadas mientras la GUI funciona con tu usuario normal.

Display Filters — Encontrando lo que importa

Los display filters son la característica más poderosa de Wireshark. A diferencia de los capture filters, funcionan después de la captura y pueden filtrar por cualquier campo de protocolo que Wireshark entienda: cientos de protocolos con miles de campos.

Display filters esenciales

# Filtrar por dirección IP
ip.addr == 192.168.1.100
ip.src == 10.0.0.1
ip.dst == 10.0.0.2

# Filtrar por puerto
tcp.port == 443
udp.port == 53

# Filtrar por protocolo
http
dns
tls
tcp
arp
icmp

# Solo peticiones HTTP
http.request

# Respuestas HTTP con códigos de estado específicos
http.response.code == 404
http.response.code >= 500

# Consultas DNS para un dominio específico
dns.qry.name contains "example.com"

# Problemas en la conexión TCP
tcp.analysis.retransmission
tcp.analysis.duplicate_ack
tcp.analysis.zero_window
tcp.analysis.reset

# Paquetes del handshake TLS
tls.handshake.type == 1    # Client Hello
tls.handshake.type == 2    # Server Hello

# Filtrar por tamaño de paquete
frame.len > 1400
frame.len < 64

# Combinar filtros con operadores lógicos
ip.addr == 192.168.1.100 and tcp.port == 80
dns or http
not arp and not icmp
(ip.src == 10.0.0.1 or ip.src == 10.0.0.2) and tcp.port == 443

Display Filters vs Capture Filters

AspectoCapture FiltersDisplay Filters
SintaxisBPF (host, port, net)Wireshark (ip.addr, tcp.port)
Cuándo se aplicanAntes de iniciar la capturaDespués de la captura, en tiempo real
Efecto en el archivoReduce el tamaño del archivoSin efecto (oculta paquetes de la vista)
Profundidad de protocoloSolo capas 2-4Todas las capas de protocolo
Se pueden cambiarSolo reiniciando la capturaEn cualquier momento del análisis
RendimientoFiltra en el kernel (rápido)Filtra en userspace (más lento)
Úsalos cuandoSabes exactamente qué capturarExploras o analizas una captura

Consejo práctico: Usa un capture filter amplio (p. ej., host 192.168.1.100) para mantener el tamaño del archivo manejable, luego utiliza display filters para profundizar en protocolos específicos durante el análisis.

Análisis de Protocolos Comunes

Seguir streams TCP

Una de las características más útiles de Wireshark es la reconstrucción de conversaciones TCP:

  1. Encuentra un paquete que pertenezca a la conversación que te interesa
  2. Clic derecho → Follow → TCP Stream
  3. Wireshark muestra la conversación completa con los datos del cliente en un color y los del servidor en otro

Esto es invaluable para depurar APIs HTTP, sesiones SMTP, consultas de bases de datos y cualquier protocolo basado en texto. Para el tráfico cifrado (TLS), verás el handshake pero el payload estará cifrado a menos que proporciones las claves de sesión.

# Exportar un stream TCP específico con tshark
tshark -r capture.pcapng -q -z follow,tcp,ascii,0

Análisis de tráfico DNS

Los problemas de DNS causan algunos de los problemas de red más desconcertantes. Filtra y examina DNS:

# Todo el tráfico DNS
dns

# Solo consultas DNS (sin respuestas)
dns.flags.response == 0

# Respuestas DNS con errores
dns.flags.rcode != 0

# Consultas para un dominio específico
dns.qry.name == "api.example.com"

# Encontrar respuestas NXDOMAIN (dominio no existe)
dns.flags.rcode == 3

Escenario real: Diagnóstico de rendimiento lento en aplicaciones

Tienes una aplicación web que intermitentemente tarda más de 5 segundos en responder. Las métricas del servidor muestran tiempos de procesamiento rápidos. El problema está en la red.

  1. Captura el tráfico entre el cliente y el servidor:

    tshark -i eth0 -f "host 10.0.0.50 and port 443" -w /tmp/slow_app.pcapng

  2. Reproduce la petición lenta desde el cliente.

  3. Abre el archivo en Wireshark y aplica filtros:

    tcp.analysis.retransmission or tcp.analysis.duplicate_ack

  4. Revisa el tiempo del handshake TCP — si el SYN-SYN/ACK tarda 200ms o más, hay un problema de enrutamiento o de distancia.

  5. Observa el tiempo entre paquetes — si el servidor envía datos rápidamente pero hay largos intervalos entre los ACKs del cliente, la red del cliente está congestionada.

  6. Verifica problemas con el TCP window scaling:

    tcp.analysis.zero_window

    Los eventos de zero window significan que el buffer del receptor está lleno: la aplicación no está leyendo los datos lo suficientemente rápido.

La respuesta suele ser: retransmisiones en un enlace Wi-Fi con pérdida de paquetes, retrasos en la resolución DNS o un handshake TLS que incluye una verificación OCSP lenta.

Funcionalidades Avanzadas de Wireshark

IO Graphs

Los IO Graphs de Wireshark (Statistics → IO Graphs) visualizan patrones de tráfico a lo largo del tiempo. Crea múltiples líneas de gráfica para diferentes filtros:

  • Línea 1: Todo el tráfico (frame)
  • Línea 2: Retransmisiones (tcp.analysis.retransmission)
  • Línea 3: Errores HTTP (http.response.code >= 400)

Los picos de retransmisiones que coinciden con picos de tráfico revelan congestión. Un goteo constante de retransmisiones sugiere un problema en la capa física (cable defectuoso, interferencia).

Expert Information

Ve a Analyze → Expert Information para el diagnóstico automatizado de Wireshark. Clasifica los problemas en:

  • Errors (rojo): paquetes malformados, fallos de checksum
  • Warnings (amarillo): retransmisiones, segmentos fuera de orden, zero windows
  • Notes (cian): ACKs duplicados, keep-alives
  • Chats (azul): eventos normales del protocolo (establecimiento de conexión, peticiones HTTP)

Comienza tu análisis aquí. Si Expert Information muestra cientos de warnings, concéntrate en ellos antes de profundizar en paquetes individuales.

Descifrado de tráfico TLS

Para inspeccionar el contenido HTTPS en Wireshark:

# Configura la variable de entorno antes de iniciar tu navegador
export SSLKEYLOGFILE=~/sslkeys.log
google-chrome &
# o
firefox &

En Wireshark: Edit → Preferences → Protocols → TLS → (Pre)-Master-Secret log filename → selecciona ~/sslkeys.log.

Ahora Wireshark descifra el tráfico TLS de esa sesión del navegador. Verás las peticiones HTTP/2 completas, encabezados y cuerpos de respuesta. Esto solo funciona para el tráfico de tu propio navegador usando ese log de claves: no puedes descifrar el tráfico de otras personas.

Estadísticas y conversaciones

Wireshark ofrece vistas estadísticas muy completas:

  • Statistics → Conversations: muestra todos los pares de comunicación con conteos de paquetes y bytes
  • Statistics → Protocol Hierarchy: desglose del tráfico por porcentaje de protocolo
  • Statistics → Endpoints: lista todas las direcciones IP con el volumen de tráfico
  • Statistics → HTTP → Requests: todas las peticiones HTTP ordenadas por URI

Estas vistas te permiten entender rápidamente la forma de una captura sin desplazarte manualmente por los paquetes.

Comparación de Wireshark con alternativas de análisis de red

CaracterísticaWireshark (GUI)tshark (CLI)tcpdumpngrep
Decodificadores de protocolo3000+3000+BásicoBásico
Visualización GUISíNoNoNo
Display filtersSintaxis completa WiresharkSintaxis completa WiresharkSolo BPFRegex en payload
Seguir streamsSí (TCP, UDP, TLS)SíNoParcial
Funciona en servidoresRequiere X11/VNCSíSíSí
Captura en tiempo realSíSíSíSí
Lee archivos pcapSíSíSíSí
Mejor paraAnálisis interactivo profundoAnálisis por scripts, remotoCaptura rápida, instalación mínimaBúsqueda de paquetes al estilo grep

Usa Wireshark para análisis interactivo detallado de protocolos en tu estación de trabajo. Usa tshark para análisis por scripts y capturas remotas. Usa tcpdump cuando Wireshark no esté instalado y necesites una captura rápida. Las tres herramientas comparten el mismo formato de archivo pcap, así que captura con una y analiza con otra.

Solución de Problemas

”No interfaces found” en Linux

# Verificar que dumpcap tiene las capabilities correctas
sudo setcap cap_net_admin,cap_net_raw=eip /usr/bin/dumpcap

# Verificar que tu usuario está en el grupo wireshark
groups $USER

# Si acabas de añadirte, cierra sesión y vuelve a entrar
# O inicia una nueva sesión:
newgrp wireshark

La captura pierde paquetes en enlaces de alta velocidad

# Aumentar el buffer de captura (el valor predeterminado suele ser demasiado pequeño)
# En Wireshark: Capture Options → Buffer size → configurar a 256 MB
# Con tshark:
tshark -i eth0 -B 256 -w /tmp/capture.pcapng

# Usa un capture filter para reducir el volumen
tshark -i eth0 -f "port 443" -B 256 -w /tmp/https_only.pcapng

Si sigues perdiendo paquetes, usa dumpcap directamente (menos overhead que tshark) o cambia a un appliance de captura dedicado para capturas sostenidas de alta velocidad.

Los archivos de captura grandes se abren lentamente

# Dividir una captura grande en archivos más pequeños
editcap -c 100000 large_capture.pcapng split_capture.pcapng

# Usar tshark para pre-filtrar y crear un archivo más pequeño
tshark -r large_capture.pcapng -Y "http" -w http_only.pcapng

# Combinar múltiples archivos de captura
mergecap -w merged.pcapng file1.pcapng file2.pcapng

Wireshark muestra errores de checksum en todas partes

Las NIC modernas delegan el cálculo de checksum al hardware. Wireshark captura los paquetes antes de que la NIC añada los checksums, por lo que parecen inválidos. Desactiva la verificación de checksum:

Edit → Preferences → Protocols → TCP → desmarca “Validate the TCP checksum if possible”

Haz lo mismo para IPv4, UDP y otros protocolos. Esto es cosmético: el tráfico de red real tiene checksums correctos.

Casos especiales y puntos de atención

Captura en la interfaz incorrecta: En una máquina con múltiples NICs, podrías capturar en la interfaz de administración mientras el tráfico de la aplicación fluye por una interfaz diferente. Usa ip route get <destino> para verificar qué interfaz maneja el tráfico hacia tu objetivo.

Modo promiscuo vs modo normal: Por defecto, Wireshark activa el modo promiscuo, capturando todos los paquetes que la NIC ve (no solo los dirigidos a tu máquina). En una red con switches, solo verás tu propio tráfico y el broadcast/multicast, a menos que configures el port mirroring en el switch.

Limitaciones de captura en Wi-Fi: En Wi-Fi, solo ves el tráfico hacia y desde tu propia máquina, a menos que uses el monitor mode, que requiere un adaptador compatible y desactiva tu conexión Wi-Fi normal.

Timestamps de paquetes: Wireshark usa el reloj de la máquina de captura para los timestamps. Si comparas capturas de dos máquinas, asegúrate de que sus relojes estén sincronizados (NTP). Incluso unos pocos cientos de milisegundos de desfase hace que correlacionar eventos entre capturas sea engañoso.

Etiquetas VLAN: Si tu interfaz de captura es una sub-interfaz VLAN (p. ej., eth0.100), las etiquetas VLAN se eliminan antes de que Wireshark las vea. Captura en la interfaz padre (eth0) para ver las etiquetas VLAN.

Resumen

  • Wireshark captura y decodifica más de 3000 protocolos — es la herramienta definitiva para entender lo que ocurre en tu red a nivel de paquete
  • Los capture filters (sintaxis BPF) reducen el tamaño del archivo filtrando antes de grabar — úsalos siempre en redes con mucho tráfico para mantener las capturas manejables
  • Los display filters (sintaxis Wireshark) permiten profundizar interactivamente en cualquier campo de protocolo — domina ip.addr, tcp.port, tcp.analysis.* y dns.qry.name para los troubleshootings más habituales
  • Follow TCP Stream reconstruye las conversaciones completas entre endpoints — indispensable para depurar llamadas a APIs, flujos de autenticación y errores de protocolo
  • Expert Information e IO Graphs ofrecen diagnóstico automatizado y visualización del tráfico — comienza aquí antes de profundizar en paquetes individuales
  • El descifrado TLS funciona con SSLKEYLOGFILE para el tráfico de tu propio navegador — invaluable para depurar problemas HTTPS sin un proxy

Artículos Relacionados