Subnetting FLSM e VLSM – metodo binario e metodo matematico

Obiettivo didattico: capire quando usare FLSM (sottoreti tutte uguali) e quando usare VLSM (sottoreti di dimensione diversa), sapendo calcolare correttamente prefisso/mask, network, broadcast, gateway e range host con due metodi: binario e matematico.

Concetti base: IP, prefisso, maschera e range

Indirizzo IPv4 = 32 bit (4 ottetti).
Prefisso /n: i primi n bit sono di rete, i restanti sono di host.
Maschera: 1 nei bit di rete, 0 nei bit di host (es. /24 = 255.255.255.0).

In una subnet IPv4 standard:
Network = tutti i bit host a 0
Broadcast = tutti i bit host a 1
Host utilizzabili = da network+1 a broadcast-1
Numero host = 2^(bit host) - 2

Attenzione: in laboratorio di solito scegliamo il gateway come primo host (network+1) oppure ultimo host (broadcast-1), ma è una scelta progettuale: l’importante è che sia coerente e documentata.

Notazione binaria (utile per capire davvero)

/26 = 255.255.255.192
11111111.11111111.11111111.11000000
                          ^^^^^^
                       bit host = 6

Notazione “matematica” (rapida)

Se hai /26 allora i bit host sono 32-26 = 6.
Host per subnet = 2^6 - 2 = 62 host utilizzabili.

Costruire la subnet mask dal CIDR (metodo q e r)
Un ottetto ha 8 bit (ecco perché compare sempre l’8).
q = CIDR // 8 → ottetti “pieni” a 255
r = CIDR % 8 → bit a 1 nel prossimo ottetto
Ottetto parziale = 256 − 2^(8 − r) (se r=0 non c’è ottetto parziale)
Restanti ottetti = 0

Esempio: /26 → q=3, r=2 → 255.255.255.(256−2^6)=255.255.255.192

Termini che useremo sempre

Block size / passo / salto: quanto “avanza” una subnet nel suo ottetto significativo.
Ottetto significativo: il primo ottetto in cui la maschera non è 255 (o non è 0), cioè dove avvengono i salti.
Allineamento: una subnet inizia solo su un multiplo del suo block size (nell’ottetto significativo).

FLSM: subnet tutte uguali

FLSM (Fixed Length Subnet Mask) = tutte le sottoreti hanno la stessa maschera e quindi la stessa dimensione (stesso numero di host).

Metodo A (FLSM) — parto dal numero di sottoreti (S)

Idea: “prendo” bit dagli host per creare più sottoreti uguali.

Rete base: IP / P (P = prefisso iniziale).
Numero sottoreti richieste: S.
Trova k tale che 2^k ≥ S (k = bit di subnet).
Nuovo prefisso: P' = P + k.
Bit host per subnet: h = 32 − P' → host utili: 2^h − 2.
Calcola block size nell’ottetto significativo e elenca network/broadcast/range.

Anche se S non è potenza di 2, il calcolo ti obbliga a “salire” alla potenza di 2 successiva (perché i bit sono discreti).

Metodo B (FLSM) — parto dagli host per sottorete (H)

Idea: prima garantisco gli host, poi vedo quante sottoreti posso ottenere dentro la rete base.

Rete base: IP / P (P = prefisso iniziale).
Host richiesti per sottorete: H.
Trova h tale che 2^h − 2 ≥ H (h = bit host necessari).
Nuovo prefisso: P' = 32 − h.
Bit disponibili totali nella rete base: B = 32 − P.
Bit “rimanenti” per le sottoreti: k = B − h.
Sottoreti realizzabili (anche se non le usi tutte): 2^k.
Calcola block size e ricava network/broadcast/range come sempre.

Nota: qui il numero di sottoreti è una conseguenza dei bit rimasti dopo aver soddisfatto gli host.

Esempio FLSM (metodo A): da 192.168.10.0/24 a 4 sottoreti uguali

Rete base: 192.168.10.0/24
Subnet richieste: 4 → serve k con 2^k ≥ 4 → k = 2
Nuovo prefisso: /24 + 2 = /26
Bit host: 32-26 = 6 → host utilizzabili: 2^6 - 2 = 62

/26 significa che nell’ultimo ottetto la maschera è 192, quindi il block size è 256 - 192 = 64.
Le subnet partono da 0 e poi 64, 128, 192.

Subnet /26 dentro un /24 (ultimo ottetto)

Subnet 1: 192.168.10.0
Subnet 2: 192.168.10.64
Subnet 3: 192.168.10.128
Subnet 4: 192.168.10.192

Subnet	Network (/26)	Broadcast	Host min	Host max
1	192.168.10.0	192.168.10.63	192.168.10.1	192.168.10.62
2	192.168.10.64	192.168.10.127	192.168.10.65	192.168.10.126
3	192.168.10.128	192.168.10.191	192.168.10.129	192.168.10.190
4	192.168.10.192	192.168.10.255	192.168.10.193	192.168.10.254

Checklist anti-errore: ogni subnet inizia a 0/64/128/192 (multipli di 64). Se trovi “network = 192.168.10.70/26” è sbagliato: 70 non è un multiplo del block size.

Esempio FLSM (metodo B): da 192.168.10.0/24 con almeno 30 host per subnet

Rete base: 192.168.10.0/24 → P = 24 → B = 32−24 = 8 bit “disponibili”.
Richiesta: H = 30 host per subnet.
Trovo h: 2^h − 2 ≥ 30 → h=5 (32−2=30) → nuovo prefisso P' = 32−5 = /27.
Bit rimanenti per le sottoreti: k = B − h = 8 − 5 = 3 → sottoreti realizzabili: 2^3 = 8.

