Guide rapide sur les attaques par adresses courtes dans les cryptomonnaies

Avez-vous déjà entendu parler d'une attaque par adresse courte ? Il s'agit d'une vulnérabilité notable des contrats intelligents Ethereum, qui permet aux attaquants d'exploiter les différences de gestion des adresses de différentes longueurs. 

Pour approfondir le sujet, cet article explore les mécanismes des attaques par adresses courtes, leur impact et les principales stratégies de prévention. En dissipant les idées reçues et en proposant des pistes pour atténuer ces attaques, nous souhaitons offrir un aperçu complet, tant aux utilisateurs occasionnels qu'aux experts.

À lire également : Quelle est la cryptomonnaie la plus sûre ?

Points clés à retenir

• Les attaques par adresse courte exploitent les vulnérabilités des contrats intelligents dans les portefeuilles de cryptomonnaie en envoyant des fonds à une adresse courte et similaire, incitant les utilisateurs à commettre des erreurs.

• Les utilisateurs peuvent perdre des fonds s’ils envoient accidentellement des crypto-monnaies à ces adresses trompeuses en raison du manque de contrôles dans certaines interfaces de portefeuille.

• Les stratégies d’atténuation incluent l’utilisation d’outils de vérification d’adresse et la garantie que le logiciel de portefeuille est à jour.

Qu'est-ce qu'une attaque par adresse courte ?

Ethereum, en tant que plateforme décentralisée, permet l'exécution de contrats intelligents grâce au langage de programmation Solidity. De même, Solidity impose des longueurs d'adresse strictes, exigeant que les adresses fassent exactement 20 octets (40 caractères hexadécimaux).

Cela garantit la cohérence et la sécurité lors du traitement des adresses dans les transactions de contrats intelligents. Cependant, une attaque par adresse courte est une vulnérabilité où les attaquants exploitent les algorithmes de codage d'adresse en ignorant les caractères de fin d'une chaîne codée. 

En créant une chaîne codée qui correspond au préfixe d’une adresse légitime, les attaquants incitent les utilisateurs à envoyer des fonds ou à effectuer des opérations à l’aide de l’adresse contrôlée par l’attaquant. 

Bien que les adresses Ethereum soient généralement de 20 octets, si un attaquant utilise une adresse plus courte que 20 octets, Solidity remplit automatiquement les octets restants à droite avec des zéros pour maintenir la longueur d'adresse correcte. 

