---
title: "Réseaux et Protocole: couche réseau"
date: 2024-02-21
tags: ["OSI", "reseau", "control plane", "data plane"]
categories: ["Réseaux et protocoles", "Cours"]
mathjax: true
---

Le but de cette partie et de comprendre ce qui se passe dans la couche réseaux
matérialisée la quasi-totalité du temps par le **protocole IP**. Comme pour les
autres couches vue jusqu'à présent, il est encore question **d'encapsulation**
et de **décapsulation**.

C'est la couche qui se trouve dans les équipements *Internet* pour faire du
**routage**: le *routeur* examine les entêtes des *paquets IP* afin de
déterminer leur destination. Deux notions apparaissent alors:

 * le **forwarding** qui consiste à récupérer les paquets sur une *interface* et
   les renvoyer vers une autre;
 * le **routage** qui consiste à déterminer la route de la source vers la
   destination (le chemin complet donc).

Dans ce chapitre nous aborderons les notions de **data plane**, **control plan**
ou encore de **software defined network** (*SDN*).

## Le *data plane*

C'est la partie responsable du mouvement "réel" des données à travers les
périphériques réseaux. La logique de routage est implémenter dans chacun des 
périphérique composant le réseau.

### Les routeurs

Pierre angulaire de l'acheminement des paquets. ils prenne des pacquets sur des
interfaces en entrée qu'il redirigent vers des interfaces en corties en fonction
de critères établis. En définitive chaque routeur est indépendant et composé
d'un *data plane* et d'un *control plane* contenant la **table de routage**.

Pour schématiser, le *control plane* représente le logiciel et le *data plane*
le matériel.

### Switch fabric

Le *data plane* se compose des ports en entrée et en sortie, au milieu se
trouve la **switch fabric**. C'est cette partie qui est charger d'acheminer les
paquets des entrées vers les sorties en fonction de ce que le *control plane*
veut. Le temps de traitement d'un *datagramme* est de l'ordre de la nanoseconde
[^traitement].


[^traitement]: là ou pour le *control plane* c'est de l'ordre de la
    milliseconde. Chaque routeur est aussi responsable de son algorithme de
    routage.

#### ports d'entrée


Ils reçoivent les *trames* de la couche liaison. Les entêtes de la couche
reseaux sont extraites. Deux traitements sont alors possibles:

 * forwarding basé sur **la destination** basé uniquement sur l'adresse de
   destination;
 * forwarding **généralisé** basé sur les valeurs de l'entête (une, quelques 
 unes ou toutes).

 Pour les correspondances sur les adresses, la règle du *longuest prefix match*
 s'applique. La correspondance se fait sur le prefixe le plus détaillé.

Le *switching rate* est donné par le rapport entre le nombre de paquet en entrée
et en sorties. Idéaliement il est de 1 ou plus, ce qui signifie que les 
*datagrammes* en entrée sont traités directement. si ce nombre est inférieur à 1
alors il y a engorgement à l'entrée. Dans ce cas les paquets sont mis en file
d'attente dans un *buffer* (à l'entrée).

Il peuvent l'être aussi si les paquets reste bloqués pour diverses raison comme
par exemple un  *buffer* de sortie plein.

En cas de remplissage du *buffer* alors des **paquets peuvent être perdus**.

#### ports de sortie

Ils reçoivent les *datagrammes* en provenance de la *switch fabric* et les
acheminent vers leur destination. Là encore nous avons un *buffer** où les
paquets en attente sont stocké par exemple si les paquets arrivent plus vite que
le lien ne peut les transmettre.

Ici encore des paquets pevent être perdus en cas de **buffer overflow**.

Les paquets évincés dépendent alors de la stratégie définie :

 * `tail drop` pour refuser les nouveaux datagrammes qui arrivent;
 * `priority`  pour supprimer des datagrammes en fonction des priorités.

#### Ordonnancement

Il est possible de définir l'ordonnancement des datagrammes et ainsi d;organiser
une stratégie de priorisation en fonction des besoins. Le plus simple reste
*FIFO* pour *First In First Out*[^FCFS] où ils sont acheminés en fonction de
leur ordre d'arrivé.

Il est aussi possible d'ordonnancer suivant la priorité, par *round-robbin*, par
poids attribués aux paquets ...

[^FCFS]: aussi appelle *First Come First Serve*.

### Le protocole IP

