--- title: "Cómo analizar tráfico de red con tcpdump en Ubuntu 24.04" description: "Aprende a capturar y filtrar paquetes con tcpdump en Ubuntu 24.04: filtros por host, puerto y flags TCP, capturas pcap con rotación y diagnóstico de HTTP y DNS." category: "Configuración de Red" language: es source: https://cubepath.com/es/docs/configuración-de-red/analisis-de-trafico-de-red-con-tcpdump updated: 2026-09-25 --- # Cómo analizar tráfico de red con tcpdump en Ubuntu 24.04 tcpdump es un analizador de paquetes de línea de comandos que captura el tráfico que pasa por una interfaz de red y lo muestra o lo guarda en un fichero `.pcap`. Está disponible en prácticamente cualquier servidor Linux y es la herramienta más rápida para responder preguntas como "¿llegan las peticiones a mi servidor?" o "¿qué responde realmente el DNS?". En este tutorial aprenderás a usar tcpdump en Ubuntu 24.04: leer su salida, construir filtros por host, puerto y protocolo, guardar capturas con rotación para abrirlas en Wireshark y aplicar todo ello a casos reales de diagnóstico. ## Requisitos previos Para seguir este tutorial necesitas: - Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath. - Un usuario no root con privilegios `sudo`. Capturar tráfico requiere permisos de root. - Algo de tráfico que observar: un servidor web, un servicio SSH o simplemente comandos como `curl` y `dig` que puedas lanzar desde otra terminal. > Advertencia: Captura solo tráfico de sistemas que administras o para los que tienes autorización. Las capturas pueden contener contraseñas, cookies y datos personales, así que trátalas como información sensible. ## Paso 1: Instalar tcpdump e identificar la interfaz Ubuntu Server suele traer tcpdump instalado. Si no lo está, instálalo desde los repositorios: ```bash sudo apt update sudo apt install -y tcpdump ``` Comprueba la versión: ```bash tcpdump --version ``` ```output tcpdump version 4.99.4 libpcap version 1.10.4 (with TPACKET_V3) OpenSSL 3.0.13 30 Jan 2024 ``` A continuación identifica la interfaz por la que sale el tráfico. En servidores virtuales suele llamarse `eth0`, `ens3` o `ens18`: ```bash ip -br address ``` ```output lo UNKNOWN 127.0.0.1/8 ::1/128 eth0 UP 203.0.113.10/24 2001:db8::10/64 ``` En este tutorial se usa `eth0`; sustitúyela por el nombre de tu interfaz. `tcpdump -D` también lista todas las interfaces en las que se puede capturar, incluida la pseudo interfaz `any`, que escucha en todas a la vez. ## Paso 2: Hacer una primera captura y leer la salida Captura cinco paquetes en la interfaz principal: ```bash sudo tcpdump -i eth0 -n -c 5 ``` Las opciones hacen lo siguiente: - `-i eth0`: interfaz en la que capturar. - `-n`: no resolver direcciones IP ni puertos a nombres. Sin ella, tcpdump hace consultas DNS por cada dirección, lo que ralentiza la salida y genera tráfico extra que también aparece en la captura. - `-c 5`: parar tras cinco paquetes. Sin `-c`, la captura sigue hasta que pulses `Ctrl+C`. Una línea típica de la salida es esta: ```output 10:42:07.311582 IP 198.51.100.23.51544 > 203.0.113.10.443: Flags [S], seq 2849126381, win 64240, options [mss 1460,sackOK,TS val 1419 ecr 0,nop,wscale 7], length 0 ``` Se lee de izquierda a derecha: | Campo | Significado | |---|---| | `10:42:07.311582` | Hora de captura con microsegundos | | `IP` | Protocolo de red (`IP6` para IPv6) | | `198.51.100.23.51544` | IP y puerto de origen (el puerto es el último número) | | `203.0.113.10.443` | IP y puerto de destino | | `Flags [S]` | Flags TCP: `S` SYN, `.` ACK, `P` PUSH, `F` FIN, `R` RST | | `length 0` | Bytes de datos de la capa de aplicación | La línea anterior es un cliente iniciando una conexión HTTPS (un SYN hacia el puerto 443). Al terminar, tcpdump muestra un resumen: ```output 5 packets captured 7 packets received by filter 0 packets dropped by kernel ``` Si `dropped by kernel` es mayor que cero, tcpdump no ha podido procesar todo el tráfico. Usa un filtro más específico, como verás en el siguiente paso. ## Paso 3: Filtrar el tráfico con expresiones BPF Sin filtro, en un servidor con actividad la salida es ilegible. tcpdump acepta expresiones de filtro en sintaxis BPF (Berkeley Packet Filter), que el kernel aplica antes de copiar los paquetes, así que además son eficientes. El filtro va al final del comando. Si estás conectado por SSH, lo primero es excluir tu propia sesión, porque cada línea que tcpdump imprime genera nuevos paquetes SSH que a su vez se capturan: ```bash sudo tcpdump -i eth0 -n not port 22 ``` ### Filtrar por host y red Tráfico hacia o desde una dirección concreta: ```bash sudo tcpdump -i eth0 -n host 198.51.100.23 ``` Solo en un sentido, con `src` o `dst`: ```bash sudo tcpdump -i eth0 -n src host 198.51.100.23 ``` Toda una subred en notación CIDR: ```bash sudo tcpdump -i eth0 -n net 10.0.0.0/8 ``` ### Filtrar por puerto y protocolo Un puerto, en TCP o UDP: ```bash sudo tcpdump -i eth0 -n port 443 ``` Un rango de puertos: ```bash sudo tcpdump -i eth0 -n portrange 8000-8100 ``` Por protocolo, con las palabras clave `tcp`, `udp`, `icmp`, `icmp6` o `arp`: ```bash sudo tcpdump -i eth0 -n icmp ``` ### Combinar filtros Los filtros se combinan con `and`, `or` y `not`. Cuando uses paréntesis, pon toda la expresión entre comillas simples para que la shell no los interprete: ```bash sudo tcpdump -i eth0 -n 'host 198.51.100.23 and (port 80 or port 443)' ``` ### Filtrar por flags TCP Para ver solo intentos de conexión nuevos (paquetes con SYN pero sin ACK), útil para saber quién intenta conectar y a qué puertos: ```bash sudo tcpdump -i eth0 -n 'tcp[tcpflags] & (tcp-syn|tcp-ack) == tcp-syn' ``` Para ver conexiones rechazadas o cortadas de forma abrupta, filtra los paquetes con RST: ```bash sudo tcpdump -i eth0 -n 'tcp[tcpflags] & tcp-rst != 0' ``` ## Paso 4: Ver el contenido de los paquetes Por defecto tcpdump solo muestra cabeceras. Para ver los datos, `-A` los imprime en ASCII y `-X` en hexadecimal y ASCII. Esto solo es legible en protocolos sin cifrar, como HTTP en el puerto 80. En una terminal, captura el tráfico HTTP local: ```bash sudo tcpdump -i lo -n -A 'tcp port 80 and (tcp[tcpflags] & tcp-push != 0)' ``` En otra terminal, lanza una petición (necesitas un servidor web escuchando en el puerto 80): ```bash curl -s http://127.0.0.1/ -o /dev/null ``` En la primera terminal verás la petición en texto claro: ```output GET / HTTP/1.1 Host: 127.0.0.1 User-Agent: curl/8.5.0 Accept: */* ``` El filtro `tcp-push` descarta los paquetes sin datos (SYN, ACK vacíos), lo que deja solo peticiones y respuestas. Para HTTPS no verás el contenido, pero sí el establecimiento de la conexión y el tamaño de cada paquete, que ya permite detectar muchos problemas. Otras opciones de salida útiles: - `-v` o `-vv`: más detalle de las cabeceras (TTL, checksum, opciones). - `-e`: muestra también las direcciones MAC de la capa de enlace. - `-tttt`: marca de tiempo con fecha completa, útil para correlacionar con logs. - `-l`: salida con buffer por línea, necesaria para enviar la salida a `grep` en tiempo real. Por ejemplo, para extraer las cabeceras `Host:` que llegan a tu servidor web: ```bash sudo tcpdump -i eth0 -n -l -A 'tcp dst port 80' | grep --line-buffered 'Host:' ``` ## Paso 5: Guardar capturas y abrirlas en Wireshark Para análisis posteriores o para compartir una captura, guárdala en un fichero pcap con `-w`. En ese modo tcpdump no imprime los paquetes: ```bash sudo tcpdump -i eth0 -n -c 1000 -w /tmp/web.pcap 'port 80 or port 443' ``` ```output tcpdump: listening on eth0, link-type EN10MB (Ethernet), snapshot length 262144 bytes 1000 packets captured ``` > Nota: En Ubuntu, tcpdump abandona los privilegios de root tras abrir la interfaz y escribe el fichero como el usuario `tcpdump`, y un perfil de AppArmor limita dónde puede escribir. Guarda las capturas en `/tmp` o en tu directorio personal para evitar errores de permisos. Lee el fichero con `-r`, aplicando si quieres un filtro distinto al de la captura: ```bash tcpdump -n -r /tmp/web.pcap 'tcp[tcpflags] & tcp-rst != 0' ``` Para analizarlo en Wireshark, descárgalo a tu equipo con `scp`: ```bash scp your_user@your_server_ip:/tmp/web.pcap . ``` Si solo te interesan las cabeceras, limita los bytes que se guardan de cada paquete con `-s`. Con `-s 128` los ficheros son mucho más pequeños y apenas contienen datos de la aplicación: ```bash sudo tcpdump -i eth0 -n -s 128 -w /tmp/headers.pcap ``` ### Captura continua con rotación Para problemas intermitentes, deja tcpdump grabando en un buffer circular: `-C` cambia de fichero cada cierto tamaño (en millones de bytes) y `-W` limita el número de ficheros, sobrescribiendo el más antiguo. Este comando mantiene como máximo 10 ficheros de 100 MB: ```bash sudo tcpdump -i eth0 -n -s 256 -C 100 -W 10 -w /tmp/ring.pcap 'not port 22' ``` tcpdump numera los ficheros como `ring.pcap0`, `ring.pcap1`, etc. Cuando el problema se reproduzca, detén la captura con `Ctrl+C` y analiza los ficheros más recientes. Para que la captura siga activa al cerrar tu sesión SSH, ejecútala dentro de `tmux` o `screen`. ## Paso 6: Diagnosticar problemas reales ### Comprobar si las peticiones llegan al servidor Si un servicio no responde desde fuera, la primera pregunta es si el tráfico llega. Captura los SYN hacia el puerto del servicio y prueba a conectar desde otro equipo: ```bash sudo tcpdump -i eth0 -n 'tcp dst port 443 and tcp[tcpflags] & tcp-syn != 0' ``` Interpreta el resultado así: - No aparece nada: el tráfico se bloquea antes de llegar al servidor (DNS apunta a otra IP, firewall externo o grupo de seguridad). - Aparecen SYN pero ninguna respuesta: el firewall local (`sudo ufw status`) descarta los paquetes. - Aparece un RST como respuesta: el paquete llega, pero ningún proceso escucha en ese puerto. Compruébalo con `sudo ss -tlnp`. ### Depurar la resolución DNS Captura las consultas y respuestas DNS mientras lanzas una consulta desde otra terminal: ```bash sudo tcpdump -i any -n port 53 ``` ```bash dig cubepath.com ``` ```output 11:03:12.114210 lo In IP 127.0.0.1.41822 > 127.0.0.53.53: 3321+ [1au] A? cubepath.com. (53) 11:03:12.114705 eth0 Out IP 203.0.113.10.35140 > 1.1.1.1.53: 1407+ [1au] A? cubepath.com. (41) 11:03:12.131882 eth0 In IP 1.1.1.1.53 > 203.0.113.10.35140: 1407 2/0/1 A 104.21.0.1, A 172.67.0.1 (73) ``` Con la interfaz `any` se ve el recorrido completo: la aplicación pregunta a `systemd-resolved` en `127.0.0.53`, que a su vez consulta al servidor DNS configurado. `A?` es la pregunta; `2/0/1` indica dos respuestas, cero registros de autoridad y un registro adicional. Si ves la pregunta pero nunca la respuesta, el problema está en el servidor DNS o en el camino hasta él. Si la respuesta es `NXDomain`, el nombre no existe. ### Detectar escaneos de puertos Un escaneo se reconoce por muchos SYN desde la misma IP hacia puertos distintos. Captura 1000 SYN entrantes y cuenta las IP de origen: ```bash sudo tcpdump -i eth0 -n -c 1000 'tcp[tcpflags] & (tcp-syn|tcp-ack) == tcp-syn and dst host 203.0.113.10' \ | awk '{print $3}' | cut -d. -f1-4 | sort | uniq -c | sort -rn | head ``` ```output 612 198.51.100.77 41 192.0.2.15 8 203.0.113.200 ``` Una IP con cientos de SYN en pocos segundos es casi siempre un escáner. Sustituye `203.0.113.10` por la IP pública de tu servidor. Para bloquear este tipo de actividad de forma automática, usa una herramienta como Fail2ban en lugar de un script propio. ## Solución de problemas **`tcpdump: eth0: You don't have permission to perform this capture on that device`.** Ejecuta el comando con `sudo`. Capturar en una interfaz requiere la capacidad `CAP_NET_RAW`. **`tcpdump: /var/log/capture.pcap: Permission denied` al usar `-w`.** tcpdump escribe como el usuario `tcpdump` y AppArmor restringe las rutas. Guarda la captura en `/tmp` o en tu directorio personal y muévela después. **La captura no muestra nada.** Comprueba que usas la interfaz correcta con `ip -br address` y prueba con `-i any`. Si capturas tráfico entre procesos del mismo servidor, está en la interfaz `lo`, no en `eth0`. **`packets dropped by kernel` es alto.** tcpdump no procesa los paquetes al ritmo al que llegan. Añade un filtro más específico, usa `-n` para evitar resoluciones DNS, reduce `-s` y escribe en un fichero con `-w` en lugar de imprimir en pantalla. ## Conclusión Ya sabes capturar tráfico con tcpdump, leer su salida, filtrar por host, puerto y flags TCP, guardar capturas con rotación y usar todo ello para diagnosticar conectividad, DNS y escaneos. Como siguientes pasos, puedes abrir tus capturas en Wireshark para seguir flujos TCP completos, usar `tshark` para analizar ficheros pcap desde la línea de comandos o consultar `man pcap-filter` para conocer toda la sintaxis de filtros BPF.