/27 → maschera ultimo ottetto 224 → block size = 256 − 224 = 32 (salti: 0,32,64,96,...).

Subnet /27 dentro un /24 (ultimo ottetto)

1: 192.168.10.0
2: 192.168.10.32
3: 192.168.10.64
4: 192.168.10.96
5: 192.168.10.128
... (fino a 224)

Subnet	Network (/27)	Broadcast	Host min	Host max	Host utili
1	192.168.10.0	192.168.10.31	192.168.10.1	192.168.10.30	30
2	192.168.10.32	192.168.10.63	192.168.10.33	192.168.10.62	30
3	192.168.10.64	192.168.10.95	192.168.10.65	192.168.10.94	30
4	192.168.10.96	192.168.10.127	192.168.10.97	192.168.10.126	30
5	192.168.10.128	192.168.10.159	192.168.10.129	192.168.10.158	30

Messaggio chiave: soddisfatti gli host (h), i bit rimasti (k) determinano quante subnet potresti creare nella rete base, anche se poi in pratica ne usi solo una parte.

VLSM: subnet di dimensioni diverse

VLSM (Variable Length Subnet Mask) = nello stesso indirizzamento “padre” usi prefissi diversi per reti con numeri di host diversi (LAN grandi, LAN piccole, link punto-punto…).

Regola d’oro del VLSM

Si assegna prima la subnet più grande, poi a scalare le più piccole.
Motivo: la subnet grande ha bisogno di blocchi “larghi”; se la metti dopo rischi di non avere più spazio contiguo allineato.

Procedura pratica

Ordina le reti per host richiesti: dalla più grande alla più piccola.
Per ogni rete: trova h con 2^h - 2 ≥ host richiesti → prefisso = 32 - h.
Assegna il primo blocco disponibile allineato (multiplo del block size).
Passa al blocco successivo e ripeti.
Per link router-router spesso basta un /30 (2 host) oppure /31 dove consentito.

Esempio VLSM completo: rete 192.168.50.0/24 con 3 LAN + 1 link P2P

Richieste:

LAN A: 100 host
LAN B: 50 host
LAN C: 20 host
Link Router-Router: 2 host (punto-punto)

Calcolo prefissi (metodo matematico)

LAN A: serve 2^h - 2 ≥ 100 → h=7 (128-2=126) → /25
LAN B: 2^h - 2 ≥ 50 → h=6 (64-2=62) → /26
LAN C: 2^h - 2 ≥ 20 → h=5 (32-2=30) → /27
P2P: 2^h - 2 ≥ 2 → h=2 (4-2=2) → /30

Block size nell’ultimo ottetto:
/25 → 256-128 = 128
/26 → 256-192 = 64
/27 → 256-224 = 32
/30 → 256-252 = 4

Assegnazione blocchi (dalla rete più grande)

Rete padre: 192.168.50.0/24

LAN A  /25  -> 192.168.50.0   - 192.168.50.127
LAN B  /26  -> 192.168.50.128 - 192.168.50.191
LAN C  /27  -> 192.168.50.192 - 192.168.50.223
P2P    /30  -> 192.168.50.224 - 192.168.50.227

Rete	Prefisso	Network	Broadcast	Host min	Host max	Gateway consigliato
LAN A	/25	192.168.50.0	192.168.50.127	192.168.50.1	192.168.50.126	192.168.50.1
LAN B	/26	192.168.50.128	192.168.50.191	192.168.50.129	192.168.50.190	192.168.50.129
LAN C	/27	192.168.50.192	192.168.50.223	192.168.50.193	192.168.50.222	192.168.50.193
Link P2P	/30	192.168.50.224	192.168.50.227	192.168.50.225	192.168.50.226	R1=225, R2=226

Metodo binario vs metodo matematico: quando usare cosa

Metodo matematico (passo/blocco)
È il più rapido in verifica e in laboratorio.

Trovi prefisso da host o subnet (potenze di 2).
Trovi block size: 256 - valore maschera nell’ottetto significativo.
Allinei network ai multipli del block size.

Metodo binario
È quello “di comprensione”: spiega perché funziona tutto il resto.

Vedi i bit di rete/subnet/host.
Capisci network = host a 0 e broadcast = host a 1.
Capisci subito perché certi indirizzi non possono essere network.

Esempio binario ultra-chiaro (ultimo ottetto)

/26 -> maschera ultimo ottetto = 192
11000000

Quindi i primi 2 bit dell'ultimo ottetto sono "di rete" (aggiunti al /24)
e gli ultimi 6 sono host:

xxhhhhhh

Subnet possibili (xx):
00 -> 0
01 -> 64
10 -> 128
11 -> 192

Per ciascuna subnet:
- network: xx000000
- broadcast: xx111111

Regola rapida per il controllo: se hai /n, allora l’indirizzo di rete deve avere a 0 i bit host. Se in binario trovi un 1 dentro la parte host, non è un network.

Riepilogo rapido

FLSM: tutte le subnet uguali → stesso prefisso per tutte (puoi partire da S oppure da H).
Metodo “da host” (FLSM): calcoli prima h per soddisfare H, poi i bit rimasti k ti dicono quante subnet puoi ottenere nella rete base.
VLSM: subnet diverse → assegna prima la rete più grande, poi a scalare.
Host utilizzabili: 2^(bit host) - 2 (in IPv4 standard).
Network = host a 0, Broadcast = host a 1.
Subnet mask: puoi costruirla con i bit “alti” oppure con q=CIDR//8, r=CIDR%8 e ottetto=256−2^(8−r).
Metodo matematico: prefisso + block size (256 - maschera nell’ottetto significativo).
Metodo binario: capisci l’allineamento e perché i salti sono potenze di 2.

Subnetting: FLSM e VLSM

Metodo binario e metodo matematico (passo/blocco)