Adressage IPv4

Nous voici au cœur du cours, et au point qui, chaque année, coince le plus. La couche liaison (chapitre 4) sait faire communiquer des machines sur un même réseau local, par leurs adresses MAC. Mais une MAC est plate et locale : rien en elle ne dit où se trouve la machine dans le monde. Pour joindre une machine à l'autre bout de la planète, il faut une adresse d'une autre nature — globale et structurée —, et un moyen de découper l'espace d'adresses en morceaux gérables. Ce sont l'adresse IP et le découpage en sous-réseaux.

Le découpage en sous-réseaux n'est pas une notion difficile à comprendre : c'est un automatisme de calcul à acquérir. On ne l'apprend pas en lisant, on l'apprend en le refaisant — d'où le poids que le programme met sur les TD, et l'exercice de programmation qui accompagne ce chapitre.

L'adresse IPv4

Une adresse IPv4 est un nombre de 32 bits, écrit pour la lisibilité en quatre octets décimaux séparés par des points : 192.168.1.10. Chaque octet va de 0 à 255 (8 bits), d'où un espace d'environ 4,3 milliards d'adresses.

L'idée maîtresse, celle sur laquelle tout repose, est qu'une adresse IP se divise en deux parties :

$\underbrace{192.168.1}_{\text{partie réseau}}\ .\ \underbrace{10}_{\text{partie hôte}}$

• la partie réseau identifie le réseau auquel la machine appartient — commune à toutes les machines du même réseau ;
• la partie hôte identifie la machine à l'intérieur de ce réseau.

C'est cette structure qui rend le routage possible (chapitre 6) : un routeur n'a pas besoin de connaître chaque machine du monde, seulement chaque réseau. La partie réseau est une adresse de quartier ; la partie hôte, le numéro de maison. Contrairement à la MAC, l'adresse IP porte donc une information de localisation — c'est toute la différence, et la clé du chapitre.

Le masque de sous-réseau

Où passe la frontière entre partie réseau et partie hôte ? Le masque de sous-réseau le dit. C'est lui aussi un motif de 32 bits : des 1 pour la partie réseau, des 0 pour la partie hôte. Le masque 255.255.255.0 s'écrit en binaire :

111111111.11111111.11111111.000000002└──────── réseau ────────┘└─ hôte ─┘

24 bits à 1 : les 24 premiers bits de l'adresse sont la partie réseau, les 8 derniers la partie hôte. Tout le calcul de ce chapitre consiste à manipuler cette frontière — et il se fait en binaire, jamais en décimal directement. C'est le réflexe fondamental : dès qu'un calcul de sous-réseau résiste, on repasse en binaire.

La notation CIDR

Écrire le masque en entier est fastidieux. La notation CIDR (Classless Inter-Domain Routing) le résume par le nombre de bits à 1, précédé d'une barre oblique : 192.168.1.0/24 signifie « masque à 24 bits de réseau », soit 255.255.255.0.

CIDR a remplacé un système plus ancien, les classes. Autrefois, la frontière réseau/hôte était imposée par les premiers bits de l'adresse :

Le défaut des classes était le gaspillage : une organisation de 300 machines devait prendre une classe B (65 000 adresses) faute de mieux — 64 700 adresses perdues. CIDR supprime les classes et autorise n'importe quel préfixe (/23, /26, /30…), donc un dimensionnement au plus juste. C'est en grande partie ce qui a permis à IPv4 de tenir bien plus longtemps que prévu. En pratique, les classes ne servent plus qu'à situer historiquement une adresse ; le vrai outil est le masque CIDR.

Adresses privées et publiques

Toutes les adresses ne sont pas routables sur Internet. Des plages sont réservées à un usage privé — les réseaux internes des entreprises et des domiciles :

110.0.0.0/8         (un très grand réseau privé)2172.16.0.0/12      (plage intermédiaire)3192.168.0.0/16     (les réseaux domestiques : 192.168.x.x)

Ces adresses ne sont pas uniques dans le monde : des millions de box domestiques utilisent 192.168.1.x. Elles ne circulent pas sur Internet ; un mécanisme, la traduction d'adresses (NAT), les convertit en une adresse publique partagée à la sortie du réseau (on l'évoquera au chapitre 6). Retenez la distinction : une adresse privée vit derrière votre box et se répète partout ; une adresse publique est unique et routable mondialement.

Le découpage en sous-réseaux

