Révision Détaillée : Réseaux et Protocoles

Introduction

Ce document est une révision détaillée des concepts clés des réseaux et protocoles, en s'appuyant sur les documents que vous avez partagés. Il couvre les modèles OSI et TCP/IP, l'analyse des trames Ethernet, les protocoles DNS, TCP, UDP, et IP, ainsi que l'utilisation des outils Wireshark et Scapy. Des exercices pratiques sont inclus pour renforcer votre compréhension.

Modèles OSI et TCP/IP

Modèle OSI

Le modèle OSI (Open Systems Interconnection) est un modèle conceptuel qui divise les fonctions de communication en sept couches. Chaque couche a un rôle spécifique et communique avec les couches adjacentes via des interfaces standardisées.

Diagramme du Modèle OSI

(Représentation visuelle des 7 couches)

Source: Wikimedia Commons

Modèle TCP/IP

Le modèle TCP/IP est une simplification du modèle OSI, avec quatre couches principales. Il est utilisé pour les communications sur Internet et est plus orienté vers la pratique que le modèle OSI.

Diagramme du Modèle TCP/IP

(Représentation visuelle des 4 couches)

Source: Wikimedia Commons

Comparaison OSI vs TCP/IP

Trames Ethernet

Une trame Ethernet est une unité de données au niveau de la couche de liaison de données (couche 2 du modèle OSI). Elle est utilisée pour encapsuler les paquets de données qui sont transmis sur un réseau Ethernet.

Structure d'une Trame Ethernet

Voici la structure détaillée d'une trame Ethernet :

Exemple de Trame Ethernet

Voici un exemple de trame Ethernet capturée en hexadécimal :

Trames Ethernet et VLAN

Avec les VLAN (Virtual LAN), une trame Ethernet peut inclure un tag VLAN (4 octets supplémentaires) pour identifier le réseau virtuel. La taille maximale d'une trame Ethernet avec VLAN est de 1522 octets.

Structure d'une trame Ethernet avec VLAN (802.1Q) :

Protocoles (DNS, TCP, UDP, IP)

DNS (Domain Name System)

Le DNS est un protocole de la couche application qui permet de traduire les noms de domaine (ex: www.cnam.fr) en adresses IP (ex: 163.173.128.52). Il utilise généralement le protocole UDP sur le port 53, mais peut aussi utiliser TCP pour des réponses longues (ex: transferts de zone).

Fonctionnement du DNS

Le DNS fonctionne selon une hiérarchie de serveurs :

1. Résolveur DNS : Reçoit la requête du client et la transmet aux serveurs DNS.
2. Serveur racine : Redirige vers le serveur TLD (.fr, .com, etc.).
3. Serveur TLD : Redirige vers le serveur faisant autorité pour le domaine.
4. Serveur faisant autorité : Retourne l'adresse IP associée au nom de domaine.

Exemple de Résolution DNS

(Requête pour www.cnam.fr)

Source: CloudNS

Exemple de Requête DNS

Voici un exemple de requête DNS capturée avec Wireshark :

Réponse DNS

TCP (Transmission Control Protocol)

TCP est un protocole de la couche transport qui offre une communication fiable, orientée connexion, et avec contrôle de flux. Il est utilisé pour des applications nécessitant une transmission sans erreur (ex: HTTP, FTP, SSH).

Caractéristiques de TCP

• Orienté connexion : Établit une connexion avant d'envoyer des données (three-way handshake).
• Fiable : Garantit la livraison des données grâce aux accusés de réception (ACK) et aux retransmissions.
• Contrôle de flux : Ajuste le débit d'envoi en fonction de la capacité du récepteur.
• Ordonnancement : Les segments sont réordonnés si nécessaire.
• Contrôle de congestion : Réduit le débit en cas de congestion du réseau.

Structure de l'En-tête TCP

Drapeaux TCP

Three-Way Handshake

Le three-way handshake est le processus utilisé par TCP pour établir une connexion :

1. SYN : Le client envoie un segment avec le drapeau SYN positionné et un numéro de séquence initial.
2. SYN-ACK : Le serveur répond avec un segment SYN-ACK, accusant réception du SYN du client et envoyant son propre SYN.
3. ACK : Le client accuse réception du SYN du serveur avec un segment ACK.

