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

约束 delegatecall 目标地址

约束 delegatecall 目标地址

当代理合约允许外部调用者决定 delegatecall 的目标地址时,攻击者可能借助恶意实现代码覆盖管理员、用户账本等关键存储槽。本课通过一个可复现的 Solidity 测试,追踪目标地址的数据流,验证恶意写槽的后果,并实现可信目标白名单约束。

学习目标

  • 识别外部输入如何影响 delegatecall 目标地址,理解执行上下文与存储槽风险。
  • 使用 Solidity 测试复现恶意代码覆盖管理员和账本槽位的行为。
  • 实现目标地址校验,并掌握代理升级审计中的验证重点。

为什么可控目标地址危险

Solidity 的 delegatecall 会执行目标地址的代码,但沿用调用方的存储、地址和余额上下文。被执行代码中的 SSTORE 修改的是代理合约的存储,而不是目标实现合约的存储。

假设代理合约使用普通状态变量声明,且没有继承其他占用存储的变量:

存储槽 代理中的变量 攻击者希望修改的值
slot 0 admin 攻击者地址 0x...BEEF
slot 1 credit 999

只要攻击者能够选择任意代码地址并触发委托执行,就可能让目标代码直接写入这些槽位。这里的 credit 是代理内部记录的账本数值,不是链上原生 ETH 余额;修改账本并不会自动改变合约实际持有的 ETH。

不可信 delegatecall 对代理存储槽的覆盖示意

审计时要检查两条数据流:第一条是目标地址从函数参数、配置或升级接口进入 delegatecall;第二条是目标代码执行后能够修改哪些代理存储槽。即使函数名称是 execute、forward 或 run,也不能仅凭名称判断安全性。

复现恶意实现覆盖存储槽

使用 Solidity 0.8.24 和 Foundry 创建测试项目,在项目根目录的 test/DelegateTarget.t.sol 中放置以下完整代码。示例故意保留不安全入口,用于本地漏洞复现,不应部署到生产网络。

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

contract UnsafeProxy {
    address public admin; // slot 0
    uint256 public credit; // slot 1

    constructor() {
        admin = msg.sender;
        credit = 100;
    }

    function execute(address target, bytes calldata data)
        external returns (bytes memory)
    {
        // 漏洞:调用者能够指定任意执行目标
        (bool ok, bytes memory result) = target.delegatecall(data);
        require(ok, "delegatecall failed");
        return result;
    }
}

contract Evil {
    function corrupt(address newAdmin, uint256 newCredit) external {
        // 直接覆盖调用方的前两个存储槽
        assembly {
            sstore(0, newAdmin)
            sstore(1, newCredit)
        }
    }
}

contract DelegateTargetTest {
    function testStorageCorruption() public {
        UnsafeProxy proxy = new UnsafeProxy();
        Evil evil = new Evil();
        address attacker = address(0xBEEF);

        require(proxy.admin() == address(this), "wrong initial admin");
        require(proxy.credit() == 100, "wrong initial credit");

        bytes memory payload = abi.encodeCall(
            Evil.corrupt, (attacker, 999)
        );
        proxy.execute(address(evil), payload);

        // 恶意实现代码修改的是代理的存储
        require(proxy.admin() == attacker, "admin unchanged");
        require(proxy.credit() == 999, "credit unchanged");
    }
}

在安装了 Foundry 的项目根目录执行:

bash
forge test --match-test testStorageCorruption

预期输出(不同 Foundry 版本的计时和汇总格式可能不同):

text
[PASS] testStorageCorruption()

测试通过说明攻击已经成功,而不是说明代理安全。攻击前 admin 为测试合约地址、credit 为 100;攻击后分别变成 0x...BEEF 和 999。

Evil 合约无需声明与代理相同的 Solidity 状态变量,因为内联汇编可以直接按槽位编号写入。实际攻击代码还可能修改映射根槽对应的存储位置、实现地址或其他授权状态。

使用可信目标约束执行入口

最直接的修复方式是不允许普通调用者任意选择实现地址。以下是固定可信目标的最小示例:目标地址由部署者在构造函数中设置,使用 immutable 保存,并在委托执行前进行校验。

把以下代码追加到同一个测试文件中:

solidity
contract TrustedLogic {
    function readCredit() external view returns (uint256 value) {
        // 通过 delegatecall 读取代理的 slot 1
        assembly {
            value := sload(1)
        }
    }
}

