Aller au contenu

Calcul d'adresses IP et découpage en sous-réseaux

À la fin, tu sauras :

  • convertir une adresse IP du décimal au binaire et inversement ;
  • lire un masque en notation décimale (255.255.255.192) et CIDR (/26) ;
  • calculer l’adresse réseau, le broadcast, la plage utilisable et le nombre d’hôtes ;
  • utiliser la méthode rapide du nombre magique ;
  • découper un réseau en sous-réseaux de taille égale ;
  • construire un plan d’adressage VLSM adapté à des besoins différents.
Prérequis Cours 1.1 et 1.2. Les rappels nécessaires sur l’adresse IPv4 sont inclus ci-dessous.
Durée Environ 3 h (théorie 1 h 30, simulateur et exercices 1 h, lab 30 min)
Matériel Papier et crayon (vraiment !), Packet Tracer

Une adresse IPv4 est un nombre de 32 bits. Pour la rendre lisible, on la découpe en 4 octets (4 × 8 bits), écrits en décimal et séparés par des points :

192 . 168 . 1 . 42 ← notation décimale pointée
11000000 . 10101000 . 00000001 . 00101010 ← la même adresse en binaire

Chaque octet va de 0 (00000000) à 255 (11111111).

Une adresse IP se divise toujours en deux parties :

Partie Rôle Analogie
Partie réseau Identifie le réseau auquel appartient la machine Le nom de la rue
Partie hôte Identifie la machine dans ce réseau Le numéro de la maison

C’est le masque qui indique où s’arrête la partie réseau et où commence la partie hôte.


Chaque bit d’un octet a un poids, une puissance de 2 :

Bit 1ᵉʳ 2ᵉ 3ᵉ 4ᵉ 5ᵉ 6ᵉ 7ᵉ 8ᵉ
Poids 128 64 32 16 8 4 2 1

On additionne les poids des bits à 1 :

0 0 1 0 1 0 1 0
128 64 32 16 8 4 2 1
32 + 8 + 2 = 42

On parcourt les poids de gauche à droite. Si le poids tient dans ce qui reste, on écrit 1 et on le soustrait. Sinon, on écrit 0.

Exemple : 172 en binaire

Poids 128 64 32 16 8 4 2 1
Reste avant 172 44 44 12 12 4 0 0
Ça tient ? oui non oui non oui oui non non
Bit 1 0 1 0 1 1 0 0

Résultat : 172 = 10101100. Vérification : 128 + 32 + 8 + 4 = 172 ✅


Le masque est aussi un nombre de 32 bits, avec une règle stricte : des 1 à gauche, puis des 0 à droite, sans trou.

  • Les bits à 1 marquent la partie réseau.
  • Les bits à 0 marquent la partie hôte.
Notation décimale Binaire Notation CIDR
255.0.0.0 11111111.00000000.00000000.00000000 /8
255.255.0.0 11111111.11111111.00000000.00000000 /16
255.255.255.0 11111111.11111111.11111111.00000000 /24
255.255.255.192 11111111.11111111.11111111.11000000 /26

La notation CIDR (/26) donne simplement le nombre de bits à 1 du masque. C’est la plus utilisée aujourd’hui, car elle est plus courte.

Les seules valeurs possibles pour un octet de masque

Section intitulée « Les seules valeurs possibles pour un octet de masque »

Comme les 1 sont toujours collés à gauche, un octet de masque ne peut prendre que 9 valeurs :

Bits à 1 dans l’octet 0 1 2 3 4 5 6 7 8
Valeur 0 128 192 224 240 248 252 254 255

Dans chaque réseau, deux adresses sont réservées :

Adresse Partie hôte Rôle
Adresse réseau Tous les bits hôte à 0 Elle désigne le réseau lui-même (utilisée dans les tables de routage). Elle ne s’attribue pas à une machine.
Adresse de broadcast Tous les bits hôte à 1 Un message envoyé à cette adresse est reçu par toutes les machines du réseau. Elle ne s’attribue pas à une machine.
Plage utilisable Tout ce qui est entre les deux Les adresses que tu peux donner aux PC, serveurs, imprimantes, à l’interface du routeur…

Exemple : 192.168.1.42/26

Étape 1 : convertir l’IP et le masque en binaire. Le /26 donne 26 bits à 1.

IP : 11000000.10101000.00000001.00101010 (192.168.1.42)
Masque : 11111111.11111111.11111111.11000000 (255.255.255.192)
↑↑
les 26 premiers bits = partie réseau

Étape 2 : l’adresse réseau, avec un ET logique (AND). On compare bit à bit : 1 ET 1 = 1, toutes les autres combinaisons donnent 0. Concrètement, on recopie la partie réseau de l’IP et on met la partie hôte à 0.

