Merge pull request #748 from LedgerHQ/feat/apa/gcs_trusted_name_sender_addr

GCS PARAM_TRUSTED_NAME sender address support

Author: apaillier-ledger

client/src/ledger_app_clients/ethereum/gcs.py

@@ -409,12 +409,19 @@ class ParamTrustedName():
     value: Value
     types: list[TrustedNameType]
     sources: list[TrustedNameSource]
+    sender_addrs: Optional[list[bytes]]
 
-    def __init__(self, version: int, value: Value, types: list[TrustedNameType], sources: list[TrustedNameSource]):
+    def __init__(self,
+                 version: int,
+                 value: Value,
+                 types: list[TrustedNameType],
+                 sources: list[TrustedNameSource],
+                 sender_addrs: Optional[list[bytes]] = None):
         self.version = version
         self.value = value
         self.types = types
         self.sources = sources
+        self.sender_addrs = sender_addrs
 
     def serialize(self) -> bytes:
         payload = bytearray()
@@ -428,6 +435,9 @@ def serialize(self) -> bytes:
         for source in self.sources:
             sources.append(source)
         payload += format_tlv(0x03, sources)
+        if self.sender_addrs is not None:
+            for addr in self.sender_addrs:
+                payload += format_tlv(0x04, addr)
         return payload
 
 

src_features/generic_tx_parser/gtp_param_trusted_name.c

@@ -7,12 +7,15 @@
 #include "gtp_field_table.h"
 #include "utils.h"
 #include "shared_context.h"
