Vulnérabilité de dépassement d'entier et sa protection
Le dépassement d'entier est un problème courant en programmation. Dans la plupart des langages de programmation, les valeurs entières sont stockées dans une mémoire de longueur fixe. Les entiers peuvent être divisés en nombres non signés et signés, la différence résidant dans le fait que le bit le plus élevé est utilisé comme bit de signe pour représenter le positif ou le négatif. Par exemple, une mémoire de 32 bits peut stocker des entiers non signés de 0 à 4 294 967 295 (uint32), ou des entiers signés de -2 147 483 648 à 2 147 483 647 (int32).
Lorsqu'un résultat de calcul dépasse la plage pouvant être représentée par un type entier, un débordement se produit. La plupart des langages de programmation ne vérifient pas cette erreur, mais effectuent simplement une opération de modulo ou produisent un comportement indéfini. Cela peut entraîner des résultats inattendus lors de l'exécution du programme. Dans les contrats intelligents de la blockchain, en particulier dans le domaine de la DeFi, les calculs entiers sont très courants, il est donc nécessaire de prêter une attention particulière aux vulnérabilités de débordement d'entier.
Définition du débordement d'entier
Le dépassement d'entier se divise en deux cas : le débordement (overflow) et le sous-débordement (underflow).
Débordement : le résultat dépasse la valeur maximale du type entier. Par exemple, 0xFFFFFFFF de uint32 plus 1 devient 0x00000000.
Sous-dépassement : le résultat est inférieur à la valeur minimale du type entier. Par exemple, 0 moins 1 en uint32 devient 0xFFFFFFFF.
Technologie de protection
Dans Rust, les mesures suivantes peuvent être prises pour éviter le dépassement d'entier :
Configurer Cargo.toml pour vérifier le débordement d'entier même en mode release :
Utiliser la crate uint pour prendre en charge des entiers plus grands :
rouille
utiliser uint::construct_uint;
construct_uint! {
pub struct U1024(16);
}
Utiliser des fonctions mathématiques sécurisées telles que checked_* :
rouille
let result = x.checked_add(y).expect("Dépassement d'addition");
Utiliser des fonctions de conversion de type comme as_u128() pour détecter les débordements :
rouille
let amount_u256 = U256::from(u128::MAX) + 1;
let amount_u128 = amount_u256.as_u128(); // déclenchera un panic
Grâce à ces méthodes, nous pouvons prévenir efficacement les vulnérabilités de dépassement d'entier dans les contrats intelligents Rust et améliorer la sécurité des contrats. Lors de la rédaction de contrats intelligents impliquant des calculs mathématiques, il est impératif de manipuler les opérations entières avec prudence et de prendre des mesures de protection appropriées.
Voir l'original
Cette page peut inclure du contenu de tiers fourni à des fins d'information uniquement. Gate ne garantit ni l'exactitude ni la validité de ces contenus, n’endosse pas les opinions exprimées, et ne fournit aucun conseil financier ou professionnel à travers ces informations. Voir la section Avertissement pour plus de détails.
8 J'aime
Récompense
8
4
Partager
Commentaire
0/400
GasDevourer
· 07-20 17:20
Attention à ne pas faire déborder et à éviter les projets douteux !
Voir l'originalRépondre0
SchrodingerAirdrop
· 07-19 14:45
Le propriétaire de l'immeuble a raison, pourquoi ne pas apprendre Rust ensemble ?
Voir l'originalRépondre0
liquiditea_sipper
· 07-17 23:42
Wow, la vérification de débordement doit être activée!
Voir l'originalRépondre0
TokenCreatorOP
· 07-17 23:24
Eh, qui n'a jamais rencontré ce genre de problème ?~
Techniques de protection contre le dépassement d'entier dans les smart contracts Rust
Vulnérabilité de dépassement d'entier et sa protection
Le dépassement d'entier est un problème courant en programmation. Dans la plupart des langages de programmation, les valeurs entières sont stockées dans une mémoire de longueur fixe. Les entiers peuvent être divisés en nombres non signés et signés, la différence résidant dans le fait que le bit le plus élevé est utilisé comme bit de signe pour représenter le positif ou le négatif. Par exemple, une mémoire de 32 bits peut stocker des entiers non signés de 0 à 4 294 967 295 (uint32), ou des entiers signés de -2 147 483 648 à 2 147 483 647 (int32).
Lorsqu'un résultat de calcul dépasse la plage pouvant être représentée par un type entier, un débordement se produit. La plupart des langages de programmation ne vérifient pas cette erreur, mais effectuent simplement une opération de modulo ou produisent un comportement indéfini. Cela peut entraîner des résultats inattendus lors de l'exécution du programme. Dans les contrats intelligents de la blockchain, en particulier dans le domaine de la DeFi, les calculs entiers sont très courants, il est donc nécessaire de prêter une attention particulière aux vulnérabilités de débordement d'entier.
Définition du débordement d'entier
Le dépassement d'entier se divise en deux cas : le débordement (overflow) et le sous-débordement (underflow).
Débordement : le résultat dépasse la valeur maximale du type entier. Par exemple, 0xFFFFFFFF de uint32 plus 1 devient 0x00000000.
Sous-dépassement : le résultat est inférieur à la valeur minimale du type entier. Par exemple, 0 moins 1 en uint32 devient 0xFFFFFFFF.
Technologie de protection
Dans Rust, les mesures suivantes peuvent être prises pour éviter le dépassement d'entier :
toml [profile.release] overflow-checks = true panic = 'abort'
rouille utiliser uint::construct_uint;
construct_uint! { pub struct U1024(16); }
rouille let result = x.checked_add(y).expect("Dépassement d'addition");
rouille let amount_u256 = U256::from(u128::MAX) + 1; let amount_u128 = amount_u256.as_u128(); // déclenchera un panic
Grâce à ces méthodes, nous pouvons prévenir efficacement les vulnérabilités de dépassement d'entier dans les contrats intelligents Rust et améliorer la sécurité des contrats. Lors de la rédaction de contrats intelligents impliquant des calculs mathématiques, il est impératif de manipuler les opérations entières avec prudence et de prendre des mesures de protection appropriées.