Attaques par Dépassement de Tampon : Une Menace Numérique Dangereuse

Les attaques par dépassement de tampon posent une menace significative à la sécurité des logiciels. Ces attaques se produisent lorsque des individus malveillants exploitent les vulnérabilités de dépassement de tampon. Cela peut conduire à des crashs de programme, à la corruption de données, au vol d’informations sensibles et à un accès non autorisé au système. Cet article explique les dépassements de tampon, leur utilisation par les attaquants, et les méthodes pour les prévenir lors du développement logiciel.

Les bases des Dépassements de Tampon

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

Chaque tampon a une taille définie. Des problèmes se produisent lorsqu’un programme tente de stocker plus de données que le tampon ne peut en contenir. Dans de tels cas, les données excédentaires débordent du tampon, se dispersant dans les emplacements mémoire adjacents. Ce comportement involontaire peut entraîner des crashs 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 fragment de code alloue un tampon de 8 octets pour stocker une chaîne obtenue à partir des entrées utilisateur. Si l’utilisateur tape plus de 8 caractères, cela écrasera la mémoire avoisinante.

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 portions de mémoire contenant du code exécutable, 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 saturer le système et causer une corruption de la mémoire.

L’attaquant cherche à remplacer le tampon avec du code malveillant. Ce code peut effectuer des actions nocives, telles que l’ouverture d’un shell ou l’exécution de commandes sans permission. L’attaque réussit lorsque l’attaquant change une adresse de retour de fonction ou un gestionnaire d’exceptions. 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 des noms d’utilisateur est de 128 octets, un hacker pourrait envoyer un nom d’utilisateur nuisible dans un certain format.

"A" * 132 + code_malveillant + fausse_adresse_de_retour

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

Exemples Réels de Dépassements de Tampon

Chaque attaque par dépassement de tampon se résume à la même stratégie :

Voici quelques exemples concrets de vulnérabilités de dépassement trouvées dans des SGBD populaires au cours des années.

MySQL COM_FIELD_LIST

Jusqu’en 2012, MySQL et MariaDB étaient vulnérables à la vulnérabilité COM_FIELD_LIST. Les bases de la vulnérabilité étaient les suivantes :

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

SELECT * FROM 'très_long_nom_de_table'.

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

SELECT * FROM 'très_long_nom'.\x31\xc0\x50\x68\x2f\x2f\x73'

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

Pour augmenter les chances de succès, les malfaiteurs ajoutaient un segment No Operation au code, en d’autres termes, un code qui n’exécute rien.

Une requête complète ressemblait à ceci :

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

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

PostgreSQL 9.3 RESETXLOG Dépassement de Tampon

De manière similaire, 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 Slammer de SQL Server

En 2003, l’attaque du Ver Slammer de SQL Server a été découverte. Elle ciblait le serveur de résolution SQL Server, qui accepte des 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 en sorte que le serveur envoie plus de copies du ver, entraînant une propagation rapide et une congestion massive du réseau. Un exemple serait comme suit :

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 Dépassement de Tampon HTTP

En 2003, une vulnérabilité de dépassement a été découverte dans le serveur Oracle. Les attaquants pouvaient envoyer un très long nom d’utilisateur dans une requête HTTP GET, ce qui faisait déborder le tampon, puis exécutait du 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 fragment de code montre un script Python qui transmet des identifiants au serveur Oracle, provoquant un dépassement de tampon. En conséquence, les identifiants exécutent du code malveillant.

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

Le développement de logiciels sécurisés nécessite une approche proactive pour prévenir les vulnérabilités de dépassement de tampon. Les stratégies suivantes sont essentielles pour réduire les risques associés aux dépassements de tampon :

1. Validation des Entrées : Assurez-vous que toutes les données fournies par les utilisateurs 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 involontaires ne causent des dépassements de tampon.
2. Fonctions de Chaîne et de Mémoire Sûres : Évitez d’utiliser des fonctions de bibliothèque standard sujettes aux dépassements de tampon. Optez plutôt pour des alternatives plus sûres, comme `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, telles que l’aléation de la disposition de l’espace d’adressage (ASLR) et la prévention de l’exécution des données (DEP), dès que possible. Ces mécanismes rendent plus difficile pour les attaquants de prédire la disposition de la mémoire et d’exécuter du code malveillant.
4. Utilisation de Langages Sécurisés pour la Mémoire : Utilisez des langages sûrs pour la mémoire comme Rust, Go, ou Java pour vous protéger contre les dépassements de tampon. Ces langages imposent des pratiques strictes de gestion de mémoire et empêchent l’accès direct à la mémoire, réduisant le risque de vulnérabilités de dépassement.
5. Mises à Jour Logicielles Régulières : Mettez à jour les bibliothèques logicielles et les dépendances rapidement lorsque des vulnérabilités de dépassement de tampon sont découvertes et 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.

Utiliser des outils de test de fuzzing et des techniques d’analyse statique de code source comme l’analyse de contamination peut aider à trouver les bugs de dépassement de tampon pendant le développement logiciel.

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

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

En 2017, le virus WannaCry a tiré parti d’une faiblesse dans le protocole Windows Server Message Block pour se propager. En une seule journée, WannaCry a infecté plus de 230 000 ordinateurs dans le monde, causant des pertes financières significatives et des perturbations majeures.

Conclusion

Les attaques par dépassement de tampon restent une préoccupation critique dans le domaine de la sécurité logicielle. Les développeurs peuvent protéger leurs logiciels en apprenant sur les dépassements de tampon et la façon dont 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ûres. Elles aident à prévenir les vulnérabilités de dépassement de tampon dans les systèmes. L’adoption de langages de programmation sécurisés pour la mémoire et la mise à jour régulière des dépendances logicielles renforcent davantage la résilience des systèmes logiciels.

Les développeurs de logiciels peuvent améliorer la sécurité des systèmes numériques en empêchant les dépassements de tampon et en restant informés des nouvelles menaces. Cela protège les données et garantit la fiabilité des systèmes informatiques.