题目预览

• Token sale
• • 分析
  • 攻击
• Token whale
• • 分析
  • 攻击
• Retirement fund
• • 分析
  • 攻击
• Mapping
• • 分析
  • 攻击
• Donation
• • 分析
  • 攻击
• Fifty years
• • 分析
  • 攻击

Token sale

分析

题目代码：

pragma solidity ^0.4.21;

contract TokenSaleChallenge {
    mapping(address => uint256) public balanceOf;
    uint256 constant PRICE_PER_TOKEN = 1 ether;

    function TokenSaleChallenge(address _player) public payable {
        require(msg.value == 1 ether);
    }

    function isComplete() public view returns (bool) {
        return address(this).balance < 1 ether;
    }

    function buy(uint256 numTokens) public payable {
        require(msg.value == numTokens * PRICE_PER_TOKEN);

        balanceOf[msg.sender] += numTokens;
    }

    function sell(uint256 numTokens) public {
        require(balanceOf[msg.sender] >= numTokens);

        balanceOf[msg.sender] -= numTokens;
        msg.sender.transfer(numTokens * PRICE_PER_TOKEN);
    }
}

目标依然是调用isComplete函数，此题中就是需要题目合约的余额小于1ether。
由于属于math系列，所以我看的时候对运算很敏锐，很容易就能发现require(msg.value == numTokens * PRICE_PER_TOKEN);会存在一个很明显的溢出，只要我们numTokens传的足够大，在乘以10**18次方后，我们的msg.value就能够超过这个溢出之后的值，我们的余额就会变得非常巨大。

攻击

攻击合约：

contract attack{
    uint256 max = 2**256-1;
    uint256 public num1;
    uint256 public num2;
    function att()public{
        num1 = max/10**18;
        num2 = (num1+1)*10**18;
    }
}

攻击合约没啥目的，只是为了算出多大的数可以溢出，以及我们需要付出多少的value。

我们在buy中传入num1+1，并给出比num2相等或更多的wei，就能够让我们的余额发生溢出。

如图所示，余额很大，所以我们提出1ether毫无问题，合约剩下的eth不足1eth，isComplete成功调用，完成攻击。

Token whale

分析

TokenWhale合约：

pragma solidity ^0.4.21;

