Réseaux et architectures matérielles

L'ordinateur selon le modèle de von Neumann

Processeur, mémoire et bus

Depuis les années 1940, la quasi-totalité des ordinateurs reposent sur le modèle de von Neumann : trois grands blocs, reliés entre eux par des bus.

Le processeur (CPU) exécute les instructions. Il regroupe :

• l'unité de commande (UC), chargée de lire chaque instruction, de la décoder, puis de piloter son exécution ; elle contient le compteur de programme, qui indique l'adresse de la prochaine instruction à traiter, ainsi que le registre d'instruction ;
• l'unité arithmétique et logique (UAL), qui effectue réellement les calculs et comparaisons demandés ;
• des registres, de petites mémoires internes très rapides, utilisées pour stocker temporairement les valeurs manipulées.

La mémoire vive (RAM) conserve, sous forme binaire, aussi bien les données que les instructions du programme en cours d'exécution — c'est précisément ce partage d'une même mémoire entre données et programmes qui caractérise le modèle de von Neumann. Elle est volatile : son contenu disparaît à l'extinction de la machine, à la différence de la mémoire de masse (disque dur, SSD), qui conserve l'information durablement.

Trois bus mettent en relation le processeur et la mémoire : le bus d'adresses transporte l'adresse de la case mémoire à consulter, le bus de données transporte la donnée elle-même, et le bus de contrôle coordonne l'ensemble (signaux de lecture ou d'écriture, synchronisation...).

Exemple. Pour exécuter LOAD R0, 5 puis ADD R0, R1, l'unité de commande va chercher chaque instruction en mémoire grâce au bus d'adresses, la récupère par le bus de données, la décode, puis confie le calcul demandé à l'UAL, qui range le résultat dans le registre R0.

Le système sur puce (SoC)

Un système sur puce (SoC, System on a Chip) regroupe sur une seule puce de silicium un ou plusieurs processeurs, de la mémoire vive, un circuit graphique et des contrôleurs de communication (Wifi, Bluetooth...). En rapprochant ainsi les composants, on réduit la distance — donc les pertes et le temps de communication — et la consommation électrique, mais au prix d'une réparabilité amoindrie : une seule panne impose souvent de remplacer toute la puce. On trouve cette architecture dans la quasi-totalité des smartphones et dans des cartes comme le Raspberry Pi ; son évolution suit la loi de Moore, selon laquelle le nombre de transistors présents sur une puce double environ tous les deux ans.

Le système d'exploitation

Rôle et gestion des fichiers

Le système d'exploitation (Windows, macOS, Linux...) sert d'intermédiaire entre le matériel et les utilisateurs ou les logiciels : il répartit la mémoire, partage le temps processeur, pilote les périphériques et organise les fichiers en une arborescence de répertoires. On désigne un fichier par un chemin absolu, qui part toujours de la racine (/home/eleve/Documents), ou par un chemin relatif, qui part du répertoire courant (../Images remonte au répertoire parent avant de redescendre dans Images).

Sous un système de type Unix, chaque fichier possède des droits d'accès définis pour trois catégories d'utilisateurs — propriétaire, groupe, autres —, combinant lecture (r), écriture (w) et exécution (x). La commande ls -l les affiche sous la forme d'une chaîne de neuf caractères, par exemple rwxr-xr-- (le propriétaire peut tout faire, le groupe lire et exécuter, les autres seulement lire).

Processus, ordonnancement et interblocage

Un processus désigne une instance d'exécution d'un programme à un instant donné : lancer deux fois le même programme crée deux processus distincts, chacun avec son propre espace mémoire. Comme le nombre de processus dépasse presque toujours le nombre de cœurs disponibles, le système d'exploitation les fait alterner entre quatre états :

C'est l'ordonnanceur (scheduler) qui choisit, parmi les processus prêts, lequel élire. La politique du tourniquet (round-robin) est la plus courante pour un usage interactif : chaque processus reçoit un court quantum de temps processeur, et retourne en fin de file d'attente s'il n'a pas terminé, ce qui garantit qu'aucun processus n'attend indéfiniment.

