Improved trusted name matching function with sources support

Author: apaillier-ledger

src_bagl/ui_flow_signTx.c

@@ -268,7 +268,9 @@ void ux_approve_tx(bool fromPlugin) {
 #ifdef HAVE_TRUSTED_NAME
         uint64_t chain_id = get_tx_chain_id();
         e_name_type type = TN_TYPE_ACCOUNT;
-        if (has_trusted_name(1, &type, &chain_id, tmpContent.txContent.destination)) {
+        e_name_source source = TN_SOURCE_ENS;
+        if (get_trusted_name(1, &type, 1, &source, &chain_id, tmpContent.txContent.destination) !=
+            NULL) {
             ux_approval_tx_flow[step++] = &ux_trusted_name_step;
             if (N_storage.verbose_trusted_name) {
                 ux_approval_tx_flow[step++] = &ux_approval_to_step;

src_features/provideTrustedName/cmd_provide_trusted_name.c

@@ -110,10 +110,56 @@ static s_tlv_payload g_tlv_payload = {0};
 static s_trusted_name_info g_trusted_name_info = {0};
 char g_trusted_name[TRUSTED_NAME_MAX_LENGTH + 1];
 
+static bool matching_type(e_name_type type, uint8_t type_count, const e_name_type *types) {
+    for (int i = 0; i < type_count; ++i) {
+        if (type == types[i]) return true;
+    }
+    return false;
+}
+
+static bool matching_source(e_name_source source,
+                            uint8_t source_count,
+                            const e_name_source *sources) {
+    for (int i = 0; i < source_count; ++i) {
+        if (source == sources[i]) return true;
+    }
+    return false;
+}
+
+static bool matching_trusted_name(const s_trusted_name_info *trusted_name,
+                                  uint8_t type_count,
+                                  const e_name_type *types,
+                                  uint8_t source_count,
+                                  const e_name_source *sources,
+                                  const uint64_t *chain_id,
+                                  const uint8_t *addr) {
+    switch (trusted_name->struct_version) {
+        case 1:
+            if (!matching_type(TN_TYPE_ACCOUNT, type_count, types)) {
+                return false;
+            }
+            if (!chain_is_ethereum_compatible(chain_id)) {
+                return false;
+            }
+            break;
+        case 2:
+            if (!matching_type(trusted_name->name_type, type_count, types)) {
+                return false;
+            }
+            if (!matching_source(trusted_name->name_source, source_count, sources)) {
+                return false;
+            }
+            if (*chain_id != trusted_name->chain_id) {
+                return false;
+            }
+            break;
+    }
+    return memcmp(addr, trusted_name->addr, ADDRESS_LENGTH) == 0;
+}
+
 /**
  * Checks if a trusted name matches the given parameters
  *
- * Does not care about the trusted name source for now.
  * Always wipes the content of \ref g_trusted_name_info
  *
  * @param[in] types_count number of given trusted name types
@@ -122,36 +168,23 @@ char g_trusted_name[TRUSTED_NAME_MAX_LENGTH + 1];
  * @param[in] addr given address
  * @return whether there is or not
  */
-bool has_trusted_name(uint8_t types_count,
-                      const e_name_type *types,
-                      const uint64_t *chain_id,
-                      const uint8_t *addr) {
-    bool ret = false;
+const char *get_trusted_name(uint8_t type_count,
+                             const e_name_type *types,
+                             uint8_t source_count,
+                             const e_name_source *sources,
+                             const uint64_t *chain_id,
+                             const uint8_t *addr) {
+    const char *ret = NULL;
 
     if (g_trusted_name_info.rcv_flags != 0) {
-        for (int i = 0; i < types_count; ++i) {
-            switch (g_trusted_name_info.struct_version) {
-                case 1:
-                    if (types[i] == TN_TYPE_ACCOUNT) {
-                        // Check if chain ID is known to be Ethereum-compatible (same derivation
-                        // path)
-                        if ((chain_is_ethereum_compatible(chain_id)) &&
-                            (memcmp(addr, g_trusted_name_info.addr, ADDRESS_LENGTH) == 0)) {
-                            ret = true;
-                        }
-                    }
-                    break;
-                case 2:
-                    if (types[i] == g_trusted_name_info.name_type) {
-                        if (*chain_id == g_trusted_name_info.chain_id) {
-                            ret = true;
-                        }
-                    }
-                    break;
-                default:
-                    ret = false;
-            }
-            if (ret) break;
+        if (matching_trusted_name(&g_trusted_name_info,
+                                  type_count,
+                                  types,
+                                  source_count,
+                                  sources,
+                                  chain_id,
+                                  addr)) {
+            ret = g_trusted_name_info.name;
         }
         explicit_bzero(&g_trusted_name_info, sizeof(g_trusted_name_info));
     }

src_features/provideTrustedName/trusted_name.h

@@ -28,10 +28,12 @@ typedef enum {
     TN_SOURCE_COUNT,
 } e_name_source;
 
-bool has_trusted_name(uint8_t types_count,
-                      const e_name_type *types,
-                      const uint64_t *chain_id,
-                      const uint8_t *addr);
+const char *get_trusted_name(uint8_t type_count,
+                             const e_name_type *types,
+                             uint8_t source_count,
+                             const e_name_source *sources,
+                             const uint64_t *chain_id,
+                             const uint8_t *addr);
 uint16_t handle_provide_trusted_name(uint8_t p1, const uint8_t *data, uint8_t length);
 
 extern char g_trusted_name[TRUSTED_NAME_MAX_LENGTH + 1];

src_features/signMessageEIP712/ui_logic.c

@@ -543,7 +543,7 @@ static bool ui_712_format_trusted_name(const uint8_t *data, uint8_t length) {
         }
         types_bak >>= 1;
     }
-    if (has_trusted_name(types_count, types, &eip712_context->chain_id, data)) {
+    if (get_trusted_name(types_count, types, 0, NULL, &eip712_context->chain_id, data) != NULL) {
         strlcpy(strings.tmp.tmp, g_trusted_name, sizeof(strings.tmp.tmp));
     }
     return true;

src_nbgl/ui_approve_tx.c

@@ -149,8 +149,9 @@ static uint8_t setTagValuePairs(void) {
 #ifdef HAVE_TRUSTED_NAME
         uint64_t chain_id = get_tx_chain_id();
         e_name_type type = TN_TYPE_ACCOUNT;
+        e_name_source source = TN_SOURCE_ENS;
         tx_approval_context.trusted_name_match =
-            has_trusted_name(1, &type, &chain_id, tmpContent.txContent.destination);
+            get_trusted_name(1, &type, 1, &source, &chain_id, tmpContent.txContent.destination);
         if (tx_approval_context.trusted_name_match) {
             pairs[nbPairs].item = "To (domain)";
             pairs[nbPairs].value = g_trusted_name;