CloudAcademia
FR

Réseaux · Module 07 · IPv6 : adressage, autoconfiguration et coexistence

Lab : explorer IPv6 sur votre propre machine

Lab45 minIntermédiaireMarkdown

Affichage du Markdown brut : le moteur de rendu n'a pas pu être chargé.

## Objectif
Trouver les adresses IPv6 que votre ordinateur possède déjà, identifier le type et la portée de chacune, observer Neighbor Discovery remplir le cache de voisins et utiliser Python pour compresser, classer et planifier des adresses IPv6. Vous n'avez pas besoin d'IPv6 chez votre fournisseur d'accès : tout ce qui se passe sur le lien fonctionne avec des adresses link-local.

## Objectifs
- Lister les adresses IPv6 de vos interfaces et identifier le type et la portée de chacune (link-local, unicast global, ULA, loopback), y compris les adresses temporaires.
- Lire la table de routage IPv6 et trouver le routeur par défaut appris grâce aux Router Advertisements.
- Inspecter le cache de voisins et voir le Neighbor Discovery Protocol (NDP, protocole de découverte de voisins) y ajouter des entrées.
- Atteindre des destinations link-local et multicast à l'aide d'un ID de zone.
- Utiliser le module `ipaddress` de Python pour appliquer la RFC 5952, classer des adresses, dériver des adresses multicast solicited-node et découper un `/48` en sous-réseaux `/64`.

## Prérequis
- Un ordinateur sous une version actuelle de Linux, macOS ou Windows 10/11, avec IPv6 activé (par défaut sur les trois).
- Python 3.8 ou ultérieur (`python3 --version` ; sous Windows, `py --version`). Seule la bibliothèque standard est utilisée.
- Un terminal. Aucun droit d'administrateur ni `sudo` n'est nécessaire : toutes les commandes de ce lab ne font que lire l'état.
- Une connexion à un réseau qui vous appartient ou que vous avez le droit d'utiliser, comme votre réseau domestique. Un réseau avec IPv6 du fournisseur d'accès est un plus, pas une obligation.
- [La leçon IPv6](lesson.fr.md) de ce module, en particulier les types d'adresses, NDP et SLAAC.

> [!WARNING]
> L'étape 5 envoie un ping à l'adresse multicast de tous les nœuds `ff02::1`, qui atteint tous les appareils de votre lien. Ne le faites que sur votre propre réseau (par exemple chez vous) ou avec l'autorisation du propriétaire du réseau. Ne l'exécutez pas sur des réseaux publics, d'entreprise ou scolaires sans autorisation. Le lab ne modifie aucune configuration ; il crée seulement un dossier contenant un fichier Python, que vous supprimez à la fin.

> [!NOTE]
> Les sorties ci-dessous utilisent des valeurs de documentation : `2001:db8::/32` (RFC 3849) pour les adresses globales, `fd8f:3c2a:61e4::/48` pour l'ULA et des adresses MAC de la plage de documentation de la RFC 7042. Vos adresses réelles, noms d'interface et durées de vie seront différents. Si vous partagez vos résultats, remplacez d'abord vos adresses globales : elles identifient votre réseau.

## Architecture
<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-fr-title ipv6-lab-architecture-fr-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="fr">
<title id="ipv6-lab-architecture-fr-title">Architecture du lab : tout se passe sur votre propre lien</title>
<desc id="ipv6-lab-architecture-fr-desc">Votre ordinateur, le routeur domestique et d&#x27;autres appareils partagent un lien. L&#x27;ordinateur a une adresse link-local fe80:: avec un ID de zone pour son interface, et une adresse globale dans un /64 comme 2001:db8:acad:10::/64 seulement si le fournisseur offre l&#x27;IPv6. Le routeur, par exemple fe80::1, envoie des Router Advertisements à ff02::1. L&#x27;ordinateur et le routeur échangent des Neighbor Solicitations et Advertisements. Un ping vers ff02::1 avec l&#x27;ID de zone de l&#x27;interface atteint tous les appareils du lien. La connexion à Internet via le routeur est facultative dans ce lab.</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">Votre lien : LAN domestique ou Wi-Fi, un segment réseau</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">Votre ordinateur</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::…%&lt;iface&gt;</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">(si votre FAI fournit l&#x27;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">Box / routeur</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 (exemple)</text>
<g class="dg-l7"><rect class="dg-tint" x="490" y="160" width="254" height="26" rx="13" fill="#f0eafb" stroke="#bd9eee" stroke-width="1.2"/><text x="617" y="177.5" font-size="12" class="dg-ink" fill="#6d28d9" font-weight="700" text-anchor="middle">Envoie des 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">Autres appareils</text>
<text x="102" y="318" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Mobiles, TV, imprimantes…</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 vers 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%&lt;iface&gt;</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">(facultatif)</text>
</svg></figure>