contract TokenWhaleChallenge {
    address player;

    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    string public name = "Simple ERC20 Token";
    string public symbol = "SET";
    uint8 public decimals = 18;

    function TokenWhaleChallenge(address _player) public {
        player = _player;
        totalSupply = 1000;
        balanceOf[player] = 1000;
    }

    function isComplete() public view returns (bool) {
        return balanceOf[player] >= 1000000;
    }

    event Transfer(address indexed from, address indexed to, uint256 value);

    function _transfer(address to, uint256 value) internal {
        balanceOf[msg.sender] -= value;
        balanceOf[to] += value;

        emit Transfer(msg.sender, to, value);
    }

    function transfer(address to, uint256 value) public {
        require(balanceOf[msg.sender] >= value);
        require(balanceOf[to] + value >= balanceOf[to]);

        _transfer(to, value);
    }

    event Approval(address indexed owner, address indexed spender, uint256 value);

    function approve(address spender, uint256 value) public {
        allowance[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
    }

    function transferFrom(address from, address to, uint256 value) public {
        require(balanceOf[from] >= value);
        require(balanceOf[to] + value >= balanceOf[to]);
        require(allowance[from][msg.sender] >= value);

        allowance[from][msg.sender] -= value;
        _transfer(to, value);
    }
}

完成此关，需要我们的token余额大于1000000.

通读合约，合约中有两种转账方式，一种transfer，一种transferFrom，transfer中我并没有看出很明显的漏洞。
但我注意到tansferFrom调用的内部转账函数也是_transfer，而在transferFrom中require(balanceOf[from] >= value);限制的是from的余额大于value，但_transfer中减少的是调用者的余额，所以只要from和调用者不是同一个地址，且to和调用者也不是一个地址，那么调用者的余额就会发生下溢。

攻击

首先部署时输入我们第一个账户的地址。

对第二个账户进行approve

使用第二个账户进行transferFrom

调用完成后第二个账户的balance就发生了下溢，我们再把余额转给第一个账户即可。

完成攻击。

Retirement fund

分析

RetirementFund合约：

pragma solidity ^0.4.21;

contract RetirementFundChallenge {
    uint256 startBalance;
    address owner = msg.sender;
    address beneficiary;
    uint256 expiration = now + 10 years;

    function RetirementFundChallenge(address player) public payable {
        require(msg.value == 1 ether);

        beneficiary = player;
        startBalance = msg.value;
    }

    function isComplete() public view returns (bool) {
        return address(this).balance == 0;
    }

    function withdraw() public {
        require(msg.sender == owner);

        if (now < expiration) {
            // early withdrawal incurs a 10% penalty
            msg.sender.transfer(address(this).balance * 9 / 10);
        } else {
            msg.sender.transfer(address(this).balance);
        }
    }

    function collectPenalty() public {
        require(msg.sender == beneficiary);

        uint256 withdrawn = startBalance - address(this).balance;

        // an early withdrawal occurred
        require(withdrawn > 0);

        // penalty is what's left
        msg.sender.transfer(address(this).balance);
    }
}

此关要求我们让合约的余额为零。

这个合约有两种方式可以取走合约所有的钱，一个是withdraw函数，owner在十年后可以取走，但合约中好像没有方法使我们成为owner。

第二种方式是collectPenalty函数，我们可以直接调用uint256 withdrawn = startBalance - address(this).balance require(withdrawn > 0);;但需要我们饶过这个限制，初步看起来好像没有办法，因为合约不存在payable函数，也就无法向其中存入余额。
但自毁合约是可以无条件向任意地址转账的，只要我们通过自毁合约向目标合约转账，就可以让withdraw发生下溢，绕过限制。

攻击

攻击合约：

contract attack{
    function destruct(address _addr)public payable{
        selfdestruct(_addr);
    }
}

合约就一个目的，通过自毁向目标合约转钱。

首先部署目标合约并传入我们的账户地址。

然后部署攻击合约，调用att函数并将目标合约的地址放入。

调用collectPenalty函数即可提出eth并完成攻击。

Mapping

分析

题目合约：

pragma solidity ^0.4.21;

contract MappingChallenge {
    bool public isComplete;
    uint256[] map;

    function set(uint256 key, uint256 value) public {
        // Expand dynamic array as needed
        if (map.length <= key) {
            map.length = key + 1;
        }

        map[key] = value;
    }

    function get(uint256 key) public view returns (uint256) {
        return map[key];
    }
}

这个题要求我们将isComplete变为true。

原理很简单，除了isComplete就只剩下一个map数组了，而这个数组的长度和值我们也可以任意设定，所以只要让数组的长度变得很大，发生溢出即可。

攻击

攻击合约：

contract figure{
    function fig()public pure returns(uint256){
        return (uint256(-1)-uint256(keccak256(bytes32(1))))+1;
    }
    
}

攻击合约只是用来计算从map的起始位置到他发生溢出需要多少位即可，得到的结果是35707666377435648211887908874984608119992236509074197713628505308453184860938。

原理很简单，因为在solidity中，在storage中会初始化数组的长度，而数组的起始位置是通过keccak256(bytes32("数组长度所在插槽"))计算的，所以用2**256-1再减去这个数加一就可以让数组的最后一位是整个storage的第一位，覆盖isCompleted变量。

调用set函数将value设定为1，isComplete即可变为true。

Donation

分析

题目合约：

pragma solidity ^0.4.21;

contract DonationChallenge {
    struct Donation {
        uint256 timestamp;
        uint256 etherAmount;
    }
    Donation[] public donations;

    address public owner;

    function DonationChallenge() public payable {
        require(msg.value == 1 ether);
        
        owner = msg.sender;
    }
    
    function isComplete() public view returns (bool) {
        return address(this).balance == 0;
    }

    function donate(uint256 etherAmount) public payable {
        // amount is in ether, but msg.value is in wei
        uint256 scale = 10**18 * 1 ether;
        require(msg.value == etherAmount / scale);

        Donation donation;
        donation.timestamp = now;
        donation.etherAmount = etherAmount;

        donations.push(donation);
    }

    function withdraw() public {
        require(msg.sender == owner);
        
        msg.sender.transfer(address(this).balance);
    }
}

题目要求我们取走合约中剩下的所有钱。

很明显能发现我们需要成为owner才能够将钱提取出来，但合约中似乎没有能够直接改变owner的值，但我们注意到他定义了一个结构体和一个结构体切片。

并且在donation函数中直接初始化了结构体再将其存入数组，这样的操作导致的直接后果就是slot0的数组长度和slot1的owner会分别被timestamp和etherAmount所覆盖，所以我们可以通过数组etherAmount的方式，直接覆盖结构体。

攻击

攻击合约：

contract figure{
    function fig(uint256 amount)public pure returns(uint256){
        return amount/10**36;
    }
}

攻击合约的目的只是为了计算出我们需要给donation传入的eth，从而绕过require(msg.value == etherAmount / scale);限制。

传入我们的地址，输入对应的wei值，再调用donate函数，owner就变成了我们的地址

withdraw后，攻击完成。

Fifty years

分析

题目合约：

pragma solidity ^0.4.21;

contract FiftyYearsChallenge {
    struct Contribution {
        uint256 amount;
        uint256 unlockTimestamp;
    }
    Contribution[] queue;
    uint256 head;

    address owner;
    function FiftyYearsChallenge(address player) public payable {
        require(msg.value == 1 ether);

        owner = player;
        queue.push(Contribution(msg.value, now + 50 years));
    }

    function isComplete() public view returns (bool) {
        return address(this).balance == 0;
    }

    function upsert(uint256 index, uint256 timestamp) public payable {
        require(msg.sender == owner);

        if (index >= head && index < queue.length) {
            // Update existing contribution amount without updating timestamp.
            Contribution storage contribution = queue[index];
            contribution.amount += msg.value;
        } else {
            // Append a new contribution. Require that each contribution unlock
            // at least 1 day after the previous one.
            require(timestamp >= queue[queue.length - 1].unlockTimestamp + 1 days);

            contribution.amount = msg.value;
            contribution.unlockTimestamp = timestamp;
            queue.push(contribution);
        }
    }

    function withdraw(uint256 index) public {
        require(msg.sender == owner);
        require(now >= queue[index].unlockTimestamp);

        // Withdraw this and any earlier contributions.
        uint256 total = 0;
        for (uint256 i = head; i <= index; i++) {
            total += queue[i].amount;

            // Reclaim storage.
            delete queue[i];
        }

        // Move the head of the queue forward so we don't have to loop over
        // already-withdrawn contributions.
        head = index + 1;

        msg.sender.transfer(total);
    }
}

合约要求我们取走合约中所有的余额。

我们很容易注意到合约中存在结构体和关于它的数组，也就能够联想到变量覆盖。
整个合约简单来说，就是玩家向合约中存钱，在经过一段时间后才能够将钱提出来，构造函数中将我们传入的一ether存入了数组，并且五十年后才能取出，且在之后的每次存钱，都会在五十年的基础上增加一天。

if (index >= head && index < queue.length) {
            // Update existing contribution amount without updating timestamp.
            Contribution storage contribution = queue[index];
            contribution.amount += msg.value;
        } else {
            // Append a new contribution. Require that each contribution unlock
            // at least 1 day after the previous one.
            require(timestamp >= queue[queue.length - 1].unlockTimestamp + 1 days);

            contribution.amount = msg.value;
            contribution.unlockTimestamp = timestamp;
            queue.push(contribution);
        }

if代码块本身的逻辑是没有问题的，并不会出现变量覆盖的情况，但else就不一样了，由于没有进if，相当于直接创建了一个结构体变量，这势必会造成变量覆盖，而能够覆盖的就是数组的长度以及head。而在取钱的时候，head必须为零我们才能取出数组中第一个元素的余额，也就是最开始的1 ether。
并且，require(timestamp >= queue[queue.length - 1].unlockTimestamp + 1 days);在这个require中很明显存在一个溢出的问题，只要数组最后一个元素的unlockTimestamp够大，这里就会出现溢出。

攻击逻辑已经出来了，我们来分析一下具体步骤：
首先我们要让我们第一次传入的unlockTimestamp足够大，才能够在第二次传入的时候发生溢出，才能够让head为0。
我们计算出需要传入的unlockTimestamp为115792089237316195423570985008687907853269984665640564039457584007913129553536。
由于数组的长度取决于我们传入的wei数，而在push中会对数组的length++，length又跟amount公用一个slot，所以我们传入1wei则长度和amount都2，我们两次都传入1wei，则第一次push的结构体会被第二次push的结构体覆盖，具体原因我就不一一阐释了。
而第二次的timeStamp为0,我们可以很轻松通过withdraw的require，分析到这里，已经可以开始攻击了。

攻击

第一步：调用upsert方法，传入index（只要大于1就好）,timestamp为上述溢出值

第二步，调用upsert方法，传入index（大于2就好）,timestamp为0

第三步：调用withdraw方法传入1即可，到这里攻击完成