Schéma du Three-Way Handshake

Source: Gate Vidyalay

Exemple de Capture TCP avec Wireshark

Voici un exemple de capture d'une connexion TCP (three-way handshake) :

UDP (User Datagram Protocol)

UDP est un protocole de la couche transport qui offre une communication non fiable et sans connexion. Il est utilisé pour des applications où la vitesse est plus importante que la fiabilité (ex: streaming vidéo, DNS, VoIP).

Caractéristiques de UDP

• Sans connexion : Pas d'établissement de connexion préalable.
• Non fiable : Pas d'accusé de réception ni de retransmission.
• Rapide : Moins de surcharge que TCP (en-tête de 8 octets seulement).
• Multidiffusion : Supporte l'envoi de datagrammes à plusieurs destinataires.

Structure de l'En-tête UDP

Exemple de Capture UDP avec Wireshark

Voici un exemple de capture d'une requête DNS (qui utilise UDP) :

IP (Internet Protocol)

IP est un protocole de la couche réseau qui permet l'adressage logique et le routage des paquets à travers les réseaux. Il existe deux versions principales : IPv4 (32 bits) et IPv6 (128 bits).

IPv4

IPv4 utilise des adresses sur 32 bits, généralement représentées en notation décimale pointée (ex: 192.168.1.1).

Exemple de Datagramme IPv4

IPv6

IPv6 utilise des adresses sur 128 bits, représentées en hexadécimal (ex: 2001:0db8:85a3:0000:0000:8a2e:0370:7334). IPv6 simplifie l'en-tête IP et ajoute des fonctionnalités comme l'auto-configuration et la sécurité intégrée.

Exemple de Datagramme IPv6

Wireshark

Wireshark est un analyseur de protocole réseau open-source qui permet de :

• Capturer le trafic réseau en temps réel.
• Analyser les paquets capturés (filtres, statistiques, graphiques).
• Décoder les protocoles (Ethernet, IP, TCP, UDP, DNS, etc.).
• Exporter des données pour analyse ultérieure.

Installation et Lancement

Wireshark est disponible pour Windows, macOS et Linux. Vous pouvez le télécharger depuis le site officiel.

Après installation, lancez Wireshark et sélectionnez une interface réseau pour commencer la capture :

Source: Wireshark

Interface de Wireshark

L'interface de Wireshark est divisée en plusieurs parties :

1. Liste des paquets : Affiche tous les paquets capturés avec des informations comme le temps, la source, la destination, le protocole, etc.
2. Détails du paquet : Affiche les détails du paquet sélectionné (en-têtes des protocoles).
3. Données brutes : Affiche les données brutes du paquet en hexadécimal et ASCII.

Source: Wireshark

Filtres Wireshark

Les filtres permettent de réduire l'affichage aux paquets qui vous intéressent. Il existe deux types de filtres :

• Filtres de capture : Appliqués pendant la capture (ex: port 80).
• Filtres d'affichage : Appliqués après la capture (ex: tcp.port == 80).

Exemples de Filtres d'Affichage

Exemple de Capture avec Filtre

Voici un exemple de capture filtrée pour afficher uniquement le trafic HTTP :

Suivi de Flux TCP

Wireshark permet de suivre un flux TCP complet pour reconstruire une conversation entre un client et un serveur. Pour ce faire :

1. Sélectionnez un paquet TCP dans la liste.
2. Faites un clic droit et choisissez Follow > TCP Stream.
3. Wireshark affichera alors tous les paquets du flux dans l'ordre, avec les données échangées.

Source: Comparitech

Statistiques et Graphiques

Wireshark offre des outils pour analyser les statistiques du trafic :

• Protocol Hierarchy : Affiche la répartition des protocoles dans la capture.
• IO Graph : Affiche un graphique du trafic au fil du temps.
• Endpoint List : Liste les adresses IP et MAC avec leur trafic.
• Conversation List : Affiche les conversations entre paires d'adresses.

Source: Wireshark

Scapy

Scapy est un outil puissant en Python pour :

