En informatique, un dépassement de tampon ou débordement de tampon (en anglais, buffer overflow) est un bug causé par un processus qui, lors de l'écriture dans un tampon, écrit à l'extérieur de l'espace alloué au tampon, écrasant ainsi des informations nécessaires au processus.
Lorsque le bug se produit non intentionnellement, le comportement de l'ordinateur devient imprévisible. Il en résulte souvent un blocage du programme, voire de tout le système.
Le bug peut aussi être provoqué intentionnellement et être exploité pour violer la politique de sécurité d’un système. Cette technique est couramment utilisée par les pirates informatiques. La stratégie du pirate est alors de détourner le programme bugué en lui faisant exécuter des instructions qu'il a introduites dans le processus.
Le principe de l'utilisation malveillante du dépassement de tampon est de profiter de l’accès à certaines variables du programme, souvent par le biais de fonctions telles que scanf() (analyse d'une chaîne de caractères) ou strcpy() (copie d'une chaîne de caractères) en langage C, qui ne contrôlent pas la taille de la chaîne à traiter, afin d’écraser la mémoire du processus jusqu’à l’adresse de retour de la fonction en cours d’exécution. Le pirate peut ainsi choisir quelles seront les prochaines instructions exécutées par le processus et faire exécuter un code malveillant qu'il aura introduit dans le programme.
Afin d’éviter ces dépassements, certaines fonctions ont été réécrites pour prendre en paramètre la taille du tampon dans lequel les données sont copiées, et éviter ainsi de copier des informations à l'extérieur du tampon. Ainsi strncpy() est une version de strcpy() qui tient compte de la taille du tampon.
La fonction strncpy présente l'inconvénient de remplir toute la fin du tampon de zéros, ce qui la rend moins efficace. Les fonctions strlcpy et strlcat, qui ne présentent pas ce défaut, ont été initialement disponibles sous OpenBSD et elles tendent à se répandre dans divers logiciels comme rsync et KDE.
Un programme en exécution (un processus) découpe la mémoire adressable en zones distinctes :
Contrairement aux deux premières, les deux dernières zones sont dynamiques, c'est-à-dire que leur pourcentage d'utilisation et leur contenu varient tout au long de l’exécution d’un processus.
La zone de la pile d'exécution est utilisée par les fonctions (stockage des variables locales et passage des paramètres). Elle se comporte comme une pile, c'est-à-dire dernier entré, premier sorti. Les variables et les paramètres d’une fonction sont empilés avant le début de la fonction et dépilés à la fin de la fonction.
Une fonction est une suite d'instructions. Les instructions d'une fonction peuvent être exécutées (en informatique, on dit que la fonction est appelée) à partir de n'importe quel endroit d'un programme. À la fin de l'exécution des instructions de la fonction, l'exécution doit se continuer à l'instruction du programme qui suit l'instruction qui a appelé la fonction.
Pour permettre le retour au programme qui a appelé la fonction, l’instruction d'appel de la fonction (l'instruction call) enregistre l'adresse de retour dans la pile d'exécution. Lors de l’exécution de l’instruction ret qui marque la fin de la fonction, le processeur récupère l’adresse de retour qu’il a précédemment stockée dans la pile d'exécution et le processus peut continuer son exécution à cette adresse.
Plus précisément, le traitement d'une fonction inclut les étapes suivantes :
Soit l’extrait de programme C suivant (volontairement simplifié) :
#includevoid foo(char *str) { char buffer[32]; strcpy(buffer, str); /* ... */ } int main(int argc, char *argv[]) { if (argc > 1) { /* appel avec le premier argument de la ligne de commandes */ foo(argv[1]); } /* ... */ return 0; }
Ce qui est traduit ainsi par un compilateur C (ici le compilateur GCC avec architecture x86) :
push ebp ; entrée de la fonction mov ebp,esp ; sub esp,40 ; 40 octets sont « alloués » (32 + les 2 variables qui serviront ; à l'appel de strcpy) mov eax,[ebp+0x8] ; paramètre de la fonction (str) mov [esp+0x4],eax ; préparation de l'appel de fonction: deuxième paramètre lea eax,[ebp-0x20] ; ebp-0x20 contient la variable locale 'buffer' mov [esp],eax ; premier paramètre call strcpy ; sortie de la fonction leave ; équivalent à mov esp,ebp et pop ebp ret
Voici l'état de la pile d'exécution et des deux registres (ebp et esp) juste avant l'appel de la fonction strcpy :
La fonction strcpy copiera le contenu de str dans buffer. La fonction strcpy ne fait aucune vérification : elle copiera le contenu de str jusqu'à ce qu'elle rencontre un caractère de fin de chaîne (caractère nul).
Si str contient plus de 32 octets avant le caractère nul, la fonction strcpy continuera à copier le contenu de la chaîne au-delà de la zone allouée par la variable locale buffer. C’est ainsi que les informations stockées dans la pile d'exécution (incluant l’adresse de retour de la fonction) pourront être écrasées comme indiqué dans l'illustration suivante :
Dans l’exemple précédent, si str contient un code malveillant sur 32 octets suivi de l’adresse de buffer, au retour de la fonction, le processeur exécutera le code contenu dans str.
Pour que cette « technique » fonctionne, il faut deux conditions :
Le dépassement de tampon avec écrasement de l'adresse de retour est un bug du programme. L’adresse de retour ayant été écrasée, à la fin de la fonction, le processeur ne peut brancher vers l'adresse de retour originale, car cette adresse a été modifiée par le dépassement de tampon. Dans le cas d'un bug involontaire, l'adresse de retour a généralement été remplacée par une adresse en dehors de la plage adressable et le programme plante en affichant un message d’erreur (erreur de segmentation).
Un pirate informatique peut utiliser ce comportement à ses fins. Par exemple, en connaissant la taille du tampon (dans l’exemple précédent 32 octets), il peut écraser l’adresse de retour pour la remplacer par une adresse qui pointe vers un code à lui, de manière à prendre le contrôle du programme. De cette façon, il obtient les droits d’exécution associés au programme qu'il a détourné et peut dans certains cas accéder à des ressources critiques.
La forme d’attaque la plus simple consiste à inclure dans une chaîne de caractères copiée dans le tampon un programme malveillant et d'écraser l'adresse de retour par une adresse pointant vers ce code malveillant.
Pour arriver à ses fins, le pirate doit surmonter deux difficultés :
La technique précédente nécessite généralement pour l’attaquant de connaître l’adresse de début du code malveillant. Ceci est assez complexe, car cela demande généralement des essais successifs, ce qui n’est pas une méthode très « discrète ». De plus, il y a de fortes chances que l’adresse de la pile change d’une version à l’autre du programme visé et d’un système d'exploitation à l’autre.
Le pirate veut généralement exploiter une faille sur le plus de versions possible du même programme (afin peut-être de concevoir un virus ou ver). Pour s’affranchir du besoin de connaître l'adresse du début du code malveillant, il doit trouver une méthode qui lui permette de brancher sur son code sans se préoccuper de la version du système d'exploitation et du programme visé tout en évitant de faire de multiples tentatives qui prendraient du temps et dévoileraient peut-être sa présence.
Il est possible dans certains cas de se servir du contexte d’exécution du système cible. Par exemple, sur des systèmes Windows, la plupart des programmes, même les plus simples contiennent un ensemble de primitives systèmes accessibles au programme (DLL). Il est possible de trouver des bibliothèques dont l’adresse mémoire lors de l’exécution change peu en fonction de la version du système. Le but pour l’attaquant est alors de trouver dans ces plages mémoires des instructions qui manipulent la pile d'exécution et lui permettront d’exécuter son code.
Par exemple, en supposant que la fonction strcpy manipule un registre processeur (eax) pour y stocker l’adresse source. Dans l’exemple précédent, eax contiendra une adresse proche de l’adresse de buffer au retour de strcpy. Le but de l’attaquant est donc de trouver dans la zone mémoire supposée « fixe » (la zone des DLL par exemple) un code qui permet de sauter vers le contenu de eax (call eax ou jmp eax). Il construira alors son buffer en plaçant son code suivi de l’adresse d’une instruction de saut (call eax ou jmp eax). Au retour de strcpy, le processeur branchera vers une zone mémoire contenant call eax ou jmp eax et puisque eax contient l’adresse du buffer, il branchera de nouveau vers le code et l’exécutera.
La deuxième difficulté pour l'attaquant est la construction du code d’exploitation appelé shellcode. Dans certains cas, le code doit être construit avec un jeu de caractères réduit : chaîne Unicode, chaîne alphanumérique, etc.
En pratique, ces limitations n'arrêtent pas un pirate déterminé. On recense des cas de piratage utilisant du code limité aux caractères légaux d'une chaîne Unicode (mais il faut pouvoir exécuter du code automodifiant).
Pour se prémunir contre de telles attaques, plusieurs options sont offertes au programmeur. Quelques unes de ces options sont décrites dans les deux sections suivantes.
Aucune de ces solutions logicielles ne s’est imposée (en 2008) dans le monde du développement industriel. Pourtant, les dépassements de tampon représentent une part encore importante des failles permettant le développement de vers, de virus et d'attaques manuelles.