智能合约与以太坊 / 系统课时

为资产金库完成安全回归验证

为资产金库完成安全回归验证

本篇以简化的 ERC-4626 资产金库为对象,使用 Foundry 验证存取款、份额换算和资产守恒。通过一个可控的向下取整缺陷,完成失败反例复现、修复验证和 GitHub Actions 持续集成,让安全测试能够阻止缺陷再次进入主分支。

学习目标

  • 编写覆盖存款、提款、份额计算和资产守恒的 Foundry 测试。
  • 构造整数舍入缺陷,理解模糊测试反例与可复现回归用例的关系。
  • 在 CI 中执行安全回归,并判断修复是否真正通过验收。

确定金库的安全边界

ERC-4626 使用底层资产和金库份额描述存款人的权益。完整标准还包含 mint、redeem、预览函数、额度限制与事件等接口。这里实现教学用最小金库,只覆盖 deposit、withdraw 和份额账本,不应直接用于生产部署。

假设金库存入 ERC-20 资产,存款获得 shares,提款销毁 shares。没有手续费时,重点验证以下性质:

检查对象 应满足的条件
首次存款 100 个资产获得 100 份额
后续存款 根据存款前资产与份额比例计算新份额
提款 销毁至少足以支付提款资产的份额
资产守恒 金库余额加外部账户余额不因转账而变化
失败操作 余额不足时必须回滚,不得部分转移资产

有外部捐赠资产时,金库资产总量可以超过存款操作的累计金额,因此不能简单断言 totalAssets == totalSupply。同时,整数份额计算必须显式考虑舍入方向。

资产金库的资产与份额流转关系

实现金库和可控缺陷

使用 Foundry 项目,并确保已安装 forge-std。示例不依赖 OpenZeppelin,代币仅实现本测试需要的转账和余额功能,以减少依赖干扰。

创建 test/VaultRegression.t.sol,其中包含简化代币、金库和测试合约。核心缺陷通过构造参数 broken 控制:错误实现使用向下取整计算提款需要销毁的份额,而正确实现使用向上取整。

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

import {Test} from "forge-std/Test.sol";

