智能合约中的多个函数重入攻击（Reentrancy Attack）详解

简介

在区块链智能合约开发中，重入攻击（Reentrancy Attack） 是一种非常危险的漏洞类型。攻击者通过利用合约内函数之间的调用漏洞，可能会重复调用某个函数或多个函数，从而导致不正常的行为，甚至损失资金。通常，重入攻击依赖于合约执行过程中状态更新与外部合约交互的顺序错误。

在这篇博文中，我们将讨论 多个函数的重入攻击，并通过一个简单的示例，解释如何通过一个函数调用另一个函数的漏洞进行攻击，及其防范措施。

什么是多个函数重入攻击？

多个函数重入攻击与单个函数重入攻击的原理相似，但在多个函数的交互中，攻击者通过精心设计的攻击路径，使得重入攻击不仅仅发生在一个函数中，而是多个函数之间相互触发。攻击者可以通过不断调用这些函数，从而不断影响合约状态，最终获取非法利益。

攻击的基本流程

多个函数的重入攻击通常发生在以下几种场景：

1. 合约函数间有相互调用的依赖。
2. 合约函数修改状态时未立即更新，并在中途进行外部调用。
3. 攻击者通过合约的状态修改、函数之间的依赖关系，递归地进行攻击。

我们通过一个简单的示例来展示如何利用多个函数之间的重入攻击漏洞。

攻击示例

假设有一个合约，该合约允许用户存款、提现以及奖励机制。合约有三个主要功能：

1. 存款函数 (deposit)：用户存款，并将资金记录在合约中。
2. 提款函数 (withdraw)：用户请求提现，合约转账给用户，并更新余额。
3. 奖励函数 (reward)：合约在提现时会奖励用户一定比例的奖励。

// 不安全的合约，容易受到多个函数重入攻击
pragma solidity ^0.8.0;

contract Vulnerable {
    mapping(address => uint256) public balances;
    mapping(address => uint256) public rewards;

    // 存款功能
    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }

    // 奖励发放功能（奖励发放时触发提现）
    function reward(address user) public {
        uint256 rewardAmount = balances[user] / 10; // 奖励金额是存款的10%
        rewards[user] += rewardAmount;

        // 奖励后触发提现
        withdraw(rewardAmount);
    }

    // 提款功能（漏洞所在）
    function withdraw(uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");

        // 先转账，再更新余额（漏洞在这里）
        payable(msg.sender).transfer(amount);
        balances[msg.sender] -= amount;
    }
}

重入攻击的发生

在上述合约中，存在一个重入攻击的隐患。我们来分析一下发生重入攻击的路径。

1. 存款与奖励的交互

• 用户首先调用 deposit() 函数存入一定的以太币。
• 然后，攻击者调用 reward() 函数来获取奖励，这会触发合约中的 withdraw() 函数来提取资金。
• 在 withdraw() 函数执行时，攻击者的合约可以通过重入攻击再次调用 withdraw() 函数（通过 reward() 调用 withdraw()）。

2. 攻击路径

攻击者可以通过一个恶意合约与 Vulnerable 合约进行交互。当攻击者调用 reward() 函数时，reward() 会先计算奖励金额并调用 withdraw() 函数进行资金转账。然而，在转账过程中，攻击者的合约的回退函数（fallback()）会被触发，导致攻击者的合约再次调用 withdraw()，从而重复提取资金。

攻击者合约示例：

// 攻击者合约
pragma solidity ^0.8.0;

import "./Vulnerable.sol";

contract Attacker {
    Vulnerable public vulnerableContract;

    constructor(address _vulnerableAddress) {
        vulnerableContract = Vulnerable(_vulnerableAddress);
    }

    // 攻击者合约的回退函数
    fallback() external payable {
        if (address(vulnerableContract).balance > 0) {
            vulnerableContract.reward(msg.sender); // 重复调用 reward 函数
        }
    }

    // 发起攻击
    function attack() public payable {
        vulnerableContract.deposit{value: msg.value}();
        vulnerableContract.reward(msg.sender); // 发起奖励请求
    }
}

攻击的步骤：

1. 攻击者首先将一定量的以太币存入 Vulnerable 合约。
2. 然后，攻击者调用 reward() 函数，触发合约执行 withdraw() 函数来转账奖励。
3. 在 withdraw() 转账过程中，攻击者的合约回退函数被触发，攻击者合约再次调用 reward() 函数，重新进入 withdraw()。
4. 重复以上步骤，直到合约的余额被消耗完。

防范多个函数重入攻击

为了避免类似的多个函数重入攻击，合约开发者应遵循以下原则：

1. 检查-效果-交互模式（Check-Effects-Interactions Pattern）

首先修改合约的状态，再进行外部调用。这意味着在执行任何外部合约操作（如转账）之前，应该先更新合约的内部状态，以确保即使攻击者再次调用函数时，也不会发生不一致的状态变化。

例如，将提现函数修改为：

// 安全的提现合约
pragma solidity ^0.8.0;

contract Secure {
    mapping(address => uint256) public balances;
    mapping(address => uint256) public rewards;

    // 存款功能
    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }

    // 奖励发放功能
    function reward(address user) public {
        uint256 rewardAmount = balances[user] / 10;
        rewards[user] += rewardAmount;

        // 先更新余额，再转账
        balances[user] -= rewardAmount;
        payable(user).transfer(rewardAmount);
    }

    // 提款功能
    function withdraw(uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");

        // 先更新余额，再转账
        balances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
    }
}

2. 使用重入锁（Reentrancy Guard）

为了确保同一时间只有一个操作在执行，可以使用重入锁。通过引入一个布尔变量，防止合约函数在执行过程中被重入。

contract SecureWithLock {
    bool internal locked;
    mapping(address => uint256) public balances;
    mapping(address => uint256) public rewards;

    modifier noReentrancy() {
        require(!locked, "No reentrancy allowed!");
        locked = true;
        _;
        locked = false;
    }

    // 存款功能
    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }

    // 奖励发放功能（带锁）
    function reward(address user) public noReentrancy {
        uint256 rewardAmount = balances[user] / 10;
        rewards[user] += rewardAmount;

        // 更新余额，执行转账
        balances[user] -= rewardAmount;
        payable(user).transfer(rewardAmount);
    }

    // 提款功能（带锁）
    function withdraw(uint256 amount) public noReentrancy {
        require(balances[msg.sender] >= amount, "Insufficient balance");

        // 更新余额，执行转账
        balances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
    }
}

3. 使用 call 而不是 transfer

call 方法更灵活，可以设置更高的 gas 限制，并且它提供了更强的错误处理机制，避免了 transfer 方法的限制。

(bool success, ) = msg.sender.call{value: amount}("");
require(success, "Transfer failed!");

总结

多个函数的重入攻击是智能合约中的一种常见攻击模式，攻击者通过利用合约内部函数的相互调用，重复进行恶意操作，最终导致合约资金的损失。为了防范重入攻击，开发者应该遵循最佳实践，如检查-效果-交互模式、引入重入锁、使用 call 代替 transfer 等。通过合理的设计和安全措施，可以有效避免这种攻击，保证合约的安全性。