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

变换交易顺序暴露状态依赖

变换交易顺序暴露状态依赖

同样的两笔存款和一笔提款,调整交易顺序后,资产可能流向不同账户。本课使用 Foundry 构造多账户交易序列,通过模糊测试比较不同顺序下的资产归属,定位依赖全局可变状态的错误,并建立可重复执行的安全回归测试。

学习目标

  • 区分正常的顺序敏感业务规则与不合理的交易顺序依赖。
  • 使用 Foundry 对同一组操作执行不同排列,并验证账户资产归属。
  • 根据失败用例定位错误状态变量,修复后重新运行模糊测试。

明确交易顺序测试的安全约束

区块链交易按区块内确定的顺序执行,状态变化本身存在先后关系。因此,并非所有顺序造成的结果差异都是漏洞。例如,余额只有 1 ETH 时,两笔各提款 1 ETH 的交易不可能都成功。

需要检查的是:在业务规则允许交换顺序的情况下,交易是否仍然满足资产归属和授权约束。

考虑一个简单的 ETH 存款合约,Alice 和 Bob 各存入 1 ETH,随后 Alice 提取自己的 1 ETH。我们测试两个顺序:

  • 顺序 A:Alice 存款、Bob 存款、Alice 提款。
  • 顺序 B:Bob 存款、Alice 存款、Alice 提款。

两组操作的业务含义相同:每个人存入相同金额,Alice 只提取自己的余额。合理的实现中,Alice 最终应收回 1 ETH,Bob 的存款仍保存在合约中。

检查项目 顺序 A 顺序 B
Alice 存款 1 ETH 1 ETH
Bob 存款 1 ETH 1 ETH
Alice 提款 1 ETH 1 ETH
Alice 实际收到 1 ETH 1 ETH
Bob 账户收到的提款 0 ETH 0 ETH
合约剩余资产 1 ETH 1 ETH

这里采用测试环境中的普通 ETH 转账模型,不计交易手续费;Foundry 测试合约通过作弊码模拟外部账户调用。

两种交易执行顺序下的账户余额与资金流向对比

构造存在顺序依赖的存款合约

准备已安装 Foundry 的 Solidity 项目。若尚未创建项目,可以在终端执行:

bash
forge init order-fuzz-demo
cd order-fuzz-demo

预期结果:创建包含 src、test、script 目录的项目,并提供 forge-std 测试依赖。实际初始化输出和依赖版本可能因 Foundry 安装版本不同而变化。

在 src/OrderVault.sol 中编写一个故意存在缺陷的最小合约。它为每个账户分别记录余额,却另外使用全局变量 lastDepositor 保存最近一次存款的账户。

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

contract OrderVault {
    mapping(address => uint256) public balances;
    address public lastDepositor;

    function deposit() external payable {
        require(msg.value > 0, "zero deposit");
        balances[msg.sender] += msg.value;
        lastDepositor = msg.sender;
    }

    function withdraw(uint256 amount) external {
        require(amount > 0, "zero amount");
        require(balances[msg.sender] >= amount, "insufficient");

        // 扣减的是提款人的余额,但收款人取自全局状态。
        balances[msg.sender] -= amount;
        (bool ok, ) = payable(lastDepositor).call{value: amount}("");
        require(ok, "transfer failed");
    }
}

这里的错误不在余额扣减,而在转账目的地址。lastDepositor 会被任何账户的后续存款覆盖,因此它不能代表当前提款人的资金所有权。

当 Alice 先存款、Bob 后存款时,Alice 的提款请求会减少 Alice 的账面余额,却把 ETH 转给 Bob。反过来,如果 Alice 是最后存款的人,错误可能暂时不暴露。

用 Foundry 比较不同交易排列

在 test/OrderVault.t.sol 中创建测试文件,使用 vm.prank 指定交易发起账户,用 vm.deal 初始化测试余额。每个排列部署独立合约,避免前一次测试污染后一次的状态。

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

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

contract OrderVaultTest is Test {
    address payable alice = payable(address(0xA11CE));
    address payable bob = payable(address(0xB0B));

    function runSequence(
        uint256 amount,
        bool aliceFirst
    ) internal returns (uint256 payout, uint256 vaultBalance) {
        OrderVault vault = new OrderVault();
        vm.deal(alice, 2 ether);
        vm.deal(bob, 2 ether);

        // 两组交易拥有相同存款金额,只交换存款顺序。
        if (aliceFirst) {
            vm.prank(alice);
            vault.deposit{value: amount}();
            vm.prank(bob);
            vault.deposit{value: amount}();
        } else {
            vm.prank(bob);
            vault.deposit{value: amount}();
            vm.prank(alice);
            vault.deposit{value: amount}();
        }

        uint256 beforeWithdraw = alice.balance;
        vm.prank(alice);
        vault.withdraw(amount);

        // 不只检查账面余额,还检查Alice实际收到多少ETH。
        payout = alice.balance - beforeWithdraw;
        vaultBalance = address(vault).balance;
    }

    function testFuzz_depositOrderPreservesOwnership(
        uint96 rawAmount
    ) public {
        uint256 amount = bound(uint256(rawAmount), 1, 1 ether);

        (uint256 payoutAB, uint256 vaultAB) =
            runSequence(amount, true);
        (uint256 payoutBA, uint256 vaultBA) =
            runSequence(amount, false);

        assertEq(payoutAB, amount, "AB: wrong recipient");
        assertEq(payoutBA, amount, "BA: wrong recipient");
        assertEq(vaultAB, amount, "AB: wrong vault balance");
        assertEq(vaultBA, amount, "BA: wrong vault balance");
    }
}

