Introducción
El tráfico de red a menudo se divide en piezas más pequeñas llamadas paquetes antes de ser transmitido a través de la red. Cuando un cliente y un servidor se comunican, envían muchos de estos paquetes de un lado a otro. Un "flujo" (stream) representa la secuencia completa y ordenada de estos paquetes para una única conexión.
Esta distinción entre paquete y flujo es uno de los cambios de mentalidad más importantes en el análisis de protocolos. Los paquetes individuales te muestran lo que sucedió en un instante específico. Los flujos te muestran la conversación completa. Muchos eventos de la capa de aplicación, como inicios de sesión, envío de formularios y transferencias de archivos, tienen mucho más sentido cuando reconstruyes la conversación en lugar de observar paquetes aislados uno por uno.
En este laboratorio, aprenderás a utilizar tshark (la versión de línea de comandos de Wireshark) para reconstruir estas conversaciones de red fragmentadas. Al seguir flujos TCP completos, podrás unir los paquetes individuales y visualizar toda la interacción de ida y vuelta entre un cliente y un servidor en texto legible. Esta es una habilidad esencial para la resolución de problemas de red y el análisis de seguridad.
Identificar flujos TCP
En este paso, aprenderás a identificar los diferentes flujos TCP presentes en un archivo de captura de red.
Cuando tshark lee un archivo de captura, agrupa automáticamente los paquetes que pertenecen a la misma conexión (misma IP de origen, puerto de origen, IP de destino y puerto de destino) y les asigna un índice entero único. Este índice se conoce como el campo tcp.stream.
Puedes pensar en tcp.stream como una etiqueta de conversación creada por el analizador. No proviene de la red en sí como un campo de protocolo. En cambio, tshark infiere que ciertos paquetes pertenecen al mismo grupo porque comparten los mismos puntos finales de conexión y la misma secuencia de eventos. Es por eso que el análisis de flujos es una "vista de analista" tan útil de los datos.
Tu entorno ya ha sido preparado con un archivo de captura de muestra llamado sample_traffic.pcap ubicado en tu directorio ~/project. Este archivo contiene algo de tráfico web básico.
Para ver todos los flujos TCP únicos en este archivo de captura, puedes indicarle a tshark que extraiga el campo tcp.stream de cada paquete, ordene los resultados y muestre solo los valores únicos.
Ejecuta el siguiente comando en tu terminal:
tshark -r sample_traffic.pcap -T fields -e tcp.stream | sort -n | uniq
Desglosemos este comando:
-r sample_traffic.pcap: Indica atsharkque lea el archivo de captura especificado.-T fields: Especifica que queremos obtener campos específicos en lugar del resumen de paquetes predeterminado.-e tcp.stream: Indica atsharkque imprima el índice del flujo TCP para cada paquete.| sort -n | uniq: Envía la salida a utilidades estándar de Linux para ordenar los números numéricamente y eliminar duplicados.
Deberías ver una salida similar a esta:
0
1
Esta salida indica que hay dos conversaciones TCP distintas (Flujo 0 y Flujo 1) registradas en este archivo de captura.
Reconstruir el flujo TCP
Ahora que conoces los números de índice de los flujos TCP, puedes reconstruir la conversación completa. Este proceso es idéntico a la función "Follow TCP Stream" (Seguir flujo TCP) en la interfaz gráfica de Wireshark.
La reconstrucción es especialmente valiosa para protocolos basados en texto como HTTP, SMTP y muchos protocolos de aplicación heredados, ya que el analista puede leer las solicitudes y respuestas en el orden en que la aplicación las experimentó. Incluso cuando el intercambio subyacente abarca múltiples paquetes, el flujo reconstruido restaura la narrativa.
En este paso, reconstruiremos el Flujo 0. Este flujo contiene una solicitud HTTP GET donde un cliente solicitó una página web al servidor.
Para seguir un flujo en tshark, utilizas la opción -z, que se emplea para diversas tareas de estadística y análisis. La sintaxis específica para seguir un flujo es -z follow,tcp,ascii,<stream_index>.
Ejecuta el siguiente comando para reconstruir el Flujo 0:
tshark -r sample_traffic.pcap -z follow,tcp,ascii,0 -q
Aquí tienes el significado de los nuevos argumentos:
-z follow,tcp,ascii,0: Indica atsharkque siga el flujo TCP con índice0y muestre la carga útil (payload) en formatoascii(texto legible).-q: Significa "quiet" (silencioso). Suprime la salida predeterminada por paquete para que solo veas los datos del flujo reconstruido.
Verás una salida que muestra la conversación HTTP completa:
===================================================================
Follow: tcp,ascii
Filter: tcp.stream eq 0
Node 0: 127.0.0.1:58548
Node 1: 127.0.0.1:8080
GET / HTTP/1.1
Host: localhost:8080
User-Agent: curl/7.81.0
Accept: */*
HTTP/1.0 200 OK
Server: SimpleHTTP/0.6 Python/3.10.12
Date: Thu, 05 Mar 2026 02:00:48 GMT
Content-type: text/html
Content-Length: 40
Last-Modified: Thu, 05 Mar 2026 02:00:44 GMT
Welcome to the LabEx Network Stream Lab
===================================================================
En esta salida, puedes ver claramente la solicitud del cliente (GET / HTTP/1.1...) seguida inmediatamente por la respuesta del servidor (HTTP/1.0 200 OK... y el contenido HTML). tshark ha unido con éxito los paquetes individuales en un bloque de texto coherente.
Analizar la conversación
Al analizar el tráfico de red, las conversaciones pueden ser muy largas. Imprimir un flujo masivo directamente en la terminal puede dificultar su lectura y análisis.
Guardar el flujo reconstruido en un archivo es un paso pequeño, pero refleja un hábito forense más amplio: preservar los artefactos de análisis intermedios. Los investigadores a menudo guardan notas, conversaciones extraídas, cargas útiles decodificadas y evidencia filtrada como archivos separados para que los hallazgos puedan ser revisados, comparados o entregados a otra persona sin tener que repetir los mismos comandos desde cero.
En este paso, reconstruirás el Flujo 1 y redirigirás la salida a un archivo de texto. Esto te permite utilizar editores de texto estándar o herramientas de línea de comandos para inspeccionar la conversación a tu propio ritmo.
El Flujo 1 contiene una solicitud HTTP POST, que normalmente se utiliza al enviar datos, como un formulario de inicio de sesión.
Ejecuta el siguiente comando para seguir el Flujo 1 y guardar la salida en un archivo llamado stream1_analysis.txt:
tshark -r sample_traffic.pcap -z follow,tcp,ascii,1 -q > stream1_analysis.txt
El operador > toma la salida que normalmente se imprimiría en tu pantalla y la escribe en stream1_analysis.txt en tu directorio actual (~/project).
Ahora, utiliza el comando cat para ver el contenido del archivo que acabas de crear:
cat stream1_analysis.txt
Tu salida debería verse similar a esta:
===================================================================
Follow: tcp,ascii
Filter: tcp.stream eq 1
Node 0: 127.0.0.1:45138
Node 1: 127.0.0.1:8080
POST /login HTTP/1.1
Host: localhost:8080
User-Agent: curl/7.81.0
Accept: */*
Content-Length: 23
Content-Type: application/x-www-form-urlencoded
user=labex&action=loginHTTP/1.0 501 Unsupported method ('POST')
Server: SimpleHTTP/0.6 Python/3.10.12
Date: Wed, 25 Oct 2026 10:00:05 GMT
Connection: close
Content-Type: text/html;charset=utf-8
Content-Length: 480
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
...
===================================================================
Al analizar este archivo, puedes observar los datos exactos que el cliente envió en el cuerpo de la solicitud POST (user=labex&action=login). También puedes ver la respuesta del servidor, que en este caso es un error 501 Unsupported method, lo que indica que el servidor web simple de Python utilizado para generar este tráfico no admite solicitudes POST.
Guardar flujos en archivos es una técnica altamente efectiva cuando necesitas extraer archivos, credenciales o registros detallados de capturas de red.
Resumen
¡Felicidades! Has completado con éxito el laboratorio de Seguimiento de flujos de red.
En este laboratorio, aprendiste a:
- Identificar flujos TCP únicos dentro de un archivo de captura de paquetes utilizando el campo
tcp.stream. - Reconstruir y visualizar la conversación completa de ida y vuelta de un flujo TCP específico utilizando la función
followdetshark. - Redirigir los datos del flujo reconstruido a archivos de texto para facilitar la lectura y un análisis más profundo.
Estas técnicas son fundamentales para los administradores de red y profesionales de seguridad al investigar problemas de red, analizar el comportamiento de malware o verificar las comunicaciones de las aplicaciones.
