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

15.5.4 审计流程与工具链

所属:全栈开发面试题库 / [15 Web3 与区块链((../index.md) / [15.5 合约安全与审计((index.md)

本节要解决的问题

面试里讲"审计",多数人只会说"用 Slither 跑一下"。真正的分水岭是:能不能讲清一次正式审计的完整流程、工具只是辅助而人工判断才是核心、以及 invariant 测试与形式化验证各自能证明什么、不能证明什么。本节解决四个具体问题:一是把审计从"工具扫描"拆成"威胁建模 → 人工代码审查 → 工具扫描 → 符号执行/fuzz → 资产扫描 → 报告撰写"的完整流程;二是讲清 Slither、Mythril、Foundry fuzz 各自的能力边界,知道工具跑过不告警不等于安全;三是把 invariant 测试的 actor 模型、handler 模式讲透,知道它如何系统性发现单测覆盖不到的路径;四是落到 severity 定级(critical/high/medium/low)的判定标准,以及 CI 里应该把哪些检查做成门禁。

学习目标

学完本节,你应当能够:

  • 描述一次正式审计的标准流程与每步产出。
  • 比较 Slither、Mythril、Foundry fuzz、形式化验证的能力边界。
  • 写一个 Foundry invariant 测试,包含 actor 与 handler 模式。
  • 说出审计报告的 severity 定级标准。

先修与前置

  • 建议先读 [15.4.3 合约测试与本地链工程((../../15.4-Solidity与合约工程/15.4.3-合约测试与本地链工程.md),理解 Foundry/Hardhat 测试基础。
  • 本节是 [15.5.5 典型攻击复盘与应急((15.5.5-典型攻击复盘与应急.md) 的前置,先掌握审计方法再学复盘。

知识地图

审计流程
  1. 威胁建模(STRIDE)→ 列出攻击面
  2. 人工代码审查 → 逐行理解逻辑
  3. 工具扫描(Slither/Mythril)→ 自动化发现已知模式
  4. 符号执行/fuzz → 探索状态空间
  5. 资产扫描(Tenderly fork)→ 模拟攻击路径
  6. 报告撰写 → severity 定级 + 修复建议

工具能力边界
  Slither:静态分析,发现已知漏洞模式(重入、tx.origin、未检查返回值)
  Mythril:符号执行,探索所有可能路径
  Foundry fuzz:随机输入,发现边界条件
  Invariant:actor 模型,系统性发现状态不一致
  形式化验证:数学证明属性成立

核心术语

  • 威胁建模(Threat Modeling):用 STRIDE 等方法列出攻击面,明确"谁想攻击、攻击什么"。
  • 静态分析(Static Analysis):不执行代码,扫描 AST 发现已知漏洞模式。
  • 符号执行(Symbolic Execution):用符号变量代替具体值,探索所有可能路径。
  • fuzz 测试:用随机输入反复调用函数,发现边界条件。
  • invariant 测试:定义"系统永远应该成立的属性",用 actor 模型随机调用,验证属性始终成立。
  • 形式化验证(Formal Verification):用数学方法证明合约属性成立(如 Certora Prover)。
  • severity 定级:critical(可直接导致资金损失)、high(需要特定条件)、medium(影响较小)、low(建议改进)。
  • 资产扫描(Asset Scan):在 fork 主网上模拟交易,看是否能套取资金。

覆盖范围

  • 正式审计的标准流程与每步产出
  • Slither/Mythril/Foundry fuzz 的能力边界
  • Foundry invariant 测试的 actor 与 handler 模式
  • 形式化验证的适用场景与局限
  • severity 定级标准
  • CI 门禁的检查项

高频题速览

编号 题目 难度 频率
15.5.4-001 一次正式审计的标准流程是什么? 基础 ★★★★★
15.5.4-002 Slither 能做什么?它的静态分析局限是什么? 基础 ★★★★★
15.5.4-003 Mythril / Foundry 符号执行/fuzz 的区别? 基础 ★★★★
15.5.4-004 Foundry invariant 测试怎么写?actor 与 handler 模式? 进阶 ★★★★★
15.5.4-005 形式化验证(Certora/Prover)能证明什么?不能证明什么? 进阶 ★★★★
15.5.4-006 审计报告的 severity(critical/high/medium/low)怎么定级? 进阶 ★★★★
15.5.4-007 资产扫描(Tenderly/fork simulation)在审计中起什么作用? 进阶 ★★★
15.5.4-008 为什么工具跑过不告警就等于安全?审计员的人工判断价值在哪? 高级 ★★★
15.5.4-009 CI 里应该把哪些检查做成门禁? 高级 ★★★★
15.5.4-010 审计后如何做 bug bounty 与持续监控? 高级 ★★★

15.5.4-001 一次正式审计的标准流程是什么?

一句话结论

一次正式审计通常分六步:威胁建模 → 人工代码审查 → 工具扫描 → 符号执行/fuzz → 资产扫描 → 报告撰写与修复验证。工具只是辅助,人工判断贯穿始终。

概念解释

  • 威胁建模:列出"谁想攻击、攻击什么、怎么攻击",明确审计重点。
  • 人工审查:逐行理解代码逻辑,找业务逻辑漏洞(工具发现不了)。
  • 工具扫描:Slither/Mythril 自动化发现已知漏洞模式。
  • 符号执行/fuzz:探索状态空间,发现边界条件。
  • 资产扫描:fork 主网模拟攻击,看是否能套取资金。
  • 报告撰写:按 severity 定级,给出修复建议。

原理流程

  1. 威胁建模:用 STRIDE(Spoofing、Tampering、Repudiation、Information Disclosure、Denial of Service、Elevation of Privilege)列出攻击面。
  2. 人工审查:审计员逐行读代码,理解业务逻辑,找逻辑漏洞。
  3. 工具扫描:跑 Slither,自动发现重入、tx.origin、未检查返回值等已知模式。
  4. 符号执行/fuzz:跑 Mythril 或 Foundry fuzz,探索所有可能路径。
  5. 资产扫描:用 Tenderly fork 主网,模拟攻击路径,看是否能套取资金。
  6. 报告撰写:按 severity 定级(critical/high/medium/low),给出修复建议,验证修复后重新跑工具。

代码或图示

审计流程:
  1. 威胁建模 → 攻击面清单
  2. 人工审查 → 发现逻辑漏洞
  3. 工具扫描 → Slither 报告
  4. 符号执行/fuzz → 发现边界条件
  5. 资产扫描 → fork 主网模拟
  6. 报告 → severity 定级 + 修复建议

常见误区

  • 误区:审计 = 工具扫描;正解:工具只发现已知模式,逻辑漏洞靠人工。
  • 误区:审计一次就够了;正解:升级后需要重新审计,持续监控。
  • 误区:审计报告是最终结论;正解:它是"发现已知问题"的报告,不是"证明无漏洞"。

追问

  • 审计为什么需要这么久?答:因为人工审查要逐行理解逻辑,工具扫描要配置参数,资产扫描要模拟攻击路径。机制上一个中型项目(5000 行代码)的审计通常需要 2-4 周。边界在于:项目越大、业务越复杂,审计时间越长。延伸:很多项目分阶段审计(先核心逻辑,再外围功能)。
  • 审计报告为什么有不同 severity?答:因为不同问题的影响不同。机制上 critical 可直接导致资金损失(如重入),high 需要特定条件(如未检查返回值),medium 影响较小(如精度损失),low 是建议改进(如代码风格)。边界在于:severity 定级有主观性,不同审计机构可能给出不同定级。延伸:行业有共识标准(如 Trail of Bits 的 severity 定义)。
  • 审计后为什么还要修复验证?答:因为修复可能引入新漏洞。机制上修复一个问题可能破坏其他逻辑,需要重新跑工具与测试。边界在于:修复验证通常由原审计机构做,确保修复正确且无新问题。延伸:很多项目把修复验证作为审计的一部分。

15.5.4-002 Slither 能做什么?它的静态分析局限是什么?

一句话结论

Slither 是静态分析工具,扫描 AST 发现已知漏洞模式(重入、tx.origin、未检查返回值、整数溢出);它的局限是只能发现"已知模式",业务逻辑漏洞、组合式攻击、依赖外部状态的漏洞发现不了。

概念解释

  • 静态分析:不执行代码,扫描 AST。
  • 已知模式:Slither 内置了大量 detector,检查重入、tx.origin、未检查返回值等。
  • 局限:只能发现"已知模式",新漏洞模式发现不了。
  • 局限:业务逻辑漏洞(如错误的舍入方向)发现不了,因为它不理解业务。

原理流程

  1. Slither 解析合约代码,生成 AST。
  2. 跑内置 detector,每个 detector 检查一种模式(如重入 detector 检查"外部 call 后写状态")。
  3. 输出报告:哪些合约、哪些函数、哪一行有问题。
  4. 局限:detector 是"已知模式",新漏洞模式发现不了。

代码或图示

# 安装与运行
pip install slither-analyzer
slither ./src/MyContract.sol

# 输出示例:
# Reentrancy in Vault.withdraw() (src/Vault.sol#42)
#   - External call: msg.sender.call{value: amount}("") (src/Vault.sol#45)
#   - State writes: balances[msg.sender( = 0 (src/Vault.sol#47)

常见误区

  • 误区:Slither 跑过不告警就安全;正解:它只发现已知模式,新漏洞发现不了。
  • 误区:Slither 的告警都是真问题;正解:误报很多,需要人工判断。
  • 误区:Slither 能发现逻辑漏洞;正解:它只发现模式,不理解业务。

追问

  • Slither 有多少 detector?答:公开版本内置了数十个 detector,覆盖重入、tx.origin、未检查返回值、整数溢出等。机制上每个 detector 是一个 Python 脚本,检查一种模式。边界在于:新漏洞模式需要写新 detector,社区会贡献。延伸:很多项目自定义 detector,检查业务特定模式。
  • Slither 的误报率高吗?答:高。机制上 detector 检查的是"模式匹配",很多看起来像漏洞但实际不是(如 CEI 顺序正确的重入 detector 会告警)。边界在于:审计员需要人工判断每个告警是否真问题。延伸:很多项目把 Slither 作为 CI 门禁,但需要配置白名单忽略误报。
  • Slither 与人工审查的关系?答:Slither 发现已知模式,人工审查发现逻辑漏洞。机制上 Slither 是"第一遍扫描",人工审查是"深度理解"。边界在于:复杂协议的逻辑漏洞(如错误的舍入方向)Slither 发现不了。延伸:审计通常"Slither + 人工"配合。

15.5.4-003 Mythril / Foundry 符号执行/fuzz 的区别?

一句话结论

Mythril 是符号执行工具,用符号变量代替具体值,探索所有可能路径;Foundry fuzz 用随机输入反复调用函数,发现边界条件。前者理论上覆盖所有路径,但受状态空间爆炸限制;后者实际覆盖随机路径,但能发现单测想不到的边界。

概念解释

  • 符号执行(Symbolic Execution):用符号变量(如 x)代替具体值,探索所有可能路径。
  • fuzz 测试:用随机输入(如 x = random())反复调用函数。
  • 状态空间爆炸:符号执行探索的路径数随分支数指数增长,实际只能探索有限路径。
  • fuzz 优势:能发现单测想不到的边界条件(如 amount = type(uint256).max)。

原理流程

  1. Mythril 把合约函数参数设为符号变量,尝试所有可能值。
  2. 对每个分支,Mythril 生成约束求解器(如 Z3),检查是否能到达漏洞点。
  3. 路径数随分支数指数增长,实际只能探索有限路径。
  4. Foundry fuzz 用随机输入反复调用函数,检查是否触发 invariant。
  5. fuzz 跑 10000 次,覆盖随机路径,发现边界条件。

代码或图示

# Mythril
myth run ./src/MyContract.sol

# Foundry fuzz
function testFuzz_withdraw(uint256 amount) public {
    vm.assume(amount <= 100 ether);
    vault.deposit{value: amount}();
    vault.withdraw(amount);
    assertEq(address(vault).balance, 0);
}

常见误区

  • 误区:符号执行覆盖所有路径;正解:状态空间爆炸,实际只能探索有限路径。
  • 误区:fuzz 跑过就安全;正解:fuzz 只覆盖随机路径,未探索的路径可能有漏洞。
  • 误区:符号执行比 fuzz 高级;正解:两者互补,符号执行探索理论路径,fuzz 发现实际边界。

追问

  • 符号执行为什么会状态空间爆炸?答:因为每个分支(if/else)都生成两条路径,N 个分支就是 2^N 条路径。机制上合约有几百个分支,路径数是天文数字。边界在于:实际只能探索有限路径(如前 10000 条),覆盖不到的路径可能有漏洞。延伸:这就是为什么符号执行工具(Mythril、Manticore)在实际审计中用得不多。
  • fuzz 怎么发现单测想不到的边界?答:因为 fuzz 用随机输入,可能产生单测想不到的值(如 amount = type(uint256).max)。机制上 fuzz 跑 10000 次,每次随机输入,覆盖各种边界。边界在于:fuzz 是随机的,不保证覆盖所有边界。延伸:很多项目用 fuzz 作为 CI 门禁,每次提交跑 10000 次。
  • 符号执行与 fuzz 怎么配合?答:符号执行探索理论路径,fuzz 发现实际边界。机制上符号执行发现"可能的漏洞点",fuzz 验证"实际是否可触发"。边界在于:两者都受限于状态空间,需要人工审查兜底。延伸:成熟审计通常"符号执行 + fuzz + 人工"配合。

15.5.4-004 Foundry invariant 测试怎么写?actor 与 handler 模式?

一句话结论

invariant 测试定义"系统永远应该成立的属性"(如"合约余额 >= 用户总余额"),用 actor 模型(多个模拟用户)随机调用合约函数,验证属性始终成立。handler 模式封装 actor 的调用逻辑,让测试更结构化。

概念解释

  • invariant:系统永远应该成立的属性,如 totalSupply <= totalAssets。
  • actor:模拟用户,有自己的地址与状态,随机调用合约函数。
  • handler:封装 actor 的调用逻辑,确保调用参数合理(如 amount <= balance)。
  • 测试流程:跑 N 次(如 10000 次),每次随机选择 actor 与函数,检查 invariant 是否成立。

原理流程

  1. 定义 invariant:assertEq(address(vault).balance, vault.totalAssets())。
  2. 写 actor:模拟用户,有自己的余额,随机调用 deposit/withdraw。
  3. 写 handler:封装 actor 的调用,确保参数合理(如 amount <= actor.balance)。
  4. 跑测试:每次随机选择 actor 与函数,调用后检查 invariant。
  5. 如果 invariant 被破坏,测试失败,打印调用序列。

代码或图示

// Handler 模式
contract Handler is Test {
    Vault public vault;
    mapping(address => uint256) public deposits;

    constructor(Vault _vault) { vault = _vault; }

    function deposit(uint256 amount) public {
        amount = bound(amount, 0, address(this).balance);
        vm.prank(msg.sender);
        vault.deposit{value: amount}();
        deposits[msg.sender( += amount;
    }

    function withdraw(uint256 amount) public {
        amount = bound(amount, 0, deposits[msg.sender();
        vm.prank(msg.sender);
        vault.withdraw(amount);
        deposits[msg.sender( -= amount;
    }
}

// Invariant 测试
function invariant_vault_balance() public {
    assertEq(address(vault).balance, vault.totalAssets());
}

常见误区

  • 误区:invariant 测试就是 fuzz;正解:fuzz 用随机输入,invariant 用 actor 模型随机调用,更结构化。
  • 误区:invariant 测试跑过就安全;正解:它只覆盖 actor 模型想到的调用路径,未想到的路径可能有漏洞。
  • 误区:handler 是多余的;正解:它确保调用参数合理,避免无意义的 revert。

追问

  • 为什么用 actor 模型?答:因为真实系统有多个用户并发操作,actor 模型模拟这种并发。机制上每个 actor 是一个模拟用户,有自己的余额,随机调用合约函数。边界在于:actor 数量有限(如 10 个),模拟不了真实世界的并发规模。延伸:很多项目用 10-20 个 actor 模拟。
  • handler 为什么要 bound 参数?答:因为随机参数可能无意义(如 amount > balance 导致 revert)。机制上 bound(amount, 0, balance) 确保参数合理,让测试跑有意义的路径。边界在于:bound 可能漏掉边界条件(如 amount = balance + 1)。延伸:很多项目用 assume 代替 bound,过滤无意义输入。
  • invariant 测试能发现什么?答:能发现单测覆盖不到的状态不一致。机制上单测只覆盖"想到的路径",invariant 覆盖"随机组合的路径"。边界在于:invariant 测试只验证"定义的 invariant",未定义的 invariant 发现不了。延伸:审计时要与业务方一起定义 invariant。

15.5.4-005 形式化验证(Certora/Prover)能证明什么?不能证明什么?

一句话结论

形式化验证用数学方法证明合约属性成立(如"withdraw 后用户余额减少 amount"),它能证明"在给定范围内属性永远成立";但它不能证明"合约没有漏洞",因为属性本身可能定义不全。

概念解释

  • 形式化验证:用数学方法证明合约属性成立。
  • 工具:Certora Prover、K Framework、TLA+。
  • 能证明:在给定范围内(如"所有可能输入"),属性成立。
  • 不能证明:属性本身是否完整、是否覆盖所有漏洞。

原理流程

  1. 用规范语言(如 Certora Spec)定义属性:withdraw(amount) => post(balance == pre(balance) - amount)。
  2. Prover 尝试所有可能路径,检查属性是否成立。
  3. 如果所有路径都成立,属性被证明。
  4. 如果某条路径不成立,Prover 给出反例。
  5. 局限:属性本身可能定义不全(如只验证了 balance,没验证 totalAssets)。

代码或图示

method withdraw(uint256 amount) {
    require(amount < balances[msg.sender();
    uint256 preBalance = balances[msg.sender(;
    uint256 preTotalAssets = totalAssets();

    with (env) {
        withdraw(amount);
    }

    assert(balances[msg.sender( == preBalance - amount);
    assert(totalAssets() == preTotalAssets - amount);
}

常见误区

  • 误区:形式化验证证明合约无漏洞;正解:它只证明定义的属性成立,属性定义不全就漏。
  • 误区:形式化验证是银弹;正解:它成本高、复杂度大,只适合关键合约。
  • 误区:形式化验证比测试高级;正解:两者互补,测试发现实际问题,形式化证明理论属性。

追问

  • 形式化验证为什么成本高?答:因为写规范需要深刻理解合约逻辑,Prover 跑起来需要大量计算资源。机制上 Certora Prover 是云服务,按小时收费,一个中型合约可能需要几千美元。边界在于:它只适合关键合约(如借贷协议的核心逻辑),不适合外围功能。延伸:很多项目只对核心合约做形式化验证。
  • 形式化验证能发现什么?答:能发现"定义的属性"被破坏的情况。机制上 Prover 尝试所有路径,检查属性是否成立,找到反例就报告。边界在于:如果属性定义不全(如只验证了 balance,没验证 totalAssets),相关漏洞发现不了。延伸:写规范需要与业务方一起,确保属性完整。
  • 形式化验证与 invariant 测试的关系?答:形式化验证证明"所有路径"属性成立,invariant 测试验证"随机路径"属性成立。机制上形式化是数学证明,invariant 是统计验证。边界在于:形式化覆盖所有路径但成本高,invariant 覆盖随机路径但成本低。延伸:关键合约用形式化,外围用 invariant。

15.5.4-006 审计报告的 severity(critical/high/medium/low)怎么定级?

一句话结论

critical 是可直接导致资金损失的漏洞(如重入、未检查返回值);high 是需要特定条件才能利用的漏洞(如未初始化实现合约);medium 是影响较小的漏洞(如精度损失);low 是建议改进(如代码风格)。

概念解释

  • critical:可直接导致资金损失,如重入、tx.origin 权限绕过。
  • high:需要特定条件(如特定角色、特定时机)才能利用,如未初始化实现合约。
  • medium:影响较小(如精度损失、gas 优化),不直接导致资金损失。
  • low:建议改进(如代码风格、文档缺失)。

原理流程

  1. 审计员发现一个漏洞,分析其影响:是否可直接导致资金损失?
  2. 如果是,定级 critical。
  3. 如果需要特定条件(如只有 owner 可触发),定级 high。
  4. 如果影响较小(如精度损失 1 wei),定级 medium。
  5. 如果是建议改进(如代码风格),定级 low。

代码或图示

severity 定级标准:
  critical:可直接导致资金损失
    例:重入、tx.origin 权限绕过、未检查返回值导致资金错误
  high:需要特定条件
    例:未初始化实现合约、代理存储冲突
  medium:影响较小
    例:精度损失、gas 优化
  low:建议改进
    例:代码风格、文档缺失

常见误区

  • 误区:severity 定级是客观的;正解:它有主观性,不同审计机构可能给出不同定级。
  • 误区:critical 必须立即修复;正解:critical 确实要立即修复,但 high 也要在上线前修复。
  • 误区:low 可以忽略;正解:low 虽然影响小,但积累起来可能引入新漏洞。

追问

  • 为什么 severity 定级有主观性?答:因为"是否可直接导致资金损失"有判断空间。机制上一个漏洞可能"理论上可导致损失,但实际需要特殊条件",不同审计员可能定级不同。边界在于:行业有共识标准(如 Trail of Bits 的 severity 定义),减少主观性。延伸:很多项目要求审计机构遵循标准 severity 定义。
  • critical 漏洞为什么必须立即修复?答:因为它可直接导致资金损失,不修复就上线等于裸奔。机制上 critical 漏洞(如重入)在主网上会被攻击者利用,资金损失不可逆。边界在于:有些 critical 漏洞需要特定条件(如特定角色),实际利用难度大,但仍应修复。延伸:很多项目在 critical 修复前不上线。
  • 审计报告的 low 项怎么处理?答:low 是建议改进,可以在后续迭代中修复。机制上 low(如代码风格)不影响安全,但积累起来可能影响可维护性。边界在于:low 项如果不修复,可能在未来迭代中引入新漏洞。延伸:很多项目把 low 项记入 backlog。

15.5.4-007 资产扫描(Tenderly/fork simulation)在审计中起什么作用?

一句话结论

资产扫描在 fork 主网上模拟交易,看是否能套取资金。它验证"理论上可利用"的漏洞是否"实际可利用",并量化攻击收益。

概念解释

  • fork 主网:在本地复制主网状态,包括所有合约与余额。
  • 模拟交易:在 fork 上执行攻击交易,看是否能套取资金。
  • 量化收益:计算攻击利润(扣除 gas 与费用)。
  • 作用:验证漏洞可利用性,量化攻击影响。

原理流程

  1. 在 fork 主网上部署攻击合约。
  2. 执行攻击交易(如闪电贷 + 操纵价格 + 借出)。
  3. 检查攻击合约余额:是否有利润?
  4. 计算利润 = 攻击后余额 - 攻击前余额 - gas - 费用。
  5. 如果利润 > 0,漏洞可利用;如果利润 = 0,漏洞理论上存在但实际不可利用。

代码或图示

# Foundry fork 主网
forge test --fork-url $MAINNET_RPC

# 测试里模拟攻击
function test_attack() public {
    uint256 balanceBefore = attacker.balance;
    // 执行攻击
    attack();
    uint256 balanceAfter = attacker.balance;
    assertGt(balanceAfter, balanceBefore, "attack not profitable");
}

常见误区

  • 误区:资产扫描是审计的全部;正解:它只是验证可利用性,不能替代人工审查。
  • 误区:fork 模拟通过就安全;正解:fork 模拟只覆盖"想到的攻击路径",未想到的路径可能有漏洞。
  • 误区:资产扫描只能验证闪电贷攻击;正解:它可以模拟任意攻击路径。

追问

  • 为什么需要 fork 主网?答:因为测试网状态与主网不同,漏洞在测试网可能不可利用,但在主网可利用。机制上 fork 主网复制主网状态,包括所有合约与余额,模拟真实攻击环境。边界在于:fork 主网需要 archive node(历史状态),成本高。延伸:很多项目用 Alchemy/Infura 的 archive node。
  • 资产扫描能量化什么?答:能量化攻击收益(利润)。机制上计算攻击后攻击合约余额,减去攻击前余额与 gas 费用,得到利润。边界在于:如果利润 < 成本,攻击者不会做。延伸:很多审计报告给出"攻击收益估计",帮助项目方判断风险。
  • 资产扫描与人工审查的关系?答:人工审查发现理论漏洞,资产扫描验证实际可利用性。机制上人工审查发现"可能的漏洞",资产扫描验证"是否可利用"。边界在于:资产扫描只覆盖"想到的攻击路径",未想到的路径发现不了。延伸:成熟审计通常"人工 + 资产扫描"配合。

15.5.4-008 为什么工具跑过不告警就等于安全?审计员的人工判断价值在哪?

一句话结论

工具只能发现"已知模式",新漏洞模式、业务逻辑漏洞、组合式攻击都发现不了。审计员的人工判断价值在于理解业务逻辑、发现逻辑漏洞、判断告警是否真问题。

概念解释

  • 已知模式:Slither/Mythril 内置的 detector 只检查已知模式。
  • 新漏洞模式:新漏洞(如签名级重入)工具发现不了。
  • 业务逻辑漏洞:错误的舍入方向、错误的权限检查,工具不理解业务发现不了。
  • 组合式攻击:工具单独扫描每个合约,组合式攻击跨合约发现不了。

原理流程

  1. 工具跑过,没有告警,项目方以为安全。
  2. 但工具只发现已知模式,新漏洞(如签名级重入)发现不了。
  3. 审计员人工审查,理解业务逻辑,发现错误的舍入方向。
  4. 审计员判断 Slither 告警是否真问题(很多是误报)。
  5. 审计员分析组合式攻击,跨合约看攻击路径。

代码或图示

工具 vs 人工:
  工具发现:
    - 已知模式(重入、tx.origin、未检查返回值)
    - 边界条件(fuzz 发现)
  人工发现:
    - 业务逻辑漏洞(错误的舍入方向)
    - 组合式攻击(跨合约攻击路径)
    - 告警是否真问题(误报判断)

常见误区

  • 误区:工具跑过就安全;正解:工具只发现已知模式,新漏洞发现不了。
  • 误区:工具告警都是真问题;正解:误报很多,需要人工判断。
  • 误区:人工审查是多余的;正解:业务逻辑漏洞只有人工能发现。

追问

  • 为什么业务逻辑漏洞工具发现不了?答:因为工具不理解业务。机制上工具检查的是"模式匹配",错误的舍入方向(如应该用 Floor 却用了 Ceil)是业务逻辑问题,工具不知道业务应该怎么取整。边界在于:有些业务逻辑漏洞可以自定义 detector,但需要深刻理解业务。延伸:很多项目自定义 Slither detector,检查业务特定模式。
  • 为什么组合式攻击工具发现不了?答:因为工具单独扫描每个合约,组合式攻击跨合约。机制上 Slither 扫描合约 A,发现 A 没有重入;扫描合约 B,发现 B 没有重入;但 A+B 组合起来可以被操纵。边界在于:工具可以扫描跨合约调用,但组合式攻击的路径太复杂。延伸:成熟审计通常人工分析跨合约攻击路径。
  • 审计员的经验有多重要?答:非常重要。机制上经验丰富的审计员知道"常见的坑"(如未初始化实现合约、错误的舍入方向),能快速发现问题。边界在于:经验也可能带来偏见("我见过的都是这样"),需要保持开放。延伸:很多项目选择有经验的审计机构(如 Trail of Bits、OpenZeppelin)。

15.5.4-009 CI 里应该把哪些检查做成门禁?

一句话结论

CI 门禁应包含:编译检查、单元测试、Slither 扫描、Foundry fuzz(每次提交跑 1000 次)、storage layout 检查、代码规范检查。这些是"每次提交都必须通过"的最低要求。

概念解释

  • 编译检查:forge build 必须通过。
  • 单元测试:forge test 必须通过。
  • Slither 扫描:跑 Slither,忽略已知误报,新告警失败。
  • Foundry fuzz:每次提交跑 1000 次 fuzz。
  • storage layout 检查:升级前对比新旧合约的 slot 布局。
  • 代码规范:lint 检查(如 solhint)。

原理流程

  1. 每次提交,CI 自动跑:编译 → 单元测试 → Slither → fuzz → storage layout → lint。
  2. 任何一项失败,提交被拒绝。
  3. Slither 告警:已知误报在白名单里,新告警失败。
  4. fuzz 跑 1000 次,发现 invariant 被破坏就失败。
  5. storage layout 检查:升级前对比新旧合约的 slot。

代码或图示

# GitHub Actions CI
jobs:
  build-test:
    steps:
      - run: forge build
      - run: forge test
      - run: slither ./src/ --triage-mode
      - run: forge test --fuzz-runs 1000
      - run: forge inspect MyContract storage-layout

常见误区

  • 误区:CI 门禁是多余的;正解:它自动化检查,防止低级错误进入主分支。
  • 误区:fuzz 跑 1000 次太慢;正解:1000 次通常几秒完成,可接受。
  • 误区:Slither 告警都要修复;正解:已知误报在白名单里,新告警才修复。

追问

  • fuzz 跑多少次合适?答:通常 1000-10000 次。机制上 1000 次几秒完成,10000 次几分钟。边界在于:fuzz 次数越多,覆盖越广,但 CI 时间越长。延伸:很多项目用 1000 次作为 CI 门禁,10000 次作为 nightly。
  • Slither 白名单怎么维护?答:已知误报在白名单文件里,新告警需要人工判断是否真问题。机制上 Slither 输出所有告警,项目方把已知误报标记为 "won't fix",新告警失败。边界在于:白名单积累可能漏过真问题。延伸:很多项目定期 review 白名单。
  • storage layout 检查怎么做?答:用 forge inspect MyContract storage-layout 输出 slot 布局,对比新旧合约。机制上每次升级前跑,对比是否一致。边界在于:继承合约的 storage layout 更复杂。延伸:很多项目在 CI 里自动对比。

15.5.4-010 审计后如何做 bug bounty 与持续监控?

一句话结论

审计后做 bug bounty(公开赏金计划),让白帽攻击者帮你找漏洞;持续监控(监控链上异常、事件日志、价格偏离),发现漏洞立即响应。

概念解释

  • bug bounty:公开赏金计划,白帽攻击者发现漏洞可获得赏金。
  • 平台:Immunefi、HackenProof。
  • 持续监控:监控链上异常(大额转账、异常交易)、事件日志、价格偏离。
  • 响应:发现漏洞立即暂停、通知用户、修复。

原理流程

  1. 上线后,在 Immunefi 发布 bug bounty,按 severity 分级赏金。
  2. 白帽攻击者发现漏洞,提交报告,项目方验证后支付赏金。
  3. 持续监控:监控链上异常(大额转账、异常交易)、事件日志、价格偏离。
  4. 发现异常,立即暂停(pause 开关),通知用户,修复漏洞。

代码或图示

bug bounty 赏金分级:
  critical:可直接导致资金损失 → 赏金 = 损失金额的 10%(上限 100 万美元)
  high:需要特定条件 → 赏金 = 损失金额的 5%
  medium:影响较小 → 固定赏金(如 5000 美元)
  low:建议改进 → 固定赏金(如 500 美元)

常见误区

  • 误区:审计后就安全了;正解:审计只发现已知问题,bug bounty 发现未知问题。
  • 误区:bug bounty 成本高;正解:与被盗损失相比,赏金成本低。
  • 误区:持续监控是多余的;正解:它能发现异常交易,及时响应。

追问

  • bug bounty 赏金怎么定?答:按 severity 分级,critical 最高。机制上 critical 漏洞赏金通常是"损失金额的 10%,上限 100 万美元"。边界在于:赏金太低,白帽攻击者没动力;赏金太高,项目方成本高。延伸:很多项目用 Immunefi 平台,按行业标准定级。
  • 持续监控监控什么?答:监控链上异常(大额转账、异常交易)、事件日志、价格偏离。机制上用 Tenderly 或自定义监控,发现异常立即告警。边界在于:监控不能预测攻击,只能发现已发生的异常。延伸:很多项目有"紧急暂停"开关,发现异常立即暂停。
  • 审计 + bug bounty + 监控的关系?答:审计发现已知问题,bug bounty 发现未知问题,监控发现异常交易。机制上三者互补,形成完整安全体系。边界在于:三者都不能保证"无漏洞",但能显著降低风险。延伸:成熟项目三者都做。

动手练习

练习 1:用 Foundry 写一个 invariant 测试

  • 任务:给一个 ERC-4626 金库写一个 invariant 测试,定义 invariant 为 address(vault).balance == vault.totalAssets(),写 actor 与 handler 模式。
  • 验收标准:
    1. 能跑 1000 次,验证 invariant 始终成立。
    2. 故意破坏 invariant(如直接 transfer 资产给金库),测试失败。
    3. 能打印失败时的调用序列。

练习 2:在 CI 里配置 Slither 门禁

  • 任务:写一个 GitHub Actions 配置,每次提交跑 Slither,已知误报在白名单里,新告警失败。
  • 验收标准:
    1. 能在 CI 里跑 Slither。
    2. 已知误报(如 timestamp 检查)在白名单里。
    3. 新告警(如 tx.origin 权限检查)导致 CI 失败。

自检清单

  • [ ( 能否描述一次正式审计的六步流程?
  • [ ( 能否比较 Slither、Mythril、Foundry fuzz 的能力边界?
  • [ ( 能否写一个 Foundry invariant 测试的 actor 与 handler?
  • [ ( 能否解释形式化验证的能力与局限?
  • [ ( 能否说出 severity 定级标准?
  • [ ( 能否解释资产扫描的作用?
  • [ ( 能否说出人工判断的价值?
  • [ ( 能否列出 CI 门禁的检查项?

延伸阅读

  • OpenZeppelin 官方文档:Security Audits、Bug Bounty。
  • Slither 官方文档:detector 列表、自定义 detector。
  • Foundry 官方文档:Invariant Testing、Fuzz Testing。
  • Certora 官方文档:Spec 语言、Prover 使用。
  • Trail of Bits 审计报告模板:severity 定级标准。

待整理清单

  • [ ( 补充近年审计报告的典型 finding 案例
  • [ ( 补充形式化验证在生产合约的落地案例
  • [ ( 补充 bug bounty 平台的最佳实践