Analyse de la vulnérabilité OpenSSL Punycode (CVE-2022-3602)

Les attaques Punycode sont des attaques de phishing qui utilisent des domaines pour imiter des marques populaires. Dans cet article, nous analysons la vulnérabilité Punycode de haute gravité, CVE-2022-3602.

Le 1er novembre 2022, le projet OpenSSL a annoncé deux vulnérabilités de haute gravité dans OpenSSL. Étant donné que ces deux vulnérabilités étaient liées à l'analyse Punycode, elles ont été familièrement connues sous le nom de vulnérabilités Punycode. Dans cet article, nous analyserons CVE-2022-3602.

OpenSSL est une bibliothèque permettant de créer et de maintenir l'identité et la communication sécurisée entre ordinateurs en fournissant une couche de sockets sécurisés et des outils associés. Il est largement déployé sur les systèmes Windows et Linux/Unix avec une grande variété de plates-formes embarquées.

Ces vulnérabilités affectaient OpenSSL v3.0.0 à v3.0.6.

Présentation de la vulnérabilité Punycode

Comprendre Punycode est une condition préalable essentielle pour comprendre ces vulnérabilités OpenSSL associées. Comme défini dans la RFC 3492, Punycode est un moyen d'utiliser une chaîne de caractères ASCII pour coder une chaîne de caractères Unicode. Ces chaînes Punycode sont utilisées en interne lors de la résolution de domaines contenant des caractères Unicode.

Dans OpenSSL v3.0.6 crypto/punycode.c il existe une erreur d'un par un sur la ligne 184 où si (sortie_écrite > sortie_max) devrait plutôt être si (sortie_écrite >=sortie_max). Lorsque OpenSSL essaie de traiter un certificat contenant une adresse e-mail spécialement conçue avec un domaine Punycode, le débordement de mémoire tampon qui en résulte peut entraîner un plantage du programme ou l'exécution de code à distance.

Présentation de la preuve de concept

Pour démontrer la vulnérabilité d'OpenSSL à l'aide d'Insure++, nous utilisons la version accessible au public preuve de concept créée par Data Dog Security Labs. Cette preuve de concept est limitée dans la mesure où elle ne génère pas toujours un crash mais elle génère toujours un corruption de mémoire problème qui Insure++ peut détecter. Si vous êtes intéressé par une plongée détaillée à la fois dans la vulnérabilité et la preuve de concept, consultez leur blog.

Configuration de la démo

Pour notre démonstration, nous avons deux machines virtuelles connectées sur le même réseau local. La machine virtuelle « victime » exécutera Windows 10 et la version vulnérable d'OpenSSL instrumentée avec Insure++. La machine virtuelle « attaquante » exécutera Ubuntu et utilisera la preuve de concept de Data Dog Security Labs. Pour cette démonstration, l'adresse IP de la « victime » sera 192.168.1.10 et celle de l'« attaquante » 192.168.1.20.

Nous allons d'abord configurer notre machine virtuelle Windows 10 « victime ». Pour compiler OpenSSL à partir des sources, nous devons installer Visual Studio 2022 et Parasoft Insure++. Les prérequis supplémentaires incluent « Strawberry Perl », NASM et « Git pour Windows » qui doivent également être installés et inclus dans Windows. PATH.

Ensuite, nous allons cloner le référentiel git OpenSSL à partir de github.com/openssl/openssl.git et consultez la balise de version vulnérable à l'aide de la commande suivante.

git checkout -b v3.0.6 balises/openssl-3.0.6

Après cela, nous devons modifier les configurations de construction pour créer un profil de construction qui utilisera Insure++ pour instrumenter OpenSSL au fur et à mesure de sa construction. Pour ce faire, nous allons hériter du profil de build Visual C Windows 64 bits en apportant quelques petites modifications à Insure++. Ouvert Configurations/10-main.conf et insérez ce qui suit après la ligne 1421.

"VC-WIN64A-INSURE" => {
inherit_from => [ "VC-WIN64A" ],
CC => "assurer",
LD => "inslink",
},

