Ce que ce cours est, et comment l'utiliser
Il s'agit du neuvième cours en Informatique Universitaire : réseaux d'ordinateur — comment un message traverse une planète en sautant de machines qui ne se doivent rien, et ce que chaque couche promet au machines qui ne se doivent rien, et ce que chaque couche promet à la une au-dessus de lui.
Limite de portée, énoncée une fois : un cours d'études, pas un diplôme ; chaque l'en-tête, la somme de contrôle et le numéro de séquence dans ce document sont décodés octet par octet octet par octet dans la série de cours, sur les valeurs exactes imprimées ici.
- Unités 9.1–9.3 transmettent une trame : couches, liaison et IP, ainsi que routage.
- Les unités 9.4–9.5 la rendent fiable et utile : transport et protocoles d'application.
- Les unités 9.6–9.7 la sécurisent et permettent son expansion : TLS et fondamentaux distribués.
L'habitude du réseau : un protocole est une promesse sur les octets — chaque unité décode une promesse à la fois.
Couche et architecture
Pourquoi c'est important. Aucune machine seule ne peut implémenter tout le trajet ; le découpage en couches permet à chaque préoccupation d'être construite, déboguée et remplacée indépendamment — la raison pour laquelle Wi-Fi a pu évoluer sans toucher votre navigateur.
Le concept, avec une image. Chaque couche offre un service à celle qui se trouve au-dessus et consomme celle du dessous : la pile à cinq niveaux est physique, lien, réseau, transport, application. Les données sont encapsulées vers le bas (chaque couche ajoute son en-tête) et désencapsulées vers le haut.
La dérivation (pourquoi les couches surpassent les monolithes). Une modification confinée à une seule couche ne nécessite aucun changement ailleurs SI l'interface de service est respectée — le contrat de la couche. Ethernet est passé de 10 Mb/s à 100 Gb/s sous un IP identique car le service de liaison (trames best-effort) n'a jamais changé. Une interface fuyante (une couche supérieure lisant un en-tête inférieur) détruit l'indépendance : le navigateur qui lit TTL est écrit une fois et casse définitivement.
Exemple détaillé 1 — un message, enveloppé deux fois. Un segment TCP de 20 octets transporte un en-tête IPv4 de 20 octets à l'intérieur d'un en-tête Ethernet de 14 octets : sur le fil, la trame contient $14 + 20 + 20 = 54$ octets d'en-tête pour le corps utile — la NIC du récepteur retire 14, la couche IP retire 20, TCP retire son 20. Chaque couche ne voit que sa propre promesse.
Exemple résolu 2 — les modèles de référence. La pile de cours à 5 couches face au modèle OSI à 7 couches : l'OSI divise notre liaison en physique + liaison et ajoute présentation + session au-dessus de l'application. Internet a remporté la course avec l' sablier : taille réduite (IP), large en haut (applications), large en bas (liaisons) — un seul protocole à la taille permet à tout ce qui est au-dessus de communiquer avec tout ce qui est en dessous.
Erreurs courantes. Compter les couches dans le mauvais sens (les services pointent VERS LE HAUT dans la pile). Confondre le service (promesse) avec le point UP la pile). Confondre le service (promesse) avec le protocole (les octets qui le maintiennent). En sautant la couche physique dans la latence mathématique (la propagation est une question de physique, pas de logiciel).
Résumé. Services actifs, protocoles passifs, encapsulation entre les deux ; l'interface est l'indépendance ; IP est le col de l' sablier.
Couche liaison et IP
Pourquoi c'est important. La couche liaison déplace un cadre entre voisins ; IP déplace un paquet entre inconnus. Confondre ces deux adresses est le bug classique des débutants.
L'idée, avec une image. Un cadre Ethernet : 6-octets destination adresse MAC MAC, 6-octets source, 2-octet type, charge utile, 4-octets CRC. Un en-tête IPv4 : version/IHL, longueur totale, TTL, protocole, somme de contrôle, 4-octets source et destination adresse IP IP.
La dérivation (pourquoi la somme de contrôle IP ne couvre que l'en-tête). La CRC protège le cadre entier d'une liaison à l'autre ; la somme de contrôle IP protège uniquement l'en-tête de bout en bout — car les routeurs réécrivent l'en-tête (décrémentation du TTL) mais ne doivent pas recalculer l'intégrité des données. Chaque mécanisme d'intégrité est limité à exactement l'étendue que son réécritureur peut toucher.
Exemple résolu 1 — décoder un en-tête. Les octets du cours
45 00 00 3C ... 40 06 ... : version 4, IHL 5 (so $5 \times 4 = 20$
octets), longueur totale $0x003C = 60$ (20 en-tête + 40 charge utile), TTL
$0x40 = 64$, protocole $0x06 =$ TCP. La suite décode chaque champ de
l’en-tête imprimé et vérifie la valeur de chacun.
Exemple résolu 2 — adresses à deux échelles. Le MAC change tous les saut (d’image en image : il nomme les voisins) ; l’IP ne change jamais (de bout en bout : il nomme des inconnus). Un paquet traversant 3 routeurs porte 4 MAC de destination différents dans 4 trames et une seule adresse IP de destination la sur tout le trajet — la suite suit les quatre images.
Erreurs courantes. Interpréter l’IHL en octets (il compte des mots de 32 bits). S’attendre à ce que la somme de contrôle IP couvre la charge utile. Croire que les adresses MAC routent (elles trouvent le prochain saut, choisi par l’IP).
Résumé. MAC = voisin, IP = inconnu ; mots IHL ; longueur totale en octets ; chaque somme de contrôle s’étend exactement sur ce que son réécriture touche.
Routage
Pourquoi c’est important. L’IP nomme la destination ; le routage décide du prochain saut — des millions de machines s’accordant sans chef, grâce à un algorithme que vous pouvez exécuter sur papier.
Le principe, avec une illustration. Une table de routage d’un routeur fait correspondre les préfixes de destination aux prochains sauts : la correspondance de préfixe le plus long La règle sélectionne le chemin le plus spécifique. Notre réseau de cours : liens avec poids, routeurs A–F, et algorithme de Dijkstra calculant l'arbre des plus courts chemins à partir de A.
La dérivation (Dijkstra, en chiffres). Poids des cours : A–B 4, A–C 2, B–C 1, B–D 5, C–D 8, C–E 10, D–E 2, E–F 3, D–F 6. Depuis A, l'ordre de fixation est C, B, D, E, F : C à 2 (via A), B à 3 (via C — le court saut par C bat la connexion directe A–B à 4), D à 8 (via B), E à 10 (via D — le double saut à $8 + 2$ bat la valeur $2 + 10 = 12$ que donnerait le lien direct de liaison directe donnerait), F à 13 (via E : $10 + 3$ bat la liaison directe de D $8 + 6 = 14$). Le meilleur chemin de F est A C B D E F à $2 + 1 + 5 + 2 + 3 = 13$. La suite exécute l'algorithme et vérifie chaque distance fixée, distance, l'ordre et l'arbre.
Exemple résolu 1 — correspondance de préfixe le plus long. Tableau : 10.0.0.0/8 → X, 10.1.0.0/16 → Y, 10.1.2.0/24 → Z, défaut → W. Destination
Destination 10.1.2.200 : seul le /24 — X. Le défaut capture ce que
Destination 10.9.9.9 : uniquement le /8 — X. Le cas par défaut attrape ce que
rien d'autre ne fait.
Exemple résolu 2 — pourquoi la hiérarchie. Des tables plates contiendraient une entrée par hôte : $4 \times 10^9$ lignes IPv4. Les préfixes s'agrègent : un L'ISP annonce un /12 couvrant $2^{20}$ adresses — la table reste à $10^5$ entrées car l'agrégation élimine les bits d'hôte.
Erreurs courantes. Oublier le nœud réglé (relâcher un nœud déjà final). Correspondre à la première ligne de la table au lieu du plus long préfixe. Compter les sauts lorsque la métrique est le délai.
Résumé. Les tables mappent les préfixes aux sauts ; le plus long préfixe l'emporte; Dijkstra construit des arbres de plus court chemin en réglant le nœud non réglé le plus proche; l'agrégation garde les tables de taille humaine.
Transport (TCP/UDP)
Pourquoi c'est important. IP promet un meilleur effort — les paquets peuvent disparaître, être réordonnés ou dupliqués. La couche de transport relie les processus d'application : TCP fournit un flux d'octages ordonné, tandis qu'UDP envoie des datagrammes sans garantir la livraison ou l'ordre.
L'idée, avec une image. UDP : ports plus une longueur et une somme de contrôle — une carte postale. TCP : numéros de séquençage, acquittements, retransmission, contrôle de débit et de congestion — un coursier avec un registre. Le handshake à trois temps SYN, SYN-ACK, ACK ouvre une connexion ; FIN la ferme.
La dérivée (pourquoi les acquittements cumulatifs). Chaque acquittement désigne le prochain octa attendu : ACK 200 indique que les octets 0–199 sont arrivés, quel que soit leur ordre. Un écart bloque le numéro d'ACK — la temporisation de l'émetteur provoque une retransmission à partir du écart. Un seul numéro résume tout l'état de réception : simple à vérifier, impossible à mal interpréter.
Exemple résolu 1 — le journal. SYN consomme la séquence 0 ; le SYN-ACK du serveur porte son propre 0. Le client envoie 100 octets : seq 1, next 101 ; l'ACK du serveur confirme 101. Le client envoie 50 : seq 101 ; l'ACK du serveur confirme 151. Un segment de 30 octets envoyé avec seq 151 est perdu : l'ACK reste 151 jusqu'à ce que la temporisation provoque sa retransmission — puis ACK 181. La suite simule l'échange et vérifie chaque numéro.
Exemple résolu 2 — portée honnête d'UDP. Un en-tête UDP de 8 octets (ports, longueur, somme de contrôle) contre le minimum TCP de 20 : DNS tient dans un seul datagramme UDP — une requête est un paquet, et s'il est perdu, le client réitère. Les appels vidéo tolèrent la perte mais pas le retard : retransmettre une redemande. Les appels vidéo tolèrent la perte mais pas le délai : retransmettre une trame due dans 30 ms arrive trop tard pour avoir de l'importance — UDP plus application Erreurs courantes. Compter SYN dans la séquence de données (il consomme
un numéro mais ne transporte rien). Confondre le contrôle de flux (fenêtre du récepteur) avec le contrôle de congestion (état du réseau). S'attendre à ce que TCP garantisse le timing — il garantit l'ordre et la livraison, jamais la latence. garantit le timing — il garantit l'ordre et la livraison, jamais la latence.
Résumé. UDP = ports plus une somme de contrôle pour des travaux de taille de requête ; TCP = registre de séquence plus acquittements cumulatifs plus retransmission ; le handshake ouvre, les FIN ferment, et les fenêtres protègent les deux extrémités.
Protocoles applicatifs
Pourquoi c'est important. Le transport déplace des octets ; l'application s'entend sur leur signification. Lire un protocole, c'est lire une conversation avec une grammaire.
L'idée, avec une image. DNS : nom $\to$ adresse, délégation hiérarchique (racine $\to$ TLD $\to$ autoritaire). HTTP : ligne de requête, en-têtes, corps ; codes de statut $2xx$ succès, $3xx$ redirection, $4xx$ erreur client, $5xx$ erreur serveur.
La dérivation (pourquoi DNS est hiérarchique). Une table de noms mondiale unique
serait une panne mondiale unique et une dispute mondiale unique. La délégation divise
cela : la racine (13 adresses) connaît les serveurs TLD ; .com serveurs
connaissent les registraires ; le serveur autoritaire connaît l'hôte. Chaque
réponse est une renvoi vers le bas — et la mise en cache transforme l'arbre en
raccourci : le résolveur qui a déjà interrogé n'a pas besoin de tout parcourir pendant la
durée de vie du TTL de la réponse.
Exemple résolu 1 — une page, en octets. GET /index.html HTTP/1.1 + Hôte: header; the server answers 200 OK, en-têtes
(Content-Type: text/html, Content-Length: 128), ligne vide, 128
octets. Le groupe de tests vérifie : une réponse avec Content-Length 128 transporte
exactement 128 octets de corps ; un 404 transporte des en-têtes et un court corps ; un 301
transporte Location: et aucun corps significatif.
Exemple résolu 2 — les codes, lus comme des promesses. 200 (voici le
corps), 301 (le corps a bougé, Location indique où), 404 (vous avez posé
faux), 500 (j'ai cassé). Un crawler traite 301 comme un pointeur à suivre,
404 comme une impasse, 500 comme à réessayer plus tard — le code est le contrat que
les programmes clients respectent.
Erreurs courantes. Oublier la ligne vide qui termine les en-têtes (le parseur attend indéfiniment). Lire Content-Length comme des octets d'en-tête. Considérer DNS comme un seul serveur (c'est un arbre délégué avec des caches).
Résumé. DNS résout les noms par délégation et caches ; HTTP est une grammaire demande-réponse où le code de statut est la promesse et les en-têtes transportent les métadonnées.
Sécurité réseau
Pourquoi c'est important. Le réseau est une ligne commune : quiconque sur le chemin peut lire, intercepter ou falsifier. La sécurité est l'ensemble des promesses qui rendent un canal ouvert sûr à utiliser.
L'idée, avec une image. Chiffrement symétrique : une clé partagée clé, rapide. Asymétrique : une paire de clés — la clé publique chiffre, la clé privée déchiffre. TLS les combine : asymétrique pour l'échange de clés, symétrique pour les données, certificats pour l'identité. ClientHello, ServerHello avec certificat, échange de clés, deux Finished — puis données symétriques
La dérivation (les propriétés et ce que chacun fournit).
La confidentialité nécessite un chiffrement ; l'intégrité nécessite un MAC avec vérification des deux sens (chaque message Finished prouve que le handshake n'a pas été modifié) ; l'authentification nécessite une chaîne de certificats menant à une racine que le client fait déjà confiance. Supprimer l'un d'eux et le protocole échoue différemment : sans chiffrement, c'est une interception, sans MAC, c'est une altération, sans certificat, c'est un imposteur. certificat est un imposteur.
Exemple résolu 1 — le poignée de main numérotée. ClientHello (offert les deux parties dérivent les clés de session à partir des trois valeurs, messages Finished vérifient, puis les données circulent en symétrique chiffré. Une opération RSA ensuite cryptographie à vitesse de flux — l'asymétrie est utilisée uniquement pour convenir de la clé symétrique. opération, puis cryptographie haute vitesse — l'asymétrie est utilisée uniquement pour convenir de la clé symétrique.
Exemple résolu 2 — le menu de l'attaquant. Écoute passive : vaincue par le chiffrement. Modification : vaincue par le MAC (la poignée de Les prises de fin empêchent la manipulation avant que les données ne transitent). Impersonnation : réduite par les certificats (le serveur prouve la possession de la clé privée correspondant à la clé publique certifiée). Rejeu du handshake : réduit par les valeurs aléatoires fraîches dans les deux messages Hello. Chaque attaque nomme sa défense.
Erreurs courantes. Chiffrer sans authentifier (vous avez un canal sécurisé vers la mauvaise machine). Confiance aux certificats autogérés en production. Croyance qu'HTTPS rend le serveur honnête (il garantit la confidentialité du canal et l'identification du serveur — le contenu peut toujours mentir). Résumé. Symétrique pour la vitesse, asymétrique pour l'échange de clés,
certificats pour l'identité, MACs pour l'intégrité ; chaque défense répond à une attaque nommée. certificats pour l'identité, MACs pour l'intégrité ; chaque défense répond Pourquoi c'est important. Une fois que deux machines coopèrent sur un réseau,
Fondamentaux des systèmes distribués
Le concept, avec une illustration. Un système distribué partage l'état entre plusieurs machines avec défaillance partielle : la panne d'une machine ne doit pas corrompre les autres. Les messages peuvent être réordonnés ou dupliqués ;
L'idée, avec une image. Un système distribué partage l'état entre plusieurs machines avec défaillances partielles : une machine en panne ne doit pas corrompre le reste. Les messages se réordonnent et se dupliquent ; l'idempotence rend la réexécution sûre ; l'ordre avant ordonne les événements même sans horloges.
La démonstration (pourquoi les horloges ne peuvent pas ordonner). Les horloges de deux machines se désynchronisent de manière non bornée, donc les timestamps ne peuvent pas ordonner en toute sécurité les événements entre machines. L'horloge de Lamport fournit un compteur qui respecte la causalité : lors de l'envoi, attachez $C{+}1$ ; lors de la réception, définissez $C = \max(C, \text{received}) + 1$. If $a$ happens-before $b$ alors $C(a) < C(b)$ — la réciproque n'est pas vraie. Un contre-exemple plus petit seul ne prouve pas une relation causale entre deux événements.
Exemple résolu 1 — la trace de Lamport. P0 envoie $m_1$ à $C = 1$; P1 reçoit : $C = \max(0, 1) + 1 = 2$ ; P1 envoie $m_2$ à $3$ ; P0 et que $C = \max(1, 3) + 1 = 4$ — l'ordre causal est préservé sans et que $C(m_1) = 1 < C(m_2) = 3$ — l'ordre causal est préservé sans aucune horloge.
2 : l'exécuter deux fois doit déduire une seule fois. Rendre
l'opération idempotente par clé : le registre enregistre deduct(user, 25, id=xyz) comme effectué
l'opération idempotente par clé — le registre enregistre xyz comme effectué
et la réessaye est une opération neutre. Les systèmes résistants aux réessais sont construits à partir
opérations idempotentes plus un registre de déduplication, sans compter sur le
réseau pour arrêter les duplications.
Erreurs courantes. Utilisation d'horodatages pour l'ordre entre machines (déviation favorise la victoire). Réessayer des opérations non idempotentes (doubles facturations). Supposer qu'un appel retourné signifie que le travail a été effectué — ou qu'une temporisation signifie qu'il ne l'a pas fait (cela signifie que vous ne savez pas : le troisième scénario).
Résumé. Les échecs partiels peuvent être temporaires ou permanents ; les messages sont réordonnés et dupliqués ; les compteurs Lamport respectent le « avant » ; l'idempotence combinée à la déduplication sécurise les réessais ; une temporisation signifie inconnu, pas échoué.