Merge pull request #1000 from LedgerHQ/ref/asset_handling

Asset handling refactoring

Author: apaillier-ledger

src/apdu_constants.h

@@ -86,11 +86,15 @@ uint16_t handle_get_public_key(uint8_t p1,
                                const uint8_t *dataBuffer,
                                uint8_t dataLength,
                                unsigned int *tx);
-uint16_t handle_provide_erc20_token_information(const uint8_t *workBuffer,
-                                                uint8_t dataLength,
+uint16_t handle_provide_erc20_token_information(uint8_t p1,
+                                                uint8_t p2,
+                                                uint8_t lc,
+                                                const uint8_t *data,
                                                 unsigned int *tx);
-uint16_t handle_provide_nft_information(const uint8_t *dataBuffer,
-                                        uint8_t dataLength,
+uint16_t handle_provide_nft_information(uint8_t p1,
+                                        uint8_t p2,
+                                        uint8_t lc,
+                                        const uint8_t *data,
                                         unsigned int *tx);
 uint16_t handle_sign(uint8_t p1, uint8_t p2, const uint8_t *dataBuffer, uint8_t dataLength);
 uint16_t handle_get_app_configuration(unsigned int *tx);

src/features/generic_tx_parser/gtp_param_nft.c

@@ -1,9 +1,11 @@
 #include "gtp_param_nft.h"
-#include "manage_asset_info.h"
 #include "utils.h"
 #include "gtp_field_table.h"
 #include "tlv_library.h"
 #include "tlv_utils.h"
+#include "shared_context.h"
+#include "tx_ctx.h"
+#include "nft_info.h"
 
 #define PARAM_NFT_TAGS(X)                                    \
     X(0x00, TAG_VERSION, handle_version, ENFORCE_UNIQUE_TAG) \
@@ -41,13 +43,16 @@ bool format_param_nft(const s_param_nft *param, const char *name) {
     bool ret;
     s_parsed_value_collection collections = {0};
     s_parsed_value_collection ids = {0};
-    const nftInfo_t *asset;
+    const s_nft_info *asset;
     char *buf = strings.tmp.tmp;
     size_t buf_size = sizeof(strings.tmp.tmp);
     uint8_t collection_idx;
     uint8_t addr_buf[ADDRESS_LENGTH];
     char tmp[80];
+    uint64_t chain_id;
 
+    if (get_current_tx_info() == NULL) return false;
+    chain_id = get_current_tx_info()->chain_id;
     if ((ret = value_get(&param->collection, &collections))) {
         if ((ret = value_get(&param->id, &ids))) {
             if (collections.size == 0) {
@@ -62,8 +67,7 @@ bool format_param_nft(const s_param_nft *param, const char *name) {
                                           collections.value[collection_idx].length,
                                           addr_buf,
                                           sizeof(addr_buf));
-                        if ((asset = (const nftInfo_t *) get_asset_info_by_addr(addr_buf)) ==
-                            NULL) {
+                        if ((asset = get_matching_nft_info(&chain_id, addr_buf)) == NULL) {
                             ret = false;
                             break;
                         }
@@ -73,7 +77,7 @@ bool format_param_nft(const s_param_nft *param, const char *name) {
                                                        sizeof(tmp)))) {
                             break;
                         }
-                        snprintf(buf, buf_size, "%s #%s", asset->collectionName, tmp);
+                        snprintf(buf, buf_size, "%s #%s", asset->collection_name, tmp);
                         if (!(ret = add_to_field_table(PARAM_TYPE_NFT, name, buf, asset))) {
                             break;
                         }

src/features/generic_tx_parser/gtp_param_token.c

@@ -2,7 +2,7 @@
 #include "gtp_param_token.h"
 #include "shared_context.h"
 #include "utils.h"
-#include "manage_asset_info.h"
+#include "token_info.h"
 #include "network.h"
 #include "gtp_field_table.h"
 #include "tx_ctx.h"
@@ -61,7 +61,7 @@ bool format_param_token(const s_param_token *param, const char *name) {
     bool ret;
     s_parsed_value_collection collec = {0};
     uint8_t addr[ADDRESS_LENGTH];
-    const tokenDefinition_t *token_def = NULL;
+    const s_token_info *token_info = NULL;
     uint64_t chain_id;
     const char *ticker = NULL;
 
@@ -72,14 +72,14 @@ bool format_param_token(const s_param_token *param, const char *name) {
             buf_shrink_expand(collec.value[i].ptr, collec.value[i].length, addr, sizeof(addr));
             if (match_native(addr, param)) {
                 ticker = get_displayable_ticker(&chain_id, g_chain_config, true);
-            } else if ((token_def = (const tokenDefinition_t *) get_asset_info_by_addr(addr))) {
-                ticker = token_def->ticker;
+            } else if ((token_info = get_matching_token_info(&chain_id, addr))) {
+                ticker = token_info->ticker;
             }
             if (ticker == NULL) {
                 ret = false;
                 break;
             }
-            if (!(ret = add_to_field_table(PARAM_TYPE_TOKEN, name, ticker, token_def))) {
+            if (!(ret = add_to_field_table(PARAM_TYPE_TOKEN, name, ticker, token_info))) {
                 break;
             }
         }

src/features/generic_tx_parser/gtp_param_token_amount.c

@@ -4,9 +4,10 @@
 #include "network.h"
 #include "utils.h"
 #include "gtp_field_table.h"
-#include "manage_asset_info.h"
+#include "token_info.h"
 #include "tx_ctx.h"
 #include "tlv_utils.h"
+#include "shared_context.h"
 
 #define PARAM_TOKEN_AMOUNT_TAGS(X)                                           \
     X(0x00, TAG_VERSION, handle_version, ENFORCE_UNIQUE_TAG)                 \
@@ -95,7 +96,7 @@ static bool process_token_amount(const s_param_token_amount *param,
     uint8_t addr_buf[ADDRESS_LENGTH];
     uint256_t zero256 = {0};
     uint256_t val256;
-    const tokenDefinition_t *token_def = NULL;
+    const s_token_info *token_info = NULL;
     uint64_t chain_id;
     const char *ticker = g_unknown_ticker;
     uint8_t decimals = 0;
@@ -108,10 +109,9 @@ static bool process_token_amount(const s_param_token_amount *param,
             ticker = get_displayable_ticker(&chain_id, g_chain_config, true);
             decimals = WEI_TO_ETHER;
         } else {
-            if ((token_def = (const tokenDefinition_t *) get_asset_info_by_addr(addr_buf)) !=
-                NULL) {
-                ticker = token_def->ticker;
-                decimals = token_def->decimals;
+            if ((token_info = get_matching_token_info(&chain_id, addr_buf)) != NULL) {
+                ticker = token_info->ticker;
+                decimals = token_info->decimals;
             }
         }
     }
@@ -128,10 +128,10 @@ static bool process_token_amount(const s_param_token_amount *param,
             return false;
         }
     }
-    if (!add_to_field_table(token_def ? PARAM_TYPE_TOKEN_AMOUNT : PARAM_TYPE_AMOUNT,
+    if (!add_to_field_table(token_info ? PARAM_TYPE_TOKEN_AMOUNT : PARAM_TYPE_AMOUNT,
                             name,
                             buf,
-                            token_def)) {
+                            token_info)) {
         return false;
     }
     return true;

src/features/provide_erc20_token_information/cmd_provide_token_info.c

@@ -1,64 +1,108 @@
 #include "apdu_constants.h"
 #include "public_keys.h"
 #include "network.h"
-#include "manage_asset_info.h"
 #include "os_pki.h"
+#include "token_info.h"
 
-uint16_t handle_provide_erc20_token_information(const uint8_t *workBuffer,
-                                                uint8_t dataLength,
+uint16_t handle_provide_erc20_token_information(uint8_t p1,
+                                                uint8_t p2,
+                                                uint8_t lc,
+                                                const uint8_t *data,
                                                 unsigned int *tx) {
     uint32_t offset = 0;
-    uint8_t tickerLength;
+    uint8_t ticker_length;
+    const char *ticker;
+    const uint8_t *address;
+    uint32_t decimals_32;
+    uint32_t chain_id_32;
     uint64_t chain_id;
     uint8_t hash[INT256_LENGTH];
-    tokenDefinition_t *token = &get_current_asset_info()->token;
+    int index;
+    s_token_info info = {0};
 
-    PRINTF("Provisioning currentAssetIndex %d\n", tmpCtx.transactionContext.currentAssetIndex);
-
-    if (dataLength < 1) {
+    if ((p1 != 0) || (p2 != 0)) {
+        return SWO_INCORRECT_P1_P2;
+    }
+    if ((offset + sizeof(ticker_length)) > lc) {
         return SWO_INCORRECT_DATA;
     }
-    tickerLength = workBuffer[offset++];
-    dataLength--;
-    if ((tickerLength + 1) > sizeof(token->ticker)) {
+    ticker_length = data[offset];
+    offset += sizeof(ticker_length);
+
+    if ((offset + ticker_length) > lc) {
         return SWO_INCORRECT_DATA;
     }
-    if (dataLength < tickerLength + 20 + 4 + 4) {
+    ticker = (const char *) &data[offset];
+    offset += ticker_length;
+
+    if ((offset + ADDRESS_LENGTH) > lc) {
         return SWO_INCORRECT_DATA;
     }
-    cx_hash_sha256(workBuffer + offset, tickerLength + 20 + 4 + 4, hash, 32);
-    memmove(token->ticker, workBuffer + offset, tickerLength);
-    token->ticker[tickerLength] = '\0';
-    offset += tickerLength;
-    dataLength -= tickerLength;
-    memmove(token->address, workBuffer + offset, 20);
-    offset += 20;
-    dataLength -= 20;
+    address = &data[offset];
+    offset += ADDRESS_LENGTH;
+
     // TODO: 4 bytes for this is overkill
-    token->decimals = U4BE(workBuffer, offset);
-    offset += 4;
-    dataLength -= 4;
+    if ((offset + sizeof(decimals_32)) > lc) {
+        return SWO_INCORRECT_DATA;
+    }
+    decimals_32 = U4BE(data, offset);
+    offset += sizeof(decimals_32);
+
     // TODO: Handle 64-bit long chain IDs
-    chain_id = U4BE(workBuffer, offset);
+    if ((offset + sizeof(chain_id_32)) > lc) {
+        return SWO_INCORRECT_DATA;
+    }
+    chain_id_32 = U4BE(data, offset);
+    chain_id = (uint64_t) chain_id_32;
+    offset += sizeof(chain_id_32);
+
+    if (offset >= lc) {
+        // no signature
+        return SWO_INCORRECT_DATA;
+    }
+
+    // sanity checks
+    if (decimals_32 > UINT8_MAX) {
+        PRINTF("Error: decimals received does not fit on one byte!\n");
+        return SWO_INCORRECT_DATA;
+    }
+    if ((ticker_length + 1) > sizeof(info.ticker)) {
+        return SWO_INCORRECT_DATA;
+    }
     if (!app_compatible_with_chain_id(&chain_id)) {
         UNSUPPORTED_CHAIN_ID_MSG(chain_id);
         return SWO_INCORRECT_DATA;
     }
-    offset += 4;
-    dataLength -= 4;
 
+    // signature is computed on everything but the ticker length
+    cx_hash_sha256(&data[sizeof(ticker_length)],
+                   offset - sizeof(ticker_length),
+                   hash,
+                   CX_SHA256_SIZE);
     if (check_signature_with_pubkey(hash,
                                     sizeof(hash),
                                     LEDGER_SIGNATURE_PUBLIC_KEY,
                                     sizeof(LEDGER_SIGNATURE_PUBLIC_KEY),
                                     CERTIFICATE_PUBLIC_KEY_USAGE_COIN_META,
-                                    (uint8_t *) (workBuffer + offset),
-                                    dataLength) != true) {
+                                    &data[offset],
+                                    lc - offset) != true) {
+        return SWO_INCORRECT_DATA;
+    }
+
+    memcpy(info.address, address, sizeof(info.address));
+    memcpy(info.ticker, ticker, ticker_length);
+    info.decimals = (uint8_t) decimals_32;
+    info.chain_id = (uint64_t) chain_id_32;
+
+    if ((index = set_token_info(&info)) == -1) {
+        return SWO_INSUFFICIENT_MEMORY;
+    }
+    if (index > UINT8_MAX) {
+        // Could not represent it on one byte
         return SWO_INCORRECT_DATA;
     }
 
-    G_io_tx_buffer[0] = tmpCtx.transactionContext.currentAssetIndex;
-    validate_current_asset_info();
+    G_io_tx_buffer[0] = (uint8_t) index;
     *tx += 1;
     return SWO_SUCCESS;
 }

src/features/provide_erc20_token_information/token_info.c

@@ -0,0 +1,61 @@
+#include <string.h>
+#include "lists.h"
+#include "app_mem_utils.h"
+#include "token_info.h"
+
+typedef struct {
+    flist_node_t _list;
+    s_token_info info;
+} s_token_info_node;
+
+static s_token_info_node *g_token_info_list;
+
+int set_token_info(const s_token_info *info) {
+    s_token_info_node *node;
+    int idx = 0;
+
+    if (info == NULL) {
+        return -1;
+    }
+    // look for an existing matching node
+    for (node = g_token_info_list; node != NULL;
+         node = (s_token_info_node *) ((flist_node_t *) node)->next) {
+        if (info->chain_id == node->info.chain_id) {
+            if (memcmp(info->address, node->info.address, sizeof(node->info.address)) == 0) {
+                break;
+            }
+        }
+        idx += 1;
+    }
+
+    if (node == NULL) {
+        if ((node = APP_MEM_ALLOC(sizeof(*node))) == NULL) {
+            return -1;
+        }
+        flist_push_back((flist_node_t **) &g_token_info_list, (flist_node_t *) node);
+    }
+    memcpy(&node->info, info, sizeof(node->info));
+    return idx;
+}
+
+static void delete_token_info(s_token_info_node *node) {
+    APP_MEM_FREE(node);
+}
+
+void clear_token_infos(void) {
+    flist_clear((flist_node_t **) &g_token_info_list, (f_list_node_del) &delete_token_info);
+}
+
+const s_token_info *get_matching_token_info(const uint64_t *chain_id, const uint8_t *address) {
+    if ((chain_id != NULL) && (address != NULL)) {
+        for (const s_token_info_node *node = g_token_info_list; node != NULL;
+             node = (s_token_info_node *) ((flist_node_t *) node)->next) {
+            if (*chain_id == node->info.chain_id) {
+                if (memcmp(address, node->info.address, sizeof(node->info.address)) == 0) {
+                    return &node->info;
+                }
+            }
+        }
+    }
+    return NULL;
+}

src/features/provide_erc20_token_information/token_info.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <stdint.h>
+#include "common_utils.h"
+#include "asset_info.h"
+
+typedef struct {
+    uint8_t address[ADDRESS_LENGTH];
+    char ticker[MAX_TICKER_LEN];
+    uint8_t decimals;
+
+    uint64_t chain_id;
+} s_token_info;
+
+int set_token_info(const s_token_info *info);
+void clear_token_infos(void);
+const s_token_info *get_matching_token_info(const uint64_t *chain_id, const uint8_t *address);