---
title: "Laboratório: observar o encapsulamento com o Wireshark"
domain: networking
level: beginner
duration: "45 min"
cost: "gratuito (ferramentas de código aberto no seu próprio computador)"
environment: "máquina local (o seu próprio computador e a sua rede doméstica)"
lang: pt
source_hash: ca2f25397e95
---

# Laboratório: observar o encapsulamento com o Wireshark

## Objetivo
Vai capturar a sua própria consulta do Sistema de Nomes de Domínio (DNS, Domain Name System) e o seu próprio pedido do Protocolo de Transferência de Hipertexto (HTTP, Hypertext Transfer Protocol) e, depois, desmontar cada pacote camada a camada. No final, consegue apontar os cabeçalhos Ethernet, do Protocolo de Internet (IP, Internet Protocol), do Protocolo de Controlo de Transmissão (TCP, Transmission Control Protocol) e HTTP numa captura real e indicar a que camada do modelo de interligação de sistemas abertos (OSI, Open Systems Interconnection) pertence cada um.

## Objetivos
- Capturar o seu próprio tráfego com o Wireshark, ou com o `tcpdump` como alternativa.
- Identificar os cabeçalhos Ethernet, IP, do Protocolo de Datagramas de Utilizador (UDP, User Datagram Protocol) ou TCP e de aplicação numa trama capturada.
- Associar cada campo de cabeçalho que observa à respetiva camada OSI e unidade de dados de protocolo (PDU, protocol data unit).
- Descrever o encapsulamento e o desencapsulamento a partir de dados reais, incluindo os campos de desmultiplexagem (EtherType, Protocol do IP, porta).
- Encontrar o tamanho máximo de segmento (MSS, maximum segment size) do TCP num segmento SYN e explicar porque é de 1460 bytes em Ethernet padrão.

