GnosisSafe.sol 学习

Posted 2022-10-05 MateZero

GnosisSafe是以太坊区块链上最流行的多签钱包！它的最初版本叫 MultiSigWallet，现在新的钱包叫Gnosis Safe，意味着它不仅仅是钱包了。它自己的介绍为:以太坊上的最可信的数字资产管理平台（The most trusted platform to manage digital assets on Ethereum）。

上次我们学习到了OwnerManager.sol，这次我们按着导入的顺序接着学习。

1. SignatureDecoder.sol

首先看源码：

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;

/// @title SignatureDecoder - Decodes signatures that a encoded as bytes
/// @author Richard Meissner - <[e-mail]>
contract SignatureDecoder 
    /// @dev divides bytes signature into `uint8 v, bytes32 r, bytes32 s`.
    /// @notice Make sure to peform a bounds check for @param pos, to avoid out of bounds access on @param signatures
    /// @param pos which signature to read. A prior bounds check of this parameter should be performed, to avoid out of bounds access
    /// @param signatures concatenated rsv signatures
    function signatureSplit(bytes memory signatures, uint256 pos)
        internal
        pure
        returns (
            uint8 v,
            bytes32 r,
            bytes32 s
        )
    
        // The signature format is a compact form of:
        //   bytes32 rbytes32 suint8 v
        // Compact means, uint8 is not padded to 32 bytes.
        // solhint-disable-next-line no-inline-assembly
        assembly 
            let signaturePos := mul(0x41, pos)
            r := mload(add(signatures, add(signaturePos, 0x20)))
            s := mload(add(signatures, add(signaturePos, 0x40)))
            // Here we are loading the last 32 bytes, including 31 bytes
            // of 's'. There is no 'mload8' to do this.
            //
            // 'byte' is not working due to the Solidity parser, so lets
            // use the second best option, 'and'
            v := and(mload(add(signatures, add(signaturePos, 0x41))), 0xff)
        
    

SignatureDecoder 顾名思义，用来解码签名，它只有一个函数signatureSplit，从它的注释和参数中我们可以猜出signatures是一个包含了多个签名的bytes变量（肯定和多签相关了），pos用来指明解码哪个签名，相当于数组的索引。 返回的结果就是解码后的v,r,s了。

注释中也提到，签名是紧密排列的，其格式为bytes32 rbytes32 suint8 v，因此其大小为0x41字节（两个 0x20 和一个0x1）。

注意中提到，在调用之前要进行边界检查，函数里是没有进行检查的。

我们重点看一下如下四行内嵌汇编：

  let signaturePos := mul(0x41, pos)
  r := mload(add(signatures, add(signaturePos, 0x20)))
  s := mload(add(signatures, add(signaturePos, 0x40)))
  v := and(mload(add(signatures, add(signaturePos, 0x41))), 0xff)

第一行，计算某个签名的偏移量（起始位置），我们提到了一个签名的大小是0x41(65)个字节，因此相应pos的领衔量为 0x41 * pos.

第二行，分离出r的值。这里很简单，就是读取r开始地址的一个word就行了。注意到这里又add了一个0x20，是为了略过长度前缀。

第三行，同样的方法分离s的值，这里add 0x40是因为长度前缀一个word，r一个word，所以我们得跳过两个word。

第四行，分离出 v值的办法稍微有一些技巧，按道理这里应该读取add 0x60(长度前缀 + 前面的r,s)，但是这样读取后的32字节只有第一个字节是我们需要的数据，后来都是无用的冗余数据。而处理32字节头部远比处理32字节尾部麻烦，因此，从后往前推一个字节读取，把欲分离的变量读取的word的最后，就是另一种思路。所以代码里它直接从add 0x41开始读，这样，v 就包含在读取的32字节的最后，我们只要把它和0xff按位与，就能把前面的冗余数据清零，得到最终的结果。

这里注释'byte' is not working due to the Solidity parser的意思是 字节（uint8）无法直接用于Solidity解析，所以借助了工具and。

分离出v类似的技巧还可以应用于分离地址类型的值，因为地址类型其实是uint160，不完全占用32字节，当然其它非32字节的固定大小类型也可以分离。

笔者注：其实最后可以不使用and操作，因为将结果赋值给了uint8会直接截断得到最后的一个字节。类似的示例见UniswapV3中BytesLib.sol中的toUint24函数。代码如下：

function toUint24(bytes memory _bytes, uint256 _start) internal pure returns (uint24) 
    require(_start + 3 >= _start, 'toUint24_overflow');
    require(_bytes.length >= _start + 3, 'toUint24_outOfBounds');
    uint24 tempUint;

    assembly 
        tempUint := mload(add(add(_bytes, 0x3), _start))
    

    return tempUint;

不过，bool类型赋值时不是只看最后一位，只要整个word不为0就是true。

