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

Le chapitre 5 a donné aux machines des adresses globales et structurées. Ce chapitre répond à la question que cette structure rendait possible, et qui est l'autre moitié du cœur du cours : comment un paquet trouve son chemin d'un bout à l'autre d'Internet, en traversant des dizaines de réseaux appartenant à des opérateurs différents ?

La réponse est d'une élégance qui mérite d'être saisie : personne ne connaît le chemin complet. Chaque routeur ne décide que d'un pas — le prochain saut — puis passe le paquet au suivant, qui refait le même calcul. Le paquet avance de proche en proche, comme un voyageur qui, à chaque carrefour, demande seulement « quelle direction pour aller là-bas ? » sans jamais connaître l'itinéraire entier. C'est ce principe local qui rend Internet extensible à l'échelle de la planète.

Le datagramme IP

L'unité de la couche réseau est le datagramme (ou paquet) IP : les données, précédées d'un en-tête IP. Les champs qui comptent pour ce chapitre :

• l'adresse source et l'adresse destination (chapitre 5) — la destination est ce que chaque routeur lit pour décider ;
• le TTL (Time To Live) : un compteur décrémenté à chaque routeur traversé. Quand il atteint zéro, le paquet est détruit. C'est le garde-fou contre les boucles de routage : sans lui, un paquet mal aiguillé tournerait indéfiniment. C'est aussi le mécanisme qu'exploite traceroute, plus bas.

IP est un service « au mieux » (best effort) : il fait de son mieux pour livrer, mais ne garantit rien — un datagramme peut être perdu, dupliqué, arriver en désordre. C'est le prix de la commutation de paquets (chapitre 1), et c'est un choix délibéré : la simplicité du cœur du réseau. Rétablir la fiabilité est laissé aux extrémités, à TCP (chapitre 7). Cette division du travail — un réseau simple et faillible, une intelligence aux bords — est le principe de conception fondateur d'Internet.

La table de routage et le plus long préfixe

Chaque routeur — et chaque machine — possède une table de routage : une liste de règles de la forme « pour telle destination (un réseau/préfixe), envoie vers tel prochain saut ». À la réception d'un paquet, le routeur lit l'adresse destination et cherche la route correspondante.

Souvent, plusieurs routes correspondent. Un paquet pour 10.1.5.42 peut correspondre à la fois à une route 10.0.0.0/8, à 10.1.0.0/16 et à 10.1.5.0/24. Laquelle choisir ? La règle est universelle :

Règle du plus long préfixe : parmi les routes qui correspondent, on choisit la plus spécifique — celle dont le préfixe est le plus long.

Ici, /24 l'emporte sur /16, qui l'emporte sur /8. L'intuition : plus le préfixe est long, plus la route est précise, et une route précise « connaît mieux » la destination qu'une route générale. C'est exactement le calcul que fait l'exercice de ce chapitre, et c'est le mécanisme au cœur de tout routeur, du plus petit au plus gros.

Routage statique et passerelle par défaut

Comment la table se remplit-elle ? De deux façons.

Le routage statique : un administrateur écrit les routes à la main. Simple, prévisible, adapté aux petits réseaux et aux cas figés. Son défaut : il ne s'adapte pas — si un lien tombe, la route reste dans la table et le paquet part dans le vide, jusqu'à ce qu'on corrige à la main.

La route par défaut, notée 0.0.0.0/0, est la clé de voûte. Son préfixe est le plus court possible (zéro bit) : elle correspond donc à tout, mais, par la règle du plus long préfixe, elle n'est choisie que si aucune autre route ne correspond. C'est le « pour tout le reste, envoie par là ». Le prochain saut de cette route est la passerelle par défaut.

Chez vous, la passerelle par défaut est votre box. Votre ordinateur ne connaît qu'une poignée de routes (le réseau local) et une route par défaut vers la box ; tout ce qui n'est pas local part vers elle, et de là vers Internet. C'est pourquoi une passerelle mal configurée coupe tout accès extérieur tout en laissant le réseau local fonctionner — un symptôme que le chapitre 9 apprendra à diagnostiquer.

