Capturar paquetes en Tshark

Introducción

En este laboratorio, aprenderá cómo utilizar Tshark, la versión de línea de comandos de Wireshark, para capturar y analizar paquetes de red. Practicará habilidades esenciales, como la selección de interfaz, el inicio de la captura de paquetes, el filtrado de protocolos y las técnicas de guardado de salida.

Este ejercicio práctico cubre la instalación de Tshark, la configuración de permisos y las operaciones básicas de comandos para un monitoreo de red efectivo. Estas habilidades fundamentales de análisis de paquetes son valiosas para la resolución de problemas de red y las investigaciones de seguridad.

Skills Graph

Instalar Tshark

En este paso, instalará Tshark, un potente analizador de protocolos de red de línea de comandos que viene con Wireshark. Tshark es la versión de terminal de Wireshark y le permite capturar y analizar el tráfico de red directamente desde la línea de comandos sin una interfaz gráfica. Esto es especialmente útil cuando se trabaja en servidores remotos o cuando se prefiere un flujo de trabajo basado en el teclado.

Primero, actualice la lista de paquetes para asegurarse de obtener la última versión de Tshark. Esta es una buena práctica antes de instalar cualquier software nuevo en sistemas Linux:
```
sudo apt update
```
Instale Tshark utilizando el siguiente comando. La bandera -y confirma automáticamente cualquier solicitud durante la instalación:
```
sudo apt install -y tshark
```
Durante la instalación, es posible que vea una solicitud sobre permitir a los usuarios no superusuarios capturar paquetes. Esta es una consideración de seguridad importante: seleccionar "Sí" permitirá a los usuarios normales ejecutar la captura de paquetes, que es lo que queremos para este laboratorio.
Después de que se complete la instalación, verifique que Tshark se haya instalado correctamente comprobando su versión. Este comando también confirma que la ruta de instalación se ha configurado correctamente en su sistema:
```
tshark --version
```
Debería ver una salida similar a la siguiente:
```
TShark (Wireshark) 3.6.12 (Git v3.6.12 packaged as 3.6.12-1~ubuntu20.04.0)
```
Para asegurarse de que Tshark pueda capturar paquetes sin requerir privilegios de root (lo que sería inconveniente y menos seguro), necesitamos agregar su usuario al grupo wireshark. Este grupo tiene los permisos necesarios para la captura de paquetes:
```
sudo usermod -aG wireshark $USER
```
Nota: Normalmente, tendría que cerrar sesión y volver a iniciar sesión para que este cambio de grupo surta efecto, pero en este entorno de laboratorio el cambio debería ser inmediato. En un sistema real, tendría que reiniciar su sesión.

Seleccionar una interfaz

En este paso, identificará y seleccionará una interfaz de red para la captura de paquetes utilizando Tshark. Las interfaces de red son los puntos de conexión entre su computadora y una red, y debe elegir la correcta para monitorear el tráfico de red. Piense en ellas como las puertas de su computadora: debe elegir la puerta correcta por la que entra el tráfico de red.

Primero, liste todas las interfaces de red disponibles en su sistema:
```
tshark -D
```
Este comando mostrará todas las interfaces de red que su computadora puede utilizar para capturar paquetes. La salida normalmente se ve así:
```
1. eth0
2. any (Pseudo - dispositivo que captura en todas las interfaces)
3. lo (Loopback)
```
Cada interfaz tiene un propósito diferente. eth0 suele ser su conexión Ethernet cableada, mientras que wlan0 sería su conexión inalámbrica si está disponible.
Examine detenidamente la salida para identificar su interfaz de red activa. Para la mayoría de los fines prácticos, querrá utilizar:
- eth0 para la conexión Ethernet (común en laboratorios y máquinas virtuales)
- wlan0 para la conexión inalámbrica (si su computadora tiene WiFi)
- any para capturar en todas las interfaces simultáneamente (útil pero puede ser ruidoso)
Para este laboratorio, utilizaremos la interfaz eth0 ya que suele estar disponible en entornos virtuales. Antes de continuar, verifiquemos que esta interfaz exista y esté activa ejecutando:
```
ip link show eth0
```
Este comando muestra información detallada sobre la interfaz eth0. Debería ver una salida que indique que la interfaz existe y su estado actual (UP/DOWN). Si el comando devuelve un error, la interfaz puede no estar disponible en su sistema.
Ahora probemos nuestra selección de interfaz con una captura rápida de paquetes. Ejecute este comando para capturar exactamente 5 paquetes de la interfaz eth0:
```
tshark -i eth0 -c 5
```
La bandera -i especifica qué interfaz utilizar, y -c 5 le dice a Tshark que se detenga después de capturar 5 paquetes. Esta es una buena manera de verificar que su selección de interfaz funcione antes de realizar capturas más largas. Los paquetes aparecerán en su terminal a medida que se capturen.

