A mostrar o Markdown sem formatação: não foi possível carregar o visualizador.
## 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
<figure class="diagram" style="--dg-w: 900px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 900 420" width="900" height="420" role="img" aria-labelledby="osi-lab-architecture-pt-title osi-lab-architecture-pt-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pt">
<title id="osi-lab-architecture-pt-title">Arquitetura do laboratório: o que captura e onde</title>
<desc id="osi-lab-architecture-pt-desc">O seu computador, 192.0.2.10, executa dig e curl na camada 7. Os pedidos descem pela pilha de rede do sistema operativo (camada 4 TCP ou UDP, camada 3 IP, camada 2 Ethernet) até à interface de rede, que é o ponto de captura do Wireshark e do tcpdump. Daí, as tramas seguem para o router, o gateway predefinido 192.0.2.1, que as encaminha para o resolvedor DNS 198.51.100.53 na porta UDP 53 e para o servidor web de example.com 203.0.113.80 na porta TCP 80.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="899" height="419" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<rect class="dg-panel" x="24" y="24" width="384" height="372" rx="14" fill="#f0f0ec"/>
<g class="dg-icon-neutral" transform="translate(44 40) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="86" y="56" font-size="16" class="dg-text" fill="#17171c" font-weight="700">O seu computador</text>
<text x="86" y="76" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">192.0.2.10</text>
<g class="dg-l7"><rect class="dg-tint" x="42" y="100" width="348" height="64" rx="12" fill="#f3eefc" stroke="#c5a9f0" stroke-width="1.2"/>
<g class="dg-icon" transform="translate(58 118) scale(1.1667)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect x="2" y="4" width="20" height="16" rx="2"/><path d="M2 9h20"/><path d="M6 6.5h.01"/><path d="M9 6.5h.01"/></g>
<text x="98" y="128" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">Aplicações</text>
<text x="98" y="148" font-size="13" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">dig · curl</text>
</g>
<g class="dg-l7"><rect class="dg-solid" x="328" y="118" width="46" height="28" rx="14" fill="#6d28d9"/><text x="351.0" y="137" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L7</text></g>
<path class="dg-line" d="M216.0 168V186M210.0 175l6-7 6 7M210.0 179l6 7 6-7" stroke="#cfcfc8" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<rect class="dg-card" x="42" y="190" width="348" height="92" rx="12" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-icon-neutral" transform="translate(58 204) scale(1.0833)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="16" height="16" x="4" y="4" rx="2"/><rect width="6" height="6" x="9" y="9" rx="1"/><path d="M15 2v2"/><path d="M15 20v2"/><path d="M2 15h2"/><path d="M2 9h2"/><path d="M20 15h2"/><path d="M20 9h2"/><path d="M9 2v2"/><path d="M9 20v2"/></g>
<text x="96" y="222" font-size="14.5" class="dg-text" fill="#17171c" font-weight="700">Pilha de rede do sistema operativo</text>
<g class="dg-l4"><rect class="dg-solid" x="52" y="240" width="104" height="28" rx="14" fill="#c2410c"/><text x="104.0" y="259" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L4 · TCP/UDP</text></g>
<g class="dg-l3"><rect class="dg-solid" x="164" y="240" width="104" height="28" rx="14" fill="#b45309"/><text x="216.0" y="259" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L3 · IP</text></g>
<g class="dg-l2"><rect class="dg-solid" x="276" y="240" width="104" height="28" rx="14" fill="#15803d"/><text x="328.0" y="259" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L2 · Ethernet</text></g>
<path class="dg-line" d="M216.0 286V304M210.0 293l6-7 6 7M210.0 297l6 7 6-7" stroke="#cfcfc8" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<g class="dg-l1"><rect class="dg-tint" x="42" y="308" width="348" height="70" rx="12" fill="#ebf3f7" stroke="#9ac3d9" stroke-width="1.2"/>
<g class="dg-icon" transform="translate(58 318) scale(1.0833)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="m15 20 3-3h2a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h2l3 3z"/><path d="M6 8v1"/><path d="M10 8v1"/><path d="M14 8v1"/><path d="M18 8v1"/></g>
<text x="96" y="336" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Interface de rede</text>
</g>
<g class="dg-l6"><rect class="dg-solid" x="56" y="346" width="320" height="24" rx="12" fill="#a21caf"/>
<g class="dg-icon-on" transform="translate(66 350) scale(0.6667)" fill="none" stroke="#ffffff" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="8"/><path d="m21 21-4.3-4.3"/></g>
<text x="88" y="362.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="600">Ponto de captura: Wireshark · tcpdump</text>
</g>
<rect class="dg-card" x="436" y="168" width="186" height="68" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(452 184) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6.01 18H6"/><path d="M10.01 18H10"/><path d="M15 10v4"/><path d="M17.84 7.17a4 4 0 0 0-5.66 0"/><path d="M20.66 4.34a8 8 0 0 0-11.31 0"/></g>
<text x="492" y="198" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Router</text>
<text x="492" y="217" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500">Gateway predefinido</text>
<text x="529.0" y="258" font-size="13" class="dg-text" fill="#17171c" font-weight="500" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">192.0.2.1</text>
<rect class="dg-card" x="664" y="60" width="212" height="100" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(680 76) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g>
<text x="720" y="90" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Resolvedor DNS</text>
<text x="720" y="109" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500"></text>
<text x="680" y="140" font-size="13" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">198.51.100.53</text>
<g class="dg-l4"><rect class="dg-solid" x="790" y="124" width="70" height="28" rx="14" fill="#c2410c"/><text x="825.0" y="143" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">UDP 53</text></g>
<rect class="dg-card" x="664" y="262" width="212" height="100" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(680 278) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="2" rx="2"/><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6 6h.01"/><path d="M6 18h.01"/></g>
<text x="720" y="292" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Servidor web</text>
<text x="720" y="311" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500">example.com</text>
<text x="680" y="342" font-size="13" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">203.0.113.80</text>
<g class="dg-l4"><rect class="dg-solid" x="790" y="326" width="70" height="28" rx="14" fill="#c2410c"/><text x="825.0" y="345" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">TCP 80</text></g>
<path class="dg-line" d="M390 343H422V202.0H436" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M622 202.0H643V110.0H664" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M643 202.0V312.0H664" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M427 196.0l7 6-7 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M655 104.0l7 6-7 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M655 306.0l7 6-7 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<circle class="dg-solid dg-l6" cx="390" cy="343" r="5" fill="#a21caf"/>
</svg></figure>
*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.