## Pré-requisitos
- Um computador que lhe pertença ou que administre, com Linux, macOS ou Windows 10/11, ligado por Ethernet ou Wi-Fi.
- **Wireshark 4.0 ou posterior** ([wireshark.org](https://www.wireshark.org/)). No Windows, o instalador também instala o Npcap, o controlador de captura.
- Alternativa para Linux e macOS: **tcpdump 4.99 ou posterior** (verifique com `tcpdump --version`). O macOS já o inclui.
- **curl 7.68 ou posterior**. No Windows 10/11, o `curl.exe` já vem incluído.
- Uma ferramenta de consulta DNS: `dig` (BIND 9) no Linux e no macOS, ou `nslookup` no Windows.
- Permissão para capturar pacotes: direitos de administrador, ou pertença ao grupo `wireshark` no Linux (Passo 2).
- Lição: [O modelo OSI: como comunicam as redes](lesson.pt.md), em especial o exemplo prático.

> [!WARNING]
> **Autorização e ética.** Capture apenas o tráfego do seu próprio computador e de uma rede que seja sua ou que tenha autorização expressa para monitorizar. Capturar o tráfego de outras pessoas sem autorização pode ser crime e violar as regras do local de trabalho ou do estabelecimento de ensino, mesmo numa rede Wi-Fi partilhada. Numa rede do trabalho ou da escola, consulte primeiro a política de utilização aceitável, ou faça o laboratório em casa. Os ficheiros de captura podem conter dados privados (por exemplo, os nomes DNS que outras aplicações consultam). Não os partilhe e apague-os na secção de Limpeza.
>
> **Custo:** gratuito. Utiliza apenas ferramentas de código aberto e envia alguns quilobytes de tráfego.

## Arquitetura
![Arquitetura do laboratório: o seu computador executa dig e curl, o respetivo tráfego desce pela pilha de rede até à interface de rede, onde o Wireshark e o tcpdump o capturam, e depois passa pelo gateway predefinido até um resolvedor DNS e ao servidor web de example.com](../../../assets/diagrams/osi-lab-architecture.pt.svg)

*Figura 1. O que captura e onde. O ponto de captura é a sua própria interface de rede, pelo que vê todos os cabeçalhos que o seu computador envia e recebe.*

O Wireshark e o `tcpdump` copiam cada trama à passagem pela sua interface de rede. Vê a trama completa com todos os cabeçalhos, exatamente como o seu computador a envia ou recebe.

> [!NOTE]
> Os endereços deste laboratório são valores de documentação, os mesmos que a lição utiliza: endereços IP da RFC 5737 e endereços de controlo de acesso ao meio (MAC, Media Access Control) do bloco de documentação da RFC 7042 (`00:00:5e:00:53:xx`). **Os seus valores reais serão diferentes.** O seu computador tem provavelmente um endereço privado como `192.168.1.x`, e `example.com` resolve para endereços públicos reais. Vá anotando os seus próprios valores.

## Passos

### Passo 1 — Encontre a interface, os endereços e a MTU
Precisa de saber que interface transporta o seu tráfego antes de capturar nela. Também quer conhecer os seus endereços IP e MAC e o seu gateway, para os reconhecer na captura. A unidade máxima de transmissão (MTU, maximum transmission unit) permite-lhe prever o MSS antes de o ver.

No Linux:

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

`<interface>` é o nome que aparece a seguir a `dev` na saída do primeiro comando (por exemplo `enp3s0` ou `wlp2s0`). Se o `resolvectl` não estiver disponível, execute `cat /etc/resolv.conf`.

Saída 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
```

No macOS e no Windows, utilize estes comandos:

| Informação | macOS | Windows (Símbolo do sistema) |
|---|---|---|
| Interface e gateway | `route -n get default` (linhas `gateway:` e `interface:`) | `ipconfig /all` (`Default Gateway`) |
| O seu endereço MAC e a MTU | `ifconfig <interface>` (linhas `ether` e `mtu`) | `ipconfig /all` (`Physical Address`); `netsh interface ipv4 show subinterfaces` (MTU) |
| Servidor DNS | `scutil --dns \| grep nameserver` | `ipconfig /all` (`DNS Servers`) |

Anote: o nome da interface, o seu endereço IPv4, o seu endereço MAC, o endereço IP do gateway, o endereço de um servidor DNS IPv4 e a MTU. Com uma MTU de 1500, a lição prevê um MSS de 1500 − 20 (IPv4) − 20 (TCP) = 1460 bytes.

> [!NOTE]
> O Windows mostra os endereços MAC com hífenes (`00-00-5E-00-53-10`). O Wireshark mostra o mesmo endereço com dois pontos.

### Passo 2 — Prepare uma pasta e a permissão de captura
Capturar pacotes exige privilégios especiais, porque uma captura pode ver todo o tráfego da interface. Atribua a si próprio apenas a permissão de que precisa e guarde os ficheiros do laboratório numa única pasta, para facilitar a limpeza.

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

Saída esperada: nenhuma. Os comandos são executados em silêncio.

Depois, configure a permissão de captura para o seu sistema:

- **Linux, Wireshark:** se o Wireshark não listar nenhuma interface ou disser que não tem permissão, adicione-se ao grupo `wireshark` (no Debian e no Ubuntu, execute primeiro `sudo dpkg-reconfigure wireshark-common` e responda **Yes**). Depois termine a sessão e volte a iniciá-la.

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

  Lembre-se de que o fez: a Limpeza desfaz esta alteração.
- **Linux e macOS, tcpdump:** o `tcpdump` é executado com `sudo` no Passo 3. Não é necessária nenhuma configuração.
- **macOS, Wireshark:** aceite o componente **ChmodBPF** quando o instalador o oferecer.
- **Windows, Wireshark:** certifique-se de que o Npcap foi instalado com o Wireshark.

> [!TIP]
> Nunca execute toda a aplicação gráfica do Wireshark como root ou administrador. O Wireshark tem muito código de análise de protocolos e executá-lo com todos os privilégios aumenta os danos que um pacote malicioso poderia causar. A configuração baseada em grupo apenas dá ao pequeno auxiliar de captura (`dumpcap`) os direitos de que necessita.

Verifique a pertença ao grupo no Linux (depois de voltar a iniciar sessão):

```bash
id -nG
```

Saída esperada (a sua lista será diferente, mas tem de incluir `wireshark`):
```text
learner wheel wireshark
```

### Passo 3 — Inicie a captura
Só quer dois tipos de tráfego: DNS (porta UDP 53) e HTTP simples (porta TCP 80). Um **filtro de captura** indica ao motor de captura que guarde apenas esses pacotes, para que o ficheiro seja pequeno e contenha o mínimo possível de dados alheios.

**Wireshark:** abra o Wireshark. No ecrã de boas-vindas, escreva isto na caixa do filtro de captura ("…using this filter") e faça duplo clique na interface do Passo 1:

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

Resultado esperado: a lista de pacotes abre e fica vazia ou mostra alguns pacotes DNS de outras aplicações. A barra de estado mostra o nome da interface e um contador de pacotes.

**tcpdump (Linux e macOS):** execute isto num terminal e deixe-o a correr.

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

- `<interface>` é o nome da interface do Passo 1.
- `-nn` mostra endereços e números de porta em vez de nomes.
- `-Z "$USER"` faz com que o `tcpdump` abandone os privilégios de root e escreva o ficheiro como o seu utilizador, para que o possa ler e apagar sem `sudo`.
- `-w osi-lab.pcap` escreve os pacotes em bruto num ficheiro em vez de os mostrar.

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

`EN10MB (Ethernet)` significa que cada pacote capturado começa com um cabeçalho Ethernet. Também o verá em Wi-Fi: no modo normal (não monitor), o sistema operativo entrega as tramas Wi-Fi à captura como tramas Ethernet.

### Passo 4 — Gere tráfego DNS e HTTP
Agora cria o tráfego que vai analisar. Consulta o DNS diretamente no seu resolvedor, para que a consulta atravesse a rede em vez de ser respondida a partir de uma cache local. Depois, obtém uma página por HTTP simples: com o HTTP Seguro (HTTPS, HTTP Secure), a cifragem esconderia a camada HTTP. A opção `-4` força o IPv4, para que os seus resultados coincidam com os da lição.

Abra um **segundo** terminal e execute:

```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>` é o endereço do servidor DNS IPv4 do Passo 1.
- `-o /dev/null` descarta o corpo da página; `-w` mostra o código de estado HTTP e o endereço IP do servidor.

No Windows, execute isto no Símbolo do sistema:

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

Saída esperada (Linux e macOS; os endereços reais serão diferentes e pode ver mais do que um):
```text
203.0.113.80
200 203.0.113.80
```

`200` significa que o servidor web respondeu com êxito ao pedido.

### Passo 5 — Pare a captura e liste os pacotes
Pare a captura para que o ficheiro fique completo e obtenha uma visão geral antes de se concentrar em pacotes individuais.

**Wireshark:** clique no quadrado vermelho (**Stop**), depois em **File → Save As** e guarde como `~/osi-lab/osi-lab.pcapng`. Escreva `dns || http || tcp.port == 80` na barra de filtro de visualização e prima Enter.

**tcpdump:** prima **Ctrl+C** no primeiro terminal e depois leia novamente o ficheiro. Não precisa de `sudo` para o ler.

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

Saída esperada (abreviada; as horas, os endereços e os números de sequência serão diferentes):
```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
```

Deve reconhecer a história: uma pergunta e uma resposta DNS, o acordo em três passos do TCP (`[S]`, `[S.]`, `[.]`), o pedido HTTP e a resposta HTTP. Seguem-se mais pacotes (o resto da página e o encerramento da ligação). Também pode ver pacotes DNS do próprio `curl` e de outras aplicações.

### Passo 6 — Analise a consulta DNS
O DNS é o pacote mais simples da captura: um datagrama UDP com uma pergunta. Use-o para praticar a leitura das camadas de fora para dentro.

**Wireshark:** filtre por `dns` e clique na primeira consulta (`Standard query … A example.com`). O painel de detalhes do pacote mostra uma linha por camada:

```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)
```

O Wireshark pode acrescentar o nome do fabricante antes de cada endereço MAC. Expanda cada linha com a seta e encontre: o **Type** do Ethernet, o **Protocol** e o **Time to Live** (TTL) do IP e a **Destination Port** do UDP.

**tcpdump:** acrescente `-e` para mostrar o cabeçalho Ethernet e `-v` para mostrar os detalhes do cabeçalho IP.

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

Saída esperada (é mostrado o primeiro pacote):
```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)
```

Leia-o camada a camada:

| Camada | O que vê | Significado |
|---|---|---|
| L2 Ligação de dados | `00:00:5e:00:53:10 > 00:00:5e:00:53:01`, `ethertype IPv4 (0x0800)` | O seu endereço MAC envia para o endereço MAC do gateway. O EtherType `0x0800` diz "a carga útil é IPv4". |
| L3 Rede | `192.0.2.10 > 198.51.100.53`, `ttl 64`, `proto UDP (17)` | Os endereços IP identificam os dois equipamentos de ponta a ponta. O protocolo `17` diz "a carga útil é UDP". |
| L4 Transporte | `.41000 > .53` | Uma porta de origem aleatória do seu lado; a porta 53 é DNS. A PDU é um **datagrama**. |
| L7 Aplicação | `A? example.com.` | A própria pergunta DNS: "qual é o endereço IPv4 de example.com?" |

Verifique o endereço MAC de destino: é o do seu gateway, mesmo que o servidor DNS possa estar noutra rede. Se o seu servidor DNS for o router doméstico, o gateway e o servidor DNS são o mesmo dispositivo.

> [!NOTE]
> `length 82` é a trama sem a sequência de verificação de trama (FCS, frame check sequence) de 4 bytes. A maioria das placas de rede verifica e remove a FCS antes de a captura ver a trama, pelo que as capturas normalmente não a mostram.

### Passo 7 — Leia o MSS no acordo em três passos do TCP
Na lição, calculou que 1460 bytes de dados de aplicação cabem num segmento TCP numa ligação com MTU de 1500 bytes. O TCP anuncia esse número na **opção MSS** do segmento SYN (synchronize, sincronizar), o primeiro pacote do acordo em três passos. Agora vê-o no cabo.

**Wireshark:** aplique este filtro de visualização e clique no primeiro pacote (o seu SYN, enviado a partir do seu endereço IP):

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

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

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

Também pode filtrar diretamente pelo valor com `tcp.options.mss_val == 1460`.

**tcpdump:**

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

O filtro mantém os segmentos com a flag SYN ativa: o seu SYN e o SYN-ACK do servidor. Saída 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
```

