Ethernaut 37 Impersonator Two

문제#

지문#

The goal of this level is for you to steal all the funds from the contract. Things that might help:

Look carefully at the 2 signatures that the owner of the contract used to lock it and set the admin.

코드#

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

4
import {Ownable} from "openzeppelin-contracts-08/access/Ownable.sol";
5
import {ECDSA} from "openzeppelin-contracts-08/utils/cryptography/ECDSA.sol";
6
import {Strings} from "openzeppelin-contracts-08/utils/Strings.sol";
7

8
contract ImpersonatorTwo is Ownable {
9
    using Strings for uint256;
10

11
    error NotAdmin();
12
    error InvalidSignature();
13
    error FundsLocked();
14

15
    address public admin;
16
    uint256 public nonce;
17
    bool locked;
18

19
    constructor() payable {}
20

21
    modifier onlyAdmin() {
22
        require(msg.sender == admin, NotAdmin());
23
        _;
24
    }
25

26
    function setAdmin(bytes memory signature, address newAdmin) public {
27
        string memory message = string(abi.encodePacked("admin", nonce.toString(), newAdmin));
28
        require(_verify(hash_message(message), signature), InvalidSignature());
29
        nonce++;
30
        admin = newAdmin;
31
    }
32

33
    function switchLock(bytes memory signature) public {
34
        string memory message = string(abi.encodePacked("lock", nonce.toString()));
35
        require(_verify(hash_message(message), signature), InvalidSignature());
36
        nonce++;
37
        locked = !locked;
38
    }
39

40
    function withdraw() public onlyAdmin {
41
        require(!locked, FundsLocked());
42
        payable(admin).transfer(address(this).balance);
43
    }
44

45
    function hash_message(string memory message) public pure returns (bytes32) {
46
        return ECDSA.toEthSignedMessageHash(abi.encodePacked(message));
47
    }
48

49
    function _verify(bytes32 hash, bytes memory signature) internal view returns (bool) {
50
        return ECDSA.recover(hash, signature) == owner();
51
    }
52
}

배경지식#

ECDSA 서명은 메시지 해시를 $z$ , 개인키를 $d$ , secp256k1의 group order를 $n$ 이라고 할 때 대략 다음 형태로 만들어진다.

s \equiv k^{-1}(z + rd) \pmod n

여기서 $k$ 는 서명마다 새로 써야 하는 nonce다. 서명 결과에 들어가는 $r$ 은 $kG$ 의 x좌표에서 나온다.

서로 다른 메시지에 대한 두 서명의 $r$ 이 같다면 같은 $k$ 를 재사용했다는 강한 신호다.

같은 개인키 $d$ 와 같은 $k$ 로 두 메시지 $z_1$ , $z_2$ 를 서명했다고 하자.

s_1 \equiv k^{-1}(z_1 + rd) \pmod n

s_2 \equiv k^{-1}(z_2 + rd) \pmod n

두 식을 빼면 개인키 항이 사라진다.

s_1 - s_2 \equiv k^{-1}(z_1-z_2) \pmod n

여기서 $k$ 를 복구할 수 있다.

k \equiv (z_1-z_2)(s_1-s_2)^{-1} \pmod n

그리고 다시 첫 번째 식에 대입하면 개인키도 나온다.

d \equiv (s_1k-z_1)r^{-1} \pmod n

즉 같은 $r$ 을 가진 두 서명과 각각의 메시지 해시만 알면 owner의 개인키를 복구할 수 있다.

컨트랙트는 ECDSA.toEthSignedMessageHash를 사용한다. 따라서 서명 대상은 단순한 keccak256(message)가 아니라 다음 prefix가 붙은 해시다.

1
keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", message.length, message))

setAdmin의 메시지도 봐야 한다. abi.encodePacked("admin", nonce.toString(), newAdmin)에서 newAdmin은 0x... 문자열이 아니라 20바이트 address 값 그대로 이어 붙는다.

문제 코드 분석#

힌트에서는 owner가 lock과 admin 설정에 사용한 두 서명을 보라고 한다. 실제 인스턴스 생성 시에는 팩토리에서 다음 순서로 호출된다.

1
bytes constant SWITCH_LOCK_SIG = abi.encodePacked(
2
    hex"e5648161e95dbf2bfc687b72b745269fa906031e2108118050aba59524a23c40", // r
3
    hex"70026fc30e4e02a15468de57155b080f405bd5b88af05412a9c3217e028537e3", // s
4
    uint8(27) // v
5
);
6
bytes constant SET_ADMIN_SIG = abi.encodePacked(
7
    hex"e5648161e95dbf2bfc687b72b745269fa906031e2108118050aba59524a23c40", // r
8
    hex"4c3ac03b268ae1d2aca1201e8a936adf578a8b95a49986d54de87cd0ccb68a79", // s
9
    uint8(27) // v
10
);
11

