Aller au contenu
Encyclopédie informatique Édition 2026

Pointeurs et gestion de la mémoire

Partie 3 sur 3

Niveau de lecture :

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.

SIX ERREURS CLASSIQUES DE GESTION DE LA MÉMOIRE erreur ce qui se passe parade dépassement de tampon on écrit au-delà de la zone prévue contrôler les tailles, langage sûr lecture hors limites on lit à côté de la zone (Heartbleed) contrôler les indices et longueurs usage après libération on se sert d’un bloc déjà rendu mettre à NULL, outils de test double libération on rend deux fois le même bloc un seul propriétaire par bloc fuite de mémoire on oublie de rendre un bloc outils de mesure, propriété claire pointeur non initialisé il contient une adresse au hasard initialiser à NULL aussitôt Les langages à mémoire gérée (Python, Java, Rust) éliminent la plupart de ces erreurs.
Figure 3. Six erreurs classiques de gestion de la mémoire, leur effet et la parade principale.

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 -Wextra pour 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::vector et std::string gè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.

Sécurité de l’information

Le coin cyber

Cet article décrit les erreurs de mémoire pour apprendre à les éviter. Il ne contient aucune méthode pour les exploiter.

C.1Pourquoi ces erreurs sont des failles

Une erreur de mémoire devient une faille quand elle peut être déclenchée par des données choisies par un tiers : un fichier, un paquet réseau, une saisie sur un site. L’attaquant n’a pas besoin de comprendre tout le programme : il lui suffit qu’une donnée mal contrôlée écrase ou révèle une zone de mémoire. Les défenseurs agissent à trois niveaux : empêcher l’erreur (langages sûrs, contrôles), la détecter avant la livraison (assainisseurs, tests aléatoires, revue) et en limiter les effets (protections du système comme le brouillage des adresses ASLR, des marqueurs de contrôle placés devant les informations sensibles, des droits minimaux pour le programme). Aucune de ces couches n’est suffisante seule.

C.2Le cadre légal

La divulgation responsable d’une faille (prévenir l’éditeur et lui laisser le temps de corriger) est encadrée en France : l’article L2321-4 du code de la défense permet de signaler à l’ANSSI une vulnérabilité découverte, sous conditions. Rechercher des failles sur un système qui ne vous appartient pas, sans accord écrit de son propriétaire, tombe sous les articles 323-1 et suivants du code pénal. Le règlement européen sur la cyber-résilience impose aux fabricants une gestion des vulnérabilités sur toute la vie du produit.

C.3Idée reçue

« Un plantage, ce n’est pas une faille : il suffit de redémarrer. » Faux. Un plantage est souvent le signe visible d’une erreur de mémoire que, dans d’autres circonstances, un attaquant peut rendre silencieuse et exploitable. Le programme qui plante sur un fichier mal formé est celui qui, bien préparé, exécutera du code étranger. Chaque plantage inexpliqué mérite d’être analysé, pas seulement relancé.

C.4Bonnes pratiques

Développeur

  • Initialiser les pointeurs, mettre à NULL après free, contrôler les retours de malloc.
  • Préférer les pointeurs intelligents et les conteneurs, ou un langage à sécurité mémoire pour le nouveau code.
  • Lancer régulièrement les assainisseurs et les tests aléatoires sur ses programmes.

Organisation

  • Se donner une feuille de route de passage aux langages sûrs pour les composants exposés à des données non fiables.
  • Activer les protections du compilateur et du système, et appliquer vite les correctifs des bibliothèques.
  • Mettre en place un processus de réception et de correction des signalements de vulnérabilités.

Référentiels : MITRE, CWE-416 (utilisation après libération), CWE-415 (double libération), CWE-787 (écriture hors limites), CWE-125 (lecture hors limites), CWE-476 (déréférencement de pointeur nul) · ISO/IEC 9899 (langage C) · Règlement (UE) 2024/2847 (Cyber Resilience Act) · Code de la défense, article L2321-4 · Code pénal, articles 323-1 à 323-7.

Références

  1. Brian W. Kernighan, Dennis M. Ritchie, The C Programming Language, Prentice Hall, 2e éd., 1988.
  2. Bjarne Stroustrup, The C++ Programming Language, Addison-Wesley (éditions successives).
  3. Steve Klabnik, Carol Nichols, The Rust Programming Language, No Starch Press.
  4. Office of the National Cyber Director (Maison-Blanche), Back to the Building Blocks: A Path Toward Secure and Measurable Software, février 2024.
  5. Google Security Blog, Rust in Android: move fast and fix things, novembre 2025.
  6. Règlement (UE) 2024/2847 du 23 octobre 2024 (Cyber Resilience Act).

Voir aussi

Citer cet article

« Pointeurs et gestion de la mémoire », Encyclopédie informatique, révision du 4 novembre 2026.