Encontre `mss 1460` no seu SYN. Agora observe os bytes em bruto da mesma trama para ver o encapsulamento em hexadecimal:

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

Saída esperada (os bytes da sua captura serão diferentes):
```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                 ..........
```

- Os bytes 0–13 são o cabeçalho Ethernet: MAC de destino, MAC de origem e depois `0800` (IPv4).
- `45` inicia o cabeçalho IPv4: versão 4, comprimento do cabeçalho 5 × 4 = 20 bytes. O décimo byte do cabeçalho IP, `06`, é o campo Protocol (TCP).
- Dentro das opções TCP, `02 04 05b4` é a opção MSS: tipo 2, comprimento 4, valor `0x05b4` = 1460.

> [!NOTE]
> Cada lado anuncia o maior segmento que está disposto a *receber*, pelo que o SYN-ACK pode mostrar um MSS diferente. Valores inferiores a 1460 são normais em redes privadas virtuais (VPN, virtual private network), ligações PPP sobre Ethernet (PPPoE, PPP over Ethernet) e algumas redes móveis ou de nuvem, porque a respetiva MTU é menor ou um intermediário reduz ("clamps") o MSS. Nos pacotes que envia, o `tcpdump -v` pode mostrar `cksum … (incorrect -> …)`. É normal: a placa de rede preenche a soma de verificação depois do ponto de captura (descarga da soma de verificação, checksum offload).

