Comprendre les attaques par débordement et sous-dépassement sur les contrats intelligents

Guide des attaques par débordement et sous-dépassement sur les contrats intelligents.

Considérez le diagramme suivant:

Comprendre les attaques par débordement et sous-dépassement sur les contrats intelligents

C’est un odomètre normal qui calcule la distance parcourue par votre voiture. Cet odomètre va de 000000 à 999999. C’est pourquoi au moment où vous traversez à 1 000 000 km votre odomètre reviendra à 000000.

Cela peut avoir des répercussions sérieuses.

Comprendre les attaques par débordement et sous-dépassement sur les contrats intelligents

Pensez au tournant du millénaire et le problème de l’an 2000. L’an 2000 était une classe de bogues informatiques qui menaçait de causer des ravages au tournant du millénaire. Pour garder les choses aussi simples que possible, de nombreux programmes représentaient des années à quatre chiffres avec seulement les deux derniers chiffres. Ainsi, 1998 a été stocké en 98 et 1999 en 99. Cependant, cela poserait problème lorsque l’année passait à 2000, car le système l’enregistrera sous 00 et reviendra à 1900.

Les deux exemples que nous vous avons donnés ci-dessus sont une classe d’erreurs appelée «dépassement d’entier». Dans ce guide, nous allons explorer les effets néfastes des attaques par débordement et sous-dépassement sur les contrats intelligents.

L’erreur de débordement

Un débordement se produit lorsqu’un nombre est incrémenté au-dessus de sa valeur maximale. Supposons que nous déclarions une variable uint8, qui est une variable non signée et peut prendre jusqu’à 8 bits. Cela signifie qu’il peut avoir des nombres décimaux entre 0 et 2 ^ 8-1 = 255.

En gardant cela à l’esprit, considérez l’exemple suivant.

uint a = 255;

a ++;

Cela entraînera un dépassement car la valeur maximale de a est de 255.

Solidity peut gérer des nombres jusqu’à 256 bits. Une incrémentation de 1 entraînerait une situation de débordement:

Cela entraînera un dépassement de capacité, car la valeur maximale de a est de 255.

Solidity peut gérer jusqu’à 256 nombres de bits. Une incrémentation de 1 entraînerait une situation de débordement:

0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

+ 0x000000000000000000000000000000000001

—————————————-

= 0x000000000000000000000000000000000000

Vérifions l’erreur de dépassement avec un simple contrat de transfert de jetons (code extrait de GitHub):

mappage (adresse => uint256) balance publique;

// PEU SÛR

transfert de fonction (adresse _to, uint256 _valeur) {

/ * Vérifier si l’expéditeur a un solde * /

require (balanceOf [msg.sender] >= _valeur);

/ * Ajouter et soustraire de nouveaux soldes * /

balanceOf [msg.sender] – = _valeur;

balanceOf [_to] + = _valeur;

}

// SÉCURISE

transfert de fonction (adresse _to, uint256 _valeur) {

/ * Vérifier si l’expéditeur a un solde et des dépassements * /

require (balanceOf [msg.sender] >= _valeur && balanceOf [_to] + _valeur >= balanceOf [_to]);

/ * Ajouter et soustraire de nouveaux soldes * /

balanceOf [msg.sender] – = _valeur;

balanceOf [_to] + = _valeur;

}

Alors, qu’avons-nous ici?

Il existe deux fonctions de «transfert» qui sont utilisées dans le programme ci-dessus. L’un recherche un dépassement, tandis que l’autre ne le vérifie pas. La fonction de transfert sécurisé vérifie si le solde atteint la valeur maximale.

Maintenant, vous devez garder une chose à l’esprit. Cette fonction peut ne pas être pertinente tout le temps, en particulier dans le scénario ci-dessus. En tant que développeur, il faut se demander si la valeur atteindra un jour un niveau aussi élevé ou s’ils dépensent inutilement du gaz.

L’erreur de sous-débit

Maintenant, nous atteignons l’autre extrémité du spectre, l’erreur Underflow. Cela fonctionne dans la direction exactement opposée. Rappelez-vous comment uint8 peut prendre des valeurs uniquement entre 0 et 255? Considérez le code suivant.

unint8 a = 0;

une-;

Nous venons de provoquer un dépassement inférieur qui fera en sorte que a ait la valeur maximale possible qui est de 255.

Appliquer la même logique dans les smart contracts solidité:

0x000000000000000000000000000000000000

– 0x000000000000000000000000000000000001

—————————————-

= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

Comme vous pouvez le voir, cela peut conduire à de graves fausses déclarations.

Jetons un coup d’œil à un morceau de code et voyons comment un simple sous-débit peut causer des ravages dans un contrat intelligent (code extrait de GitHub):

mappage (adresse => uint256) balance publique;

// PEU SÛR

transfert de fonction (adresse _to, uint256 _valeur) {

/ * Vérifier si l’expéditeur a un solde * /

require (balanceOf [msg.sender] >= _valeur);

/ * Ajouter et soustraire de nouveaux soldes * /

balanceOf [msg.sender] – = _valeur;

balanceOf [_to] + = _valeur;

}

// SÉCURISE

transfert de fonction (adresse _to, uint256 _valeur) {

/ * Vérifier si l’expéditeur a un solde et des dépassements * /

require (balanceOf [msg.sender] >= _valeur && balanceOf [_to] + _valeur >= balanceOf [_to]);

/ * Ajouter et soustraire de nouveaux soldes * /

balanceOf [msg.sender] – = _valeur;

balanceOf [_to] + = _valeur;

}

Dans l’exemple de code donné ci-dessus, un hacker peut tirer parti de manipulateMe car les tableaux dynamiques sont stockés de manière séquentielle. Tout ce qu’un hacker doit faire est:

Appelez popBonusCode pour underflow

Calculer l’emplacement de stockage de manipulateMe

Modifier et mettre à jour la valeur de manipulateMe à l’aide de modifyBonusCode

Évidemment, il est simple de signaler toutes les erreurs dans les fonctions isolées, cependant, imaginez un contrat intelligent long et compliqué avec des milliers de lignes de code. Il peut être très facile de perdre la trace d’une telle erreur lors de la vérification du code.

Dangers des attaques de débordement et de sous-débordement

L’erreur de sous-dépassement est plus susceptible de se produire que l’erreur de dépassement de capacité, car il sera quelque peu impossible pour quelqu’un d’obtenir le nombre requis de jetons pour provoquer un débordement.

Imaginez une situation où un détenteur de jetons n’a que X jetons. Supposons qu’il essaie de dépenser X + 1 jetons. Si le programme ne vérifie même pas cela, il est possible qu’un attaquant se retrouve avec plus de jetons que ce qu’il possède réellement et obtienne un solde maximal.

Prenons l’exemple suivant (tiré de nethemba):

solidité pragma ^ 0,4,22;

jeton de contrat {

mappage (adresse => uint) soldes;

transfert de fonction (adresse _to, uint _value) public {

require (soldes [msg.sender] – _value >= 0);

soldes [msg.sender] – = _valeur;

soldes [_to] + = _valeur;

}

}

Dans le code ci-dessus, la condition requise dans la fonction «transfert» peut sembler correcte à première vue, mais seulement jusqu’à ce que vous vous rendiez compte que les opérations entre deux unités produisent une valeur unitaire.

Ce que cela signifie finalement, c’est que la valeur de soldes [msg.sender] – _value >= 0 sera toujours vrai quelle que soit la condition.

En raison de cette condition, un pirate informatique peut en fait posséder plus de fonds que ce qu’il possède réellement et maximiser son solde. Par exemple. si le pirate possède 100 jetons et essaie de posséder 101 jetons, il se retrouvera avec 100-101 jetons, ce qui lui donnera 2 ^ 256-1 jetons à la suite d’un sous-débit!

Cela peut simplement briser tout le système.

Problèmes du monde réel causés par les attaques de sous-flux

4chan’s / biz / grouped ensemble a créé la «pièce de preuve de mains faibles» ou POWH. C’était un programme de Ponzi légitime, cependant, les gens y ont toujours adhéré et il est passé à plus d’un million de dollars..

Cependant, il s’avère que les développeurs de POWH coin n’ont pas sécurisé toutes les opérations et n’ont pas été en mesure de mettre en place les défenses appropriées contre les attaques de débordement et de sous-débordement. Pour cette raison même, un pirate informatique inconnu a pu siphonner 2000 ETH d’une valeur d’environ 2,3 millions de dollars..

Comme vous pouvez le voir, il est important pour un développeur de renforcer ses défenses contre les attaques de débordement et de sous-débordement. En tant que chasseur de primes, vous devez être à l’affût des attaques de débordement / sous-débordement.

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me