15.5.1 重入、权限与整数溢出
所属:全栈开发面试题库 / [15 Web3 与区块链((../index.md) / [15.5 合约安全与审计((index.md)
本节要解决的问题
面试里讲"重入",多数人只会背一句"先改状态再转钱"。真正的分水岭是:能不能在白板上画出攻击者合约的 fallback 回调链,说清楚为什么这个顺序能被重复利用,以及为什么加了 ReentrancyGuard 之后还要警惕跨函数重入、ERC-777 hook 重入、签名级重入。本节解决四个具体问题:一是把 checks-effects-interactions 从口诀拆成可执行的代码顺序,知道为什么外部调用必须放在状态更新之后;二是讲清 tx.origin 与 msg.sender 的权限边界,为什么用 tx.origin 做 owner 校验等于把钱包权限借给了任何被调用的第三方合约;三是把 Solidity 0.8 内置溢出检查、unchecked 块、SafeMath 三条路线的差异讲透,知道什么时候可以放心用 unchecked、什么时候审计会把它标红;四是落到精度与舍入方向——同样一个 mulDiv,向下取整对协议方有利、向上取整对用户有利,方向选错就是漏洞。
学习目标
学完本节,你应当能够:
- 画出一笔重入攻击的完整调用栈,并指出 CEI 顺序破坏在哪一步。
- 解释
ReentrancyGuard的实现原理,并说出它为什么防不住跨函数重入。 - 区分 Solidity 0.7/0.8 在整数溢出上的默认行为,以及
unchecked块的边界。 - 在审计代码里识别出
tx.origin权限检查、未校验返回值的transfer、错误舍入方向这三类典型问题。
先修与前置
- 建议先读 [15.3.3 ABI 编码与调用栈((../../15.3-以太坊与EVM/15.3.3-ABI编码与调用栈.md),理解 call/delegatecall/callcode 的差异与调用栈深度。
- 本节是 [15.5.2 闪电贷与价格操纵((15.5.2-闪电贷与价格操纵.md) 与 [15.5.3 代理升级与存储冲突((15.5.3-代理升级与存储冲突.md) 的前置,先掌握"外部调用 = 不可信跳转"这一基本事实。
知识地图
外部调用风险面
call / send / transfer ──┬─ 原生 ETH 转账触发 fallback/receive
├─ ERC-20 transfer/transferFrom 触发回调(777/721 hook)
└─ 任意合约 call 触发未知代码
防护层
第 1 层:checks-effects-interactions(先校验、先改状态、最后外部调用)
第 2 层:ReentrancyGuard(重入锁,防同函数重入)
第 3 层:调用深度限制 / gas limit / pull-over-push
第 4 层:权限收敛(msg.sender 白名单,禁用 tx.origin)
整数安全
Solidity <=0.7:默认 wrap,需 SafeMath
Solidity >=0.8:默认 revert on overflow,可显式 unchecked
精度:mulDiv 方向(floor/ceil)决定谁承担舍入误差
核心术语
- 重入(Reentrancy):合约在外部调用未返回时,被调用方通过 fallback/回调再次进入原合约的同一函数,重复利用尚未更新的状态。
- checks-effects-interactions(CEI):函数内按"校验 → 改状态 → 外部调用"的顺序书写,确保外部调用发生时状态已一致。
- 重入锁(Reentrancy Guard):用一个状态变量标记函数是否正在执行,重入时直接 revert;OpenZeppelin 的
ReentrancyGuard即此实现。 - 跨函数重入(Cross-function Reentrancy):攻击者从函数 A 重入到同合约的另一个函数 B,A 自己的锁挡不住 B。
- 签名级重入(Signature Reentrancy):在用户签名授权后、交易上链前,利用同一签名重入利用状态差。
- tx.origin:整条交易链上的原始发起者地址;
msg.sender是直接调用者。 - SafeMath:Solidity 0.8 之前的库,在加/减/乘前显式检查溢出并 revert。
- unchecked 块:Solidity 0.8 引入的语法,块内跳过溢出检查,用于性能敏感且数学上可证明不会溢出的场景。
- 舍入方向(Rounding Direction):
mulDiv向下取整(floor)或向上取整(ceil),协议设计上必须让"对自己不利"的方向生效。
覆盖范围
- CEI 顺序与原生 ETH 转账的 fallback 触发路径
- ReentrancyGuard 实现与跨函数/签名级重入
tx.origin权限检查的钓鱼攻击面- Solidity 0.8 溢出检查与
unchecked块的边界 - 精度、舍入方向与 ERC-4626 类金库的舍入攻击
- ERC-777 / ERC-721 hook 对重入面的扩大
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 15.5.1-001 | 什么是重入攻击?checks-effects-interactions 为什么能防住它? | 基础 | ★★★★★ |
| 15.5.1-002 | 为什么 tx.origin 不能做权限检查?msg.sender 与 tx.origin 的差别? |
基础 | ★★★★★ |
| 15.5.1-003 | Solidity 0.8 之前整数溢出怎么发生?SafeMath 原理? | 基础 | ★★★★★ |
| 15.5.1-004 | ReentrancyGuard 的实现原理是什么?为什么它防不住跨函数重入? | 进阶 | ★★★★★ |
| 15.5.1-005 | ERC-777 / ERC-721 的 hook 如何把重入面扩大到转账路径? | 进阶 | ★★★★ |
| 15.5.1-006 | 精度与舍入方向为什么会成为安全问题?mulDiv 向上/向下取整的取舍? | 进阶 | ★★★★ |
| 15.5.1-007 | unchecked 块什么时候可以用?审计为什么要重点查它? |
进阶 | ★★★★ |
| 15.5.1-008 | 签名级重入(signature reentrancy)与普通重入有什么不同? | 高级 | ★★★ |
| 15.5.1-009 | 为什么 transfer/send 只转 2300 gas 不是万能解药? |
高级 | ★★★ |
| 15.5.1-010 | 设计一个带外部 ERC-20 的金库,需要同时防住哪些攻击面? | 高级 | ★★★★ |
15.5.1-001 什么是重入攻击?checks-effects-interactions 为什么能防住它?
一句话结论
重入攻击利用了"合约向外部地址转账时,控制权先交给对方、状态后更新"这一窗口:攻击者在 fallback 里反复回调原合约的提款函数,每次都基于尚未清零的余额继续提款,直到合约余额耗尽。CEI 的本质是把"状态更新"挪到"外部调用"之前,让重入回调进来时看到的余额已经是零,无法继续。
概念解释
- 外部调用是不可信跳转:
call到一个地址,对方可以是合约,合约可以在 fallback 里执行任意代码,包括回调你的合约。 - 状态在外部调用前必须已一致:否则重入看到的是旧状态,而你以为自己已经把账清了。
- 原生 ETH 转账触发
receive()或fallback():这是最经典的重入入口,因为 ETH 转账本身就附带了控制权转移。 - CEI 是顺序约定,不是编译器强制:Solidity 不会替你排序,全靠开发者自觉。
原理流程
- 攻击者部署一个恶意合约
Attacker,里面写好fallback(),收到 ETH 后立刻回调Vault.withdraw()。 - 攻击者向
Vault存入 1 ETH,拿到balances[attacker( = 1。 - 攻击者调用
Vault.withdraw(),合约读取余额、检查balances[msg.sender( > 0,然后msg.sender.call{value: amount}("")。 - call 把控制权转给
Attacker.fallback(),此时Vault里balances[attacker(还没被清零(因为状态更新写在 call 之后)。 - fallback 再次调用
withdraw(),检查通过、再次 call,递归直到Vault余额耗尽或 gas 用完。 - 递归返回后,外层函数才执行
balances[msg.sender( = 0,但已经太晚。 - CEI 写法:先
balances[msg.sender( = 0,再call{value: amount}(""),重入回调进来时检查balances[msg.sender( > 0直接 revert。
代码或图示
// 漏洞版本:状态更新在外部调用之后
function withdraw() external {
uint256 amount = balances[msg.sender(;
require(amount > 0);
(bool ok, ) = msg.sender.call{value: amount}(""); // 控制权先出去
require(ok);
balances[msg.sender( = 0; // 太晚
}
// 加固版本:CEI
function withdraw() external nonReentrant {
uint256 amount = balances[msg.sender(;
require(amount > 0);
balances[msg.sender( = 0; // effects 先做
(bool ok, ) = msg.sender.call{value: amount}("");
require(ok, "transfer failed");
}
调用栈:
Attacker.attack()
Vault.withdraw()
Attacker.fallback() ← 重入点
Vault.withdraw()
Attacker.fallback()
Vault.withdraw()
...直到 gas 或余额耗尽
常见误区
- 误区:用了
transfer()(2300 gas)就不会重入;正解:2300 gas 在大都会与 SSTORE 涨价后已不够安全,且不能阻止所有重入路径,更不能替代 CEI。 - 误区:CEI 是唯一防护;正解:CEI + ReentrancyGuard + pull-over-push 是组合拳,单一手段都有边界。
- 误区:只要不转原生 ETH 就不会重入;正解:ERC-777、ERC-721、任意第三方合约回调都能触发重入。
追问
- 为什么递归重入能持续到合约余额耗尽而不是一次就 revert?答:每次重入都基于"旧余额"通过 require,而合约余额在递归中不断减少,只要还够支付一次 call 就继续。机制上状态在递归返回前不更新,等于把"单次取款"放大成了"按余额重复取款"。边界在于:如果合约里有其他用户的存款,攻击者取走的是别人的钱;如果合约余额不足,最后一次 call 会因 value 超余额而失败。延伸:这就是经典 DAO 类漏洞的数学结构。
- CEI 顺序写反了会怎样?答:编译器不报错、测试不失败,只有攻击者能触发。机制上正常用户调用时外部调用成功、状态更新照常执行,单测看不到任何异常。边界在于:富吉测试(fuzz)如果不引入恶意合约 actor,也发现不了。延伸:这就是为什么 invariant 测试要把合约作为 actor 纳入。
- CEI 能不能防住所有外部调用风险?答:不能。它防的是"基于旧状态重入",但防不住"外部调用本身被对方用来操纵环境"(如闪电贷价格操纵、MEV 排序)。机制上 CEI 只解决本合约的状态一致性,不解决预言机、流动性、交易顺序这些外部依赖。延伸:15.5.2 专门讲这一类。
15.5.1-002 为什么 tx.origin 不能做权限检查?msg.sender 与 tx.origin 的差别?
一句话结论
tx.origin 是整条交易链的最外层发起者(钱包持有人),msg.sender 是直接调用本合约的地址(可能是用户钱包,也可能是中间合约)。用 tx.origin 做 owner 检查意味着:用户只要通过任何一个被攻击者控制的合约来调用你的合约,tx.origin 仍然是用户本人,权限检查就被绕过了。
概念解释
tx.origin:交易最外层 EOA 地址,整条交易链不变。msg.sender:直接调用栈上一层的地址,每深入一层都会变。- 钓鱼攻击:攻击者部署一个恶意合约,诱导 owner 去调用它,恶意合约再调用你的
ownerAction(),此时tx.origin == owner。 - 正确做法:权限检查用
msg.sender与 owner 比对,且 owner 是 EOA 或多签合约。
原理流程
- 项目合约
Vault写了require(tx.origin == owner, "not owner")。 - 攻击者部署
Phishing,里面有一个函数steal(),内部调用Vault.withdrawAll()。 - 攻击者在社交渠道发消息:"快来体验新功能,点这里领空投",并诱导 owner 钱包发起一笔交易调用
Phishing.steal()。 - owner 的钱包签名这笔交易,
tx.origin = owner,msg.sender = Phishing。 Phishing.steal()内部调用Vault.withdrawAll(),此时msg.sender = Phishing,但tx.origin = owner。Vault的权限检查通过,攻击者成功提走全部资金。
代码或图示
// 危险写法
function setOwner(address newOwner) external {
require(tx.origin == owner, "not owner"); // 任何中间合约都能通过
owner = newOwner;
}
// 正确写法
function setOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
modifier onlyOwner() {
require(msg.sender == owner, "not owner");
_;
}
调用链:
owner(EOA) → Phishing.steal()
└─ Vault.setOwner(attacker)
tx.origin = owner ← 攻击者利用这一点
msg.sender(Phishing) = Phishing
msg.sender(Vault) = Phishing
常见误区
- 误区:用
tx.origin做检查可以"防止合约调用",是更安全的;正解:它防不住"用户被诱导调用恶意合约",反而把钓鱼攻击面打开了。 - 误区:
tx.origin只能用于钱包类合约;正解:任何权限敏感操作都不应该用它,包括提款、铸币、暂停、升级。 - 误区:owner 是多签合约就没问题;正解:多签合约里的
tx.origin仍然是发起多签签名的 EOA,钓鱼依然成立。
追问
- 什么场景下
tx.origin是合法的?答:仅用于"判断当前调用是否来自 EOA",例如防止合约钱包直接调用某个敏感函数。机制上tx.origin是 EOA,msg.sender是合约,二者不等说明中间有合约。边界在于:现代智能账户(ERC-4337)让"EOA 直接调用"这个假设本身在瓦解,这种用法也在退化。延伸:审查时凡是看到tx.origin,都要追问"这里到底想判断什么"。 - 钓鱼攻击为什么能诱导 owner 点?答:因为签名交易本身不直接显示"接下来会调用哪些合约",用户看到的是
Phishing.steal()的 ABI,看不到内部嵌套调用。机制上 EVM 不向用户展示内部调用图,钱包只能解析最外层 calldata。边界在于:钱包的 "simulate"(如 EIP-5792、Tenderly 风格预览)能把内部调用展开给用户看,是一种缓解。延伸:这也是为什么签名授权(permits、signatures)要把授权范围写死在 EIP-712 里。 - 用
msg.sender就一定安全吗?答:不一定。msg.sender是直接调用者,如果你的函数允许任意合约调用,攻击者可以让自己的合约作为msg.sender通过检查。机制上正确的权限模型是"owner 白名单 + 角色分离",而不是单一变量。边界在于:如果 owner 本身是个热钱包被泄露,msg.sender检查一样失效。延伸:多签、时间锁、角色(AccessControl)是下一层防护。
15.5.1-003 Solidity 0.8 之前整数溢出怎么发生?SafeMath 原理?
一句话结论
Solidity 0.8 之前,uint 算术在溢出时静默回绕(wrap around),不 revert;攻击者可以构造输入让 a + b 回绕成很小的值,绕过 require(balance >= amount) 这类检查。SafeMath 在每次运算前显式检查上界与下界,溢出即 revert。Solidity 0.8 把这套检查内建到编译器里,默认开启,只有显式 unchecked 块才回绕。
概念解释
uint256最大值约 1.15e77,加 1 会变成 0。- 溢出攻击的典型路径:
balanceOf[user( + amount回绕成 0,require(balanceOf[user( >= amount)失败;或反过来balance -= amount下溢成极大值。 - SafeMath:库函数,加/减/乘前 require 上下界,除前 require 分母非零。
- Solidity 0.8:编译器在每个算术操作后插入
0 < x之类的隐式检查,溢出 revert。
原理流程
- 0.7 代码:
balances[msg.sender( += amount,用户传type(uint256).max加上自己已有余额,回绕成 0。 - 检查
require(balances[msg.sender( >= amount)时,0 < amount,检查失败——但如果顺序反过来,先require再+=,就能被利用。 - 更常见的是
balances[from( -= amount:如果balances[from( < amount,下溢成一个极大值,再balances[to( += amount让 to 账户凭空多钱。 - SafeMath 的
sub(a, b)内部require(b <= a),不满足直接 revert,不会回绕。 - 0.8 编译器在 AST 层面给每个
+、-、*插入溢出检查,等价于自动包了 SafeMath。
代码或图示
// Solidity 0.7 漏洞代码
function transfer(address to, uint256 amount) public {
balances[msg.sender( -= amount; // 若余额不足,下溢成极大数
balances[to( += amount; // 接收方凭空入账
}
// SafeMath 加固
using SafeMath for uint256;
function transfer(address to, uint256 amount) public {
balances[msg.sender( = balances[msg.sender(.sub(amount);
balances[to( = balances[to(.add(amount);
}
// Solidity 0.8 默认行为
function transfer(address to, uint256 amount) public {
balances[msg.sender( -= amount; // 余额不足自动 revert
balances[to( += amount;
}
常见误区
- 误区:0.8 之后就再也没有整数问题了;正解:0.8 只防溢出回绕,不防"逻辑上溢出但数学上合法"的精度损失、舍入错误、外部输入未校验范围。
- 误区:SafeMath 比 0.8 慢;正解:SafeMath 与 0.8 内建检查的 gas 量级相当,性能差异主要在 unchecked 块是否显式使用。
- 误区:乘除顺序无所谓;正解:
(a * b) / c与(a / c) * b在大数下结果差异巨大,且前者可能溢出。
追问
- 为什么 0.8 之前社区会出 SafeMath?答:因为 EVM 本身不做溢出检查,Solidity 早期为了省 gas 也不插入,开发者必须自己加。机制上 EVM 的
ADD/MUL指令溢出时直接截断,不会报错。边界在于:SafeMath 只能挡住它包装过的运算,没包装的裸运算依然危险。延伸:0.8 把这个责任从开发者转移到编译器,是工程上的重大改进。 - 外部调用返回值未校验与溢出有什么关系?答:ERC-20 的
transfer/transferFrom在 0.8 时代仍可能返回false而不是 revert(如 USDT 的实现),如果直接balances[to( += amount而不检查返回值,等于"钱没到账但账上加了"。机制上这不是溢出,但属于同一类"未校验外部返回值"的漏洞族。边界在于:OpenZeppelin 的SafeERC20会把false转成 revert,并处理不返回数据的 token。延伸:审计里SafeERC20是必查项。 - 0.8 的 unchecked 块是不是"回到 0.7 行为"?答:是,但仅限块内。机制上编译器跳过该块内的溢出检查,开发者自己负责数学上不会溢出。边界在于:unchecked 块里的变量来自外部输入时,必须有显式范围校验,否则等于把漏洞又请回来。延伸:审计看到 unchecked 块会逐条问"这里凭什么不溢出"。
15.5.1-004 ReentrancyGuard 的实现原理是什么?为什么它防不住跨函数重入?
一句话结论
ReentrancyGuard 用一个 uint256 状态变量 _status(0 表示空闲,1 表示锁定),修饰符 nonReentrant 在函数入口检查 _status == 0,然后置 1,函数返回时恢复 0。它防的是"同一函数被重入",但防不住"函数 A 重入到同合约的函数 B"——因为 B 自己可能没加 nonReentrant,或者加了但锁是同一个、A 持锁时 B 也能进。
概念解释
- 锁是合约级单变量:所有
nonReentrant函数共享同一把锁。 - 函数 A 持锁期间,B 也带
nonReentrant时会被挡住;但 B 不带nonReentrant时,重入 B 完全合法。 - 跨函数重入的典型路径:A 是提款函数,B 是转账函数,A 持锁 call 外部合约,外部合约回调 B,B 利用 A 还没更新完的状态做转账。
- 防护思路:要么所有"读写共享状态"的函数都加锁,要么用 CEI 让所有重入看到的状态一致。
原理流程
- OZ 的
ReentrancyGuard定义uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status;。 nonReentrant修饰符:require(_status == _NOT_ENTERED); _status = _ENTERED; _; _status = _NOT_ENTERED;。- 攻击者从
withdraw()(带锁)重入到transfer()(不带锁),transfer直接执行。 - 此时
withdraw还在 call 等待中,balances[attacker(可能已被清零,但allowances[attacker([victim(这类状态还没更新,攻击者可以把 victim 的授权额度转给自己。 - 解决方案:要么
transfer也加nonReentrant,要么把"所有会修改共享状态的函数"都纳入同一把锁。
代码或图示
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status = _NOT_ENTERED;
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
// 跨函数重入示例:
function withdraw() external nonReentrant {
uint256 amount = balances[msg.sender(;
(bool ok, ) = msg.sender.call{value: amount}("");
require(ok);
balances[msg.sender( = 0;
}
function transfer(address to, uint256 amount) external {
balances[msg.sender( -= amount; // 没加锁
balances[to( += amount;
}
// 攻击者在 fallback 里调 transfer:此时 balances[attacker( 还没清零,但 allowances 还在
常见误区
- 误区:加了
nonReentrant就万事大吉;正解:它是个粗粒度锁,必须与 CEI 配合,且要覆盖所有共享状态写入函数。 - 误区:锁越多越好;正解:所有函数都加锁会让合法的跨函数调用也被挡住(如 A 内部调用 B,B 带锁就死锁),需要用
_nonReentrantBefore/_nonReentrantAfter或内部函数不加锁。 - 误区:ReentrancyGuard 是 OpenZeppelin 专利;正解:它就是个 20 行的状态机,自己写也一样,但用 OZ 的实现经过审计更稳妥。
追问
- 为什么 OZ 用 1/2 而不是 0/1?答:为了让"未初始化"状态与"未进入"状态区分开。机制上合约部署时 storage 槽默认是 0,如果用 0 表示空闲,第一次调用检查
_status == 0也会通过,看起来没问题;但用 1/2 可以让构造函数初始化时显式赋 1,避免 storage 默认值带来的歧义。边界在于:这是防御性设计,不是安全必需。延伸:OZ 在 v4 后才把_status改成_NOT_ENTERED=1模式。 - 锁能不能防住闪电贷?答:不能。闪电贷是在同一笔交易里借入、操纵、归还,整笔交易都在一个 call 上下文里。机制上重入锁防的是"递归重入",闪电贷是"线性执行",锁在闪电贷开始前就已经释放。边界在于:闪电贷攻击的核心是价格操纵,不是状态重入,防护思路完全不同。延伸:见 15.5.2。
- 跨函数重入怎么在审计中识别?答:找"带外部 call 的函数 A"和"不带锁但读写共享状态的函数 B",画调用图看 A 能否通过外部合约回调到 B。机制上人工审计要列一张"外部 call → 可重入函数"的表。边界在于:协议越大,函数越多,调用图越复杂,工具(Slither 的 reentrancy detector)会自动扫这类路径。延伸:invariant 测试把合约作为 actor 是更系统的发现方式。
15.5.1-005 ERC-777 / ERC-721 的 hook 如何把重入面扩大到转账路径?
一句话结论
ERC-777 在 transfer/send 时会调用接收方合约的 tokensReceived hook,ERC-721 在 safeTransferFrom 时会调用 onERC721Received;这意味着即使你的合约不转原生 ETH,只要你在外部调用里转了一个带 hook 的 ERC-20/ERC-721,接收方就能在 hook 里重入你的合约,重入面从"原生 ETH 转账"扩大到"任意 token 转账"。
概念解释
- ERC-777:标准规定
transfer时必须调用IERC1820Registry注册的tokensReceived接口,接收方可以是合约。 - ERC-721
safeTransferFrom:调用onERC721Received,返回值不匹配会 revert,但 hook 本身已执行。 - 重入时机:token 转账发生在你合约函数的中间,状态可能已部分更新。
- 防护:所有 token 转账都应放在 CEI 的最后,且整个函数加
nonReentrant。
原理流程
- 你的合约
swap():先更新balances[msg.sender(,然后token.transferOut(attacker, amount)。 token是 ERC-777,transferOut内部调用attacker.tokensReceived(...)。attacker在tokensReceived里回调你的合约swap(),此时balances[msg.sender(已被更新,但reserve还没更新(或反过来)。- 攻击者利用状态差重复兑换,套取差价。
- 防护:CEI + nonReentrant 覆盖所有 token 流出路径;不与未审计的 hook 代币交互,或用
transfer而不是safeTransferFrom。
代码或图示
// 漏洞:token 转账在状态更新中间
function swap(uint256 amountIn) external {
reserves[msg.sender( += amountIn;
IERC777(token).transfer(msg.sender, amountOut); // hook 触发
reserves[address(this)( -= amountOut; // 还没更新
}
// 加固
function swap(uint256 amountIn) external nonReentrant {
reserves[msg.sender( += amountIn;
reserves[address(this)( -= amountOut;
IERC777(token).transfer(msg.sender, amountOut); // 最后才转账
}
常见误区
- 误区:用
transfer而不是safeTransferFrom就不会触发 hook;正解:ERC-777 即使不用 safe 也会触发tokensReceivedhook(它是 transfer 的强制行为)。 - 误区:你的合约不持有 ERC-777 就没事;正解:只要你在交易路径上调用了"外部 token 转账给攻击者",攻击者就能注册 hook 接收。
- 误区:OZ 的
SafeERC20能防 hook;正解:它只处理返回值,不阻止 hook 执行。
追问
- 为什么 ERC-777 要设计 hook?答:为了让接收方合约能在收到 token 时自动执行逻辑(如自动做市、自动质押),类似"代币到账即触发动作"。机制上它把 ERC-20 从"被动账本"升级成"主动消息"。边界在于:这个便利性同时把所有转账路径变成了重入入口,所以 ERC-777 在 DeFi 协议里的采用率一直不高。延伸:ERC-777 最著名的案例就是被用于重入攻击。
- 审计时怎么判断一个 token 是不是 hook 代币?答:查它是否注册了 ERC-1820 接口、是否继承自 ERC-777、是否有
tokensReceived调用。机制上可以在 fork 测试里把 token 换成恶意实现,看是否能重入。边界在于:有些老 token 不标准但有自定义 hook(如某些资产凭证),需要看源码。延伸:协议设计上常维护一个"已知 hook 代币"白名单。 - 为什么 ERC-721 的 safeTransferFrom 也要警惕?答:因为
onERC721Received在 NFT 元数据更新前执行,攻击者可以在 hook 里重入涉及 NFT 状态的函数。机制上与 ERC-777 同理,只是触发点是 NFT 转移。边界在于:ERC-721 的 hook 必须返回特定 magic value,否则 revert,所以"重入后 revert"会导致整个交易失败,但攻击者可以利用这个 revert 做 DoS。延伸:NFT 市场的重入攻击历史上多次出现。
15.5.1-006 精度与舍入方向为什么会成为安全问题?mulDiv 向上/向下取整的取舍?
一句话结论
在金库、借贷、AMM 这类按比例计算份额的协议里,mulDiv(a, b, c) 的舍入方向决定了"谁承担舍入误差":向下取整对协议方有利(用户拿到的份额略少),向上取整对用户有利(协议多付)。方向选错在极端输入下会被攻击者反复利用,每次套取微小差额,累积成可观损失——这就是"舍入攻击"。
概念解释
- ERC-4626 金库:
assets = totalSupply * totalAssets / totalShares,乘除顺序与舍入方向直接影响份额计算。 - 舍入方向:OZ 的
Math.mulDiv默认向下取整,Rounding.Ceil向上取整。 - 舍入攻击:攻击者用极小数额多次存取,每次套取舍入差,配合闪电贷放大。
- 原则:"对自己不利的方向取整"——mint 份额时向下取整,burn 赎回时向上取整,让协议永远不吃亏。
原理流程
- 金库总份额 1e18,总资产 1e18,汇率 1:1。
- 攻击者存入 1 wei,按向下取整
shares = assets * totalShares / totalAssets = 1 wei,拿到 1 wei 份额。 - 攻击者通过捐赠(直接 transfer 资产给金库)人为抬高
totalAssets到 1e18 + 1。 - 攻击者赎回 1 wei 份额,
assets = shares * totalAssets / totalShares,向下取整可能拿到 1 wei 或 0 wei——但在某些顺序下,舍入差会被算成 2 wei。 - 重复此操作,每次套 1 wei 差,配合闪电贷放大 1e18 次,累积成显著损失。
- 加固:mint 时
shares = assets.mulDiv(totalShares, totalAssets, Floor),redeem 时assets = shares.mulDiv(totalAssets, totalShares, Ceil),让用户永远少拿一点。
代码或图示
// ERC-4626 正确的舍入方向
function _convertToShares(uint256 assets, Rounding rounding) internal view returns (uint256) {
return assets.mulDiv(totalSupply(), totalAssets(), rounding);
// mint 用 Floor(用户拿少)
// withdraw 用 Ceil(用户多拿,但 burn 时要核对)
}
// 原则:
// deposit → mint 份额:Floor(用户拿少)
// withdraw → 赎回资产:Floor(用户拿少)
// mint → 按份额算资产:Ceil(用户多存才能拿到对应份额)
// redeem → 按份额算资产:Floor(用户拿少)
常见误区
- 误区:舍入误差很小,无所谓;正解:在份额类协议里,单次 1 wei 的差配合闪电贷和高频调用,累积损失可以是协议总资产的显著比例。
- 误区:用
uint256就不会精度问题;正解:uint 是整数,任何除法都有舍入,关键是方向。 - 误区:OZ 库默认方向是对的;正解:OZ 默认
Floor,但你要根据 mint/burn 场景选择Ceil,不能全用默认。
追问
- 为什么"对自己不利方向取整"是安全原则?答:因为攻击者只会在"对自己有利"时才触发交易。机制上如果你取整方向让攻击者每次都吃亏,他就没有动机反复调用;如果方向让他每次都赚一点,他就会用闪电贷无限放大。边界在于:极端情况下"对自己不利"会让正常用户也吃亏(每次存取损失微量精度),需要在文档里说明。延伸:ERC-4626 标准明确规定了 mint/burn 的舍入方向,实现时必须遵守。
- 舍入攻击与闪电贷是什么关系?答:舍入攻击单次获利极小(1 wei 量级),需要闪电贷把本金放大到 1e18 级,再高频重复操作才能累积成可观测损失。机制上闪电贷提供"无需自有资金"的放大杠杆,让小攻击者也能尝试。边界在于:如果协议有最小存取限额、有冷却期、有费率,舍入攻击的收益会被压缩。延伸:很多协议加"first depositor"保护(初始捐赠锁定)就是为了防这类。
- 乘除顺序怎么选?答:
mulDiv(a, b, c)一次性做完,比(a * b) / c安全,因为前者用 512 位中间值,不会溢出。机制上 OZ 的mulDiv内部用 assembly 做 512 位乘法与除法。边界在于:如果a * b在业务逻辑上本身就需要中间值,顺序选择会影响精度。延伸:审计里凡是看到裸a * b / c,都要问"为什么不用 mulDiv"。
15.5.1-007 unchecked 块什么时候可以用?审计为什么要重点查它?
一句话结论
unchecked 块跳过 Solidity 0.8 的溢出检查,节省 gas,仅在数学上可证明块内运算不会溢出时使用;典型场景是循环计数器(for (uint i = 0; i < n; i++) 中 i++)、已经过范围校验的外部输入、以及已知有界的差分。审计看到 unchecked 块会逐条追问"凭什么这里不溢出",答不上来就是高危。
概念解释
- Solidity 0.8 内建检查:每个
+、-、*后插入一个LT检查,约耗 150 gas。 unchecked块:块内不插入检查,等价于 0.7 行为。- 合法场景:循环计数(
i < n已经限制了i++不会溢出)、已 require 范围的输入、单调递增 nonce。 - 危险场景:外部输入直接参与运算、依赖外部合约返回值做差、用户可控的数组索引。
原理流程
- 编译器在 0.8 下给每个
i++插入溢出检查。 - 循环
for (uint i = 0; i < n; i++)里,i从 0 开始,每次 +1,i < n已经限制i < n < 2^256,所以i++不可能溢出。 - 写成
unchecked { i++; }可以省 gas。 - 但如果块内是
balances[from( -= amount,from的余额来自外部输入,amount也是外部输入,unchecked 就会回绕成极大数。 - 审计的判定:块内所有变量的来源是否都有界?边界条件是否覆盖?
代码或图示
// 合法:循环计数器
function process(uint256 n) external {
for (uint256 i = 0; i < n; i++) {
unchecked { i++; } // i < n 已限制上界
}
}
// 危险:外部输入直接做差
function withdraw(uint256 amount) external {
unchecked {
balances[msg.sender( -= amount; // 若 amount > balance,下溢成极大数
}
}
常见误区
- 误区:unchecked 是优化开关,随便用;正解:它是"我对这段数学有信心"的承诺,写错就是漏洞。
- 误区:循环里用 unchecked 一定安全;正解:如果循环边界
n本身来自外部输入且未校验,i < n不能保证i不溢出。 - 误区:unchecked 只影响 gas;正解:它影响正确性,是安全审查项。
追问
- 审计怎么判断一个 unchecked 块是否合法?答:审计员会手动推演块内所有变量的上界,看 require 链是否覆盖。机制上需要画出数据流:变量来自哪里、经过哪些 require、块内运算的中间值是否可能溢出。边界在于:复杂协议里数据流跨多个函数,人工推演容易遗漏,工具(Slither 的 unchecked detector)会列出所有 unchecked 块让人复核。延伸:很多团队的约定是"unchecked 块必须写注释说明为什么不溢出"。
- unchecked 能省多少 gas?答:每次运算省约 50–150 gas,循环里累积可观。机制上溢出检查是一次
LT+JUMPI,在循环里重复执行几百次,节省量放大。边界在于:现代 EIP-1559 下 gas 价格波动大,省 gas 的收益不一定值得冒安全风险。延伸:热点路径(如 AMM 的 swap)常用 unchecked,但关键路径(mint/burn)很少用。 - 0.8 内建检查会不会误报?答:不会误报,但可能"过度保守"——数学上不会溢出但编译器仍然检查。机制上编译器不知道你的业务逻辑,它按最坏情况检查。边界在于:如果业务逻辑能证明不溢出,unchecked 是合法优化;如果不能证明,宁可保留检查。延伸:审计的判定标准是"你能在白板上证明不溢出吗"。
15.5.1-008 签名级重入(signature reentrancy)与普通重入有什么不同?
一句话结论
普通重入发生在同一笔交易的 call 栈内;签名级重入发生在"用户已签名但交易还未上链"的窗口——用户签名授权了一笔操作,攻击者利用这个签名在 mempool 等待期间,先构造另一笔交易调用同一合约的其他函数,让状态发生变化,再让签名交易上链时基于已变化的状态执行,套取差额。
概念解释
- 签名授权:用户用私钥签了一段 calldata(如 permit、授权、批量操作),把签名交给前端,前端再提交。
- 签名有效期:签名里有
nonce、deadline、chainId,在有效期内任意人都可以提交。 - 重入窗口:签名从生成到上链之间,链上状态可能被攻击者操纵。
- 防护:签名里绑定具体的状态预期(如 minAmount、deadline、specific nonce),让攻击者无法利用状态差。
原理流程
- 用户签了一个 permit:允许
spender动用amount个 token,deadline 是 1 小时后。 - 用户把签名发给前端,前端准备提交到 mempool。
- 攻击者监听到这笔交易(或自己构造一笔交易用这个签名),先在同一合约上调用另一个函数,把
amount对应的状态改成对攻击者有利。 - 然后让签名交易上链,此时 permit 基于被操纵的状态执行,用户授权的额度被用来做对攻击者有利的事。
- 防护:permit 里必须包含
amount的具体值、deadline、nonce,且nonce一次性消费,避免重放;业务上还要在签名里绑定"最小可接受结果"(如 minAmountOut)。
代码或图示
// EIP-2612 permit 的标准字段
struct Permit {
address owner;
address spender;
uint256 value;
uint256 nonce;
uint256 deadline;
}
// 用户签名后,任何人都可以提交 permit
// 攻击者在提交前先操纵状态(如拉低价格、改变余额)
// 业务层签名应绑定结果预期
struct SwapRequest {
address tokenIn;
address tokenOut;
uint256 amountIn;
uint256 minAmountOut; // ← 关键:攻击者无法让结果低于这个值
uint256 deadline;
uint256 nonce;
}
常见误区
- 误区:签名是离线的,链上状态变化不影响;正解:签名只是一段 calldata,链上执行时基于当时状态,状态变了结果就变。
- 误区:nonce 一次性消费就够了;正解:nonce 只防重放,不防"签名后、提交前"的状态操纵。
- 误区:deadline 短就安全;正解:攻击者在 mempool 里就能完成操纵,秒级窗口足够。
追问
- 签名级重入与普通重入的防护思路有什么不同?答:普通重入靠 CEI + 锁,签名级重入靠"在签名里绑定结果预期"。机制上普通重入是同一笔交易内的状态不一致,签名级重入是签名时与执行时的状态不一致。边界在于:签名里绑定的预期越多,用户体验越差(用户要等前端算好 minAmountOut)。延伸:这就是为什么所有 DEX 签名都要求"滑点保护"。
- 为什么 mempool 等待是个问题?答:因为交易从提交到上链有时间窗口,且 MEV 搜索者可以重新排序。机制上公开 mempool 里,攻击者能看到所有待处理交易,包括用户签名的 calldata。边界在于:私有交易池(如 Flashbots Protect)能隐藏 calldata,但不能消除"签名后状态被操纵"的根本问题。延伸:EIP-5792 / ERC-4337 的 bundle 思路把多笔交易打包成一个原子操作,是缓解方向。
- 审计时怎么发现签名级重入?答:找所有"接受外部签名 + 执行外部 call + 依赖链上状态"的函数,问"签名时与执行时的状态差能被谁利用"。机制上签名里如果没有
minAmount、deadline、specific recipient,就是高危。边界在于:业务签名(如允许任何人代付的 permit)本身设计就是公开提交,必须在业务层加结果绑定。延伸:审计报告里这类问题通常归为"逻辑漏洞"而不是"代码漏洞"。
15.5.1-009 为什么 transfer/send 只转 2300 gas 不是万能解药?
一句话结论
早期社区用 transfer()(2300 gas)防重入,因为攻击者 fallback 里做不了多少事;但 EIP-1884、EIP-2929 等调整后,2300 gas 已经不够完成一次 SSTORE 甚至一次外部调用,且它会把"合规的接收方合约"也挡住(如 Gnosis Safe 的接收逻辑需要更多 gas)。现代最佳实践是 call{value: ...}("") + CEI + ReentrancyGuard,而不是依赖 gas 限制。
概念解释
transfer:硬编码 2300 gas,失败时 revert。send:硬编码 2300 gas,失败时返回 false。call{value: ...}(""):转发所有剩余 gas,由调用方决定。- EIP-1884:调整了 SSTORE 等操作的 gas 成本,让 2300 gas 不再是"安全的空操作预算"。
原理流程
- 早期
transfer2300 gas 假设:fallback 只能做日志事件,不能写 storage、不能再 call。 - 但有些合规合约(如 Gnosis Safe、ERC-777 接收方)在接收 ETH 时需要写 storage、发事件,2300 gas 不够,导致
transfer失败。 - 同时,EIP-1884 后 SSTORE 成本上升,2300 gas 连一次 SSTORE 都做不到,反而把"正常接收方"挡在外面。
- 攻击者 fallback 即使在 2300 gas 内,也能做一次
call到其他合约(虽然不能写 storage),配合其他合约的状态操纵仍可能利用。 - 现代做法:用
call{value: ...}(""),检查返回值,配合 CEI + 锁,让接收方有足够 gas 完成合规逻辑。
代码或图示
// 不推荐:transfer 会挡住合规接收方
msg.sender.transfer(amount);
// 推荐:call + 返回值检查
(bool ok, ) = msg.sender.call{value: amount}("");
require(ok, "ETH transfer failed");
// 同时配合 CEI + nonReentrant
function withdraw() external nonReentrant {
uint256 amount = balances[msg.sender(;
require(amount > 0);
balances[msg.sender( = 0;
(bool ok, ) = msg.sender.call{value: amount}("");
require(ok);
}
常见误区
- 误区:用
transfer就安全;正解:它只是省了 gas,且在 EIP-1884 后行为不可靠。 - 误区:2300 gas 内攻击者什么都做不了;正解:仍能做一次 call(虽然便宜),且能触发其他合约的逻辑。
- 误区:
send返回 false 比transferrevert 好;正解:send返回 false 后你必须检查,否则等于"钱没转出但状态已更新",更危险。
追问
- 为什么 EIP-1884 改变了 2300 gas 的语义?答:因为经济安全原因,调整了 trie 大小的 gas 成本,让状态访问变贵。机制上 EIP-1884 提高了 SLOAD/SSTORE 的 gas,让 2300 gas 不足以完成写 storage。边界在于:这是协议层参数调整,合约无法控制,依赖 2300 gas 的代码会在硬分叉后突然行为变化。延伸:这就是为什么"硬编码 gas"是反模式。
- 为什么 call 转发所有 gas 是安全的?答:因为安全不来自 gas 限制,而来自"状态已更新 + 锁已持有"。机制上即使攻击者拿到所有 gas,重入时检查
balances[msg.sender( > 0也是 false。边界在于:如果你的防护只依赖 gas 限制,不依赖 CEI/锁,call 就会让你暴露。延伸:这是 15.5.1-001 到 15.5.1-004 的核心结论。 - 接收方合约 revert 怎么办?答:用 pull-over-push 模式——让用户自己来提,而不是合约主动推。机制上
withdraw()函数让用户主动 call,失败时用户可以换个方式提,不阻塞其他人。边界在于:有些业务场景必须主动推(如清算、空投),这时要做白名单或失败回退。延伸:审计里"push 模式"是常见的 DoS 风险点。
15.5.1-010 设计一个带外部 ERC-20 的金库,需要同时防住哪些攻击面?
一句话结论
一个接受任意 ERC-20 存款、可赎回的金库,需要同时防:原生 ETH/ERC-20 转账的重入(CEI + 锁)、ERC-777 hook 重入(所有 token 流出在最后)、精度与舍入方向(mint Floor / redeem Floor)、transfer 返回值未校验(SafeERC20)、价格预言机操纵(与 15.5.2 衔接)、权限检查(msg.sender 而非 tx.origin)、未初始化实现合约(与 15.5.3 衔接)。
概念解释
- 金库核心状态:
totalShares、totalAssets、balances[user(。 - 外部依赖:用户存入的 ERC-20 可能是 hook 代币、可能是返回 false 的非标代币、可能价格被操纵。
- 攻击面清单:重入、精度、未校验返回值、预言机、权限、初始化、升级。
- 防护组合:CEI + ReentrancyGuard + SafeERC20 + mulDiv 方向 + 预言机多源 + onlyOwner。
原理流程
- 存款:用户
transferFromtoken 到金库,金库按当前汇率mint份额。 - 校验:用 SafeERC20 包装 transfer,检查返回值。
- 汇率计算:
shares = assets.mulDiv(totalShares, totalAssets, Floor),避免向上取整让用户多拿。 - 赎回:先
burn份额,再transfertoken 给用户,整个函数加 nonReentrant。 - token 流出放在状态更新最后,防止 ERC-777 hook 重入。
- 权限:
onlyOwner修饰器用msg.sender,禁用tx.origin。 - 升级:实现合约构造函数禁用初始化(
_disableInitializers()),防止攻击者把实现合约初始化后自毁。
代码或图示
contract Vault is ERC4626, ReentrancyGuard {
using SafeERC20 for IERC20;
function deposit(uint256 assets, address receiver) public nonReentrant returns (uint256) {
uint256 shares = previewDeposit(assets); // 用 Floor
_mint(receiver, shares);
IERC20(asset()).safeTransferFrom(msg.sender, address(this), assets);
// 注意:状态先改,token 后转(但 transferFrom 是用户给我们转,不是我们给外部转)
}
function withdraw(uint256 assets, address receiver, address owner) public nonReentrant returns (uint256) {
uint256 shares = previewWithdraw(assets);
_burn(owner, shares); // 先 burn
IERC20(asset()).safeTransfer(receiver, assets); // 再转 token
// 即使 receiver 是 ERC-777 hook 合约,重入时 shares 已 burn,preview 显示 0
}
function _convertToShares(uint256 assets, Rounding r) internal view returns (uint256) {
return assets.mulDiv(totalSupply(), totalAssets(), r);
}
}
攻击面 → 防护映射:
原生 ETH 重入 → CEI + nonReentrant(本合约不收 ETH,但子合约要防)
ERC-777 hook 重入 → token 流出放最后 + nonReentrant
非标 ERC-20 返回 false → SafeERC20
舍入攻击 → mint Floor / redeem Floor
权限钓鱼 → onlyOwner 用 msg.sender
实现合约被初始化 → _disableInitializers()
预言机操纵 → 多源 TWAP(见 15.5.2)
常见误区
- 误区:用了 OZ 的 ERC4626 就安全;正解:OZ 只给骨架,舍入方向、SafeERC20、nonReentrant 仍需你自己接。
- 误区:金库不收 ETH 就不用防重入;正解:ERC-777 hook 一样能触发重入。
- 误区:金额小就不用审计;正解:攻击面与金额大小无关,只与代码结构有关。
追问
- 为什么存款用 transferFrom、赎回用 safeTransfer 是两个不同的风险方向?答:transferFrom 是用户给你转,控制权在用户(用户的合约可以在 transferFrom 里做任何事);safeTransfer 是你给用户转,控制权到用户手里。机制上前者的重入点是"用户给你转账时回调你的 deposit",后者是"你给用户转账时回调你的 withdraw"。边界在于:deposit 时状态更新在 transferFrom 之前还是之后?正确顺序是先算份额、再 mint、再 transferFrom,让 transferFrom 的重入看到的是已 mint 的状态。延伸:ERC-4626 标准对 deposit/withdraw 的顺序有明确规定。
- 如果金库支持多种 ERC-20,风险面怎么变?答:每种 token 都可能是非标、hook、恶意,风险面乘以 token 数量。机制上多资产金库要给每种 token 做独立的汇率与舍入计算,且不能让一种 token 的操纵影响另一种。边界在于:如果多种 token 共享同一储备池,风险会交叉传染。延伸:多资产金库通常隔离储备(每个 token 一个池子),或用单一计价资产。
- 审计金库时最常发现的问题是什么?答:按历史统计,舍入方向错误、未用 SafeERC20、预言机单点、未初始化实现合约这四类最高频。机制上这些都是"看起来对、细想漏"的问题,单测很难覆盖。边界在于:成熟审计会跑 invariant 测试覆盖"任意 actor 存取"场景,能发现单测覆盖不到的路径。延伸:审计报告里金库类问题通常占比最大。
动手练习
练习 1:手写一个带重入漏洞的金库并利用它
- 任务:在 Foundry 里写一个简单的
Vault(CEI 顺序写反),再写一个Attacker合约,用console.log打印攻击前后合约余额,验证递归重入。 - 验收标准:
- Attacker 的 fallback 里能看到重入时
Vault.balances[attacker(还是旧值。 - 把 Vault 改成 CEI + nonReentrant,重入失败,交易 revert。
- 尝试用 ERC-777 hook 替代原生 ETH 转账,复现跨函数重入。
- Attacker 的 fallback 里能看到重入时
练习 2:审计一段真实的金库代码
- 任务:找一个开源 ERC-4626 金库的实现,列出它的舍入方向、是否用 SafeERC20、是否有 nonReentrant。
- 验收标准:
- 能指出 mint/redeem 各用 Floor 还是 Ceil,是否符合"对自己不利"原则。
- 能说出至少一处可改进的防护(如预言机多源、紧急暂停)。
- 能解释
unchecked块在该合约里出现的位置及是否合法。
自检清单
- [ ( 能否在白板上画出重入攻击的完整 call 栈,并指出 CEI 顺序破坏在哪一步?
- [ ( 能否说出
tx.origin钓鱼攻击的三个步骤? - [ ( 能否解释 0.8 内建溢出检查与 0.7 SafeMath 的等价性?
- [ ( 能否说出 ReentrancyGuard 防不住跨函数重入的原因?
- [ ( 能否解释 ERC-777 hook 为什么扩大了重入面?
- [ ( 能否说出 mint/redeem 的正确舍入方向?
- [ ( 能否判断一个
unchecked块是否合法? - [ ( 能否说出签名级重入与普通重入的防护思路差异?
延伸阅读
- OpenZeppelin 官方文档:
ReentrancyGuard、ERC4626、SafeERC20、Math.mulDiv(以当前版本为准)。 - Solidity 官方文档:"Control Flow"、"Checking overflow"、"unchecked" 章节。
- EIP-1967(代理存储槽)、EIP-2612(permit)、EIP-777(tokensReceived hook)原文。
- 经典重入案例公开复盘:The DAO 事件分析(不引用具体金额与地址,只看机制)。
- Trail of Bits、OpenZeppelin 审计报告模板:severity 定级与 finding 描述规范。
待整理清单
- [ ( 补充 ERC-4337 智能账户对 tx.origin 语义的影响
- [ ( 补充近年 ERC-777 重入攻击的公开复盘案例
- [ ( 补充 Foundry invariant 测试覆盖重入场景的模板