---
title: "Laboratório: explorar o IPv6 no seu próprio computador"
domain: networking
level: intermediate
duration: "45 min"
cost: "gratuito"
environment: "o seu próprio computador (Linux, macOS ou Windows) na sua própria rede"
lang: pt
source_hash: c2e8e0d971ba
---

# Laboratório: explorar o IPv6 no seu próprio computador

## 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
![Arquitetura do laboratório: o seu computador, o router doméstico e outros dispositivos numa só ligação. O router envia Router Advertisements para ff02::1, o computador e o router trocam Neighbor Solicitations e Advertisements, e um ping a ff02::1 com o ID de zona da interface chega a todos os dispositivos. A Internet é opcional](../../../assets/diagrams/ipv6-lab-architecture.pt.svg)

*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.
