Web3 & DApp Development Fundamentals · Aula

Boas Práticas de Segurança para Contratos

Boas Práticas de Segurança para Contratos é uma aula grátis de Web3 & DApp Development Fundamentals no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Web3 & DApp Development Fundamentals, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Web3 & DApp Development Fundamentals inclui 3 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Smart Contract Security Intro

Welcome to the critical world of smart contract security! Unlike traditional software, bugs in smart contracts can lead to irreversible loss of funds.

Because smart contracts are immutable once deployed, fixing vulnerabilities is extremely difficult, often requiring complex upgrade mechanisms or even redeploying a new contract.

In this lesson, we'll explore essential practices to build more secure and robust smart contracts.

Understanding Reentrancy

One of the most infamous vulnerabilities is reentrancy. It occurs when an external call to another contract or address "re-enters" the calling contract before the initial function's state updates are complete.

Imagine a bank ATM that lets you withdraw money. If it debits your account *after* giving you cash, a reentrancy attack would be like repeatedly asking for cash before the system updates your balance, draining the ATM.

Vulnerable Withdrawal Code

Consider this simplified contract where a user can deposit and withdraw Ether. Can you spot the danger?

The withdraw() function first sends Ether, then updates the balance. An attacker can call withdraw() again from their malicious contract during the external call, before their balance is set to zero.

/// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract VulnerableBank {
    mapping(address => uint) public balances;

    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }

    function withdraw(uint _amount) public {
        require(balances[msg.sender] >= _amount, "Insufficient balance");

        // Vulnerable point: send Ether BEFORE updating balance
        (bool success, ) = msg.sender.call{value: _amount}("");
        require(success, "Failed to send Ether");

        balances[msg.sender] -= _amount; // This happens AFTER the external call
    }

    function getBalance() public view returns (uint) {
        return address(this).balance;
    }
}

Preventing Reentrancy: State Locks

A common and effective way to prevent reentrancy is using a reentrancy guard. This involves locking the state of the contract during an external call and unlocking it afterward.

If a re-entrant call tries to execute the locked function, it will revert. OpenZeppelin's ReentrancyGuard is a popular implementation, but you can also build a simple one.

Implementing Reentrancy Guard

Let's add a simple reentrancy guard using a boolean flag. This ensures that the withdraw function cannot be called again until the current execution is complete and the state has been updated.

The nonReentrant modifier sets a lock, performs the operation, and then releases the lock.

/// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SecureBank {
    mapping(address => uint) public balances;
    bool private _locked; // Reentrancy guard flag

    modifier nonReentrant() {
        require(!_locked, "Reentrant call detected");
        _locked = true;
        _;
        _locked = false;
    }

    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }

    function withdraw(uint _amount) public nonReentrant {
        require(balances[msg.sender] >= _amount, "Insufficient balance");

        balances[msg.sender] -= _amount; // Update balance BEFORE external call (CEI)

        (bool success, ) = msg.sender.call{value: _amount}("");
        require(success, "Failed to send Ether");
    }

    function getBalance() public view returns (uint) {
        return address(this).balance;
    }
}

The CEI Pattern

The Checks-Effects-Interactions (CEI) pattern is a fundamental security best practice. It dictates a specific order for operations within a function:

Checks: Validate conditions (e.g., require statements, onlyOwner).
Effects: Update the contract's state (e.g., balances[msg.sender] -= amount).
Interactions: Perform external calls to other contracts or addresses.

Following CEI helps prevent various attacks, including reentrancy, by ensuring your contract's state is finalized *before* external calls.

CEI in Withdrawal Function

Notice how our SecureBank's withdraw function already follows the CEI pattern:

Checks: require(balances[msg.sender] >= _amount, ...) and require(!_locked, ...) from the modifier.
Effects: balances[msg.sender] -= _amount; updates the state.
Interactions: msg.sender.call{value: _amount}(""); performs the external transfer.

This order is crucial for preventing reentrancy and ensuring consistent state.

/// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract CEIDemo {
    mapping(address => uint) public balances;
    bool private _locked;

    modifier nonReentrant() {
        require(!_locked, "Reentrant call detected");
        _locked = true;
        _;
        _locked = false;
    }

    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }

    function withdraw(uint _amount) public nonReentrant {
        // --- CHECKS ---
        require(balances[msg.sender] >= _amount, "Insufficient balance");

        // --- EFFECTS ---
        balances[msg.sender] -= _amount; // State updated BEFORE external call

        // --- INTERACTIONS ---
        (bool success, ) = msg.sender.call{value: _amount}("");
        require(success, "Failed to send Ether");
    }
}

Restricting Access

Not all functions in a smart contract should be callable by everyone. Access control ensures that only authorized addresses or roles can execute specific sensitive operations.

Common examples include:

An onlyOwner modifier for administrative functions.
Role-based access control (RBAC) where different roles (e.g., MINTER, PAUSER) have specific permissions.

Proper access control is vital to prevent unauthorized actions and maintain contract integrity.

Owner-Restricted Function

Here's how to implement a simple onlyOwner access control using a modifier. The contract stores the deployer's address as the owner, and only this address can call the setNewAdmin function.

This pattern is widely used for critical administrative functions.

/// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract AccessControlled {
    address public owner;
    address public admin;

    constructor() {
        owner = msg.sender; // Deployer is the owner
        admin = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }

    function setNewAdmin(address _newAdmin) public onlyOwner {
        admin = _newAdmin;
    }

    function getAdmin() public view returns (address) {
        return admin;
    }
}

Security Best Practices Check

You've learned about reentrancy, the CEI pattern, and access control. Which of the following statements are true regarding secure smart contract development?

Recap: Secure Contracts

Great job! You've grasped fundamental smart contract security practices:

Reentrancy: A critical vulnerability where external calls can "re-enter" a function before state updates.
Reentrancy Guards: Mechanisms (like mutexes or modifiers) to lock contract state during external calls.
CEI Pattern: The recommended order of operations (Checks, Effects, Interactions) to ensure state is updated before external calls.
Access Control: Restricting sensitive functions to authorized addresses, often using onlyOwner modifiers.

These practices are crucial for building robust and trustworthy decentralized applications. Keep practicing and stay vigilant!

Perguntas Frequentes

A aula “Boas Práticas de Segurança para Contratos” é grátis?

Sim — o texto completo de “Boas Práticas de Segurança para Contratos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Web3 & DApp Development Fundamentals, atualize para CoddyKit PRO. O curso de Web3 & DApp Development Fundamentals inclui 3 aulas no total.

O que vou aprender em “Boas Práticas de Segurança para Contratos”?

Descubra práticas essenciais de segurança para o desenvolvimento de contratos inteligentes, incluindo proteções contra reentrância, o padrão verificações-efeitos-interações e controle de acesso. Você pratica Web3 & DApp Development Fundamentals com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Web3 & DApp Development Fundamentals?

Nenhuma experiência prévia é necessária. Web3 & DApp Development Fundamentals no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.

Quanto tempo leva a aula “Boas Práticas de Segurança para Contratos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Web3 & DApp Development Fundamentals?

Sim. Cada aula de Web3 & DApp Development Fundamentals inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Padrões ERC (ERC-20, ERC-721)
Boas Práticas de Segurança para Contratos
Contratos Atualizáveis

← Voltar para Web3 & DApp Development Fundamentals