智能合约的重入攻击_重入攻击 智能合约

智能合约的重入攻击是一种常见的安全漏洞，特别是在基于以太坊的区块链上，它利用了智能合约设计或实现中的缺陷。重入攻击的核心在于攻击者能够在一个交易的中间阶段，即智能合约尚未完成其预期的内部状态更新时，递归地调用合约的同一或另一个函数。

基本原理：

1. 初始调用：攻击者首先调用易受攻击的智能合约中的一个函数，比如一个提款函数，通常会伴随一些以太币或代币的转移。

2. 状态变更前的外部调用：在智能合约内部，可能有一个点会在更新其状态变量（比如余额）之前进行外部调用，比如使用 .call() 或 .delegatecall() 方法向攻击者的合约转账或执行代码。

3. 递归调用：攻击者精心设计了自己的合约，当接收到调用或资金时，会立即回调易受攻击合约的同一个或另一个存在漏洞的函数。此时，原合约的状态尚未更新，所以攻击者可以再次获得调用权限，并重复执行相同的行动，即再次请求资金转移。

4. 状态更新失败：由于递归调用，原始合约的状态更新（比如减少攻击者的余额）可能永远无法执行，因为每次攻击者都可以在状态更新前再次调用合约。

5. 无限循环或直到资金耗尽：这个递归过程可能会一直持续，直到合约的所有资金都被耗尽，或者直到达到某个外部限制，比如 gas 限额。

重入攻击的关键在于攻击者能够利用合约的执行顺序和状态更新的时机。为了防止这类攻击，开发者需要确保在进行任何外部调用之前，所有的内部状态更新都已经完成。此外，使用 .transfer() 和 .send() 方法代替 .call() 也可以降低风险，因为它们在默认情况下有较低的 gas 限额，这可能不足以执行复杂的恶意代码。

演示案例

最知名的可能是针对The DAO的攻击，尽管它不是严格意义上的重入攻击，但它展示了攻击者如何利用合约漏洞来非法获取资金。但是，下面我将给出一个简化的智能合约重入攻击的示例，这通常在教育和研究场景中用来解释重入攻击的概念。

假设我们有一个简单的智能合约，它允许用户存款和提款：