IP : 11000000.10101000.00000001.00101010
Masque : 11111111.11111111.11111111.11000000
─────────────────────────────────── ET
Réseau : 11000000.10101000.00000001.00000000 → 192.168.1.0

Étape 3 : le broadcast. On garde la partie réseau et on met tous les bits hôte à 1 :

Broadcast : 11000000.10101000.00000001.00111111 → 192.168.1.63

Étape 4 : la plage utilisable. Elle va de l’adresse réseau + 1 au broadcast − 1 :

Élément Valeur
Adresse réseau 192.168.1.0
Première utilisable 192.168.1.1
Dernière utilisable 192.168.1.62
Broadcast 192.168.1.63

Avec h bits d’hôte :

Nombre total d'adresses = 2^h
Nombre d'hôtes utilisables = 2^h − 2 (on retire le réseau et le broadcast)

Pour notre /26 : h = 32 − 26 = 6, donc 2⁶ = 64 adresses et 62 hôtes.

CIDR Masque Bits hôte Adresses Hôtes utilisables Usage typique
/24 255.255.255.0 8 256 254 Réseau local classique
/25 255.255.255.128 7 128 126
/26 255.255.255.192 6 64 62
/27 255.255.255.224 5 32 30
/28 255.255.255.240 4 16 14 Petit réseau (DMZ, serveurs)
/29 255.255.255.248 3 8 6
/30 255.255.255.252 2 4 2 Liaison entre deux routeurs
/23 255.255.254.0 9 512 510
/22 255.255.252.0 10 1 024 1 022
/16 255.255.0.0 16 65 536 65 534

Le binaire est indispensable pour comprendre. Mais pour aller vite (examen, dépannage), les pros utilisent la méthode du nombre magique.

La méthode en 3 étapes :

  1. Trouver l’octet intéressant : celui où le masque n’est ni 255 ni 0.
  2. Calculer le nombre magique (la taille du bloc) : 256 − valeur du masque sur cet octet.
  3. Les réseaux commencent à chaque multiple du nombre magique. On cherche le multiple juste inférieur ou égal à la valeur de l’IP sur cet octet : c’est l’adresse réseau. Le multiple suivant, moins 1, donne le broadcast.

Exemple 1 : 192.168.1.42/26

  1. Masque 255.255.255.192 : l’octet intéressant est le 4ᵉ (192).
  2. Nombre magique : 256 − 192 = 64.
  3. Réseaux possibles sur le 4ᵉ octet : 0, 64, 128, 192. Comme 42 est entre 0 et 64 :
    • réseau : 192.168.1.0 ;
    • broadcast : 64 − 1 = 63, donc 192.168.1.63.

Exemple 2 : 10.20.30.40/20

  1. Le /20 donne 255.255.240.0 : l’octet intéressant est le 3ᵉ (240).
  2. Nombre magique : 256 − 240 = 16.
  3. Multiples de 16 : 0, 16, 32, 48… Comme 30 est entre 16 et 32 :
    • réseau : 10.20.16.0 (les octets après l’octet intéressant passent à 0) ;
    • broadcast : 10.20.31.255 (32 − 1 = 31, puis les octets suivants passent à 255) ;
    • hôtes : 32 − 20 = 12 bits, donc 2¹² − 2 = 4 094.

Pourquoi découper ? Un seul grand réseau pour toute une entreprise pose des problèmes :

  • trop de broadcast : chaque machine reçoit les diffusions de toutes les autres ;
  • pas de séparation : la comptabilité et les visiteurs se retrouvent sur le même réseau, ce qui est un problème de sécurité.

On découpe donc en sous-réseaux : un par service, ou un par VLAN (on le verra au cours 2.4).

Le principe : emprunter des bits à la partie hôte

Section intitulée « Le principe : emprunter des bits à la partie hôte »

Avec b bits empruntés, on crée 2^b sous-réseaux.

Exemple : découper 192.168.10.0/24 en 4 sous-réseaux

Étape 1 : combien de bits emprunter ? On cherche le plus petit b tel que 2^b ≥ 4 : 2¹ = 2 (trop peu), 2² = 4 ✅. On emprunte donc 2 bits.

Étape 2 : le nouveau masque. /24 + 2 = /26, soit 255.255.255.192.

Ancien /24 : 11111111.11111111.11111111.00000000
Nouveau /26: 11111111.11111111.11111111.11000000
↑↑ les 2 bits empruntés

Étape 3 : la taille de chaque bloc. Il reste 6 bits d’hôte : 2⁶ = 64 adresses par sous-réseau, donc 62 hôtes.

Étape 4 : lister les sous-réseaux. On ajoute 64 à chaque fois :

