Aller au contenu
Encyclopédie informatique Édition 2026

Le dépassement de tampon

Partie 3 sur 4

Niveau de lecture :

5Les protections du compilateur et du système

CINQ COUCHES DE DÉFENSE, DE LA CAUSE AUX CONSÉQUENCES 1. Le code vérifier les tailles, langage à mémoire sûre supprime la cause 2. Le compilateur canari, options de durcissement, alertes détecte l’écrasement 3. Le système pile non exécutable, adresses aléatoires complique l’exploitation 4. L’isolation droits minimaux, bac à sable, segmentation limite les dégâts 5. Le suivi correctifs, veille, journaux, détection réduit la durée d’exposition Aucune couche ne suffit seule : c’est leur empilement qui protège.
Figure 2. La défense en profondeur : chaque couche rattrape ce que la précédente laisse passer.

Même avec du bon code, une erreur peut subsister. C’est pourquoi les systèmes modernes ajoutent des protections qui, sans supprimer l’erreur, rendent son exploitation beaucoup plus difficile ou plus coûteuse. Aucune ne suffit seule ; leur empilement s’appelle la défense en profondeur (figure 2). Voici les principales, expliquées sans détails d’exploitation.

5.1Le canari : un témoin contre l’écrasement

Le nom vient des canaris que les mineurs emportaient autrefois pour détecter le gaz. À la compilation, le compilateur insère, entre les variables locales et l’adresse de retour, une valeur de contrôle choisie au hasard à chaque lancement du programme. Avant de quitter la fonction, le programme vérifie que cette valeur n’a pas changé. Si elle a changé, c’est qu’une écriture a débordé : le programme s’arrête aussitôt au lieu de continuer avec une adresse de retour douteuse. Cette protection transforme une prise de contrôle possible en plantage. Elle se demande au compilateur par une option (pour GCC et Clang, deux compilateurs très répandus, -fstack-protector-strong) et est activée par défaut dans de nombreuses distributions. Elle ne protège que certains cas (écrasement continu de la pile) et peut être contournée dans des conditions particulières, d’où la nécessité des autres couches.

5.2La pile non exécutable (NX, DEP)

Pour qu’un programme exécute des instructions déposées dans une zone de données, il faut que le processeur accepte d’exécuter ce qui se trouve dans cette zone. Depuis les années 2000, les processeurs permettent de marquer chaque zone de mémoire comme exécutable ou non. Le système marque les zones de données (pile, tas) comme non exécutables : le processeur refuse alors d’y exécuter quoi que ce soit. Cette protection s’appelle NX (No eXecute) pour le matériel, DEP (Data Execution Prevention) sous Windows, ou W^X (« écriture ou exécution, jamais les deux ») sur d’autres systèmes. Elle rend inutile l’idée simple de l’ancien temps, qui consistait à placer des instructions dans le tampon lui-même.

5.3Les adresses aléatoires (ASLR)

Beaucoup d’astuces supposent de connaître à l’avance l’adresse exacte de telle ou telle zone de mémoire. L’ASLR (Address Space Layout Randomization, « mélange de la disposition de l’espace d’adresses ») place la pile, le tas et les bibliothèques à des endroits différents à chaque lancement du programme. Celui qui prépare une attaque doit donc deviner ces adresses, ce qui échoue la plupart du temps et fait planter le programme à chaque essai (un plantage répété est d’ailleurs un signal détectable). Pour que la protection soit complète, le programme doit lui-même être compilé de façon à pouvoir être placé n’importe où (option appelée PIE, pour « exécutable indépendant de sa position »).

5.4La protection du flot d’exécution

Les attaques modernes détournent le programme sans y injecter de code : elles enchaînent des morceaux de code déjà présents dans la mémoire. Les parades visent donc le chemin que prend l’exécution :

  • la pile fantôme (shadow stack) : le processeur garde une copie protégée des adresses de retour et vérifie, à chaque retour de fonction, que l’adresse n’a pas changé. Elle existe sur les processeurs récents (par exemple la technologie CET d’Intel) et dans les systèmes qui la gèrent.
  • l’intégrité du flot de contrôle (CFI) : le compilateur ajoute des vérifications pour que les sauts du programme n’aillent que vers des destinations légitimes.
  • sur les processeurs ARM (téléphones, ordinateurs récents d’Apple), l’authentification des pointeurs (PAC) : les adresses sont signées par le processeur, et une adresse altérée est refusée.

5.5Les protections de la mémoire elle-même

Une autre voie consiste à rendre les dépassements détectables par le matériel. Le marquage de la mémoire (MTE, sur certains processeurs ARM) attache une petite étiquette à chaque bloc de mémoire et à chaque pointeur qui lui est destiné : si un programme sort de son bloc, les étiquettes ne correspondent plus et le processeur signale l’erreur. Des architectures expérimentales, comme CHERI, vont plus loin en associant à chaque pointeur ses limites autorisées. Ces techniques arrivent progressivement dans les produits.

5.6Limiter les dégâts : l’isolation

Dernier rempart, valable même si tout le reste a cédé : que le programme compromis n’ait pas les moyens de faire grand-chose. Cela passe par le principe du moindre privilège (le service n’a que les droits dont il a besoin, et pas ceux de l’administrateur), par les bacs à sable (zones isolées où tournent les parties les plus exposées d’un programme, par exemple l’analyse d’un document dans un navigateur) et par la segmentation du réseau. Un dépassement dans un service qui s’exécute avec des droits minimaux et sans accès au reste du réseau a des conséquences limitées.

Pour s’exercer

Exercice 5 : comprendre Heartbleed