Iniciar la captura de paquetes

En este paso, comenzará a capturar el tráfico de red en tiempo real utilizando Tshark en la interfaz que seleccionó en el paso anterior. La captura de paquetes es fundamental para el análisis de redes, ya que le permite monitorear y examinar todas las comunicaciones de red que pasan a través de la interfaz seleccionada. Piense en ello como si estuviera configurando un micrófono para grabar todas las conversaciones que se producen en un canal de red específico.

Primero, asegúrese de estar en el directorio correcto donde trabajaremos:
```
cd ~/project
```
Esto garantiza que todos los archivos de paquetes capturados se guardarán en la ubicación correcta y mantendrá su espacio de trabajo organizado.
Inicie una captura básica de paquetes en la interfaz seleccionada (eth0) con el siguiente comando:
```
tshark -i eth0
```
La bandera -i le dice a Tshark en qué interfaz debe escuchar (en este caso, eth0). Este comando comienza a capturar todos los paquetes en la interfaz eth0 y los muestra en tiempo real en su terminal. Cada línea representa un solo paquete de red con detalles sobre su origen, destino, protocolo y otras características.
Deje que la captura se ejecute durante aproximadamente 30 segundos para recopilar algo de tráfico. Verá una salida similar a la siguiente:
```
1 0.000000000 192.168.1.2 → 192.168.1.1 TCP 74 55922 → 80 [SYN] Seq=0 Win=64240 Len=0
2 0.000123456 192.168.1.1 → 192.168.1.2 TCP 74 80 → 55922 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0
```
Este ejemplo muestra un handshake TCP entre dos dispositivos. La primera línea muestra un paquete SYN que inicia una conexión, mientras que la segunda línea muestra la respuesta (SYN - ACK).
Para detener la captura, presione Ctrl+C en su terminal. Este atajo de teclado envía una señal de interrupción a Tshark. Luego, la herramienta mostrará estadísticas de captura como:
```
^C123 packets captured
```
Este resumen le dice cuántos paquetes se capturaron durante su sesión.
Para una captura más controlada, puede especificar el número exacto de paquetes a capturar (por ejemplo, 50 paquetes):
```
tshark -i eth0 -c 50
```
La bandera -c significa "count" (conteo) y hace que Tshark se detenga automáticamente después de capturar el número especificado de paquetes. Esto es útil cuando solo necesita una muestra del tráfico de red en lugar de una captura continua.

Filtrar por protocolo

En este paso, aprenderá a filtrar el tráfico de red por protocolos específicos utilizando Tshark. El filtrado por protocolo es esencial porque las redes transportan muchos tipos diferentes de tráfico simultáneamente. Al filtrar, puede centrarse en protocolos particulares que le interesan mientras ignora los paquetes irrelevantes, lo que hace su análisis más eficiente.

