CloudAcademia
IT

Reti · Modulo 05 · Indirizzamento IP: i fondamenti di IPv4

Laboratorio: ispezionare e classificare i tuoi indirizzi

Laboratorio45 minPrincipianteMarkdown

Viene mostrato il Markdown grezzo: non è stato possibile caricare il visualizzatore.

## Obiettivo
Leggi la configurazione IPv4 del tuo computer (indirizzo, prefisso, gateway e da dove arriva), verifichi i calcoli della lezione con il modulo `ipaddress` di Python e scrivi un piccolo script che classifica gli indirizzi in base allo scopo. Nulla sulla tua rete viene modificato.

## Obiettivi
- Trovare il tuo indirizzo IPv4, la lunghezza del prefisso, la subnet mask e il gateway predefinito su Linux, macOS o Windows.
- Capire se il tuo indirizzo è stato configurato staticamente o tramite il protocollo di configurazione dinamica degli host (DHCP, Dynamic Host Configuration Protocol).
- Calcolare indirizzo di rete, indirizzo di broadcast e intervallo di host utilizzabili, e confermarli con Python.
- Classificare gli indirizzi IPv4 come privati, pubblici, condivisi (traduzione degli indirizzi di rete a livello carrier, CGN, Carrier-Grade Network Address Translation), loopback, link-local, di documentazione, multicast o broadcast.
- Spiegare perché il flag `is_private` di Python è più ampio di "RFC 1918".

## Prerequisiti
- Un computer con Linux (con il comando `ip` di iproute2), macOS o Windows 10/11.
- Python 3.8 o successivo, solo libreria standard. Questo laboratorio è stato provato con Python 3.14.7 e 3.11.8. Controlla il tuo con `python3 --version` (su Windows: `py --version`).
- Un editor di testo.
- Nessun diritto di amministratore: tutti i comandi di questo laboratorio leggono soltanto la configurazione.
- [Lezione: indirizzamento IP](lesson.it.md) di questo modulo.

> [!WARNING]
> I tuoi indirizzi, il gateway e i dettagli del lease descrivono la tua rete. Non pubblicare l'output di questi comandi su forum pubblici o negli screenshot. Quando condividi i risultati, sostituisci i valori con indirizzi di documentazione (`192.0.2.0/24`, `198.51.100.0/24`, `203.0.113.0/24`).

## Architettura
<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-it-title ip-lab-architecture-it-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="it">
<title id="ip-lab-architecture-it-title">Architettura del lab: dove vive ogni indirizzo</title>
<desc id="ip-lab-architecture-it-desc">Il tuo computer ha un indirizzo privato come 192.168.1.23/24 sulla rete locale. Il router è il suo gateway predefinito a 192.168.1.1, assegna gli indirizzi con DHCP e li traduce con NAT. Sul lato pubblico si collega al tuo provider Internet con un indirizzo pubblico, o con un indirizzo di 100.64.0.0/10 se il provider usa il NAT di livello carrier (CGN), e da lì a 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">La tua LAN · indirizzi privati (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">Lato pubblico</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">Il tuo computer</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">Indirizzo privato</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">Il tuo router</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="161" height="26" rx="13" fill="#b45309"/><text x="398.5" y="169.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">Gateway predefinito</text></g>
<g class="dg-l7"><rect class="dg-solid" x="318" y="184" width="103" height="26" rx="13" fill="#6d28d9"/><text x="369.5" y="201.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">Server 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">Il tuo ISP</text>
<text x="558" y="148" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Provider Internet</text>
<text x="558" y="168" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Indirizzo pubblico</text>
<g class="dg-warn"><rect class="dg-tint" x="558" y="186" width="175" height="26" rx="13" fill="#f8e8e8" stroke="#e09999" stroke-width="1.2"/><text x="645.5" y="203.5" font-size="12" class="dg-ink" fill="#b91c1c" font-weight="700" text-anchor="middle">o 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>

*Figura 1. Dove vive ogni indirizzo. Tutto ciò che sta a sinistra è la tua rete privata; il router traduce tra questa e il lato pubblico. I valori d'esempio sono tipici di una rete domestica; i tuoi possono essere diversi.*