N° Adresse réseau Première utilisable Dernière utilisable Broadcast
1 192.168.10.0/26 192.168.10.1 192.168.10.62 192.168.10.63
2 192.168.10.64/26 192.168.10.65 192.168.10.126 192.168.10.127
3 192.168.10.128/26 192.168.10.129 192.168.10.190 192.168.10.191
4 192.168.10.192/26 192.168.10.193 192.168.10.254 192.168.10.255

Le découpage égal gaspille des adresses quand les besoins sont différents. Donner un /26 (62 hôtes) à une liaison entre deux routeurs qui n’a besoin que de 2 adresses, c’est gâcher 60 adresses.

Le VLSM (Variable Length Subnet Mask, masque de longueur variable) donne à chaque sous-réseau la taille dont il a besoin.

  1. Trier les besoins du plus grand au plus petit. C’est obligatoire : sinon les blocs ne tombent pas sur des frontières valides et se chevauchent.
  2. Pour chaque besoin, trouver le plus petit h tel que 2^h − 2 ≥ nombre d’hôtes. Le préfixe vaut 32 − h.
  3. Placer le bloc à la première adresse libre.
  4. Avancer à l’adresse qui suit le broadcast, puis passer au besoin suivant.

Exemple : 192.168.1.0/24 pour 4 besoins. Atelier : 100 hôtes. Direction : 50. Compta : 20. Liaison entre routeurs : 2.

Réseau Besoin Calcul de h Préfixe Adresse réseau Plage utilisable Broadcast
Atelier 100 2⁷ − 2 = 126 ≥ 100 /25 192.168.1.0 .1 → .126 .127
Direction 50 2⁶ − 2 = 62 ≥ 50 /26 192.168.1.128 .129 → .190 .191
Compta 20 2⁵ − 2 = 30 ≥ 20 /27 192.168.1.192 .193 → .222 .223
Liaison routeurs 2 2² − 2 = 2 ≥ 2 /30 192.168.1.224 .225 → .226 .227

Il reste les adresses 192.168.1.228 à 192.168.1.255 de libres pour de futurs besoins.


Choisis un mode, saisis tes valeurs, puis clique sur Calculer ou Découper. Le simulateur affiche le résultat et le déroulé complet du calcul, en binaire et avec la méthode rapide.

Exemples de masque acceptés : /26, 26 ou 255.255.255.192

Comment s’entraîner efficacement :

  1. Fais d’abord le calcul sur papier.
  2. Vérifie ensuite avec le simulateur.
  3. Si tu t’es trompé, compare étape par étape pour trouver où ton raisonnement a dévié.

Constater que deux machines branchées sur le même switch ne communiquent pas si elles sont dans des sous-réseaux différents.

PC0 SWITCH 2960 PC1
192.168.1.10/26 ───── Fa0/1 Fa0/2 ───── 192.168.1.100/26
  1. Reprends le lab du cours 1.1 (ou recrée 2 PC et un switch 2960, reliés en câble droit).
  2. Configure PC0 : 192.168.1.10, masque 255.255.255.192.
  3. Configure PC1 : 192.168.1.100, masque 255.255.255.192.
  4. Depuis PC0 → Command Prompt : ping 192.168.1.100.

Résultat : ❌ le ping échoue (Request timed out ou Destination host unreachable).

Utilise le simulateur (mode 1) sur les deux adresses :

Machine Adresse Réseau Plage
PC0 192.168.1.10/26 192.168.1.0 .1 → .62
PC1 192.168.1.100/26 192.168.1.64 .65 → .126

Les deux PC sont dans deux réseaux différents. Avant d’envoyer un paquet, PC0 applique son masque et constate que 192.168.1.100 n’est pas dans son réseau. Il essaie donc de l’envoyer à sa passerelle (le routeur)… mais il n’en a pas. Le câble et le switch fonctionnent : c’est le plan d’adressage qui empêche la communication.

  1. Change l’adresse de PC1 en 192.168.1.50 (même masque).
  2. Relance ping 192.168.1.50 depuis PC0 : ✅ ça fonctionne, car les deux PC sont maintenant dans le réseau 192.168.1.0/26.

Fais-les sur papier, puis vérifie avec le simulateur.

  1. Convertis 200 en binaire.
  2. Convertis 11100000 en décimal.
  3. Écris le masque /28 en décimal pointé.
Voir la correction
  1. 200 = 128 + 64 + 8, donc 11001000.
  2. 128 + 64 + 32 = 224.
  3. /28 = 24 + 4 bits : 255.255.255. puis 4 bits à 1 dans le dernier octet (11110000 = 240). Résultat : 255.255.255.240.

Pour l’adresse 172.16.5.130/27, donne : le masque, l’adresse réseau, la première et la dernière adresse utilisable, le broadcast et le nombre d’hôtes.

