feat(core): Handle wallet collision while creation

common/Firewall/sec_flash.c

@@ -73,7 +73,7 @@
 #include "utils.h"
 
 #define SEC_FLASH_STRUCT_TLV_SIZE                                              \
-  (6 + 3 + (MAX_WALLETS_ALLOWED * (9 + sizeof(Wallet_Share_Data))) + 3 +       \
+  (6 + 3 + (MAX_WALLETS_ALLOWED * (12 + sizeof(Wallet_Share_Data))) + 3 +      \
    (MAX_KEYSTORE_ENTRY * ((4 * 3) + sizeof(Card_Keystore))))
 
 #define FLASH_WRITE_PERM_STRUCTURE_SIZE sizeof(Flash_Perm_Struct) / 4
@@ -85,6 +85,7 @@ typedef enum Sec_Flash_tlv_tags {
   TAG_SEC_FLASH_WALLET_SHARE_STRUCT = 0x11,
   TAG_SEC_FLASH_WALLET_ID = 0x12,
   TAG_SEC_FLASH_WALLET_SHARE = 0x13,
+  TAG_SEC_FLASH_WALLET_NONCE = 0x14,
 
   TAG_SEC_FLASH_KEYSTORE = 0x30,
   TAG_SEC_FLASH_KEYSTORE_USED = 0x31,
@@ -551,6 +552,11 @@ static void serialize_sec_fs_wallet(uint8_t *array,
                    TAG_SEC_FLASH_WALLET_SHARE,
                    BLOCK_SIZE,
                    sec_fs->wallet_share_data[wallet_index].wallet_share);
+    fill_flash_tlv(array,
+                   starting_index,
+                   TAG_SEC_FLASH_WALLET_NONCE,
+                   PADDED_NONCE_SIZE,
+                   sec_fs->wallet_share_data[wallet_index].wallet_nonce);
 
     array[len_index] = (*starting_index) - len_index - 2;
     array[len_index + 1] = ((*starting_index) - len_index - 2) >> 8;
@@ -710,6 +716,11 @@ static void deserialize_sec_fs_wallet(Wallet_Share_Data *wallet_share_data,
         break;
       }
 
+      case TAG_SEC_FLASH_WALLET_NONCE: {
+        memcpy(wallet_share_data->wallet_nonce, tlv + index + 2, size);
+        break;
+      }
+
       case TAG_SEC_FLASH_WALLET_ID: {
         memcpy(wallet_share_data->wallet_id, tlv + index + 2, size);
         break;

common/Firewall/sec_flash.h

@@ -66,6 +66,8 @@ typedef struct Wallet_share {
   uint8_t wallet_id[WALLET_ID_SIZE];    ///< Wallet ID derived from seed
   uint8_t
       wallet_share[BLOCK_SIZE];    ///< Device's (5th) share derived from seed
+  uint8_t wallet_nonce[PADDED_NONCE_SIZE];    ///< Wallet's nonce including IV
+                                              ///< and version data
 } Wallet_Share_Data;
 #pragma pack(pop)
 

common/coin_support/wallet.c

@@ -114,7 +114,8 @@ bool encrypt_shares() {
         &ctx, wallet_shamir_data.mnemonic_shares[i], share, BLOCK_SIZE);
     chacha20poly1305_finish(
         &ctx,
-        (uint8_t *)(wallet_shamir_data.share_encryption_data[i] + NONCE_SIZE));
+        (uint8_t *)(wallet_shamir_data.share_encryption_data[i] +
+                    PADDED_NONCE_SIZE));
     memcpy(wallet_shamir_data.mnemonic_shares[i], share, BLOCK_SIZE);
   }
 
@@ -134,7 +135,8 @@ bool decrypt_shares() {
         &ctx, wallet_shamir_data.mnemonic_shares[i], share, BLOCK_SIZE);
     chacha20poly1305_finish(
         &ctx,
-        (uint8_t *)(wallet_shamir_data.share_encryption_data[i] + NONCE_SIZE));
+        (uint8_t *)(wallet_shamir_data.share_encryption_data[i] +
+                    PADDED_NONCE_SIZE));
     // TODO: Add mac comparison for decryption verification
     memcpy(wallet_shamir_data.mnemonic_shares[i], share, BLOCK_SIZE);
   }

common/coin_support/wallet.h

@@ -28,7 +28,10 @@
    CARD_VERSION_GIT_REV_SIZE)
 
 #define BLOCK_SIZE 32