*Ispezioni solo il riquadro di sinistra. I valori mostrati sono esempi; i tuoi saranno diversi.*

## Passaggi

### Passo 1 — Crea una cartella di lavoro
Scriverai due piccoli script. Tienili in un'unica cartella, così la pulizia si riduce a un solo comando.

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

Nessun output significa successo (PowerShell stampa i dettagli della nuova cartella).

### Passo 2 — Trova il tuo indirizzo, il prefisso e il gateway
Questi sono i quattro valori di cui ogni host ha bisogno. Esegui i comandi per il tuo sistema operativo e compila la tabella alla fine di questo passo.

**Linux.** Mostra gli indirizzi IPv4 e poi la route predefinita:

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

Output atteso (i nomi delle interfacce e i valori del tuo sistema saranno diversi):

```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 riga `inet` riporta insieme indirizzo e prefisso (`192.168.1.23/24`). Ignora `lo`: è l'interfaccia di loopback. La riga `default via` riporta il gateway.

**macOS.** Trova l'interfaccia che porta la route predefinita, poi il suo indirizzo:

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

Output atteso (abbreviato; sostituisci `en0` con il valore di `interface` del primo comando):

```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 mostra la maschera in esadecimale: `0xffffff00` è `ff.ff.ff.00` = `255.255.255.0` = `/24`.

**Windows (PowerShell).**

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

Output atteso (abbreviato):

```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` è la route predefinita: "ogni destinazione non coperta da una route più specifica".

> [!NOTE]
> La formulazione esatta, la spaziatura delle colonne e i formati di data variano con la versione del sistema operativo e la lingua di visualizzazione. Se vedi più adattatori (Wi-Fi, Ethernet, VPN, adattatori di macchine virtuali), usa quello il cui gateway corrisponde alla route predefinita.

Annota i tuoi valori:

| Valore | Il tuo |
|---|---|
| Indirizzo IPv4 | `<address>` |
| Lunghezza del prefisso / maschera | `<prefix>` / `<mask>` |
| Gateway predefinito | `<gateway>` |
| Interfaccia | `<interface>` |

### Passo 3 — Scopri da dove arriva l'indirizzo
Un indirizzo DHCP ha un lease che scade; un indirizzo statico no. Sapere quale hai ti dice dove guardare quando qualcosa si rompe.