Voir la correction
  • Masque : /27 donne 255.255.255.224.
  • Nombre magique : 256 − 224 = 32, sur le 4ᵉ octet. Multiples de 32 : 0, 32, 64, 96, 128, 160… Comme 130 est entre 128 et 160 :
  • Réseau : 172.16.5.128
  • Première utilisable : 172.16.5.129
  • Dernière utilisable : 172.16.5.158
  • Broadcast : 172.16.5.159 (160 − 1)
  • Hôtes : 2⁵ − 2 = 30

Pour 10.20.30.40/20, trouve l’adresse réseau, le broadcast et le nombre d’hôtes.

Voir la correction
  • /20 donne 255.255.240.0 : l’octet intéressant est le 3ᵉ.
  • Nombre magique : 256 − 240 = 16. Multiples de 16 : 0, 16, 32… Comme 30 est entre 16 et 32 :
  • Réseau : 10.20.16.0
  • Broadcast : 10.20.31.255
  • Hôtes : 2¹² − 2 = 4 094

Un technicien veut configurer un PC avec l’adresse 192.168.1.64/26. Est-ce possible ?

Voir la correction

Non. En /26, le nombre magique est 64 : les réseaux commencent à 0, 64, 128 et 192. L’adresse 192.168.1.64 est donc l’adresse réseau du sous-réseau 192.168.1.64/26 (plage .65 à .126, broadcast .127). Elle ne peut pas être attribuée à une machine.

Découpe 10.0.0.0/24 pour obtenir 6 sous-réseaux. Donne le nouveau masque, le nombre d’hôtes par sous-réseau et les adresses des 8 sous-réseaux obtenus.

Voir la correction
  • 2² = 4 (trop peu), 2³ = 8 ≥ 6 : on emprunte 3 bits.
  • Nouveau préfixe : /27 (255.255.255.224).
  • Taille du bloc : 2⁵ = 32 adresses, donc 30 hôtes par sous-réseau.
  • Sous-réseaux : 10.0.0.0, 10.0.0.32, 10.0.0.64, 10.0.0.96, 10.0.0.128, 10.0.0.160, 10.0.0.192, 10.0.0.224 (tous en /27). On en utilise 6, et 2 restent en réserve.

À partir de 192.168.50.0/24, construis un plan VLSM pour : Production 60 hôtes, Bureaux 30, Serveurs 12, Liaison entre routeurs 2.

Voir la correction
Réseau Besoin Préfixe Adresse réseau Plage utilisable Broadcast
Production 60 /26 (62) 192.168.50.0 .1 → .62 .63
Bureaux 30 /27 (30) 192.168.50.64 .65 → .94 .95
Serveurs 12 /28 (14) 192.168.50.96 .97 → .110 .111
Liaison 2 /30 (2) 192.168.50.112 .113 → .114 .115

Attention aux Bureaux : 30 hôtes tiennent pile dans un /27. Si le service doit grandir, il faudra prévoir un /26.

Un réseau doit accueillir 500 machines. Quel est le plus petit masque possible ?

Voir la correction

On cherche h tel que 2^h − 2 ≥ 500 : 2⁸ − 2 = 254 (trop peu), 2⁹ − 2 = 510 ✅. h = 9 bits d’hôte, donc un préfixe /23 (255.255.254.0).


Piège La réalité
Oublier le − 2 2^h donne le nombre d’adresses. Les hôtes utilisables sont 2^h − 2.
Attribuer l’adresse réseau ou le broadcast à un PC Ces deux adresses sont réservées. Vérifie toujours avec le nombre magique.
VLSM dans le désordre Sans tri du plus grand au plus petit, les blocs se chevauchent.
Oublier la passerelle L’interface du routeur consomme une adresse de la plage : compte-la dans tes besoins.
« Même switch = même réseau » Faux : c’est le masque qui définit le réseau, pas le câblage (voir le lab).
Masque avec un trou Seules 9 valeurs sont possibles par octet : 0, 128, 192, 224, 240, 248, 252, 254, 255.

  • Une IPv4 = 32 bits = 4 octets. Le masque sépare la partie réseau de la partie hôte.
  • Poids des bits : 128 – 64 – 32 – 16 – 8 – 4 – 2 – 1.
  • Réseau = IP ET masque (bits hôte à 0). Broadcast = bits hôte à 1.
  • Hôtes = 2^h − 2.
  • Nombre magique = 256 − valeur du masque sur l’octet intéressant.
  • Découpage égal : b bits empruntés donnent 2^b sous-réseaux.
  • VLSM : trier du plus grand au plus petit, puis prendre pour chaque besoin le plus petit bloc qui convient.
  • /30 (ou /31) pour les liaisons entre routeurs.

Cours suivant : 1.7 IPv6 : les bases