*Figure 1. Tout ce lab se déroule sur votre propre lien. Votre ordinateur n'a besoin que d'une adresse link-local ; une adresse globale n'apparaît que si votre FAI fournit l'IPv6.*

Tout ce que vous faites se passe sur votre propre lien. Les routeurs ne transmettent jamais le trafic link-local ni `ff02::`, donc rien de ce lab ne quitte votre réseau.

## Étapes

### Étape 1 — Créez un dossier de travail
Vous y conserverez un petit utilitaire Python, de sorte que le nettoyage final tienne en une commande.

Linux et 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"
```

Aucune sortie n'est attendue.

### Étape 2 — Listez vos adresses IPv6
Toute interface avec IPv6 activé possède au moins une adresse link-local, et en général plusieurs autres. Les lister est la première chose à faire pour dépanner IPv6.

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

macOS (`<iface>` est généralement `en0`) :
```bash
ifconfig <iface> inet6
```

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

`<iface>` est le nom de votre interface réseau active. Sous Linux, il apparaît dans la sortie de `ip` (par exemple `eth0`, `enp3s0`, `wlan0` ou `wlp2s0`) ; sous macOS, `en0` est généralement le Wi-Fi ou l'Ethernet intégré.

Sortie attendue sous Linux, sur un réseau avec IPv6 du fournisseur (la vôtre sera différente) :
```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
```

Sous macOS, cherchez les mots-clés `secured` (adresse à confidentialité stable), `temporary` et `autoconf` (construite avec SLAAC) ; les adresses link-local sont affichées avec leur zone, comme dans `fe80::…%en0`. Sous Windows, la colonne `Addr Type` indique `Public` (stable), `Temporary` et `Other` (link-local), et les adresses link-local se terminent par `%<indice>`.

Si votre fournisseur n'a pas d'IPv6, vous ne verrez que `::1` et une adresse `fe80::`. Cela suffit pour le reste du lab.

### Étape 3 — Identifiez le type et la portée de chaque adresse
Copiez ce tableau dans vos notes et remplissez-le pour chaque adresse de l'étape 2. Servez-vous du tableau des types d'adresses de la leçon et de ces indices de la sortie Linux :

| Mot-clé Linux | Signification |
|---|---|
| `scope host` | Valide uniquement à l'intérieur de cette machine (`::1`). |
| `scope link` | Link-local (`fe80::/10`). |
| `scope global` | Unicast global **ou** ULA : Linux signale les deux comme global ; vérifiez le préfixe (`2000::/3` contre `fd00::/8`). |
| `temporary` | Une adresse temporaire (de confidentialité) de la RFC 8981, utilisée pour les connexions sortantes. |
| `mngtmpaddr` | L'adresse stable à partir de laquelle le noyau gère les adresses temporaires. |
| `dynamic` | Apprise automatiquement (SLAAC ou DHCPv6) et assortie de durées de vie ; les adresses statiques affichent `forever`. |
| `tentative` / `dadfailed` | La détection d'adresses dupliquées est encore en cours / a trouvé un doublon. |
| `deprecated` | La durée de vie préférée a expiré : conservée pour les connexions existantes, non utilisée pour les nouvelles. |

| Adresse | Longueur de préfixe | Type | Portée | Comment elle a été configurée |
|---|---|---|---|---|
| `::1` | `/128` | Loopback | Hôte | Intégrée |
| `fe80::4c3e:9b12:a7f0:6d21` | `/64` | Link-local | Lien | Générée à l'activation du lien |
| `2001:db8:acad:10:4c3e:9b12:a7f0:6d21` | `/64` | Unicast global, stable | Globale | SLAAC |
| `2001:db8:acad:10:91d4:2e6b:c07a:3f58` | `/64` | Unicast global, temporaire | Globale | SLAAC (RFC 8981) |
| `fd8f:3c2a:61e4:10:5a7e:21c9:8b04:e3f6` | `/64` | Locale unique (ULA) | Globale (routée seulement à l'intérieur du site) | SLAAC |

> [!TIP]
> Regardez l'ID d'interface de votre adresse link-local. S'il contient `ff:fe` au milieu (par exemple `fe80::200:5eff:fe00:5310`), votre système utilise l'EUI-64 modifié, qui intègre votre adresse MAC. Un IID d'apparence aléatoire indique que la confidentialité stable ou des IID aléatoires sont utilisés.

### Étape 4 — Trouvez votre routeur par défaut
Les hôtes IPv6 apprennent leur routeur par défaut grâce aux Router Advertisements, jamais grâce à DHCPv6. La table de routage indique d'où vient la route.

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

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

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

Sortie attendue sous Linux (avec un routeur IPv6 sur le lien) :
```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
```

Notez trois choses :
- Le saut suivant de la route par défaut est une adresse **link-local** (`fe80::1` ici ; sur de nombreuses box domestiques, c'est une longue adresse EUI-64 ou aléatoire) plus une interface (`dev eth0`). C'est pourquoi les adresses link-local ont besoin d'une zone.
- `proto ra` signifie que la route a été apprise d'un Router Advertisement.
- Les routes `/64` on-link proviennent de l'information de préfixe du RA (l'indicateur L).

Notez l'adresse link-local de votre routeur et le nom de votre interface. S'il n'y a pas de ligne `default`, votre réseau n'a pas de routeur IPv6 ; continuez quand même et sautez le ping de la passerelle à l'étape 5.

### Étape 5 — Atteignez votre lien avec le multicast et les adresses link-local
Générez maintenant un peu de trafic NDP et observez-le dans le cache de voisins. Regardez d'abord le cache tel qu'il est.

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

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

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

Envoyez ensuite un ping au groupe multicast de **tous les nœuds** de votre lien. Tous les appareils IPv6 du lien le reçoivent ; ceux qui sont configurés pour répondre le font depuis leurs adresses link-local. L'ID de zone `%<iface>` indique au système quel lien utiliser.

Linux (iputils ; sur les systèmes plus anciens, utilisez `ping6 -c 2 ff02::1%<iface>`) :
```bash
ping -c 2 ff02::1%<iface>
```

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

Sortie attendue sous Linux (une ligne par appareil qui répond ; les réponses supplémentaires au même numéro de séquence sont marquées `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 première réponse vient souvent de votre propre machine, qui est aussi membre de `ff02::1`. De nombreux appareils, y compris Windows avec ses règles de pare-feu par défaut, ne répondent pas aux pings ; ne voir que votre propre adresse est donc normal. `ttl=` dans la sortie est le Hop Limit IPv6.

