CloudAcademia
FR

Réseaux · Module 05 · Adressage IP : les bases d'IPv4

Lab : inspecter et classer vos propres adresses

Lab45 minDébutantMarkdown

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

## Objectif
Vous lisez la configuration IPv4 de votre propre ordinateur (adresse, préfixe, passerelle et origine), vous vérifiez les calculs de la leçon avec le module `ipaddress` de Python et vous écrivez un petit script qui classe les adresses selon leur usage. Rien n'est modifié sur votre réseau.

## Objectifs
- Trouver votre adresse IPv4, la longueur de préfixe, le masque de sous-réseau et la passerelle par défaut sous Linux, macOS ou Windows.
- Savoir si votre adresse a été configurée statiquement ou par le protocole de configuration dynamique d'hôte (DHCP, Dynamic Host Configuration Protocol).
- Calculer l'adresse réseau, l'adresse de broadcast et la plage d'hôtes utilisables, et les confirmer avec Python.
- Classer des adresses IPv4 comme privées, publiques, partagées (traduction d'adresses réseau de niveau opérateur, CGN, Carrier-Grade Network Address Translation), loopback, link-local, de documentation, multicast ou broadcast.
- Expliquer pourquoi l'indicateur `is_private` de Python est plus large que « RFC 1918 ».

## Prérequis
- Un ordinateur sous Linux (avec la commande `ip` d'iproute2), macOS ou Windows 10/11.
- Python 3.8 ou ultérieur, bibliothèque standard uniquement. Ce lab a été testé avec Python 3.14.7 et 3.11.8. Vérifiez la vôtre avec `python3 --version` (sous Windows : `py --version`).
- Un éditeur de texte.
- Aucun droit d'administrateur : toutes les commandes de ce lab ne font que lire la configuration.
- [Leçon : adressage IP](lesson.fr.md) de ce module.

> [!WARNING]
> Vos propres adresses, votre passerelle et les détails du bail décrivent votre réseau. Ne publiez pas la sortie de ces commandes sur des forums publics ni dans des captures d'écran. Quand vous partagez des résultats, remplacez les valeurs par des adresses de documentation (`192.0.2.0/24`, `198.51.100.0/24`, `203.0.113.0/24`).

## Architecture
<figure class="diagram" style="--dg-w: 940px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 940 300" width="940" height="300" role="img" aria-labelledby="ip-lab-architecture-fr-title ip-lab-architecture-fr-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="fr">
<title id="ip-lab-architecture-fr-title">Architecture du lab : où vit chaque adresse</title>
<desc id="ip-lab-architecture-fr-desc">Votre ordinateur possède une adresse privée comme 192.168.1.23/24 sur votre réseau local. Votre routeur est sa passerelle par défaut en 192.168.1.1, distribue des adresses avec DHCP et les traduit avec NAT. Côté public, il se connecte à votre fournisseur d&#x27;accès avec une adresse publique, ou avec une adresse de 100.64.0.0/10 si le fournisseur utilise du NAT de niveau opérateur (CGN), puis à Internet.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="939" height="299" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l2"><rect class="dg-tint" x="20" y="20" width="470" height="260" 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"><rect x="4" y="11" width="16" height="10" rx="2"/><path d="M8 11V7a4 4 0 0 1 8 0v4"/></g>
<text x="62" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">Votre LAN · adresses privées (RFC 1918)</text></g>
<g class="dg-l1"><rect class="dg-tint" x="500" y="20" width="420" height="260" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(516 33) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" 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="542" y="47" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">Côté public</text></g>
<rect class="dg-card" x="44" y="90" width="200" height="130" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(60 106) 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="127" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Votre ordinateur</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">192.168.1.23/24</text>
<text x="62" y="178" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Adresse privée</text>
<rect class="dg-card" x="300" y="70" width="172" height="190" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(316 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="358" y="107" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Votre routeur</text>
<text x="318" y="138" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">192.168.1.1</text>
<g class="dg-l3"><rect class="dg-solid" x="318" y="152" width="96" height="26" rx="13" fill="#b45309"/><text x="366" y="169.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">Passerelle</text></g>
<g class="dg-l7"><rect class="dg-solid" x="318" y="184" width="110" height="26" rx="13" fill="#6d28d9"/><text x="373" y="201.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">Serveur DHCP</text></g>
<g class="dg-l4"><rect class="dg-solid" x="318" y="216" width="46" height="26" rx="13" fill="#c2410c"/><text x="341" y="233.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">NAT</text></g>
<rect class="dg-card" x="540" y="80" width="220" height="150" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(556 96) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4.9 16.1C1 12.2 1 5.8 4.9 1.9"/><path d="M7.8 4.7a6.14 6.14 0 0 0-.8 7.5"/><circle cx="12" cy="9" r="2"/><path d="M16.2 4.8c2 2 2.26 5.11.8 7.47"/><path d="M19.1 1.9a9.96 9.96 0 0 1 0 14.1"/><path d="M9.5 18h5"/><path d="m8 22 4-11 4 11"/></g>
<text x="598" y="117" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Votre FAI</text>
<text x="558" y="148" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Fournisseur d&#x27;accès</text>
<text x="558" y="168" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Adresse publique</text>
<g class="dg-warn"><rect class="dg-tint" x="558" y="186" width="182" height="26" rx="13" fill="#f8e8e8" stroke="#e09999" stroke-width="1.2"/><text x="649" y="203.5" font-size="12" class="dg-ink" fill="#b91c1c" font-weight="700" text-anchor="middle">ou 100.64.0.0/10 (CGN)</text></g>
<circle class="dg-card" cx="852" cy="150" r="40" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(834 132) 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="852" y="214" font-size="14" class="dg-text" fill="#17171c" font-weight="700" text-anchor="middle">Internet</text>
<path class="dg-line" d="M244 155H296" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M289 149l8 6-8 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M472 155H536" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M529 149l8 6-8 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M760 155H808" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M801 149l8 6-8 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
</svg></figure>

*Figure 1. Où vit chaque adresse. Tout ce qui est à gauche est votre réseau privé ; le routeur fait la traduction entre lui et le côté public. Les valeurs d'exemple sont typiques d'un réseau domestique ; les vôtres peuvent différer.*

*Vous n'inspectez que le cadre de gauche. Les valeurs affichées sont des exemples ; les vôtres seront différentes.*

## Étapes

### Étape 1 — Créez un dossier de travail
Vous allez écrire deux petits scripts. Gardez-les dans un seul dossier pour que le nettoyage tienne en une commande.

Linux et macOS :

```bash
mkdir -p ~/ip-lab && cd ~/ip-lab
```

Windows (PowerShell) :

```powershell
New-Item -ItemType Directory -Force "$HOME\ip-lab"; Set-Location "$HOME\ip-lab"
```

Aucune sortie signifie que tout s'est bien passé (PowerShell affiche les détails du nouveau dossier).

### Étape 2 — Trouvez votre adresse, votre préfixe et votre passerelle
Ce sont les quatre valeurs dont tout hôte a besoin. Exécutez les commandes de votre système d'exploitation et remplissez le tableau à la fin de cette étape.

**Linux.** Affichez les adresses IPv4, puis la route par défaut :

```bash
ip -4 addr show
ip route show default
```

Sortie attendue (les noms d'interface et les valeurs de la vôtre seront différents) :

```text
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
    inet 192.168.1.23/24 brd 192.168.1.255 scope global dynamic noprefixroute eth0
       valid_lft 86077sec preferred_lft 86077sec
default via 192.168.1.1 dev eth0 proto dhcp src 192.168.1.23 metric 100
```

La ligne `inet` donne l'adresse et le préfixe ensemble (`192.168.1.23/24`). Ignorez `lo` : c'est l'interface de loopback. La ligne `default via` donne la passerelle.

**macOS.** Trouvez l'interface qui porte la route par défaut, puis son adresse :

```bash
route -n get default
ifconfig en0 | grep "inet "
```

Sortie attendue (abrégée ; remplacez `en0` par la valeur de `interface` de la première commande) :

```text
   route to: default
destination: default
       mask: default
    gateway: 192.168.1.1
  interface: en0
…
	inet 192.168.1.23 netmask 0xffffff00 broadcast 192.168.1.255
```

macOS affiche le masque en hexadécimal : `0xffffff00` est `ff.ff.ff.00` = `255.255.255.0` = `/24`.

**Windows (PowerShell).**

```powershell
ipconfig /all
Get-NetRoute -DestinationPrefix 0.0.0.0/0
```

Sortie attendue (abrégée) :

```text
Ethernet adapter Ethernet:
   …
   DHCP Enabled. . . . . . . . . . . : Yes
   IPv4 Address. . . . . . . . . . . : 192.168.1.23(Preferred)
   Subnet Mask . . . . . . . . . . . : 255.255.255.0
   Lease Obtained. . . . . . . . . . : Wednesday, 4 November 2026 08:12:40
   Lease Expires . . . . . . . . . . : Thursday, 5 November 2026 08:12:40
   Default Gateway . . . . . . . . . : 192.168.1.1
   DHCP Server . . . . . . . . . . . : 192.168.1.1
   DNS Servers . . . . . . . . . . . : 192.168.1.1

ifIndex DestinationPrefix  NextHop       RouteMetric ifMetric PolicyStore
------- -----------------  -------       ----------- -------- -----------
12      0.0.0.0/0          192.168.1.1             0       25 ActiveStore
```

`0.0.0.0/0` est la route par défaut : « toute destination qui ne correspond pas à une route plus précise ».

> [!NOTE]
> La formulation exacte, l'espacement des colonnes et les formats de date varient selon la version du système d'exploitation et la langue d'affichage. Si vous voyez plusieurs adaptateurs (Wi-Fi, Ethernet, VPN, adaptateurs de machines virtuelles), utilisez celui dont la passerelle correspond à la route par défaut.

Notez vos valeurs :

| Valeur | La vôtre |
|---|---|
| Adresse IPv4 | `<address>` |
| Longueur de préfixe / masque | `<prefix>` / `<mask>` |
| Passerelle par défaut | `<gateway>` |
| Interface | `<interface>` |

### Étape 3 — Découvrez d'où vient l'adresse
Une adresse DHCP a un bail qui expire ; une adresse statique, non. Savoir laquelle vous avez indique où chercher quand quelque chose tombe en panne.

- **Linux :** la ligne `inet` de l'étape 2 contient `dynamic` et un `valid_lft` fini (par exemple `86077sec`) pour une adresse DHCP. Une adresse statique affiche `valid_lft forever` et pas de `dynamic`. `proto dhcp` sur la route par défaut le confirme.
- **Windows :** `DHCP Enabled. . . : Yes` ainsi que les lignes `Lease Obtained` / `Lease Expires` et `DHCP Server`.
- **macOS :** affichez le bail DHCP de l'interface :

  ```bash
  ipconfig getpacket en0
  ```

  Sortie attendue (abrégée) :

  ```text
  op = BOOTREPLY
  …
  yiaddr = 192.168.1.23
  …
  subnet_mask (ip): 255.255.255.0
  router (ip_mult): {192.168.1.1}
  lease_time (uint32): 0x15180
  server_identifier (ip): 192.168.1.1
  ```

  `yiaddr` (« your IP address », votre adresse IP) est l'adresse que le serveur vous a donnée. `0x15180` vaut 86 400 secondes : un bail de 24 heures. Aucune sortie signifie que l'interface n'a pas été configurée par DHCP.

Notez : statique ou DHCP ? Quel appareil est le serveur DHCP ? Sur la plupart des réseaux domestiques, c'est le même appareil que la passerelle.

### Étape 4 — Vérifiez le calcul de la leçon avec Python
Lancez une session Python interactive avec `python3` (Windows : `py`) et tapez les lignes qui suivent `>>>`. Vous allez confirmer l'exemple `192.0.2.130/26` de la section Comment ça marche de la leçon.

```python
>>> import ipaddress
>>> iface = ipaddress.ip_interface("192.0.2.130/26")
>>> iface.network
>>> iface.netmask
>>> iface.network.broadcast_address
>>> iface.network.num_addresses
>>> list(iface.network.hosts())[0]
>>> list(iface.network.hosts())[-1]
```

Sortie attendue, ligne par ligne :

```text
IPv4Network('192.0.2.128/26')
IPv4Address('255.255.255.192')
IPv4Address('192.0.2.191')
64
IPv4Address('192.0.2.129')
IPv4Address('192.0.2.190')
```

64 adresses, moins l'adresse réseau et celle de broadcast, laissent les 62 hôtes utilisables de la leçon. Vérifiez maintenant la réponse du contrôle rapide et jetez un œil à IPv6 :

```python
>>> ipaddress.ip_address("198.51.100.200") in ipaddress.ip_network("198.51.100.192/27")
>>> ipaddress.ip_interface("2001:db8:0:10::82/64").network
```

```text
True
IPv6Network('2001:db8:0:10::/64')
```

Quittez avec `exit()`.

> [!TIP]
> `ipaddress.ip_network("192.0.2.130/26")` lève `ValueError: 192.0.2.130/26 has host bits set`, car un réseau doit être écrit avec son adresse réseau. Utilisez `ip_interface()` pour « cette adresse sur ce réseau », ou passez `strict=False`.

### Étape 5 — Écrivez un calculateur d'adresses
Un script permet de refaire le calcul pour n'importe quelle adresse, y compris la vôtre. Enregistrez ceci sous `ipcalc.py` dans votre dossier `ip-lab` :

```python
"""Show the network facts for an IPv4 address with a prefix, e.g. 192.0.2.130/26."""
import ipaddress
import sys


def dotted_binary(addr):
    return ".".join(f"{int(octet):08b}" for octet in str(addr).split("."))


iface = ipaddress.IPv4Interface(sys.argv[1] if len(sys.argv) > 1 else "192.0.2.130/26")
net = iface.network

print(f"Address       {iface.ip}")
print(f"  in binary   {dotted_binary(iface.ip)}")
print(f"Prefix        /{net.prefixlen}  ({net.prefixlen} network + {32 - net.prefixlen} host bits)")
print(f"Subnet mask   {net.netmask}")
print(f"  in binary   {dotted_binary(net.netmask)}")
print(f"Network       {net.network_address}")
print(f"Broadcast     {net.broadcast_address}")
if net.prefixlen <= 30:
    print(f"First host    {net.network_address + 1}")
    print(f"Last host     {net.broadcast_address - 1}")
    print(f"Usable hosts  {net.num_addresses - 2}  (2^{32 - net.prefixlen} - 2)")
else:
    print("Special case: /31 and /32 have no separate network and broadcast addresses (see module 06).")
```

Exécutez-le sans argument (l'exemple de la leçon), puis avec le piège du `/20` de la leçon :

```bash
python3 ipcalc.py
python3 ipcalc.py 172.20.13.77/20
```

Sous Windows, utilisez `py` au lieu de `python3`. Sortie attendue :

```text
Address       192.0.2.130
  in binary   11000000.00000000.00000010.10000010
Prefix        /26  (26 network + 6 host bits)
Subnet mask   255.255.255.192
  in binary   11111111.11111111.11111111.11000000
Network       192.0.2.128
Broadcast     192.0.2.191
First host    192.0.2.129
Last host     192.0.2.190
Usable hosts  62  (2^6 - 2)
Address       172.20.13.77
  in binary   10101100.00010100.00001101.01001101
Prefix        /20  (20 network + 12 host bits)
Subnet mask   255.255.240.0
  in binary   11111111.11111111.11110000.00000000
Network       172.20.0.0
Broadcast     172.20.15.255
First host    172.20.0.1
Last host     172.20.15.254
Usable hosts  4094  (2^12 - 2)
```

Exécutez-le maintenant sur votre propre adresse de l'étape 2 :

```bash
python3 ipcalc.py <address>/<prefix>
```

`<address>/<prefix>` est votre adresse IPv4 et votre longueur de préfixe, par exemple `192.168.1.23/24`. Si vous n'avez qu'un masque en décimal pointé (Windows, macOS), Python l'accepte aussi : `192.168.1.23/255.255.255.0`.

Vérifiez : votre passerelle par défaut se trouve-t-elle entre `First host` et `Last host` ? Elle le doit.

### Étape 6 — Classez les adresses selon leur usage
Les objets `ipaddress` de Python ont des indicateurs tels que `is_private`, `is_global`, `is_loopback`, `is_link_local` et `is_multicast`. Ce script les compare à un tableau explicite des blocs à usage spécial de la leçon. Enregistrez-le sous `classify.py` :

```python
"""Classify IPv4 addresses by purpose and compare with Python's ipaddress flags."""
import ipaddress
import sys

# Special-purpose blocks (RFC 6890 and the IANA IPv4 Special-Purpose Address Registry).
# Checked in order: the first match wins, so 255.255.255.255 comes before 240.0.0.0/4.
BLOCKS = [
    ("0.0.0.0/8", "This network (RFC 791)"),
    ("10.0.0.0/8", "Private (RFC 1918)"),
    ("100.64.0.0/10", "Shared / CGN (RFC 6598)"),
    ("127.0.0.0/8", "Loopback (RFC 1122)"),
    ("169.254.0.0/16", "Link-local (RFC 3927)"),
    ("172.16.0.0/12", "Private (RFC 1918)"),
    ("192.0.2.0/24", "Documentation (RFC 5737)"),
    ("192.168.0.0/16", "Private (RFC 1918)"),
    ("198.51.100.0/24", "Documentation (RFC 5737)"),
    ("203.0.113.0/24", "Documentation (RFC 5737)"),
    ("224.0.0.0/4", "Multicast (RFC 5771)"),
    ("255.255.255.255/32", "Limited broadcast (RFC 919)"),
    ("240.0.0.0/4", "Reserved (RFC 1112)"),
]
BLOCKS = [(ipaddress.IPv4Network(net), label) for net, label in BLOCKS]

SAMPLES = [
    "192.168.1.10", "10.20.30.40", "172.20.1.5", "172.32.1.5", "100.64.12.34",
    "127.0.0.1", "169.254.17.3", "192.0.2.130", "198.51.100.7", "203.0.113.250",
    "224.0.0.251", "255.255.255.255", "0.0.0.0",
]


def purpose(addr):
    for net, label in BLOCKS:
        if addr in net:
            return label
    if addr.is_global:
        return "Public (global unicast)"
    return "Other special (see IANA)"


def mark(flag):
    return "yes" if flag else "-"


print(f"{'Address':<16} {'Purpose':<28} {'private':>7} {'global':>6} {'loopbk':>6} {'link-l':>6} {'mcast':>5}")
for text in sys.argv[1:] or SAMPLES:
    a = ipaddress.IPv4Address(text)
    print(f"{text:<16} {purpose(a):<28} {mark(a.is_private):>7} {mark(a.is_global):>6} "
          f"{mark(a.is_loopback):>6} {mark(a.is_link_local):>6} {mark(a.is_multicast):>5}")
```

Exécutez-le sur les échantillons intégrés :

```bash
python3 classify.py
```

Sortie attendue :

```text
Address          Purpose                      private global loopbk link-l mcast
192.168.1.10     Private (RFC 1918)               yes      -      -      -     -
10.20.30.40      Private (RFC 1918)               yes      -      -      -     -
172.20.1.5       Private (RFC 1918)               yes      -      -      -     -
172.32.1.5       Public (global unicast)            -    yes      -      -     -
100.64.12.34     Shared / CGN (RFC 6598)            -      -      -      -     -
127.0.0.1        Loopback (RFC 1122)              yes      -    yes      -     -
169.254.17.3     Link-local (RFC 3927)            yes      -      -    yes     -
192.0.2.130      Documentation (RFC 5737)         yes      -      -      -     -
198.51.100.7     Documentation (RFC 5737)         yes      -      -      -     -
203.0.113.250    Documentation (RFC 5737)         yes      -      -      -     -
224.0.0.251      Multicast (RFC 5771)               -    yes      -      -   yes
255.255.255.255  Limited broadcast (RFC 919)      yes      -      -      -     -
0.0.0.0          This network (RFC 791)           yes      -      -      -     -
```

Lisez attentivement le tableau. Quatre résultats surprennent la plupart des gens :
- **`172.32.1.5` est public.** Le bloc RFC 1918 `172.16.0.0/12` s'arrête à `172.31.255.255`.
- **`is_private` n'est pas « RFC 1918 ».** Python marque une adresse comme privée quand le registre de l'IANA dit qu'elle *n'est pas joignable globalement*. Cela inclut le loopback, le link-local, la documentation, `0.0.0.0` et le broadcast. Pour tester spécifiquement la RFC 1918, vérifiez vous-même les trois blocs, comme le fait `BLOCKS`.
- **`100.64.12.34` n'est ni privé ni global.** Python traite l'espace partagé CGN (RFC 6598) comme un cas particulier : il n'est pas joignable depuis Internet, mais il n'est pas à vous non plus.
- **`224.0.0.251` est « global ».** `is_global` provient du registre à usage spécial, et le multicast n'y figure pas (il a son propre registre). `is_global` ne signifie pas « adresse unicast publique que vous pouvez pinguer ».

> [!NOTE]
> Python 3.12.4 et 3.13 ont corrigé les tables derrière `is_private` et `is_global` pour qu'elles correspondent au registre de l'IANA (CVE-2024-4032 ; le correctif a aussi été rétroporté dans des versions de sécurité de certaines branches plus anciennes). Pour toutes les adresses de `SAMPLES`, la sortie ci-dessus est identique sous Python 3.14.7 et sous 3.11.8, qui est antérieur au correctif. Les résultats diffèrent pour certaines adresses de `192.0.0.0/24` : par exemple, `192.0.0.100` est `global` sous 3.11.8 et `private` sous 3.14.7. Si vous vous appuyez sur ces indicateurs dans du code réel, vérifiez votre version de Python.

### Étape 7 — Classez vos propres adresses
Passez en arguments votre adresse et votre passerelle de l'étape 2 :

```bash
python3 classify.py <address> <gateway>
```

Avec les valeurs d'exemple (`192.168.1.23`, passerelle `192.168.1.1`), la sortie est :

```text
Address          Purpose                      private global loopbk link-l mcast
192.168.1.23     Private (RFC 1918)               yes      -      -      -     -
192.168.1.1      Private (RFC 1918)               yes      -      -      -     -
```

La plupart des ordinateurs domestiques et de bureau reçoivent une adresse privée et accèdent à Internet via la traduction d'adresses réseau (NAT, Network Address Translation) du routeur. Si votre adresse est publique, votre réseau attribue directement des adresses publiques (certaines universités et centres de données le font). Si elle est link-local (`169.254.x.x`), DHCP a échoué : voir Dépannage.

## Vérification
Vous avez terminé le lab si vous pouvez répondre « oui » à chaque contrôle :

| Contrôle | Comment le confirmer |
|---|---|
| Vous avez noté adresse, préfixe, passerelle et interface | Le tableau de l'étape 2 est rempli |
| Vous savez si votre adresse est statique ou DHCP | Étape 3 : `dynamic` / `DHCP Enabled: Yes` / sortie de `ipconfig getpacket` |
| Python est d'accord avec la leçon | L'étape 4 affiche `192.0.2.128/26`, `192.0.2.191` et 64 adresses |
| Votre passerelle est dans votre propre réseau | `python3 ipcalc.py <address>/<prefix>` montre la passerelle entre `First host` et `Last host` |
| Vous savez expliquer `is_private` par rapport à la RFC 1918 | `python3 classify.py` affiche `yes` sous `private` pour `192.0.2.130` bien qu'elle ne soit pas RFC 1918 |

## Dépannage
| Symptôme | Cause probable | Solution |
|---|---|---|
| `python3: command not found` (ou le Microsoft Store s'ouvre sous Windows) | Python n'est pas installé, ou sous Windows il est installé sous le nom `py` | Utilisez `py` sous Windows, ou installez Python 3 depuis python.org ou votre gestionnaire de paquets |
| `ip: command not found` sous Linux | Système minimal sans iproute2 | Installez le paquet `iproute2`, ou utilisez `hostname -I` pour les adresses uniquement |
| Plusieurs adresses et adaptateurs listés | Réseau privé virtuel (VPN), Docker, machine virtuelle, ou Wi-Fi et Ethernet actifs en même temps | Utilisez l'interface nommée dans la route par défaut (`ip route show default`, `route -n get default`, `Get-NetRoute`) |
| Votre adresse commence par `169.254.` et il n'y a pas de passerelle | Aucun serveur DHCP n'a répondu (repli de la RFC 3927) | Vérifiez le câble ou la connexion Wi-Fi, puis renouvelez le bail (par exemple, reconnectez-vous au réseau). Ne définissez pas d'adresse statique pour « réparer » |
| `ipconfig getpacket en0` n'affiche rien sous macOS | L'interface n'est pas `en0`, ou elle n'a pas été configurée par DHCP | Utilisez l'interface indiquée par `route -n get default` |
| `AddressValueError` ou `NetmaskValueError` dans un script | Faute de frappe, adresse IPv6 ou préfixe manquant | Passez une adresse IPv4 comme `192.168.1.23/24` ; les scripts ne gèrent que l'IPv4 |

## Défi (facultatif)
1. Trouvez l'adresse externe (réseau étendu, WAN, wide area network) de votre routeur dans sa page d'administration. Passez-la à `classify.py`. Si elle est dans `100.64.0.0/10`, votre FAI utilise du Carrier-Grade NAT : qu'est-ce que cela signifie pour héberger un service chez vous ?
2. Étendez `classify.py` pour qu'il accepte aussi les adresses IPv6 (`ipaddress.ip_address()` renvoie l'un ou l'autre type) et classez `::1`, `fe80::1` et `2001:db8::1`. Comparez ce que vous trouvez avec le [module 07](../07-ipv6/README.fr.md).
3. Exécutez `python3 ipcalc.py 192.0.2.130/<n>` pour chaque préfixe de `/24` à `/30`. Notez comment les adresses réseau et de broadcast se déplacent. Vous réutiliserez ce schéma dans le [module 06](../06-subnetting/README.fr.md).

## Nettoyage
Le lab n'a créé que le dossier `ip-lab` et ses deux scripts. Supprimez-les.

Linux et macOS :

```bash
cd ~ && rm -r ~/ip-lab
```

Windows (PowerShell) :

```powershell
Set-Location $HOME; Remove-Item -Recurse -Force "$HOME\ip-lab"
```

Aucun paramètre réseau n'a été modifié, il n'y a donc rien d'autre à annuler.

## Ce que vous avez appris
- Tout hôte a besoin d'une adresse, d'un préfixe (ou masque), d'une passerelle par défaut et de serveurs du système de noms de domaine (DNS, Domain Name System), et vous pouvez tous les lire avec des commandes intégrées à n'importe quel système d'exploitation.
- Une adresse DHCP affiche un bail et un serveur DHCP ; une adresse statique n'affiche ni l'un ni l'autre.
- Le réseau, le broadcast et la plage d'hôtes découlent directement du préfixe, et le module `ipaddress` de Python est un moyen fiable de vérifier votre arithmétique.
- « Privé » a deux sens : les blocs RFC 1918, et le « non joignable globalement » plus large de Python. Sachez lequel votre outil utilise.
- Votre passerelle doit toujours se trouver dans votre propre réseau.