+#include "feature_signTx.h"  // get_public_key
+#include "apdu_constants.h"
 
 enum {
     TAG_VERSION = 0x00,
     TAG_VALUE = 0x01,
     TAG_TYPES = 0x02,
     TAG_SOURCES = 0x03,
+    TAG_SENDER_ADDR = 0x04,
 };
 
 static bool handle_version(const s_tlv_data *data, s_param_trusted_name_context *context) {
@@ -49,6 +52,19 @@ static bool handle_sources(const s_tlv_data *data, s_param_trusted_name_context
     return true;
 }
 
+static bool handle_sender_addr(const s_tlv_data *data, s_param_trusted_name_context *context) {
+    if ((data->length > sizeof(context->param->sender_addr)) ||
+        (context->param->sender_addr_count == ARRAYLEN(context->param->sender_addr))) {
+        return false;
+    }
+    buf_shrink_expand(data->value,
+                      data->length,
+                      context->param->sender_addr[context->param->sender_addr_count],
+                      sizeof(context->param->sender_addr[context->param->sender_addr_count]));
+    context->param->sender_addr_count += 1;
+    return true;
+}
+
 bool handle_param_trusted_name_struct(const s_tlv_data *data,
                                       s_param_trusted_name_context *context) {
     bool ret;
@@ -66,6 +82,9 @@ bool handle_param_trusted_name_struct(const s_tlv_data *data,
         case TAG_SOURCES:
             ret = handle_sources(data, context);
             break;
+        case TAG_SENDER_ADDR:
+            ret = handle_sender_addr(data, context);
+            break;
         default:
             PRINTF(TLV_TAG_ERROR_MSG, data->tag);
             ret = false;
@@ -87,6 +106,14 @@ bool format_param_trusted_name(const s_param_trusted_name *param, const char *na
         chain_id = get_tx_chain_id();
         for (int i = 0; i < values.size; ++i) {
             buf_shrink_expand(values.value[i].ptr, values.value[i].length, addr, sizeof(addr));
+            // replace by wallet addr if a match is found
+            for (uint8_t idx = 0; idx < param->sender_addr_count; ++idx) {
+                if (memcmp(addr, param->sender_addr[idx], ADDRESS_LENGTH) == 0) {
+                    ret = get_public_key(addr, sizeof(addr)) == APDU_RESPONSE_OK;
+                    break;
+                }
+            }
+            if (!ret) break;
             if ((tname = get_trusted_name(param->type_count,
                                           param->types,
                                           param->source_count,

src_features/generic_tx_parser/gtp_param_trusted_name.h

@@ -9,13 +9,17 @@
 #include "gtp_value.h"
 #include "trusted_name.h"
 
+#define MAX_SENDER_ADDRS 3
+
 typedef struct {
     uint8_t version;
     s_value value;
     uint8_t type_count;
     e_name_type types[TN_TYPE_COUNT];
     uint8_t source_count;
     e_name_source sources[TN_SOURCE_COUNT];
+    uint8_t sender_addr_count;
+    uint8_t sender_addr[MAX_SENDER_ADDRS][ADDRESS_LENGTH];
 } s_param_trusted_name;
 
 typedef struct {

tests/ragger/snapshots/flex/test_gcs_nft/00001.png

@@ -40,10 +40,12 @@ def test_gcs_nft(firmware: Firmware,
             abi=json.load(file),
             address=None
         )
-    recipient_addr = bytes.fromhex("1111111111111111111111111111111111111111")
+    with app_client.get_public_addr(bip32_path="m/44'/60'/0'/0/0", display=False):
+        pass
+    _, device_addr, _ = ResponseParser.pk_addr(app_client.response().data)
     data = contract.encode_abi("safeBatchTransferFrom", [
-        bytes.fromhex("Dad77910DbDFdE764fC21FCD4E74D71bBACA6D8D"),
-        recipient_addr,
+        bytes.fromhex("1111111111111111111111111111111111111111"),
+        bytes.fromhex("d8da6bf26964af9d7eed9e03e53415d37aa96045"),
         [
             0xff,
             0xffff,
@@ -75,8 +77,8 @@ def test_gcs_nft(firmware: Firmware,
             Field(
                 1,
                 "From",
-                ParamType.RAW,
-                ParamRaw(
+                ParamType.TRUSTED_NAME,
+                ParamTrustedName(
                     1,
                     Value(
                         1,
@@ -88,14 +90,27 @@ def test_gcs_nft(firmware: Firmware,
                                 PathLeaf(PathLeafType.STATIC),
                             ]
                         ),
-                    )
+                    ),
+                    [
+                        TrustedNameType.ACCOUNT,
+                    ],
+                    [
+                        TrustedNameSource.UD,
+                        TrustedNameSource.ENS,
+                        TrustedNameSource.FN,
+                    ],
+                    [
+                        bytes.fromhex("0000000000000000000000000000000000000000"),
+                        bytes.fromhex("1111111111111111111111111111111111111111"),
+                        bytes.fromhex("2222222222222222222222222222222222222222"),
+                    ],
                 )
             ),
             Field(
                 1,
                 "To",
-                ParamType.TRUSTED_NAME,
-                ParamTrustedName(
+                ParamType.RAW,
+                ParamRaw(
                     1,
                     Value(
                         1,
@@ -107,15 +122,7 @@ def test_gcs_nft(firmware: Firmware,
                                 PathLeaf(PathLeafType.STATIC),
                             ]
                         ),
-                    ),
-                    [
-                        TrustedNameType.ACCOUNT,
-                    ],
-                    [
-                        TrustedNameSource.UD,
-                        TrustedNameSource.ENS,
-                        TrustedNameSource.FN,
-                    ],
+                    )
                 )
             ),
             Field(
@@ -205,7 +212,7 @@ def test_gcs_nft(firmware: Firmware,
 
     app_client.provide_transaction_info(tx_info.serialize())
     challenge = ResponseParser.challenge(app_client.get_challenge().data)
-    app_client.provide_trusted_name_v2(recipient_addr,
+    app_client.provide_trusted_name_v2(device_addr,
                                        "gerard.eth",
                                        TrustedNameType.ACCOUNT,
                                        TrustedNameSource.ENS,