12
address constant OWNER = 0x03E2cf81BBE61D1fD1421aFF98e8605a5A9e953a;
13
address constant ADMIN = 0xADa4aFfe581d1A31d7F75E1c5a3A98b2D4C40f68;
14

15
instance.transferOwnership(OWNER);
16
instance.switchLock(SWITCH_LOCK_SIG);
17
instance.setAdmin(SET_ADMIN_SIG, ADMIN);

두 서명은 r이 같다.

1
r = e5648161e95dbf2bfc687b72b745269fa906031e2108118050aba59524a23c40

서명 nonce $k$ 가 재사용됐으므로, switchLock에 쓰인 메시지와 setAdmin에 쓰인 메시지 해시를 알면 owner 개인키를 복구할 수 있다.

팩토리 호출 순서를 기준으로 처음 nonce는 0이다.

1
function switchLock(bytes memory signature) public {
2
    string memory message = string(abi.encodePacked("lock", nonce.toString()));
3
    require(_verify(hash_message(message), signature), InvalidSignature());
4
    nonce++;
5
    locked = !locked;
6
}

첫 호출은 switchLock이므로 메시지는 "lock0"이다. 이 호출 뒤 nonce는 1이 되고 locked는 true가 된다.

1
function setAdmin(bytes memory signature, address newAdmin) public {
2
    string memory message = string(abi.encodePacked("admin", nonce.toString(), newAdmin));
3
    require(_verify(hash_message(message), signature), InvalidSignature());
4
    nonce++;
5
    admin = newAdmin;
6
}

두 번째 호출은 setAdmin이므로 메시지는 abi.encodePacked("admin", "1", ADMIN)이다. 이 호출 뒤 nonce는 2가 되고 admin은 초기 admin 주소가 된다.

서명 검증은 owner 주소로 recover되는지만 본다.

1
function _verify(bytes32 hash, bytes memory signature) internal view returns (bool) {
2
    return ECDSA.recover(hash, signature) == owner();
3
}

서명 사용 여부를 저장하지도 않고, signer가 msg.sender인지도 확인하지 않는다. owner 개인키만 복구하면 이후 nonce에 맞는 새 owner 서명을 만들 수 있다. 출금 조건은 두 가지다.

1
function withdraw() public onlyAdmin {
2
    require(!locked, FundsLocked());
3
    payable(admin).transfer(address(this).balance);
4
}

admin이 우리 주소여야 하고, locked가 false여야 한다. 초기 상태는 nonce = 2, locked = true, admin = ADMIN이므로 admin2<player>에 대한 서명으로 admin을 바꾸고, 이어서 lock3에 대한 서명으로 잠금을 다시 끄면 된다.

풀이#

두 초기 서명에서 owner 개인키를 복구하면 된다.

switchLock 초기 서명은 lock0에 대한 서명이다.
setAdmin 초기 서명은 abi.encodePacked("admin", "1", INITIAL_ADMIN)에 대한 서명이다.
두 서명의 r이 같으므로 같은 $k$ 를 재사용했다.
위 공식으로 owner 개인키 $d$ 를 복구한다.
현재 플레이어 주소로 admin2<player> 메시지를 서명해 setAdmin을 호출한다.
그 다음 nonce는 3이므로 lock3 메시지를 서명해 switchLock을 호출한다.
이제 admin == player, locked == false이므로 withdraw로 잔액을 가져온다.

vm.sign은 임의 private key와 digest로 서명을 만들어주므로, 복구한 owner private key를 트랜잭션 송신에 쓰는 것이 아니라 문제 컨트랙트가 요구하는 bytes signature를 만드는 데만 사용한다. 실제 트랜잭션은 플레이어의 PRIVATE_KEY로 보낸다.

익스플로잇#

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

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

6
interface IImpersonatorTwo {
7
    function nonce() external view returns (uint256);
8
    function owner() external view returns (address);
9
    function admin() external view returns (address);
10
    function setAdmin(bytes memory signature, address newAdmin) external;
11
    function switchLock(bytes memory signature) external;
12
    function withdraw() external;
13
}
14