- **Linux:** la riga `inet` del passo 2 contiene `dynamic` e un `valid_lft` finito (per esempio `86077sec`) per un indirizzo DHCP. Un indirizzo statico mostra `valid_lft forever` e nessun `dynamic`. `proto dhcp` sulla route predefinita lo conferma.
- **Windows:** `DHCP Enabled. . . : Yes` più le righe `Lease Obtained` / `Lease Expires` e `DHCP Server`.
- **macOS:** stampa il lease DHCP dell'interfaccia:

  ```bash
  ipconfig getpacket en0
  ```

  Output atteso (abbreviato):

  ```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", il tuo indirizzo IP) è l'indirizzo che il server ti ha dato. `0x15180` è 86.400 secondi: un lease di 24 ore. Nessun output significa che l'interfaccia non è stata configurata dal DHCP.

Annota: statico o DHCP? Quale dispositivo è il server DHCP? Sulla maggior parte delle reti domestiche è lo stesso dispositivo del gateway.

### Passo 4 — Verifica il calcolo della lezione con Python
Avvia una sessione interattiva di Python con `python3` (Windows: `py`) e digita le righe dopo `>>>`. Confermerai l'esempio `192.0.2.130/26` della sezione Come funziona della lezione.

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

Output atteso, riga per riga:

```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 indirizzi, meno quello di rete e quello di broadcast, lasciano i 62 host utilizzabili della lezione. Ora controlla la risposta della verifica rapida e dai un'occhiata a 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')
```

Esci con `exit()`.

> [!TIP]
> `ipaddress.ip_network("192.0.2.130/26")` solleva `ValueError: 192.0.2.130/26 has host bits set`, perché una rete va scritta con il suo indirizzo di rete. Usa `ip_interface()` per "questo indirizzo su quella rete", oppure passa `strict=False`.

### Passo 5 — Scrivi un calcolatore di indirizzi
Uno script permette di ripetere il calcolo per qualsiasi indirizzo, compreso il tuo. Salva questo come `ipcalc.py` nella cartella `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).")
```

Eseguilo senza argomenti (l'esempio della lezione), poi con l'errore comune della `/20` della lezione:

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

Su Windows usa `py` al posto di `python3`. Output atteso:

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

Ora eseguilo sul tuo indirizzo del passo 2:

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

`<address>/<prefix>` è il tuo indirizzo IPv4 con la lunghezza del prefisso, per esempio `192.168.1.23/24`. Se hai solo una maschera in decimale puntato (Windows, macOS), Python accetta anche quella: `192.168.1.23/255.255.255.0`.

Verifica: il tuo gateway predefinito sta tra `First host` e `Last host`? Deve starci.

### Passo 6 — Classifica gli indirizzi in base allo scopo
Gli oggetti `ipaddress` di Python hanno flag come `is_private`, `is_global`, `is_loopback`, `is_link_local` e `is_multicast`. Questo script li confronta con una tabella esplicita dei blocchi per scopi speciali della lezione. Salvalo come `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}")
```

Eseguilo sui campioni integrati:

```bash
python3 classify.py
```

Output atteso:

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

Leggi la tabella con attenzione. Quattro risultati sorprendono la maggior parte delle persone:
- **`172.32.1.5` è pubblico.** Il blocco RFC 1918 `172.16.0.0/12` finisce a `172.31.255.255`.
- **`is_private` non è "RFC 1918".** Python segna un indirizzo come privato quando il registro IANA dice che *non è raggiungibile globalmente*. Questo include loopback, link-local, documentazione, `0.0.0.0` e broadcast. Per verificare specificamente la RFC 1918, controlla tu i tre blocchi, come fa `BLOCKS`.
- **`100.64.12.34` non è né privato né globale.** Python tratta lo spazio condiviso CGN (RFC 6598) come caso speciale: non è raggiungibile da Internet, ma non è nemmeno tuo da usare.
- **`224.0.0.251` è "globale".** `is_global` deriva dal registro degli scopi speciali, e il multicast non vi compare (ha un proprio registro). `is_global` non significa "indirizzo unicast pubblico che puoi pingare".

> [!NOTE]
> Python 3.12.4 e 3.13 hanno corretto le tabelle dietro `is_private` e `is_global` per farle coincidere con il registro IANA (CVE-2024-4032; la correzione è stata portata anche in rilasci di sicurezza di alcuni rami più vecchi). Per tutti gli indirizzi in `SAMPLES` l'output qui sopra è identico su Python 3.14.7 e su 3.11.8, che precede la correzione. I risultati differiscono per alcuni indirizzi dentro `192.0.0.0/24`: per esempio `192.0.0.100` è `global` su 3.11.8 e `private` su 3.14.7. Se ti affidi a questi flag nel codice reale, controlla la tua versione di Python.

### Passo 7 — Classifica i tuoi indirizzi
Passa come argomenti il tuo indirizzo e il gateway del passo 2:

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

Con i valori d'esempio (`192.168.1.23`, gateway `192.168.1.1`) l'output è:

```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 maggior parte dei computer domestici e da ufficio riceve un indirizzo privato e raggiunge Internet tramite la traduzione degli indirizzi di rete (NAT, Network Address Translation) del router. Se il tuo indirizzo è pubblico, la tua rete assegna direttamente indirizzi pubblici (alcune università e data center lo fanno). Se è link-local (`169.254.x.x`), il DHCP è fallito: vedi Risoluzione dei problemi.

## Verifica
Hai completato il laboratorio se puoi rispondere "sì" a ogni controllo:

| Controllo | Come confermarlo |
|---|---|
| Hai annotato indirizzo, prefisso, gateway e interfaccia | La tabella del passo 2 è compilata |
| Sai se il tuo indirizzo è statico o DHCP | Passo 3: `dynamic` / `DHCP Enabled: Yes` / output di `ipconfig getpacket` |
| Python concorda con la lezione | Il passo 4 stampa `192.0.2.128/26`, `192.0.2.191` e 64 indirizzi |
| Il tuo gateway è dentro la tua rete | `python3 ipcalc.py <address>/<prefix>` mostra il gateway tra `First host` e `Last host` |
| Sai spiegare `is_private` rispetto a RFC 1918 | `python3 classify.py` mostra `yes` sotto `private` per `192.0.2.130` anche se non è RFC 1918 |

## Risoluzione dei problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| `python3: command not found` (o su Windows si apre il Microsoft Store) | Python non è installato, o su Windows è installato come `py` | Usa `py` su Windows, oppure installa Python 3 da python.org o dal tuo gestore di pacchetti |
| `ip: command not found` su Linux | Sistema minimale senza iproute2 | Installa il pacchetto `iproute2`, oppure usa `hostname -I` solo per gli indirizzi |
| Vengono elencati più indirizzi e adattatori | Rete privata virtuale (VPN), Docker, macchina virtuale, o Wi-Fi ed Ethernet attivi insieme | Usa l'interfaccia indicata nella route predefinita (`ip route show default`, `route -n get default`, `Get-NetRoute`) |
| Il tuo indirizzo inizia con `169.254.` e non c'è gateway | Nessun server DHCP ha risposto (ripiego della RFC 3927) | Controlla il cavo o la connessione Wi-Fi, poi rinnova il lease (per esempio, riconnettiti alla rete). Non impostare un indirizzo statico per "risolvere" |
| `ipconfig getpacket en0` non stampa nulla su macOS | L'interfaccia non è `en0`, oppure non è stata configurata dal DHCP | Usa l'interfaccia indicata da `route -n get default` |
| `AddressValueError` o `NetmaskValueError` da uno script | Refuso, indirizzo IPv6 o prefisso mancante | Passa un indirizzo IPv4 come `192.168.1.23/24`; gli script gestiscono solo IPv4 |

## Sfida (facoltativa)
1. Trova l'indirizzo esterno (rete geografica, WAN, wide area network) del tuo router nella sua pagina di amministrazione. Passalo a `classify.py`. Se è in `100.64.0.0/10`, il tuo ISP usa il Carrier-Grade NAT: che cosa significa per ospitare un servizio a casa?
2. Estendi `classify.py` perché accetti anche indirizzi IPv6 (`ipaddress.ip_address()` restituisce l'uno o l'altro tipo) e classifica `::1`, `fe80::1` e `2001:db8::1`. Confronta ciò che trovi con il [modulo 07](../07-ipv6/README.it.md).
3. Esegui `python3 ipcalc.py 192.0.2.130/<n>` per ogni prefisso da `/24` a `/30`. Annota come si spostano gli indirizzi di rete e di broadcast. Userai questo schema nel [modulo 06](../06-subnetting/README.it.md).

## Pulizia
Il laboratorio ha creato solo la cartella `ip-lab` e i suoi due script. Rimuovili.

Linux e macOS:

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

Windows (PowerShell):

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

Nessuna impostazione di rete è stata modificata, quindi non c'è altro da annullare.

## Cosa hai imparato
- Ogni host ha bisogno di un indirizzo, un prefisso (o maschera), un gateway predefinito e server del sistema dei nomi di dominio (DNS, Domain Name System), e puoi leggerli tutti con comandi integrati in qualsiasi sistema operativo.
- Un indirizzo DHCP mostra un lease e un server DHCP; uno statico non mostra né l'uno né l'altro.
- Rete, broadcast e intervallo di host derivano direttamente dal prefisso, e il modulo `ipaddress` di Python è un modo affidabile per controllare i tuoi calcoli.
- "Privato" ha due significati: i blocchi RFC 1918 e il più ampio "non raggiungibile globalmente" di Python. Sappi quale usa il tuo strumento.
- Il tuo gateway deve sempre trovarsi dentro la tua rete.