Un interblocage (deadlock) apparaît lorsque plusieurs processus s'attendent mutuellement sans qu'aucun ne puisse progresser. Exemple à deux processus : $P_1$ détient la ressource $R_1$ et réclame $R_2$ ; $P_2$ détient $R_2$ et réclame $R_1$. Chacun attend une ressource détenue par l'autre : ce cycle d'attente bloque définitivement les deux processus.

Capteurs, actionneurs et interface Homme-Machine

Un périphérique d'entrée fournit une information à l'ordinateur : le clavier ou la souris en sont des exemples courants, mais aussi les capteurs, qui mesurent une grandeur physique (température, luminosité, présence...) et la convertissent en donnée numérique exploitable. À l'inverse, un périphérique de sortie reçoit une information de l'ordinateur pour agir sur son environnement ; parmi eux, les actionneurs convertissent une donnée numérique en action physique concrète (faire tourner un moteur, allumer une LED, émettre un son avec un buzzer...).

Une interface Homme-Machine (IHM) regroupe l'ensemble des éléments, matériels et logiciels, qui permettent à un utilisateur d'interagir avec un système informatique. La réaliser par programmation consiste à écrire le code qui réagit à un événement déclencheur — un clic, ou une mesure fournie par un capteur — pour produire en retour une sortie adaptée, souvent selon une boucle répétée acquisition - décision - action :

tant que Vrai:
    valeur = lire_capteur()
    si valeur > seuil:
        activer(actionneur)
    sinon:
        desactiver(actionneur)

Les réseaux informatiques

Postes, commutateurs et routeurs

Un réseau informatique relie plusieurs machines capables d'échanger des données entre elles. On y distingue un poste (toute machine connectée au réseau), un commutateur (switch), qui relie les postes d'un même réseau local et aiguille chaque donnée directement vers son destinataire, et un routeur, qui relie entre eux plusieurs réseaux différents — par exemple un réseau local à Internet. Chaque machine possède une adresse qui l'identifie sur le réseau, un peu comme une adresse postale identifie un destinataire.

Adresses IP et notation CIDR

Sur un réseau IPv4, une adresse IP s'écrit comme quatre nombres séparés par des points (192.168.1.10), et se décompose en une partie réseau et une partie hôte au sein de ce réseau. Le masque de sous-réseau fixe la frontière entre les deux : il précise combien de bits, comptés depuis la gauche de l'adresse, désignent le réseau. On le note souvent en CIDR, sous la forme /n accolée à l'adresse.

Exemple. 192.168.1.0/24 désigne un réseau dont les 24 premiers bits sont fixés (soit les trois premiers nombres, 192.168.1) ; les 8 bits restants numérotent les hôtes de ce réseau, de 192.168.1.0 à 192.168.1.255. La machine 192.168.1.42 appartient donc à ce réseau.

Paquets et encapsulation

Une donnée volumineuse (fichier, page web...) n'est presque jamais transmise en une seule fois : elle est découpée en paquets de taille limitée. Ce découpage permet à plusieurs communications de se partager équitablement le réseau, de ne retransmettre qu'un seul paquet en cas de perte plutôt que la donnée entière, et laisse même la possibilité aux paquets d'une même donnée d'emprunter des chemins différents avant d'être réassemblés à l'arrivée.

Avant d'être émis, chaque paquet reçoit un en-tête, ajouté au début des données et contenant les informations nécessaires à son acheminement (adresse de destination, contrôle d'erreur...) : c'est l'encapsulation. Une donnée traverse en général plusieurs niveaux de traitement successifs, chacun ajoutant son propre en-tête à ce que lui a transmis le niveau précédent, un peu comme des enveloppes empilées les unes dans les autres. À la réception, la machine destinataire effectue l'opération inverse, la désencapsulation, en retirant les en-têtes un par un, dans l'ordre inverse de leur ajout.

Le protocole du bit alterné

