wallet-stack 1.0.0-alpha.121

package/src/keylessBackup/WalletSecurityPrimer.tsx

@@ -0,0 +1,81 @@
+import { NativeStackScreenProps } from '@react-navigation/native-stack'
+import React from 'react'
+import { useTranslation } from 'react-i18next'
+import { Image, ScrollView, StyleSheet, Text, View } from 'react-native'
+import { SafeAreaView } from 'react-native-safe-area-context'
+import AppAnalytics from 'src/analytics/AppAnalytics'
+import { KeylessBackupEvents } from 'src/analytics/Events'
+import { getAppConfig } from 'src/appConfig'
+import Button, { BtnSizes, BtnTypes } from 'src/components/Button'
+import { walletSafe } from 'src/images/Images'
+import { KeylessBackupFlow } from 'src/keylessBackup/types'
+import { navigate } from 'src/navigator/NavigationService'
+import { Screens } from 'src/navigator/Screens'
+import { StackParamList } from 'src/navigator/types'
+import { typeScale } from 'src/styles/fonts'
+import { Spacing } from 'src/styles/styles'
+
+type Props = NativeStackScreenProps<StackParamList, Screens.WalletSecurityPrimer>
+
+function WalletSecurityPrimer({ route }: Props) {
+  const { t } = useTranslation()
+  return (
+    <SafeAreaView style={styles.container} edges={['bottom']}>
+      <ScrollView style={styles.scrollContainer}>
+        <View style={styles.imageContainer}>
+          <Image
+            testID="Email"
+            source={
+              getAppConfig().themes?.default?.assets?.backupAndRecoveryImages?.walletSafe ??
+              walletSafe
+            }
+          />
+        </View>
+        <Text style={styles.title}>{t('walletSecurityPrimer.title')}</Text>
+        <Text style={styles.description}>{t('walletSecurityPrimer.description')}</Text>
+      </ScrollView>
+      <Button
+        testID="WalletSecurityPrimer/GetStarted"
+        onPress={function () {
+          AppAnalytics.track(KeylessBackupEvents.wallet_security_primer_get_started)
+          navigate(Screens.KeylessBackupIntro, {
+            keylessBackupFlow: KeylessBackupFlow.Setup,
+          })
+        }}
+        text={t('getStarted')}
+        size={BtnSizes.FULL}
+        type={BtnTypes.PRIMARY}
+        style={styles.button}
+      />
+    </SafeAreaView>
+  )
+}
+
+export default WalletSecurityPrimer
+
+const styles = StyleSheet.create({
+  container: {
+    justifyContent: 'space-between',
+    height: '100%',
+  },
+  scrollContainer: {
+    padding: Spacing.Thick24,
+  },
+  title: {
+    ...typeScale.titleMedium,
+    textAlign: 'center',
+    marginTop: Spacing.Thick24,
+  },
+  description: {
+    ...typeScale.bodyMedium,
+    textAlign: 'center',
+    marginTop: Spacing.Regular16,
+  },
+  button: {
+    padding: Spacing.Thick24,
+  },
+  imageContainer: {
+    alignItems: 'center',
+    paddingTop: Spacing.Thick24,
+  },
+})

package/src/keylessBackup/encryption.test.ts