À grande échelle, écrire les routes à la main devient impossible : les routeurs échangent alors automatiquement leurs routes par des protocoles de routage dynamique (OSPF à l'intérieur d'un réseau, BGP entre opérateurs). Ils s'adaptent aux pannes en recalculant les chemins. Le détail est hors programme en L1 ; retenez qu'ils existent, et que la décision qu'ils produisent reste, à l'arrivée, la même règle du plus long préfixe.

ICMP : ping et traceroute

IP transporte les données ; ICMP transporte les messages de service du réseau — les erreurs et les diagnostics. Deux outils, que vous emploierez en TP et au chapitre 9, reposent dessus.

ping envoie un message ICMP « echo request » et attend un « echo reply ». Il répond à deux questions : la machine est-elle joignable ? et en combien de temps ? (le RTT, la latence du chapitre 1). C'est le premier réflexe de tout dépannage.

traceroute est plus astucieux, et il exploite le TTL vu plus haut. Il envoie des paquets avec un TTL de 1, puis 2, puis 3, etc. Le paquet à TTL 1 est détruit par le premier routeur, qui renvoie une erreur ICMP — révélant son adresse. Le TTL 2 atteint le deuxième routeur, et ainsi de suite. En augmentant le TTL, traceroute cartographie le chemin saut par saut jusqu'à la destination. C'est une illustration magnifique du routage de proche en proche : on voit littéralement le paquet avancer d'un routeur à l'autre.

Un aperçu d'IPv6

Le chapitre 5 l'a laissé entrevoir : les 4,3 milliards d'adresses IPv4 sont épuisées. La réponse de fond est IPv6, qui porte les adresses à 128 bits — un espace si vaste ($3{,}4 \times 10^{38}$ adresses) qu'il est en pratique inépuisable. Une adresse IPv6 s'écrit en hexadécimal, par blocs séparés de deux-points : 2001:db8::1.

Au-delà de la taille, IPv6 simplifie l'en-tête, intègre mieux l'autoconfiguration, et supprime le besoin de NAT — chaque machine peut de nouveau avoir une adresse unique et routable, ce qui restaure le principe de bout en bout d'origine. La transition est lente : IPv4 et IPv6 coexistent depuis des années, car changer un protocole aussi fondamental sur un réseau planétaire ne se décrète pas. En L1, retenez la raison (l'épuisement d'IPv4), la solution (128 bits) et le fait que les deux cohabitent — le détail relève des cours ultérieurs.

À vous

L'exercice met la décision d'acheminement entre vos mains. Vous implémentez le choix qu'un routeur opère pour chaque paquet : parmi les routes qui correspondent à la destination, garder celle au plus long préfixe. Vous voyez alors le /24 l'emporter sur le /16, le /16 sur le /8, et la route par défaut 0.0.0.0/0 ne servir que de dernier recours — la passerelle vers Internet.

Le TP fait toucher du doigt le principe du chapitre : chaque routeur ne décide que du prochain saut, refait le même calcul, et le paquet avance de proche en proche. Personne n'a la carte complète — et c'est précisément ce qui fait tenir Internet.

// Un routeur reçoit un paquet, lit son adresse IP DESTINATION, et consulte sa
// TABLE DE ROUTAGE pour décider par où l'envoyer (le « prochain saut »).
//
// Chaque route dit : « pour cette destination (réseau/préfixe), va vers X ».
// La route 0.0.0.0/0 est la ROUTE PAR DÉFAUT : elle correspond à TOUT — c'est
// « pour tout le reste, envoie à la passerelle ».

const table = [
  { reseau: "10.0.0.0",   prefixe: 8,  saut: "interface locale A" },
  { reseau: "10.1.0.0",   prefixe: 16, saut: "routeur R2" },
  { reseau: "10.1.5.0",   prefixe: 24, saut: "routeur R3" },
  { reseau: "0.0.0.0",    prefixe: 0,  saut: "passerelle Internet" }, // défaut
];

