MetaMask/Partner Snaps - StarknetSnap

1 Executive Summary

This report presents the results of our engagement with ConsenSys to review their MetaMask Starknet Snap.

The review was conducted from June 26, 2023 to June 29, 2023. A total of 4 person-days were spent.

2 Scope

The review focused on the commit hash ec24b0053eae641f49e4095809979c2839758bdf. The list of files in scope can be found in the Appendix.

2.1 Verification Phase

Mitigations were reviewed from July 18, 2023 to July 20, 2023 focussing on the commit hash 7231bb7fa4671283b2e7b4cbf5a519d56a57697a.

2.2 Objectives

Together with the client, we identified the following priorities for this review:

1. Correctness of the implementation, consistent with the intended functionality and without unintended edge cases.
2. Identify vulnerabilities particular to the MetaMask Snaps SDK integration in coherence with the MetaMask Snap Threat Model describing a Snap as an extension of the MetaMask Wallet Trust Module.

3 Snap Outline

• The snap requests access to coinType:9004 BIP44 Entropy, effectively managing the coins private root key.
• The private key can be displayed to the user within the context of the snap.
• The private key can not be exported to an RPC origin.
• Transactions are signed within the realm of the snap.
• The public key is exposed to connected snaps without additional user confirmation.
• The snap may interact with the following 3rd party service providers via the fetch() API:
  • https://api.coingecko.com
  • https://voyager.online
  • https://infura.io
  • https://starknet.io
  • and potentially others
• Connected dapps can communicate with the snap via MetaMask snap RPC.

3.1 Capabilities

Details

👉 2485 (lines of code)
[🚀 == Bundle == ]
    🔺 - bundle (../../dist/bundle.js) does not not exist!
    🔺 - package-lock missing
    🔺 - package.json: invalid license '(Apache-2.0 OR MIT)'
    🔺 - package.json: incomplete package files selection 'undefined'
----%<---- raw permissions
🌐 : https://docs.metamask.io/snaps/reference/rpc-api/#wallet_requestsnaps
{
  snap_dialog: {},
  'endowment:network-access': {},
  snap_getBip44Entropy: [ { coinType: 9004 } ],
  snap_manageState: {},
  'endowment:rpc': { snaps: false, dapps: true }
}
---->%---- raw permissions
🚜 [snap_dialog]
    ☝️ - snap_dialog - Displays a dialog in the MetaMask UI. There are three types of dialogs with different parameters and return types.
    ⚠️ - this method renders Markdown! check for ctrlchar/markdown/injection
       🔸  src/signMessage.ts
       🔸  src/sendTransaction.ts
       🔸  src/recoverAccounts.ts
       🔸  src/index.ts
       🔸  src/extractPrivateKey.ts
       🔸  src/createAccount.ts
🚜 [endowment:network-access]
    🌐 - endowment:network-access - snap can access internet
     ⚠️ - this method may leak information to external api
       🔸  src/utils/starknetUtils.ts
🚜 [snap_getBip44Entropy]
    ✨ - snap_getBip44Entropy - Gets the BIP-44 coin_type key for the coin_type number specified by the method name. See SLIP-44 for the list of available protocols and their coin_type values.
       ⚠️ - If you call this method, you receive the user's parent key for the protocol they request. You're managing the user's keys and assets on their behalf. Their safety is your responsibility.
       🔸  src/utils/keyPair.ts
🚜 [snap_manageState]
    🪤 - snap_manageState - snap can store up to 100mb (isolated)
       🔸  src/index.ts
       🔸  src/utils/snapUtils.ts
🚜 [endowment:rpc]
    ❗- endowment:rpc.dapps - snap can communicate with websites/dapps; check origin for internal api calls!
       🔸  src/index.ts

3.2 Dependencies

🌲 - Package Depenencies:
      - async-mutex:^0.3.2
      - chai:^4.3.6
      - ethereum-unit-converter:^0.0.17
      - ethers:^5.5.1
      - sinon:^13.0.2
      - sinon-chai:^3.7.0
      - starknet:^4.22.0
      - starknet_v4.6.0:npm:[email protected]

