罗罗编程学习记录 全栈面试题库
本页导航 展开查看

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 不会替你排序,全靠开发者自觉。

原理流程

  1. 攻击者部署一个恶意合约 Attacker,里面写好 fallback(),收到 ETH 后立刻回调 Vault.withdraw()。
  2. 攻击者向 Vault 存入 1 ETH,拿到 balances[attacker( = 1。
  3. 攻击者调用 Vault.withdraw(),合约读取余额、检查 balances[msg.sender( > 0,然后 msg.sender.call{value: amount}("")。
  4. call 把控制权转给 Attacker.fallback(),此时 Vault 里 balances[attacker( 还没被清零(因为状态更新写在 call 之后)。
  5. fallback 再次调用 withdraw(),检查通过、再次 call,递归直到 Vault 余额耗尽或 gas 用完。
  6. 递归返回后,外层函数才执行 balances[msg.sender( = 0,但已经太晚。
  7. 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 或多签合约。

原理流程

  1. 项目合约 Vault 写了 require(tx.origin == owner, "not owner")。
  2. 攻击者部署 Phishing,里面有一个函数 steal(),内部调用 Vault.withdrawAll()。
  3. 攻击者在社交渠道发消息:"快来体验新功能,点这里领空投",并诱导 owner 钱包发起一笔交易调用 Phishing.steal()。
  4. owner 的钱包签名这笔交易,tx.origin = owner,msg.sender = Phishing。
  5. Phishing.steal() 内部调用 Vault.withdrawAll(),此时 msg.sender = Phishing,但 tx.origin = owner。
  6. 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。

原理流程

  1. 0.7 代码:balances[msg.sender( += amount,用户传 type(uint256).max 加上自己已有余额,回绕成 0。
  2. 检查 require(balances[msg.sender( >= amount) 时,0 < amount,检查失败——但如果顺序反过来,先 require 再 +=,就能被利用。
  3. 更常见的是 balances[from( -= amount:如果 balances[from( < amount,下溢成一个极大值,再 balances[to( += amount 让 to 账户凭空多钱。
  4. SafeMath 的 sub(a, b) 内部 require(b <= a),不满足直接 revert,不会回绕。
  5. 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 让所有重入看到的状态一致。

原理流程

  1. OZ 的 ReentrancyGuard 定义 uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status;。
  2. nonReentrant 修饰符:require(_status == _NOT_ENTERED); _status = _ENTERED; _; _status = _NOT_ENTERED;。
  3. 攻击者从 withdraw()(带锁)重入到 transfer()(不带锁),transfer 直接执行。
  4. 此时 withdraw 还在 call 等待中,balances[attacker( 可能已被清零,但 allowances[attacker([victim( 这类状态还没更新,攻击者可以把 victim 的授权额度转给自己。
  5. 解决方案:要么 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。

原理流程

  1. 你的合约 swap():先更新 balances[msg.sender(,然后 token.transferOut(attacker, amount)。
  2. token 是 ERC-777,transferOut 内部调用 attacker.tokensReceived(...)。
  3. attacker 在 tokensReceived 里回调你的合约 swap(),此时 balances[msg.sender( 已被更新,但 reserve 还没更新(或反过来)。
  4. 攻击者利用状态差重复兑换,套取差价。
  5. 防护: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 也会触发 tokensReceived hook(它是 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 赎回时向上取整,让协议永远不吃亏。

原理流程

  1. 金库总份额 1e18,总资产 1e18,汇率 1:1。
  2. 攻击者存入 1 wei,按向下取整 shares = assets * totalShares / totalAssets = 1 wei,拿到 1 wei 份额。
  3. 攻击者通过捐赠(直接 transfer 资产给金库)人为抬高 totalAssets 到 1e18 + 1。
  4. 攻击者赎回 1 wei 份额,assets = shares * totalAssets / totalShares,向下取整可能拿到 1 wei 或 0 wei——但在某些顺序下,舍入差会被算成 2 wei。
  5. 重复此操作,每次套 1 wei 差,配合闪电贷放大 1e18 次,累积成显著损失。
  6. 加固: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。
  • 危险场景:外部输入直接参与运算、依赖外部合约返回值做差、用户可控的数组索引。

原理流程

  1. 编译器在 0.8 下给每个 i++ 插入溢出检查。
  2. 循环 for (uint i = 0; i < n; i++) 里,i 从 0 开始,每次 +1,i < n 已经限制 i < n < 2^256,所以 i++ 不可能溢出。
  3. 写成 unchecked { i++; } 可以省 gas。
  4. 但如果块内是 balances[from( -= amount,from 的余额来自外部输入,amount 也是外部输入,unchecked 就会回绕成极大数。
  5. 审计的判定:块内所有变量的来源是否都有界?边界条件是否覆盖?

代码或图示

// 合法:循环计数器
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),让攻击者无法利用状态差。

原理流程

  1. 用户签了一个 permit:允许 spender 动用 amount 个 token,deadline 是 1 小时后。
  2. 用户把签名发给前端,前端准备提交到 mempool。
  3. 攻击者监听到这笔交易(或自己构造一笔交易用这个签名),先在同一合约上调用另一个函数,把 amount 对应的状态改成对攻击者有利。
  4. 然后让签名交易上链,此时 permit 基于被操纵的状态执行,用户授权的额度被用来做对攻击者有利的事。
  5. 防护: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 不再是"安全的空操作预算"。

原理流程

  1. 早期 transfer 2300 gas 假设:fallback 只能做日志事件,不能写 storage、不能再 call。
  2. 但有些合规合约(如 Gnosis Safe、ERC-777 接收方)在接收 ETH 时需要写 storage、发事件,2300 gas 不够,导致 transfer 失败。
  3. 同时,EIP-1884 后 SSTORE 成本上升,2300 gas 连一次 SSTORE 都做不到,反而把"正常接收方"挡在外面。
  4. 攻击者 fallback 即使在 2300 gas 内,也能做一次 call 到其他合约(虽然不能写 storage),配合其他合约的状态操纵仍可能利用。
  5. 现代做法:用 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 比 transfer revert 好;正解: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。

原理流程

  1. 存款:用户 transferFrom token 到金库,金库按当前汇率 mint 份额。
  2. 校验:用 SafeERC20 包装 transfer,检查返回值。
  3. 汇率计算:shares = assets.mulDiv(totalShares, totalAssets, Floor),避免向上取整让用户多拿。
  4. 赎回:先 burn 份额,再 transfer token 给用户,整个函数加 nonReentrant。
  5. token 流出放在状态更新最后,防止 ERC-777 hook 重入。
  6. 权限:onlyOwner 修饰器用 msg.sender,禁用 tx.origin。
  7. 升级:实现合约构造函数禁用初始化(_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 打印攻击前后合约余额,验证递归重入。
  • 验收标准:
    1. Attacker 的 fallback 里能看到重入时 Vault.balances[attacker( 还是旧值。
    2. 把 Vault 改成 CEI + nonReentrant,重入失败,交易 revert。
    3. 尝试用 ERC-777 hook 替代原生 ETH 转账,复现跨函数重入。

练习 2:审计一段真实的金库代码

  • 任务:找一个开源 ERC-4626 金库的实现,列出它的舍入方向、是否用 SafeERC20、是否有 nonReentrant。
  • 验收标准:
    1. 能指出 mint/redeem 各用 Floor 还是 Ceil,是否符合"对自己不利"原则。
    2. 能说出至少一处可改进的防护(如预言机多源、紧急暂停)。
    3. 能解释 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 测试覆盖重入场景的模板