> [!NOTE]
> Sous Windows, l'ID de zone est l'indice numérique de l'interface (affiché sous la forme `%<indice>` après les adresses link-local à l'étape 2, ou dans la colonne `Idx` de `netsh interface ipv6 show interfaces`). `ping -n 2 ff02::1%<indice>` est accepté, mais le `ping` de Windows n'affiche généralement pas les réponses à une destination multicast. Sous Windows, sautez le ping multicast et faites le ping de la passerelle ci-dessous.

Envoyez ensuite un ping à l'adresse link-local de votre routeur par défaut trouvée à l'étape 4 :

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

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

`<router-link-local>` est l'adresse située après `via` à l'étape 4 (par exemple `fe80::1`) ; `<indice>` est l'indice de votre interface sous Windows.

Sortie attendue sous 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
```

Regardez maintenant de nouveau le cache de voisins avec la même commande qu'avant :
```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
```

Chaque entrée associe une adresse IPv6 à une adresse MAC (`lladdr`), apprise grâce aux messages Neighbor Solicitation et Neighbor Advertisement. `router` marque un voisin qui envoie des RA. `REACHABLE` signifie confirmé récemment ; `STALE` signifie qu'il sera revérifié à la prochaine utilisation. Comparez les entrées avec ce que vous aviez vu avant les pings.

### Étape 6 — Construisez un petit utilitaire IPv6 en Python
Faire à la main la compression RFC 5952, la classification et le calcul du solicited-node est source d'erreurs. Le module standard `ipaddress` de Python fait l'arithmétique ; l'utilitaire ci-dessous ajoute la classification de la leçon.

Enregistrez ceci sous le nom `ipv6_tool.py` dans votre dossier `ipv6-lab` (avec n'importe quel éditeur de texte) :

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

Quelques remarques sur le code :
- `parse()` retire l'ID de zone et toute longueur de préfixe avant l'analyse. La zone n'est conservée que pour l'affichage.
- `classify()` utilise sa propre table plutôt que des propriétés de `ipaddress` comme `is_global` et `is_private`, dont le comportement exact a changé selon les versions de Python.
- `solicited_node()` applique la règle de la leçon : `ff02::1:ff` plus les 24 derniers bits.

Lancez l'autotest (sous Windows, utilisez `py` à la place de `python3` dans cette étape et les suivantes) :
```bash
python3 ipv6_tool.py --selftest
```

Sortie attendue :
```text
All self-tests passed.
```

### Étape 7 — Compressez, développez et classez des adresses
Lancez l'utilitaire sur un mélange d'adresses, écrites en forme longue et en forme courte :

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

Sortie attendue :
```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

