A mostrar o Markdown sem formatação: não foi possível carregar o visualizador.
## Objetivo
Encontrar os endereços IPv6 que o computador já tem, identificar o tipo e o âmbito de cada um, ver o Neighbor Discovery preencher a cache de vizinhos e usar Python para comprimir, classificar e planear endereços IPv6. Não é necessário IPv6 do fornecedor de Internet: tudo o que se passa na ligação funciona com endereços link-local.
## Objetivos
- Listar os endereços IPv6 das interfaces e identificar o tipo e o âmbito de cada um (link-local, unicast global, ULA, loopback), incluindo os endereços temporários.
- Ler a tabela de rotas IPv6 e encontrar o router por omissão aprendido dos Router Advertisements.
- Inspecionar a cache de vizinhos e ver o Neighbor Discovery Protocol (NDP, protocolo de descoberta de vizinhos) acrescentar entradas.
- Alcançar destinos link-local e multicast usando um ID de zona.
- Usar o módulo `ipaddress` do Python para aplicar a RFC 5952, classificar endereços, derivar endereços multicast solicited-node e dividir um `/48` em sub-redes `/64`.
## Pré-requisitos
- Um computador com uma versão atual de Linux, macOS ou Windows 10/11, com IPv6 ativo (por omissão nos três).
- Python 3.8 ou posterior (`python3 --version`; no Windows, `py --version`). Só se usa a biblioteca padrão.
- Um terminal. Não são necessários direitos de administrador nem `sudo`: todos os comandos deste laboratório apenas leem o estado.
- Ligação a uma rede que seja sua ou que esteja autorizado a usar, como a rede doméstica. Uma rede com IPv6 do fornecedor de Internet é um extra, não um requisito.
- [A lição de IPv6](lesson.pt.md) deste módulo, sobretudo os tipos de endereço, o NDP e o SLAAC.
> [!WARNING]
> O passo 5 envia um ping para o endereço multicast de todos os nós `ff02::1`, que chega a todos os dispositivos da ligação. Faça-o apenas na sua própria rede (por exemplo, em casa) ou com autorização do proprietário da rede. Não o execute em redes públicas, empresariais ou escolares sem autorização. O laboratório não faz alterações de configuração; apenas cria uma pasta com um ficheiro Python, que se apaga no fim.
> [!NOTE]
> As saídas abaixo usam valores de documentação: `2001:db8::/32` (RFC 3849) para os endereços globais, `fd8f:3c2a:61e4::/48` para a ULA e endereços MAC do intervalo de documentação da RFC 7042. Os seus endereços reais, nomes de interface e tempos de vida serão diferentes. Se partilhar os resultados, substitua primeiro os endereços globais: identificam a sua rede.
## Arquitetura
<figure class="diagram" style="--dg-w: 920px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 920 370" width="920" height="370" role="img" aria-labelledby="ipv6-lab-architecture-pt-title ipv6-lab-architecture-pt-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pt">
<title id="ipv6-lab-architecture-pt-title">Arquitetura do laboratório: tudo acontece na sua própria ligação</title>
<desc id="ipv6-lab-architecture-pt-desc">O computador, o router doméstico e outros dispositivos partilham uma ligação. O computador tem um endereço link-local fe80:: com um ID de zona para a sua interface e um endereço global num /64 como 2001:db8:acad:10::/64 apenas se o fornecedor disponibilizar IPv6. O router, por exemplo fe80::1, envia Router Advertisements para ff02::1. O computador e o router trocam Neighbor Solicitations e Advertisements. Um ping a ff02::1 com o ID de zona da interface chega a todos os dispositivos da ligação. A ligação à Internet através do router é opcional neste laboratório.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="919" height="369" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l2"><rect class="dg-tint" x="20" y="20" width="720" height="330" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 20h.01"/><path d="M2 8.82a15 15 0 0 1 20 0"/><path d="M5 12.86a10 10 0 0 1 14 0"/><path d="M8.5 16.43a5 5 0 0 1 7 0"/></g>
<text x="62" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">A sua ligação: LAN doméstica ou Wi-Fi, um segmento de rede</text></g>
<rect class="dg-card" x="44" y="70" width="280" height="140" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(60 86) 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="102" y="107" font-size="15" class="dg-text" fill="#17171c" font-weight="700">O seu computador</text>
<text x="62" y="138" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">fe80::…%<iface></text>
<text x="62" y="158" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">2001:db8:acad:10::…/64</text>
<text x="62" y="178" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">(só se o ISP fornecer IPv6)</text>
<rect class="dg-card" x="474" y="70" width="244" height="140" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(490 86) 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="532" y="107" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Router doméstico</text>
<text x="492" y="138" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">fe80::1 (exemplo)</text>
<g class="dg-l7"><rect class="dg-tint" x="490" y="160" width="218" height="26" rx="13" fill="#f0eafb" stroke="#bd9eee" stroke-width="1.2"/><text x="599" y="177.5" font-size="12" class="dg-ink" fill="#6d28d9" font-weight="700" text-anchor="middle">Envia Router Advertisements</text></g>
<rect class="dg-card" x="44" y="262" width="280" height="72" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(60 278) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="10" height="14" x="3" y="8" rx="2"/><path d="M5 4a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2h-2.4"/><path d="M8 18h.01"/></g>
<text x="102" y="299" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Outros dispositivos</text>
<text x="102" y="318" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Telemóveis, TV, impressoras…</text>
<g class="dg-l7"><path class="dg-stroke" d="M474 112H330" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><path class="dg-stroke" d="M335 106l-8 6 8 6" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><rect class="dg-bg-plain" x="338.387" y="100" width="123.225" height="24" rx="12" fill="#ffffff"/><text x="400" y="116.5" font-size="11.5" class="dg-ink" fill="#6d28d9" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">RA para ff02::1</text></g>
<g class="dg-l3"><path class="dg-stroke" d="M328 172H470" stroke="#b45309" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l3"><path class="dg-stroke" d="M463 166l8 6-8 6" stroke="#b45309" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l3"><path class="dg-stroke" d="M335 166l-8 6 8 6" stroke="#b45309" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l3"><rect class="dg-bg-plain" x="368.46" y="160" width="63.08" height="24" rx="12" fill="#ffffff"/><text x="400" y="176.5" font-size="11.5" class="dg-ink" fill="#b45309" font-weight="600" text-anchor="middle">NS / NA</text></g>
<g class="dg-l1"><path class="dg-stroke" d="M150 210V256" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="7 6"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M144 249l6 8 6-8" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="160.85" y="222" width="158.3" height="24" rx="12" fill="#ffffff"/><text x="240" y="238.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">ping ff02::1%<iface></text></g>
<path class="dg-line" d="M718 140H798" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="7 6"/>
<path class="dg-line" d="M791 134l8 6-8 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<circle class="dg-card" cx="846" cy="140" r="40" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(828 122) scale(1.5000)" 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="846" y="204" font-size="14" class="dg-text" fill="#17171c" font-weight="700" text-anchor="middle">Internet</text>
<text x="846" y="222" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" text-anchor="middle">(opcional)</text>
</svg></figure>
*Figura 1. Tudo neste laboratório acontece na sua própria ligação. O computador só precisa de um endereço link-local; um endereço global só aparece se o ISP fornecer IPv6.*
Tudo o que faz acontece na sua própria ligação. Os routers nunca reencaminham tráfego link-local nem `ff02::`, pelo que nada deste laboratório sai da sua rede.
## Passos
### Passo 1 — Crie uma pasta de trabalho
Vai guardar aqui um pequeno auxiliar em Python, pelo que a limpeza final é um único comando.
Linux e macOS:
```bash
mkdir -p ~/ipv6-lab && cd ~/ipv6-lab
```
Windows (PowerShell):
```powershell
New-Item -ItemType Directory -Force "$HOME\ipv6-lab" | Out-Null; Set-Location "$HOME\ipv6-lab"
```
Não se espera qualquer saída.
### Passo 2 — Liste os endereços IPv6
Toda a interface com IPv6 ativo tem pelo menos um endereço link-local, e normalmente vários mais. Listá-los é a primeira coisa a fazer ao diagnosticar IPv6.
Linux:
```bash
ip -6 addr show
```
macOS (`<iface>` costuma ser `en0`):
```bash
ifconfig <iface> inet6
```
Windows:
```powershell
netsh interface ipv6 show addresses
```
`<iface>` é o nome da interface de rede ativa. Em Linux aparece na saída de `ip` (por exemplo `eth0`, `enp3s0`, `wlan0` ou `wlp2s0`); em macOS, `en0` costuma ser o Wi-Fi ou a Ethernet integrada.
Saída esperada em Linux, numa rede com IPv6 do fornecedor (a sua será diferente):
```text
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 state UNKNOWN qlen 1000
inet6 ::1/128 scope host noprefixroute
valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 state UP qlen 1000
inet6 2001:db8:acad:10:91d4:2e6b:c07a:3f58/64 scope global temporary dynamic
valid_lft 85912sec preferred_lft 13912sec
inet6 2001:db8:acad:10:4c3e:9b12:a7f0:6d21/64 scope global dynamic mngtmpaddr noprefixroute
valid_lft 86395sec preferred_lft 14395sec
inet6 fd8f:3c2a:61e4:10:5a7e:21c9:8b04:e3f6/64 scope global dynamic mngtmpaddr noprefixroute
valid_lft 86395sec preferred_lft 14395sec
inet6 fe80::4c3e:9b12:a7f0:6d21/64 scope link noprefixroute
valid_lft forever preferred_lft forever
```
Em macOS, procure as palavras-chave `secured` (endereço de privacidade estável), `temporary` e `autoconf` (construído com SLAAC); os endereços link-local são mostrados com a respetiva zona, como em `fe80::…%en0`. No Windows, a coluna `Addr Type` mostra `Public` (estável), `Temporary` e `Other` (link-local), e os endereços link-local terminam em `%<índice>`.
Se o fornecedor não tiver IPv6, só verá `::1` e um endereço `fe80::`. É suficiente para o resto do laboratório.
### Passo 3 — Identifique o tipo e o âmbito de cada endereço
Copie esta tabela para as suas notas e preencha-a para cada endereço do passo 2. Use a tabela de tipos de endereço da lição e estas pistas da saída do Linux:
| Palavra-chave do Linux | Significado |
|---|---|
| `scope host` | Válido apenas dentro desta máquina (`::1`). |
| `scope link` | Link-local (`fe80::/10`). |
| `scope global` | Unicast global **ou** ULA: o Linux indica ambos como global; verifique o prefixo (`2000::/3` contra `fd00::/8`). |
| `temporary` | Um endereço temporário (de privacidade) da RFC 8981, usado para ligações de saída. |
| `mngtmpaddr` | O endereço estável a partir do qual o kernel gere os endereços temporários. |
| `dynamic` | Aprendido automaticamente (SLAAC ou DHCPv6) e com tempos de vida; os endereços estáticos mostram `forever`. |
| `tentative` / `dadfailed` | A deteção de endereços duplicados ainda está em curso / encontrou um duplicado. |
| `deprecated` | O tempo de vida preferido expirou: mantido para ligações existentes, não usado para as novas. |
| Endereço | Comprimento do prefixo | Tipo | Âmbito | Como foi configurado |
|---|---|---|---|---|
| `::1` | `/128` | Loopback | Anfitrião | Integrado |
| `fe80::4c3e:9b12:a7f0:6d21` | `/64` | Link-local | Ligação | Gerado quando a ligação fica ativa |
| `2001:db8:acad:10:4c3e:9b12:a7f0:6d21` | `/64` | Unicast global, estável | Global | SLAAC |
| `2001:db8:acad:10:91d4:2e6b:c07a:3f58` | `/64` | Unicast global, temporário | Global | SLAAC (RFC 8981) |
| `fd8f:3c2a:61e4:10:5a7e:21c9:8b04:e3f6` | `/64` | Local único (ULA) | Global (encaminhado apenas dentro do site) | SLAAC |
> [!TIP]
> Observe o ID de interface do endereço link-local. Se contiver `ff:fe` a meio (por exemplo `fe80::200:5eff:fe00:5310`), o sistema usa EUI-64 modificado, que incorpora o endereço MAC. Um IID de aspeto aleatório significa que se usam privacidade estável ou IID aleatórios.
### Passo 4 — Encontre o router por omissão
Os anfitriões IPv6 aprendem o router por omissão dos Router Advertisements, nunca do DHCPv6. A tabela de rotas mostra de onde veio a rota.
Linux:
```bash
ip -6 route show
```
macOS:
```bash
netstat -rn -f inet6 | grep -i default
```
Windows:
```powershell
netsh interface ipv6 show route
```
Saída esperada em Linux (com um router IPv6 na ligação):
```text
2001:db8:acad:10::/64 dev eth0 proto ra metric 100 pref medium
fd8f:3c2a:61e4:10::/64 dev eth0 proto ra metric 100 pref medium
fe80::/64 dev eth0 proto kernel metric 1024 pref medium
default via fe80::1 dev eth0 proto ra metric 100 pref medium
```
Repare em três coisas:
- O próximo salto da rota por omissão é um endereço **link-local** (`fe80::1` aqui; em muitos routers domésticos é um endereço EUI-64 longo ou aleatório) mais uma interface (`dev eth0`). É por isso que os endereços link-local precisam de uma zona.
- `proto ra` significa que a rota foi aprendida de um Router Advertisement.
- As rotas `/64` on-link vêm da informação de prefixo do RA (o indicador L).
Anote o endereço link-local do router e o nome da interface. Se não houver nenhuma linha `default`, a rede não tem router IPv6; continue na mesma e salte o ping ao gateway do passo 5.
### Passo 5 — Alcance a ligação com multicast e endereços link-local
Agora gere um pouco de tráfego NDP e veja-o na cache de vizinhos. Primeiro, veja a cache tal como está.
Linux:
```bash
ip -6 neigh show
```
macOS:
```bash
ndp -an
```
Windows:
```powershell
netsh interface ipv6 show neighbors
```
Depois faça ping ao grupo multicast de **todos os nós** da ligação. Todos os dispositivos IPv6 da ligação o recebem; os configurados para responder fazem-no a partir dos respetivos endereços link-local. O ID de zona `%<iface>` indica ao sistema que ligação usar.
Linux (iputils; em sistemas mais antigos use `ping6 -c 2 ff02::1%<iface>`):
```bash
ping -c 2 ff02::1%<iface>
```
macOS:
```bash
ping6 -c 2 ff02::1%<iface>
```
Saída esperada em Linux (uma linha por dispositivo que responde; as respostas adicionais ao mesmo número de sequência são marcadas com `DUP!`):
```text
PING ff02::1%eth0 (ff02::1%eth0) 56 data bytes
64 bytes from fe80::4c3e:9b12:a7f0:6d21%eth0: icmp_seq=1 ttl=64 time=0.062 ms
64 bytes from fe80::1%eth0: icmp_seq=1 ttl=64 time=0.814 ms (DUP!)
64 bytes from fe80::200:5eff:fe00:5325%eth0: icmp_seq=1 ttl=64 time=3.21 ms (DUP!)
64 bytes from fe80::4c3e:9b12:a7f0:6d21%eth0: icmp_seq=2 ttl=64 time=0.058 ms
...
```
A primeira resposta costuma vir do próprio computador, que também é membro de `ff02::1`. Muitos dispositivos, incluindo o Windows com as regras de firewall por omissão, não respondem a pings, pelo que ver apenas o seu próprio endereço é normal. `ttl=` na saída é o Hop Limit do IPv6.
> [!NOTE]
> No Windows, o ID de zona é o índice numérico da interface (mostrado como `%<índice>` a seguir aos endereços link-local no passo 2, ou na coluna `Idx` de `netsh interface ipv6 show interfaces`). `ping -n 2 ff02::1%<índice>` é aceite, mas o `ping` do Windows geralmente não mostra as respostas a um destino multicast. No Windows, salte o ping multicast e faça o ping ao gateway abaixo.
Em seguida, faça ping ao endereço link-local do router por omissão do passo 4:
Linux / macOS (`ping6` em macOS):
```bash
ping -c 2 <router-link-local>%<iface>
```
Windows:
```powershell
ping -n 2 <router-link-local>%<index>
```
`<router-link-local>` é o endereço a seguir a `via` no passo 4 (por exemplo `fe80::1`); `<índice>` é o índice da interface no Windows.
Saída esperada em Linux:
```text
PING fe80::1%eth0 (fe80::1%eth0) 56 data bytes
64 bytes from fe80::1%eth0: icmp_seq=1 ttl=64 time=0.791 ms
64 bytes from fe80::1%eth0: icmp_seq=2 ttl=64 time=0.705 ms
```
Veja agora de novo a cache de vizinhos com o mesmo comando de antes:
```text
fe80::1 dev eth0 lladdr 00:00:5e:00:53:01 router REACHABLE
fe80::200:5eff:fe00:5325 dev eth0 lladdr 00:00:5e:00:53:25 STALE
```
Cada entrada associa um endereço IPv6 a um endereço MAC (`lladdr`), aprendido com mensagens Neighbor Solicitation e Neighbor Advertisement. `router` marca um vizinho que envia RA. `REACHABLE` significa confirmado recentemente; `STALE` significa que será verificado de novo na próxima utilização. Compare as entradas com o que viu antes dos pings.
### Passo 6 — Construa um pequeno auxiliar IPv6 em Python
Fazer à mão a compressão segundo a RFC 5952, a classificação e o cálculo do solicited-node é propenso a erros. O módulo padrão `ipaddress` do Python faz a aritmética; o auxiliar abaixo acrescenta a classificação da lição.
Guarde isto como `ipv6_tool.py` na pasta `ipv6-lab` (com qualquer editor de texto):
```python
"""IPv6 helper for the CloudAcademia IPv6 lab (standard library only)."""
import ipaddress
import sys
# Most specific first: the first match wins.
TYPES = [
("::/128", "unspecified"),
("::1/128", "loopback"),
("::ffff:0:0/96", "IPv4-mapped"),
("64:ff9b::/96", "NAT64 well-known prefix"),
("fe80::/10", "link-local unicast"),
("fc00::/7", "unique local (ULA)"),
("ff00::/8", "multicast"),
("2001:db8::/32", "global unicast (documentation)"),
("2000::/3", "global unicast"),
]
TYPES = [(ipaddress.ip_network(net), name) for net, name in TYPES]
MCAST_SCOPES = {1: "interface-local", 2: "link-local", 5: "site-local", 8: "organization-local", 14: "global"}
def parse(text):
"""Return (address, zone ID or None). Accepts fe80::1%eth0 and 2001:db8::1/64."""
text = text.split("/")[0]
addr, _, zone = text.partition("%")
return ipaddress.IPv6Address(addr), zone or None
def classify(addr):
for net, name in TYPES:
if addr in net:
if name == "multicast":
scope = int(addr) >> 112 & 0xF # 4th hex digit: ff0X::
return f"multicast, {MCAST_SCOPES.get(scope, f'scope {scope:x}')} scope"
return name
return "other / reserved"
def solicited_node(addr):
"""ff02::1:ff00:0/104 + the last 24 bits of the unicast address."""
return ipaddress.IPv6Address(int(ipaddress.IPv6Address("ff02::1:ff00:0")) | (int(addr) & 0xFFFFFF))
def describe(text):
addr, zone = parse(text)
print(f"input : {text}")
print(f"compressed : {addr.compressed}")
print(f"exploded : {addr.exploded}")
print(f"type : {classify(addr)}")
if zone:
print(f"zone ID : {zone}")
if not (addr.is_multicast or addr.is_unspecified or addr.is_loopback or addr.ipv4_mapped):
print(f"solicited-node : {solicited_node(addr)}")
print()
def plan(prefix, count):
net = ipaddress.IPv6Network(prefix)
subnets = net.subnets(new_prefix=64)
print(f"{net} contains {2 ** (64 - net.prefixlen)} /64 subnets. The first {count}:")
for _, sub in zip(range(count), subnets):
print(f" {sub}")
print()
def selftest():
def addr(text):
return parse(text)[0]
assert addr("2001:0DB8:0000:0000:0000:ff00:0042:8329").compressed == "2001:db8::ff00:42:8329"
assert addr("2001:db8:0:0:1:0:0:1").compressed == "2001:db8::1:0:0:1"
assert addr("2001:db8:0:1:1:1:1:1").compressed == "2001:db8:0:1:1:1:1:1"
assert parse("fe80::1%eth0") == (ipaddress.IPv6Address("fe80::1"), "eth0")
assert classify(addr("fe80::1%eth0")) == "link-local unicast"
assert classify(addr("fd8f:3c2a:61e4:10::1")) == "unique local (ULA)"
assert classify(addr("ff02::2")) == "multicast, link-local scope"
assert str(solicited_node(addr("2001:db8:acad:10:4c3e:9b12:a7f0:6d21"))) == "ff02::1:fff0:6d21"
assert len(list(ipaddress.IPv6Network("2001:db8:acad::/56").subnets(new_prefix=64))) == 256
print("All self-tests passed.")
if __name__ == "__main__":
args = sys.argv[1:]
if not args:
sys.exit("usage: ipv6_tool.py ADDRESS... | --plan PREFIX [COUNT] | --selftest")
try:
if args[0] == "--selftest":
selftest()
elif args[0] == "--plan":
plan(args[1], int(args[2]) if len(args) > 2 else 4)
else:
for a in args:
describe(a)
except ValueError as err:
sys.exit(f"error: {err}")
```
Algumas notas sobre o código:
- `parse()` retira o ID de zona e qualquer comprimento de prefixo antes de analisar. A zona é conservada apenas para apresentação.
- `classify()` usa a sua própria tabela em vez de propriedades de `ipaddress` como `is_global` e `is_private`, cujo comportamento exato mudou entre versões do Python.
- `solicited_node()` aplica a regra da lição: `ff02::1:ff` mais os últimos 24 bits.
Execute o autoteste (no Windows, use `py` em vez de `python3` neste passo e nos seguintes):
```bash
python3 ipv6_tool.py --selftest
```
Saída esperada:
```text
All self-tests passed.
```
### Passo 7 — Comprima, expanda e classifique endereços
Execute o auxiliar com uma mistura de endereços, escritos na forma longa e na curta:
```bash
python3 ipv6_tool.py 2001:0DB8:0000:0000:0000:ff00:0042:8329 fe80::4c3e:9b12:a7f0:6d21%eth0 fd8f:3c2a:61e4:10::25 ff02::1 ::1
```
Saída esperada:
```text
input : 2001:0DB8:0000:0000:0000:ff00:0042:8329
compressed : 2001:db8::ff00:42:8329
exploded : 2001:0db8:0000:0000:0000:ff00:0042:8329
type : global unicast (documentation)
solicited-node : ff02::1:ff42:8329
input : fe80::4c3e:9b12:a7f0:6d21%eth0
compressed : fe80::4c3e:9b12:a7f0:6d21
exploded : fe80:0000:0000:0000:4c3e:9b12:a7f0:6d21
type : link-local unicast
zone ID : eth0
solicited-node : ff02::1:fff0:6d21
input : fd8f:3c2a:61e4:10::25
compressed : fd8f:3c2a:61e4:10::25
exploded : fd8f:3c2a:61e4:0010:0000:0000:0000:0025
type : unique local (ULA)
solicited-node : ff02::1:ff00:25
input : ff02::1
compressed : ff02::1
exploded : ff02:0000:0000:0000:0000:0000:0000:0001
type : multicast, link-local scope
input : ::1
compressed : ::1
exploded : 0000:0000:0000:0000:0000:0000:0000:0001
type : loopback
```
Confira a saída com a lição:
- O primeiro endereço está agora em minúsculas, sem zeros à esquerda, e a sequência de três grupos de zeros é `::`.
- O endereço link-local e o seu equivalente global da lição (`2001:db8:acad:10:4c3e:9b12:a7f0:6d21`) partilham os mesmos últimos 24 bits, pelo que partilham um grupo solicited-node, `ff02::1:fff0:6d21`. Um único Neighbor Solicitation chega ao proprietário de ambos.
Execute-o agora com **os seus próprios** endereços do passo 2 (cole-os tal como aparecem, com `/64` ou `%<iface>` se existirem) e compare a linha `type` com a tabela preenchida no passo 3. Não cole os endereços globais em nenhum local público.
Por fim, experimente uma entrada inválida (dois `::`) para ver o que o analisador rejeita:
```bash
python3 ipv6_tool.py 2001:db8::1::2
```
Saída esperada:
```text
error: At most one '::' permitted in '2001:db8::1::2'
```
### Passo 8 — Planeie sub-redes `/64` a partir de um prefixo de site
Use o exemplo prático da lição: a Example Corp tem `2001:db8:acad::/48`. Liste os primeiros `/64` e depois veja quanto contém um `/56`:
```bash
python3 ipv6_tool.py --plan 2001:db8:acad::/48 4
python3 ipv6_tool.py --plan 2001:db8:acad:1000::/56 3
```
Saída esperada:
```text
2001:db8:acad::/48 contains 65536 /64 subnets. The first 4:
2001:db8:acad::/64
2001:db8:acad:1::/64
2001:db8:acad:2::/64
2001:db8:acad:3::/64
2001:db8:acad:1000::/56 contains 256 /64 subnets. The first 3:
2001:db8:acad:1000::/64
2001:db8:acad:1001::/64
2001:db8:acad:1002::/64
```
O ID de sub-rede é simplesmente o quarto grupo. Para escolher o `/64` de um dado ID de sub-rede, indexe a lista com o ID escrito em hexadecimal. No plano da lição, o edifício 0 VLAN 10 é o ID de sub-rede `0010` e o edifício 1 VLAN 10 é `1010`:
```bash
python3 -c "import ipaddress as i; s = list(i.ip_network('2001:db8:acad::/48').subnets(new_prefix=64)); print(s[0x0010], s[0x1010])"
```
Saída esperada:
```text
2001:db8:acad:10::/64 2001:db8:acad:1010::/64
```
Note que `s[0x0010]` é o índice 16, e não 10: os IDs de sub-rede são hexadecimais.
## Verificação
Concluiu o laboratório se todas as condições seguintes se verificarem:
| Verificação | Condição de sucesso |
|---|---|
| Endereços listados | A tabela do passo 3 tem pelo menos `::1` e um endereço `fe80::`, cada um com o tipo e o âmbito corretos. |
| Router por omissão | Encontrou a rota por omissão no passo 4 e sabe dizer se veio de um RA (`proto ra` em Linux), ou confirmou que não há router IPv6 na ligação. |
| Neighbor Discovery | Após o passo 5, a cache de vizinhos tem pelo menos uma entrada que antes não tinha (ou o gateway está `REACHABLE`). |
| IDs de zona | Um ping a um endereço link-local ou `ff02::` funcionou com `%<iface>` (Linux/macOS) ou `%<índice>` (Windows). |
| Auxiliar | `python3 ipv6_tool.py --selftest` imprime `All self-tests passed.` |
| Planeamento | `python3 ipv6_tool.py --plan 2001:db8:acad::/56 1` indica `256 /64 subnets`. |
## Resolução de problemas
| Sintoma | Causa provável | Solução |
|---|---|---|
| Só aparecem `::1` e um endereço `fe80::` | A rede ou o fornecedor não oferece IPv6, pelo que não chega nenhum RA com prefixo. | Nada a corrigir: continue com endereços link-local. Os endereços globais são opcionais neste laboratório. |
| Não existe nenhum endereço `fe80::` | O IPv6 está desativado na interface (por exemplo por um cliente VPN ou um script de endurecimento). | Registe-o como constatação. Reativar o IPv6 é uma alteração de configuração fora deste laboratório só de leitura; consulte quem administra a máquina. |
| `ping: Warning: IPv6 link-local address on ICMP datagram socket may require ifname or scope-id` e sem respostas | Fez ping a `fe80::…` ou `ff02::1` sem ID de zona. | Acrescente `%<iface>` (Linux/macOS) ou `%<índice>` (Windows). |
| `ping: ff02::1%wlan1: Name or service not known` | O nome de interface depois de `%` não existe. | Use o nome exato da interface do passo 2. |
| `ping6: command not found` (Linux) | Algumas distribuições recentes já não incluem um `ping6` separado; o `ping` serve para ambos. | Use `ping` (deteta IPv6 pelo endereço; acrescente `-6` se necessário). |
| O ping multicast mostra apenas o seu próprio endereço | Os outros dispositivos não respondem a echo request enviados a multicast (comum com firewalls e alguns telemóveis). | É normal. Faça ping ao endereço link-local do gateway e verifique depois a cache de vizinhos. |
| Um endereço mostra `dadfailed` | Outro dispositivo da ligação usa o mesmo endereço. | Registe qual o endereço e o dispositivo; é um problema de rede real que convém comunicar ao proprietário da rede. |
| `SyntaxError` ou `AttributeError` ao executar o auxiliar | Python anterior a 3.8, ou um erro de copiar e colar (indentação perdida). | Verifique `python3 --version`; copie de novo o bloco de código para um editor de texto simples. |
## Desafio (opcional)
Descubra se a firewall do anfitrião do computador aplica ao IPv6 a mesma política que ao IPv4. Em Linux, veja o conjunto de regras do nftables (usa uma tabela `inet`, ou tabelas `ip` e `ip6` separadas?); no Windows, compare as regras de ICMPv4 e ICMPv6 da Firewall do Windows Defender; em macOS, veja a Application Firewall e as definições do `pf`. Depois verifique se as regras deixariam passar o ICMPv6 Packet Too Big (tipo 2) e as mensagens NDP (tipos 133–137), como recomenda a RFC 4890. Alguns destes comandos precisam de direitos de administrador; execute-os apenas no seu próprio computador e não altere nada.
## Limpeza
O laboratório criou apenas a pasta `ipv6-lab`. As entradas da cache de vizinhos do passo 5 expiram sozinhas.
Linux e macOS:
```bash
cd ~ && rm -r ~/ipv6-lab
```
Windows (PowerShell):
```powershell
Set-Location $HOME; Remove-Item -Recurse -Force "$HOME\ipv6-lab"
```
Apague as notas em que colou os seus endereços IPv6 globais reais, se já não precisar delas.
## O que aprendeu
- O computador já usa IPv6: cada interface tem um endereço link-local e, com um router IPv6, também endereços globais estável e temporário (e por vezes uma ULA).
- O Linux mostra o âmbito (`host`, `link`, `global`) e a origem (`temporary`, `mngtmpaddr`, `dynamic`) de cada endereço; as ULA aparecem com âmbito `global`, pelo que se deve verificar o prefixo.
- A rota por omissão aponta para o endereço link-local do router e provém dos Router Advertisements.
- Os endereços link-local e os multicast de âmbito de ligação precisam de um ID de zona; o NDP preenche a cache de vizinhos à medida que se comunica com os vizinhos.
- O módulo `ipaddress` do Python aplica a RFC 5952, expande endereços e divide prefixos em sub-redes `/64`; os endereços solicited-node são `ff02::1:ff` mais os últimos 24 bits.