Pointeurs et gestion de la mémoire
Partie 3 sur 3
5Les erreurs classiques
La figure 3 en dresse la liste. Aucune n’est exotique : elles apparaissent dans des programmes écrits par des professionnels expérimentés, parce que le compilateur ne les voit pas toujours.
5.1Le dépassement de tampon
Un tampon (buffer) est une zone de mémoire de taille fixe qui reçoit des données, par exemple un tableau de 16 caractères pour un nom. Si le programme y copie plus de données qu’il n’en peut contenir, l’excédent écrase la mémoire voisine : d’autres variables, ou des informations de contrôle du programme (par exemple l’adresse où il doit reprendre après une fonction). Selon ce qui est écrasé, le résultat va d’un plantage à la prise de contrôle du programme par celui qui a fourni les données. C’est le dépassement de tampon, étudié aussi pour les tableaux (voir les tableaux). Il est évité par des copies bornées, par le contrôle des longueurs et, mieux, par des langages qui vérifient les limites.
5.2La lecture hors limites
L’inverse est tout aussi grave : lire au-delà de la zone prévue. Le programme ne plante pas ; il renvoie des données qui ne devraient pas sortir (clés, mots de passe, contenus d’autres utilisateurs). C’est la faille « Heartbleed » de 2014 (voir l’anecdote), qui faisait lire à un serveur bien plus de mémoire que demandé.
5.3L’utilisation après libération
Après free, le bloc est rendu au système, qui peut le redonner à autre chose. Un pointeur qui conserve l’ancienne adresse est un pointeur pendant (dangling pointer). L’utiliser (use after free) lit ou écrit une mémoire qui appartient désormais à une autre partie du programme. Les attaquants savent exploiter cette erreur en provoquant exactement ce partage. La parade : mettre le pointeur à NULL juste après free, et surtout ne pas conserver plusieurs pointeurs vers un bloc sans savoir qui est responsable de le rendre.
5.4La double libération
Rendre deux fois le même bloc (double free) corrompt les données internes du gestionnaire de mémoire et peut, là aussi, être exploité. Mettre le pointeur à NULL après libération aide, car free(NULL) est permis et ne fait rien ; mais la vraie parade est de n’avoir qu’un seul propriétaire par bloc.
5.5La fuite de mémoire
Si l’on perd la dernière adresse d’un bloc sans l’avoir rendu, il ne pourra plus jamais l’être : c’est une fuite de mémoire. Un programme court ne s’en aperçoit pas ; un service qui tourne des semaines grossit peu à peu jusqu’à épuiser la mémoire de la machine. Des outils les repèrent (voir partie 6).
5.6Le pointeur non initialisé et le déréférencement de NULL
Utiliser un pointeur sans valeur (partie 2.2) ou déréférencer NULL est la plus simple des erreurs, mais fréquente. Sur un système moderne, déréférencer NULL arrête le programme proprement : c’est un plantage, pas une faille, ce qui est déjà un progrès. La parade est de contrôler les pointeurs avant usage quand ils peuvent être vides.
Pour s’exercer
Exercice 4 : fuite ou pas ?
Dans une boucle de 1 000 000 d’itérations, un programme fait char *s = malloc(100); puis utilise s, sans jamais appeler free. Combien de mémoire est perdue et que faire ?
Voir la réponse
Chaque itération réserve 100 octets sans les rendre, et perd l’adresse à l’itération suivante : 1 000 000 × 100 = 100 000 000 octets, soit environ 100 mégaoctets de fuite (un peu plus, car le gestionnaire ajoute une petite marge à chaque bloc). Il faut appeler free(s) à la fin de chaque itération, ou réserver le bloc une seule fois avant la boucle. Un outil comme Valgrind ou AddressSanitizer aurait signalé la fuite.
Exercice 5 : double libération
Pourquoi ce code est-il dangereux, et comment le rendre plus sûr ? free(p); /* ... */ free(p);
Voir la réponse
Le même bloc est rendu deux fois : le gestionnaire de mémoire peut être corrompu, ce qui provoque un plantage ou une faille. Pour limiter le risque, on écrit free(p); p = NULL; : un second free(p) ne fait alors rien. Mieux, on organise le code pour qu’un seul endroit soit responsable de rendre le bloc, ou l’on emploie un pointeur intelligent.
Exercice 6 : référence ou pointeur ?
En C++, pour chacun des cas, choisissez une référence ou un pointeur : (a) une fonction qui doit modifier un entier fourni obligatoirement ; (b) une fonction qui accepte « pas de valeur » pour un paramètre facultatif ; (c) une variable qui doit viser tantôt un objet, tantôt un autre.
Voir la réponse
(a) une référence : elle ne peut être ni nulle ni redirigée, et l’appel s’écrit simplement. (b) un pointeur : il peut valoir nullptr pour signaler l’absence de valeur. (c) un pointeur : une référence ne peut pas changer de cible une fois initialisée.
6Se protéger : outils et langages
6.1Les outils de détection
- Le compilateur lui-même, avec les avertissements activés (
-Wall -Wextrapour GCC et Clang, voir la compilation), repère beaucoup d’erreurs courantes. - Les assainisseurs (sanitizers), dont AddressSanitizer, ajoutent au programme des contrôles pendant l’exécution de test : ils signalent un dépassement, une utilisation après libération, une fuite, avec la ligne de code en cause.
- Des outils comme Valgrind exécutent le programme sous surveillance et signalent les accès mémoire invalides et les fuites, sans avoir à le recompiler.
- Les tests par données aléatoires (fuzzing) bombardent le programme d’entrées inattendues pour provoquer des erreurs.
Ces outils sont réservés aux tests : ils ralentissent l’exécution, mais ils transforment des erreurs silencieuses en erreurs franches.
6.2C++ moderne : la mémoire liée à la vie des objets
Le C++ moderne s’appuie sur une idée appelée RAII (Resource Acquisition Is Initialization, « l’acquisition d’une ressource est une initialisation ») : on lie la durée de vie d’une ressource à celle d’un objet local, de sorte que la ressource est rendue automatiquement quand l’objet disparaît. Les pointeurs intelligents en sont l’application :
std::unique_ptr: un seul propriétaire ; le bloc est rendu quand ce propriétaire disparaît ; impossible de le copier par erreur.std::shared_ptr: plusieurs propriétaires ; un compteur retient combien ils sont, et le bloc est rendu quand le dernier disparaît.- Les conteneurs comme
std::vectoretstd::stringgèrent eux-mêmes leur mémoire.
#include <memory> auto notes = std::make_unique<int[]>(100); // rendu automatiquement notes[0] = 12;
Écrire new et delete à la main est devenu l’exception en C++ récent (voir le langage C++).
6.3Les langages à mémoire gérée
Python, Java, C# ou JavaScript n’exposent ni adresses ni free. Un programme appelé ramasse-miettes (garbage collector) retrouve les blocs que plus rien n’utilise et les rend. Cela supprime les fuites ordinaires, la double libération et l’utilisation après libération. Le prix : un peu de mémoire en plus, des pauses parfois imprévisibles, et moins de maîtrise de la disposition en mémoire.
6.4Rust : des règles vérifiées à la compilation
Le langage Rust (voir le langage Rust) choisit une troisième voie, sans ramasse-miettes : le compilateur impose des règles de propriété et d’emprunt. Chaque donnée a un propriétaire unique ; on peut la prêter en lecture à plusieurs, ou en écriture à un seul à la fois ; la donnée est rendue quand son propriétaire disparaît. Un programme qui violerait ces règles ne se compile pas : les erreurs des parties 5.3 et 5.4 deviennent impossibles dans la partie « sûre » du langage. Rust permet aussi de marquer des zones unsafe, où le programmeur reprend la responsabilité : c’est là que se concentrent les rares erreurs restantes.
Pour s’exercer
Exercice 7 : choisir un langage
Une équipe doit écrire un service qui lit des fichiers envoyés par des inconnus sur Internet. Elle hésite entre C, C++ et un langage à mémoire gérée ou Rust. Que lui conseillez-vous, et à quelle condition le C reste défendable ?
Voir la réponse
Un service qui traite des données non fiables est exactement le cas où les erreurs de mémoire sont exploitées. On conseillera un langage à mémoire gérée ou Rust, qui suppriment la plupart de ces erreurs. Le C ou le C++ restent défendables si des contraintes précises l’imposent (matériel, performances, bibliothèque existante), à condition de compenser : pointeurs intelligents et conteneurs en C++, copies bornées, assainisseurs et tests aléatoires en continu, revue de code ciblée, et isolation du service avec des droits minimaux.
7Pourquoi cela compte pour la sécurité
Ces erreurs de mémoire ne sont pas une curiosité de programmeurs. Elles sont, depuis des décennies, l’une des causes principales de failles graves. Plusieurs grands éditeurs ont publié des mesures : Microsoft, puis le projet Chromium de Google, ont rapporté qu’environ 70 % des vulnérabilités de sécurité qu’ils corrigeaient avaient pour origine un problème de sécurité mémoire. Cette proportion est devenue l’argument central de la transition vers des langages plus sûrs.
Les résultats d’Android en donnent une illustration concrète : en 2025, Google a annoncé que la part des vulnérabilités de mémoire dans Android était passée sous 20 % du total pour la première fois, après une politique de nouveau code écrit en Rust ; le nombre absolu est passé de 223 en 2019 à moins de 50 en 2024, d’après son annonce. Google indique aussi une densité de vulnérabilités réduite d’un facteur mille dans le code Rust par rapport au code C et C++ d’Android. Même dans ce code, des erreurs subsistent quand on emploie unsafe, mais elles sont bien plus rares et mieux circonscrites.
Les pouvoirs publics s’y intéressent. Aux États-Unis, la Maison-Blanche a publié en février 2024 un rapport appelant à passer à des langages à sécurité mémoire, et l’agence de cybersécurité (CISA) a demandé aux éditeurs de publier une feuille de route vers la sécurité mémoire. En Europe, le règlement sur la cyber-résilience (Cyber Resilience Act) pousse les éditeurs à réduire les failles dès la conception. Il ne s’agit pas de réécrire tout le code existant, ce qui serait irréaliste, mais d’écrire le nouveau code dans des langages sûrs, d’entourer l’ancien d’outils de contrôle et de corriger vite les failles découvertes (voir les vulnérabilités).
Pour un apprenti programmeur, la conclusion pratique est double. Comprendre les pointeurs reste indispensable : pour lire du code existant, pour travailler avec le matériel, pour comprendre pourquoi un autre langage fait ce qu’il fait. Mais choisir, quand on le peut, un langage ou des outils qui contrôlent la mémoire à votre place est une bonne mesure de sécurité, pas un manque de courage.