• Créer et manipuler des paquets réseau.
• Envoyer et recevoir des paquets (sniffing).
• Analyser et décoder des protocoles.
• Automatiser des tests réseau et des attaques (pour des fins éducatives ou de sécurité).

Installation de Scapy

Scapy peut être installé via pip :

pip install scapy
            

Ou sur Linux (Debian/Ubuntu) :

sudo apt-get install python3-scapy
            

Premiers Pas avec Scapy

Lancez Scapy en mode interactif avec la commande :

sudo scapy
            

Voici quelques commandes de base :

# Afficher la liste des commandes disponibles
ls()

# Créer un paquet IP
p = IP()

# Afficher les détails du paquet
p.show()

# Créer un paquet IP avec des adresses source et destination
p = IP(src="192.168.1.100", dst="8.8.8.8")

# Ajouter une couche ICMP (pour un ping)
p = IP(dst="8.8.8.8")/ICMP()

# Envoyer le paquet
send(p)

# Sniffer des paquets (10 paquets)
pkts = sniff(count=10)

# Afficher les paquets capturés
pkts.show()
            

Exemples Avancés

Envoyer un Ping (ICMP Echo Request)

# Créer un paquet ICMP Echo Request
ping = IP(dst="8.8.8.8")/ICMP()

# Envoyer le paquet
send(ping)
            

Sniffer du Trafic ICMP

# Sniffer les paquets ICMP pendant 10 secondes
pkts = sniff(filter="icmp", timeout=10)

# Afficher les paquets capturés
pkts.show()
            

Envoyer un SYN Scan (Balayage de Ports)

# Créer un paquet TCP SYN pour le port 80
syn = IP(dst="192.168.1.1")/TCP(dport=80, flags="S")

# Envoyer le paquet
send(syn)
            

Créer un Paquet Personnalisé

# Créer un paquet Ethernet + IP + TCP avec des données
p = Ether(dst="00:11:22:33:44:55")/IP(dst="192.168.1.1", ttl=64)/TCP(dport=80)/"Hello, World!"

# Envoyer le paquet
sendp(p)
            

Sniffer et Filtrer du Trafic

# Sniffer le trafic TCP sur le port 80
pkts = sniff(filter="tcp and port 80", count=5)

# Afficher les paquets
for pkt in pkts:
    pkt.show()
            

Exemple Complet : Envoi d'une Requête DNS

from scapy.all import *

# Créer une requête DNS pour www.cnam.fr
dns_req = IP(dst="8.8.8.8")/UDP(dport=53)/DNS(rd=1,qd=DNSQR(qname="www.cnam.fr"))

# Envoyer la requête et attendre la réponse
ans, unans = sr(dns_req)

# Afficher la réponse
ans.show()
            

Exercices Pratiques

Exercice 1 : Analyse de Trame Ethernet

Exercice 2 : Capture DNS avec Wireshark

Exercice 3 : Utilisation de Scapy pour un Ping

>>> packet = IP(dst="8.8.8.8")/ICMP()
>>> send(packet)
                

Exercice 4 : Analyse de Connexion TCP

Exercice 5 : Sniffing avec Scapy

from scapy.all import *

# Sniffer 10 paquets
pkts = sniff(count=10)

# Afficher les paquets
for pkt in pkts:
    pkt.show()
                

Conclusion

Ce document de révision détaillé couvre les concepts fondamentaux des réseaux et protocoles, en mettant l'accent sur :

• Les modèles OSI et TCP/IP et leurs différences.
• L'analyse des trames Ethernet et leur structure.
• Les protocoles DNS, TCP, UDP et IP et leur fonctionnement.
• L'utilisation de Wireshark pour capturer et analyser le trafic réseau.
• L'utilisation de Scapy pour forger et envoyer des paquets réseau.
• Des exercices pratiques pour appliquer ces connaissances.

Pour approfondir vos connaissances, je vous recommande de :

• Pratiquer régulièrement avec Wireshark et Scapy.
• Explorer les RFC (Request for Comments) pour comprendre les protocoles en détail.
• Expérimenter avec des captures réseau dans différents environnements (domestique, professionnel).
• Lire des livres ou suivre des cours en ligne sur les réseaux (ex: cours sur Udemy, Coursera, ou les MOOC du CNAM).

Ressources Supplémentaires