---
title: "Laboratorio: esplorare IPv6 sul tuo computer"
domain: networking
level: intermediate
duration: "45 min"
cost: "gratuito"
environment: "il tuo computer (Linux, macOS o Windows) sulla tua rete"
lang: it
source_hash: c2e8e0d971ba
---

# Laboratorio: esplorare IPv6 sul tuo computer

## Obiettivo
Trovare gli indirizzi IPv6 che il tuo computer ha già, identificare tipo e ambito di ciascuno, osservare Neighbor Discovery riempire la neighbor cache e usare Python per comprimere, classificare e pianificare indirizzi IPv6. Non ti serve IPv6 dal tuo fornitore di accesso: tutto ciò che avviene sul link funziona con indirizzi link-local.

## Obiettivi
- Elencare gli indirizzi IPv6 delle tue interfacce e riconoscere tipo e ambito di ciascuno (link-local, unicast globale, ULA, loopback), compresi gli indirizzi temporanei.
- Leggere la tabella di routing IPv6 e trovare il router predefinito appreso dai Router Advertisement.
- Ispezionare la neighbor cache e vedere il Neighbor Discovery Protocol (NDP, protocollo di scoperta dei vicini) aggiungere voci.
- Raggiungere destinazioni link-local e multicast usando uno zone ID.
- Usare il modulo `ipaddress` di Python per applicare la RFC 5952, classificare indirizzi, ricavare indirizzi multicast solicited-node e dividere un `/48` in sottoreti `/64`.

## Prerequisiti
- Un computer con una versione attuale di Linux, macOS o Windows 10/11, con IPv6 abilitato (impostazione predefinita su tutti e tre).
- Python 3.8 o successivo (`python3 --version`; su Windows, `py --version`). Si usa solo la libreria standard.
- Un terminale. Non servono diritti di amministratore né `sudo`: tutti i comandi di questo laboratorio si limitano a leggere lo stato.
- Connessione a una rete tua o che sei autorizzato a usare, come la rete di casa. Una rete con IPv6 dal fornitore di accesso è un bonus, non un requisito.
- [La lezione su IPv6](lesson.it.md) di questo modulo, in particolare tipi di indirizzo, NDP e SLAAC.

> [!WARNING]
> Il passo 5 invia un ping all'indirizzo multicast di tutti i nodi `ff02::1`, che raggiunge ogni dispositivo del tuo link. Fallo solo sulla tua rete (per esempio a casa) o con il permesso del proprietario della rete. Non eseguirlo su reti pubbliche, aziendali o scolastiche senza autorizzazione. Il laboratorio non modifica alcuna configurazione; crea solo una cartella con un file Python, che cancelli alla fine.

> [!NOTE]
> Gli output qui sotto usano valori di documentazione: `2001:db8::/32` (RFC 3849) per gli indirizzi globali, `fd8f:3c2a:61e4::/48` per la ULA e indirizzi MAC dell'intervallo di documentazione della RFC 7042. I tuoi indirizzi reali, i nomi delle interfacce e le durate saranno diversi. Se condividi i risultati, sostituisci prima i tuoi indirizzi globali: identificano la tua rete.