4 Findings

Each issue has an assigned severity:

• Minor issues are subjective in nature. They are typically suggestions around best practices or readability. Code maintainers should use their own judgment as to whether to address such issues.
• Medium issues are objective in nature but are not security vulnerabilities. These should be addressed unless there is a clear reason not to.
• Major issues are security vulnerabilities that may not be directly exploitable or may require certain conditions in order to be exploited. All major issues should be addressed.
• Critical issues are directly exploitable security vulnerabilities that need to be fixed.

export function getSigningTxnText(
  state: SnapState,
  contractAddress: string,
  contractFuncName: string,
  contractCallData: string[],
  senderAddress: string,
  maxFee: number.BigNumberish,
  network: Network,
): string {
  // Retrieve the ERC-20 token from snap state for confirmation display purpose
  const token = getErc20Token(state, contractAddress, network.chainId);
  let tokenTransferStr = '';
  if (token && contractFuncName === 'transfer') {
    try {
      let amount = '';
      if ([3, 6, 9, 12, 15, 18].includes(token.decimals)) {
        amount = convert(contractCallData[1], -1 * token.decimals, 'ether');
      } else {
        amount = (Number(contractCallData[1]) * Math.pow(10, -1 * token.decimals)).toFixed(token.decimals);
      }
      tokenTransferStr = `\n\nSender Address: ${senderAddress}\n\nRecipient Address: ${contractCallData[0]}\n\nAmount(${token.symbol}): ${amount}`;
    } catch (err) {
      console.error(`getSigningTxnText: error found in amount conversion: ${err}`);
    }
  }
  return (
    `Contract: ${contractAddress}\n\nCall Data: [${contractCallData.join(', ')}]\n\nEstimated Gas Fee(ETH): ${convert(
      maxFee,
      'wei',
      'ether',
    )}\n\nNetwork: ${network.name}` + tokenTransferStr
  );
}

const signingTxnText = getSigningTxnText(
  state,
  contractAddress,
  contractFuncName,
  contractCallData,
  senderAddress,
  maxFee,
  network,
);

const response = await wallet.request({
  method: 'snap_dialog',
  params: {
    type: DialogType.Confirmation,
    content: panel([
      heading('Do you want to sign this transaction ?'),
      text(`It will be signed with address: ${senderAddress}`),
      text(signingTxnText),
    ]),
  },
});

try {
  validateAndParseAddress(requestParamsObj.tokenAddress);
} catch (err) {
  throw new Error(`The given token address is invalid: ${requestParamsObj.tokenAddress}`);
}
try {
  validateAndParseAddress(requestParamsObj.userAddress);
} catch (err) {
  throw new Error(`The given user address is invalid: ${requestParamsObj.userAddress}`);
}

export function validateAndParseAddress(address: BigNumberish): string {
  assertInRange(address, ZERO, MASK_251, 'Starknet Address');

  const result = addAddressPadding(address);

  if (!result.match(/^(0x)?[0-9a-fA-F]{64}$/)) {
    throw new Error('Invalid Address Format');
  }

  return result;
}

export function validateAndParseAddress(address: BigNumberish): string {
  assertInRange(address, ZERO, MASK_251, 'Starknet Address');

  const result = addAddressPadding(address);

  if (!result.match(/^(0x)?[0-9a-fA-F]{64}$/)) {
    throw new Error('Invalid Address Format');
  }

  return result;
}

const response = await wallet.request({
  method: 'snap_dialog',
  params: {
    type: DialogType.Confirmation,
    content: panel([heading('Do you want to sign this message ?'), text(JSON.stringify(typedDataMessage))]),
  },
});
if (!response) return false;

const response = await wallet.request({
  method: 'snap_dialog',
  params: {
    type: DialogType.Confirmation,
    content: panel([heading('Do you want to sign this message ?'), text(JSON.stringify(typedDataMessage))]),
  },
});

{"a **mykey**":"this should not render **markdown** <pre>test</pre><b>bbb</b><strong>strongstrong</strong>[visit oststrom](https://oststrom.com) _ital_"}