-#define NONCE_SIZE 16
+#define NONCE_SIZE 12
+#define PADDED_NONCE_SIZE                                                      \
+  NONCE_SIZE + 4    // 3 bytes as RFU and LSB as version byte
+#define HASH_SIZE 32
 #define WALLET_MAC_SIZE 16
 #define PIN_SHARE_SIZE 80
 #define CHECKSUM_SIZE 4
@@ -115,7 +118,7 @@ typedef struct Wallet {
   uint8_t wallet_info;
   uint8_t password_double_hash[BLOCK_SIZE];
 
-  uint8_t wallet_share_with_mac_and_nonce[BLOCK_SIZE + NONCE_SIZE +
+  uint8_t wallet_share_with_mac_and_nonce[BLOCK_SIZE + PADDED_NONCE_SIZE +
                                           WALLET_MAC_SIZE];
   uint8_t arbitrary_data_share[512];
 
@@ -156,7 +159,7 @@ typedef struct Wallet_shamir_data {
   };
   uint8_t share_x_coords[TOTAL_NUMBER_OF_SHARES];
   uint8_t share_encryption_data[TOTAL_NUMBER_OF_SHARES]
-                               [NONCE_SIZE + WALLET_MAC_SIZE];
+                               [PADDED_NONCE_SIZE + WALLET_MAC_SIZE];
 } Wallet_shamir_data;
 #pragma pack(pop)
 

common/interfaces/card_interface/apdu.c

@@ -217,7 +217,7 @@ uint16_t create_apdu_add_wallet(const struct Wallet *wallet, uint8_t apdu[]) {
   fill_tlv(apdu,
            &index,
            INS_WALLET_SHARE,
-           BLOCK_SIZE + NONCE_SIZE + WALLET_MAC_SIZE,
+           BLOCK_SIZE + PADDED_NONCE_SIZE + WALLET_MAC_SIZE,
            wallet);
   fill_tlv(apdu, &index, INS_STRUCTURE_CHECKSUM, CHECKSUM_SIZE, wallet);
   fill_tlv(apdu, &index, INS_MIN_NO_OF_SHARES, 1, wallet);

common/interfaces/flash_interface/flash_api.c

@@ -160,7 +160,8 @@ int add_wallet_to_flash(const Flash_Wallet *fwallet, uint32_t *index_OUT) {
 
 int add_wallet_share_to_sec_flash(const Flash_Wallet *fwallet,
                                   uint32_t *index_OUT,
-                                  const uint8_t *wallet_share) {
+                                  const uint8_t *wallet_share,
+                                  const uint8_t *wallet_nonce) {
   get_flash_ram_instance();    // to load
   get_sec_flash_ram_instance();
   if (flash_ram_instance.wallet_count == MAX_WALLETS_ALLOWED)
@@ -190,6 +191,9 @@ int add_wallet_share_to_sec_flash(const Flash_Wallet *fwallet,
   memcpy(sec_flash_instance.wallet_share_data[*index_OUT].wallet_share,
          wallet_share,
          BLOCK_SIZE);
+  memcpy(sec_flash_instance.wallet_share_data[*index_OUT].wallet_nonce,
+         wallet_nonce,
+         PADDED_NONCE_SIZE);
   sec_flash_struct_save();
   return SUCCESS_;
 }
@@ -230,7 +234,8 @@ int put_wallet_flash(const uint8_t index, const Flash_Wallet *wallet) {
 }
 
 int put_wallet_share_sec_flash(const uint8_t index,
-                               const uint8_t *wallet_share) {
+                               const uint8_t *wallet_share,
+                               const uint8_t *wallet_nonce) {
   get_flash_ram_instance();    // to load
   get_sec_flash_ram_instance();
   if (index >= MAX_WALLETS_ALLOWED)
@@ -246,6 +251,9 @@ int put_wallet_share_sec_flash(const uint8_t index,
   memcpy(sec_flash_instance.wallet_share_data[index].wallet_share,
          wallet_share,
          BLOCK_SIZE);
+  memcpy(sec_flash_instance.wallet_share_data[index].wallet_nonce,
+         wallet_nonce,
+         PADDED_NONCE_SIZE);
   sec_flash_struct_save();
   flash_ram_instance.wallets[index].state = VALID_WALLET;
   flash_struct_save();
@@ -531,6 +539,42 @@ int get_flash_wallet_share_by_name(const char *name, uint8_t *wallet_share) {
   return DOESNT_EXIST;
 }
 
+int get_flash_wallet_nonce_by_name(const char *name, uint8_t *wallet_nonce) {
+  ASSERT(name != NULL);
+  ASSERT(wallet_nonce != NULL);
+
+  get_flash_ram_instance();    // to load
+  get_sec_flash_ram_instance();
+  size_t name_len = strnlen(name, NAME_SIZE);
+  if (name_len == 0 || name_len >= NAME_SIZE)
+    return INVALID_ARGUMENT;
+  uint8_t walletIndex = 0;
+  for (; walletIndex < MAX_WALLETS_ALLOWED; walletIndex++) {
+    if (!_wallet_is_filled(walletIndex))
+      continue;
+    if (!strcmp(
+            (const char *)flash_ram_instance.wallets[walletIndex].wallet_name,
+            name)) {
+      if (is_wallet_share_not_present(walletIndex))
+        return DOESNT_EXIST;
+      for (int i = 0; i < WALLET_ID_SIZE; i++) {
+        if (flash_ram_instance.wallets[walletIndex].wallet_id[i] !=
+            sec_flash_instance.wallet_share_data[walletIndex].wallet_id[i]) {
+          flash_ram_instance.wallets[walletIndex].state =
+              VALID_WALLET_WITHOUT_DEVICE_SHARE;
+          flash_struct_save();
+          return DOESNT_EXIST;
+        }
+      }
+      memcpy(wallet_nonce,
+             sec_flash_instance.wallet_share_data[walletIndex].wallet_nonce,
+             BLOCK_SIZE);
+      return SUCCESS_;
+    }
+  }
+  return DOESNT_EXIST;
+}
+
 /**
  * @brief Tells if wallet is in partial state
  *
@@ -663,7 +707,7 @@ int set_wallet_locked(const char *wallet_name, uint8_t encoded_card_number) {
   flash_wallet->is_wallet_locked = true;
   memzero(&(flash_wallet->challenge), sizeof(flash_wallet->challenge));
   flash_wallet->challenge.card_locked = encoded_card_number;
-  memset(flash_wallet->challenge.nonce, 0xFF, NONCE_SIZE);
+  memset(flash_wallet->challenge.nonce, 0xFF, PADDED_NONCE_SIZE);
   flash_struct_save();
   return SUCCESS;
 }
@@ -743,7 +787,7 @@ int update_wallet_locked_flash(const char *name, const bool is_wallet_locked) {
     flash_wallet->challenge.time_to_unlock_in_secs = 0;
 
     // Reset nonce to 0xFF as challenge is not fetched
-    memset(flash_wallet->challenge.nonce, 0xFF, NONCE_SIZE);
+    memset(flash_wallet->challenge.nonce, 0xFF, PADDED_NONCE_SIZE);
   } else {
     // Wallet unlocked, reset challenge
     memzero(&(flash_wallet->challenge), sizeof(flash_wallet->challenge));

common/interfaces/flash_interface/flash_api.h

@@ -64,6 +64,8 @@ int add_wallet_to_flash(const Flash_Wallet *wallet, uint32_t *index_OUT);
  *
  * @param[in] fwallet a constant reference to an object of type Flash_Wallet
  * @param[out] index_OUT index at which share entry is made
+ * @param[in] wallet_share The 5th share of wallet to be written on device
+ * @param[in] wallet_nonce Wallet nonce common for all shares
  * @return SUCCESS,	MEMORY_OVERFLOW, INVALID_ARGUMENT, ALREADY_EXISTS
  * @retval SUCCESS Wallet share written to firewall region
  * @retval MEMORY_OVERFLOW in case of no empty slots
@@ -72,8 +74,8 @@ int add_wallet_to_flash(const Flash_Wallet *wallet, uint32_t *index_OUT);
  */
 int add_wallet_share_to_sec_flash(const Flash_Wallet *fwallet,
                                   uint32_t *index_OUT,
-                                  const uint8_t *wallet_share);
-
+                                  const uint8_t *wallet_share,
+                                  const uint8_t *wallet_nonce);
 /**
  * @brief Deletes a wallet from flash
  *
@@ -172,7 +174,9 @@ int put_wallet_flash(uint8_t index, const Flash_Wallet *wallet);
  * @retval INVALID_ARGUMENT non-existent wallet reference or wallet_index >=
  * MAX_WALLETS_ALLOWED
  */
-int put_wallet_share_sec_flash(uint8_t index, const uint8_t *wallet_share);
+int put_wallet_share_sec_flash(uint8_t index,
+                               const uint8_t *wallet_share,
+                               const uint8_t *wallet_nonce);
 
 /**
  * @brief Outputs the index of the wallet with given name
@@ -261,6 +265,21 @@ int get_flash_wallet_by_name(const char *name, Flash_Wallet **flash_wallet_OUT);
  */
 int get_flash_wallet_share_by_name(const char *name, uint8_t *wallet_share);
 
+/**
+ * Retrieves the wallet nonce associated with a given name from flash memory.
+ *
+ * @param name A pointer to a character array representing the name of the
+ * wallet.
+ * @param wallet_nonce A pointer to a uint8_t array where the wallet nonce will
+ * be stored.
+ *
+ * @return SUCCESS, INVALID_ARGUMENT, DOESNT_EXIST
+ * @retval SUCCESS Wallet found & wallet share returned
+ * @retval INVALID_ARGUMENT Passed name is invalid
+ * @retval DOESNT_EXIST Wallet does not exist with given name
+ */
+int get_flash_wallet_nonce_by_name(const char *name, uint8_t *wallet_nonce);
+
 /**
  * @brief Update the card states for the wallet at specified index (on deletion
  * of the wallet from the given card number)

common/interfaces/flash_interface/flash_struct.h

@@ -87,7 +87,7 @@ typedef struct Flash_Wallet {
   uint8_t wallet_name[NAME_SIZE];
   uint8_t wallet_info;
   uint8_t
-      wallet_share_with_mac_and_nonce[BLOCK_SIZE + NONCE_SIZE +
+      wallet_share_with_mac_and_nonce[BLOCK_SIZE + PADDED_NONCE_SIZE +
                                       WALLET_MAC_SIZE];    // does not include
                                                            // MAC and nonce
 

common/libraries/util/wallet_utilities.c

@@ -177,4 +177,19 @@ Card_Data_errors_t validate_wallet(Wallet *wallet) {
   if (is_zero(wallet->wallet_id, sizeof(wallet->wallet_id)))
     return INVALID_WALLET_ID;
   return VALID_DATA;
+}
+
+void derive_wallet_nonce(
+    uint8_t share_encryption_data[TOTAL_NUMBER_OF_SHARES]
+                                 [PADDED_NONCE_SIZE + WALLET_MAC_SIZE]) {
+  uint8_t wallet_nonce[NONCE_SIZE] = {0};
+  random_generate(wallet_nonce, 12);
+
+  for (int i = 0; i < TOTAL_NUMBER_OF_SHARES; i++) {
+    // First 12 bytes of share_encryption_data are wallet nonce.
+    memcpy(share_encryption_data[i], wallet_nonce, 12);
+    // Skip next 3 bytes as RFU
+    // Version byte
+    share_encryption_data[i][15] = 0x01;
+  }
 }

common/libraries/util/wallet_utilities.h

@@ -113,4 +113,17 @@ void derive_wallet_key(uint8_t key[KEY_SIZE], const char *mnemonics);
  */
 Card_Data_errors_t validate_wallet(Wallet *wallet);
 
+/**
+ * @brief The function `derive_wallet_nonce` generates a random wallet nonce and
+ * assigns it to each share. On the share_encryption_data 2-D array, the wallet
+ * nonce is stored at the first 12 bytes and next 4 bytes contain RFU bytes + 1
+ * version byte.
+ *
+ * @param share_encryption_data This 2-D array is used to store the share
+ * encryption data for each share.
+ */
+void derive_wallet_nonce(
+    uint8_t share_encryption_data[TOTAL_NUMBER_OF_SHARES]
+                                 [PADDED_NONCE_SIZE + WALLET_MAC_SIZE]);
+
 #endif

src/card_operations/card_fetch_share.c

@@ -117,7 +117,7 @@ static void _handle_retrieve_wallet_success(uint8_t xcor) {
            BLOCK_SIZE);
   memcpy(wallet_shamir_data.share_encryption_data[xcor],
          wallet.wallet_share_with_mac_and_nonce + BLOCK_SIZE,
-         NONCE_SIZE + WALLET_MAC_SIZE);
+         PADDED_NONCE_SIZE + WALLET_MAC_SIZE);
   memzero(wallet.arbitrary_data_share, sizeof(wallet.arbitrary_data_share));
   memzero(wallet.wallet_share_with_mac_and_nonce,
           sizeof(wallet.wallet_share_with_mac_and_nonce));

src/card_operations/card_read_verify_shares.c

@@ -117,7 +117,7 @@ static void read_card_share_post_process(uint8_t xcor) {
            BLOCK_SIZE);
   memcpy(wallet_shamir_data.share_encryption_data[xcor],
          wallet.wallet_share_with_mac_and_nonce + BLOCK_SIZE,
-         NONCE_SIZE + WALLET_MAC_SIZE);
+         PADDED_NONCE_SIZE + WALLET_MAC_SIZE);
   memzero(wallet.arbitrary_data_share, sizeof(wallet.arbitrary_data_share));
   memzero(wallet.wallet_share_with_mac_and_nonce,
           sizeof(wallet.wallet_share_with_mac_and_nonce));

src/card_operations/card_write_share.c

@@ -124,7 +124,7 @@ static void write_card_pre_process(uint8_t card_num) {
            BLOCK_SIZE);
   memcpy(wallet.wallet_share_with_mac_and_nonce + BLOCK_SIZE,
          wallet_shamir_data.share_encryption_data[card_num - 1],
-         NONCE_SIZE + WALLET_MAC_SIZE);
+         PADDED_NONCE_SIZE + WALLET_MAC_SIZE);
   return;
 }
 

src/level_four/core/controller/receive_transaction_controller_eth.c

@@ -137,7 +137,7 @@ void receive_transaction_controller_eth() {
                                      wallet_shamir_data.mnemonic_shares[1]);
       memcpy(wallet_shamir_data.share_encryption_data[1],
              wallet_shamir_data.share_encryption_data[0],
-             NONCE_SIZE + WALLET_MAC_SIZE);
+             PADDED_NONCE_SIZE + WALLET_MAC_SIZE);
       flow_level.level_three = RECV_TXN_DERIVE_ADD_SCREEN_ETH;
       break;
 

