reseau

Calculs réseau — Subnetting et adressage IP

Mémo complet des règles, formules et exemples de calculs réseau pour le jury TSSR

  • IP
  • Subnetting
  • CIDR
  • Masque
  • Réseau

Calculs réseau — Subnetting et adressage IP

C’est quoi ?

Une adresse IP permet d’identifier de manière unique chaque machine sur un réseau. Le subnetting (ou découpage en sous-réseaux) consiste à diviser un réseau en plusieurs sous-réseaux plus petits, pour mieux organiser le trafic, isoler des groupes de machines, et optimiser l’utilisation des adresses IP disponibles.

En entreprise, le subnetting est indispensable pour :

  • Séparer les services (RH, Comptabilité, Informatique…)
  • Limiter les domaines de broadcast
  • Sécuriser les communications entre départements

La structure d’une adresse IP

Une adresse IPv4 est composée de 32 bits, organisés en 4 octets séparés par des points.

Exemple : 192 . 168 . 10 . 1
           |       |    |    |
         Octet1  Oct2  Oct3  Oct4

Chaque octet peut valoir entre 0 et 255.

Table des valeurs de bits (à connaître par cœur !)

Bit76543210
Valeur1286432168421
Exemple : 11000000 = 128 + 64 = 192
          10101000 = 128 + 32 + 8 = 168

Partie réseau / partie hôte

L’adresse IP est divisée en deux parties :

  • Partie réseau : identifie le réseau (déterminée par le masque)
  • Partie hôte : identifie la machine dans ce réseau
Adresse  : 192.168.10.25  /24
Réseau   : 192.168.10     (les 24 premiers bits)
Hôte     : 25             (les 8 derniers bits)

Les classes d’adresses

ClassePlage de débutMasque par défautUsage
A1.0.0.0 → 126.255.255.255/8 (255.0.0.0)Très grands réseaux
B128.0.0.0 → 191.255.255.255/16 (255.255.0.0)Réseaux moyens
C192.0.0.0 → 223.255.255.255/24 (255.255.255.0)Petits réseaux
D224.0.0.0 → 239.255.255.255—Multicast
E240.0.0.0 → 255.255.255.255—Réservé / Expérimental

Adresses privées (RFC 1918) — non routables sur Internet

ClassePlage privée
A10.0.0.0 → 10.255.255.255
B172.16.0.0 → 172.31.255.255
C192.168.0.0 → 192.168.255.255

Le masque de sous-réseau

Le masque indique quelle partie de l’adresse IP correspond au réseau et quelle partie correspond à l’hôte.

Masque /24 en binaire :
11111111.11111111.11111111.00000000
= 255.255.255.0

Les 1 = partie réseau
Les 0 = partie hôte

Tableau complet /8 à /30

CIDRMasque décimalNb hôtes maxSaut
/8255.0.0.016 777 2141 (oct 2)
/9255.128.0.08 388 606128 (oct 2)
/10255.192.0.04 194 30264 (oct 2)
/11255.224.0.02 097 15032 (oct 2)
/12255.240.0.01 048 57416 (oct 2)
/13255.248.0.0524 2868 (oct 2)
/14255.252.0.0262 1424 (oct 2)
/15255.254.0.0131 0702 (oct 2)
/16255.255.0.065 5341 (oct 3)
/17255.255.128.032 766128 (oct 3)
/18255.255.192.016 38264 (oct 3)
/19255.255.224.08 19032 (oct 3)
/20255.255.240.04 09416 (oct 3)
/21255.255.248.02 0468 (oct 3)
/22255.255.252.01 0224 (oct 3)
/23255.255.254.05102 (oct 3)
/24255.255.255.02541 (oct 4)
/25255.255.255.128126128 (oct 4)
/26255.255.255.1926264 (oct 4)
/27255.255.255.2243032 (oct 4)
/28255.255.255.2401416 (oct 4)
/29255.255.255.24868 (oct 4)
/30255.255.255.25224 (oct 4)

Quel octet est concerné par le saut ?

/8  → /15  : saut sur le 2ème octet  → masque 255.X.0.0
/16 → /23  : saut sur le 3ème octet  → masque 255.255.X.0
/24 → /31  : saut sur le 4ème octet  → masque 255.255.255.X