contract MockAsset {
    mapping(address => uint256) public balanceOf;

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        require(balanceOf[msg.sender] >= amount, "asset balance");
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount)
        external returns (bool)
    {
        require(msg.sender == from, "unauthorized");
        require(balanceOf[from] >= amount, "asset balance");
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract SimpleVault {
    MockAsset public immutable asset;
    bool public immutable broken;
    mapping(address => uint256) public balanceOf;
    uint256 public totalSupply;

    constructor(MockAsset token, bool useBrokenRounding) {
        asset = token;
        broken = useBrokenRounding;
    }

    function totalAssets() public view returns (uint256) {
        return asset.balanceOf(address(this));
    }

    function deposit(uint256 assets) external returns (uint256 shares) {
        require(assets > 0, "zero assets");
        uint256 supply = totalSupply;
        uint256 held = totalAssets();
        shares = supply == 0 ? assets : assets * supply / held;
        require(shares > 0, "zero shares");
        require(asset.transferFrom(msg.sender, address(this), assets));
        balanceOf[msg.sender] += shares;
        totalSupply += shares;
    }

    function previewWithdraw(uint256 assets) public view returns (uint256) {
        uint256 held = totalAssets();
        require(held > 0, "empty vault");
        uint256 numerator = assets * totalSupply;
        // 正确实现需要向上取整,避免少销毁份额。
        return numerator / held + (numerator % held == 0 ? 0 : 1);
    }

    function withdraw(uint256 assets) external returns (uint256 shares) {
        require(assets > 0 && assets <= totalAssets(), "invalid assets");
        // 可控缺陷:故意向下取整。
        shares = broken
            ? assets * totalSupply / totalAssets()
            : previewWithdraw(assets);
        require(balanceOf[msg.sender] >= shares, "insufficient shares");
        balanceOf[msg.sender] -= shares;
        totalSupply -= shares;
        require(asset.transfer(msg.sender, assets));
    }
}

contract VaultRegressionTest is Test {
    MockAsset token;
    SimpleVault vault;
    address alice = address(0xA11CE);
    address bob = address(0xB0B);

    function setUp() public {
        token = new MockAsset();
        vault = new SimpleVault(token, false);
        token.mint(alice, 1000000);
        token.mint(bob, 1000000);
    }

    function testFuzz_DepositWithdraw(uint256 amount) public {
        amount = bound(amount, 1, 1000000);
        uint256 initial = token.balanceOf(alice);
        vm.startPrank(alice);
        uint256 shares = vault.deposit(amount);
        uint256 burned = vault.withdraw(amount);
        vm.stopPrank();
        assertEq(shares, amount);
        assertEq(burned, shares);
        assertEq(token.balanceOf(alice), initial);
        assertEq(vault.totalAssets(), 0);
        assertEq(vault.totalSupply(), 0);
    }

    function testFuzz_AssetConservation(uint256 a, uint256 b) public {
        a = bound(a, 1, 1000000);
        b = bound(b, 1, 1000000);
        uint256 initial = token.balanceOf(alice) + token.balanceOf(bob);
        vm.prank(alice);
        vault.deposit(a);
        vm.prank(bob);
        vault.deposit(b);
        assertEq(
            token.balanceOf(alice) + token.balanceOf(bob) + vault.totalAssets(),
            initial
        );
    }

    function test_BrokenRoundingCounterexample() public {
        SimpleVault bad = new SimpleVault(token, true);
        vm.prank(alice);
        bad.deposit(2);
        vm.prank(alice);
        token.transfer(address(bad), 1); // 捐赠提高每份额的资产价值
        vm.prank(bob);
        assertEq(bad.deposit(2), 1);
        assertEq(bad.previewWithdraw(2), 2);
        vm.prank(bob);
        assertEq(bad.withdraw(2), 1); // 错误实现只销毁 1 份额
    }

    function test_FixedRoundingRejectsUnderburn() public {
        vm.prank(alice);
        vault.deposit(2);
        vm.prank(alice);
        token.transfer(address(vault), 1);
        vm.prank(bob);
        assertEq(vault.deposit(2), 1);
        assertEq(vault.previewWithdraw(2), 2);
        vm.expectRevert(bytes("insufficient shares"));
        vm.prank(bob);
        vault.withdraw(2);
        assertEq(vault.totalAssets(), 5);
        assertEq(vault.totalSupply(), 3);
    }
}

这个示例的 MockAsset.transferFrom 仅允许本人调用,属于教学简化,不符合完整 ERC-20 授权语义;正式实现需要使用标准 ERC-20 和安全转账工具。份额也省略了虚拟资产、虚拟份额及初始存款攻击防护,不应据此声称满足完整 ERC-4626 安全要求。

重现舍入缺陷并验证修复

反例使用很小的整数,避免 18 位精度掩盖舍入问题。操作顺序与计算如下:

操作 金库资产 总份额 Bob 份额
Alice 存入 2 2 2 0
Alice 直接捐赠 1 3 2 0
Bob 存入 2,获得 1 份额 5 3 1
Bob 请求提取 2 5 3 1

提款需销毁的正确份额是向上取整的 2 × 3 / 5,即 2 份。错误实现向下取整得到 1 份,让 Bob 以不足的份额拿走 2 个资产。

这里使用明确反例证明缺陷,用 fuzz 测试覆盖正常操作的更多输入,并不是依赖随机测试碰巧生成这个特殊状态。执行:

bash
forge test --match-contract VaultRegressionTest -vv

预期输出(测试数量及耗时会随 Foundry 版本变化):

text
[PASS] testFuzz_DepositWithdraw(uint256)
[PASS] testFuzz_AssetConservation(uint256,uint256)
[PASS] test_BrokenRoundingCounterexample()
[PASS] test_FixedRoundingRejectsUnderburn()

注意,缺陷复现测试通过意味着它成功证明了坏实现存在问题,并不意味着坏实现安全。修复验收必须查看 test_FixedRoundingRejectsUnderburn,确认同一输入在正确实现中回滚,并且回滚后金库资产和总份额未变化。

为了让安全性质成为真正的回归门禁,还应加入针对实际 withdraw 的断言:成功提款时,销毁份额不能小于提款前 previewWithdraw(assets)。该断言应放在调用前记录预览值,调用后比较返回值的测试中;不要只验证资产总量守恒,因为错误实现虽然损害其他存款人的份额权益,但代币转账仍可能满足资产守恒。

将安全回归加入 CI

在仓库创建 .github/workflows/vault-security.yml。使用 GitHub Actions 安装 Foundry,并运行完整测试。生产仓库建议将 Action 固定到经过审核的提交 SHA,并为关键项目锁定 Foundry 工具链版本。

yaml
name: Vault Security Regression
on:
  push:
  pull_request:
permissions:
  contents: read
jobs:
  forge-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: foundry-rs/foundry-toolchain@v1
        with:
          version: stable
      - name: Run vault regression
        run: forge test --match-contract VaultRegressionTest -vv
      - name: Run full test suite
        run: forge test

配置生效后,向仓库推送分支并创建 Pull Request。在 GitHub 的 Actions 页面查看 Vault Security Regression 工作流,确认两项测试步骤均成功。如果构建失败,应检查 Solidity 编译器版本、forge-std 依赖、导入路径和相关工具链安装日志。

CI 验收条件是:正常存取款与资产守恒测试通过;已知缺陷可稳定复现;相同提款反例在修复版中被拒绝;完整测试套件通过。对于本例,test_BrokenRoundingCounterexample 是安全漏洞证明,test_FixedRoundingRejectsUnderburn 才是修复后的安全回归条件。

这套最小案例验证了特定提款舍入缺陷和有限的资产守恒性质。实际 ERC-4626 项目仍需补充多账户状态序列、mint 与 redeem、授权、费用、极端精度、捐赠攻击及不变量测试,才能扩大安全覆盖范围。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

为资产金库完成安全回归验证

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通