```

Comparez la sortie avec la leçon :
- La première adresse est maintenant en minuscules, sans zéros de tête, et la suite de trois groupes nuls est devenue `::`.
- L'adresse link-local et son équivalent global de la leçon (`2001:db8:acad:10:4c3e:9b12:a7f0:6d21`) partagent les mêmes 24 derniers bits, donc le même groupe solicited-node, `ff02::1:fff0:6d21`. Un seul Neighbor Solicitation atteint le propriétaire des deux.

Lancez-le maintenant sur **vos propres** adresses de l'étape 2 (collez-les telles qu'elles apparaissent, avec `/64` ou `%<iface>` s'il y en a) et comparez la ligne `type` avec le tableau rempli à l'étape 3. Ne collez vos adresses globales dans aucun lieu public.

Pour finir, essayez une entrée invalide (deux `::`) pour voir ce que l'analyseur rejette :
```bash
python3 ipv6_tool.py 2001:db8::1::2
```

Sortie attendue :
```text
error: At most one '::' permitted in '2001:db8::1::2'
```

### Étape 8 — Planifiez des sous-réseaux `/64` à partir d'un préfixe de site
Reprenez l'exemple concret de la leçon : Example Corp possède `2001:db8:acad::/48`. Listez les premiers `/64`, puis regardez combien en contient un `/56` :

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

Sortie attendue :
```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 de sous-réseau est simplement le quatrième groupe. Pour obtenir le `/64` correspondant à un ID de sous-réseau donné, indexez la liste avec l'ID écrit en hexadécimal. Dans le plan de la leçon, le bâtiment 0 VLAN 10 a l'ID de sous-réseau `0010` et le bâtiment 1 VLAN 10 a `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])"
```

Sortie attendue :
```text
2001:db8:acad:10::/64 2001:db8:acad:1010::/64
```

Notez que `s[0x0010]` est l'indice 16, pas 10 : les ID de sous-réseau sont hexadécimaux.

## Vérification
Vous avez terminé le lab si tous les points suivants sont vrais :

| Contrôle | Condition de réussite |
|---|---|
| Adresses listées | Votre tableau de l'étape 3 contient au moins `::1` et une adresse `fe80::`, chacune avec le bon type et la bonne portée. |
| Routeur par défaut | Vous avez trouvé la route par défaut à l'étape 4 et pouvez dire si elle vient d'un RA (`proto ra` sous Linux), ou vous avez constaté qu'il n'y a pas de routeur IPv6 sur votre lien. |
| Neighbor Discovery | Après l'étape 5, le cache de voisins contient au moins une entrée qu'il n'avait pas avant (ou votre passerelle est `REACHABLE`). |
| ID de zone | Un ping vers une adresse link-local ou `ff02::` a fonctionné avec `%<iface>` (Linux/macOS) ou `%<indice>` (Windows). |
| Utilitaire | `python3 ipv6_tool.py --selftest` affiche `All self-tests passed.` |
| Planification | `python3 ipv6_tool.py --plan 2001:db8:acad::/56 1` indique `256 /64 subnets`. |