这段测试完成了三个关键动作:

  1. 将模糊测试输入限制在 1 wei 至 1 ETH,避免零值以及测试账户余额不足。
  2. 对相同金额分别执行 AB 和 BA 两种存款顺序,始终由 Alice 执行提款。
  3. 检查提款的实际收款金额以及合约剩余 ETH,防止只看内部账本而漏掉错误资金转移。

运行测试:

bash
forge test --match-test testFuzz_depositOrderPreservesOwnership -vvv

预期结果:使用上述缺陷合约时,模糊测试失败。失败位置为 AB: wrong recipient,因为 AB 顺序中的 Bob 是最后存款人,Alice 实际收到 0 ETH,而断言要求 Alice 收到完整提款金额。

Foundry 的失败详情通常包含触发失败的模糊输入和断言信息;具体输出格式取决于所安装的 Foundry 版本。即使测试框架缩减输入得到不同的最小反例,资产归属错误仍然成立。

从失败结果定位状态依赖

这次测试中的错误可通过三项状态逐步定位:

状态 Alice后存款 Bob后存款
balances[alice] 提款前 1 ETH 1 ETH
lastDepositor Alice Bob
Alice提款后实际收款人 Alice Bob

表中金额以每人存款 1 ETH 为例。两种顺序里,Alice 都通过了余额校验,账面余额也正确减少,但资金的实际接收者不同。

这说明安全断言不能只检查 balances[alice] == 0。账面状态与真实资产转移必须共同验证,否则资金已经流向其他账户时,内部余额仍可能看起来正常。

更一般地,在智能合约中值得关注的顺序相关状态包括:

  • 全局保存的最近操作者、最近收款人或最近报价。
  • 被多个用户共同修改的奖励累计值或份额价格。
  • 需要先授权、先初始化或先结算的前置状态。
  • 多个交易共享的额度、库存、清算阈值和提款限额。

检查时要根据业务定义建立不变量。对独立用户的存款,改变先后顺序不应改变所有权;对共享库存的购买交易,先成交者可能合理地获得最后一份库存,不能把这种正常竞争直接判成漏洞。

修复转账目标并验证回归

本例修复只需修改收款地址:提款人通过自己的余额校验后,资金必须返回该提款人,而不能由其他交易写入的全局状态决定。

将 src/OrderVault.sol 中的 withdraw 替换为:

solidity
function withdraw(uint256 amount) external {
    require(amount > 0, "zero amount");
    require(balances[msg.sender] >= amount, "insufficient");

    // 先扣余额,再向提款账户转账。
    balances[msg.sender] -= amount;
    (bool ok, ) = payable(msg.sender).call{value: amount}("");
    require(ok, "transfer failed");
}

这是合约内部的函数替换片段,依赖前面完整定义的 OrderVault 合约和 balances 状态变量。由于 Solidity 调用失败后的回滚具有原子性,require(ok) 失败时,之前的余额扣减也会回滚。

重新执行测试:

bash
forge test --match-test testFuzz_depositOrderPreservesOwnership -vvv

预期结果:在仅应用上述修复且其他代码保持不变时,模糊测试通过,终端中的测试状态显示为 PASS。两个排列均满足以下断言:

  • Alice 实际收到的提款金额等于 amount。
  • 两个独立合约实例在提款后均剩余 amount ETH。
  • Alice 与 Bob 的存款先后变化不再影响 Alice 的实际收款人。

还可以继续使用 forge test --fuzz-runs 1000 增加模糊测试轮次。该命令会运行当前项目中匹配到的测试,并将默认模糊测试执行次数设置为 1000;如果项目还存在其他失败测试,整体命令仍可能失败。

预期结果:修复后的资产归属用例在增加测试轮次后继续通过。如果需要复现某次失败,应保存 Foundry 输出的反例输入,并将它补充为具有明确金额和账户顺序的确定性回归测试。

扩展到更复杂的账户操作序列

实际业务往往不止两次存款和一次提款。可以把操作抽象成带参数的动作,再对合法排列进行测试。

例如初始 Alice 和 Bob 均有 2 ETH,构造以下四个操作:

动作 发起账户 金额
A Alice 存款 1 ETH
B Bob 存款 0.5 ETH
C Alice 提款 0.4 ETH
D Bob 提款 0.2 ETH

合法排列必须满足各用户在提款前拥有足够的可提款余额。对于每个合法排列,可以检查以下结果:

  • Alice 最终账面余额应为 0.6 ETH,Bob 为 0.3 ETH。
  • 合约实际 ETH 余额应为 0.9 ETH。
  • Alice 累计收到提款 0.4 ETH,Bob 累计收到提款 0.2 ETH。
  • 无论其他账户如何穿插合法操作,都不能改变对应提款的接收者。

在 Foundry 中,后续可以将存款、提款封装为 Handler 动作,使用状态模糊测试生成更长的合法调用序列,并通过 invariant 测试检查资产守恒。不过,动作生成器必须正确处理余额不足等预期回滚,否则容易把非法输入造成的失败误判为安全缺陷。

针对本例,最有效的测试策略是先用 AB、BA 两种最小排列定位错误,再增加多账户交错操作验证修复覆盖范围。这样既能获得可解释的最小反例,也能发现较长交易历史中被其他状态更新掩盖的资金归属问题。

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

目录与阅读设置

阅读设置

17

记录一个想法

变换交易顺序暴露状态依赖

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

登录哪都通