← COMP5565 全部讲次
L04c-4 · 第 4 周

L04c-4 重入攻击、CEI 与七条最佳实践

一行外部调用就是一次交权,对方能在你记账之前反手调回来;先记账再转账,再挂一把锁,最后收成七条写合约的习惯。

一句话版

一行外部调用就是一次交权:对方的代码能在你落笔记账之前,反手再调你一次。防线是先记账再转账,再挂一把重入锁;课件最后的七条最佳实践,把这些收成写合约的习惯。

上一页 L04c-3 讲了怎样调用别人的合约。这一页讲调用出去以后,对方拿着控制权能做什么。

先认识这几个词

词 白话意思
重入 reentrancy 你还没记完账,对方就回头再调你一次
CEI Checks-Effects-Interactions:先检查、再改自己的账、最后调外部合约
重入锁 reentrancy guard 一个布尔开关,函数执行期间锁住,不让再进来
调用帧 一次函数调用在执行栈上占的一层
gas 上限 一个区块能装下的计算量上限,超过就做不完

一个类比:结账时账本还没划

你把钱递过去,账本上「还欠多少」那栏还没划掉。对方接过钱,顺手又伸过来一张同样的单子。你低头一看,账本上数字还在,于是又付一次。只要划账排在付钱后面,这个循环就能一直转下去,直到钱箱见底。

办法很朴素:先划账再付钱。再保险一点,在柜台上挂一块「正在结账,请勿插队」的牌子,前一张单子没办完,后一张一律不收。

类比在哪里失效:

  • 现实里对方第二次伸手,你有时间察觉。链上这串嵌套调用全在同一笔交易里,等你能看到时,交易已经上链或整体回滚。
  • 现实里多付的钱可以去追。链上一旦确认就追不回来,修复只能写进下一版合约。

从零讲起

1. 重入

它解决什么问题

这一节讲的是一种攻击,要先看懂它怎么发生,才知道防线该设在哪。合约用 call 给一个地址转账时,如果收款方也是合约,就会触发它的 receive 或 fallback。控制权这时在对方手里,它可以在那里回头再调你的提款函数。

从哪来(补充)

2016 年 6 月 17 日,The DAO 遭到攻击,利用的漏洞包括递归调用,也就是重入,约 360 万 ETH 被转出。出处:Wikipedia: The DAO。

直觉

重入能成立,靠的是一个时间差。提款函数先转账、后清零,转账那一刻把控制权交了出去,而清零那行还没执行。对方回头再调提款函数,读到的仍是旧余额,检查照样放行。

每一层嵌套的提款都读到同一个原始本金。只要合约里还有钱、对方还愿意回调,就能一直取下去。

一步一步看

目标:跟着攻击合约一层层重入 Bank.withdraw,看出漏洞出在转账发生在余额清零之前。

  1. 攻击合约先存入一笔本金,再调 Bank.withdraw()。

  2. withdraw 读余额、过检查,然后用 call 把钱转给攻击合约。

  3. 转账触发攻击合约的 receive,控制权到了对方手里。

  4. receive 再调 withdraw,这时清零那行还没执行,余额仍是原值,又转一次。

  5. 循环到 Bank 的钱不够为止,各层 withdraw 再依次跑完各自的清零。

    重入调用帧竖向图:Attacker.attack 调 Bank.withdraw,withdraw 用 call 转账,触发被青绿高亮的 Attacker.receive,receive 又调回 Bank.withdraw,此时余额尚未清零

怎么判断

读一个会转钱的函数,找两行:外部调用在哪一行,改自己状态的那行在哪。外部调用排在状态更新之前,而且收款方可以是合约,就有重入风险。

常见误解

「函数开头的 require(amount > 0) 能拦住重入」对吗?

拦不住。它读的 balances 要到清零那行才改,嵌套的每一层读到的都是同一个本金,require 每次都放行。检查没写错,错在生效排在交互后面。

「只有用 call 转账才会重入」对吗?