Voici l'automatisme central. Découper en sous-réseaux, c'est prendre un réseau et en emprunter quelques bits à la partie hôte pour créer plusieurs sous-réseaux plus petits. Un /24 (256 adresses) découpé en /26 donne quatre sous-réseaux de 64 adresses chacun — on a emprunté 2 bits d'hôte, et $2^2 = 4$.

Pour un réseau donné, quatre grandeurs se calculent, et il faut les produire de tête ou au brouillon, vite :

Le fameux « − 2 » est la source d'erreur numéro un : dans chaque sous-réseau, l'adresse la plus basse (tous les bits d'hôte à 0) est l'adresse réseau, et la plus haute (tous à 1) est la diffusion. Ni l'une ni l'autre ne s'attribue à une machine. Un /30 (2 bits d'hôte) ne donne donc que $4 - 2 = 2$ hôtes utilisables — exactement ce qu'il faut pour une liaison entre deux routeurs, cas très courant.

Un raccourci de terrain, à connaître : le pas du découpage se lit sur le dernier octet non plein du masque. Un /26 a pour masque 255.255.255.192 ; $256 - 192 = 64$, donc les sous-réseaux vont de 64 en 64 : .0, .64, .128, .192. Pour situer une IP comme 10.0.0.200/26, on cherche le multiple de 64 juste en dessous de 200 : c'est 192, donc l'IP est dans le sous-réseau 10.0.0.192. Ce réflexe évite de tout repasser en binaire à chaque fois.

À vous

L'exercice est le TD de ce chapitre transformé en programme, et le meilleur moyen d'installer l'automatisme. Vous implémentez le calculateur de sous-réseau complet : adresse réseau (IP ET masque), adresse de diffusion (partie hôte à 1), plage utilisable, nombre d'hôtes ($2^{\text{bits}} - 2$). Vous le testez sur /24, /26, et vous situez 10.0.0.200/26.

Un avertissement, qui est aussi le conseil du programme : coder le calculateur ne suffit pas. Le découpage est un réflexe, et un réflexe se forge par la répétition à la main. Après l'exercice, refaites masque / réseau / diffusion / plage sur dix adresses au brouillon, sans machine. C'est à ce prix, et à ce prix seulement, que le point qui coince cesse de coincer.

// Une adresse IPv4 = 32 bits, écrits en 4 octets décimaux (ex. 192.168.1.10).
// Le MASQUE sépare la partie RÉSEAU (bits de gauche, à 1) de la partie HÔTE
// (bits de droite, à 0). En notation CIDR, /24 = 24 bits de réseau.
//
// Tout le calcul se fait en binaire sur 32 bits. On outille d'abord les
// conversions, puis les quatre grandeurs à connaître par cœur.

function versEntier(ip) {                    // "192.168.1.10" -> entier 32 bits
  return ip.split(".").reduce((n, o) => (n * 256 + Number(o)) >>> 0, 0);
}
function versIP(n) {                          // entier -> "192.168.1.10"
  return [24, 16, 8, 0].map((d) => (n >>> d) & 255).join(".");
}
function masqueDepuisCIDR(prefixe) {          // 24 -> entier du masque
  // /0 -> 0 ; sinon, 'prefixe' bits de 1 à gauche, complétés de 0.
  return prefixe === 0 ? 0 : (0xffffffff << (32 - prefixe)) >>> 0;
}

// ── À VOUS : les quatre grandeurs ───────────────────────────────────────────
// Toutes s'obtiennent par des opérations BIT À BIT entre l'IP et le masque.
function adresseReseau(ip, prefixe) {
  // ET bit à bit entre l'IP et le masque : met à 0 la partie hôte.
  return 0; // à compléter : versEntier(ip) & masqueDepuisCIDR(prefixe)
}
function adresseDiffusion(ip, prefixe) {
  // adresse réseau OU (complément du masque) : met à 1 toute la partie hôte.
  return 0; // à compléter
}
function nombreHotes(prefixe) {
  // bits d'hôte = 32 - prefixe. Adresses = 2^(bits d'hôte).
  // Hôtes UTILISABLES = ce nombre - 2 (on retire réseau et diffusion).
  return 0; // à compléter
}