### Passo 8 — Analise o pedido HTTP camada a camada
O pedido HTTP é o exemplo mais claro de encapsulamento completo: dados de aplicação dentro de um segmento TCP, dentro de um pacote IP, dentro de uma trama Ethernet. Agora lê os quatro cabeçalhos de uma única trama.

**Wireshark:** aplique o filtro de visualização `http.request` e clique no pacote `GET / HTTP/1.1`. Expanda cada linha do painel de detalhes do pacote:

```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
```

Clique numa linha do painel de detalhes: o Wireshark realça os bytes correspondentes no painel de bytes, na parte inferior. Clique em **Ethernet II**, depois em **Internet Protocol**, a seguir em **Transmission Control Protocol** e por fim em **Hypertext Transfer Protocol**, e observe o realce a avançar para o interior da trama. Isso é o encapsulamento, visto de fora para dentro.

**tcpdump:**

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

O filtro mantém os segmentos que enviou para a porta 80 e que transportam dados (flag PSH ativa). Saída 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: */*
```

Verifique se os tamanhos batem certo:

| Elemento | Bytes neste exemplo | Onde se lê |
|---|---|---|
| Pedido HTTP (dados de aplicação) | 74 | `length 74` do TCP / `Len: 74` do Wireshark |
| Cabeçalho TCP (20 + 12 bytes de opções de marca temporal) | 32 | comprimento total do IP − cabeçalho IP − dados |
| Cabeçalho IPv4 | 20 | `Header Length: 20 bytes` do IP |
| Pacote IP (comprimento total do IP) | 74 + 32 + 20 = 126 | `length 126` do IP |
| Cabeçalho Ethernet | 14 | |
| Trama capturada (sem FCS) | 126 + 14 = 140 | `length 140` / `Frame 6: 140 bytes` |

Depois, observe a resposta do servidor (`HTTP/1.1 200 OK`) e compare o respetivo cabeçalho IP com o do seu pedido. A origem e o destino estão trocados, e o TTL é normalmente **inferior** ao valor com que o servidor o iniciou (muitas vezes 64 ou 128). Cada router no caminho decrementou-o em um.

> [!NOTE]
> O cabeçalho TCP nos segmentos de dados tem muitas vezes 32 bytes em vez de 20, porque muitos sistemas acrescentam a opção de marca temporal a cada segmento. Os seus tamanhos podem ser diferentes: versões diferentes do curl enviam cabeçalhos ligeiramente diferentes (por exemplo, outro `User-Agent`).

### Passo 9 — Associe o que viu às camadas OSI
Reunir tudo transforma o que viu no modelo. Copie esta tabela para as suas notas e preencha a última coluna com os valores da **sua** captura.

| Camada OSI | PDU | Linha do Wireshark | Campo a registar | Valor de exemplo | O seu valor |
|---|---|---|---|---|---|
| 7 Aplicação | Dados | Hypertext Transfer Protocol | Linha de pedido e `Host` | `GET / HTTP/1.1`, `example.com` | |
| 4 Transporte | Segmento | Transmission Control Protocol | Porta de origem, porta de destino, MSS no SYN | `50514`, `80`, `1460` | |
| 4 Transporte | Datagrama | User Datagram Protocol | Porta de destino da consulta DNS | `53` | |
| 3 Rede | Pacote | Internet Protocol Version 4 | IP de origem e de destino, TTL, Protocol | `192.0.2.10`, `203.0.113.80`, `64`, `6` | |
| 2 Ligação de dados | Trama | Ethernet II | MAC de origem e de destino, Type | `00:00:5e:00:53:10`, `00:00:5e:00:53:01`, `0x0800` | |
| 1 Física | Bit | Frame (metadados da captura) | Bytes on wire | `140` | |

> [!NOTE]
> A linha **Frame** do Wireshark não é um cabeçalho de protocolo. É informação que a ferramenta de captura acrescenta (hora de chegada, comprimento, interface). É o que mais se aproxima da camada 1 que verá, porque a captura só vê bits depois de a placa de rede ter convertido novamente os sinais em bytes.

As camadas 5 e 6 não têm linha própria: com HTTP simples sobre TCP, não surge no cabo nenhum protocolo de sessão ou de apresentação separado. Com HTTPS, o Transport Layer Security (TLS) ficaria entre o TCP e o HTTP (consulte o Desafio).

## Verificação
Concluiu o laboratório quando todas as verificações seguintes forem bem-sucedidas.

1. O ficheiro de captura existe e contém pacotes. Wireshark: o ficheiro guardado volta a abrir e mostra pacotes. tcpdump:

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

   Saída esperada: um número de pelo menos 7 (o número exato varia).

2. O seu SYN transporta um MSS que corresponde à sua MTU. Wireshark: o filtro `tcp.flags.syn == 1 && tcp.flags.ack == 0` mostra o seu SYN, com um MSS de 1460 numa MTU de 1500 bytes. tcpdump:

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

   Saída esperada: uma linha que contém `Flags [S]` e `mss 1460` (ou MTU − 40 se a sua MTU não for 1500).

Depois, confirme a sua compreensão com a captura:

- [ ] Encontrou o EtherType `0x0800` no cabeçalho Ethernet das suas tramas IPv4.
- [ ] Encontrou o Protocol do IP `17` na consulta DNS e `6` no pedido HTTP.
- [ ] O endereço MAC de destino das suas tramas de saída é o do seu gateway, não o do servidor.
- [ ] Sabe explicar porque o MSS é 1460: 1500 (MTU) − 20 (cabeçalho IPv4) − 20 (cabeçalho TCP).
- [ ] A tabela do Passo 9 está completa, com os seus próprios valores.

## Resolução de problemas
| Sintoma | Causa provável | Solução |
|---|---|---|
| O Wireshark não mostra interfaces, ou mostra "You don't have permission to capture on that device." | O seu utilizador não tem permissão para capturar (grupo `wireshark` no Linux, ChmodBPF no macOS, Npcap no Windows). | Linux: conclua o Passo 2 e termine e volte a iniciar a sessão (`id -nG` tem de listar `wireshark`). macOS: reinstale o Wireshark e aceite o ChmodBPF. Windows: reinstale o Npcap a partir do instalador do Wireshark. |
| `tcpdump: <interface>: You don't have permission to capture on that device` | Executou o `tcpdump` sem `sudo`. | Execute o comando do Passo 3 com `sudo`. |
| `tcpdump: osi-lab.pcap: Permission denied` | O `tcpdump` abandonou os privilégios de root e não consegue escrever na pasta atual. | Utilize a opção `-Z "$USER"` como indicado e execute o comando a partir de `~/osi-lab`, que lhe pertence. |
| A captura continua vazia depois do Passo 4. | Está a capturar na interface errada (por exemplo, uma porta Ethernet desligada, uma bridge do Docker ou uma interface de VPN). | Verifique a interface que transporta a rota predefinida (Passo 1) e capture nessa. No Wireshark, escolha a interface cujo gráfico de tráfego se move. |
| Sem pacotes HTTP, apenas TCP porta 443 ou TLS. | Utilizou `https://`, ou algo o redirecionou para HTTPS. A cifragem esconde a camada HTTP. | Utilize exatamente `http://example.com/` com o `curl`, não um navegador. Os navegadores passam muitas vezes para HTTPS automaticamente. |
| Sem consulta DNS na captura. | Executou o `dig` sem `@<dns-server>`, pelo que a resposta veio de uma cache local (por exemplo, o `systemd-resolved` em `127.0.0.53`) ou através de DNS sobre HTTPS. | Execute `dig @<dns-server> example.com A` com o servidor DNS do Passo 1. Se capturou na interface de loopback (`lo`), só vê a consulta à cache local. |
| O MSS é muito grande (por exemplo 65495 no Linux), ou os endereços MAC são todos zeros. | Capturou na interface de loopback, que tem uma MTU muito grande e nenhuma placa de rede real. | Capture na sua interface física (Passo 1). |
| Os pacotes mostram `ethertype IPv6 (0x86dd)` e um MSS de 1440. | O `curl` ligou-se por IPv6. O cabeçalho IPv6 tem 40 bytes, pelo que o MSS é 1500 − 40 − 20 = 1440. | Acrescente `-4` ao `curl` como indicado no Passo 4, ou mantenha a captura IPv6 como comparação adicional. |
| Sem cabeçalho Ethernet (`link-type RAW`) e um MSS inferior a 1460. | Está ativa uma VPN e capturou na respetiva interface de túnel. | Desligue a VPN durante o laboratório ou capture na interface física. Um MSS menor através de uma VPN é o esperado. |

## Desafio (opcional)
Repita a captura com HTTPS: utilize o filtro de captura `tcp port 443` e execute `curl -4 -s -o /dev/null https://example.com/`. Sem ajuda passo a passo, responda a estas perguntas a partir da captura:

1. Que cabeçalhos continua a conseguir ler (Ethernet, IP, TCP) e onde começa a parte cifrada?
2. Encontre o Client Hello do TLS. Que informação sobre o sítio web continua visível em texto simples? (Pista: procure a extensão Server Name Indication, SNI.)
3. Como se articula isto com a afirmação da lição de que "a cifragem numa camada só protege as camadas acima dela"?

## Limpeza
Pare qualquer captura que ainda esteja a decorrer (Wireshark: **Stop**; tcpdump: **Ctrl+C**) e verifique que não resta nenhum processo `tcpdump`:

```bash
pgrep -a tcpdump
```

Saída esperada: nenhuma (não é listado nenhum processo).

Apague os ficheiros de captura e a pasta do laboratório. Podem conter dados privados.

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

No Windows, apague no Explorador de Ficheiros a pasta onde guardou `osi-lab.pcapng`.

Se se adicionou ao grupo `wireshark` **apenas para este laboratório** (Passo 2), remova a pertença e termine e volte a iniciar a sessão:

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

Saída esperada:
```text
Removing user learner from group wireshark
```

Se instalou o Wireshark, o Npcap ou o ChmodBPF apenas para este laboratório, pode desinstalá-los com o gestor de pacotes do seu sistema ou com o desinstalador do Wireshark.

> [!NOTE]
> O Wireshark também memoriza os ficheiros abertos recentemente. Para limpar a lista, utilize **File → Open Recent → Clear Recent Files**.

## O que aprendeu
- Uma ferramenta de captura mostra todos os cabeçalhos de uma trama, pelo que vê o encapsulamento diretamente, em vez de apenas em diagramas.
- O cabeçalho de cada camada diz ao recetor o que vem a seguir: o EtherType `0x0800` significa IPv4, o Protocol do IP `6` significa TCP e `17` significa UDP, e a porta de destino escolhe a aplicação.
- As suas tramas de saída vão para o endereço MAC do gateway, enquanto os endereços IP identificam os extremos reais.
- O segmento SYN anuncia o MSS: 1460 bytes numa ligação Ethernet padrão de 1500 bytes, ou seja, 1500 − 20 (IPv4) − 20 (TCP).
- A cifragem esconde as camadas acima dela. O HTTP simples mostra o pedido em texto simples; o HTTPS mostra apenas as camadas inferiores e o acordo TLS.
- Capturar tráfego é poderoso e delicado: capture apenas o seu próprio tráfego, mantenha os ficheiros privados e apague-os quando terminar.
