Chapitre 1 — Histoire et modèles OSI/TCP-IP#
Ce chapitre retrace la naissance d’Internet et présente les deux modèles de référence qui structurent encore aujourd’hui toute la réflexion sur les réseaux : le modèle OSI à 7 couches et le modèle TCP/IP à 4 couches.
Naissance d’Internet#
ARPANET (1969)#
Tout commence en 1969 lorsque l’agence de recherche du département américain de la Défense, l”ARPA (Advanced Research Projects Agency), finance la création d’un réseau expérimental reliant quatre universités :
UCLA (Los Angeles)
Stanford Research Institute
UC Santa Barbara
Université de l’Utah
Le 29 octobre 1969, le premier message est envoyé de UCLA vers Stanford. La tentative est de transmettre le mot « LOGIN » — seules les lettres « L » et « O » passent avant que le système ne plante. Internet est né sur un bug.
L’idée fondatrice d’ARPANET est la commutation de paquets (packet switching), proposée indépendamment par Paul Baran (RAND Corporation) et Donald Davies (NPL, Royaume-Uni) : plutôt que d’établir un circuit dédié entre deux points (comme le téléphone), les données sont découpées en paquets qui empruntent des chemins différents et se reassemblent à destination.
Chronologie clé#
RFC et IETF#
La gouvernance technique d’Internet repose sur deux piliers :
RFC (Request for Comments) : Documents techniques publiés depuis 1969 qui définissent tous les protocoles Internet. Malgré leur nom, beaucoup sont des standards définitifs. Quelques exemples incontournables :
RFC |
Protocole |
Année |
|---|---|---|
RFC 791 |
IPv4 |
1981 |
RFC 793 |
TCP |
1981 |
RFC 1034/1035 |
DNS |
1987 |
RFC 2616 |
HTTP/1.1 |
1999 |
RFC 7540 |
HTTP/2 |
2015 |
RFC 9000 |
QUIC |
2021 |
IETF (Internet Engineering Task Force) : Organisation ouverte créée en 1986 qui développe et promeut les standards Internet. Contrairement à d’autres organismes de normalisation, l’IETF n’a pas de membres formels — n’importe qui peut participer. Les décisions se prennent par « rough consensus and running code ».
Le modèle OSI (Open Systems Interconnection)#
Développé par l’ISO (Organisation internationale de normalisation) entre 1977 et 1984, le modèle OSI est un cadre conceptuel qui décompose la communication réseau en 7 couches indépendantes. Son but : permettre à des systèmes hétérogènes de communiquer, et standardiser les interfaces entre niveaux.
Principe fondamental du modèle OSI
Chaque couche n’interagit qu’avec la couche immédiatement inférieure et supérieure. Une couche fournit des services à la couche du dessus et utilise les services de la couche du dessous. Cela permet de changer l’implémentation d’une couche sans affecter les autres.
Les 7 couches OSI#
Description détaillée des couches#
Couche 1 — Physique
Transmet les bits bruts sur le support physique. Elle définit les caractéristiques électriques, mécaniques et fonctionnelles du support : tensions, fréquences, connecteurs (RJ45, LC pour fibre), débit brut. PDU : bit.
Couche 2 — Liaison de données
Organise les bits en trames et gère l’accès au support partagé (MAC — Medium Access Control). Elle détecte (et parfois corrige) les erreurs de transmission au niveau local. Exemples : Ethernet (IEEE 802.3), Wi-Fi (IEEE 802.11). PDU : trame.
Couche 3 — Réseau
Assure le routage des paquets de la source à la destination à travers des réseaux hétérogènes. Elle gère l’adressage logique (adresses IP) et détermine le chemin optimal. PDU : paquet.
Couche 4 — Transport
Fournit une communication de bout en bout entre processus. Elle assure (ou non, selon le protocole) la fiabilité, le contrôle de flux et la gestion des erreurs. TCP (fiable, orienté connexion) et UDP (non fiable, sans connexion). PDU : segment (TCP) ou datagramme (UDP).
Couche 5 — Session
Établit, gère et termine les sessions de communication entre applications. Peu implémentée en pratique — ses fonctions sont souvent absorbées par les couches 4 et 7.
Couche 6 — Présentation
Traduit les données entre le format réseau et le format application : encodage des caractères (ASCII, UTF-8), sérialisation (JSON, XML), compression, chiffrement (SSL/TLS est parfois placé ici).
Couche 7 — Application
Interface directe avec les applications utilisateur. Définit les protocoles métier : HTTP pour le web, SMTP pour le courrier, DNS pour la résolution de noms, FTP pour les fichiers…
Le modèle TCP/IP#
Le modèle TCP/IP (aussi appelé modèle Internet ou modèle DoD) est le modèle pratique sur lequel Internet est réellement construit. Il comporte 4 couches, fruit d’une simplification pragmatique par rapport à OSI.
Correspondance OSI / TCP/IP#
Couche TCP/IP |
Couches OSI équivalentes |
Exemples de protocoles |
|---|---|---|
Application |
Application (7) + Présentation (6) + Session (5) |
HTTP, DNS, SMTP, FTP, SSH |
Transport |
Transport (4) |
TCP, UDP, SCTP |
Internet |
Réseau (3) |
IP (v4/v6), ICMP, OSPF |
Accès réseau |
Liaison (2) + Physique (1) |
Ethernet, Wi-Fi, PPP |
OSI vs TCP/IP en pratique
Le modèle OSI est un outil pédagogique et conceptuel de référence — on raisonne en couches OSI pour diagnostiquer des problèmes réseau. Le modèle TCP/IP est la réalité déployée : Internet fonctionne sur TCP/IP, pas sur OSI. Dans la pratique, on parle souvent de « couche 3 » (réseau/IP) ou « couche 7 » (applicatif) en référence à OSI, même lorsqu’on travaille sur TCP/IP.
Encapsulation et décapsulation#
L”encapsulation est le processus par lequel chaque couche ajoute son propre en-tête (et parfois un pied de page) aux données reçues de la couche supérieure, avant de les transmettre à la couche inférieure.
À la réception, le processus inverse — la décapsulation — retire les en-têtes couche par couche.
Simulation Python d’encapsulation avec struct#
import struct
def make_http_payload(methode: str, chemin: str, hote: str) -> bytes:
"""Construit une requête HTTP/1.1 minimale."""
requete = f"{methode} {chemin} HTTP/1.1\r\nHost: {hote}\r\nConnection: close\r\n\r\n"
return requete.encode("ascii")
def encapsuler_tcp(payload: bytes, port_src: int, port_dst: int, seq: int = 1000) -> bytes:
"""
Ajoute un faux en-tête TCP simplifié (sans checksum réel).
Format : port_src (2o) | port_dst (2o) | seq (4o) | ack (4o) | flags (2o)
"""
flags = 0x018 # PSH + ACK
en_tete_tcp = struct.pack(">HHIIH", port_src, port_dst, seq, 0, flags)
return en_tete_tcp + payload
def encapsuler_ip(segment: bytes, ip_src: str, ip_dst: str, proto: int = 6) -> bytes:
"""
Ajoute un faux en-tête IPv4 simplifié.
Format : version+IHL (1o) | TTL (1o) | proto (1o) | longueur (2o) | src (4o) | dst (4o)
"""
def ip_to_bytes(ip: str) -> bytes:
return bytes(int(x) for x in ip.split("."))
longueur = 13 + len(segment) # en-tête simplifié (13 octets) + segment
version_ihl = (4 << 4) | 5 # IPv4, IHL=5 (20 octets réels, simplifié ici)
en_tete_ip = struct.pack(">BBH", version_ihl, 64, longueur)
en_tete_ip += ip_to_bytes(ip_src) + ip_to_bytes(ip_dst) + bytes([proto])
return en_tete_ip + segment
def encapsuler_ethernet(paquet: bytes, mac_src: str, mac_dst: str, ethertype: int = 0x0800) -> bytes:
"""
Ajoute un en-tête Ethernet simplifié.
Format : dst (6o) | src (6o) | EtherType (2o)
"""
def mac_to_bytes(mac: str) -> bytes:
return bytes(int(x, 16) for x in mac.split(":"))
en_tete_eth = mac_to_bytes(mac_dst) + mac_to_bytes(mac_src) + struct.pack(">H", ethertype)
return en_tete_eth + paquet
# --- Simulation ---
print("=== Simulation d'encapsulation réseau ===\n")
# Couche Application : données HTTP
payload = make_http_payload("GET", "/index.html", "example.com")
print(f"[Couche Application] Données HTTP : {len(payload)} octets")
print(f" {payload[:60]}...\n")
# Couche Transport : encapsulation TCP
segment = encapsuler_tcp(payload, port_src=54321, port_dst=80)
print(f"[Couche Transport] Segment TCP : {len(segment)} octets")
print(f" En-tête TCP (hex) : {segment[:10].hex(' ')}\n")
# Couche Internet : encapsulation IP
paquet = encapsuler_ip(segment, ip_src="192.168.1.10", ip_dst="93.184.216.34")
print(f"[Couche Internet] Paquet IP : {len(paquet)} octets")
print(f" En-tête IP (hex) : {paquet[:13].hex(' ')}\n")
# Couche Accès réseau : encapsulation Ethernet
trame = encapsuler_ethernet(paquet,
mac_src="aa:bb:cc:dd:ee:ff",
mac_dst="11:22:33:44:55:66")
print(f"[Couche Accès réseau] Trame Ethernet : {len(trame)} octets")
print(f" En-tête Ethernet (hex) : {trame[:14].hex(' ')}\n")
print(f"--- Trame complète ({len(trame)} octets) ---")
print(f" Premiers 32 octets : {trame[:32].hex(' ')}")
=== Simulation d'encapsulation réseau ===
[Couche Application] Données HTTP : 66 octets
b'GET /index.html HTTP/1.1\r\nHost: example.com\r\nConnection: clo'...
[Couche Transport] Segment TCP : 80 octets
En-tête TCP (hex) : d4 31 00 50 00 00 03 e8 00 00
[Couche Internet] Paquet IP : 93 octets
En-tête IP (hex) : 45 40 00 5d c0 a8 01 0a 5d b8 d8 22 06
[Couche Accès réseau] Trame Ethernet : 107 octets
En-tête Ethernet (hex) : 11 22 33 44 55 66 aa bb cc dd ee ff 08 00
--- Trame complète (107 octets) ---
Premiers 32 octets : 11 22 33 44 55 66 aa bb cc dd ee ff 08 00 45 40 00 5d c0 a8 01 0a 5d b8 d8 22 06 d4 31 00 50 00
Décapsulation : lecture des en-têtes#
def decapsuler_ethernet(trame: bytes):
"""Lit et retire l'en-tête Ethernet."""
mac_dst = trame[0:6]
mac_src = trame[6:12]
ethertype = struct.unpack(">H", trame[12:14])[0]
payload = trame[14:]
print(f"[Ethernet] dst={':'.join(f'{b:02x}' for b in mac_dst)}"
f" src={':'.join(f'{b:02x}' for b in mac_src)}"
f" EtherType=0x{ethertype:04X}")
return payload
def decapsuler_ip(paquet: bytes):
"""Lit et retire l'en-tête IP simplifié (13 octets ici)."""
version_ihl, ttl, longueur = struct.unpack(">BBH", paquet[0:4])
ip_src = ".".join(str(b) for b in paquet[4:8])
ip_dst = ".".join(str(b) for b in paquet[8:12])
proto = paquet[12]
payload = paquet[13:]
print(f"[IP] src={ip_src} dst={ip_dst} TTL={ttl} proto={proto}")
return payload
def decapsuler_tcp(segment: bytes):
"""Lit et retire l'en-tête TCP simplifié (10 octets ici)."""
port_src, port_dst, seq, ack, flags = struct.unpack(">HHIIH", segment[0:14])
payload = segment[14:]
print(f"[TCP] src_port={port_src} dst_port={port_dst} seq={seq} flags=0x{flags:03X}")
return payload
print("=== Simulation de décapsulation (côté récepteur) ===\n")
reste = decapsuler_ethernet(trame)
reste = decapsuler_ip(reste)
reste = decapsuler_tcp(reste)
print(f"[HTTP] {reste.decode('ascii', errors='replace')[:80]}...")
=== Simulation de décapsulation (côté récepteur) ===
[Ethernet] dst=11:22:33:44:55:66 src=aa:bb:cc:dd:ee:ff EtherType=0x0800
[IP] src=192.168.1.10 dst=93.184.216.34 TTL=64 proto=6
[TCP] src_port=54321 dst_port=80 seq=1000 flags=0x018
[HTTP] GET /index.html HTTP/1.1
Host: example.com
Connection: close
...
Résumé#
Points clés à retenir
Internet est né d’ARPANET en 1969 sur le principe de la commutation de paquets.
Le modèle OSI (7 couches) est un cadre pédagogique et de référence ; le modèle TCP/IP (4 couches) est la réalité déployée.
Les PDU (Protocol Data Units) changent de nom selon la couche : bits → trames → paquets → segments → données.
L”encapsulation consiste à envelopper les données de chaque couche dans un en-tête de la couche inférieure.
Les RFC sont les documents techniques fondateurs d’Internet, gérés par l”IETF.