// ── Affichage complet d'un sous-réseau ──────────────────────────────────────
function decrire(ip, prefixe) {
  const res = adresseReseau(ip, prefixe);
  const diff = adresseDiffusion(ip, prefixe);
  console.log("Adresse donnée   : " + ip + "/" + prefixe);
  console.log("  masque         : " + versIP(masqueDepuisCIDR(prefixe)));
  console.log("  réseau         : " + versIP(res));
  console.log("  1er utilisable : " + versIP((res + 1) >>> 0));
  console.log("  dernier util.  : " + versIP((diff - 1) >>> 0));
  console.log("  diffusion      : " + versIP(diff));
  console.log("  hôtes util.    : " + nombreHotes(prefixe));
  console.log("");
}

decrire("192.168.1.10", 24);
decrire("192.168.1.10", 26);   // /26 découpe le /24 en 4 sous-réseaux
decrire("10.0.0.200", 26);     // dans quel sous-réseau /26 tombe cette IP ?

function adresseReseau(ip, prefixe) {
  return (versEntier(ip) & masqueDepuisCIDR(prefixe)) >>> 0;
}
function adresseDiffusion(ip, prefixe) {
  const hote = (~masqueDepuisCIDR(prefixe)) >>> 0;    // complément du masque
  return (adresseReseau(ip, prefixe) | hote) >>> 0;   // partie hôte à 1
}
function nombreHotes(prefixe) {
  const bitsHote = 32 - prefixe;
  return Math.pow(2, bitsHote) - 2;                    // -2 : réseau + diffusion
}

// ── Résultats ───────────────────────────────────────────────────────────────
// 192.168.1.10/24 : réseau 192.168.1.0, diffusion 192.168.1.255,
//                   plage .1 à .254, 254 hôtes.
// 192.168.1.10/26 : masque 255.255.255.192 ; réseau 192.168.1.0,
//                   diffusion 192.168.1.63, plage .1 à .62, 62 hôtes.
//                   (/26 = 4 sous-réseaux : .0, .64, .128, .192)
// 10.0.0.200/26   : 200 = 11001000 ; les 2 bits de réseau -> bloc .192.
//                   réseau 10.0.0.192, diffusion 10.0.0.255, plage .193 à .254.

// ── La méthode à automatiser (le point qui coince) ──────────────────────────
//
// 1. TOUT est binaire. Le masque /n = n bits de 1 à gauche. La frontière
//    réseau/hôte est cette limite entre les 1 et les 0. Les quatre grandeurs
//    sont de simples opérations bit à bit :
//       réseau    = IP ET masque          (partie hôte forcée à 0)
//       diffusion = réseau OU (NON masque) (partie hôte forcée à 1)
//       hôtes     = 2^(32-n) - 2          (-2 : réseau et diffusion réservés)
//
// 2. Le « pas » d'un découpage se lit sur le dernier octet du masque.
//    /26 -> masque ...192 -> 256-192 = 64 : les sous-réseaux vont de 64 en 64
//    (.0, .64, .128, .192). Pour situer une IP, on cherche le multiple du pas
//    immédiatement en dessous : 200 tombe dans le bloc .192.
//
// 3. Pourquoi « -2 » ? L'adresse la plus basse (tous bits d'hôte à 0) est
//    l'adresse RÉSEAU, non attribuable ; la plus haute (tous à 1) est la
//    DIFFUSION. Un /30 (2 bits d'hôte) donne donc 4-2 = 2 hôtes utilisables —
//    juste ce qu'il faut pour une liaison entre deux routeurs.
//
// 4. CIDR remplace les vieilles CLASSES (A/B/C, à masque fixe) : on choisit
//    le préfixe exactement à la taille voulue, sans gâcher d'adresses. C'est
//    ce qui a permis à IPv4 de tenir bien plus longtemps que prévu.
//
// Cet automatisme ne s'apprend pas en le lisant : refaites-le à la main sur
// dix exemples, masque, réseau, diffusion, plage. C'est un réflexe de calcul.

Ce que la suite en fait

Vous savez maintenant adresser les machines à l'échelle du monde et découper l'espace en sous-réseaux. Reste la question que cette structure rendait possible : comment un paquet trouve son chemin d'un réseau à l'autre, à travers Internet ?

C'est l'objet du chapitre 6, l'autre moitié du cœur du cours. On y verra le datagramme IP, la table de routage et le principe d'acheminement de proche en proche, la passerelle par défaut, le protocole ICMP (ping, traceroute), et un aperçu d'IPv6 — dont la raison d'être est précisément l'épuisement de l'espace d'adresses IPv4 que ce chapitre a fait entrevoir.

À retenir