Sikker kodning med SafeMath
Lær at bruge biblioteker som SafeMath til at forhindre integer overflow- og underflow-angreb i aritmetiske operationer.
Sikker kodning med SafeMath er en gratis Blockchain-smart contracts med Solidity-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Blockchain-smart contracts med Solidity, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Blockchain-smart contracts med Solidity-kurset indeholder 4 lektioner i alt.
Problemet med heltal
I Solidity har heltalstyper som uint256 en fast størrelse. Det betyder, at de kun kan gemme tal op til en bestemt maksimumværdi og ned til en minimumværdi (normalt 0 for heltal uden fortegn).
Når en aritmetisk operation overskrider disse grænser, kan det føre til kritiske sårbarheder kaldet heltalsoverløb og heltalsunderløb.
Farerne ved ukontrolleret matematik
Soliditys standardaritmetiske operationer (+, -, *, /) kontrollerer ikke automatisk for overløb eller underløb. I stedet "ruller" tallet rundt.
Denne adfærd kan udnyttes af angribere og føre til forkerte token-saldi, uventet tilstand i contracten og økonomiske tab.
Overløb i praksis
Se på en variabel af typen uint8, som kan indeholde værdier fra 0 til 255. Hvad sker der, hvis vi forsøger at lægge 1 til 255? Kør denne kode, og kald incrementUnsafely(). Du vil se, at værdien nulstilles til 0!
/*
This contract demonstrates an integer overflow.
A uint8 can only hold values from 0 to 255.
Adding 1 to 255 will cause it to wrap around to 0.
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract UnsafeCounter {
uint8 public count = 255; // Max value for uint8
// Function to increment the counter unsafely
function incrementUnsafely() public {
count = count + 1;
}
}Eksempel på underløb
På samme måde opstår et underløb, når et tal kommer under sin minimumsværdi. For en uint (et heltal uden fortegn) er minimumsværdien 0.
Hvis du trækker 1 fra 0, ruller værdien rundt til maksimumsværdien (255 for uint8 eller 2^256 - 1 for uint256).
/*
This contract demonstrates an integer underflow.
A uint8 can only hold values from 0 to 255.
Subtracting 1 from 0 will cause it to wrap around to 255.
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract UnderflowDemo {
uint8 public value = 0; // Min value for uint8
// Function to decrement the value unsafely
function decrementUnsafely() public {
value = value - 1;
}
}Introduktion til SafeMath
For at forhindre disse kritiske fejl bruger vi biblioteker som SafeMath. SafeMath leverer funktioner til aritmetiske operationer (addition, subtraktion, multiplikation og division), som ruller transaktionen tilbage, hvis der ville opstå et overløb eller underløb.
Det sikrer, at din contracts tilstand forbliver konsistent og sikker, og forhindrer ondsindede udnyttelser.
Solidity-biblioteker forklaret
Et Solidity-bibliotek er en særlig contracttype, der indeholder genanvendelig kode. I modsætning til almindelige contracts er biblioteker tilstandsløse (de gemmer ikke data direkte) og kan ikke indeholde Ether.
- De udrulles én gang, og deres funktioner kaldes via
DELEGATECALL. - Det betyder, at bibliotekets kode kører i den kaldende contracts kontekst.
- Biblioteker er perfekte til fælles hjælpefunktioner som SafeMath.
Integration af SafeMath
For at bruge SafeMath importerer du det typisk fra en betroet kilde som OpenZeppelin. Derefter angiver du, at Solidity skal anvende SafeMaths funktioner på en bestemt heltalstype ved hjælp af direktivet using A for B;.
Det gør SafeMaths funktioner tilgængelige som medlemsfunktioner på typen B.
/*
This contract demonstrates how to integrate and use SafeMath.
We're including a simplified mock SafeMath library for demonstration.
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// A simplified mock SafeMath library for demonstration
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
}
contract MySafeContract {
// Use SafeMath functions for all uint256 variables
using SafeMath for uint256;
uint256 public balance = 100;
function deposit(uint256 amount) public {
// Now you can call .add() directly on balance
balance = balance.add(amount);
}
function getBalance() public view returns (uint256) {
return balance;
}
}Sikker addition i praksis
Med SafeMath integreret bruger du .add() i stedet for standardoperatoren +. Hvis additionen ville give et overløb, rulles transaktionen tilbage, så forkerte ændringer af tilstanden forhindres.
Kald safeAdd() med en værdi som 10. Prøv at kalde den med en værdi, der ville give et overløb (f.eks. hvis totalen var den maksimale uint8, og du lagde 1 til).
/*
This contract uses SafeMath for secure addition.
If the addition causes an overflow, the transaction will revert.
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
}
contract SafeAdder {
using SafeMath for uint256;
uint256 public total = 0;
function safeAdd(uint256 _value) public {
total = total.add(_value); // Uses SafeMath.add
}
}Sikker subtraktion i praksis
Brug på samme måde .sub() til subtraktion. Det forhindrer underløb og sikrer, at en subtraktion rulles tilbage, hvis resultatet ville blive negativt (under nul for heltal uden fortegn).
Kald safeSubtract() med en værdi som 10. Prøv at kalde den med en værdi, der er større end balance (f.eks. 101) for at se den rulle tilbage.
/*
This contract uses SafeMath for secure subtraction.
If the subtraction causes an underflow, the transaction will revert.
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction underflow");
uint256 c = a - b;
return c;
}
}
contract SafeSubtractor {
using SafeMath for uint256;
uint256 public balance = 100;
function safeSubtract(uint256 _value) public {
balance = balance.sub(_value); // Uses SafeMath.sub
}
}Multiplikation, division og modulo
SafeMath leverer også .mul(), .div() og .mod() til henholdsvis multiplikation, division og modulooperationer.
.mul()kontrollerer for overløb..div()kontrollerer for division med nul og overløb..mod()kontrollerer for division med nul.
Brug altid disse sikre versioner til kritisk aritmetik i dine contracts.
Hurtigt tjek af SafeMath
Du har lært, hvor vigtigt SafeMath er. Lad os teste din forståelse.
Opsummering: Sikker matematik
Du har lært om de kritiske sårbarheder ved heltalsoverløb og heltalsunderløb i Solidity, og hvordan SafeMath giver en robust løsning.
- Brug altid SafeMath (eller tilsvarende reviderede biblioteker) til aritmetiske operationer på heltal uden fortegn i dine smart contracts.
- Det forhindrer uventet adfærd og beskytter integriteten af din kontrakt.
Bliv ved med at øve dig i sikker kodning! I de næste lektioner går vi mere i dybden med avancerede sikkerhedsmønstre.
Lær Blockchain-smart contracts med Solidity med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 12
- Lektioner
- 48
Ofte stillede spørgsmål
Er lektionen “Sikker kodning med SafeMath” gratis?
Ja — hele teksten til “Sikker kodning med SafeMath” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Blockchain-smart contracts med Solidity-kurset, skal du opgradere til CoddyKit PRO. Blockchain-smart contracts med Solidity-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Sikker kodning med SafeMath”?
Lær at bruge biblioteker som SafeMath til at forhindre integer overflow- og underflow-angreb i aritmetiske operationer. Du øver dig i Blockchain-smart contracts med Solidity med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Blockchain-smart contracts med Solidity?
Der kræves ingen tidligere erfaring. Blockchain-smart contracts med Solidity på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.
Hvor lang tid tager lektionen “Sikker kodning med SafeMath”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Blockchain-smart contracts med Solidity-lektion?
Ja. Alle Blockchain-smart contracts med Solidity-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Almindelige sårbarheder (reentrancy m.m.)
- Mønstre for adgangskontrol
- Sikker kodning med SafeMath
- Auditering, test og bug bounties