Lancez maintenant une invite de commande x64 Native Tools pour VS 2022 et accédez à l'emplacement où vous avez cloné le dépôt Git source OpenSSL. Exécutez la commande suivante pour configurer la source de notre profil de build Insure++.

perl Configurer VC-WIN64A-INSURE

Si la commande précédente a réussi, nous sommes prêts à construire en utilisant la commande suivante. Cela construira OpenSSL à l'aide de Visual Studio tandis qu'Insure++ instrumentera le code généré.

nfaire

Vous pourrez voir le code en cours de compilation dans l'interface graphique Insure++, comme illustré dans l'image suivante.

Si la compilation a réussi, la configuration de notre machine virtuelle « victime » est terminée. Pour la machine virtuelle « attaquante », installez simplement Ubuntu et clonez le dépôt Git de preuve de concept depuis github.com/DataDog/security-labs-pocs.git.

Exécution d'une preuve de concept dans un environnement de démonstration

Sur la machine virtuelle « attaquante », à partir de la racine du référentiel de preuve de concept de Data Dog Security Labs que nous avons cloné, accédez à preuve de concept-exploits/openssl-punycode-vulnerability/vagrant/WindowsCrash. Dans ce répertoire, il y a des certificats et des clés spécialement construits qui reproduiront la vulnérabilité lorsqu'un serveur OpenSSL sera lancé avec eux. Il n'est pas nécessaire d'avoir une version vulnérable d'OpenSSL pour utiliser ces fichiers, nous allons donc lancer un serveur OpenSSL en utilisant la version fournie avec Ubuntu. La commande suivante lancera un serveur OpenSSL avec les clés et les certificats de preuve de concept.

openssl s_server -accept 3000 -CAfile ca.crt -cert test.crt -key test.key.pem -state

Le serveur OpenSSL étant exécuté sur notre machine virtuelle « attaquante », nous sommes prêts à utiliser notre client OpenSSL instrumenté Insure++ sur la machine virtuelle « victime » pour reproduire et analyser la vulnérabilité. Sur cette machine, depuis la racine du dépôt OpenSSL cloné, accédez à =apps= et exécutez la commande suivante.

openssl.exe s_client -connect 10.10.10.7:3000

Lorsque le client « victime » se connecte au serveur « attaquant », Insure++ détecte le dépassement de capacité d'écriture de mémoire et l'affiche dans l'interface graphique comme indiqué dans l'image suivante.

Analyser la vulnérabilité avec Insure++

Comme le montre l'image précédente, Insure++ a détecté divers problèmes de mémoire à partir de cette exécution d'OpenSSL. Intéressons-nous en particulier au défaut lié à cette vulnérabilité Punycode. Dans l'interface graphique Insure++, cliquez sur le WRITE_OVERFLOW=in=punycode.c sur comme 187. Vous devriez voir quelque chose de similaire à ce qui suit.

Vous pouvez voir qu'Insure++ a correctement identifié la faiblesse comme étant CWE-120, ce qui correspond à l'entrée pour CVE-2022-3602 dans le Entrée NIST. En dessous, nous pouvons voir un graphique montrant celui de notre tampon d'origine de 2048 octets, l'appel à memmove() écrit 12 octets à la fin du tampon dont 8 octets sont dans le tampon et les 4 derniers octets débordent. Cette constatation concorde avec les résultats publiés dans le blog susmentionné de Data Dogs Security Labs. Les plages d'adresses exactes impliquées sont indiquées ci-dessous. Enfin, vous pouvez voir une trace de pile et un extrait de code dans la fenêtre.

Conclusion

J'espère avoir démontré certaines des fonctionnalités et capacités uniques d'Insure++ ainsi que notre nouvelle interface graphique. Ces fonctionnalités font d'Insure++ un excellent ajout aux outils d'un chercheur en sécurité, en particulier lorsqu'il s'agit de fuzzing, de recherche de vulnérabilités et d'attaques basées sur la mémoire.