2. SecuredTokenTransfer.sol

这个和UniswapV2的_safeTransfer及Openzeppelin的SafeERC20类似，都是使用底层调用来转移ERC20代币。为什么要使用底层调用呢？因为部分早期的代币不是标准的ERC20代币（例如USDT）其transfer函数没有返回值，使用contract.transfer方式会由于函数返回值检查通不过而失败。使用底层调用能绕过这个返回值检查。

本合约源码如下：

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;

/// @title SecuredTokenTransfer - Secure token transfer
/// @author Richard Meissner - <[e-mail]>
contract SecuredTokenTransfer 
    /// @dev Transfers a token and returns if it was a success
    /// @param token Token that should be transferred
    /// @param receiver Receiver to whom the token should be transferred
    /// @param amount The amount of tokens that should be transferred
    function transferToken(
        address token,
        address receiver,
        uint256 amount
    ) internal returns (bool transferred) 
        // 0xa9059cbb - keccack("transfer(address,uint256)")
        bytes memory data = abi.encodeWithSelector(0xa9059cbb, receiver, amount);
        // solhint-disable-next-line no-inline-assembly
        assembly 
            // We write the return value to scratch space.
            // See https://docs.soliditylang.org/en/v0.7.6/internals/layout_in_memory.html#layout-in-memory
            let success := call(sub(gas(), 10000), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            switch returndatasize()
                case 0 
                    transferred := success
                
                case 0x20 
                    transferred := iszero(or(iszero(success), iszero(mload(0))))
                
                default 
                    transferred := 0
                
        
    

这里的代码完全是内嵌汇编，和以前的稍有不同。一是call调用时预留了1000gas，另一个是将返回值写在了第内存的第一个字节。

接下来的switch case倒是简单，如果没有返回值，则返回是否成功（这时1代表成功，0代表失败）。如果有返回值（只有一个word），那么根据是否调用成功和返回值是否为0来得到最后的transferred。如果返回值不只一个word，则表示不能处理的返回值，直接算失败。

注意，这里的代码并没有重置交易，只是返回了一个代表是否转移成功的布尔值。在实际使用中一定要根据不同的返回值进行处理。

如果想失败时直接重置交易，直接使用_safeTransfer倒是个不错的选择，相关代码如下：

bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
function _safeTransfer(address token, address to, uint value) private 
    (bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
    require(success && (data.length == 0 || abi.decode(data, (bool))), 'UniswapV2: TRANSFER_FAILED');

3. ISignatureValidator.sol

这个合约很简单，源码如下：

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;

contract ISignatureValidatorConstants 
    // bytes4(keccak256("isValidSignature(bytes,bytes)")
    bytes4 internal constant EIP1271_MAGIC_VALUE = 0x20c13b0b;


abstract contract ISignatureValidator is ISignatureValidatorConstants 
    /**
     * @dev Should return whether the signature provided is valid for the provided data
     * @param _data Arbitrary length data signed on the behalf of address(this)
     * @param _signature Signature byte array associated with _data
     *
     * MUST return the bytes4 magic value 0x20c13b0b when function passes.
     * MUST NOT modify state (using STATICCALL for solc < 0.5, view modifier for solc > 0.5)
     * MUST allow external calls
     */
    function isValidSignature(bytes memory _data, bytes memory _signature) public view virtual returns (bytes4);

这个类似ERC721中的onERC721Received，也就是给别人一个执行完成后的回调，返回0x20c13b0b这个常量。

4. FallbackManager.sol

这个从名字可以看出来，是回调管理，到底是什么回调呢？其实是Solidity合约的默认回调函数fallback()。

先上源码：

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;

import "../common/SelfAuthorized.sol";

/// @title Fallback Manager - A contract that manages fallback calls made to this contract
/// @author Richard Meissner - <[e-mail]>
contract FallbackManager is SelfAuthorized 
    event ChangedFallbackHandler(address handler);

    // keccak256("fallback_manager.handler.address")
    bytes32 internal constant FALLBACK_HANDLER_STORAGE_SLOT = 0x6c9a6c4a39284e37ed1cf53d337577d14212a4870fb976a4366c693b939918d5;

    function internalSetFallbackHandler(address handler) internal 
        bytes32 slot = FALLBACK_HANDLER_STORAGE_SLOT;
        // solhint-disable-next-line no-inline-assembly
        assembly 
            sstore(slot, handler)
        
    

    /// @dev Allows to add a contract to handle fallback calls.
    ///      Only fallback calls without value and with data will be forwarded.
    ///      This can only be done via a Safe transaction.
    /// @param handler contract to handle fallbacks calls.
    function setFallbackHandler(address handler) public authorized 
        internalSetFallbackHandler(handler);
        emit ChangedFallbackHandler(handler);
    

    // solhint-disable-next-line payable-fallback,no-complex-fallback
    fallback() external 
        bytes32 slot = FALLBACK_HANDLER_STORAGE_SLOT;
        // solhint-disable-next-line no-inline-assembly
        assembly 
            let handler := sload(slot)
            if iszero(handler) 
                return(0, 0)
            
            calldatacopy(0, 0, calldatasize())
            // The msg.sender address is shifted to the left by 12 bytes to remove the padding
            // Then the address without padding is stored right after the calldata
            mstore(calldatasize(), shl(96, caller()))
            // Add 20 bytes for the address appended add the end
            let success := call(gas(), handler, 0, 0, add(calldatasize(), 20), 0, 0)
            returndatacopy(0, 0, returndatasize())
            if iszero(success) 
                revert(0, returndatasize())
            
            return(0, returndatasize())
        
    

我们知道，GnosisSafe采用的是一个代理/实现模式。我们实际调用的合约是GnosisSafeProxy，它会将所有调用通过fallback全部委托调用GnosisSafe执行，

也就是这里已经回调过一次了，那么在实现合约中能否再实现一个fallback再次进行调用/委托调用呢？答案是肯定的。本合约指定了一个特定插槽，将插槽的内容不为空地址时，则将消息调用转发到插槽对应的地址执行（注意是call调用），同时，会在原payload上添加调用者的地址。

至于为什么要这样做，暂时还未清楚，等后面学习后也许就可以解惑了。

4.1 internalSetFallbackHandler 函数

内部调用，就是设置插槽的值，很简单

4.2 setFallbackHandler 函数

外部调用，注意限定了自调用。就是设置插槽的值再加触发一个事件。注意，这里是可以设置零地址的，这样就不用再次调用其它合约了。

4.3 fallback 函数

这个也比较简单，首先读取插槽值，如果为零地址，则直接退出执行。否则的话将calldata数据（payload）全部复制到内存中0地址开始的地方，注意这里并未使用变量，因此是没有长度前缀的，内存中零地址开始到calldatasize的内容就是payload的值。

mstore(calldatasize(), shl(96, caller())) 是在后面添加了一个msg.sender地址，为了节省空间，将caller(msg.sender)向左移动了12个字节（地址是20字节40位，一个word是32字节，所以左移12个字节相当于把地址放在一个word的开头位置）。最后使用mstore添加在payload后。这样0 ~ calldatasize就是原payload,calldatasize ~ calldatasize + 32就是原msg.sender。有人说，你这并未节省啊，因为mstore还是操作的word，你还是占32字节，请往下看。

let success := call(gas(), handler, 0, 0, add(calldatasize(), 20), 0, 0) 。

我们再次回顾一个call函数的简单定义：call(g, a, v, in, insize, out, outsize)

对比一下，我们可以看到以前使用时insize的值为calldatasize，这次的值为calldatasize + 20，这样我们就把内存中复制的旧payload后附加的地址一并作为新的payload发送了出去。这是是add 20不是add 0x20，所以call左移12字节后最右边的12字节的0并没有作为新的payload发送出去。

后面的执行同原来的示例类似，注意 call和delegatecall返回0代表失败，1代表成功。

这里有一个风险点：当回调地址插槽FALLBACK_HANDLER_STORAGE_SLOT的内容为任一EOA账号（Externally Owned Account）时，由于EOA账号没有代码，此时call执行会成功（这是由于EVM的特性造成的，其它项目有过类似的安全事故）。所以在执行前必须小心设定该插槽的内容。

5. StorageAccessible.sol

本合约只有两个函数，一个函数getStorageAt是获取连续的多个内存插槽的内容，另一个simulateAndRevert是模拟执行并返回结果。

我们贴了源码后分别学习。

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;

/// @title StorageAccessible - generic base contract that allows callers to access all internal storage.
/// @notice See https://github.com/gnosis/util-contracts/blob/bb5fe5fb5df6d8400998094fb1b32a178a47c3a1/contracts/StorageAccessible.sol
contract StorageAccessible 
    /**
     * @dev Reads `length` bytes of storage in the currents contract
     * @param offset - the offset in the current contract's storage in words to start reading from
     * @param length - the number of words (32 bytes) of data to read
     * @return the bytes that were read.
     */
    function getStorageAt(uint256 offset, uint256 length) public view returns (bytes memory) 
        bytes memory result = new bytes(length * 32);
        for (uint256 index = 0; index < length; index++) 
            // solhint-disable-next-line no-inline-assembly
            assembly 
                let word := sload(add(offset, index))
                mstore(add(add(result, 0x20), mul(index, 0x20)), word)
            
        
        return result;
    

    /**
     * @dev Performs a delegetecall on a targetContract in the context of self.
     * Internally reverts execution to avoid side effects (making it static).
     *
     * This method reverts with data equal to `abi.encode(bool(success), bytes(response))`.
     * Specifically, the `returndata` after a call to this method will be:
     * `success:bool || response.length:uint256 || response:bytes`.
     *
     * @param targetContract Address of the contract containing the code to execute.
     * @param calldataPayload Calldata that should be sent to the target contract (encoded method name and arguments).
     */
    function simulateAndRevert(address targetContract, bytes memory calldataPayload) external 
        // solhint-disable-next-line no-inline-assembly
        assembly 
            let success := delegatecall(gas(), targetContract, add(calldataPayload, 0x20), mload(calldataPayload), 0, 0)

            mstore(0x00, success)
            mstore(0x20, returndatasize())
            returndatacopy(0x40, 0, returndatasize())
            revert(0, add(returndatasize(), 0x40))
        
    

5.1 getStorageAt 函数

我们知道，在Solidity中，内存是使用字节为单位的，比如地址0x20，则是从0x20字节开始。但是存储却是以插槽为单位的，理论上插槽是从1到2**256-1个。

所以getStorageAt的两个参数分别为：offset，起始插槽，length欲获取内容的插槽数量。这两个弄明白了后面就很好解决了。

因为插槽内容也是32字节（key-value都是一个word,32字节），所以bytes memory result = new bytes(length * 32); 先分配了一块内存区域来保存返回结果。

接下来一个For循环遍历读取每个欲获取的插槽内容，并且写入到result中对应的位置去。这里为什么会有add(result, 0x20)呢？记住result是个bytes，动态类型，它有个长度前缀，所以得跳过这个长度前缀word。

5.2 simulateAndRevert 函数

这个函数逻辑倒是不难，难点在应用上。我们直接学习汇编代码。

首先，进行了一个委托调用，这里delegatgecall我们已经学习很多次了，所以可以直接看明白。

接下来，将是否调用成功存在了内存第一个32字节，将返回的数据大小存在了内存的第二个32字节。将返回的数据存在了内存第三个32字节开始的地方。

接下来重置交易，因为是模拟执行，所以不能改变状态，然后将内存中returndatasize + 0x40大小的内容（其实就是包含了返回数据和内存中前两个word)作为重置原因返回。

可以看到，该函数为非view函数，因此就算是调用失败了，也仍然会记录在链上，仍然要花费gas。所以这里免费调用可能需要一定的技巧，例如在ethers.js中使用provider.call来调用（不绑定钱包，这样就不花费了），然后catch返回的结果就可以了（暂未测试验证，待有空验证）。

6. GuardManager.sol

先上源码：

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;

import "../common/Enum.sol";
import "../common/SelfAuthorized.sol";

interface Guard 
    function checkTransaction(
        address to,
        uint256 value,
        bytes memory data,
        Enum.Operation operation,
        uint256 safeTxGas,
        uint256 baseGas,
        uint256 gasPrice,
        address gasToken,
        address payable refundReceiver,
        bytes memory signatures,
        address msgSender
    ) external;

    function checkAfterExecution(bytes32 txHash, bool success) external;


/// @title Fallback Manager - A contract that manages fallback calls made to this contract
/// @author Richard Meissner - <[e-mail]>
contract GuardManager is SelfAuthorized 
    event ChangedGuard(address guard);
    // keccak256("guard_manager.guard.address")
    bytes32 internal constant GUARD_STORAGE_SLOT = 0x4a204f620c8c5ccdca3fd54d003badd85ba500436a431f0cbda4f558c93c34c8;

    /// @dev Set a guard that checks transactions before execution
    /// @param guard The address of the guard to be used or the 0 address to disable the guard
    function setGuard(address guard) external authorized 
        bytes32 slot = GUARD_STORAGE_SLOT;
        // solhint-disable-next-line no-inline-assembly
        assembly 
            sstore(slot, guard)
        
        emit ChangedGuard(guard);
    

    function getGuard() internal view returns (address guard) 
        bytes32 slot = GUARD_STORAGE_SLOT;
        // solhint-disable-next-line no-inline-assembly
        assembly 
            guard := sload(slot)
        
    

可以看到，本合约源文件包含一个接口定义和一个简单的检查合约。

接口 Guard定义了一个函数用来检查交易，还定义了一个函数用来要执行后检查（具体逻辑未知）。

合约GuardManager定义了一个插槽GUARD_STORAGE_SLOT用来保存实现Guard接口的合约的地址，并分别提供了get和set函数。注意set函数是限定自调用的。

好了，到此我们GnosisSafe合约所有的导入合约都学习完毕，从学习中我们可以看出，它采用模块化设计的，导入的合约虽然多，但是每个都是独立实现了一个小功能，方便复用。

有了这些导入合约学习作基础，我们接下来便可学习GnosisSafe合约的正文了。