15
contract Sol37 is Script {
16
    uint256 private constant SECP256K1_N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141;
17
    uint256 private constant SECP256K1_HALF_N = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0;
18

19
    uint256 private constant R = 0xe5648161e95dbf2bfc687b72b745269fa906031e2108118050aba59524a23c40;
20
    uint256 private constant SWITCH_LOCK_S = 0x70026fc30e4e02a15468de57155b080f405bd5b88af05412a9c3217e028537e3;
21
    uint256 private constant SET_ADMIN_S = 0x4c3ac03b268ae1d2aca1201e8a936adf578a8b95a49986d54de87cd0ccb68a79;
22

23
    address private constant OWNER = 0x03E2cf81BBE61D1fD1421aFF98e8605a5A9e953a;
24
    address private constant INITIAL_ADMIN = 0xADa4aFfe581d1A31d7F75E1c5a3A98b2D4C40f68;
25

26
    function run() external {
27
        uint256 privateKey = vm.envUint("PRIVATE_KEY");
28
        address player = vm.addr(privateKey);
29
        IImpersonatorTwo target = IImpersonatorTwo(vm.envAddress("IMPERSONATOR_TWO_INSTANCE"));
30

31
        uint256 ownerPrivateKey = _recoverOwnerPrivateKey();
32
        require(vm.addr(ownerPrivateKey) == OWNER, "owner key recovery failed");
33
        require(target.owner() == OWNER, "unexpected owner");
34

35
        uint256 nonce = target.nonce();
36
        bytes32 setAdminHash = _hashMessage(abi.encodePacked("admin", _toString(nonce), player));
37
        bytes memory setAdminSignature = _sign(ownerPrivateKey, setAdminHash);
38

39
        bytes32 switchLockHash = _hashMessage(abi.encodePacked("lock", _toString(nonce + 1)));
40
        bytes memory switchLockSignature = _sign(ownerPrivateKey, switchLockHash);
41

42
        vm.startBroadcast(privateKey);
43
        target.setAdmin(setAdminSignature, player);
44
        target.switchLock(switchLockSignature);
45
        target.withdraw();
46
        vm.stopBroadcast();
47

48
        require(target.admin() == player, "admin was not changed");
49
        require(address(target).balance == 0, "funds still remain");
50
    }
51

52
    function _recoverOwnerPrivateKey() private view returns (uint256) {
53
        bytes32 lockHash = _hashMessage(abi.encodePacked("lock", "0"));
54
        bytes32 adminHash = _hashMessage(abi.encodePacked("admin", "1", INITIAL_ADMIN));
55

56
        uint256 k = mulmod(
57
            _subMod(uint256(lockHash), uint256(adminHash)),
58
            _modInverse(_subMod(SWITCH_LOCK_S, SET_ADMIN_S)),
59
            SECP256K1_N
60
        );
61

62
        return mulmod(_subMod(mulmod(SWITCH_LOCK_S, k, SECP256K1_N), uint256(lockHash)), _modInverse(R), SECP256K1_N);
63
    }
64

65
    function _sign(uint256 privateKey, bytes32 digest) private pure returns (bytes memory) {
66
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, digest);
67
        uint256 sValue = uint256(s);
68

69
        if (sValue > SECP256K1_HALF_N) {
70
            s = bytes32(SECP256K1_N - sValue);
71
            v = 55 - v;
72
        }
73

74
        return abi.encodePacked(r, s, v);
75
    }
76

77
    function _hashMessage(bytes memory message) private pure returns (bytes32) {
78
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", _toString(message.length), message));
79
    }
80

81
    function _modInverse(uint256 value) private view returns (uint256) {
82
        return _modExp(value, SECP256K1_N - 2, SECP256K1_N);
83
    }
84

85
    function _modExp(uint256 base, uint256 exponent, uint256 modulus) private view returns (uint256 result) {
86
        bytes memory input = abi.encode(uint256(32), uint256(32), uint256(32), base, exponent, modulus);
87
        bool success;
88

89
        assembly {
90
            success := staticcall(gas(), 0x05, add(input, 0x20), mload(input), 0x00, 0x20)
91
            result := mload(0x00)
92
        }
93

94
        require(success, "modexp failed");
95
    }
96

97
    function _subMod(uint256 left, uint256 right) private pure returns (uint256) {
98
        return addmod(left % SECP256K1_N, SECP256K1_N - (right % SECP256K1_N), SECP256K1_N);
99
    }
100

101
    function _toString(uint256 value) private pure returns (string memory) {
102
        if (value == 0) {
103
            return "0";
104
        }
105

106
        uint256 temp = value;
107
        uint256 digits;
108

109
        while (temp != 0) {
110
            digits++;
111
            temp /= 10;
112
        }
113

114
        bytes memory buffer = new bytes(digits);
115

116
        while (value != 0) {
117
            digits--;
118
            buffer[digits] = bytes1(uint8(48 + (value % 10)));
119
            value /= 10;
120
        }
121

122
        return string(buffer);
123
    }
124
}

screenshot