@@ -0,0 +1,139 @@
+import * as secp from '@noble/secp256k1'
+import { fromBytes, fromHex } from 'viem'
+import {
+  decryptPassphrase,
+  deriveKeyFromKeyShares,
+  encryptPassphrase,
+  getSecp256K1KeyPair,
+  getWalletAddressFromPrivateKey,
+} from './encryption'
+
+describe("Encryption utilities using Node's crypto and futoin-hkdf", () => {
+  let keyshare1: Buffer
+  let keyshare2: Buffer
+  let passphrase: string
+
+  beforeEach(() => {
+    keyshare1 = Buffer.from('57e25df276a72a7f38c862803a201596', 'hex')
+    keyshare2 = Buffer.from('bc56bf47e65f62319a0659bfe106e992', 'hex')
+    passphrase =
+      'hurdle citizen woman cherry wedding screen camp pony curve bargain pipe trend clump absent mule uncover where obey other tent december betray space jacket'
+  })
+
+  describe('deriveKeyFromKeyShares', () => {
+    it('should derive a buffer of length 32 by default', () => {
+      const buffer = deriveKeyFromKeyShares(keyshare1, keyshare2)
+      expect(buffer).toBeInstanceOf(Buffer)
+      expect(buffer.length).toBe(32)
+    })
+
+    it('should derive a buffer of length 48 when specified', () => {
+      const buffer = deriveKeyFromKeyShares(keyshare1, keyshare2, 48)
+      expect(buffer).toBeInstanceOf(Buffer)
+      expect(buffer.length).toBe(48)
+    })
+
+    it('gives same result when called twice with same inputs', () => {
+      const buffer1 = deriveKeyFromKeyShares(keyshare1, keyshare2)
+      const buffer2 = deriveKeyFromKeyShares(keyshare1, keyshare2)
+      expect(buffer1).toEqual(buffer2)
+    })
+
+    it('should produce different outputs for different keyshares', () => {
+      const buffer1 = deriveKeyFromKeyShares(keyshare1, keyshare2)
+      const buffer2 = deriveKeyFromKeyShares(keyshare2, keyshare1)
+      expect(buffer1.toString('hex')).not.toBe(buffer2.toString('hex'))
+    })
+    it('should throw if a keyshare is less than 16 bytes', () => {
+      const shortKeyshare = Buffer.from('77020c157b3440de1b697ab0e66baf', 'hex') // obtained with crypto.randomBytes(15).toString('hex')
+      expect(() => deriveKeyFromKeyShares(keyshare1, shortKeyshare)).toThrow()
+      expect(() => deriveKeyFromKeyShares(shortKeyshare, keyshare2)).toThrow()
+    })
+  })
+
+  describe('getSecp256K1KeyPair', () => {
+    it('should produce a valid secp256k1 key pair', async () => {
+      const { privateKey, publicKey } = getSecp256K1KeyPair(keyshare1, keyshare2)
+      expect(fromHex(privateKey, 'bytes').byteLength).toEqual(32)
+      expect(fromHex(publicKey, 'bytes').byteLength).toEqual(33)
+
+      // able to sign with private key and verify with public key
+      const messageHash = await secp.utils.sha256(new TextEncoder().encode('hello world'))
+      const signature = await secp.sign(messageHash, fromHex(privateKey, 'bytes'))
+      expect(secp.verify(signature, messageHash, fromHex(publicKey, 'bytes'))).toBe(true)
+    })
+
+    it('gives same result when called twice with same inputs', async () => {
+      const { privateKey, publicKey } = getSecp256K1KeyPair(keyshare1, keyshare2)
+      const { privateKey: privateKey2, publicKey: publicKey2 } = getSecp256K1KeyPair(
+        keyshare1,
+        keyshare2
+      )
+      expect(privateKey).toEqual(privateKey2)
+      expect(publicKey).toEqual(publicKey2)
+    })
+  })
+
+  describe('encryptPassphrase', () => {
+    it('should encrypt a passphrase using two keyshares', () => {
+      const encrypted = encryptPassphrase(keyshare1, keyshare2, passphrase)
+      expect(encrypted).toBeTruthy()
+      expect(typeof encrypted).toBe('string')
+    })
+  })
+
+  describe('decryptPassphrase', () => {
+    it('should decrypt an encrypted passphrase correctly', () => {
+      const encrypted = encryptPassphrase(keyshare1, keyshare2, passphrase)
+      const decrypted = decryptPassphrase(keyshare1, keyshare2, encrypted)
+      expect(decrypted).toBe(passphrase)
+    })
+    it('should be deterministic', () => {
+      const encrypted = encryptPassphrase(keyshare1, keyshare2, passphrase)
+      const decrypted1 = decryptPassphrase(keyshare1, keyshare2, encrypted)
+      const decrypted2 = decryptPassphrase(keyshare1, keyshare2, encrypted)
+      expect(decrypted1).toBe(decrypted2)
+    })
+    it('should decrypt an encrypted passphrase where the authTag was serialized from an ArrayBuffer', () => {
+      const encrypted = encryptPassphrase(keyshare1, keyshare2, passphrase)
+      const [nonceBase64, encryptedMessage, authTagBase64] = encrypted.split(':')
+      const authTagSerializedArrayBuffer = Array.from(
+        Buffer.from(authTagBase64, 'base64')
+      ).toString()
+      const encryptedSerialized = `${nonceBase64}:${encryptedMessage}:${authTagSerializedArrayBuffer}`
+      const decrypted = decryptPassphrase(keyshare1, keyshare2, encryptedSerialized)
+      expect(decrypted).toBe(passphrase)
+    })
+    it('throws if authTag is tampered with', () => {
+      // fails if decipher.final() is not called
+      const encrypted = encryptPassphrase(keyshare1, keyshare2, passphrase)
+      const [nonceBase64, encryptedMessage, authTagBase64] = encrypted.split(':')
+      const tamperedFirstChar = authTagBase64[0] === 'A' ? 'B' : 'A'
+      const tampered = `${nonceBase64}:${encryptedMessage}:${tamperedFirstChar}${authTagBase64.slice(
+        1
+      )}`
+      expect(() => decryptPassphrase(keyshare1, keyshare2, tampered)).toThrow()
+    })
+    it('throws if authTag from other passphrase is used', () => {
+      const encrypted0 = encryptPassphrase(keyshare1, keyshare2, passphrase)
+      const encrypted1 = encryptPassphrase(keyshare1, keyshare2, 'passphrase one')
+      const [nonce0, encryptedMessage0, _authTag0] = encrypted0.split(':')
+      const [_nonce1, _encryptedMessage1, authTag1] = encrypted1.split(':')
+      const tampered = `${nonce0}:${encryptedMessage0}:${authTag1}`
+      expect(() => decryptPassphrase(keyshare1, keyshare2, tampered)).toThrow()
+    })
+  })
+
+  describe('getWalletAddressFromPrivateKey', () => {
+    it('gives lowercase wallet address associated with private key', () => {
+      expect(
+        getWalletAddressFromPrivateKey(
+          fromBytes(
+            Buffer.from('0da7744e59ab530ebaa3ca5c6e67170fd18276fb1e093ba2eaa48f1d5756ffcb', 'hex'),
+            'hex'
+          )
+        )
+      ).toBe('0xbdde6c4f63a50b23c8bd8409fe4d9cfb33c619de')
+    })
+  })
+})

