Qu'est-ce qu'une attaque de réentrance? Comment empêcher cette vulnérabilité?

Les attaques de réentrance exploitent les défauts du contrat intelligent, permettant des appels de fonction répétés avant la résolution de l'État, conduisant à des actions non autorisées; Empêcher avec le modèle de contrôle-effets-interactions.

Apr 12, 2025 at 12:35 am

Une attaque de réentrance est un type de vulnérabilité de sécurité qui peut se produire dans les contrats intelligents, en particulier ceux de la blockchain Ethereum. Cette attaque exploite une faille dans la logique du contrat qui permet à un attaquant d'appeler à plusieurs reprises une fonction avant que l'appel initial ne soit complètement résolu. Cela peut entraîner des retraits non autorisés ou d'autres actions malveillantes. Dans cet article, nous explorerons les mécanismes d'une attaque de réentrance, examinerons des exemples du monde réel et fournirons des conseils détaillés sur la façon d'empêcher cette vulnérabilité dans vos contrats intelligents.

Comprendre les attaques de réentrance

Une attaque de réentrance se produit lorsqu'un contrat intelligent appelle un contrat externe avant de résoudre ses propres changements d'État. Cela peut créer une fenêtre d'opportunité pour le contrat externe pour réintégrer le contrat d'origine et manipuler son état. L'attaque implique généralement un contrat malveillant qui draine les fonds du contrat de victime en appelant à plusieurs reprises une fonction telle que withdraw() avant que le contrat de victime ne puisse mettre à jour son solde.

Pour illustrer, considérez un exemple simple d'un contrat qui permet aux utilisateurs de déposer et de retirer des fonds:

 contract Vulnerable { mapping(address => uint) public balances; function deposit() public payable { balances[msg.sender] += msg.value; } function withdraw(uint amount) public { require(balances[msg.sender] >= amount, 'Insufficient balance'); (bool success, ) = msg.sender.call{value: amount}(''); require(success, 'Transfer failed'); balances[msg.sender] -= amount; }

}

Dans cet exemple, la fonction withdraw vérifie d'abord si l'utilisateur a un solde suffisant, puis tente d'envoyer les fonds à l'utilisateur et met enfin à mettre à jour le solde de l'utilisateur. La vulnérabilité réside dans le fait que les balances[msg.sender] ne sont mis à jour qu'après l'appel externe à msg.sender.call . Si le msg.sender est un contrat malveillant, il peut réintégrer la fonction withdraw avant que le solde ne soit mis à jour, permettant les retraits multiples avant que le solde ne soit fixé à zéro.

Exemples du monde réel d'attaques de réentrance

L'une des attaques de réentrance les plus infâmes s'est produite lors du hack DAO en 2016. Le DAO (organisation autonome décentralisée) était un contrat intelligent sur la blockchain Ethereum qui a permis aux utilisateurs d'investir dans des projets. Le contrat avait une vulnérabilité similaire à celle décrite ci-dessus, qui a permis à un attaquant de drainer environ 3,6 millions d'ETH du DAO.

Un autre exemple est le piratage de portefeuille de parité en 2017. Le portefeuille de parité, un portefeuille multi-signature populaire sur Ethereum, a été exploité en raison d'une vulnérabilité de réentrance. L'attaquant a pu égoutter les fonds à partir de plusieurs portefeuilles, entraînant des pertes importantes pour les utilisateurs.

Comment éviter les attaques de réentrance

La prévention des attaques de réentrance nécessite une conception minutieuse et une mise en œuvre de contrats intelligents. Voici quelques stratégies pour atténuer cette vulnérabilité:

Utilisez le modèle de vérification des effets d'interactions

Le modèle de chèques-effets-interactions est la meilleure pratique pour rédiger des contrats intelligents sécurisés. Ce modèle garantit que toutes les modifications d'état sont apportées avant que des appels externes ne soient exécutés. Dans le contexte de la fonction withdraw , cela signifie mettre à jour le solde de l'utilisateur avant d'envoyer les fonds:

 contract Secure { mapping(address => uint) public balances; function deposit() public payable { balances[msg.sender] += msg.value; } function withdraw(uint amount) public { require(balances[msg.sender] >= amount, 'Insufficient balance'); balances[msg.sender] -= amount; (bool success, ) = msg.sender.call{value: amount}(''); require(success, 'Transfer failed'); }

}

En mettant à jour le solde avant de passer l'appel externe, le contrat garantit que le solde de l'utilisateur est correctement défini sur zéro avant que toute réentrance puisse se produire.

Utilisez le modèle de retrait