不对。任何把控制权交给外部合约的调用都可能被反手调回,包括调用对方的普通函数。转账只是最常见的一种。

试一下

收款方是 EOA,withdraw 先转账后清零,会被重入吗?

不会。EOA 没有代码,收到钱后不执行任何东西,控制权直接回到 Bank。风险来自收款方是合约。

2. CEI 与重入锁

它解决什么问题

重入靠的是转账和记账之间的时间差。把这个时间差消掉,或者在时间差里禁止再进来,攻击就不成立。

从哪来(补充)

过去常用 transfer 防重入,因为它只给对方 2300 gas。Istanbul 升级在 2019 年 12 月 8 日生效,其中 EIP-1884 把 SLOAD 从 200 提到 800 gas、BALANCE 从 400 提到 700 gas。同样 2300 gas 可能不够执行合法的收款逻辑,部分合约钱包因此收款失败。出处:EIP-1884、ethereum.org 升级历史。

直觉

第一道防线是 CEI 顺序:先检查前置条件,再更新自己的状态,最后才做外部调用。对方回头再调时,读到的已经是清零后的新账,检查直接失败。

第二道防线是重入锁,用修饰器写。_; 之前上锁,_; 之后开锁,函数执行期间谁再进来,都会在 require(!locked) 处被拦下。

一步一步看

目标:按 CEI 顺序重排提款再加上重入锁,看出这两招怎样消掉或封住转账与记账之间的时间差。

  1. Checks:require(amount > 0),确认这次提款合法。

  2. Effects:balances[msg.sender] = 0;,先把账记掉。

  3. Interactions:msg.sender.call{value: amount}(""),最后才交出控制权。

  4. 加锁:进门时 require(!locked),接着 locked = true。

  5. 执行函数体,结束后 locked = false。

    CEI 三步顺序图:Checks 检查前置条件,Effects 先更新自己的状态并被青绿高亮,最后才是 Interactions 外部调用,箭头标出三者的先后

bool locked;
modifier noReentrant() {
    require(!locked, "no reentrancy");
    locked = true;
    _;
    locked = false;
}

重入锁四步流程:进门 require 未上锁并被青绿高亮,接着上锁,然后在下划线分号处执行函数体,最后开锁,重入的第二次调用会在第一步被拦下

怎么判断

修完一个提款函数,自己当攻击者再走一遍:控制权交出去的那一刻,自己的状态是不是已经更新完了?是,CEI 就成立。再看有没有别的函数读同一份余额又没上锁,有的话,锁要覆盖到那些函数。

常见误解

「有了重入锁就可以不管顺序」对吗?

不对。锁只挡同一把锁覆盖的函数。对方从另一个没上锁、却读同一份余额的函数绕回来,锁就失效。CEI 是第一道防线,锁是补的第二道。OpenZeppelin 的 ReentrancyGuard 是这把锁的成熟版。

「换成 transfer 就修好了」对吗?

不算推荐修复。2300 gas 的限额还在,但操作码涨价后,合法收款也可能失败;而且转账在清零之前的顺序根本没变。安全不能押在对方 gas 不够上,仍需 CEI 或重入锁。

试一下

CEI 版的 Bank 被攻击时,攻击合约在 receive 里再调 withdraw 会怎样?

余额已经清零,require(amount > 0) 失败。失败一路传到最外层,整笔交易回滚,攻击者什么都拿不到,只付 gas。

3. 七条最佳实践

它解决什么问题

重入只是一类事故。合约代码部署后改不了,钱又直接放在里面,写之前最好有一张检查清单。课件最后一页给了七条,每条都能对上前面讲过的某个坑。

直觉

七条可以归成三组。一组管 gas:动态数组和循环的成本随长度增长,长度没有上限时,调用可能超过区块 gas 上限,钱就永久卡在合约里。一组管外部交互:少调别人的合约,调了就处理失败。一组管代码本身:用修饰器抽出前置条件,用审过的编译器和库,把数字写得一眼能看懂。

一步一步看