contract SafeProxy {
    address public admin;
    uint256 public credit;
    address public immutable trustedTarget;

    constructor(address target) {
        require(target.code.length > 0, "not a contract");
        admin = msg.sender;
        credit = 100;
        trustedTarget = target;
    }

    function execute(address target, bytes calldata data)
        external returns (bytes memory)
    {
        // 拒绝所有未列入固定信任集合的目标
        require(target == trustedTarget, "untrusted target");
        (bool ok, bytes memory result) = target.delegatecall(data);
        require(ok, "delegatecall failed");
        return result;
    }
}

contract SafeProxyTest {
    function testTargetRestriction() public {
        TrustedLogic trusted = new TrustedLogic();
        SafeProxy proxy = new SafeProxy(address(trusted));
        Evil evil = new Evil();

        bytes memory malicious = abi.encodeCall(
            Evil.corrupt, (address(0xBEEF), 999)
        );

        // 低级调用捕获预期的拒绝结果
        (bool accepted, ) = address(proxy).call(
            abi.encodeCall(SafeProxy.execute, (address(evil), malicious))
        );
        require(!accepted, "malicious target accepted");

        bytes memory result = proxy.execute(
            address(trusted),
            abi.encodeCall(TrustedLogic.readCredit, ())
        );
        require(abi.decode(result, (uint256)) == 100, "wrong credit");
        require(proxy.admin() == address(this), "admin changed");
        require(proxy.credit() == 100, "credit changed");
    }
}

执行验证:

bash
forge test --match-test testTargetRestriction

预期输出:

text
[PASS] testTargetRestriction()

该测试验证两个边界:调用恶意地址被拒绝,调用可信逻辑能够读取原有账本且没有破坏存储。trustedTarget 是不可变地址,不占用普通存储槽,因此不会改变示例中 admin 和 credit 的槽位位置。

不过,固定目标只解决目标地址不受外部任意控制的问题,并不能证明目标代码没有漏洞。示例中的 TrustedLogic 明确依赖 slot 1 的布局,仅适合演示,真实工程应使用经过审查且与代理存储布局兼容的实现。

审计升级入口和地址来源

可升级代理不能简单地把实现地址永久固定,否则无法升级。对于 ERC-1967 或 UUPS 风格的代理,还要检查升级授权、实现地址校验以及升级后代码的行为。

代理升级授权与委托执行的信任边界

在真实项目中按以下顺序检查:

  1. 搜索全部 delegatecall,记录目标地址是来自外部参数、存储变量、硬编码地址还是其他合约的返回值。
  2. 如果来源是外部参数,沿调用链检查是否存在未经授权的入口,以及是否能绕过目标白名单。
  3. 如果来源是实现地址槽,检查所有能写入该槽的升级函数、初始化函数和内部调用路径。
  4. 检查升级授权是否只允许治理合约、多签或指定角色操作,并确认授权逻辑不能通过代理自身的错误权限配置绕过。
  5. 检查新实现是否有部署代码、是否满足预期接口、是否与已有存储布局兼容,以及升级是否引入新的不安全委托调用。

对于标准 ERC-1967 代理,实现地址使用约定的专用槽位,而不是本课演示的普通 slot 0。不要直接把本课的攻击槽位编号套用到 OpenZeppelin 代理;必须结合真实编译产物和代理类型确认布局。

验证修复是否覆盖关键风险

完成修复后,可以建立以下回归检查:

测试场景 预期结果
普通账户传入未批准目标 调用回退,存储不变
传入已批准目标并执行只读逻辑 正常返回 100
恶意实现尝试修改 admin 未授权目标被拒绝
恶意实现尝试修改 credit 未授权目标被拒绝
升级函数由无权限账户调用 权限校验拒绝升级
合法升级使用不兼容存储布局 升级前测试或审计发现并阻止发布

最后两项需要在实际可升级代理项目中增加独立测试,本课固定目标示例不包含升级功能。还应额外验证已批准的实现本身是否包含危险写槽操作,因为白名单不能阻止可信地址中的恶意或错误逻辑。

本地演示可用 forge test -vv 查看测试结果;需要进一步检查执行轨迹时使用 forge test -vvvv。其中第一组测试证明任意目标委托调用确实能够污染代理存储,第二组测试证明未批准地址被阻断。审计结论应分别记录目标地址的来源、授权边界、存储布局和可执行代码的可信性,而不能只依据某一次调用是否成功。

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

目录与阅读设置

阅读设置

17

记录一个想法

约束 delegatecall 目标地址

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

登录哪都通