package/src/keylessBackup/encryption.ts

@@ -0,0 +1,121 @@
+import * as secp from '@noble/secp256k1'
+import crypto from 'crypto'
+import hkdf from 'futoin-hkdf'
+import { Hex, fromBytes } from 'viem'
+import { privateKeyToAccount } from 'viem/accounts'
+
+/**
+ * Derives a key using the HKDF method from two key shares.
+ *
+ * @param {string} keyshare1 - The first keyshare in utf8 format.
+ * @param {string} keyshare2 - The second keyshare in utf8 format.
+ * @param {number} outputKeyBytes - The number of bytes to output. Defaults to 32.
+ * @returns {Buffer} A derived key as a Buffer.
+ */
+export function deriveKeyFromKeyShares(
+  keyshare1: Buffer,
+  keyshare2: Buffer,
+  outputKeyBytes: number = 32
+): Buffer {
+  // sanity check
+  if (keyshare1.length < 16 || keyshare2.length < 16) {
+    throw new Error('Key shares must be at least 16 bytes long')
+  }
+
+  // Combining the keyshares
+  const salt = 'd922444e-ef5d-4921-b19d-ceec3780e704'
+  const info = 'valora.keylessBackup.deriveKeyFromKeyShares'
+  const combinedKeyShares = Buffer.concat([
+    keyshare1,
+    hkdf(keyshare2, 32, {
+      // per advice from @nategraf: [using 32 here] gives the maximum available security available with SHA-256, and prevents a bit of wasted work if the requested output is longer than 32 bytes
+      salt,
+      info,
+      hash: 'SHA-256',
+    }),
+  ])
+
+  return hkdf(combinedKeyShares, outputKeyBytes, {
+    salt,
+    info,
+    hash: 'SHA-256',
+  })
+}
+
+/**
+ * Derives a 256-bit key using the HKDF method from two key shares then derives a secp256k1 pair from that.
+ *
+ * @param {string} keyshare1 - The first keyshare in utf8 format.
+ * @param {string} keyshare2 - The second keyshare in utf8 format.
+ */
+export function getSecp256K1KeyPair(
+  keyshare1: Buffer,
+  keyshare2: Buffer
+): { privateKey: Hex; publicKey: Hex } {
+  const derivedKey = deriveKeyFromKeyShares(keyshare1, keyshare2, 48) // 40 is the minimum for hashToPrivateKey
+  const privateKey = secp.utils.hashToPrivateKey(derivedKey)
+  const publicKey = secp.getPublicKey(privateKey, true)
+  return { privateKey: fromBytes(privateKey, 'hex'), publicKey: fromBytes(publicKey, 'hex') }
+}
+
+export function getWalletAddressFromPrivateKey(privateKey: Hex) {
+  return privateKeyToAccount(privateKey).address.toLowerCase()
+}
+
+/**
+ * Encrypts a passphrase using AES-256-GCM encryption with a key derived from two key shares.
+ *
+ * @param {string} keyshare1 - The first keyshare used to derive the encryption key.
+ * @param {string} keyshare2 - The second keyshare used to derive the encryption key.
+ * @param {string} passphrase - The passphrase to encrypt.
+ * @returns {string} The encrypted passphrase, formatted as `nonce:encrypted:authTag`, all parts base64 encoded.
+ */
+export function encryptPassphrase(
+  keyshare1: Buffer,
+  keyshare2: Buffer,
+  passphrase: string
+): string {
+  const derivedKey = deriveKeyFromKeyShares(keyshare1, keyshare2)
+  const nonce = crypto.randomBytes(12) // GCM recommends a 12-byte nonce
+  const cipher = crypto.createCipheriv('aes-256-gcm', derivedKey, nonce)
+
+  let encrypted = cipher.update(passphrase, 'utf8', 'base64')
+  encrypted += cipher.final('base64')
+  const authTag = cipher.getAuthTag()
+
+  return `${nonce.toString('base64')}:${encrypted}:${authTag.toString('base64')}`
+}
+
+/**
+ * Decrypts an encrypted passphrase using AES-256-GCM decryption with a key derived from two key shares.
+ *
+ * @param {string} keyshare1 - The first keyshare used to derive the decryption key.
+ * @param {string} keyshare2 - The second keyshare used to derive the decryption key.
+ * @param {string} encryptedData - The data to decrypt, formatted as `nonce:encrypted:authTag`, all parts base64 encoded.
+ * @returns {string} The decrypted passphrase.
+ */
+export function decryptPassphrase(
+  keyshare1: Buffer,
+  keyshare2: Buffer,
+  encryptedData: string
+): string {
+  const derivedKey = deriveKeyFromKeyShares(keyshare1, keyshare2)
+  const [nonceBase64, encrypted, authTagBase64OrSerializedArrayBuffer] = encryptedData.split(':')
+  const nonce = Buffer.from(nonceBase64, 'base64')
+  // There was a bug with the initial switch to react-native-quick-crypto,
+  // `cipher.getAuthTag()` was returning an ArrayBuffer instead of a Buffer
+  // so the auth tag in the encrypted data wasn't in base64 format, but just a serialized array buffer (e.g. "1,2,3,4")
+  let authTag: Buffer
+  if (authTagBase64OrSerializedArrayBuffer.split(',').length > 1) {
+    authTag = Buffer.from(authTagBase64OrSerializedArrayBuffer.split(',').map(Number))
+  } else {
+    authTag = Buffer.from(authTagBase64OrSerializedArrayBuffer, 'base64')
+  }
+  const decipher = crypto.createDecipheriv('aes-256-gcm', derivedKey, nonce)
+  decipher.setAuthTag(authTag)
+
+  let decrypted = decipher.update(encrypted, 'base64', 'utf8')
+  decrypted += decipher.final('utf8')
+
+  return decrypted
+}

