---
title: "Laboratorio: observar el encapsulamiento con Wireshark"
domain: networking
level: beginner
duration: "45 min"
cost: "gratis (herramientas de código abierto en tu propio ordenador)"
environment: "máquina local (tu propio ordenador y tu red doméstica)"
lang: es
source_hash: ca2f25397e95
---

# Laboratorio: observar el encapsulamiento con Wireshark

## Objetivo
Capturas tu propia consulta del Sistema de nombres de dominio (DNS, Domain Name System) y tu propia petición del Protocolo de transferencia de hipertexto (HTTP, Hypertext Transfer Protocol), y luego desmontas cada paquete capa por capa. Al terminar, podrás señalar las cabeceras Ethernet, del Protocolo de Internet (IP, Internet Protocol), del Protocolo de control de transmisión (TCP, Transmission Control Protocol) y HTTP en una captura real y decir a qué capa del modelo de interconexión de sistemas abiertos (OSI, Open Systems Interconnection) pertenece cada una.

## Objetivos
- Capturar tu propio tráfico con Wireshark, o con `tcpdump` como alternativa.
- Identificar las cabeceras Ethernet, IP, del Protocolo de datagramas de usuario (UDP, User Datagram Protocol) o TCP, y de aplicación en una trama capturada.
- Asociar cada campo de cabecera que veas con su capa OSI y su unidad de datos de protocolo (PDU, protocol data unit).
- Describir el encapsulamiento y el desencapsulamiento a partir de datos reales, incluidos los campos de demultiplexación (EtherType, Protocol de IP, puerto).
- Encontrar el tamaño máximo de segmento (MSS, maximum segment size) de TCP en un segmento SYN y explicar por qué es de 1460 bytes en Ethernet estándar.