Un service de chiffrement reçoit un petit message et une valeur qui indique sa longueur, puis renvoie autant d’octets que cette valeur le dit, sans vérifier qu’elle correspond à la longueur réelle du message reçu. Quelle erreur est-ce ? Quelles actions conseiller après sa découverte ?

Voir la réponse

C’est une lecture hors limites : le service lit au-delà du message et renvoie des octets de mémoire voisine, qui peuvent contenir des mots de passe, des clés ou des données d’autres utilisateurs. La correction du code consiste à comparer la longueur annoncée à la longueur réelle et à rejeter le message si elle diffère. Pour les victimes : appliquer le correctif, puis considérer que les secrets du serveur ont pu fuir : changer les clés et certificats (révocation de l’ancien), inviter les utilisateurs à changer leurs mots de passe, et examiner les journaux.

Exercice 6 : un avis de sécurité sur un service que vous exploitez

Un éditeur publie un avis : un service réseau que vous utilisez est vulnérable à un dépassement de tampon exploitable à distance, un correctif est disponible. Dans quel ordre agissez-vous ?

Voir la réponse

(1) Vérifier si vous êtes concerné (inventaire : version, exposition à Internet). (2) Évaluer l’urgence : service exposé, exploitation connue, importance du service. (3) Appliquer le correctif en priorité sur les systèmes exposés, après un test rapide ; en parallèle, limiter l’exposition si le correctif ne peut pas être appliqué tout de suite (restriction d’adresses, désactivation de la fonction, filtre). (4) Surveiller les journaux avant et après l’application, à la recherche de plantages ou de comportements anormaux, car la faille a pu être utilisée avant le correctif. (5) Documenter, et, en cas de doute sur une compromission, déclencher le plan de réponse aux incidents. Un correctif non appliqué est la cause la plus fréquente des incidents.

6Écrire sans l’erreur : langages sûrs et outils de détection

6.1Les langages à mémoire sûre

La meilleure parade est de rendre l’erreur impossible. Beaucoup de langages le font : Java, C#, Python, Go, Swift, JavaScript vérifient les limites des tableaux à chaque accès et gèrent eux-mêmes la libération de la mémoire. Une tentative d’écrire en dehors d’un tableau y déclenche une erreur contrôlée, pas une corruption silencieuse. Le langage Rust (voir l’article sur Rust) obtient les mêmes garanties sans ramasse-miettes et avec des performances proches de celles du C, en faisant vérifier les règles d’accès à la mémoire par le compilateur avant l’exécution. Cela explique que ces langages entrent dans le noyau de Linux, dans Android et dans les navigateurs. Ils ne suppriment pas tous les défauts (une erreur de logique reste possible, et les parties dites « non sûres » existent), mais ils font disparaître la famille entière des dépassements de tampon.

Les chiffres du secteur sont parlants : Microsoft estime qu’environ 70 % des vulnérabilités qui reçoivent un identifiant officiel (CVE) chaque année chez lui sont des erreurs de sûreté de la mémoire, et l’équipe de Chromium aboutit au même ordre de grandeur pour ses failles graves. En février 2024, la Maison-Blanche a publié un rapport recommandant aux développeurs d’adopter des langages à mémoire sûre, et l’agence américaine de cybersécurité (la CISA) demande aux éditeurs de publier une feuille de route sur ce sujet. Il n’est pas réaliste de réécrire tout le code existant : la tendance est d’écrire en langage sûr les nouveaux composants et les parties les plus exposées, tout en renforçant l’ancien code.

6.2Trouver les erreurs avant les attaquants

  • L’analyse statique : un outil lit le code sans l’exécuter et repère les motifs dangereux (copie sans limite, calcul de taille douteux).
  • Les assainisseurs (sanitizers) : lors des tests, le compilateur ajoute des vérifications qui arrêtent le programme au premier accès hors limites et indiquent la ligne fautive. L’outil le plus connu s’appelle AddressSanitizer.
  • Le fuzzing (en français, « test à données aléatoires ») : un programme fournit à l’application des millions d’entrées malformées ou aléatoires pour la faire planter. Chaque plantage révèle une erreur à corriger. Des projets comme OSS-Fuzz de Google font tourner ces tests en continu sur de nombreux logiciels libres. Un test de ce type relève de la qualité du code lorsqu’il est mené par les équipes qui maintiennent le logiciel, sur leurs propres versions.
  • La revue de code et les listes de contrôle : relire avec la question « où sont les tailles, et qui les vérifie ? ».
  • Les tests de sécurité menés par des auditeurs, dans un cadre convenu (voir l’audit de sécurité).

Pour s’exercer

Exercice 7 : la politique d’une équipe qui écrit du C++

Une équipe développe un programme en C++ qui lit des fichiers venant de clients. Proposez six mesures, en commençant par la plus efficace.

Voir la réponse

(1) Écrire les nouveaux composants d’analyse de fichiers dans un langage à mémoire sûre quand c’est possible, ou au moins utiliser les types sûrs du C++ (chaînes et tableaux dynamiques, accès contrôlés) et interdire les fonctions de copie sans limite. (2) Valider la longueur et le format de chaque champ avant de l’utiliser, et vérifier les calculs de taille. (3) Compiler avec toutes les protections (canari, intégrité du flot, adresses aléatoires) et traiter les avertissements comme des erreurs. (4) Intégrer à la chaîne de tests l’analyse statique, un assainisseur de mémoire et du fuzzing sur l’analyseur de fichiers. (5) Faire relire par une autre personne tout code qui manipule des tailles. (6) Exécuter l’analyseur avec des droits minimaux, dans un bac à sable, et prévoir un processus de mise à jour rapide pour les clients.