Aller au contenu
Encyclopédie informatique Édition 2026

Le dépassement de tampon

Partie 2 sur 4

Niveau de lecture :

3Le mécanisme, sur le principe

Le raisonnement tient en quatre temps. Il décrit pourquoi l’erreur est grave, pas comment s’en servir.

  1. Une zone de taille fixe est réservée pour recevoir une donnée : par exemple un tampon de 16 octets pour un prénom. Un octet est l’unité de base de la mémoire ; il suffit à stocker une lettre.
  2. Le programme copie la donnée reçue dans le tampon, sans comparer sa longueur à celle du tampon. Certaines fonctions de copie, en C, copient jusqu’à ce qu’elles rencontrent une marque de fin, sans jamais demander quelle est la place disponible.
  3. Si la donnée est plus longue que le tampon, l’écriture continue dans les cases suivantes. Elle écrase d’abord les variables voisines, puis les informations de gestion de la fonction, dont l’adresse de retour.
  4. Quand la fonction se termine, le processeur lit l’adresse de retour (maintenant altérée) et s’y rend. Selon ce qu’elle contient, le programme plante (adresse invalide) ou, si une personne a étudié l’organisation de ce programme précis, exécute autre chose que ce qui était prévu.

Le point important est la quatrième étape : la donnée est interprétée comme une instruction de contrôle. On nomme shell l’interpréteur de commandes (le programme qui permet de piloter une machine en tapant des ordres) et shellcode le petit programme qu’un attaquant cherche à faire exécuter pour l’ouvrir. Ces mots sont utiles pour lire la presse spécialisée ; nous n’en décrivons pas la fabrication. Un programme confond ainsi ce qu’on lui donne à traiter (de simples données) et ce qui commande son déroulement (les adresses où il va). C’est la même famille d’erreur que l’injection de commandes dans une base de données (l’injection SQL), où une donnée saisie est prise pour une commande.

3.1Pourquoi c’est difficile, et pourquoi ce n’est plus un obstacle

On lit souvent que la mise en œuvre d’une telle attaque « est très compliquée car elle demande une connaissance fine de l’architecture des programmes et des processeurs », avant d’ajouter qu’il existe des outils qui l’automatisent. Les deux affirmations restent vraies, avec une nuance. Tirer parti d’un dépassement demande effectivement une compétence rare et du temps, surtout depuis que les protections de la partie 5 existent : chaque protection ajoute des obstacles. Mais une fois qu’une personne a réussi, son travail est publié sous forme d’outil réutilisable, que d’autres emploient sans rien comprendre. Et la faille, elle, reste dans le programme jusqu’à ce qu’on la corrige. Une vulnérabilité difficile à exploiter n’est donc jamais une vulnérabilité acceptable : voir l’article sur les vulnérabilités.

3.2Les erreurs voisines

  • Le dépassement d’entier : un calcul sur une taille dépasse la capacité du type de nombre utilisé et « revient à zéro » ; le programme réserve alors un tampon trop petit, puis y copie une donnée qui ne tient plus. Beaucoup de dépassements de tampon ont en réalité cette origine.
  • La chaîne de format : une donnée saisie est passée telle quelle comme modèle d’affichage à une fonction d’écriture, qui peut alors lire ou écrire dans la mémoire.
  • L’utilisation après libération : le programme continue à employer une zone de mémoire qu’il a déjà rendue au système, et qui a servi entre-temps à autre chose.
  • La lecture hors limites : voir plus haut.

Toutes ces erreurs relèvent de la même famille : les erreurs de sûreté de la mémoire. Elles ont les mêmes remèdes.

4Pourquoi le langage C est exposé, et comment bien programmer

Le langage C (créé au début des années 1970, voir l’article sur le C) donne au programmeur un contrôle total de la mémoire, ce qui explique sa vitesse et son usage dans les systèmes d’exploitation, les pilotes, les objets connectés. Le prix à payer est que rien ne vérifie à sa place les limites des zones. Le C++ (voir le C++) hérite de la même liberté, tout en offrant des outils plus sûrs que l’on doit choisir d’employer. Une grande part des défenses consiste donc à bien programmer.

4.1Les fonctions à éviter

Certaines fonctions de la bibliothèque standard du C copient ou lisent des données sans connaître la taille de leur destination. Elles sont connues pour être à l’origine de très nombreuses failles. On cite souvent strcpy() ; en voici une liste plus complète, avec ce qu’on emploie à la place :

  • gets() lit une ligne sans limite de longueur. Elle est si dangereuse que la norme du langage l’a supprimée en 2011. On la remplace par fgets(), qui reçoit la taille maximale.
  • strcpy() et strcat() copient et concatènent des chaînes sans limite. On les remplace par des variantes qui reçoivent la taille de la destination, ou par snprintf().
  • sprintf() écrit un texte formaté sans limite. On emploie snprintf().
  • scanf("%s", …) lit un mot sans limite. On précise une largeur maximale ou on lit avec fgets().