目标:把课件的七条最佳实践和各自的理由对照着读,看出每条防的是前面讲过的哪一类坑。

  1. 除非必要,避免动态数组。
  2. 除非必要,避免调用其他合约。
  3. 优雅地处理失败,管理外部调用失败,给出有用的错误消息。
  4. 明智地使用修饰器。
  5. 避免不必要的循环,限制 gas 消耗。
  6. 使用最新版本的编译器和库。
  7. 正确格式化代码。
实践 为什么
避免动态数组 遍历成本随长度线性增长
避免外部调用 不知道对方代码会做什么
优雅地处理失败 被调方回滚不等于外层交易回滚
明智地使用修饰器 前置条件抽出来,可读、可审计
避免不必要的循环 gas 失控的主要来源
用最新版编译器和库 选已审阅的适用版本并测试,新版不保证无漏洞
正确格式化代码 0.1 ether 比 100000000000000000 安全

课件没列、但同样要记的两条:用 CEI 顺序防重入;用 OpenZeppelin 的现成实现,不自己手写 ERC-20 和权限控制。

怎么判断

拿一份合约逐条对照:有没有对长度不受控的数组做全量循环?每个外部调用的返回值有没有处理?权限检查是不是抽成了修饰器?金额是不是用 ether 单位写的?

常见误解

「动态数组不能用」对吗?

能用。风险在一次要遍历的长度没有上限。数组足够长时调用超过 gas 上限,若提款只能靠这个循环,资金就会被卡住。分批处理或者不做全量遍历就能解决。

「用最新版编译器就没有漏洞」对吗?

不对。这一条的意思是选用已经审阅过、适合项目的版本并做测试,新版本本身也可能有问题。

试一下

require(withdraw_amount <= 100000000000000000); 违反了哪一条?怎么改?

正确格式化代码。改成 require(withdraw_amount <= 0.1 ether);,两者等价,后者少数一个零都看得出来。

把它们串起来

外部调用把控制权交给对方。对方拿到控制权的那一刻,你的状态停在哪一版,决定了重入能不能发生。CEI 把记账挪到转账前面,让旧账不存在;重入锁在函数执行期间挂上状态位,补第二道。

transfer 和 send 靠限制对方的 gas 碰巧挡住重入,代价是合法收款也可能失败。call 不设限,安全就全靠顺序和锁。

七条最佳实践把这些收成习惯。「避免外部调用」和「优雅地处理失败」说的是同一件事:每次外部调用都是一次交权,非交不可就先把账记清楚,再看对方回了什么。

课件里的坑

  • [课件未点名] 讲调用风险的那一页描述的正是重入的成因,但 reentrancy 这个词从头到尾没出现;七条最佳实践里也没有 CEI,两处都要自己补(p.66、p.74 + 补充)
  • [已过时的防御] 介绍 transfer / send 的 2300 gas 限额时,没提它已不再是推荐的防重入手段(p.26 + 补充)
  • [教学代码勿抄] testCallFoo / testDelegatecallFoo 只把 (success, data) emit 出来,没有按业务处理失败,正好是「优雅地处理失败」的反面教材(p.73、p.74)

课后 10 分钟:考点复习

这 10 分钟怎么用:先把下面那道重入题的攻击过程在纸上跑一遍,数字对不上说明还没想透;再默写重入锁修饰器的四行;最后背七条最佳实践和三种转账写法的差别。

必背

  1. 重入的成因是课件那条总纲:没有任何东西能阻止任意复杂、甚至恶意的合约调用你的代码或被你的代码调用;用 call 转账会把控制权交给收款方并触发它的 receive 或 fallback,它可以在那里回头再调你的函数。
  2. 检查-生效-交互(checks-effects-interactions)顺序:先检查前置条件、再更新自己的状态、最后才做外部调用;第二道防线是重入锁,用修饰器写成 require(!locked); locked = true; _; locked = false;。
  3. 重入锁只挡同一把锁覆盖的函数,对方从另一个读同一份余额、却没上锁的函数绕回来就失效;CEI 是第一道防线,锁是第二道。
  4. 最佳实践七条:除非必要避免动态数组与外部调用、处理失败、明智使用修饰器、限制循环、审慎更新编译器和库、格式化代码;无界循环可能超过 gas 上限。
  5. address(this).balance 取本合约余额;transfer 失败抛异常、send 失败返回 false 必须检查返回值,两者都限 2300 gas,现在推荐用 call。

