Blockchain Smart Contracts with Solidity · Lekcja

Bezpieczne programowanie z SafeMath

Naucz się korzystać z bibliotek takich jak SafeMath, aby zapobiegać przepełnieniom i niedopełnieniom liczb całkowity w operacjach arytmetycznych.

Lekcja 3 z 412 kroki

Bezpieczne programowanie z SafeMath to bezpłatna lekcja Blockchain Smart Contracts with Solidity na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Blockchain Smart Contracts with Solidity, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Blockchain Smart Contracts with Solidity zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

The Integer Problem

In Solidity, integer types like uint256 have a fixed size. This means they can only store numbers up to a certain maximum value and down to a minimum (usually 0 for unsigned integers).

When an arithmetic operation exceeds these limits, it can lead to critical vulnerabilities called integer overflows and underflows.

Unchecked Math Dangers

Solidity's default arithmetic operations (+, -, *, /) do not automatically check for overflows or underflows. Instead, the number 'wraps around'.

This behavior can be exploited by attackers, leading to incorrect token balances, unexpected contract state, and financial losses.

Overflow in Action

Consider a uint8 variable, which can hold values from 0 to 255. What happens if we try to add 1 to 255? Run this code and call incrementUnsafely(). You'll see the value reset to 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;
    }
}

Underflow Example

Similarly, an underflow occurs when a number goes below its minimum value. For a uint (unsigned integer), the minimum is 0.

If you subtract 1 from 0, it wraps around to the maximum value (255 for uint8, or 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;
    }
}

Introducing SafeMath

To prevent these critical errors, we use libraries like SafeMath. SafeMath provides functions for arithmetic operations (addition, subtraction, multiplication, division) that revert the transaction if an overflow or underflow would occur.

This ensures your contract's state remains consistent and secure, preventing malicious exploits.

Solidity Libraries Explained

A Solidity Library is a special type of contract that contains reusable code. Unlike regular contracts, libraries are stateless (they don't store data directly) and cannot hold Ether.

They are deployed once and their functions are called via DELEGATECALL.
This means the library's code runs in the context of the calling contract.
Libraries are perfect for shared utility functions like SafeMath.

Integrating SafeMath

To use SafeMath, you typically import it from a trusted source like OpenZeppelin. Then, you tell Solidity to apply SafeMath's functions to a specific integer type using the using A for B; directive.

This makes SafeMath's functions available as member functions on type 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;
    }
}

Safe Addition in Action

With SafeMath integrated, you use .add() instead of the standard + operator. If the addition would overflow, the transaction will revert, preventing incorrect state changes.

Call safeAdd() with a value like 10. Try calling it with a value that would cause an overflow (e.g., if total was max uint8 and you added 1).

/*
  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
    }
}

Safe Subtraction in Action

Similarly, use .sub() for subtraction. This prevents underflows, ensuring that a subtraction operation will revert if the result would be negative (below zero for unsigned integers).

Call safeSubtract() with a value like 10. Try calling it with a value larger than balance (e.g., 101) to see it revert.

/*
  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
    }
}

Multiply, Divide, Modulo

SafeMath also provides .mul(), .div(), and .mod() for multiplication, division, and modulo operations, respectively.

.mul() checks for overflow.
.div() checks for division by zero and overflow.
.mod() checks for division by zero.

Always use these safe versions for critical arithmetic in your contracts.

Quick Check on SafeMath

You've learned about the importance of SafeMath. Let's test your understanding.

Odpowiedz w interaktywnej lekcji

Recap: Secure Math

You've learned about the critical vulnerabilities of integer overflows and underflows in Solidity and how SafeMath provides a robust solution.

Always use SafeMath (or similar audited libraries) for arithmetic operations on unsigned integers in your smart contracts.
This prevents unexpected behavior and protects your contract's integrity.

Keep practicing secure coding! The next lessons will dive deeper into advanced security patterns.

Bezpłatny start

Ucz się Blockchain Smart Contracts with Solidity dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 12
Lekcje: 48

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Bezpieczne programowanie z SafeMath” jest bezpłatna?

Tak — pełny tekst „Bezpieczne programowanie z SafeMath” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Blockchain Smart Contracts with Solidity, przejdź na CoddyKit PRO. Kurs Blockchain Smart Contracts with Solidity zawiera 4 lekcji w sumie.

Co nauczysz się w „Bezpieczne programowanie z SafeMath”?

Naucz się korzystać z bibliotek takich jak SafeMath, aby zapobiegać przepełnieniom i niedopełnieniom liczb całkowity w operacjach arytmetycznych. Ćwiczysz Blockchain Smart Contracts with Solidity z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Blockchain Smart Contracts with Solidity?

Nie wymagamy żadnego doświadczenia. Blockchain Smart Contracts with Solidity w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Bezpieczne programowanie z SafeMath”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Blockchain Smart Contracts with Solidity?

Tak. Każda lekcja Blockchain Smart Contracts with Solidity zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Typowe luki w zabezpieczeniach (reentrancy itp.)
Wzorce kontroli dostępu
Bezpieczne programowanie z SafeMath
Audytowanie, testowanie i bug bounty

← Powrót do Blockchain Smart Contracts with Solidity