Le conseil courant, « utiliser par exemple les fonctions strncpy() », doit être nuancé : strncpy() évite le dépassement mais a un piège connu. Si la source est aussi longue que la destination, elle ne termine pas la chaîne par la marque de fin, et la suite du programme peut lire au-delà. Ce n’est donc pas une solution à elle seule. Il faut soit terminer la chaîne à la main, soit employer snprintf() ou les fonctions de copie bornée fournies par certains systèmes.

4.2Un exemple de motif à ne pas écrire, et sa correction

Voici le motif classique, présenté pour que vous puissiez le reconnaître en relisant du code. La première version copie un nom sans regarder sa longueur.

/* À NE PAS FAIRE : aucune vérification de taille */
void saluer(const char *nom)
{
    char tampon[16];
    strcpy(tampon, nom);       /* si nom dépasse 15 caractères : dépassement */
    printf("Bonjour %s\n", tampon);
}

La seconde version limite la copie à la place disponible, et la fonction produit un résultat tronqué plutôt qu’une erreur de mémoire :

/* Version corrigée : la taille de la destination est respectée */
void saluer(const char *nom)
{
    char tampon[16];
    snprintf(tampon, sizeof tampon, "%s", nom);   /* tronque si trop long */
    printf("Bonjour %s\n", tampon);
}

Le gain n’est pas seulement technique : sizeof tampon fait calculer la taille par le compilateur, ce qui évite qu’un changement de taille d’un côté ne soit oublié de l’autre.

4.3Les règles de base

  • Ne jamais faire confiance à une donnée venue de l’extérieur (saisie, fichier, réseau, autre programme) : vérifier sa longueur et son format avant de l’employer.
  • Passer la taille avec le tampon à chaque fonction, et la tester avant d’écrire.
  • Vérifier les calculs de taille : avant de multiplier ou d’additionner des longueurs pour réserver de la mémoire, s’assurer que le résultat ne « revient pas à zéro ».
  • Préférer les types qui connaissent leur taille (chaînes et tableaux dynamiques du C++, comme std::string et std::vector, avec accès contrôlé) aux tableaux nus et aux pointeurs.
  • Activer les avertissements du compilateur et les traiter : beaucoup de motifs dangereux sont signalés automatiquement.
  • Relire le code et l’analyser (partie 6) : une seconde paire d’yeux et des outils attrapent ce qu’on ne voit plus.

Pour s’exercer

Exercice 1 : repérer le motif dangereux

Une fonction réserve char nom[32]; puis appelle gets(nom);. Pourquoi est-ce une erreur ? Comment la corriger ?

Voir la réponse

gets() lit une ligne sans connaître la taille du tampon : si la ligne dépasse 31 caractères (plus la marque de fin), l’excédent écrase la mémoire voisine. La fonction a d’ailleurs été retirée de la norme du langage en 2011. On la remplace par fgets(nom, sizeof nom, stdin);, qui lit au plus la taille indiquée et laisse la place de la marque de fin.

Exercice 2 : combien dépasse-t-il ?

Un tampon fait 16 octets et on y copie une donnée de 40 octets, marque de fin comprise. Combien d’octets dépassent ? Quelles zones sont menacées ?

Voir la réponse

40 − 16 = 24 octets dépassent. Ils écrasent ce qui suit le tampon dans la pile : d’abord les variables locales voisines, puis les informations de gestion de la fonction, dont l’adresse de retour si la distance est franchie. Les conséquences possibles : plantage, comportement faux, ou dans le pire cas détournement de l’exécution. La correction est de refuser ou de tronquer la donnée avant de la copier.

Exercice 3 : associer protection et rôle

Associez : (a) canari ; (b) pile non exécutable ; (c) ASLR ; (d) pile fantôme ; (e) langage à mémoire sûre ; à : 1. rend les adresses imprévisibles ; 2. empêche l’erreur à la source ; 3. refuse d’exécuter des instructions placées dans des données ; 4. détecte que l’adresse de retour a été modifiée, grâce à une copie protégée ; 5. détecte l’écrasement avant la sortie de la fonction.

Voir la réponse

(a) 5 ; (b) 3 ; (c) 1 ; (d) 4 ; (e) 2. Seul le langage sûr supprime la cause ; les autres rendent l’exploitation plus difficile ou détectable, d’où l’intérêt de les empiler.

Exercice 4 : le piège de strncpy

Un programmeur écrit strncpy(dest, source, sizeof dest); en pensant être à l’abri. Quel problème peut subsister, et que faire ?

Voir la réponse

Si la source est aussi longue que la destination ou plus, strncpy() copie exactement la taille demandée et n’ajoute pas la marque de fin : la « chaîne » n’est pas terminée, et les fonctions qui la lisent ensuite iront chercher une marque de fin plus loin en mémoire. Il faut soit copier une place de moins puis terminer à la main (dest[sizeof dest - 1] = '\0';), soit employer snprintf(dest, sizeof dest, "%s", source);, qui termine toujours la chaîne.