Tráfico HTTP Inseguro — Captura y Extracción con Wireshark y tshark

🔓

Tráfico HTTP Inseguro

Captura y análisis de peticiones HTTP con Wireshark, tshark y python http.server

Para que la apertura de una imagen genere paquetes capturables y un registro en python -m http.server, deben cumplirse cuatro condiciones simultáneamente:

🌐

El navegador debe obtener la imagen vía HTTP (http://127.0.0.1:8080/imagen.jpg) y no desde file://.

📡

La captura debe estar en la interfaz correcta: loopback / Npcap Loopback Adapter si estás en Windows.

🚫

La petición no debe servirse desde caché del navegador — forzar recarga o desactivar caché en DevTools.

⚡

Opcional: usar curl para forzar un GET y comprobar la captura rápidamente sin depender del navegador.

Paso 1

Npcap

Instalar con soporte loopback habilitado

Paso 2

Interfaz

Seleccionar Npcap Loopback Adapter en Wireshark

Paso 3

Caché OFF

DevTools → Network → Disable cache

Paso 4

Captura

Iniciar Wireshark y navegar a la URL HTTP

Paso 5

Extraer

File → Export Objects → HTTP

🪟

Pasos Detallados — Windows

Configuración completa para captura en loopback local

Instalar Npcap con soporte loopback

Descarga e instala Npcap marcando la opción "Support loopback traffic ('Npcap Loopback Adapter')". Reinicia Wireshark si estaba abierto.

ℹ️ Sin esta opción marcada, Wireshark no verá el tráfico 127.0.0.1 ↔ 127.0.0.1 del servidor local.

Seleccionar la interfaz loopback en Wireshark

Abre Wireshark → Capture Options → selecciona "Npcap Loopback Adapter". Opcionalmente añade un filtro de captura BPF para reducir ruido:

BPF Capture Filter

host 127.0.0.1 and port 8080

💡 BPF vs Display Filter: El capture filter actúa a nivel de kernel y descarta paquetes no coincidentes antes de que lleguen a Wireshark. El display filter actúa solo visualmente sobre los paquetes ya capturados.

Desactivar la caché del navegador

Abre DevTools (F12) → pestaña Network → marca "Disable cache" (solo mientras DevTools esté abierto). Alternativamente abre la imagen en pestaña nueva y pulsa Ctrl+F5.

⚠️ Importante: Si la petición se sirve desde caché del navegador, no habrá ningún paquete HTTP en la red ni registro en python -m http.server. Este es el error más frecuente.

Iniciar captura y abrir la imagen por HTTP

Inicia la captura en Wireshark. Navega desde el navegador a la URL usando 127.0.0.1 (preferible a localhost para evitar problemas IPv6).

URL — usar 127.0.0.1, no localhost

http://127.0.0.1:8080/lpic.jpg

Observa el log de python -m http.server. Si aparece GET /imagen.jpg 200 -, la petición llegó al servidor correctamente:

python http.server — log de confirmación
127.0.0.1 - - [01/Jan/2025 12:00:00] "GET /lpic.jpg HTTP/1.1" 200 -
# Si ves 200 → la petición llegó → Wireshark debe tener el paquete
# Si no ves nada → la petición no salió del navegador (caché o file://)

🔍

5. Filtros de Visualización — Wireshark

Display filters para aislar el tráfico HTTP relevante

http.request.method == "GET" && tcp.port == 8080

http.response.code == 200 && tcp.port == 8080

http.request && http.request.uri contains ".jpg"

http && http.content_type contains "jpeg"

http.request || http.response

tcp.port == 8080

CLI Alternativa: tshark / tcpdump Captura y análisis desde línea de comandos

bash — captura en vivo con tshark

# Captura en vivo — selecciona el índice de interfaz correcto
tshark -i <iface_number> -f "host 127.0.0.1 and port 8080" -w capture.pcapng

bash — leer pcap y mostrar GETs

tshark -r capture.pcapng -Y "http.request and tcp.port==8080" \
  -T fields \
  -e frame.number \
  -e ip.src \
  -e ip.dst \
  -e http.request.method \
  -e http.request.uri

bash — buscar POSTs

tshark -r capture.pcapng -Y 'http.request.method == "POST"'

bash — listar respuestas JPEG

tshark -r capture.pcapng \
  -Y 'http.response and http.content_type contains "jpeg"' \
  -T fields \
  -e frame.number \
  -e http.content_type \
  -e http.content_length \
  -e http.response.code

📦

Recomponer / Extraer la Imagen

3 métodos según el tipo de tráfico y herramienta preferida

1 Método fácil — Wireshark GUI (imagen servida en GET → response)

Abrir el pcap y aplicar filtro

Carga el archivo en Wireshark y aplica el display filter para localizar la respuesta JPEG.

Display filter

http && http.content_type contains "jpeg"

Exportar con File → Export Objects → HTTP

En el menú: File → Export Objects → HTTP. Aparece una lista de objetos HTTP — selecciona el .jpg y pulsa Save. Wireshark lo entrega ya reconstruido.

Alternativa: Follow → TCP Stream

Si no aparece en Export Objects: selecciona el paquete de respuesta → botón derecho → Follow → TCP Stream. En "Show data as" elige Raw → guarda con extensión .jpg.

2 Método rápido — tshark CLI

tshark puede exportar todos los objetos HTTP de un pcap a una carpeta de una sola vez:

bash — exportar todos los objetos HTTP

# Crea ./export_http/ con todos los archivos HTTP (incluyendo .jpg)
tshark -r captura.pcapng --export-objects "http,./export_http"

💡 Este es el método más rápido cuando tienes múltiples objetos o quieres procesar un pcap en un script.

3 Imagen subida por POST — multipart/form-data

⚠️ Wireshark no siempre lista las partes subidas en Export Objects (muestra objetos servidos, no el body del request). Para extraer un fichero enviado en un POST:

Localizar el paquete del POST

Filtra por http.request.method == "POST" y localiza el paquete donde empieza el POST.

Follow → TCP Stream → Raw → Guardar

Botón derecho → Follow → TCP Stream → "Show data as" = Raw → guardar como upload_raw.bin.

Extraer la parte binaria del multipart

El .bin contiene cabeceras HTTP + body multipart. Busca el boundary en la cabecera Content-Type y extrae la parte binaria entre los delimitadores del boundary.

Cabecera multipart — ejemplo de boundary
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryXXXX

4 Configurar Wireshark para reensamblar TCP/HTTP

Para garantizar que HTTP bodies largos se muestren completos y Export Objects devuelva el archivo entero, activa estas dos opciones:

Edit → Preferences → Protocols → TCP

✅ Allow subdissector to reassemble TCP streams

Permite que los protocolos de capa superior (como HTTP) reensamblen segmentos TCP fragmentados.

Edit → Preferences → Protocols → HTTP

✅ Reassemble HTTP bodies spanning multiple TCP segments

Garantiza que los bodies HTTP que ocupan múltiples segmentos TCP se muestren como un único objeto completo.

🐛

Errores Típicos y Soluciones

Los problemas más frecuentes al capturar tráfico HTTP local

Abrí la imagen desde el sistema de archivos (file://)

Si abres la imagen como file:///C:/ruta/imagen.jpg, no habrá petición HTTP y por tanto no habrá paquetes ni registro en http.server. Siempre usa http://127.0.0.1:8080/.

La caché del navegador sirve la imagen

Si el navegador ya tiene la imagen en caché, no realizará ninguna petición HTTP. Solución: desactivar caché en DevTools o pulsar Ctrl+F5. Si no ves nada en el log de http.server, la petición nunca salió del navegador.

Aparece ::ffff:127.0.0.1 en lugar de 127.0.0.1

Esto es IPv4-mapped IPv6 — Wireshark puede mostrarlo como IPv6. Para filtrar de forma robusta independientemente de la versión IP, usa tcp.port == 8080 en lugar de filtrar por dirección IP.

dsniff/Wireshark no captura nada en loopback

Verifica que Npcap esté instalado con soporte loopback ("Npcap Loopback Adapter" debe aparecer en la lista de interfaces de Wireshark). Si no aparece, reinstala Npcap marcando esa opción.

python -m http.server no muestra el GET

Si el servidor no registra el GET, la petición nunca llegó al servidor — el problema está antes (caché, file://, o interfaz incorrecta). Si sí lo registra pero Wireshark no captura, el problema es de interfaz o filtro en Wireshark.

🖥️

Configuración VM / Host Distinto

Cuando el servidor y el navegador están en máquinas separadas

Servicio en VM, navegador en host (o viceversa): captura en la máquina que origina la petición, o en la interfaz de red virtual que conecta ambas (ej. VMnet8 para NAT, VMnet1 para host-only).
Servicio en VM, navegador dentro de la VM: captura dentro de la VM en su interfaz loopback — o captura en la interfaz virtual del host que conecta con la VM.

bash — verificar captura con tcpdump desde Linux/VM

# Confirmar que los paquetes HTTP llegan a nivel de red
sudo tcpdump -i lo -A port 8080

# En interfaz de red VM (ej. eth0, enp0s3)
sudo tcpdump -i enp0s3 -A port 8080

ℹ️ Regla de diagnóstico: Si python -m http.server registra el GET pero Wireshark no muestra el paquete → problema de interfaz en Wireshark. Si python no registra nada → la petición nunca salió del cliente (caché, file://, o URL incorrecta).