Web3 & DApp Development Fundamentals · Lección

Prácticas recomendadas de seguridad para contratos

Descubra prácticas de seguridad esenciales para desarrollar smart contracts, como las protecciones contra reentrancia, el patrón checks-effects-interactions y el control de acceso.

Prácticas recomendadas de seguridad para contratos es una lección gratuita de Web3 & DApp Development Fundamentals en CoddyKit. Esta es la lección 2 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Web3 & DApp Development Fundamentals, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Web3 & DApp Development Fundamentals incluye 3 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en 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!

Preguntas frecuentes

¿La lección «Prácticas recomendadas de seguridad para contratos» es gratis?

Sí — el texto completo de «Prácticas recomendadas de seguridad para contratos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Web3 & DApp Development Fundamentals, actualiza a CoddyKit PRO. El curso de Web3 & DApp Development Fundamentals incluye 3 lecciones en total.

¿Qué aprenderé en «Prácticas recomendadas de seguridad para contratos»?

Descubra prácticas de seguridad esenciales para desarrollar smart contracts, como las protecciones contra reentrancia, el patrón checks-effects-interactions y el control de acceso. Practicas Web3 & DApp Development Fundamentals con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Web3 & DApp Development Fundamentals?

No se requiere experiencia previa. Web3 & DApp Development Fundamentals en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 3.

¿Cuánto tiempo toma la lección «Prácticas recomendadas de seguridad para contratos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Web3 & DApp Development Fundamentals?

Sí. Cada lección de Web3 & DApp Development Fundamentals incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Estándares ERC (ERC-20, ERC-721)
Prácticas recomendadas de seguridad para contratos
Contratos actualizables

← Volver a Web3 & DApp Development Fundamentals