function versEntier(ip) {
  return ip.split(".").reduce((n, o) => (n * 256 + Number(o)) >>> 0, 0);
}
function masque(prefixe) {
  return prefixe === 0 ? 0 : (0xffffffff << (32 - prefixe)) >>> 0;
}
// Le paquet correspond-il à cette route ? (destination ET masque == réseau)
function correspond(dst, route) {
  return (versEntier(dst) & masque(route.prefixe)) >>> 0 ===
         (versEntier(route.reseau) & masque(route.prefixe)) >>> 0;
}

// ── À VOUS : la décision d'acheminement ─────────────────────────────────────
// Parmi TOUTES les routes qui correspondent, choisir celle au préfixe le PLUS
// LONG (la plus SPÉCIFIQUE). C'est la règle du plus long préfixe.
function acheminer(dst) {
  let meilleure = null;
  for (const route of table) {
    if (correspond(dst, route)) {
      // à compléter : garder 'route' si son préfixe est plus long que celui
      // de 'meilleure' (ou si meilleure est null)
    }
  }
  return meilleure ? meilleure.saut : "INJOIGNABLE";
}

// ── Vérification ────────────────────────────────────────────────────────────
const tests = ["10.1.5.42", "10.1.9.3", "10.9.9.9", "8.8.8.8"];
for (const dst of tests) {
  console.log(dst.padEnd(12) + " -> " + acheminer(dst));
}

function acheminer(dst) {
  let meilleure = null;
  for (const route of table) {
    if (correspond(dst, route)) {
      if (!meilleure || route.prefixe > meilleure.prefixe) {
        meilleure = route;                    // plus spécifique = préfixe plus long
      }
    }
  }
  return meilleure ? meilleure.saut : "INJOIGNABLE";
}

// ── Résultats ───────────────────────────────────────────────────────────────
// 10.1.5.42 -> routeur R3   : correspond à /8, /16 ET /24 ; le /24 gagne
//                             (le plus spécifique).
// 10.1.9.3  -> routeur R2   : correspond à /8 et /16 ; le /16 gagne.
// 10.9.9.9  -> interface A  : ne correspond qu'à /8.
// 8.8.8.8   -> passerelle   : ne correspond qu'à la route par défaut /0.
//
// ── Ce que l'exercice enseigne ──────────────────────────────────────────────
//
// 1. Le routage est LOCAL et RÉPÉTÉ. Chaque routeur ne décide QUE du prochain
//    saut, pas du chemin entier. Le paquet est relayé de proche en proche,
//    chaque routeur refaisant ce même calcul. Personne ne connaît la route
//    complète — c'est ce qui rend Internet extensible.
//
// 2. La règle du PLUS LONG PRÉFIXE : quand plusieurs routes correspondent, on
//    prend la plus SPÉCIFIQUE (préfixe le plus long). /24 l'emporte sur /16,
//    qui l'emporte sur /8. C'est la règle universelle d'une table de routage.
//
// 3. La ROUTE PAR DÉFAUT (0.0.0.0/0) correspond à tout, avec le préfixe le
//    plus court : c'est donc le dernier recours, « pour tout ce que je ne
//    connais pas, envoie à la passerelle ». Chez vous, la passerelle par
//    défaut est votre box — d'où tout part vers Internet.
//
// 4. Ce routage est STATIQUE (la table est écrite à la main). À grande
//    échelle, les routeurs échangent leurs routes par des protocoles de
//    routage DYNAMIQUE (OSPF, BGP) — hors programme, mais la décision par
//    plus long préfixe reste la même.

Ce que la suite en fait

La couche réseau est complète : vous savez adresser (chapitre 5) et acheminer (ce chapitre). Mais IP est « au mieux » — il perd des paquets, les mélange, les duplique, sans jamais s'en soucier. Aucune application sérieuse ne peut vivre avec cela telle quelle.

Le chapitre 7, la couche transport, ajoute l'intelligence aux extrémités. TCP y rétablit la fiabilité — détection des pertes, retransmission, remise en ordre — que la couche liaison (chapitre 4) ne faisait que détecter sans corriger, et que IP ne fait pas du tout. On y verra aussi UDP, son opposé volontairement minimal, et les ports, qui permettent à plusieurs applications de partager une même adresse IP.

À retenir