## Architettura
![Architettura del laboratorio: il tuo computer, il router di casa e altri dispositivi su un unico link. Il router invia Router Advertisement a ff02::1, computer e router si scambiano Neighbor Solicitation e Advertisement, e un ping a ff02::1 con lo zone ID dell'interfaccia raggiunge tutti i dispositivi. Internet è opzionale](../../../assets/diagrams/ipv6-lab-architecture.it.svg)

*Figura 1. Tutto in questo laboratorio avviene sul tuo link. Il computer ha bisogno solo di un indirizzo link-local; un indirizzo globale compare solo se il tuo ISP fornisce IPv6.*

Tutto ciò che fai avviene sul tuo link. I router non inoltrano mai traffico link-local né `ff02::`, quindi nulla di questo laboratorio esce dalla tua rete.

## Passaggi

### Passo 1 — Crea una cartella di lavoro
Qui conserverai un piccolo helper in Python, quindi la pulizia finale è un solo 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"
```

Non è previsto alcun output.

### Passo 2 — Elenca i tuoi indirizzi IPv6
Ogni interfaccia con IPv6 abilitato ha almeno un indirizzo link-local, e di solito diversi altri. Elencarli è la prima cosa da fare quando si diagnostica IPv6.

Linux:
```bash
ip -6 addr show
```

macOS (`<iface>` di solito è `en0`):
```bash
ifconfig <iface> inet6
```

Windows:
```powershell
netsh interface ipv6 show addresses
```

`<iface>` è il nome della tua interfaccia di rete attiva. Su Linux compare nell'output di `ip` (per esempio `eth0`, `enp3s0`, `wlan0` o `wlp2s0`); su macOS, `en0` di solito è il Wi-Fi o l'Ethernet integrata.

Output atteso su Linux, su una rete con IPv6 dal fornitore (il tuo sarà diverso):
```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
```

Su macOS, cerca le parole chiave `secured` (indirizzo a privacy stabile), `temporary` e `autoconf` (costruito con SLAAC); gli indirizzi link-local sono mostrati con la loro zona, come in `fe80::…%en0`. Su Windows, la colonna `Addr Type` mostra `Public` (stabile), `Temporary` e `Other` (link-local), e gli indirizzi link-local finiscono con `%<indice>`.

Se il tuo fornitore non ha IPv6, vedrai solo `::1` e un indirizzo `fe80::`. Basta per il resto del laboratorio.

### Passo 3 — Riconosci tipo e ambito di ogni indirizzo
Copia questa tabella nei tuoi appunti e compilala per ogni indirizzo del passo 2. Usa la tabella dei tipi di indirizzo della lezione e questi indizi dall'output di Linux:

| Parola chiave di Linux | Significato |
|---|---|
| `scope host` | Valido solo dentro questa macchina (`::1`). |
| `scope link` | Link-local (`fe80::/10`). |
| `scope global` | Unicast globale **o** ULA: Linux li indica entrambi come global; controlla il prefisso (`2000::/3` contro `fd00::/8`). |
| `temporary` | Un indirizzo temporaneo (di privacy) della RFC 8981, usato per le connessioni in uscita. |
| `mngtmpaddr` | L'indirizzo stabile da cui il kernel gestisce gli indirizzi temporanei. |
| `dynamic` | Appreso automaticamente (SLAAC o DHCPv6) e con durate; gli indirizzi statici mostrano `forever`. |
| `tentative` / `dadfailed` | Il rilevamento degli indirizzi duplicati è ancora in corso / ha trovato un duplicato. |
| `deprecated` | La durata preferita è scaduta: mantenuto per le connessioni esistenti, non usato per quelle nuove. |

| Indirizzo | Lunghezza del prefisso | Tipo | Ambito | Come è stato configurato |
|---|---|---|---|---|
| `::1` | `/128` | Loopback | Host | Integrato |
| `fe80::4c3e:9b12:a7f0:6d21` | `/64` | Link-local | Link | Generato all'attivazione del link |
| `2001:db8:acad:10:4c3e:9b12:a7f0:6d21` | `/64` | Unicast globale, stabile | Globale | SLAAC |
| `2001:db8:acad:10:91d4:2e6b:c07a:3f58` | `/64` | Unicast globale, temporaneo | Globale | SLAAC (RFC 8981) |
| `fd8f:3c2a:61e4:10:5a7e:21c9:8b04:e3f6` | `/64` | Unique local (ULA) | Globale (instradato solo dentro il sito) | SLAAC |

> [!TIP]
> Guarda l'ID di interfaccia del tuo indirizzo link-local. Se contiene `ff:fe` nel mezzo (per esempio `fe80::200:5eff:fe00:5310`), il tuo sistema usa l'EUI-64 modificato, che incorpora il tuo indirizzo MAC. Un IID dall'aspetto casuale indica che si usano privacy stabile o IID casuali.

### Passo 4 — Trova il tuo router predefinito
Gli host IPv6 apprendono il router predefinito dai Router Advertisement, mai da DHCPv6. La tabella di routing mostra da dove viene la route.

Linux:
```bash
ip -6 route show
```

macOS:
```bash
netstat -rn -f inet6 | grep -i default
```

Windows:
```powershell
netsh interface ipv6 show route
```

Output atteso su Linux (con un router IPv6 sul link):
```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
```

Nota tre cose:
- Il next hop della route predefinita è un indirizzo **link-local** (qui `fe80::1`; su molti router domestici è un lungo indirizzo EUI-64 o casuale) più un'interfaccia (`dev eth0`). Ecco perché gli indirizzi link-local richiedono una zona.
- `proto ra` significa che la route è stata appresa da un Router Advertisement.
- Le route `/64` on-link vengono dalle informazioni di prefisso dell'RA (il flag L).

Annota l'indirizzo link-local del router e il nome della tua interfaccia. Se non c'è alcuna riga `default`, la tua rete non ha un router IPv6; continua comunque e salta il ping al gateway del passo 5.

### Passo 5 — Raggiungi il tuo link con multicast e indirizzi link-local
Ora genera un po' di traffico NDP e guardalo nella neighbor cache. Prima guarda la cache così com'è.

Linux:
```bash
ip -6 neigh show
```

macOS:
```bash
ndp -an
```

Windows:
```powershell
netsh interface ipv6 show neighbors
```

Poi fai ping al gruppo multicast di **tutti i nodi** del tuo link. Lo riceve ogni dispositivo IPv6 del link; quelli configurati per rispondere lo fanno dai loro indirizzi link-local. Lo zone ID `%<iface>` indica al sistema quale link usare.

Linux (iputils; su sistemi più vecchi usa `ping6 -c 2 ff02::1%<iface>`):
```bash
ping -c 2 ff02::1%<iface>
```

macOS:
```bash
ping6 -c 2 ff02::1%<iface>
```

Output atteso su Linux (una riga per ogni dispositivo che risponde; le risposte aggiuntive allo stesso numero di sequenza sono marcate `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
...
```

La prima risposta spesso arriva dalla tua stessa macchina, che è anch'essa membro di `ff02::1`. Molti dispositivi, compreso Windows con le regole del firewall predefinite, non rispondono ai ping, quindi vedere solo il tuo indirizzo è normale. `ttl=` nell'output è l'Hop Limit di IPv6.

> [!NOTE]
> Su Windows, lo zone ID è l'indice numerico dell'interfaccia (mostrato come `%<indice>` dopo gli indirizzi link-local al passo 2, o nella colonna `Idx` di `netsh interface ipv6 show interfaces`). `ping -n 2 ff02::1%<indice>` è accettato, ma il `ping` di Windows in genere non mostra le risposte a una destinazione multicast. Su Windows, salta il ping multicast ed esegui il ping al gateway qui sotto.

Poi fai ping all'indirizzo link-local del tuo router predefinito del passo 4:

Linux / macOS (`ping6` su macOS):
```bash
ping -c 2 <router-link-local>%<iface>
```

Windows:
```powershell
ping -n 2 <router-link-local>%<index>
```

`<router-link-local>` è l'indirizzo dopo `via` nel passo 4 (per esempio `fe80::1`); `<indice>` è l'indice della tua interfaccia su Windows.

Output atteso su 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
```

Ora guarda di nuovo la neighbor cache con lo stesso comando di prima:
```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
```

Ogni voce associa un indirizzo IPv6 a un indirizzo MAC (`lladdr`), appreso con messaggi Neighbor Solicitation e Neighbor Advertisement. `router` contrassegna un vicino che invia RA. `REACHABLE` significa confermato di recente; `STALE` significa che sarà ricontrollato al prossimo uso. Confronta le voci con ciò che vedevi prima dei ping.

### Passo 6 — Costruisci un piccolo helper IPv6 in Python
Fare a mano la compressione RFC 5952, la classificazione e il calcolo del solicited-node è soggetto a errori. Il modulo standard `ipaddress` di Python fa i calcoli; l'helper qui sotto aggiunge la classificazione della lezione.

Salva questo come `ipv6_tool.py` nella tua cartella `ipv6-lab` (con un qualsiasi editor di testo):

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

Alcune note sul codice:
- `parse()` toglie lo zone ID e qualsiasi lunghezza di prefisso prima dell'analisi. La zona è conservata solo per la visualizzazione.
- `classify()` usa una propria tabella invece di proprietà di `ipaddress` come `is_global` e `is_private`, il cui comportamento esatto è cambiato fra le versioni di Python.
- `solicited_node()` applica la regola della lezione: `ff02::1:ff` più gli ultimi 24 bit.

Esegui l'autotest (su Windows, usa `py` al posto di `python3` in questo passo e nei seguenti):
```bash
python3 ipv6_tool.py --selftest
```

Output atteso:
```text
All self-tests passed.
```

### Passo 7 — Comprimi, espandi e classifica indirizzi
Esegui l'helper su un mix di indirizzi, scritti in forma lunga e corta:

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

Output atteso:
```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

```

Confronta l'output con la lezione:
- Il primo indirizzo ora è in minuscolo, senza zeri iniziali, e la sequenza di tre gruppi a zero è `::`.
- L'indirizzo link-local e il suo omologo globale della lezione (`2001:db8:acad:10:4c3e:9b12:a7f0:6d21`) condividono gli stessi ultimi 24 bit, quindi condividono un gruppo solicited-node, `ff02::1:fff0:6d21`. Un solo Neighbor Solicitation raggiunge il proprietario di entrambi.

Ora eseguilo sui **tuoi** indirizzi del passo 2 (incollali come appaiono, con `/64` o `%<iface>` se presenti) e confronta la riga `type` con la tabella compilata al passo 3. Non incollare i tuoi indirizzi globali in nessun luogo pubblico.

Infine, prova un input non valido (due `::`) per vedere cosa rifiuta il parser:
```bash
python3 ipv6_tool.py 2001:db8::1::2
```

Output atteso:
```text
error: At most one '::' permitted in '2001:db8::1::2'
```

### Passo 8 — Pianifica sottoreti `/64` da un prefisso di sito
Usa l'esempio pratico della lezione: Example Corp ha `2001:db8:acad::/48`. Elenca i primi `/64`, poi guarda quanti ne contiene un `/56`:

```bash
python3 ipv6_tool.py --plan 2001:db8:acad::/48 4
python3 ipv6_tool.py --plan 2001:db8:acad:1000::/56 3
```

Output atteso:
```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

```

L'ID di sottorete è semplicemente il quarto gruppo. Per scegliere il `/64` di un dato ID di sottorete, indicizza la lista con l'ID scritto in esadecimale. Nel piano della lezione, edificio 0 VLAN 10 è l'ID di sottorete `0010` ed edificio 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])"
```

Output atteso:
```text
2001:db8:acad:10::/64 2001:db8:acad:1010::/64
```

Nota che `s[0x0010]` è l'indice 16, non 10: gli ID di sottorete sono esadecimali.

## Verifica
Hai completato il laboratorio se tutte queste condizioni sono vere:

| Controllo | Condizione di successo |
|---|---|
| Indirizzi elencati | La tua tabella del passo 3 ha almeno `::1` e un indirizzo `fe80::`, ciascuno con tipo e ambito corretti. |
| Router predefinito | Hai trovato la route predefinita al passo 4 e sai dire se viene da un RA (`proto ra` su Linux), oppure hai accertato che sul tuo link non c'è un router IPv6. |
| Neighbor Discovery | Dopo il passo 5, la neighbor cache ha almeno una voce che prima non aveva (o il tuo gateway è `REACHABLE`). |
| Zone ID | Un ping a un indirizzo link-local o `ff02::` ha funzionato con `%<iface>` (Linux/macOS) o `%<indice>` (Windows). |
| Helper | `python3 ipv6_tool.py --selftest` stampa `All self-tests passed.` |
| Pianificazione | `python3 ipv6_tool.py --plan 2001:db8:acad::/56 1` riporta `256 /64 subnets`. |

## Risoluzione dei problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Compaiono solo `::1` e un indirizzo `fe80::` | La tua rete o il tuo fornitore non offre IPv6, quindi non arriva alcun RA con prefisso. | Nulla da correggere: continua con gli indirizzi link-local. Gli indirizzi globali sono opzionali in questo laboratorio. |
| Nessun indirizzo `fe80::` | IPv6 è disabilitato sull'interfaccia (per esempio da un client VPN o da uno script di hardening). | Annotalo come riscontro. Riabilitare IPv6 è una modifica di configurazione fuori da questo laboratorio di sola lettura; chiedi a chi gestisce la macchina. |
| `ping: Warning: IPv6 link-local address on ICMP datagram socket may require ifname or scope-id` e nessuna risposta | Hai fatto ping a `fe80::…` o `ff02::1` senza zone ID. | Aggiungi `%<iface>` (Linux/macOS) o `%<indice>` (Windows). |
| `ping: ff02::1%wlan1: Name or service not known` | Il nome dell'interfaccia dopo `%` non esiste. | Usa il nome esatto dell'interfaccia dal passo 2. |
| `ping6: command not found` (Linux) | Alcune distribuzioni recenti non includono più un `ping6` separato; `ping` gestisce entrambi. | Usa `ping` (rileva IPv6 dall'indirizzo; aggiungi `-6` se serve). |
| Il ping multicast mostra solo il tuo indirizzo | Gli altri dispositivi non rispondono agli echo request inviati a multicast (comune con firewall e alcuni telefoni). | Normale. Fai ping all'indirizzo link-local del tuo gateway, poi controlla la neighbor cache. |
| Un indirizzo mostra `dadfailed` | Un altro dispositivo sul link usa lo stesso indirizzo. | Annota quale indirizzo e quale dispositivo; è un vero problema di rete da segnalare al proprietario della rete. |
| `SyntaxError` o `AttributeError` eseguendo l'helper | Python precedente alla 3.8, o un errore di copia e incolla (indentazione persa). | Controlla `python3 --version`; copia di nuovo il blocco di codice in un editor di testo semplice. |

## Sfida (facoltativa)
Scopri se il firewall dell'host del tuo computer applica a IPv6 la stessa politica di IPv4. Su Linux, guarda il ruleset di nftables (usa una tabella `inet`, o tabelle `ip` e `ip6` separate?); su Windows, confronta le regole ICMPv4 e ICMPv6 di Windows Defender Firewall; su macOS, guarda l'Application Firewall e le impostazioni di `pf`. Poi verifica se le regole lascerebbero passare l'ICMPv6 Packet Too Big (tipo 2) e i messaggi NDP (tipi 133–137), come raccomanda la RFC 4890. Alcuni di questi comandi richiedono diritti di amministratore; eseguili solo sul tuo computer e non modificare nulla.

## Pulizia
Il laboratorio ha creato solo la cartella `ipv6-lab`. Le voci della neighbor cache del passo 5 scadono da sole.

Linux e macOS:
```bash
cd ~ && rm -r ~/ipv6-lab
```

Windows (PowerShell):
```powershell
Set-Location $HOME; Remove-Item -Recurse -Force "$HOME\ipv6-lab"
```

Cancella gli appunti in cui hai incollato i tuoi veri indirizzi IPv6 globali, se non ti servono più.

## Cosa hai imparato
- Il tuo computer usa già IPv6: ogni interfaccia ha un indirizzo link-local e, con un router IPv6, anche indirizzi globali stabile e temporaneo (e a volte una ULA).
- Linux mostra l'ambito (`host`, `link`, `global`) e l'origine (`temporary`, `mngtmpaddr`, `dynamic`) di ogni indirizzo; le ULA compaiono con ambito `global`, quindi controlla il prefisso.
- La route predefinita punta all'indirizzo link-local del router e viene dai Router Advertisement.
- Gli indirizzi link-local e multicast di ambito link richiedono uno zone ID; NDP riempie la neighbor cache man mano che parli con i vicini.
- Il modulo `ipaddress` di Python applica la RFC 5952, espande gli indirizzi e divide i prefissi in sottoreti `/64`; gli indirizzi solicited-node sono `ff02::1:ff` più gli ultimi 24 bit.