src/level_four/core/controller/receive_transaction_controller_near.c

@@ -171,7 +171,7 @@ void receive_transaction_controller_near() {
                                      wallet_shamir_data.mnemonic_shares[1]);
       memcpy(wallet_shamir_data.share_encryption_data[1],
              wallet_shamir_data.share_encryption_data[0],
-             NONCE_SIZE + WALLET_MAC_SIZE);
+             PADDED_NONCE_SIZE + WALLET_MAC_SIZE);
       flow_level.level_three = RECV_TXN_DERIVE_ADD_SCREEN_NEAR;
       break;
 

src/level_four/core/controller/receive_transaction_controller_solana.c

@@ -133,7 +133,7 @@ void receive_transaction_controller_solana() {
                                      wallet_shamir_data.mnemonic_shares[1]);
       memcpy(wallet_shamir_data.share_encryption_data[1],
              wallet_shamir_data.share_encryption_data[0],
-             NONCE_SIZE + WALLET_MAC_SIZE);
+             PADDED_NONCE_SIZE + WALLET_MAC_SIZE);
       flow_level.level_three = RECV_TXN_DERIVE_ADD_SCREEN_SOLANA;
       break;
 

src/level_four/core/controller/send_transaction_controller_eth.c

@@ -214,7 +214,7 @@ void send_transaction_controller_eth() {
                                      wallet_shamir_data.mnemonic_shares[1]);
       memcpy(wallet_shamir_data.share_encryption_data[1],
              wallet_shamir_data.share_encryption_data[0],
-             NONCE_SIZE + WALLET_MAC_SIZE);
+             PADDED_NONCE_SIZE + WALLET_MAC_SIZE);
       flow_level.level_three = SEND_TXN_SIGN_TXN_ETH;
       break;
 

src/level_four/core/controller/send_transaction_controller_solana.c

@@ -230,7 +230,7 @@ void send_transaction_controller_solana() {
                                      wallet_shamir_data.mnemonic_shares[1]);
       memcpy(wallet_shamir_data.share_encryption_data[1],
              wallet_shamir_data.share_encryption_data[0],
-             NONCE_SIZE + WALLET_MAC_SIZE);
+             PADDED_NONCE_SIZE + WALLET_MAC_SIZE);
       flow_level.level_three = SEND_TXN_SIGN_TXN_SOLANA;
       break;
 

src/level_four/core/controller/sign_message_controller_eth.c

@@ -176,7 +176,7 @@ void sign_message_controller_eth() {
                                      wallet_shamir_data.mnemonic_shares[1]);
       memcpy(wallet_shamir_data.share_encryption_data[1],
              wallet_shamir_data.share_encryption_data[0],
-             NONCE_SIZE + WALLET_MAC_SIZE);
+             PADDED_NONCE_SIZE + WALLET_MAC_SIZE);
       flow_level.level_three = SIGN_MSG_SIGN_TXN_ETH;
       break;