Un autre moyen efficace de prévenir les attaques de réentrance consiste à utiliser le modèle de retrait . Au lieu d'envoyer directement des fonds aux utilisateurs, le contrat stocke le montant du retrait et permet aux utilisateurs de retirer leurs fonds ultérieurement. Cette approche élimine le besoin d'appels externes pendant le processus de retrait:

 contract WithdrawalPattern { mapping(address => uint) public balances; mapping(address => uint) public withdrawalPending; function deposit() public payable { balances[msg.sender] += msg.value; } function requestWithdrawal(uint amount) public { require(balances[msg.sender] >= amount, 'Insufficient balance'); balances[msg.sender] -= amount; withdrawalPending[msg.sender] += amount; } function withdraw() public { uint amount = withdrawalPending[msg.sender]; require(amount > 0, 'No pending withdrawal'); withdrawalPending[msg.sender] = 0; (bool success, ) = msg.sender.call{value: amount}(''); require(success, 'Transfer failed'); }

}

Dans cet exemple, la fonction requestWithdrawal met à jour le solde de l'utilisateur et stocke le montant de retrait dans withdrawalPending . La fonction withdraw envoie ensuite les fonds à l'utilisateur sans aucun risque de réentrance.

Mettre en œuvre les gardes de réentrance

Les gardes de réentrance sont une autre technique pour empêcher les attaques de réentrance. Ces gardes utilisent une variable d'état pour expliquer si une fonction est actuellement en cours d'exécution. Si une fonction est rentrée, le gardien empêchera l'exécution supplémentaire:

 contract ReentrancyGuard { bool private _notEntered; constructor() { _notEntered = true; } modifier nonReentrant() { require(_notEntered, 'ReentrancyGuard: reentrant call'); _notEntered = false; _; _notEntered = true; } function withdraw(uint amount) public nonReentrant { require(balances[msg.sender] >= amount, 'Insufficient balance'); balances[msg.sender] -= amount; (bool success, ) = msg.sender.call{value: amount}(''); require(success, 'Transfer failed'); }

}

Le modificateur nonReentrant garantit que la fonction withdraw ne peut pas être rentrée pendant qu'elle s'exécute.

Test et audit pour les vulnérabilités de réentrance

En plus de mettre en œuvre des mesures préventives, il est crucial de tester et d'auditer soigneusement vos contrats intelligents pour les vulnérabilités de réentrance. Voici quelques étapes à suivre:

• Tests unitaires : écrivez des tests unitaires qui simulent les attaques de réentrance pour garantir que votre contrat se comporte correctement dans de telles conditions.
• Analyse statique : Utilisez des outils comme Mythril et Slither pour détecter automatiquement les vulnérabilités de réentorance potentielles dans votre code.
• Audit manuel : les auditeurs de contrats intelligents expérimentés examinent votre code pour tout problème de réentrance potentiel. Les audits manuels peuvent révéler des vulnérabilités complexes que les outils automatisés pourraient manquer.

Meilleures pratiques pour le développement de contrats intelligents

Pour réduire davantage le risque d'attaques de réentrance, considérez les meilleures pratiques suivantes:

• Gardez les contrats simples : les contrats complexes sont plus susceptibles de contenir des vulnérabilités. Gardez vos contrats aussi simples et simples que possible.
• Utilisez des bibliothèques établies : tirez parti des bibliothèques et des cadres bien audités, tels que Openzeppelin , qui fournissent des implémentations sécurisées de modèles de contrat communs.
• Mises à jour régulières : restez informé des dernières meilleures pratiques de sécurité et mettez à jour vos contrats en conséquence.

Questions fréquemment posées

Q: Les attaques de réentrance peuvent-elles se produire dans d'autres plates-formes de blockchain en plus d'Ethereum?

R: Bien que les attaques de réentrance soient le plus souvent associées à Ethereum en raison de son utilisation généralisée de contrats intelligents, des vulnérabilités similaires peuvent se produire sur d'autres plateformes de blockchain qui prennent en charge les contrats intelligents, tels que Binance Smart Chain et Solana. Les principes de prévention des attaques de réentrance restent les mêmes sur différentes plates-formes.

Q: Y a-t-il des outils spécialement conçus pour détecter les vulnérabilités de réentrance?

R: Oui, plusieurs outils sont conçus pour détecter les vulnérabilités de réentrance dans les contrats intelligents. Mythril et Slith sont des outils d'analyse statique populaires qui peuvent identifier les problèmes de réentrance potentiels. De plus, Echidna est un outil de test basé sur la propriété qui peut être utilisé pour tester les vulnérabilités de réentrance grâce à la génération automatisée de cas de test.

Q: Comment puis-je m'assurer que mon contrat intelligent soit sécurisé contre les attaques de réentrance si je ne suis pas un expert en sécurité?

R: Si vous n'êtes pas un expert en sécurité, il est fortement recommandé d'engager des auditeurs de contrats intelligents professionnels pour examiner votre code. De plus, l'utilisation de bibliothèques établies comme Openzeppelin et la suite des meilleures pratiques telles que le modèle de contrôle-effets-interactions peuvent réduire considérablement le risque de vulnérabilités de réentrance. La mise à jour régulière de vos connaissances sur la sécurité des contrats intelligentes et la participation aux discussions communautaires peuvent également vous aider à rester informé des dernières pratiques de sécurité.