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,看出漏洞出在转账发生在余额清零之前。
-
攻击合约先存入一笔本金,再调
Bank.withdraw()。 -
withdraw读余额、过检查,然后用call把钱转给攻击合约。 -
转账触发攻击合约的
receive,控制权到了对方手里。 -
receive再调withdraw,这时清零那行还没执行,余额仍是原值,又转一次。 -
循环到 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 顺序重排提款再加上重入锁,看出这两招怎样消掉或封住转账与记账之间的时间差。
-
Checks:
require(amount > 0),确认这次提款合法。 -
Effects:
balances[msg.sender] = 0;,先把账记掉。 -
Interactions:
msg.sender.call{value: amount}(""),最后才交出控制权。 -
加锁:进门时
require(!locked),接着locked = true。 -
执行函数体,结束后
locked = false。
bool locked;
modifier noReentrant() {
require(!locked, "no reentrancy");
locked = true;
_;
locked = false;
}
怎么判断
修完一个提款函数,自己当攻击者再走一遍:控制权交出去的那一刻,自己的状态是不是已经更新完了?是,CEI 就成立。再看有没有别的函数读同一份余额又没上锁,有的话,锁要覆盖到那些函数。
常见误解
「有了重入锁就可以不管顺序」对吗?
不对。锁只挡同一把锁覆盖的函数。对方从另一个没上锁、却读同一份余额的函数绕回来,锁就失效。CEI 是第一道防线,锁是补的第二道。OpenZeppelin 的 ReentrancyGuard 是这把锁的成熟版。
「换成 transfer 就修好了」对吗?
不算推荐修复。2300 gas 的限额还在,但操作码涨价后,合法收款也可能失败;而且转账在清零之前的顺序根本没变。安全不能押在对方 gas 不够上,仍需 CEI 或重入锁。
试一下
CEI 版的 Bank 被攻击时,攻击合约在 receive 里再调 withdraw 会怎样?
余额已经清零,require(amount > 0) 失败。失败一路传到最外层,整笔交易回滚,攻击者什么都拿不到,只付 gas。
3. 七条最佳实践
它解决什么问题
重入只是一类事故。合约代码部署后改不了,钱又直接放在里面,写之前最好有一张检查清单。课件最后一页给了七条,每条都能对上前面讲过的某个坑。
直觉
七条可以归成三组。一组管 gas:动态数组和循环的成本随长度增长,长度没有上限时,调用可能超过区块 gas 上限,钱就永久卡在合约里。一组管外部交互:少调别人的合约,调了就处理失败。一组管代码本身:用修饰器抽出前置条件,用审过的编译器和库,把数字写得一眼能看懂。
一步一步看
目标:把课件的七条最佳实践和各自的理由对照着读,看出每条防的是前面讲过的哪一类坑。
- 除非必要,避免动态数组。
- 除非必要,避免调用其他合约。
- 优雅地处理失败,管理外部调用失败,给出有用的错误消息。
- 明智地使用修饰器。
- 避免不必要的循环,限制 gas 消耗。
- 使用最新版本的编译器和库。
- 正确格式化代码。
| 实践 | 为什么 |
|---|---|
| 避免动态数组 | 遍历成本随长度线性增长 |
| 避免外部调用 | 不知道对方代码会做什么 |
| 优雅地处理失败 | 被调方回滚不等于外层交易回滚 |
| 明智地使用修饰器 | 前置条件抽出来,可读、可审计 |
| 避免不必要的循环 | 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 分钟怎么用:先把下面那道重入题的攻击过程在纸上跑一遍,数字对不上说明还没想透;再默写重入锁修饰器的四行;最后背七条最佳实践和三种转账写法的差别。
必背
- 重入的成因是课件那条总纲:没有任何东西能阻止任意复杂、甚至恶意的合约调用你的代码或被你的代码调用;用 call 转账会把控制权交给收款方并触发它的 receive 或 fallback,它可以在那里回头再调你的函数。
- 检查-生效-交互(checks-effects-interactions)顺序:先检查前置条件、再更新自己的状态、最后才做外部调用;第二道防线是重入锁,用修饰器写成 require(!locked); locked = true; _; locked = false;。
- 重入锁只挡同一把锁覆盖的函数,对方从另一个读同一份余额、却没上锁的函数绕回来就失效;CEI 是第一道防线,锁是第二道。
- 最佳实践七条:除非必要避免动态数组与外部调用、处理失败、明智使用修饰器、限制循环、审慎更新编译器和库、格式化代码;无界循环可能超过 gas 上限。
- 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(); // ← 在收款时反手再调
}
}
}
-
定位漏洞:
withdraw先转账、后清零。call把控制权交给收款方,收款方是合约就触发它的receive;清零那行执行之前,balances[attacker]一直是原来的数。 -
设定初始状态:
Bank里已有其他用户存的 10 ether,攻击者本金 1 ether。 -
attack{value: 1 ether}():先deposit,balances[attacker] = 1 ether,Bank余额 11 ether,紧接着调withdraw。 -
第 1 次
withdraw:amount = 1 ether,转出 1 ether,Bank剩 10 ether,控制权进入receive。 -
嵌套:
receive看到 10 ≥ 1 ether,再调withdraw;清零那行还没执行,amount仍读到 1 ether,再转 1 ether,Bank剩 9 ether,又进receive,如此往复。 -
终止:第 11 次转出后
Bank降到 0,receive的条件不再成立,11 层withdraw依次跑完各自的清零语句。攻击者用 1 ether 本金取走 11 ether,Bank归零。The DAO 就是这个形状。 -
require(amount > 0)为什么没拦住:它检查的是存储里的balances,而存储要到最后一行才改,错的是顺序。 -
修复一:调整顺序,把清零挪到转账之前:
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 早在另一笔成功交易中完成,旧存款才会保留。
-
修复二:重入锁,执行前上锁、返回前解锁,重入时 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 把存储和逻辑拆开,做出可以升级的合约。
个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。