Primero, asegúrese de estar en el directorio correcto donde trabajaremos. Esto ayuda a mantener organizados los archivos de su proyecto:
```
cd ~/project
```
Comencemos con el tráfico TCP, que es utilizado por muchos servicios comunes como la navegación web (HTTP/HTTPS) y el shell seguro (SSH). El siguiente comando captura 20 paquetes TCP:
```
tshark -i eth0 -f "tcp" -c 20
```
La bandera -f especifica el filtro de captura, mientras que -c limita el número de paquetes capturados.
Ahora, intente capturar el tráfico UDP, que se utiliza para comunicaciones livianas como las consultas DNS y los servicios de VoIP. Este comando captura 10 paquetes UDP:
```
tshark -i eth0 -f "udp" -c 10
```
Para los paquetes ICMP (utilizados por herramientas de diagnóstico de red como ping), utilice este comando para capturar 5 paquetes:
```
tshark -i eth0 -f "icmp" -c 5
```
Puede combinar filtros para capturar múltiples protocolos simultáneamente. Este ejemplo captura tanto el tráfico DNS (puerto UDP 53) como el tráfico HTTP (puerto TCP 80), en total 15 paquetes:
```
tshark -i eth0 -f "port 53 or port 80" -c 15
```
Para un filtrado más preciso después de la captura, utilice filtros de visualización con la opción -Y. Este comando captura 30 paquetes pero solo muestra el tráfico HTTP o DNS en la salida:
```
tshark -i eth0 -c 30 -Y "http or dns"
```
Los filtros de visualización se procesan después de la captura, lo que permite un filtrado más complejo sin afectar lo que se registra.

Guardar la salida de la captura

En este paso, aprenderá a guardar el tráfico de red capturado en archivos para su posterior análisis. Guardar las capturas de paquetes es crucial porque le permite revisar la actividad de la red en un momento posterior, compartir los hallazgos con los miembros del equipo o realizar un análisis detallado sin necesidad de capturar tráfico en vivo nuevamente. El formato PCAP (Packet CAPture) es el formato de archivo estándar utilizado por la mayoría de las herramientas de análisis de redes.

Primero, asegúrese de estar en el directorio correcto donde desea guardar sus archivos de captura. El directorio del proyecto es un buen lugar para mantener su trabajo organizado:
```
cd ~/project
```
El comando básico para guardar los paquetes capturados utiliza la bandera -w para especificar el archivo de salida. Este ejemplo captura 50 paquetes de la interfaz eth0 y los guarda en formato PCAP:
```
tshark -i eth0 -c 50 -w capture.pcap
```
La extensión .pcap es importante ya que indica que se trata de un archivo de captura de paquetes estándar que puede ser abierto por la mayoría de las herramientas de análisis de redes.
Para una mejor organización, puede crear un directorio dedicado para sus capturas. Este comando primero crea un directorio 'captures' si no existe, luego captura solo el tráfico HTTP (puerto 80) y lo guarda con un nombre de archivo descriptivo:
```
mkdir -p captures && tshark -i eth0 -c 30 -w captures/http_traffic.pcap -f "port 80"
```
Para revisar un archivo de captura guardado, utilice la opción -r (read, leer). Esto muestra los paquetes en la terminal como si fuera una captura en vivo:
```
tshark -r capture.pcap
```
Para flujos de trabajo más avanzados, puede capturar todo el tráfico primero y luego extraer protocolos específicos más tarde. Este ejemplo captura 100 paquetes y luego filtra solo el tráfico DNS en un nuevo archivo:
```
tshark -i eth0 -c 100 -w full_capture.pcap \
  && tshark -r full_capture.pcap -Y "dns" -w dns_only.pcap
```
Finalmente, verifique sus capturas guardadas listándolas con sus tamaños. Esto le ayuda a confirmar que los archivos se crearon y le da una idea de cuántos datos se capturaron:
```
ls -lh *.pcap
```
Las opciones -lh hacen que la salida sea más legible al mostrar los tamaños de los archivos en un formato legible para humanos (KB, MB) en lugar de bytes.

Resumen

En este laboratorio, has aprendido cómo instalar y configurar Tshark para el análisis de paquetes de red. El proceso incluyó la instalación de Tshark a través de apt, la actualización de las listas de paquetes y la verificación de la instalación con tshark --version.

También practicaste la identificación de interfaces de red utilizando tshark -D y la selección de una interfaz adecuada para la captura de tráfico. Estas habilidades fundamentales te preparan para un análisis de protocolos de red más avanzado en ejercicios futuros.