C'est un ensemble de règle définissant:

 * un format de *datagrammes*;
 * l'adressage;
 * les conventions d'action sur les paquets;
 * le protocole ICMP (report d'erreur et signalement de routeurs);
 * les algorithme de sélection de chemins pour router les paquets (BGP, OSPF).

L'entête d'un datagramme IP fait 20 octets pour sa version v4, elle se compose:

 * *version* du protocole (4 bits);
 * *longueur de l'entête* -- nombre de mots de 32 bits -- par défaut 5 (4 bits);
 * *type de services* (8bits);
 * *longueur totale du datagramme* en octets (16 bits);
 * données utilisé pour la fragmentation :
   * *identifiant* ( 16 bits);
   * *drapeau* (4 bits);
   * *décallage*  (12 bits);
 * adresse *source* (32 bits);
 * adresse *destination* (32 bits);
 * *options* si besoin (32 bits);

#### L'adresse IP

C'est un identifiant codé sur 32 bits et attribué à chacune des interface des
hôtes connectés au réseau. Une *interface* représente une connexion entre un
hôte (ou un routeur) et un lien physique (issu de la couche liaison que nous
verrons plus tard)

Il existe deux façons de classifier les adresse IP:

 * L'adressage par classes représenté par des classes d'adresses allant de *A* à
   *E* en fonction des préfixes (1.0.0.0 - 126.255.255.255 pour la classe A par
   exemple);
 * *CIDR* pour *Classless Inter Domain Routing* ou les sous-réseaux peuvent
   avoir des adresses d'une taille arbitraire.

Dasn le second cas, les adresses sont découpés entre le préfixe de sous-réseau
et la part réserver aux hôtes, par exemple

```text
192.168.23.0/23
```

Il existe aussi les adresses publiques et privées (utilisable dans un réseaux
local). Pour ces dernière 3 classes sont disponibles:

 * 10.0.0.0/8
 * 172.16.0.0/12
 * 192.168.0.0/16

##### le sous-réseau

Nous avons parlé de sous-réseaux, c'est la portion d'un réseau ou les hôtes
peuvent se contacter les uns les autres sans que les datagrammes passent par
un routeur. Ainsi chaque portion isolée d'un réseau est un sous-réseau. NMous
pouvons alors créer des "îles".


#### Obtenir une adresse IP

Plusieurs moyens sont à la disponision des administrateurs réseaux afin
d'assigner une adresse IP à une interface.

 * Adresse codée directement "en dur" sur l'interface via, par exemple, le
   fichier `/etc/network/interfaces`.
 * Assignée dynamiquement par un serveur *DHCP* *Dynamic Host Configuration 
   Protocol*.

Pour ce dernier, voici les étapes:

 1. l'hôte envoie un message de *broadcast* de type `DHCP discover`;
 2. les serveurs *DHCP* disponibles répondent avec le message `DHCP Offer` et 
    fait une proposition;
 3. l'hôte répond avec avec un message `DHCP request` au serveur qu'il a retennu
    avec comme charge utile l'adresse IP qui lui a été proposée;
 4. le serveur retenu répond alors avec un message `DHCP ack`.

Le DHCP fait bien plus qu'assigner des adresses IP, il peut aussi définit
l'adresse de la passerelle (routeur de premier niveau), les adresses des
serveurs de nom, le masque de réseau etc.

### NAT, *Network Address Translation*

Il est question ici de *"partager"* une adresse IP **publique**. L'agent
responsable de la translation d'adresse. Il est question de remplacer le port et
l'adresse IP source. Notre agent responsable -- équipement effectuant la
translation -- une table de translation est disponible afin de connaitre l'état
des connexions en cours.

Le NAT n'est utile que pour l'IP v4 dont les adresses routables sont au bord de
l'epuisement. Il est utilisé intensivement pour les connexions domestiques et
les réseaux cellulaires. Cependant les problèmes de pénurie ont leur solution:
IPV6.

Problème supplémentaire, c'est le routeur qui se charge de faire le *NAT*,
cependant il ne ddevrai pas aller farfouller dans la couche 4 du modèle OSI et
se cantonner **sa couche 3**. 

### Forwarding généralisé (SDN)

Chaque routeur contient une **table de forwarding**. Lors du forwarding
généralisé, la correspondance ne se fait pas seulement sur l'adresse de
destination mais sur l'ensemble de l'entête. Le routeur utilise alors la
correspondance (*match*), les *actions* et la *priorité*.

 * Les *match* se font sur les couches *lien*, *réseau* et * transport.
 * Les actions possibles sur les paquets sont *drop*, *copy*, *modify* et *log*.
 * Les priorité afin de savoir *quoi faire* lorsque plusieurs *match* arrivent.
 * Enfin, les couteurs sont là afin d'acoir des metriques sur *les bits* et les
   *paquets* qui passent.

Le principe du SDN est d'unifier **routage**, **pare-feu**, **NAT**,
**switching** en allant chercher dans toutes les entêtes de ces couches.

## Control plane

Comme nous l'avons vu au début de cette partie, le **control plane** est
responsable du routage : il détermine le chemin pris par les paquets. Deux
possibilités s'offre alors à nous:

 1. un *control plane* dans chaque routeur (ce que nous avons jusqu'ici);
 2. un *control plane* centralisé qui pilote un ensemble de routeurs.

Dans le premier cas il est nécessaire d'implémenter le routage par équipement
individuellement, ce qui peut vite se réveller fastidieux. Dans le second cas,
les routeurs utilisent un control place distant définis par logiciel. ainsi la
configuration de tous les routeurs **est unifiée**.

Pour rappel, le routage a pour objectif de déterminer le meilleur chemin à
prendre pour un paquet donné. Le chemin est en fait un ensemble de routeur par
lequel le paquet va passer. Le meilleur chemin peut avoir plusieurs sens,
parlons nous de *moins cher*, de *plus rapide*, *moins congestionné*?

### Algorithme de routage

Il existe bien évidemment plusieurs algorithme de routage avec chacuns
avantages et inconvénients par exemple :

 * *statique*, les routes changent peu et lentement
 * *dynamique*, les routes changent rapidement soit périodiquement soit en
   réponse à des incidents;
 * algorithme *link-state* ou chaque routeur voit la topologie complète avec les
   coûts des différents liens;
 * algorithme décentralisé *distant vector* ou les routeurs ne connaissent au
   départ que les coûts des liens vers leurs voisins directs. C'est un
   algorithme dynamique basé sur le calcul, et l'échange d'informations entre
   routeurs voisins.


#### Algorithme de Dijkstra

C'est un algorithme centralisé ou les coûts vers tous les nœuds sont connus à
l'avance via des messages de type `link-state broadcast`. Tous les nœuds
détiennent **les mêmes informations**.

Avec ces informations, nous pouvons alors calculer les chemins les *moins 
chers*" depuis un nœud vers tous les autres. Nous obtenons alors une table de
*forwarding* complète.

Le processus est **itératif*, ainsi après un nombre \\(K\\) d'itérations., nous
connaissons le meilleurs chemin vers \\(k\\) destinations. Voici cet algorithme:

```
// c(x,y) coût entre lien direct entre x et y
// D[v]   estimation du coût du meilleur chemin vers v depuis la source
// p(v)   nœud précédent sur le chemin de la source vers v
// N``    ensemble de nœuds que notre algorithme connais via least-cost path

/* Init */
N` = u; //compute least-cost path from u to all others nodes}
for all_node v 
    if v in all_node()
        D[v] = c(u,v);
    else 
        D[v] = INFINITE;

do 
    find w not_in N` such D[w] is minimal
    add w to N`
    update D[v] for all v adjacent tow and not in N`:
        D[v] = min(D[v], D[w] + c(w,v))
until all node in N`
```

#### Algorithme de Bellman-Ford

Chaque nœud envoie régulièrement sa table de vecteur de distance et leurs coûts
associés à ses voisins. Lorsque notre nœud reçoit les information de ses
voisins, il mets à jour sa propre table de vecteurs de distances en réalisant
des calculs. C'est un algorithme asynchrone, itératif et sans notification de
l'extérieur.

### Routage intra-ISP: OSPF

Pour l'instant, tout ce que nous avons vu relève du **monde idéal** et ne passe
pas à l'échelle pour *Internet*:

 * tout le réseau est **identique**;
 * le réseau est "**plat**".

Dans la vrai vie l existe des **milliards** de destinations et tout un tas de
**réseaux autonomes**. Il est donc impossible de stocker toutes ces information
dans une sable de routage ni de gérer de façon unifiés tout ce beau monde. Il
est donc nécessaire d'agréger des régions appelées **systèmes autonomes** abrégé
*AS*. nous avons alors deux types de routages:

 * **intra-AS** ou *intra-domaine* pour tout ce qui se trouve dans notre système
   autonome, le protocole utilisé est forcément le même sur tous les routeurs de
   notre domaine
 * **inter-AS** ou *inter-domaine* qui représentens les liens entre différents
   *AS*

Les liens entre les *AS* sont réalisés par les routeurs de bordures.

#### Protocoles intra-AS

Les protocoles les plus communs sont:

 * **RIP** pour *Routing Information Protocol*, les routeurs échange des
   *distant vectors* classique toutes les 30 secondes -- n'est plus utilisé
   aujourd'hui;
 * **EIGRP** pour *Enhanced Interior Gateway Procolol* qui est lui aussi basé
   sur les *distant vectors*, c'est à l'origine un protocole propriétaire de
   Cisco mais ouvert en 2013;
 * **OSPF** pour *Open Short Path First* qui est un protocole de type
   *link-state*

Dans le cadre de ce cours nous ne verrons qu'*OSPF* qui est le plus utilisé
aujourd'hui.Chaque routeur annonce l'état de ces liens directement en utilisant
le protocole IP (pas d'encapsulation de segment de la couche transport) à tous
les autre routeur de l'*AS*. Les informations de coûts peuvent provenir de
différentes métriques comme la bande passante, la latence etc.

Au niveau sécurité ds échanges, tous les messages *OSPF* peuvent être
authentifiés.

*OSPF* propose deux niveau de **hiérarchie** :

 * *backbone* interconnectant plusieurs zones;
 * *local area* représentant une zone en particulier, plus localisée.

L'état des liens, comprenant le couple *IP/masque* est enregistré dans une base
de données. Cette ase est ensuite utilisée pour les calculs. La mise à jour se
fait par des messages multicasts `link-state-advertisement`. Plusieurs types de
paquets existent.

 * `hello` pour la découverte des voisins, l'entetien des relations de
   voisinages. Ces paquets sont envoyés toutes les 10 secondes, si aucune de
   reponse n'est effectuées au bouts de 4 `hello`, alors l'hote est considéré
   comme *downn*.
 * `database description` pour synchroniser les bases de données avec ses
   voisins.
 * `link-state-request` pour demander des informations aux voisins.
 * `link-state-advertisement` pour mettre à jour l'état des liens, il en existe
   11 types différents de paquets:
   * type 1: décrire les interfaces du routeur;
   * type 2: décription ds routeur conectés à un segment (dans une même *area
     OSPF);
   * type 3: résumés des information envoyées depuis une autre *area*.
   * etc.
 * `link-state-update` qui contient plusieurs `LSA`
 * `link-state-ack` pour l'acquitement d'un `LSR` ou d'un `LSA`

OSPF est basé sur l'algorithme de Dijkstra: le plus court chemin. Il est calculé
en fonction de la bande passante du lien. 100Mbit/s a un poind de 1, 10Mbit/s un
poid de 10 (100/10) et 1000Mbit/s 0.1 (100/1000). Cependant le poind ne peut
être inférieur à 1, donc 0,1 devient 1. Pour poivoir profiter des poids sur les
liens suppieur à 100Mbit/s, il faut alors **modifier manuellement la valeur de
base**.

#### Protocole inter-AS: BGP

BGP pour *Border Gateway Protocol* annonce l'existance d'un réseau, d'une
destination. Il permet d'obtenir des informations  de routage de ses voisins via
**eBGP**, de déterminer les routes vers les autres réseaux en fonction des
information de disponibilités et des politiques ou encore d'avertir ses voisins
de ses propres réseaux / disponibilités. Par le biais **d'iBGP** il propage les
information obtenues de ses voisins à tous les routeur *intra-domaine*.

*BGP** utilise les sessions établies via TCP pour communiquer. Plusieurs type de
messages sont disponibles:

 * **open** pour ouvrir une connexion TCP vers un  hôte BGP distant et
   s'authentifier;
 * **update** pour avertir de changement que se soit suppression, ajout ou
   modification;
 * **keepalive** pour maintenir la session ouverte;
 * **notification** pour notifier d'une erreur ou fermer une session.

Une annonce contient un *préfixe* plus un *attribut*. Les deux attributs les
plus importants sont:

 * *as-path* qui représente le chemin;
 * *next-hop* qui indique le routeur spécifique pour arriver à une destination
   définie.

BGP utilise des politique de routage pour déterminer les chemins à annoncer.

Principe de la **patate chaude**: BGP choisira de faire sortir le paquet le plus
vite possible de son infrastructure, ne prenant pas en comptes les coûts
intra=domaines


### SDN *Software Defined Network

Depuis 2005, des recherches sont menées afin de trouvwr de nouvelles approches
réseaux. Le *control plane* et le *data plane* se faisaient traditionnellement
sur les routeurs. Maintenant le controle est éloigné et installe à distance les
tables de routages. Ainsi la gestion du réseau est facilitée (configuration en
un seul point, plus de flexibilité, contrôle *openflow* et architcture
indépendate du vendeur --interopérable).

Le *SDN controller* prend alors trois fonctions:
 
 * *interface layer* offrant l'accès aux API;
 * *network state management* prenant en compte les information des liens, du
   *switching;
 * les communication via les API (Openflow, SNMP).

#### le protocole Openflow

Il s'intercate entre les controlleurs et les *switches* et utilise TCP. Il
comporte trois types de messages:

 * `controller` vers les `switch` pour demander des information, envoyer des
   configurations etc.;
 * asynchrone avec par exemple les paquets à traiter par le conrolleurs,
   notifier la suppression d'une entrée dans la *table de forwarding*
 * symetrique

#### ICMP *Internet Control Message Protocol*

C'est un protoboe de contrôle utilisé pour obtenir des informations au niveau du
réseau (*unreachable host|protocol|port*, *ping*). Il s'intercate entre les
couches réseau et transport.