Attaques de Dépassement de Tampon

Les attaques de dépassement de tampon posent une menace significative à la sécurité des logiciels. Ces attaques se produisent lorsque des individus malveillants exploitent des vulnérabilités de dépassement de tampon. Cela peut entraîner des plantages de programme, des corruptions de données, le vol d’informations sensibles et un accès non autorisé au système. Cet article explique ce qu’est un dépassement de tampon, comment les attaquants les utilisent et les méthodes pour les prévenir dans le développement de logiciels.

Les Bases des Dépassements de Tampon

Un tampon, dans le contexte de l’informatique, est une zone de mémoire allouée pour stocker temporairement des données. Les programmes utilisent des tampons pour contenir divers types de données, comme les entrées utilisateur, le contenu de fichiers ou les chaînes de caractères.

Chaque tampon a une taille définie. Les problèmes surviennent lorsqu’un programme essaie de stocker plus de données que la capacité du tampon. Dans ce cas, le surplus de données déborde du tampon et se répand dans les emplacements mémoire adjacents. Ce comportement imprévu peut entraîner des plantages de programme, la corruption de données et des vulnérabilités de sécurité.

Considérez l’exemple suivant en langage de programmation C :

char buffer[8];
scanf("%s", buffer);

Ce code alloue un tampon de 8 octets pour stocker une chaîne obtenue à partir de l’entrée de l’utilisateur. Si l’utilisateur tape plus de 8 caractères, cela écrasera la mémoire adjacente.

Exploitation des Vulnérabilités de Dépassement de Tampon

Les attaquants exploitent les vulnérabilités de dépassement de tampon en écrasant stratégiquement des parties de mémoire contenant du code exécutable, en le remplaçant par du code malveillant. L’attaquant identifie d’abord un programme avec une vulnérabilité de dépassement de tampon connue. L’attaquant envoie délibérément trop de données pour submerger le système et provoquer une corruption de mémoire.

L’attaquant veut remplacer le tampon par du code malveillant. Ce code peut effectuer des actions nuisibles, telles que l’ouverture d’une shell ou l’exécution de commandes sans autorisation. L’attaque réussie lorsque l’attaquant modifie une adresse de retour de fonction ou un gestionnaire d’exception. Lorsque l’utilisateur exécute le code altéré, il exécute le code malveillant.

Pour illustrer ce concept, considérez un programme serveur qui reçoit des noms d’utilisateur de clients. Si l’espace de stockage du nom d’utilisateur est de 128 octets, un hacker pourrait envoyer un nom d’utilisateur nuisible dans un certain format.

"A" * 132 + code_malveillant + adresse_de_retour_faussée

La série de caractères “A” déborde le tampon, permettant au code malveillant de s’écrire dans la mémoire. L’adresse de retour faussée garantit que le code malveillant s’exécute lorsque la fonction écrasée retourne.

Exemples Réels de Dépassement de Tampon

Toutes les attaques de dépassement de tampon se résument à la même stratégie :

Voici quelques exemples réels de vulnérabilités de dépassement trouvées dans des SGBD populaires au fil des ans.

MySQL COM_FIELD_LIST

Jusqu’en 2012, MySQL et MariaDB étaient sujets à une vulnérabilité de type COM_FIELD_LIST. Les bases de cette vulnérabilité étaient les suivantes :

Un malfaiteur faisait une requête au serveur MySQL avec une clause ‘FROM’, spécifiant un nom de table très long pour provoquer un dépassement de tampon.

SELECT * FROM 'nom_de_table_très_long'.

La longueur exacte n’était pas spécifiée, mais 5000 octets suffisaient pour provoquer un dépassement. Cela provoquerait l’arrêt du serveur, mais dans le moment entre le dépassement et l’arrêt, le serveur devenait vulnérable aux attaques. C’est à ce moment-là que les malfaiteurs inséraient du code malveillant sous forme d’octets hexadécimaux.

SELECT * FROM 'nom_très_long'.\x31\xc0\x50\x68\x2f\x2f\x73'

Le code devait exécuter des commandes bash, comme ‘rm -rf /bin/’.

Pour augmenter les chances de succès, les malfaiteurs ajoutaient un segment No Operation au code, en d’autres termes, du code qui ne faisait rien.

Une requête complète ressemblerait à ceci :

SELECT * FROM 'AAAAAAAAAAA..' provoquant un dépassement de tampon
'\x0\x0\x0\x0\x0' - No Operation slide
'\xe3\x50\x53\x89\xe1\xb0\x0b' - Code malveillant.

La vulnérabilité a été corrigée dans MySQL versions 5.5.23, 5.1.63, et 5.6.6, ainsi que dans MariaDB versions 5.5.23, 5.3.12, 5.2.14, et 5.1.63. La mise à jour vers ces versions ou des versions ultérieures a corrigé la vulnérabilité et protégé les bases de données contre cette attaque spécifique.

PostgreSQL 9.3 RESETXLOG Dépassement de Tampon

De la même manière, en 2013, il a été découvert et rapidement corrigé que la fonction pg_resetxlog() de PostgreSQL était sujette à ces attaques.

postgres=# SELECT pg_resetxlog('A' * 1000 + *code_malveillant*);