Par exemple, si une fonction attend deux arguments, comme une adresse et un montant de jetons, le contrat peut interpréter par inadvertance une partie du second argument (le montant de jetons) comme faisant partie du premier (l'adresse) en raison de ce remplissage automatique. Cette mauvaise interprétation permet à l'attaquant d'envoyer un nombre de jetons supérieur à celui initialement prévu.

En substance, ce type d'attaque exploite souvent l'erreur humaine, car les utilisateurs peuvent ne pas vérifier chaque caractère de l'adresse d'un portefeuille en raison de sa complexité. Les attaquants exploitent donc cette situation en créant des adresses presque identiques aux adresses réelles, mais légèrement raccourcies ou modifiées.

Exemple d'attaque par adresse courte

Considérez le code de solidité ci-dessous qui est utilisé pour transférer des jetons du compte de l'expéditeur à un autre :

fonction transfert(adresse _à, uint256 _valeur) public {

    require(_to.length == 20);

    _to.transfer(_valeur);

}

Cette fonction de contrat est conçue pour transférer un montant spécifié à une adresse donnée. Pour vérifier que l'adresse fournie est une valeur valide de 20 octets, le contrat vérifie sa longueur grâce à la propriété « length ». 

Cependant, s'appuyer sur la propriété « length » n'est pas une méthode fiable pour valider une adresse, car elle renvoie le nombre d'octets, et non de bits. Cela crée une vulnérabilité aux attaques par adresse courte : un attaquant pourrait fournir une adresse de moins de 20 octets, tout en paraissant valide car sa longueur est égale ou supérieure à 20 octets.

Pour montrer comment une attaque par adresse courte peut se produire, considérez le code Solidity suivant :

fonction transfert(adresse _à, uint256 _valeur) public {

    require(_to.length == 20);

    _to.transfer(_valeur);

}

fonction testAttack() public {

    adresse shortAddress = 0x01;

    valeur uint256 = 100 ;

    transfert(shortAddress, valeur);

}

Dans ce cas, la fonction de transfert est identique à celle utilisée dans l'exemple précédent. Cependant, le contrat inclut également une fonction « testAttack », qui appelle la fonction de transfert avec une adresse courte et une valeur de 100. 

Comme la fonction de transfert valide l'adresse grâce à la propriété « length », elle suppose à tort que l'adresse fournie est valide sur 20 octets et poursuit le transfert. Cependant, comme l'adresse est en réalité plus courte que 20 octets, le transfert échouera et la valeur ne sera pas transférée.

Comment fonctionne une attaque par adresse courte ?

La norme ERC20 stipule que la fonction « transfer » nécessite deux paramètres : l'adresse du destinataire et une valeur « uint256 » représentant le nombre de jetons à transférer. Lors d'une attaque par adresse courte, l'attaquant fournit une entrée plus courte que celle attendue par le contrat.

Cela entraîne une mauvaise interprétation des données par le contrat récepteur, car les champs peuvent être désalignés. Certaines applications tierces qui encodent les données de transaction ne gérant pas correctement le remplissage ou ne validant pas correctement la longueur, le contrat peut traiter des transactions mal formatées, ce qui peut entraîner un comportement inattendu.

Voici une description simplifiée du processus :

Manipulation de l'adresse

L'attaquant fournit une version abrégée d'une adresse de portefeuille légitime. Dans certains cas, il peut utiliser un outil ou un logiciel malveillant pour renseigner automatiquement ou afficher une adresse erronée lors de la transaction.

Par exemple, l'attaquant envoie une transaction à la fonction de transfert avec une adresse courte 0x123456 et un montant de 1000.

Rembourrage

Le client Ethereum ajoute des zéros à l'adresse courte pour l'étendre aux 20 octets requis. Ce remplissage désaligne les paramètres suivants de la transaction, ce qui conduit le contrat intelligent à mal interpréter les données de la transaction.

Par exemple, le client Ethereum complète la valeur 0x123456 en 0x1234560000000000000000000000000000000000 . Cela décale le paramètre de montant prévu de 1000, ce qui amène le contrat à interpréter incorrectement les données.

Erreur humaine

L'utilisateur qui initie la transaction ne remarque pas que l'adresse du portefeuille est incomplète ou incorrecte. Cela se produit souvent car les adresses sont longues et les utilisateurs supposent qu'un simple copier-coller sera toujours exact.

Transfert de fonds

L'utilisateur envoie des cryptomonnaies à l'adresse raccourcie ou incorrecte. Les transactions blockchain étant irréversibles, les fonds sont perdus ou envoyés à l'adresse de l'attaquant.

L'un des cas les plus marquants d'attaque par adresse raccourcie s'est produit mi-2022 lorsqu'un influenceur crypto de renom a publiquement annoncé un transfert prévu de 250 ETH (d'une valeur d'environ 500 000 $ à l'époque). Des pirates, surveillant les transactions de l'influenceur, ont substitué une version raccourcie de l'adresse du portefeuille du destinataire dans le champ de la transaction.

L'influenceur, pensant que l'adresse était exacte, a envoyé les fonds à l'adresse de l'attaquant sans le savoir. Malgré des tentatives rapides pour annuler la transaction, l'irréversibilité de la blockchain a entraîné une perte définitive.

Cet incident a mis en évidence l’importance de vérifier les adresses de portefeuille, en particulier lorsqu’il s’agit de grosses sommes d’argent ou de transactions publiques.

Il convient toutefois de noter qu'à partir de la version 0.5.0 de Solidity , le compilateur effectue des vérifications à l'exécution afin de s'assurer que la taille des données d'appel correspond à la longueur attendue pour les arguments de taille statique, ou qu'elle est au moins égale à la taille minimale requise pour les arguments de taille dynamique. Ces vérifications contribuent à se prémunir contre les techniques de manipulation, telles que les attaques par adresse courte, où des attaquants pourraient tenter d'exploiter des différences de longueur de données.

De plus, il garantit la cohérence des données lors de l’exécution du contrat.

« La blockchain est une technologie très intéressante qui aura des applications très profondes pour la société dans les années à venir. » — Kenneth C. Griffin

Impact des attaques par adresses courtes

Les attaques par adresse courte ne sont peut-être pas aussi répandues que le phishing ou les arnaques au rug pull , mais leur impact est important, notamment pour les transactions de grande valeur.

De plus, comme les attaques par adresses courtes reposent sur des manipulations subtiles, elles peuvent souvent contourner les contrôles de sécurité standard, ce qui les rend particulièrement dangereuses pour les utilisateurs qui ne sont pas habitués à vérifier chaque détail de leur transaction.

La plupart des attaques par adresse courte ont été signalées sur des plateformes de finance décentralisée (DeFi) et des services de portefeuilles numériques dépourvus de mesures de vérification rigoureuses. Ces plateformes sont particulièrement vulnérables en raison de la nature des transactions de pair à pair et de l'absence d'intermédiaires capables de valider l'exactitude des adresses de portefeuilles.

Selon Chainanalysis , au premier trimestre 2022, les pirates informatiques ont dérobé 1.3 milliard de dollars à des plateformes d'échange, des plateformes et des entités privées, une part importante de ces pertes affectant de manière disproportionnée le secteur de la finance décentralisée (DeFi).

De plus, notez que si tout le monde peut être victime d'un piratage, la majorité des victimes appartiennent généralement à la catégorie des utilisateurs de cryptomonnaies novices ou inexpérimentés. La complexité des adresses de portefeuille et la méconnaissance des protocoles de transaction contribuent à leur vulnérabilité.

Même les plus grandes entreprises de cryptomonnaies ne disposent probablement pas de cyberdéfenses suffisamment sophistiquées pour déjouer les pirates. Avec la croissance rapide du secteur des cryptomonnaies, il est compréhensible qu'il soit difficile de suivre le rythme. — Luke Willmott, cofondateur et directeur opérationnel d'AutoCoinCars, une plateforme automobile basée sur les cryptomonnaies.

Comment détecter les vulnérabilités liées aux attaques par adresses courtes

La détection des vulnérabilités liées aux attaques par adresses courtes nécessite une approche multicouche, incluant des analyses de code approfondies, des outils automatisés et des pratiques de sécurité renforcées. Voici quelques méthodes pour détecter ces vulnérabilités dans les contrats intelligents :

Audits de code et vérification formelle

L'un des moyens les plus efficaces de détecter les vulnérabilités liées aux adresses courtes consiste à effectuer des audits manuels du code et des processus de vérification formels. Les auditeurs expérimentés en sécurité des contrats intelligents peuvent identifier les faiblesses potentielles dans la gestion des adresses par le contrat. 

La vérification formelle utilise des modèles mathématiques pour prouver que le contrat se comporte comme prévu dans tous les cas, y compris ceux impliquant des adresses mal formées ou raccourcies.

Outils de sécurité automatisés

Il existe plusieurs outils automatisés conçus pour détecter les vulnérabilités des contrats intelligents, notamment ceux sujets aux attaques par adresses courtes. Parmi les outils les plus populaires, on trouve :

• MytheX:Il s'agit d'un outil d'analyse de sécurité des contrats intelligents Ethereum qui permet d'identifier les vulnérabilités potentielles, notamment les problèmes d'adresse courte.
• Sécuriser:Un outil d'audit qui effectue des contrôles de sécurité automatisés pour les contrats intelligents et signale les problèmes liés au formatage des adresses.
• Plugins IDE Remix:Les développeurs Ethereum peuvent utiliser Remix IDE avec des plugins de sécurité qui signalent automatiquement le code vulnérable.

Ces outils analysent la logique du contrat et mettent en évidence les pratiques dangereuses qui pourraient être exploitées via des attaques par adresse courte.

Validation de la longueur dans le code

Les développeurs de contrats intelligents doivent implémenter une validation de la longueur des adresses afin de garantir que toutes les adresses mesurent 20 octets avant de traiter les transactions. Cela peut se faire en vérifiant explicitement la longueur du paramètre d'adresse et en rejetant les transactions dont les adresses sont raccourcies ou mal formatées.

Par exemple, dans Solidity, les développeurs peuvent utiliser la fonction suivante pour valider une adresse :

fonction isValidAddress(adresse _addr) public pure renvoie (bool) {

    retourner _addr != adresse(0) && _addr == adresse(uint160(_addr));

}

Cette vérification simple garantit que la longueur de l'adresse est correcte avant de traiter la transaction, évitant ainsi d'éventuelles attaques par adresse courte.

Simulation de réseau de test et tests de pénétration

Avant de déployer un contrat intelligent sur le réseau principal Ethereum, les développeurs doivent effectuer des simulations de réseau de test et des tests d'intrusion afin d'identifier les vulnérabilités potentielles. Ces tests reproduisent des scénarios d'attaque réels et peuvent révéler des problèmes qui pourraient ne pas être apparents lors du développement. 

En simulant des attaques d’adresses courtes sur un réseau de test, les développeurs peuvent évaluer si leur contrat gère correctement le formatage des adresses et garantit des transactions sécurisées.

Lire aussi : Statistiques sur les failles de sécurité dans le domaine des cryptomonnaies : tendances et analyses

Comment prévenir les attaques par adresses courtes

La prévention des attaques par adresses courtes nécessite à la fois des solutions technologiques et la sensibilisation des utilisateurs. Plusieurs stratégies efficaces peuvent contribuer à réduire le risque d'être victime de telles attaques :

Validation des entrées

Utilisez des mécanismes de validation d'entrée performants dans l'interface utilisateur ou les composants hors chaîne pour vérifier que les adresses respectent la longueur et le format attendus. Par exemple, de nombreux portefeuilles cryptographiques proposent désormais des outils de vérification d'adresse qui valident automatiquement l'adresse complète avant toute transaction. 

Ces outils empêchent les utilisateurs d'envoyer des fonds à une adresse tronquée ou incorrecte. Tokenview , par exemple , est un vérificateur d'adresses de portefeuilles crypto largement utilisé, qui simplifie la vérification des adresses sur plusieurs blockchains.

Il permet aux utilisateurs de confirmer l'authenticité des adresses tout en fournissant des informations sur les jetons détenus, l'historique des transactions et d'autres détails pertinents.

Éducation des utilisateurs

Étant donné que de nombreuses attaques par adresses courtes exploitent l'erreur humaine, la formation des utilisateurs est cruciale. Les plateformes d'échange de cryptomonnaies et les fournisseurs de portefeuilles peuvent réduire les risques en apprenant aux utilisateurs à vérifier leurs adresses et en les encourageant à revérifier leurs transactions avant d'envoyer des fonds. 

Des étapes simples, comme copier-coller l’adresse complète dans un bloc-notes pour la vérifier manuellement, peuvent empêcher de nombreuses attaques.

Mécanisme de somme de contrôle 

Une somme de contrôle est une chaîne de chiffres et de lettres dérivée des données d'origine, permettant de détecter les erreurs. Vérifiez que toutes les adresses sont des adresses Ethereum valides avec somme de contrôle. 

La mise en œuvre de sommes de contrôle permet de vérifier leur conformité au format d’adresse Ethereum, minimisant ainsi le risque de manipulations d’adresses courtes.

Audit et tests

Des audits réguliers des contrats intelligents et des tests complets peuvent révéler des vulnérabilités de sécurité. Par conséquent, l'utilisation d'outils d'audit automatisés, conjuguée à des revues de code manuelles, peut jouer un rôle crucial dans la prévention de telles attaques.

Vérification formelle 

La vérification formelle consiste à prouver mathématiquement l'exactitude des contrats intelligents. Cette méthode permet de garantir le traitement précis des paramètres d'entrée, empêchant ainsi les attaques par adresses courtes.

Solidity SMTChecker est un exemple d'outil de vérification formelle . Intégré au compilateur Solidity, il utilise des méthodes formelles pour détecter les erreurs logiques.

Bibliothèques mathématiques sécurisées

L'utilisation de bibliothèques mathématiques sécurisées comme SafeMath d'OpenZeppelin renforce la protection contre les attaques par adresse IP courte. Ces bibliothèques fournissent des fonctions effectuant des opérations mathématiques avec des contrôles de sécurité intégrés, garantissant ainsi le déclenchement d'erreurs en cas de dépassement de capacité.

Autres vulnérabilités courantes des contrats intelligents

Les contrats intelligents offrent un avantage clé en nous permettant de vérifier le logiciel sous-jacent et ses opérations sans avoir à faire confiance au fournisseur de services.

Cependant, la présence de contrats intelligents attire également des individus cherchant à exploiter des vulnérabilités potentielles. En coulisses, certains cherchent à exploiter les faiblesses du code.

Ces dernières années, des milliards de dollars en cryptomonnaies ont été perdus en raison de failles de sécurité dans les contrats intelligents. Par exemple, en août 2022, la société américaine Nomad a annoncé le vol de 190 millions de dollars en cryptomonnaies suite au piratage de son pont de tokenisation.

Cela souligne l'urgence de renforcer les mesures de sécurité. Examinons rapidement d'autres vulnérabilités des contrats intelligents à connaître :

Dépassement/sous-dépassement d'entier

Les dépassements et les sous-dépassements d'entiers sont des problèmes fréquents dans les contrats intelligents Solidity. Ils surviennent lorsque les opérations arithmétiques dépassent les valeurs maximales ou minimales pouvant être stockées dans un type de données. Ces problèmes affectent les types de données « uint » et « int », ce qui peut entraîner des comportements inattendus ou la perte d'actifs. 

Par exemple, si le contrat utilise 32 bits de mémoire pour chaque entier, il ne peut stocker que des valeurs comprises entre [0, 2 147 483 647]. Si une opération arithmétique génère une valeur supérieure à 2 147 483 647, la variable sera automatiquement ramenée à 0, ce qui peut entraîner des problèmes importants.

L'attaque Proof of Weak Hands Coin (PoWHC) en est un exemple . PoWHC est un système de Ponzi construit sur Ethereum avec Solidity, créé par un groupe issu de 4chan. Dans ce cas précis, les auteurs du contrat intelligent n'ont pas pris en compte les situations de sous-dépassement et de dépassement de capacité, ce qui a entraîné le retrait non autorisé de 866 ethers du contrat.

Recommandation

Utilisez la bibliothèque SafeMath de Solidity pour vous protéger contre les dépassements de capacité et les dépassements de capacité inférieurs. Cette bibliothèque propose des fonctions permettant d'effectuer des opérations arithmétiques qui vérifient automatiquement ces conditions et lèvent une exception en cas de dépassement ou de dépassement inférieur.

Attaque de réentrée

La réentrance est une vulnérabilité de sécurité des contrats intelligents Solidity qui permet aux attaquants d'invoquer à plusieurs reprises des fonctions du contrat, ce qui peut entraîner le vol de fonds ou d'actifs. Cette vulnérabilité survient lorsqu'un attaquant parvient à appeler une fonction du contrat plusieurs fois avant la fin de son exécution initiale, ce qui lui permet de manipuler l'état du contrat et de détourner des jetons.

Les attaques par réentrance sont une méthode courante utilisée par les pirates informatiques malveillants ; elles représentent 5 des 60 piratages attribués à des vulnérabilités et ont entraîné des pertes totales de 8.5 millions de dollars au cours du premier semestre 2023. Un exemple notable s’est produit en juin 2016 lorsqu’une telle attaque a drainé les fonds de « la DAO », incitant les développeurs d’Ethereum à créer une bifurcation de la blockchain.

Recommandation

Pour réduire cette vulnérabilité, une solution efficace consiste à utiliser le modificateur « nonReentrant » fourni par l'implémentation ERC20 d'OpenZeppelin. 

Il est important de noter qu'en raison de la présence d'une seule protection « non-réentrante », les fonctions marquées avec ce modificateur ne peuvent pas s'appeler directement. Cependant, cette limitation peut être contournée en rendant ces fonctions privées et en fournissant des points d'entrée externes marqués comme « non-réentrants ».

Pour atténuer les attaques par réentrance, une autre stratégie efficace consiste à implémenter le modèle « Vérifications-Effets-Interactions ». Cette approche commence par la validation des entrées et des conditions, puis par la mise à jour des variables d'état et enfin par l'interaction avec les contrats externes. 

En garantissant que toutes les modifications d’état sont finalisées avant toute interaction externe, ce modèle empêche efficacement les vulnérabilités de réentrance.

Stockage de données incorrect

Une erreur fréquente dans le développement de contrats intelligents est l'utilisation d'une mémoire de stockage de données non optimisée, ce qui peut entraîner une augmentation des coûts de transaction. La mémoire sert de zone de stockage temporaire pour les variables pendant l'exécution du contrat et est vidée après chaque appel de fonction.

Recommandation

Pour les fonctions qui n'ont besoin que de lire des valeurs, il est conseillé d'utiliser calldata. Calldata est une zone de stockage en lecture seule qui contient les arguments de fonction passés à un contrat, permettant ainsi d'optimiser les coûts de gaz et de garantir l'immuabilité des arguments d'entrée.

Exploits d'approbation

Les exploits d'approbation constituent une faille de sécurité présente dans les contrats de jetons ERC20. Les utilisateurs autorisent un contrat tiers à transférer un nombre illimité de jetons en leur nom. Cela permet au contrat approuvé de transférer des jetons du compte de l'utilisateur vers n'importe quel autre compte sans autorisation supplémentaire.

Le problème avec cette configuration est qu'elle permet au contrat approuvé de transférer des jetons à tout moment, même si l'utilisateur révoque son approbation ou si le contrat est compromis. Par conséquent, un attaquant peut exploiter cette vulnérabilité en prenant le contrôle du contrat approuvé et en effectuant des transferts de jetons non autorisés du compte de l'utilisateur vers le sien.

Recommandation

Afin de réduire le risque d'exploitation des approbations, les contrats de jetons ERC20 doivent prévoir un mécanisme d'allocation limitant le nombre de jetons qu'un contrat approuvé peut transférer au nom de l'utilisateur. Cela peut se faire en fixant une allocation maximale ou en mettant en place une allocation limitée dans le temps, expirant après une période spécifiée.

De plus, les développeurs peuvent améliorer la sécurité en exigeant la confirmation de l’utilisateur pour chaque transfert de jeton ou en utilisant l’authentification multifacteur pour vérifier les transferts de jetons.

Dépendance d'état interfonctionnelle

La vulnérabilité de dépendance d'état interfonctionnelle est similaire à la vulnérabilité de réentrance, qui survient lorsque deux fonctions s'appuient sur le même état de contrat. Cela peut entraîner des résultats inattendus si une fonction est invoquée alors qu'une autre est en cours d'exécution. 

De plus, ce problème peut survenir lorsque les deux fonctions sont appelées en même temps, ce qui entraîne des conditions de concurrence potentielles qui menacent l'intégrité du contrat intelligent.

Recommandation

Pour réduire cette vulnérabilité, il est conseillé de mettre en œuvre les mêmes mesures préventives que celles utilisées pour gérer des situations de concurrence similaires. Plus précisément, assurez-vous que tous les changements d'état sont finalisés avant tout transfert d'Ether. 

En suivant cette approche, le contrat intelligent effectuera toutes les modifications d’état nécessaires avant de lancer toute transaction Ether.

« Il n'y a aucun recours. C'est irréparable. On ne peut pas annuler les transactions blockchain. » — Alx Finn, entrepreneur en cryptomonnaies 

Conclusion : L’avenir de la prévention des attaques par adresses courtes

Les attaques par adresses courtes constituent une préoccupation majeure en raison des pertes souvent importantes qu'elles entraînent. Face à l'évolution des cryptomonnaies et de la technologie blockchain, il est crucial pour les utilisateurs et les plateformes de rester vigilants face à ce type d'attaques.

La combinaison de la formation des utilisateurs, des avancées technologiques et des améliorations de la plateforme peut réduire considérablement le risque de telles attaques. En sensibilisant davantage et en encourageant les bonnes pratiques, la communauté des cryptomonnaies peut créer un environnement plus sûr pour tous les utilisateurs.

En fin de compte, la meilleure défense contre les attaques par adresses courtes réside dans la diligence. Les utilisateurs doivent prendre le temps de vérifier chaque transaction, et les plateformes doivent mettre en œuvre des mesures de sécurité avancées pour se protéger contre les menaces en constante évolution. 

À mesure que le paysage cryptographique mûrit, ces efforts seront essentiels pour maintenir la confiance et sécuriser les actifs numériques contre les attaques frauduleuses.

FAQ