Les formules essentielles

1. Nombre d’hôtes adressables

Hôtes = 2^n - 2

n = nombre de bits hôtes = 32 - CIDR

Le -2 s’explique ainsi :

  • -1 pour l’adresse réseau (première adresse, non assignable)
  • -1 pour l’adresse broadcast (dernière adresse, non assignable)
Exemple : /24
n = 32 - 24 = 8 bits hôtes
Hôtes = 2^8 - 2 = 256 - 2 = 254 hôtes

2. Nombre de sous-réseaux

Sous-réseaux = 2^n

n = nombre de bits empruntés à la partie hôte
Exemple : /24 découpé en /27
Bits empruntés = 27 - 24 = 3
Sous-réseaux = 2^3 = 8 sous-réseaux

3. Adresse réseau

Adresse réseau = IP "arrondie vers le bas" selon le saut

Octets AVANT l'octet concerné → identiques à l'IP
Octet CONCERNÉ                → résultat du calcul (octet ÷ saut, partie entière × saut)
Octets APRÈS l'octet concerné → toujours 0

4. Adresse broadcast

Broadcast = adresse réseau + saut - 1 (sur l'octet concerné)

Octets AVANT l'octet concerné → identiques à l'IP
Octet CONCERNÉ                → adresse réseau (octet) + saut - 1
Octets APRÈS l'octet concerné → toujours 255

5. Première et dernière adresse hôte

1ère IP adressable = adresse réseau + 1 (sur le dernier octet)
Dernière IP        = broadcast - 1     (sur le dernier octet)

Méthode de calcul pas à pas

Type FLSM — Découper un réseau en N sous-réseaux

Phrase mnémotechnique : “Je Borne Mon Saut au Tableau”

Étape 1 — Identifier : réseau de départ + nombre de SR voulus
Étape 2 — Borner    : 2^n ≥ nombre SR → toujours la puissance AU-DESSUS
Étape 3 — Masque    : nouveau CIDR = ancien + n → convertir en décimal
Étape 4 — Saut      : 256 - valeur de l'octet du masque qui change
Étape 5 — Tableau   : remplir réseau / 1ère IP / dernière IP / broadcast

Exemple complet : 10.1.0.0/16 — 60 sous-réseaux

Étape 1 : réseau = 10.1.0.0/16, SR voulus = 60

Étape 2 : 2^5 = 32 < 60 ❌
          2^6 = 64 ≥ 60 ✅ → on emprunte 6 bits

Étape 3 : /16 + 6 = /22
          3ème octet : 128+64+32+16+8+4 = 252
          Masque = 255.255.252.0

Étape 4 : saut = 256 - 252 = 4 (sur le 3ème octet)

Étape 5 :
SR 1  → 10.1.0.0    | 10.1.0.1   | 10.1.3.254  | 10.1.3.255
SR 2  → 10.1.4.0    | 10.1.4.1   | 10.1.7.254  | 10.1.7.255
SR 60 → 10.1.236.0  | 10.1.236.1 | 10.1.239.254| 10.1.239.255

Formule SR n° direct : saut × (n-1) sur l'octet concerné
SR 60 = 4 × (60-1) = 4 × 59 = 236 → 10.1.236.0

Type A — Trouver le sous-réseau d’une IP

Étape 1 : masque → saut → octet concerné
Étape 2 : octet IP ÷ saut → partie entière × saut = adresse réseau
Étape 3 : broadcast = réseau + saut - 1 sur l'octet concerné

Exemple : 192.168.37.14/27

Étape 1 : /27 → 255.255.255.224 → saut = 32 → 4ème octet

Étape 2 : 14 ÷ 32 = 0.43 → partie entière = 0
          0 × 32 = 0
          Réseau = 192.168.37.0

Étape 3 : broadcast = 192.168.37.0 + 32 - 1 = 192.168.37.31

Résultat :
Réseau      = 192.168.37.0
1ère IP     = 192.168.37.1
Dernière IP = 192.168.37.30
Broadcast   = 192.168.37.31

Type B — Combien d’hôtes dans un réseau ?

Étape 1 : bits hôtes = 32 - CIDR
Étape 2 : hôtes = 2^(bits hôtes) - 2

Exemple : /22

Bits hôtes = 32 - 22 = 10
Hôtes = 2^10 - 2 = 1024 - 2 = 1022 hôtes

Type C — Quel masque pour X hôtes ?

Étape 1 : trouver n tel que 2^n - 2 ≥ hôtes voulus (puissance AU-DESSUS)
Étape 2 : CIDR = 32 - n
Étape 3 : convertir en décimal

Exemple : 200 hôtes

2^7 - 2 = 126 ❌ (126 < 200)
2^8 - 2 = 254 ✅ (254 ≥ 200) → n = 8

CIDR = 32 - 8 = /24
Masque = 255.255.255.0

Exercices résolus

Exercice 1 — 172.16.0.0/16 avec 14 sous-réseaux

Étape 1 : 2^3 = 8 < 14 ❌ | 2^4 = 16 ≥ 14 ✅ → 4 bits

Étape 2 : /16 + 4 = /20
          3ème octet : 128+64+32+16 = 240
          Masque = 255.255.240.0

Étape 3 : saut = 256 - 240 = 16 (sur le 3ème octet)

Étape 4 : hôtes = 32 - 20 = 12 bits → 2^12 - 2 = 4094 hôtes/SR

Tableau :
SR 1  : 172.16.0.0   | 172.16.0.1   | 172.16.15.254  | 172.16.15.255
SR 2  : 172.16.16.0  | 172.16.16.1  | 172.16.31.254  | 172.16.31.255
SR 14 : 172.16.208.0 | 172.16.208.1 | 172.16.223.254 | 172.16.223.255

SR 14 → 16 × (14-1) = 16 × 13 = 208 → 172.16.208.0

Exercice 2 — 192.168.50.0/24 avec 10 sous-réseaux

Étape 1 : 2^3 = 8 < 10 ❌ | 2^4 = 16 ≥ 10 ✅ → 4 bits

Étape 2 : /24 + 4 = /28
          4ème octet : 128+64+32+16 = 240
          Masque = 255.255.255.240

Étape 3 : saut = 256 - 240 = 16 (sur le 4ème octet)
          ⚠️ Ne pas confondre saut (16) et hôtes (14) !

Étape 4 : hôtes = 32 - 28 = 4 bits → 2^4 - 2 = 14 hôtes/SR

Tableau :
SR 1  : 192.168.50.0   | 192.168.50.1   | 192.168.50.14  | 192.168.50.15
SR 2  : 192.168.50.16  | 192.168.50.17  | 192.168.50.30  | 192.168.50.31
SR 10 : 192.168.50.144 | 192.168.50.145 | 192.168.50.158 | 192.168.50.159

SR 10 → 16 × (10-1) = 16 × 9 = 144 → 192.168.50.144

Exercice 3 — Type A : 10.10.75.200/21

Étape 1 : /21 → 255.255.248.0 → saut = 8 → 3ème octet

Étape 2 : 75 ÷ 8 = 9.37 → partie entière = 9
          9 × 8 = 72
          Réseau = 10.10.72.0

Étape 3 : broadcast = 10.10.72.0 + 8 - 1 (sur 3ème octet) = 10.10.79.255

Résultat :
Réseau      = 10.10.72.0
1ère IP     = 10.10.72.1
Dernière IP = 10.10.79.254
Broadcast   = 10.10.79.255

Tableau mental :
           1er  | 2ème | 3ème | 4ème
IP         10   |  10  |  75  | 200
Réseau     10   |  10  |  72  |   0   ← octet concerné arrondi, suite = 0
Broadcast  10   |  10  |  79  | 255   ← réseau+saut-1, suite = 255
1ère IP    10   |  10  |  72  |   1
Dernière   10   |  10  |  79  | 254

Le subnetting VLSM

Le VLSM (Variable Length Subnet Mask) permet d’attribuer des masques de tailles différentes à chaque sous-réseau selon ses besoins réels.

Exemple : réseau 192.168.1.0/24 à découper pour :
- Service A : 50 hôtes  → /26 (62 hôtes max)  → 192.168.1.0/26
- Service B : 20 hôtes  → /27 (30 hôtes max)  → 192.168.1.64/27
- Service C : 10 hôtes  → /28 (14 hôtes max)  → 192.168.1.96/28
- Lien WAN  : 2 hôtes   → /30 (2 hôtes max)   → 192.168.1.112/30

Principe VLSM : toujours commencer par le plus grand besoin en hôtes !

Tableau récapitulatif des puissances de 2

n2^n
01
12
24
38
416
532
664
7128
8256
9512
101 024
112 048
124 096
138 192
1416 384
1532 768
1665 536
17131 072
18262 144
19524 288
201 048 576
2416 777 216
324 294 967 296

⚠️ Les pièges classiques

Piège 1 — Prendre la puissance en dessous

❌ Tu veux 12 SR → 2^3 = 8 → pas assez !
✅ Tu veux 12 SR → 2^4 = 16 → suffisant
Toujours prendre la puissance AU-DESSUS ou ÉGALE.

Piège 2 — Confondre adresse réseau et 1ère IP

❌ 1ère IP = 192.168.1.0
✅ 1ère IP = 192.168.1.1  (réseau + 1)
L'adresse réseau n'est JAMAIS adressable.

Piège 3 — Confondre broadcast et adresse réseau suivante

❌ Broadcast = 192.168.1.32  (c'est l'adresse du SR suivant !)
✅ Broadcast = 192.168.1.31  (réseau suivant - 1)
Le broadcast est la DERNIÈRE adresse du bloc actuel.

Piège 4 — Confondre saut et nombre d’hôtes

/28 : saut = 256 - 240 = 16
/28 : hôtes = 2^4 - 2 = 14
Le saut est TOUJOURS égal aux hôtes + 2.

Piège 5 — Garder le dernier octet de l’IP dans l’adresse réseau (Type A)

❌ IP 10.10.75.200/21 → réseau = 10.10.72.200
✅ IP 10.10.75.200/21 → réseau = 10.10.72.0
Après l'octet concerné → toujours 0 pour le réseau, 255 pour le broadcast.

Piège 6 — Oublier le -2 dans le calcul des hôtes (Type C)

❌ Tu veux 126 hôtes → 2^7 = 128 → /25 ← FAUX !
✅ Tu veux 126 hôtes → 2^7 - 2 = 126 → /25 ← JUSTE (exactement suffisant)
Toujours calculer 2^n - 2 AVANT de comparer.

🎯 Ce que le jury TSSR peut demander

Question type 1 — Découpage FLSM

“Vous disposez du réseau 10.1.0.0/16 et devez créer 60 sous-réseaux. Donnez les 2 premiers et le dernier sous-réseau avec leur plage d’adresses et broadcast.” → Appliquer la méthode en 5 étapes. Montrer le calcul 2^n ≥ 60.

Question type 2 — Appartenance (Type A)

“À quel sous-réseau appartient l’adresse 192.168.10.145/28 ?” → Calculer le saut, diviser l’octet concerné, arrondir vers le bas.

Question type 3 — Nombre d’hôtes (Type B)

“Combien d’hôtes peut-on adresser dans un réseau /22 ?” → 32 - 22 = 10 bits hôtes → 2^10 - 2 = 1022 hôtes.

Question type 4 — Quel masque pour X hôtes (Type C)

“Vous avez besoin de 500 hôtes par sous-réseau. Quel masque utilisez-vous ?” → 2^9 - 2 = 510 ≥ 500 → /23 → 255.255.254.0

Question type 5 — Tableau de ports

“Complétez le tableau avec les numéros de port TCP/UDP.”

ServiceTCPUDP
SSH22—
FTP20/21—
HTTP80—
HTTPS443—
DNS5353
DHCP—67/68
SNMP—161
NTP—123
LDAP389—
RDP3389—
TFTP—69
POP3110—
IMAP143—
SMTP25—
MYSQL3306—
ISAKMP—500

Ce que le jury valorise :

  • Montrer le raisonnement (pas juste la réponse)
  • Écrire le calcul 2^n explicitement
  • Justifier le choix de la puissance (AU-DESSUS ou ÉGALE)
  • Présenter un tableau propre et complet

Fiches liées

  • reseau/dns-comprehension
  • reseau/vlan-comprehension