课件例题

本讲课件没有例题。这一页对应的 p.66、p.74 只给规则和清单,同一讲要求读代码、判断结果的例题分布在 L04b 和 L04c 的前几页。

考试常见两种问法。一是给一段先转账后清零的提款函数,问漏洞在哪、攻击者能取走多少、怎么改,下面的完整例题就是这个形状。二是给几种写法让你判断哪个能防重入,比如 transfer、重入锁、CEI,要答出各自靠什么、哪个只是碰巧挡住。

完整例题

题面(自编情境,课件只在 p.66 给了成因):下面的 Bank 让用户存钱取钱。指出漏洞,写出攻击过程,给出修复。

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

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

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

    function withdraw() external {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "nothing to withdraw");
        (bool ok, ) = msg.sender.call{value: amount}("");   // ← 交互
        require(ok, "transfer failed");
        balances[msg.sender] = 0;                            // ← 生效,写在交互之后
    }
}

contract Attacker {
    Bank bank;
    constructor(address _bank) { bank = Bank(_bank); }

    function attack() external payable {
        bank.deposit{value: msg.value}();
        bank.withdraw();
    }

    receive() external payable {
        if (address(bank).balance >= 1 ether) {
            bank.withdraw();                                  // ← 在收款时反手再调
        }
    }
}
  1. 定位漏洞:withdraw 先转账、后清零。call 把控制权交给收款方,收款方是合约就触发它的 receive;清零那行执行之前,balances[attacker] 一直是原来的数。

  2. 设定初始状态:Bank 里已有其他用户存的 10 ether,攻击者本金 1 ether。

  3. attack{value: 1 ether}():先 deposit,balances[attacker] = 1 ether,Bank 余额 11 ether,紧接着调 withdraw。

  4. 第 1 次 withdraw:amount = 1 ether,转出 1 ether,Bank 剩 10 ether,控制权进入 receive。

  5. 嵌套:receive 看到 10 ≥ 1 ether,再调 withdraw;清零那行还没执行,amount 仍读到 1 ether,再转 1 ether,Bank 剩 9 ether,又进 receive,如此往复。

  6. 终止:第 11 次转出后 Bank 降到 0,receive 的条件不再成立,11 层 withdraw 依次跑完各自的清零语句。攻击者用 1 ether 本金取走 11 ether,Bank 归零。The DAO 就是这个形状。

  7. require(amount > 0) 为什么没拦住:它检查的是存储里的 balances,而存储要到最后一行才改,错的是顺序。

  8. 修复一:调整顺序,把清零挪到转账之前:

    uint256 amount = balances[msg.sender];
    require(amount > 0, "nothing to withdraw");   // checks
    balances[msg.sender] = 0;                     // effects
    (bool ok, ) = msg.sender.call{value: amount}("");   // interactions
    require(ok, "transfer failed");

    再走一遍:第二次 withdraw 读到 0 并失败,异常传到最外层 attack,连同本次 deposit 一起回滚。以此前无余额的新攻击合约为前提,Bank 仍有 10 ETH、balances[attacker]=0;发送者收回附带的 1 ETH,但仍付 gas。若 deposit 早在另一笔成功交易中完成,旧存款才会保留。

  9. 修复二:重入锁,执行前上锁、返回前解锁,重入时 require(!locked) 失败。CEI 不禁止合法提款;收款方不重入或捕获内层失败时仍可取回应得金额。

答题格式:漏洞一句话(哪两行顺序反了)→ 逐层记账(每层转出多少、剩多少)→ 修复代码 → 修复后再走一遍。

变式题(先自己做)