export function AlertView({ text, variant, ...otherProps }: Props) {
  const paragraph = useRef<HTMLParagraphElement | null>(null);
  const [isMultiline, setIsMultiline] = useState(false);
  useEffect(() => {
    if (paragraph.current) {
      const height = paragraph.current.offsetHeight;
      setIsMultiline(height > 20);
    }
  }, []);
  return (
    <Wrapper isMultiline={isMultiline} variant={variant} {...otherProps}>
      <>
        {variant === VariantOptions.SUCCESS && <LeftIcon icon={['fas', 'check-circle']} />}
        {variant === VariantOptions.INFO && <LeftIcon icon={['fas', 'info-circle']} color={theme.palette.info.dark} />}
        {variant === VariantOptions.ERROR && (
          <LeftIcon icon={['fas', 'exclamation-circle']} color={theme.palette.error.main} />
        )}
        {variant === VariantOptions.WARNING && (
          <LeftIcon icon={['fas', 'exclamation-triangle']} color={theme.palette.warning.main} />
        )}
        <Parag ref={paragraph} color={variant} dangerouslySetInnerHTML={{ __html: text }} />
      </>
    </Wrapper>
  );
}

export const NoFlaskModalView = () => {
  return (
    <Wrapper>
      <StarknetLogo />
      <Title>You don't have the MetaMask Flask extension</Title>
      <DescriptionCentered>
        You need to install MetaMask Flask extension in order to use the StarkNet Snap.
        <br />
        <br />
        <AlertView
          text="Please make sure that the regular MetaMask extension is disabled or use a different browser profile"
          variant="warning"
        />
      </DescriptionCentered>
      <a href="https://metamask.io/flask" target="_blank" rel="noreferrer noopener">
        <ConnectButton customIconLeft={<FlaskIcon />} onClick={() => {}}>
          Download MetaMask Flask
        </ConnectButton>
      </a>
    </Wrapper>
  );
};

  validateAddErc20TokenParams(requestParamsObj, network);

  const erc20Token: Erc20Token = {
    address: tokenAddress,
    name: tokenName,
    symbol: tokenSymbol,
    decimals: tokenDecimals,
    chainId: network.chainId,
  };

  await upsertErc20Token(erc20Token, wallet, saveMutex);

  console.log(`addErc20Token:\nerc20Token: ${JSON.stringify(erc20Token)}`);
  return erc20Token;
} catch (err) {
  console.error(`Problem found: ${err}`);
  throw err;
}

  }
  return null;
};

const { privateKey: signerPrivateKey } = await getKeysFromAddress(keyDeriver, network, state, signerAddress);
const signerKeyPair = getKeyPairFromPrivateKey(signerPrivateKey);
const typedDataSignature = getTypedDataMessageSignature(signerKeyPair, typedDataMessage, signerAddress);

const { privateKey: userPrivateKey } = await getKeysFromAddress(keyDeriver, network, state, userAddress);

const { publicKey } = await getKeysFromAddress(keyDeriver, network, state, userAddress);
userPublicKey = publicKey;

const {
  privateKey: senderPrivateKey,
  publicKey,
  addressIndex,
} = await getKeysFromAddress(keyDeriver, network, state, senderAddress);

const { privateKey: signerPrivateKey } = await getKeysFromAddress(keyDeriver, network, state, signerAddress);
const signerKeyPair = getKeyPairFromPrivateKey(signerPrivateKey);

const { privateKey: signerPrivateKey } = await getKeysFromAddress(keyDeriver, network, state, verifySignerAddress);

const { privateKey: senderPrivateKey, publicKey } = await getKeysFromAddress(
  keyDeriver,
  network,
  state,
  senderAddress,
);

const transactions = getTransactions(
  state,
  network.chainId,
  requestParamsObj.senderAddress,
  requestParamsObj.contractAddress,
  requestParamsObj.txnType,
  undefined,
  minTimeStamp,
);

// Switch statement for methods not requiring state to speed things up a bit
console.log(origin, request);

