Introduction
La communauté des développeurs de blockchains a longtemps eu besoin de solutions efficaces pour la sécurité et l'intégrité des contrats intelligents.
## Introduction et résumé
Ce nouveau système de vérification formelle va changer la façon dont les développeurs peuvent vérifier que leurs contrats intelligents Solidity sont corrects. Il est plus flexible que les autres méthodes automatiques classiques de démonstration de théorèmes, car il est plus facile à programmer par l'homme, mais il offre aussi plus de souplesse pour exprimer et démontrer les propriétés de correction qu'avant.
Ça permet aux développeurs de commencer plus facilement à créer des preuves que les spécifications découlent de la représentation abstraite.
Introduction au cadre
Le framework compile des preuves vérifiables par ordinateur de l'exactitude des contrats intelligents Yul dans un sous-langage de l'assistant de vérification Lean, et il peut compiler des spécifications pour les exécuter sur l'EVM en conformité avec les tests visant à vérifier l'exactitude du modèle.
Cette méthode tire parti des riches bibliothèques mathématiques et de l'automatisation des preuves de l'écosystème Lean. Elle nécessite donc plus d'interventions manuelles que les autres méthodes d'automatisation connues, mais tout argument de justesse pouvant être écrit sur papier peut être prouvé par ordinateur.
Le cadre utilise des bibliothèques de formalisation mathématique efficaces et des options d'automatisation spécifiques au domaine. Mais, comme le montrent plein de théorèmes mathématiques de base, il y aura toujours des affirmations qui peuvent être prouvées dans aucun système assez puissant pour les prouver.
Cette possibilité devrait permettre de vérifier les propriétés de correction des contrats intelligents complexes. Le cadre est particulièrement propice à illustrer sa force en vérifiant les propriétés complexes des algorithmes d'approximation numérique appliqués dans les applications financières décentralisées et les vérificateurs à connaissance nulle sur la chaîne.
Architecture technique et fonctionnalités
Pour faciliter au maximum la confiance, le cadre a été soutenu par des subventions pour tester la sémantique par rapport aux suites de tests de conformité Ethereum et pour étendre le modèle aux derniers plans de mise à niveau d'Ethereum. Ce modèle amélioré sera publié comme un bien public.
Le framework comprend un générateur de conditions de vérification, qui peut extraire des programmes Yul dans l'assistant de preuve Lean. Il décompose non seulement les programmes en blocs gérables faciles à comprendre, mais génère aussi des descriptions simplifiées de la sémantique de ces blocs.
Le framework permet aussi d'écrire des preuves grâce à une bibliothèque de théorèmes et des outils d'automatisation. Les preuves peuvent ensuite être vérifiées avec LeanCompiler, dont le noyau de vérification des preuves est un peu plus petit, mais qui est actuellement considéré comme exempt de bogues dans le sens où il n'accepte pas de preuves de propositions fausses.
Cette approche a l'avantage de permettre d'écrire n'importe quelle propriété pouvant être écrite et prouvée formellement sur papier, puis de la vérifier avec LeanCompiler, qui dispose d'un noyau de vérification des preuves relativement petit et qui est actuellement considéré comme exempt de bogues dans le sens où il n'accepte pas de preuves de propositions fausses. Cette flexibilité est supérieure à celle de la plupart des méthodes automatisées, qui sont limitées par le raisonnement intégré des méthodes.
Compositionnalité et abstraction
Les propriétés de compositionnalité et d'abstraction signifient que les composants éprouvés du code sont gardés quand on les utilise dans de nouvelles situations. Ça permet de remplacer de grandes parties du code sophistiqué par des déclarations simples de leurs actions.
Il peut même prendre en charge le remplacement sécurisé d'implémentations de code par d'autres implémentations alternatives mais sémantiquement équivalentes, par exemple en optimisant les algorithmes et en garantissant leur exactitude.
Le cadre offre une automatisation contrôlée et extensible grâce à des procédures personnalisées qui produisent des preuves vérifiées par le système sous-jacent. Ça réduit beaucoup le travail manuel et les garanties de vérification sont préservées.
Composants du système et flux de travail
Le cadre a trois éléments clés qui bossent ensemble pour offrir une grande puissance de vérification :
- Modèle du dialecte Yul EVM qui explique la sémantique du code Yul dans l'environnement d'assistant de preuve. C'est ce qui donne au raisonnement sur le comportement des programmes sa sémantique sous-jacente
- Recueil de tactiques et de théorèmes personnalisés spécialement conçus pour faciliter la rédaction de preuves concernant les programmes Yul. Ces outils traitent les modèles et les opérations courants qui apparaissent souvent dans la vérification des contrats intelligents
- Le générateur de conditions de vérification crée des modèles de preuve avec une structure de haut niveau et génère automatiquement des preuves qui simplifient les programmes Yul en formes canoniques. Ces conditions de vérification ne sont plus spécifiées en termes de langage Yul, mais plutôt d'une manière plus accessible.
La vérification est un processus structuré. Les utilisateurs commencent avec un programme Yul et le compilent avec des options de compilation spéciales pour produire un code qui respecte les hypothèses structurelles du cadre. Ce code est ensuite traité par le générateur de conditions de vérification pour créer l'infrastructure de preuve nécessaire.
Commencez dès aujourd'hui à vérifier vos contrats intelligents
Transformez votre développement Solidity grâce à la vérification formelle. Commencez dès maintenant.
Exigences relatives à la compilation des contrats
Le cadre suppose une certaine structure des codes Yul.
Mise en pratique : fonction de multiplication
Pour implémenter une fonction de multiplication, les exigences structurelles suivantes doivent être respectées en compilant le code suivant avec des indicateurs de compilation spécifiques. Cet exemple montre comment le framework est capable de gérer les fonctions écrites par l'utilisateur et les structures de flux de contrôle arbitraires.
Le processus de multiplication a deux entrées et fait une multiplication en ajoutant une valeur à un accumulateur autant de fois que nécessaire.
Des interruptions conditionnelles sont utilisées dans les boucles à la place des conditions de boucle standard pour montrer que le framework peut gérer des scénarios de flux de contrôle complexes.
Processus de génération des conditions de vérification
Lancer le générateur de conditions de vérification sur un programme crée une hiérarchie de fichiers structurée avec les fichiers qu'il a générés. En gros, ça donne :
- Fichiers générés pour chaque fichier Yul et contrat
- Autres sous-dossiers courants de blocs de code abstraits
Le framework décompose automatiquement les programmes en unités et génère une logique d'intégration pour s'assurer que les unités composées correspondent au programme original. Chaque bloc de code élémentaire produit trois types de fichiers qui peuvent être facilement raisonnés, des composants réutilisables et de meilleures performances et évolutivité.
Le code du programme Yul et le raisonnement spécifique au framework comprennent des conditions de vérification et des preuves que l'exécution d'un bloc de code entraîne une condition de vérification représentée dans les fichiers de famille générés. Ces fichiers font le lien entre la spécification/satisfaction et l'exécution du code. Il faut faire super gaffe avec les fichiers de famille des utilisateurs, car ce sont les fichiers générés par le framework qui contiennent la logique de vérification que l'utilisateur doit compléter.
Pour combler les lacunes logiques, le système doit fournir des spécifications de comportement conditionnel. Afin d'exprimer la sémantique du contrôle de boucle, le système propose des utilitaires permettant d'effectuer des opérations courantes telles que la sortie de boucle et l'accès aux variables dans les états du programme.
Les spécifications ne doivent pas nécessairement être incorrectes, mais elles peuvent ne pas refléter facilement le comportement souhaité si elles ne précisent pas suffisamment certains points importants. Les problèmes de spécification sont généralement la partie la plus difficile de la vérification formelle, parfois même plus que la rédaction proprement dite des preuves.
Défis liés à la vérification des boucles
Les boucles sont super dures à vérifier avec un système de vérification, en partie à cause du raisonnement inductif souvent nécessaire pour ce genre de système. Le cadre gère ça en donnant des spécifications systématiques des composants de boucle.
L'utilisateur doit préciser :
- Conditions de résiliation
- Comportement après itération
- Comportement du corps de la boucle
- Invariants de boucle en général
Le framework prend en charge la description de la sémantique des boucles de mises à jour de variables simples pour élaborer une logique conditionnelle. Même si ce genre de détail technique peut sembler pas très clair au premier abord, il permet de s'assurer que toutes les possibilités d'exécution sont couvertes.
Construction et automatisation de la relecture
Une fois les spécifications établies, l'utilisateur doit montrer que les conditions de vérification peuvent prouver les spécifications indiquées. Le cadre offre une automatisation massive pour traiter les modèles de preuves typiques.
Des tactiques personnalisées sont utilisées pour traiter :
- Stockez les manipulations dans des variables
- Raisonnement sur le contrôle du flux
- Autres problèmes de vérification courants
Ces méthodes automatisées permettent de réduire considérablement le travail manuel nécessaire pour effectuer les vérifications tout en maintenant un niveau de vérification super élevé.
Le processus de vérification commence généralement par le déploiement des abstractions correspondantes, car ces preuves sont directement liées aux propriétés définies par l'utilisateur. Il applique le cadre pour automatiser un grand nombre de conditions de vérification à l'aide de tactiques de nettoyage polyvalentes utilisées pour gérer les détails techniques tels que les opérations de stockage des variables et les transitions d'état.
Fonctionnalités avancées et développement futur
Le framework est un outil complexe qui permet de transformer n'importe quel programme Yul en un ensemble d'instructions décrivant ce que le programme est censé faire et de prouver que le code répond aux attentes. Les programmes sont d'abord traduits en programmes avec des preuves de cohérence dans une représentation abstraite, ce qui donne des points de départ simplifiés pour d'autres preuves de spécification.
Les modèles dans le raisonnement du programme Yul, comme les opérations sur un magasin de variables, sont gérés par des procédures d'automatisation personnalisées.
Développement ultérieur
Les développements ultérieurs apportent plusieurs améliorations notables :
- Le modèle de hachage fiable aura une sémantique cryptographique correcte.
- La modélisation des appels inter-contrats permettra de comprendre les schémas complexes d'interaction.
- L'exactitude sémantique sera vérifiée par modélisation du gaz en tenant compte du coût d'exécution
- Respecter les dernières modifications des plans de mise à niveau d'Ethereum pour que ça colle avec le fonctionnement actuel du réseau
- Améliorer la convivialité permettra aux utilisateurs de rendre leur utilisation quotidienne plus efficace et plus conviviale
On peut encore bosser pour extraire les clients d'exécution Ethereum des spécifications et créer des compilateurs Yul vers EVM bytecode qui sont vérifiés de manière formelle.
Intégration avec les bibliothèques mathématiques
Le framework s'appuie sur un large éventail de bibliothèques mathématiques et informatiques dans son système de preuve sous-jacent. Ces bibliothèques offrent des concepts formalisés qui apparaissent souvent lors du raisonnement sur les programmes, ce qui simplifie grandement l'effort nécessaire pour effectuer des preuves complexes.
Les tactiques personnalisées s'appuient sur un environnement de métaprogrammation solide sans compromettre la vérification. La nature modulable de l'automatisation, qui s'appuie sur les modèles d'utilisation observés, garantit une amélioration continue de la convivialité au fil du temps.
L'architecture permet d'encoder Yul directement dans l'environnement de preuve, ce qui rend l'interface transparente et naturelle pour les développeurs habitués au langage, et offre des capacités inédites en matière de vérification automatisée pour garantir l'exactitude du code.
