Analyse des vulnérabilités du compilateur Solidity et stratégies de réponse

Le compilateur est l'un des composants de base des systèmes informatiques modernes. Son rôle est de convertir le code source des langages de programmation de haut niveau en instructions exécutables par l'ordinateur. La plupart des développeurs et des professionnels de la sécurité se concentrent généralement sur la sécurité du code des applications, mais négligent souvent la sécurité du compilateur lui-même. En réalité, en tant que programme informatique, le compilateur peut également présenter des vulnérabilités de sécurité, ce qui peut entraîner des risques de sécurité graves dans des scénarios spécifiques.

Par exemple, lors de la compilation et de l'exécution de code JavaScript, il est possible qu'en raison des vulnérabilités du moteur JavaScript, les utilisateurs soient exposés à des attaques lorsque qu'ils accèdent à des pages Web malveillantes, permettant à un attaquant d'exécuter du code à distance et de prendre finalement le contrôle du navigateur de la victime, voire de son système d'exploitation. Une autre étude a également montré que les bogues des compilateurs C++ pourraient entraîner des conséquences graves, telles que l'exécution de code à distance.

Le compilateur Solidity présente également des vulnérabilités de sécurité. Selon l'alerte de sécurité de l'équipe de développement de Solidity, plusieurs versions du compilateur Solidity contiennent des vulnérabilités de sécurité. Le rôle du compilateur Solidity est de convertir le code des contrats intelligents en code d'instructions (EVM) pour la machine virtuelle Ethereum, qui sera finalement téléchargé sur Ethereum et exécuté par l'EVM.

Il est nécessaire de distinguer les vulnérabilités du compilateur Solidity et les vulnérabilités de l'EVM elle-même. Les vulnérabilités de l'EVM font référence aux problèmes de sécurité qui surviennent lors de l'exécution des instructions par la machine virtuelle, pouvant affecter l'ensemble du réseau Ethereum. En revanche, les vulnérabilités du compilateur Solidity se réfèrent aux problèmes qui surviennent lors de la conversion de Solidity en code EVM, qui n'affectent pas directement le réseau Ethereum, mais peuvent entraîner une incohérence entre le code EVM généré et les attentes du développeur.

Une des dangers des vulnérabilités des compilateurs Solidity est qu'elles peuvent entraîner une divergence entre le code EVM généré et les attentes des développeurs de contrats intelligents. Étant donné que les contrats intelligents impliquent généralement les actifs cryptographiques des utilisateurs, tout bug causé par le compilateur pourrait entraîner des pertes d'actifs pour les utilisateurs, avec des conséquences graves.

Les développeurs et les auditeurs se concentrent souvent sur la logique des contrats et les problèmes de sécurité courants, tandis que les vulnérabilités des compilateurs sont difficiles à détecter par une inspection de code. Il est nécessaire d'analyser conjointement les versions spécifiques du compilateur et les modèles de code pour déterminer si un contrat intelligent est affecté par des vulnérabilités de compilateur.

Voici quelques exemples réels de vulnérabilités des compilateurs Solidity :

1. SOL-2016-9 HighOrderByteCleanStorage

Cette vulnérabilité existe dans les versions antérieures du compilateur Solidity ( >= 0.1.6 < 0.4.4). Considérez le code suivant :

solidité contrat C { uint32 a = 0x12345678; uint32 b = 0; fonction f() publique { a = a + 1; } fonction run() public view returns (uint32) { return b; } }

Théoriquement, la variable b n'a pas été modifiée, la fonction run() devrait retourner 0. Cependant, dans le code généré par la version vulnérable du compilateur, run() retourne 1. Cela est dû au fait que l'EVM utilise des éléments de pile de taille 32 octets, tandis que Solidity prend en charge des types de données plus petits comme uint32. Le compilateur doit nettoyer les bits supérieurs (clean up) lors du traitement, mais n'a pas géré correctement le débordement d'addition, entraînant l'écriture du bit supérieur 1 dans la variable b.

2. SOL-2022-4 InlineAssemblyMemorySideEffects

Cette vulnérabilité existe dans les versions 0.8.13 à 0.8.15 du compilateur. Considérons le code suivant :

solidité contrat C { function f() public pure returns (uint) { assemblage { mstore(0, 0x42) } uint x; assemblage { x := mload(0) } return x; } }

Le compilateur, afin d'optimiser, supprimera les opérations d'écriture en mémoire apparemment inutiles, mais il a également optimisé à tort les accès mémoire à travers des blocs d'assemblage. Cela a conduit à ce que la fonction f() retourne 0 au lieu du correct 0x42.

3. SOL-2022-6 Débordement de tête AbiReencoding avec nettoyage de tableau statique

Cette vulnérabilité affecte les versions 0.5.8 à 0.8.16 du compilateur. Considérez le code suivant :

solidité contrat C { fonction f(string[1] calldata a) externe pur renvoie (string mémoire) { return abi.decode(abi.encode(a), (string[1]))[0]; } }

En temps normal, cette fonction devrait renvoyer la chaîne de caractères d'entrée. Cependant, dans la version vulnérable, elle renvoie une chaîne vide. Cela est dû au fait que le compilateur a, par erreur, nettoyé certaines données lors de l'encodage abi du tableau calldata, entraînant une incohérence des données après encodage et décodage.

Concernant les vulnérabilités du compilateur Solidity, l'équipe de sécurité blockchain de Cobo propose les recommandations suivantes :

Pour les développeurs:

1. Utilisez une version plus récente du compilateur Solidity, les problèmes de sécurité connus sont généralement moins fréquents.

2. Améliorer les cas de test unitaire. La plupart des bugs au niveau du compilateur entraînent des résultats d'exécution de code non conformes aux attentes, et en augmentant la couverture des tests, on peut éviter de tels problèmes.

3. Évitez d'utiliser des assemblages en ligne, des opérations complexes de codage et de décodage ABI, et ne utilisez pas aveuglément de nouvelles fonctionnalités et des fonctionnalités expérimentales. La plupart des vulnérabilités des compilateurs sont liées à ces opérations complexes.

Pour le personnel de sécurité:

1. Ne négligez pas les risques de sécurité que le compilateur pourrait introduire lors de l'audit. L'élément de vérification pertinent est SWC-102 : Version du compilateur obsolète.

2. Dans le processus de développement, encourager l'équipe de développement à mettre à niveau la version du compilateur, il est possible d'introduire une vérification automatique des versions dans le CI/CD.

3. Ne vous inquiétez pas trop des vulnérabilités des compilateurs. La plupart des vulnérabilités ne se déclenchent que dans des modèles de code spécifiques, et il est nécessaire d'évaluer l'impact sur la sécurité en fonction du projet.

Quelques ressources utiles :

• Alerte de sécurité officielle Solidity :
• Liste officielle des bugs de Solidity :
• Liste des bugs des différents compilateurs :
• L'icône d'avertissement en haut à droite de la page du contrat Etherscan peut indiquer les vulnérabilités de sécurité présentes dans la version actuelle du compilateur.

En résumé, les développeurs et les responsables de la sécurité doivent accorder une attention particulière aux risques de sécurité que peuvent engendrer les vulnérabilités du compilateur Solidity, prendre des mesures appropriées pour réduire ces risques et garantir la sécurité des contrats intelligents.