Ver SQL Server Slammer

En 2003, une attaque de ver SQL Server Slammer a été découverte. Elle ciblait le serveur de résolution SQL Server, qui accepte les paquets UDP sur le port 1434. Lorsqu’un paquet spécialement conçu était envoyé à ce port, il débordait le tampon et permettait au ver d’exécuter du code arbitraire. Ce code faisait envoyer au serveur plus de copies du ver, entraînant une propagation rapide et une congestion massive du réseau. Un exemple serait comme ceci :

payload = create_malicious_packet()
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.sendto('A' * 1000, *code_malveillant*, (target_ip, 1434))
sock.close()

Oracle 9i XDB HTTP Dépassement de Tampon

En 2003, une vulnérabilité de dépassement de tampon a été découverte dans le serveur Oracle. Les attaquants pouvaient envoyer un nom d’utilisateur très long dans une requête HTTP GET, ce qui débordait le tampon, puis exécuter le code malveillant.

long_username = 'A' * 1000 + *code_malveillant*
password = 'password'
credentials = f"{long_username}:{password}"
encoded_credentials = base64.b64encode(credentials.encode()).decode()
http_request = ( "GET / HTTP/1.1\r\n" f"
Host: {target_ip}\r\n" "User-Agent: Mozilla/5.0\r\n" f"
Authorization: Basic {payload}\r\n" "Accept: */*\r\n" "\r\n" )
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((target_ip, target_port))
sock.sendall(http_request.encode())

Ce snippet présente un script python qui transmet des identifiants au serveur Oracle qui déborde son tampon. Par conséquent, ces identifiants exécutent du code malveillant.

Prévenir les Vulnérabilités de Dépassement de Tampon

Développer un logiciel sécurisé nécessite une approche proactive pour prévenir les vulnérabilités de dépassement de tampon. Les stratégies suivantes sont essentielles pour atténuer les risques associés aux dépassements de tampon :

1. Validation des Entrées : Assurez-vous que toutes les données fournies par l’utilisateur sont dans les limites attendues avant de les stocker dans des tampons. Validez la longueur, le format et le contenu des entrées pour éviter que des données malveillantes ou non intentionnelles ne causent des dépassements de tampon.
2. Fonctions de Chaîne et de Mémoire Sécurisées : Évitez d’utiliser des fonctions de bibliothèque standard qui sont sujettes aux dépassements de tampon. Optez plutôt pour des alternatives plus sûres, telles que `strncpy` et `memcpy_s`, qui incluent des garde-fous intégrés contre les dépassements.
3. Protections au Niveau du Système : Activez les fonctionnalités de sécurité au niveau du système, comme l’aléatoirisation de l’agencement de l’espace d’adressage (ASLR) et la prévention de l’exécution des données (DEP), chaque fois que possible. Ces mécanismes rendent plus difficile pour les attaquants de prédire les agencements de mémoire et d’exécuter du code malveillant.
4. Utilisez des langages de programmation sûrs comme Rust, Go ou Java pour vous protéger contre les dépassements de tampon. Ces langages imposent des pratiques strictes de gestion de la mémoire et empêchent l’accès direct à la mémoire, ce qui réduit le risque de vulnérabilités de dépassement.
5. Mises à Jour Logiciels Régulières : Mettez rapidement à jour les bibliothèques logicielles et les dépendances lorsque des vulnérabilités de dépassement de tampon sont découvertes et que des correctifs sont publiés. Rester à jour avec les derniers correctifs de sécurité est crucial pour se protéger contre les vulnérabilités connues.

L’utilisation d’outils de tests par fuzzing et de techniques SAST, telles que l’analyse de contaminations, peut aider à trouver les bugs de dépassement de tampon pendant le développement du logiciel.

Impact Réel des Attaques de Dépassement de Tampon

Tout au long de l’histoire de l’informatique, de nombreux incidents de sécurité de premier plan ont été attribués à des vulnérabilités de dépassement de tampon. Le ver Morris était un des premiers vers sur internet. Il se propageait en exploitant une faille de sécurité dans le programme Unix `finger` en 1988.

En 2017, le virus WannaCry a profité d’une faiblesse du protocole Windows Server Message Block pour se propager. En une seule journée, WannaCry a infecté plus de 230 000 ordinateurs dans le monde entier, entraînant des pertes financières et des interruptions significatives.

Conclusion

Les attaques de dépassement de tampon restent un problème crucial dans le domaine de la sécurité des logiciels. Les développeurs peuvent protéger leurs logiciels contre les attaques en apprenant ce qu’est un dépassement de tampon et comment les attaquants les exploitent.

Il est important d’utiliser des pratiques de codage sécurisées. Ces pratiques incluent la validation des entrées et l’utilisation de fonctions de mémoire sécurisées. Elles aident à prévenir les vulnérabilités de dépassement de tampon dans les systèmes. L’adoption de langages de programmation sûrs pour la mémoire et le maintien à jour des dépendances logicielles renforcent encore la résilience des systèmes logiciels.

Les développeurs de logiciels peuvent améliorer la sécurité des systèmes numériques en prévenant les dépassements de tampon et en restant conscients des nouvelles menaces. Cela protège les données et assure la fiabilité des systèmes informatiques.