package/src/keylessBackup/hooks.ts

@@ -0,0 +1,179 @@
+import { useRef, useState } from 'react'
+import { useAsync } from 'react-async-hook'
+import { Platform } from 'react-native'
+import DeviceInfo from 'react-native-device-info'
+import { showError } from 'src/alert/actions'
+import AppAnalytics from 'src/analytics/AppAnalytics'
+import { KeylessBackupEvents } from 'src/analytics/Events'
+import { ErrorMessages } from 'src/app/ErrorMessages'
+import { appKeyshareIssued } from 'src/keylessBackup/slice'
+import { KeylessBackupFlow, KeylessBackupOrigin } from 'src/keylessBackup/types'
+import { RecaptchaActionType, RecaptchaService } from 'src/recaptcha/RecaptchaService'
+import { useDispatch } from 'src/redux/hooks'
+import Logger from 'src/utils/Logger'
+import { PhoneNumberVerificationStatus } from 'src/verify/hooks'
+import networkConfig from 'src/web3/networkConfig'
+
+const TAG = 'keylessBackup/hooks'
+
+export function useVerifyPhoneNumber(
+  phoneNumber: string,
+  keylessBackupFlow: KeylessBackupFlow,
+  origin: KeylessBackupOrigin
+) {
+  const verificationCodeRequested = useRef(false)
+
+  const dispatch = useDispatch()
+
+  const [verificationStatus, setVerificationStatus] = useState(PhoneNumberVerificationStatus.NONE)
+  const [issueCodeCompleted, setIssueCodeCompleted] = useState(false)
+  const [smsCode, setSmsCode] = useState('')
+
+  // Async hook to make request to get sms code
+  useAsync(
+    async () => {
+      if (verificationCodeRequested.current) {
+        // verificationCodeRequested prevents the verification request from
+        // being fired multiple times, due to hot reloading during development
+        Logger.debug(
+          `${TAG}/issueSmsCode`,
+          'Skipping request to issueSmsCode since a request was already initiated'
+        )
+        return
+      }
+
+      AppAnalytics.track(KeylessBackupEvents.cab_issue_sms_code_start, {
+        keylessBackupFlow,
+        origin,
+      })
+      Logger.debug(`${TAG}/issueSmsCode`, 'Initiating request')
+
+      let recaptchaToken: string | null = null
+      if (RecaptchaService.isEnabled()) {
+        try {
+          recaptchaToken = await RecaptchaService.getToken(RecaptchaActionType.KEYLESS_BACKUP)
+          Logger.debug(`${TAG}/issueSmsCode`, 'Got reCAPTCHA token')
+        } catch (error) {
+          // Allow the flow to continue if there is an error since the CAB restore flow is critical
+          Logger.error(
+            `${TAG}/issueSmsCode`,
+            'Failed to get reCAPTCHA token, proceeding without it',
+            error
+          )
+        }
+      }
+
+      const response = await fetch(networkConfig.cabIssueSmsCodeUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          phoneNumber,
+          clientPlatform: Platform.OS,
+          clientBundleId: DeviceInfo.getBundleId(),
+          recaptchaToken: recaptchaToken ?? undefined,
+        }),
+      })
+      if (response.ok) {
+        return response
+      } else {
+        throw new Error(await response.text())
+      }
+    },
+    [phoneNumber],
+    {
+      onError: (error: Error) => {
+        AppAnalytics.track(KeylessBackupEvents.cab_issue_sms_code_error, {
+          keylessBackupFlow,
+          origin,
+        })
+        Logger.debug(`${TAG}/issueSmsCode`, 'Received error from issueSmsCode', error)
+        dispatch(showError(ErrorMessages.PHONE_NUMBER_VERIFICATION_FAILURE))
+      },
+      onSuccess: async (response?: Response) => {
+        if (!response) {
+          return
+        }
+        setIssueCodeCompleted(true)
+        verificationCodeRequested.current = true
+
+        AppAnalytics.track(KeylessBackupEvents.cab_issue_sms_code_success, {
+          keylessBackupFlow,
+          origin,
+        })
+        Logger.debug(`${TAG}/issueSmsCode`, 'Successfully issued sms code')
+      },
+    }
+  )
+
+  // Async hook to post code and get keyshare once user types in code
+  useAsync(
+    async () => {
+      // add issueCodeCompleted to this hook, in case the SMS is received by the
+      // user before the successful response from issueSmsCode
+      if (!smsCode || !issueCodeCompleted) {
+        return
+      }
+
+      AppAnalytics.track(KeylessBackupEvents.cab_issue_app_keyshare_start, {
+        keylessBackupFlow,
+        origin,
+      })
+      Logger.debug(
+        `${TAG}/issueAppKeyshare`,
+        'Initiating request to issueAppKeyshare to validate code and issue key share'
+      )
+
+      const response = await fetch(networkConfig.cabIssueAppKeyshareUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          phoneNumber,
+          smsCode,
+          clientPlatform: Platform.OS,
+          clientBundleId: DeviceInfo.getBundleId(),
+        }),
+      })
+
+      if (response.ok) {
+        return response
+      } else {
+        throw new Error(await response.text())
+      }
+    },
+    [smsCode, phoneNumber, issueCodeCompleted],
+    {
+      onSuccess: async (response?: Response) => {
+        if (!response) {
+          return
+        }
+
+        const { keyshare, token } = await response.json()
+        AppAnalytics.track(KeylessBackupEvents.cab_issue_app_keyshare_success, {
+          keylessBackupFlow,
+          origin,
+        })
+        Logger.debug(`${TAG}/issueAppKeyShare`, 'Successfully verified sms code and got keyshare')
+        setVerificationStatus(PhoneNumberVerificationStatus.SUCCESSFUL)
+        dispatch(appKeyshareIssued({ keyshare, keylessBackupFlow, origin, jwt: token }))
+      },
+      onError: (error: Error) => {
+        AppAnalytics.track(KeylessBackupEvents.cab_issue_app_keyshare_error, {
+          keylessBackupFlow,
+          origin,
+        })
+        Logger.debug(`${TAG}/issueAppKeyShare`, `Received error from issueAppKeyShare`, error)
+        setVerificationStatus(PhoneNumberVerificationStatus.FAILED)
+        setSmsCode('')
+      },
+    }
+  )
+
+  return {
+    setSmsCode,
+    verificationStatus,
+  }
+}