## Dépannage
| Symptôme | Cause probable | Correction |
|---|---|---|
| Seuls `::1` et une adresse `fe80::` apparaissent | Votre réseau ou fournisseur n'offre pas IPv6, donc aucun RA avec préfixe n'arrive. | Rien à corriger : continuez avec les adresses link-local. Les adresses globales sont facultatives dans ce lab. |
| Aucune adresse `fe80::` | IPv6 est désactivé sur l'interface (par exemple par un client VPN ou un script de durcissement). | Notez-le comme constat. Réactiver IPv6 est une modification de configuration hors de ce lab en lecture seule ; demandez à la personne qui administre la machine. |
| `ping: Warning: IPv6 link-local address on ICMP datagram socket may require ifname or scope-id` et aucune réponse | Vous avez envoyé un ping à `fe80::…` ou `ff02::1` sans ID de zone. | Ajoutez `%<iface>` (Linux/macOS) ou `%<indice>` (Windows). |
| `ping: ff02::1%wlan1: Name or service not known` | Le nom d'interface après `%` n'existe pas. | Utilisez le nom exact de l'interface de l'étape 2. |
| `ping6: command not found` (Linux) | Certaines distributions récentes ne fournissent plus de `ping6` séparé ; `ping` gère les deux. | Utilisez `ping` (il détecte IPv6 d'après l'adresse ; ajoutez `-6` si besoin). |
| Le ping multicast n'affiche que votre propre adresse | Les autres appareils ne répondent pas aux echo request envoyés en multicast (courant avec les pare-feu et certains téléphones). | Normal. Envoyez plutôt un ping à l'adresse link-local de votre passerelle, puis vérifiez le cache de voisins. |
| Une adresse affiche `dadfailed` | Un autre appareil du lien utilise la même adresse. | Notez l'adresse et l'appareil ; c'est un vrai problème réseau à signaler au propriétaire du réseau. |
| `SyntaxError` ou `AttributeError` en lançant l'utilitaire | Python antérieur à 3.8, ou erreur de copier-coller (indentation perdue). | Vérifiez `python3 --version` ; recopiez le bloc de code dans un éditeur de texte brut. |

## Défi (facultatif)
Déterminez si le pare-feu de votre ordinateur applique à IPv6 la même politique qu'à IPv4. Sous Linux, examinez le jeu de règles nftables (utilise-t-il une table `inet`, ou des tables `ip` et `ip6` séparées ?) ; sous Windows, comparez les règles ICMPv4 et ICMPv6 du Pare-feu Windows Defender ; sous macOS, examinez l'Application Firewall et les réglages `pf`. Vérifiez ensuite si les règles laisseraient passer l'ICMPv6 Packet Too Big (type 2) et les messages NDP (types 133–137), comme le recommande la RFC 4890. Certaines de ces commandes exigent des droits d'administrateur ; n'exécutez-les que sur votre propre machine et ne modifiez rien.

## Nettoyage
Le lab n'a créé que le dossier `ipv6-lab`. Les entrées du cache de voisins de l'étape 5 expirent d'elles-mêmes.

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

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

Supprimez les notes dans lesquelles vous avez collé vos vraies adresses IPv6 globales si vous n'en avez plus besoin.

## Ce que vous avez appris
- Votre ordinateur utilise déjà IPv6 : chaque interface a une adresse link-local et, avec un routeur IPv6, aussi des adresses globales stable et temporaire (et parfois une ULA).
- Linux affiche la portée (`host`, `link`, `global`) et l'origine (`temporary`, `mngtmpaddr`, `dynamic`) de chaque adresse ; les ULA apparaissent avec la portée `global`, il faut donc vérifier le préfixe.
- La route par défaut pointe vers l'adresse link-local du routeur et provient des Router Advertisements.
- Les adresses link-local et les adresses multicast de portée lien ont besoin d'un ID de zone ; NDP remplit le cache de voisins à mesure que vous parlez à vos voisins.
- Le module `ipaddress` de Python applique la RFC 5952, développe les adresses et découpe des préfixes en sous-réseaux `/64` ; les adresses solicited-node sont `ff02::1:ff` plus les 24 derniers bits.