## Requisitos previos
- Un ordenador de tu propiedad o que administres, con Linux, macOS o Windows 10/11, conectado por Ethernet o Wi-Fi.
- **Wireshark 4.0 o posterior** ([wireshark.org](https://www.wireshark.org/)). En Windows, el instalador también instala Npcap, el controlador de captura.
- Alternativa para Linux y macOS: **tcpdump 4.99 o posterior** (compruébalo con `tcpdump --version`). macOS lo incluye de serie.
- **curl 7.68 o posterior**. En Windows 10/11, `curl.exe` viene incluido.
- Una herramienta de consulta DNS: `dig` (BIND 9) en Linux y macOS, o `nslookup` en Windows.
- Permiso para capturar paquetes: derechos de administrador, o pertenecer al grupo `wireshark` en Linux (Paso 2).
- Lección: [El modelo OSI: cómo se comunican las redes](lesson.es.md), especialmente el ejemplo práctico.

> [!WARNING]
> **Autorización y ética.** Captura solo el tráfico de tu propio ordenador y de una red que sea tuya o que tengas permiso expreso para monitorizar. Capturar el tráfico de otras personas sin permiso puede ser delito y vulnerar las normas del trabajo o del centro de estudios, incluso en una red Wi-Fi compartida. En una red del trabajo o del centro de estudios, consulta antes la política de uso aceptable, o haz el laboratorio en casa. Los archivos de captura pueden contener datos privados (por ejemplo, los nombres DNS que consultan otras aplicaciones). No los compartas y bórralos en la sección de Limpieza.
>
> **Coste:** gratis. Solo usas herramientas de código abierto y envías unos pocos kilobytes de tráfico.

## Arquitectura
![Arquitectura del laboratorio: tu ordenador ejecuta dig y curl, su tráfico baja por la pila de red hasta la interfaz de red, donde Wireshark y tcpdump lo capturan, y después pasa por la puerta de enlace predeterminada hasta un resolvedor DNS y el servidor web de example.com](../../../assets/diagrams/osi-lab-architecture.es.svg)

*Figura 1. Qué capturas y dónde. El punto de captura es tu propia interfaz de red, así que ves todas las cabeceras que tu ordenador envía y recibe.*

Wireshark y `tcpdump` copian cada trama a su paso por tu interfaz de red. Ves la trama completa con todas sus cabeceras, exactamente como tu ordenador la envía o la recibe.

> [!NOTE]
> Las direcciones de este laboratorio son valores de documentación, los mismos que usa la lección: direcciones IP de la RFC 5737 y direcciones de control de acceso al medio (MAC, Media Access Control) del bloque de documentación de la RFC 7042 (`00:00:5e:00:53:xx`). **Tus valores reales serán distintos.** Es probable que tu ordenador tenga una dirección privada como `192.168.1.x`, y `example.com` se resuelve a direcciones públicas reales. Ve anotando tus propios valores.

## Pasos

### Paso 1 — Encuentra tu interfaz, tus direcciones y la MTU
Necesitas saber qué interfaz transporta tu tráfico antes de capturar en ella. También te interesan tus direcciones IP y MAC y tu puerta de enlace, para reconocerlas en la captura. La unidad máxima de transmisión (MTU, maximum transmission unit) te permite predecir el MSS antes de verlo.

En Linux:

```bash
ip -4 route show default
ip link show <interface>
resolvectl dns
```

`<interface>` es el nombre que aparece después de `dev` en la salida del primer comando (por ejemplo `enp3s0` o `wlp2s0`). Si `resolvectl` no está disponible, ejecuta `cat /etc/resolv.conf` en su lugar.

Salida esperada:
```text
default via 192.0.2.1 dev enp3s0 proto dhcp src 192.0.2.10 metric 100
2: enp3s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP mode DEFAULT group default qlen 1000
    link/ether 00:00:5e:00:53:10 brd ff:ff:ff:ff:ff:ff
Global:
Link 2 (enp3s0): 198.51.100.53
```

En macOS y Windows, usa estos comandos:

| Información | macOS | Windows (Símbolo del sistema) |
|---|---|---|
| Interfaz y puerta de enlace | `route -n get default` (líneas `gateway:` e `interface:`) | `ipconfig /all` (`Default Gateway`) |
| Tu dirección MAC y la MTU | `ifconfig <interface>` (líneas `ether` y `mtu`) | `ipconfig /all` (`Physical Address`); `netsh interface ipv4 show subinterfaces` (MTU) |
| Servidor DNS | `scutil --dns \| grep nameserver` | `ipconfig /all` (`DNS Servers`) |

Anota: el nombre de la interfaz, tu dirección IPv4, tu dirección MAC, la dirección IP de la puerta de enlace, la dirección de un servidor DNS IPv4 y la MTU. Con una MTU de 1500, la lección predice un MSS de 1500 − 20 (IPv4) − 20 (TCP) = 1460 bytes.

> [!NOTE]
> Windows muestra las direcciones MAC con guiones (`00-00-5E-00-53-10`). Wireshark muestra la misma dirección con dos puntos.

### Paso 2 — Prepara una carpeta y el permiso de captura
Capturar paquetes requiere privilegios especiales porque una captura puede ver todo el tráfico de la interfaz. Concédete solo el permiso que necesitas y guarda los archivos del laboratorio en una sola carpeta para que la limpieza sea fácil.

```bash
mkdir -p ~/osi-lab
cd ~/osi-lab
```

Salida esperada: ninguna. Los comandos se ejecutan en silencio.

Después configura el permiso de captura para tu sistema:

- **Linux, Wireshark:** si Wireshark no muestra ninguna interfaz o dice que no tienes permiso, añádete al grupo `wireshark` (en Debian y Ubuntu, ejecuta antes `sudo dpkg-reconfigure wireshark-common` y responde **Yes**). Después cierra sesión y vuelve a iniciarla.

  ```bash
  sudo usermod -aG wireshark "$USER"
  ```

  Recuerda si hiciste esto: la Limpieza lo deshace.
- **Linux y macOS, tcpdump:** ejecutas `tcpdump` con `sudo` en el Paso 3. No hace falta ninguna configuración.
- **macOS, Wireshark:** acepta el componente **ChmodBPF** cuando el instalador lo ofrezca.
- **Windows, Wireshark:** asegúrate de que Npcap se instaló junto con Wireshark.

> [!TIP]
> No ejecutes nunca toda la aplicación gráfica de Wireshark como root o administrador. Wireshark tiene mucho código para analizar protocolos, y ejecutarlo con todos los privilegios aumenta el daño que podría causar un paquete malicioso. La configuración basada en el grupo solo da al pequeño ayudante de captura (`dumpcap`) los derechos que necesita.

Comprueba la pertenencia al grupo en Linux (después de volver a iniciar sesión):

```bash
id -nG
```

Salida esperada (tu lista será distinta, pero debe incluir `wireshark`):
```text
learner wheel wireshark
```

### Paso 3 — Inicia la captura
Solo quieres dos tipos de tráfico: DNS (puerto UDP 53) y HTTP sin cifrar (puerto TCP 80). Un **filtro de captura** indica al motor de captura que conserve únicamente esos paquetes, de modo que el archivo sea pequeño y contenga la menor cantidad posible de datos ajenos.

**Wireshark:** abre Wireshark. En la pantalla de bienvenida, escribe esto en el cuadro del filtro de captura ("…using this filter") y haz doble clic en tu interfaz del Paso 1:

```text
tcp port 80 or udp port 53
```

Resultado esperado: se abre la lista de paquetes y está vacía o muestra algunos paquetes DNS de otras aplicaciones. La barra de estado muestra el nombre de la interfaz y un contador de paquetes.

**tcpdump (Linux y macOS):** ejecuta esto en un terminal y déjalo en marcha.

```bash
cd ~/osi-lab
sudo tcpdump -i <interface> -nn -Z "$USER" -w osi-lab.pcap 'tcp port 80 or udp port 53'
```

- `<interface>` es el nombre de la interfaz del Paso 1.
- `-nn` muestra direcciones y números de puerto en lugar de nombres.
- `-Z "$USER"` hace que `tcpdump` abandone los privilegios de root y escriba el archivo como tu usuario, para que puedas leerlo y borrarlo sin `sudo`.
- `-w osi-lab.pcap` escribe los paquetes en bruto en un archivo en lugar de mostrarlos.

Salida esperada:
```text
tcpdump: listening on enp3s0, link-type EN10MB (Ethernet), snapshot length 262144 bytes
```

`EN10MB (Ethernet)` significa que cada paquete capturado empieza con una cabecera Ethernet. También lo verás en Wi-Fi: en modo normal (no monitor), el sistema operativo entrega a la captura las tramas Wi-Fi como tramas Ethernet.

### Paso 4 — Genera tráfico DNS y HTTP
Ahora creas el tráfico que vas a analizar. Consultas el DNS directamente a tu resolvedor para que la consulta cruce la red en lugar de responderse desde una caché local. Después descargas una página por HTTP sin cifrar: con HTTP seguro (HTTPS, HTTP Secure), el cifrado te ocultaría la capa HTTP. La opción `-4` fuerza IPv4 para que tus resultados coincidan con los de la lección.

Abre un **segundo** terminal y ejecuta:

```bash
dig @<dns-server> example.com A +short
curl -4 -s -o /dev/null -w '%{http_code} %{remote_ip}\n' http://example.com/
```

- `<dns-server>` es la dirección del servidor DNS IPv4 del Paso 1.
- `-o /dev/null` descarta el cuerpo de la página; `-w` muestra el código de estado HTTP y la dirección IP del servidor.

En Windows, ejecuta esto en el Símbolo del sistema:

```bat
nslookup example.com <dns-server>
curl.exe -4 -s -o NUL -w "%{http_code} %{remote_ip}\n" http://example.com/
```

Salida esperada (Linux y macOS; las direcciones reales serán distintas y puede que veas más de una):
```text
203.0.113.80
200 203.0.113.80
```

`200` significa que el servidor web respondió correctamente a la petición.

### Paso 5 — Detén la captura y lista los paquetes
Detén la captura para que el archivo quede completo y obtén una visión general antes de acercarte a paquetes concretos.

**Wireshark:** haz clic en el cuadrado rojo (**Stop**), después en **File → Save As** y guarda como `~/osi-lab/osi-lab.pcapng`. Escribe `dns || http || tcp.port == 80` en la barra de filtro de visualización y pulsa Intro.

**tcpdump:** pulsa **Ctrl+C** en el primer terminal y luego vuelve a leer el archivo. No necesitas `sudo` para leerlo.

```bash
tcpdump -nn -r osi-lab.pcap
```

Salida esperada (abreviada; tus horas, direcciones y números de secuencia serán distintos):
```text
reading from file osi-lab.pcap, link-type EN10MB (Ethernet), snapshot length 262144
10:15:02.120000 IP 192.0.2.10.41000 > 198.51.100.53.53: 6699+ [1au] A? example.com. (40)
10:15:02.135000 IP 198.51.100.53.53 > 192.0.2.10.41000: 6699 1/0/1 A 203.0.113.80 (56)
10:15:02.150000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [S], seq 1000000, win 64240, options [mss 1460,sackOK,TS val 1000 ecr 0,nop,wscale 7], length 0
10:15:02.165000 IP 203.0.113.80.80 > 192.0.2.10.50514: Flags [S.], seq 2000000, ack 1000001, win 65535, options [mss 1460,sackOK,TS val 5000 ecr 1000,nop,wscale 10], length 0
10:15:02.180000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [.], ack 1, win 502, options [nop,nop,TS val 1001 ecr 5000], length 0
10:15:02.195000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [P.], seq 1:75, ack 1, win 502, options [nop,nop,TS val 1001 ecr 5000], length 74: HTTP: GET / HTTP/1.1
10:15:02.210000 IP 203.0.113.80.80 > 192.0.2.10.50514: Flags [P.], seq 1:79, ack 75, win 1050, options [nop,nop,TS val 5010 ecr 1001], length 78: HTTP: HTTP/1.1 200 OK
```

Deberías reconocer la historia: una pregunta y una respuesta DNS, el acuerdo en tres pasos de TCP (`[S]`, `[S.]`, `[.]`), la petición HTTP y la respuesta HTTP. Siguen más paquetes (el resto de la página y el cierre de la conexión). También puede que veas paquetes DNS del propio `curl` y de otras aplicaciones.

### Paso 6 — Analiza la consulta DNS
DNS es el paquete más sencillo de la captura: un datagrama UDP con una pregunta. Úsalo para practicar la lectura de las capas de fuera hacia dentro.

**Wireshark:** filtra por `dns` y haz clic en la primera consulta (`Standard query … A example.com`). El panel de detalles del paquete muestra una línea por capa:

```text
Frame 1: 82 bytes on wire (656 bits), 82 bytes captured (656 bits) on interface enp3s0, id 0
Ethernet II, Src: 00:00:5e:00:53:10, Dst: 00:00:5e:00:53:01
Internet Protocol Version 4, Src: 192.0.2.10, Dst: 198.51.100.53
User Datagram Protocol, Src Port: 41000, Dst Port: 53
Domain Name System (query)
```

Wireshark puede añadir el nombre del fabricante delante de cada dirección MAC. Expande cada línea con la flecha y busca: el **Type** de Ethernet, el **Protocol** y el **Time to Live** (TTL) de IP, y el **Destination Port** de UDP.

**tcpdump:** añade `-e` para mostrar la cabecera Ethernet y `-v` para mostrar los detalles de la cabecera IP.

```bash
tcpdump -nn -e -v -r osi-lab.pcap 'udp port 53'
```

Salida esperada (se muestra el primer paquete):
```text
10:15:02.120000 00:00:5e:00:53:10 > 00:00:5e:00:53:01, ethertype IPv4 (0x0800), length 82: (tos 0x0, ttl 64, id 4242, offset 0, flags [DF], proto UDP (17), length 68)
    192.0.2.10.41000 > 198.51.100.53.53: 6699+ [1au] A? example.com. (40)
```

Léelo capa por capa:

| Capa | Qué ves | Significado |
|---|---|---|
| L2 Enlace de datos | `00:00:5e:00:53:10 > 00:00:5e:00:53:01`, `ethertype IPv4 (0x0800)` | Tu dirección MAC envía a la dirección MAC de la puerta de enlace. El EtherType `0x0800` dice "la carga útil es IPv4". |
| L3 Red | `192.0.2.10 > 198.51.100.53`, `ttl 64`, `proto UDP (17)` | Las direcciones IP identifican a los dos equipos de extremo a extremo. El protocolo `17` dice "la carga útil es UDP". |
| L4 Transporte | `.41000 > .53` | Un puerto de origen aleatorio en tu lado; el puerto 53 es DNS. La PDU es un **datagrama**. |
| L7 Aplicación | `A? example.com.` | La propia pregunta DNS: "¿cuál es la dirección IPv4 de example.com?" |

Comprueba la dirección MAC de destino: es la de tu puerta de enlace, aunque el servidor DNS pueda estar en otra red. Si tu servidor DNS es tu router doméstico, la puerta de enlace y el servidor DNS son el mismo dispositivo.

> [!NOTE]
> `length 82` es la trama sin la secuencia de verificación de trama (FCS, frame check sequence) de 4 bytes. La mayoría de las tarjetas de red comprueban y quitan la FCS antes de que la captura vea la trama, por lo que las capturas no suelen mostrarla.

### Paso 7 — Lee el MSS en el acuerdo en tres pasos de TCP
En la lección calculaste que 1460 bytes de datos de aplicación caben en un segmento TCP en un enlace con MTU de 1500 bytes. TCP anuncia ese número en la **opción MSS** del segmento SYN (synchronize, sincronizar), el primer paquete del acuerdo en tres pasos. Ahora lo ves en el cable.

**Wireshark:** aplica este filtro de visualización y haz clic en el primer paquete (tu SYN, enviado desde tu dirección IP):

```text
tcp.flags.syn == 1
```

Expande **Transmission Control Protocol → Options**. Resultado esperado:

```text
TCP Option - Maximum segment size: 1460 bytes
```

También puedes filtrar directamente por el valor con `tcp.options.mss_val == 1460`.

**tcpdump:**

```bash
tcpdump -nn -e -v -r osi-lab.pcap 'tcp[tcpflags] & tcp-syn != 0'
```

El filtro conserva los segmentos con la bandera SYN activada: tu SYN y el SYN-ACK del servidor. Salida esperada:
```text
10:15:02.150000 00:00:5e:00:53:10 > 00:00:5e:00:53:01, ethertype IPv4 (0x0800), length 74: (tos 0x0, ttl 64, id 4244, offset 0, flags [DF], proto TCP (6), length 60)
    192.0.2.10.50514 > 203.0.113.80.80: Flags [S], cksum 0x42da (correct), seq 1000000, win 64240, options [mss 1460,sackOK,TS val 1000 ecr 0,nop,wscale 7], length 0
10:15:02.165000 00:00:5e:00:53:01 > 00:00:5e:00:53:10, ethertype IPv4 (0x0800), length 74: (tos 0x0, ttl 64, id 4245, offset 0, flags [DF], proto TCP (6), length 60)
    203.0.113.80.80 > 192.0.2.10.50514: Flags [S.], cksum 0xa590 (correct), seq 2000000, ack 1000001, win 65535, options [mss 1460,sackOK,TS val 5000 ecr 1000,nop,wscale 10], length 0
```

Busca `mss 1460` en tu SYN. Ahora mira los bytes en bruto de la misma trama para ver el encapsulamiento en hexadecimal:

```bash
tcpdump -nn -XX -c 1 -r osi-lab.pcap 'tcp[tcpflags] == tcp-syn'
```

Salida esperada (los bytes de tu captura serán distintos):
```text
10:15:02.150000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [S], seq 1000000, win 64240, options [mss 1460,sackOK,TS val 1000 ecr 0,nop,wscale 7], length 0
	0x0000:  0000 5e00 5301 0000 5e00 5310 0800 4500  ..^.S...^.S...E.
	0x0010:  003c 1094 4000 4006 2bcd c000 020a cb00  .<..@.@.+.......
	0x0020:  7150 c552 0050 000f 4240 0000 0000 a002  qP.R.P..B@......
	0x0030:  faf0 42da 0000 0204 05b4 0402 080a 0000  ..B.............
	0x0040:  03e8 0000 0000 0103 0307                 ..........
```

- Los bytes 0–13 son la cabecera Ethernet: MAC de destino, MAC de origen y después `0800` (IPv4).
- `45` inicia la cabecera IPv4: versión 4, longitud de cabecera 5 × 4 = 20 bytes. El décimo byte de la cabecera IP, `06`, es el campo Protocol (TCP).
- Dentro de las opciones TCP, `02 04 05b4` es la opción MSS: tipo 2, longitud 4, valor `0x05b4` = 1460.

> [!NOTE]
> Cada lado anuncia el segmento más grande que está dispuesto a *recibir*, por lo que el SYN-ACK puede mostrar un MSS distinto. Los valores inferiores a 1460 son normales en redes privadas virtuales (VPN, virtual private network), enlaces PPP sobre Ethernet (PPPoE, PPP over Ethernet) y algunas redes móviles o de nube, porque su MTU es menor o un intermediario reduce ("clamps") el MSS. En los paquetes que envías, `tcpdump -v` puede mostrar `cksum … (incorrect -> …)`. Es normal: la tarjeta de red calcula la suma de comprobación después del punto de captura (descarga de la suma de comprobación, checksum offload).

### Paso 8 — Analiza la petición HTTP capa por capa
La petición HTTP es el ejemplo más claro de encapsulamiento completo: datos de aplicación dentro de un segmento TCP, dentro de un paquete IP, dentro de una trama Ethernet. Ahora lees las cuatro cabeceras de una misma trama.

**Wireshark:** aplica el filtro de visualización `http.request` y haz clic en el paquete `GET / HTTP/1.1`. Expande cada línea del panel de detalles del paquete:

```text
Frame 6: 140 bytes on wire (1120 bits), 140 bytes captured (1120 bits) on interface enp3s0, id 0
Ethernet II, Src: 00:00:5e:00:53:10, Dst: 00:00:5e:00:53:01
Internet Protocol Version 4, Src: 192.0.2.10, Dst: 203.0.113.80
Transmission Control Protocol, Src Port: 50514, Dst Port: 80, Seq: 1, Ack: 1, Len: 74
Hypertext Transfer Protocol
```

Haz clic en una línea del panel de detalles: Wireshark resalta los bytes correspondientes en el panel de bytes de la parte inferior. Haz clic en **Ethernet II**, luego en **Internet Protocol**, después en **Transmission Control Protocol** y por último en **Hypertext Transfer Protocol**, y observa cómo el resalte avanza hacia dentro de la trama. Eso es el encapsulamiento, visto de fuera hacia dentro.

**tcpdump:**

```bash
tcpdump -nn -e -v -r osi-lab.pcap 'tcp dst port 80 and tcp[tcpflags] & tcp-push != 0'
```

El filtro conserva los segmentos que enviaste al puerto 80 y que llevan datos (bandera PSH activada). Salida esperada:
```text
10:15:02.195000 00:00:5e:00:53:10 > 00:00:5e:00:53:01, ethertype IPv4 (0x0800), length 140: (tos 0x0, ttl 64, id 4247, offset 0, flags [DF], proto TCP (6), length 126)
    192.0.2.10.50514 > 203.0.113.80.80: Flags [P.], cksum 0x4260 (correct), seq 1000001:1000075, ack 2000001, win 502, options [nop,nop,TS val 1001 ecr 5000], length 74: HTTP, length: 74
	GET / HTTP/1.1
	Host: example.com
	User-Agent: curl/8.5.0
	Accept: */*
```

Comprueba que los tamaños cuadran:

| Pieza | Bytes en este ejemplo | Dónde se lee |
|---|---|---|
| Petición HTTP (datos de aplicación) | 74 | `length 74` de TCP / `Len: 74` de Wireshark |
| Cabecera TCP (20 + 12 bytes de opciones de marca de tiempo) | 32 | longitud total de IP − cabecera IP − datos |
| Cabecera IPv4 | 20 | `Header Length: 20 bytes` de IP |
| Paquete IP (longitud total de IP) | 74 + 32 + 20 = 126 | `length 126` de IP |
| Cabecera Ethernet | 14 | |
| Trama capturada (sin FCS) | 126 + 14 = 140 | `length 140` / `Frame 6: 140 bytes` |

Después mira la respuesta del servidor (`HTTP/1.1 200 OK`) y compara su cabecera IP con la de tu petición. El origen y el destino están intercambiados, y el TTL suele ser **menor** que el valor con el que el servidor lo inició (a menudo 64 o 128). Cada router del camino lo decrementó en uno.

> [!NOTE]
> La cabecera TCP de los segmentos de datos suele medir 32 bytes en lugar de 20 porque muchos sistemas añaden la opción de marca de tiempo a cada segmento. Tus tamaños pueden ser distintos: las diferentes versiones de curl envían cabeceras ligeramente distintas (por ejemplo, otro `User-Agent`).

### Paso 9 — Asocia lo que has visto con las capas OSI
Reunir todo convierte lo que has visto en el modelo. Copia esta tabla en tus notas y rellena la última columna con los valores de **tu** captura.

| Capa OSI | PDU | Línea de Wireshark | Campo que anotar | Valor de ejemplo | Tu valor |
|---|---|---|---|---|---|
| 7 Aplicación | Datos | Hypertext Transfer Protocol | Línea de petición y `Host` | `GET / HTTP/1.1`, `example.com` | |
| 4 Transporte | Segmento | Transmission Control Protocol | Puerto de origen, puerto de destino, MSS en el SYN | `50514`, `80`, `1460` | |
| 4 Transporte | Datagrama | User Datagram Protocol | Puerto de destino de la consulta DNS | `53` | |
| 3 Red | Paquete | Internet Protocol Version 4 | IP de origen y de destino, TTL, Protocol | `192.0.2.10`, `203.0.113.80`, `64`, `6` | |
| 2 Enlace de datos | Trama | Ethernet II | MAC de origen y de destino, Type | `00:00:5e:00:53:10`, `00:00:5e:00:53:01`, `0x0800` | |
| 1 Física | Bit | Frame (metadatos de la captura) | Bytes on wire | `140` | |

> [!NOTE]
> La línea **Frame** de Wireshark no es una cabecera de protocolo. Es información que añade la herramienta de captura (hora de llegada, longitud, interfaz). Es lo más parecido a la capa 1 que verás, porque la captura solo ve bits después de que la tarjeta de red haya convertido de nuevo las señales en bytes.

Las capas 5 y 6 no tienen fila propia: con HTTP sin cifrar sobre TCP, no aparece en el cable ningún protocolo de sesión ni de presentación independiente. Con HTTPS, Transport Layer Security (TLS) se situaría entre TCP y HTTP (consulta el Reto).

## Verificación
Has completado el laboratorio cuando se cumplan todas las comprobaciones siguientes.

1. El archivo de captura existe y contiene paquetes. Wireshark: el archivo guardado se vuelve a abrir y muestra paquetes. tcpdump:

   ```bash
   tcpdump -nn -r osi-lab.pcap 2>/dev/null | wc -l
   ```

   Salida esperada: un número de al menos 7 (el número exacto varía).

2. Tu SYN lleva un MSS que coincide con tu MTU. Wireshark: el filtro `tcp.flags.syn == 1 && tcp.flags.ack == 0` muestra tu SYN, con un MSS de 1460 en una MTU de 1500 bytes. tcpdump:

   ```bash
   tcpdump -nn -r osi-lab.pcap 'tcp[tcpflags] == tcp-syn'
   ```

   Salida esperada: una línea que contiene `Flags [S]` y `mss 1460` (o MTU − 40 si tu MTU no es 1500).

Después comprueba lo que has entendido con la captura:

- [ ] Has encontrado el EtherType `0x0800` en la cabecera Ethernet de tus tramas IPv4.
- [ ] Has encontrado el Protocol de IP `17` en la consulta DNS y `6` en la petición HTTP.
- [ ] La dirección MAC de destino de tus tramas salientes es la de tu puerta de enlace, no la del servidor.
- [ ] Sabes explicar por qué el MSS es 1460: 1500 (MTU) − 20 (cabecera IPv4) − 20 (cabecera TCP).
- [ ] Tu tabla del Paso 9 está completa, con tus propios valores.

## Resolución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| Wireshark no muestra interfaces, o muestra "You don't have permission to capture on that device." | Tu usuario no tiene permiso para capturar (grupo `wireshark` en Linux, ChmodBPF en macOS, Npcap en Windows). | Linux: completa el Paso 2 y cierra sesión y vuelve a iniciarla (`id -nG` debe mostrar `wireshark`). macOS: reinstala Wireshark y acepta ChmodBPF. Windows: reinstala Npcap desde el instalador de Wireshark. |
| `tcpdump: <interface>: You don't have permission to capture on that device` | Ejecutaste `tcpdump` sin `sudo`. | Ejecuta el comando del Paso 3 con `sudo`. |
| `tcpdump: osi-lab.pcap: Permission denied` | `tcpdump` abandonó los privilegios de root y no puede escribir en la carpeta actual. | Usa la opción `-Z "$USER"` como se muestra y ejecuta el comando desde `~/osi-lab`, que es tuya. |
| La captura sigue vacía después del Paso 4. | Estás capturando en la interfaz equivocada (por ejemplo, un puerto Ethernet desconectado, un puente de Docker o una interfaz de VPN). | Comprueba la interfaz que lleva la ruta predeterminada (Paso 1) y captura en esa. En Wireshark, elige la interfaz cuyo gráfico de tráfico se mueve. |
| No hay paquetes HTTP, solo TCP puerto 443 o TLS. | Usaste `https://`, o algo te redirigió a HTTPS. El cifrado oculta la capa HTTP. | Usa exactamente `http://example.com/` con `curl`, no un navegador. Los navegadores suelen pasar a HTTPS automáticamente. |
| No hay ninguna consulta DNS en la captura. | Ejecutaste `dig` sin `@<dns-server>`, así que la respuesta vino de una caché local (por ejemplo, `systemd-resolved` en `127.0.0.53`) o a través de DNS sobre HTTPS. | Ejecuta `dig @<dns-server> example.com A` con el servidor DNS del Paso 1. Si capturaste en el bucle local (`lo`), solo ves la consulta a la caché local. |
| El MSS es muy grande (por ejemplo 65495 en Linux), o las direcciones MAC son todo ceros. | Capturaste en la interfaz de bucle local, que tiene una MTU muy grande y ninguna tarjeta de red real. | Captura en tu interfaz física (Paso 1). |
| Los paquetes muestran `ethertype IPv6 (0x86dd)` y un MSS de 1440. | `curl` se conectó por IPv6. La cabecera IPv6 mide 40 bytes, así que el MSS es 1500 − 40 − 20 = 1440. | Añade `-4` a `curl` como se muestra en el Paso 4, o conserva la captura IPv6 como comparación adicional. |
| No hay cabecera Ethernet (`link-type RAW`) y el MSS es inferior a 1460. | Hay una VPN activa y capturaste en su interfaz de túnel. | Desconecta la VPN durante el laboratorio o captura en la interfaz física. Un MSS menor a través de una VPN es lo esperado. |

## Reto (opcional)
Repite la captura con HTTPS: usa el filtro de captura `tcp port 443` y ejecuta `curl -4 -s -o /dev/null https://example.com/`. Sin ayuda paso a paso, responde a estas preguntas a partir de la captura:

1. ¿Qué cabeceras puedes seguir leyendo (Ethernet, IP, TCP) y dónde empieza la parte cifrada?
2. Busca el Client Hello de TLS. ¿Qué dato sobre el sitio web sigue siendo visible en texto claro? (Pista: busca la extensión Server Name Indication, SNI.)
3. ¿Cómo encaja esto con la afirmación de la lección de que "el cifrado en una capa solo protege las capas superiores"?

## Limpieza
Detén cualquier captura que siga en marcha (Wireshark: **Stop**; tcpdump: **Ctrl+C**) y comprueba que no queda ningún proceso `tcpdump`:

```bash
pgrep -a tcpdump
```

Salida esperada: ninguna (no aparece ningún proceso).

Borra los archivos de captura y la carpeta del laboratorio. Pueden contener datos privados.

```bash
rm -rf ~/osi-lab
```

En Windows, borra en el Explorador de archivos la carpeta donde guardaste `osi-lab.pcapng`.

Si te añadiste al grupo `wireshark` **solo para este laboratorio** (Paso 2), elimina la pertenencia y cierra sesión y vuelve a iniciarla:

```bash
sudo gpasswd -d "$USER" wireshark
```

Salida esperada:
```text
Removing user learner from group wireshark
```

Si instalaste Wireshark, Npcap o ChmodBPF solo para este laboratorio, puedes desinstalarlos con el gestor de paquetes de tu sistema o con el desinstalador de Wireshark.

> [!NOTE]
> Wireshark también recuerda los archivos abiertos recientemente. Para borrar la lista, usa **File → Open Recent → Clear Recent Files**.

## Qué has aprendido
- Una herramienta de captura te muestra todas las cabeceras de una trama, así que ves el encapsulamiento directamente en lugar de solo en diagramas.
- La cabecera de cada capa le dice al receptor qué viene a continuación: el EtherType `0x0800` significa IPv4, el Protocol de IP `6` significa TCP y `17` significa UDP, y el puerto de destino elige la aplicación.
- Tus tramas salientes van a la dirección MAC de la puerta de enlace, mientras que las direcciones IP identifican los extremos reales.
- El segmento SYN anuncia el MSS: 1460 bytes en un enlace Ethernet estándar de 1500 bytes, es decir, 1500 − 20 (IPv4) − 20 (TCP).
- El cifrado oculta las capas que están por encima. HTTP sin cifrar muestra la petición en texto claro; HTTPS muestra solo las capas inferiores y el acuerdo TLS.
- Capturar tráfico es potente y delicado: captura solo tu propio tráfico, mantén los archivos en privado y bórralos cuando termines.