Un réseau n'est jamais parfaitement fiable : un paquet, ou son accusé de réception, peut se perdre en chemin. Le protocole du bit alterné permet à un émetteur de s'assurer qu'un paquet a bien été reçu, et de le retransmettre sinon. Chaque paquet envoyé reçoit un bit de séquence, qui alterne entre 0 et 1. Après l'envoi, l'émetteur attend un accusé de réception (noté ACK) portant ce même bit avant d'envoyer le paquet suivant ; faute d'ACK avant l'expiration d'un délai fixé (un timeout), il considère le paquet perdu et le retransmet avec le même bit. De son côté, le récepteur compare le bit du paquet reçu à celui du dernier paquet déjà accepté : si les deux bits coïncident, il s'agit d'une retransmission d'un paquet déjà reçu (l'ACK précédent s'était perdu) ; le récepteur ne le traite pas une seconde fois, mais renvoie tout de même un ACK, pour que l'émetteur puisse progresser.

Le routage entre réseaux

Chaque routeur tient à jour une table de routage, qui associe à chaque réseau de destination la passerelle à utiliser, c'est-à-dire l'adresse du prochain routeur sur le chemin. Une ligne particulière, la route par défaut (notée 0.0.0.0/0), capte tout le trafic qui ne correspond à aucune autre ligne — en général vers Internet. Ces tables peuvent être renseignées à la main par un administrateur, ou mises à jour dynamiquement par un algorithme, indispensable dès que le réseau devient grand.

Deux grandes familles d'algorithmes de routage dynamique coexistent :

• RIP (Routing Information Protocol), qui fonctionne à vecteur de distances : chaque routeur ne connaît que la distance, en nombre de sauts, vers chaque réseau, et échange régulièrement sa table avec ses voisins directs. Sa connaissance du réseau reste locale, et la distance maximale autorisée est de 15 sauts.
• OSPF (Open Shortest Path First), qui fonctionne à état de liens : chaque routeur diffuse l'état de ses propres liaisons à l'ensemble du réseau, si bien que tous finissent par disposer d'une vision globale et identique de la topologie. Chaque routeur y applique alors l'algorithme de Dijkstra pour calculer, depuis lui-même, le chemin le moins coûteux vers chaque destination.

Sécuriser une communication : chiffrement et HTTPS

Chiffrement symétrique et asymétrique

Un chiffrement est dit symétrique lorsqu'une seule et même clé sert à la fois à chiffrer et à déchiffrer un message — c'est le cas du chiffrement de César, ou du standard actuel AES. Ce procédé pose toutefois un problème pratique : il faut transmettre cette clé secrète à son interlocuteur sans qu'elle puisse être interceptée en chemin.

Le chiffrement asymétrique (mis en œuvre par exemple par l'algorithme RSA) répond à ce problème grâce à deux clés distinctes : une clé publique, que l'on peut diffuser librement et qui sert à chiffrer, et une clé privée, gardée secrète par son propriétaire, qui seule permet de déchiffrer. Beaucoup plus coûteux en calcul que le chiffrement symétrique, il n'est pas utilisé pour chiffrer de gros volumes de données, mais pour échanger en toute sécurité une clé symétrique.

Le protocole HTTPS

HTTPS combine les deux approches pour sécuriser la navigation web. Le chiffrement asymétrique ne sert qu'à échanger une clé de session symétrique ; toute la communication qui suit est ensuite chiffrée symétriquement, ce qui est beaucoup plus rapide. Le serveur transmet sa clé publique, accompagnée d'un certificat signé par une autorité de certification, qui garantit que la clé appartient bien au site attendu. Le client vérifie ce certificat, génère une clé de session, la chiffre avec la clé publique du serveur, puis la lui envoie : seul le serveur, grâce à sa clé privée, peut la déchiffrer. C'est la fin de la poignée de main (handshake), après quoi client et serveur échangent leurs données chiffrées symétriquement avec cette clé de session, connue d'eux seuls.

Ce mécanisme hybride répond à deux menaces à la fois : il empêche un tiers de lire les données échangées (elles sont chiffrées), et, grâce au certificat, il empêche un tiers de se faire passer pour le serveur légitime.