console.log(`${request.method}:\nrequestParams: ${JSON.stringify(requestParams)}`);

console.log(`Snap State:\n${JSON.stringify(state, null, 2)}`);

"chai": "^4.3.6",

"sinon": "^13.0.2",
"sinon-chai": "^3.7.0",

"license": "(Apache-2.0 OR MIT)",

case 'starkNet_extractPrivateKey':
  apiParams.keyDeriver = await getAddressKeyDeriver(snap);
  return extractPrivateKey(apiParams);

const detectMetamaskFlask = async () => {
  try {
    const provider = (await detectEthereumProvider({
      mustBeMetaMask: false,
      silent: true,
    })) as any | undefined;
    const isFlask = (await provider?.request({ method: 'web3_clientVersion' }))?.includes('flask');
    if (provider && isFlask) {
      return true;
    }

⇒ window.ethereum.isMetaMask
true
⇒ await window.ethereum.request({ method: 'web3_clientVersion' })
'MetaMask/v10.32.0-flask.0'

Appendix 1 - Files in Scope

Appendix 2 - Disclosure

ConsenSys Diligence (“CD”) typically receives compensation from one or more clients (the “Clients”) for performing the analysis contained in these reports (the “Reports”). The Reports may be distributed through other means, including via ConsenSys publications and other distributions.

The Reports are not an endorsement or indictment of any particular project or team, and the Reports do not guarantee the security of any particular project. This Report does not consider, and should not be interpreted as considering or having any bearing on, the potential economics of a token, token sale or any other product, service or other asset. Cryptographic tokens are emergent technologies and carry with them high levels of technical risk and uncertainty. No Report provides any warranty or representation to any Third-Party in any respect, including regarding the bugfree nature of code, the business model or proprietors of any such business model, and the legal compliance of any such business. No third party should rely on the Reports in any way, including for the purpose of making any decisions to buy or sell any token, product, service or other asset. Specifically, for the avoidance of doubt, this Report does not constitute investment advice, is not intended to be relied upon as investment advice, is not an endorsement of this project or team, and it is not a guarantee as to the absolute security of the project. CD owes no duty to any Third-Party by virtue of publishing these Reports.

PURPOSE OF REPORTS The Reports and the analysis described therein are created solely for Clients and published with their consent. The scope of our review is limited to a review of code and only the code we note as being within the scope of our review within this report. Any Solidity code itself presents unique and unquantifiable risks as the Solidity language itself remains under development and is subject to unknown risks and flaws. The review does not extend to the compiler layer, or any other areas beyond specified code that could present security risks. Cryptographic tokens are emergent technologies and carry with them high levels of technical risk and uncertainty. In some instances, we may perform penetration testing or infrastructure assessments depending on the scope of the particular engagement.

CD makes the Reports available to parties other than the Clients (i.e., “third parties”) – on its website. CD hopes that by making these analyses publicly available, it can help the blockchain ecosystem develop technical best practices in this rapidly evolving area of innovation.

LINKS TO OTHER WEB SITES FROM THIS WEB SITE You may, through hypertext or other computer links, gain access to web sites operated by persons other than ConsenSys and CD. Such hyperlinks are provided for your reference and convenience only, and are the exclusive responsibility of such web sites’ owners. You agree that ConsenSys and CD are not responsible for the content or operation of such Web sites, and that ConsenSys and CD shall have no liability to you or any other person or entity for the use of third party Web sites. Except as described below, a hyperlink from this web Site to another web site does not imply or mean that ConsenSys and CD endorses the content on that Web site or the operator or operations of that site. You are solely responsible for determining the extent to which you may use any content at any other web sites to which you link from the Reports. ConsenSys and CD assumes no responsibility for the use of third party software on the Web Site and shall have no liability whatsoever to any person or entity for the accuracy or completeness of any outcome generated by such software.

TIMELINESS OF CONTENT The content contained in the Reports is current as of the date appearing on the Report and is subject to change without notice. Unless indicated otherwise, by ConsenSys and CD.