pragma solidity ^0.8.0;

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

    function deposit() public payable {
        balances[msg.sender] += msg.value;
    }

    function withdraw(uint256 _amount) public {
        if (_amount <= balances[msg.sender]) {
            // 这里存在漏洞，因为它先检查余额，然后调用外部合约
            (bool success, ) = msg.sender.call{value: _amount}("");
            require(success, "Transfer failed.");
            balances[msg.sender] -= _amount;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在这个合约中，withdraw 函数存在一个漏洞，它先检查用户的余额是否足够，然后尝试将资金转移到用户账户，最后才更新合约中的余额。如果攻击者有一个恶意合约，它可以在接收到资金时立即回调 SimpleBank 合约的 withdraw 函数，因为余额还没有更新，所以攻击者可以无限次地从合约中提取资金，直到 gas 耗尽。

接下来是攻击者合约的一个简单示例：

pragma solidity ^0.8.0;

contract Attacker {
    address private target;

    constructor(address _target) {
        target = _target;
    }

    function attack() public payable {
        (bool success, ) = target.call{value: msg.value}("");
        require(success, "Attack failed.");
    }

    fallback() external payable {
        // 当接收到资金时，立即回调受害合约
        (bool success, ) = target.call{value: 1 ether}("");
        require(success, "Recursive call failed.");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在这个攻击者合约中，fallback 函数会在接收到以太币时自动触发。当攻击者调用 attack 函数并将资金发送给受害合约时，一旦资金到达，fallback 函数就会被触发，从而递归地调用受害合约的 withdraw 函数，试图再次取出资金。

请注意，这个示例是为了展示重入攻击的概念，并不建议在生产环境中使用。在现实世界中，智能合约的开发者会采取多种安全措施来防止此类攻击，例如在外部调用前更新状态，使用原子操作，或使用更安全的以太坊提供的转移函数 .transfer() 和 .send()。

攻击流程

我们一步步解析攻击合约的代码，以便更好地理解它是如何实现重入攻击的。

首先，这是攻击合约的构造函数：

constructor(address _target) {
    target = _target;
}
1
2
3

这里的 _target 参数是指向受害者的智能合约地址，也就是我们上面提到的 SimpleBank 合约。在部署攻击合约时，你需要提供这个地址，这样攻击合约就知道要攻击哪个合约了。

接下来是 attack 函数：

function attack() public payable {
    (bool success, ) = target.call{value: msg.value}("");
    require(success, "Attack failed.");
}
1
2
3
4

这个函数接收以太币作为参数（通过 payable 关键字）。当你调用这个函数并发送以太币时，它会把这笔钱转给 _target，也就是 SimpleBank 合约。这里使用了低级的 .call() 方法，它可以执行任意数据的调用，包括转移以太币。

现在，关键的部分来了，fallback 函数：

fallback() external payable {
    // 当接收到资金时，立即回调受害合约
    (bool success, ) = target.call{value: 1 ether}("");
    require(success, "Recursive call failed.");
}
1
2
3
4
5

在 Solidity 中，fallback 函数是在合约接收到没有指定函数调用的数据或以太币时自动执行的函数。在我们的案例中，当 SimpleBank 合约尝试将资金退还给攻击者时，它实际上是在调用攻击合约的 fallback 函数。

在 fallback 函数内部，攻击者合约立即再次调用 SimpleBank 合约的 withdraw 函数，试图再次提取资金。由于 SimpleBank 合约在退款后才更新余额，这意味着攻击者合约可以不断地重复这一过程，直到所有的以太币都被抽走或者交易的 gas 被耗尽。

总结一下，攻击流程如下：

1. 攻击者调用 attack 函数并发送以太币到 SimpleBank 合约。
2. SimpleBank 合约的 withdraw 函数被调用，尝试退款给攻击者。
3. 在退款过程中，fallback 函数在攻击者合约中被触发，因为它接收到了以太币。
4. fallback 函数立即回调 SimpleBank 合约的 withdraw 函数，试图再次提款。
5. 这个过程可以反复进行，直到所有资金被耗尽或交易结束。

这就是重入攻击的基本原理。在实际应用中，攻击者合约可能需要一些额外的逻辑来避免无限循环，并确保攻击成功。此外，现代的智能合约开发实践会使用更安全的方法来避免这类攻击，比如先扣除余额再转账，或者使用 .transfer() 或 .send() 方法，它们会立即抛出异常而不会继续执行剩余的代码。

fallback 函数

fallback 函数在Solidity智能合约中是一种特殊类型的函数，它会在以下几种情况下自动执行：

1. 当合约接收到Ether（以太币）：如果有人向你的合约发送以太币，且没有指定任何函数调用，那么fallback函数就会自动执行。

2. 当接收到一个未知的函数调用：如果发送到合约的消息包含了函数调用数据，但该函数签名并不匹配合约中的任何函数，那么fallback函数会被调用。

3. 当使用.call()方法：当你的合约使用低级别的.call()、.delegatecall()或.staticcall()方法调用另一个合约时，如果目标合约没有返回任何数据，那么目标合约的fallback函数将会被执行。

需要注意的是，在Solidity 0.6.0版本之后，fallback函数被分为两个部分：fallback和receive。receive函数只处理纯Ether的接收，没有附加数据的情况，而fallback函数则处理带有数据的Ether接收或未知函数调用。这意味着在新版本的Solidity中，如果你只想处理纯Ether的接收，你可以使用receive函数，而不需要写任何代码体，它会自动接收Ether而不做其他操作。

例如，一个简单的receive函数可以这样定义：

receive() external payable {}
1

这表示你的合约可以接收Ether，而不会触发任何额外的操作。而一个fallback函数可能会包含更多的逻辑，例如处理接收到的数据或执行某些业务逻辑。

在你提到的攻击合约示例中，fallback函数正是利用了这个特性，自动执行并发起递归调用来耗尽目标合约的资金。