(1) 自编情境,换一组初始条件:Bank 里其他用户存了 5 ether,攻击者本金 2 ether,Attacker.receive 的阈值同步改成 address(bank).balance >= 2 ether。withdraw 嵌套几层?攻击者取走多少?Bank 最后剩多少?(2) 有人提议把 msg.sender.call{value: amount}("") 换成 payable(msg.sender).transfer(amount),理由是 transfer 只给 2300 gas。为什么这不算推荐修复?

提示

第一问照着例题第 4–6 步一层层记账,每层只写两个数:这层转出多少、转完还剩多少。每层读到的 amount 都是同一个本金,因为清零那行始终没轮到执行;终止判断用的是转账之后的余额。第二问想两件事:操作码涨价后,2300 gas 能做的事情是否不变,以及就算挡住了,withdraw 里那个顺序有没有改过来。

判分点与答案(非官方评分标准)

判分点:① 记账从 deposit 之后的 7 ether 起算,漏掉本金是最常见的算错;② 终止条件比的是转账后余额与阈值 2 ether;③ 第二问要答出 gas 预算不能充当安全证明、顺序没被修正两层。

(1) deposit 之后 balances[attacker] = 2 ether,Bank 余额 5 + 2 = 7 ether。第 1 次 withdraw 转出 2、剩 5,receive 判断 5 ≥ 2 继续;第 2 次转出 2、剩 3,3 ≥ 2 继续;第 3 次转出 2、剩 1,1 < 2 停。一共嵌套 3 层 withdraw,攻击者取走 6 ether,扣掉 2 ether 本金净赚 4 ether,Bank 最后剩 1 ether。剩下这 1 ether 是阈值写死成 2 ether 的结果。

(2) Istanbul 改的是部分操作码的成本,不是把 2300 限额取消;同样预算可能让合法收款失败。更重要的是转账在清零之前的顺序没变,不能把安全全押在对方 gas 不够上,仍需 CEI 或重入锁。

闪卡自测(含英文边界判断,非官方试题)

1. True or False: In the CEI variant, if the reentrant failure propagates to the top level, a deposit made in the same transaction is also reverted.
中文:CEI 变式中,重入失败若传到最外层,同笔交易的存款也撤销。

True. The whole transaction reverts, including that deposit. 先清零使重复提款失败;注意 same transaction、propagates。早先另一笔成功交易的存款不受影响(p.74 补充)。

2. 重入锁用修饰器怎么写?

靠 _; 能放在中间这条性质:require(!locked); locked = true; _; locked = false;。函数体执行前上锁、执行后解锁,重入进来的第二次调用在 require 处被拦住(p.43–44)。

3. 「避免动态数组」和「避免不必要的循环」为什么是同一条建议?

两者都提醒防止无界遍历。当处理一次的工作量超出现有 gas 上限,调用无法完成;不是所有动态数组天然有问题(p.19、p.74)。

4. transfer 和 send 失败时的表现有什么不同?

transfer 失败直接抛异常,整笔回滚;send 失败只返回 false,不检查返回值就当钱已经付出去了。两者都只给 2300 gas,现在推荐用 call 并检查返回值(p.26)。

5. 课件第 66 页没出现 reentrancy 这个词,为什么说它讲的就是重入?

那一页说没有任何东西能阻止任意复杂、甚至恶意的合约调用你的代码或被你的代码调用。「被你的代码调用」的那个合约,正好能在收到控制权时反过来调你,这就是重入的全部前提(p.66)。

6. CEI 三个字母各指什么?

Checks 检查前置条件,Effects 更新自己的状态,Interactions 最后才做外部调用(p.74 补充)。

下一讲

Solidity 这一讲到此结束。下一讲 L05a 进入代理合约:怎样用本讲的 delegatecall 把存储和逻辑拆开,做出可以升级的合约。

下一讲 →
Lab1a Lab1a 在 Remix 里跑通第一份合约:从 10 行 SimpleStorage 到有主人的 SimpleStorageV2

个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。