Migrated EIP-712 feature to the new memory allocator

Author: apaillier-ledger

src/mem_utils.c

@@ -8,11 +8,9 @@
  * Format an unsigned number up to 32-bit into memory into an ASCII string.
  *
  * @param[in] value Value to write in memory
- * @param[out] length number of characters written to memory
- *
  * @return pointer to memory area or \ref NULL if the allocation failed
  */
-char *mem_legacy_alloc_and_format_uint(uint32_t value, uint8_t *const length) {
+const char *mem_alloc_and_format_uint(uint32_t value) {
     char *mem_ptr;
     uint32_t value_copy;
     uint8_t size;
@@ -24,12 +22,8 @@ char *mem_legacy_alloc_and_format_uint(uint32_t value, uint8_t *const length) {
         size += 1;
     }
     // +1 for the null character
-    if ((mem_ptr = mem_legacy_alloc(sizeof(char) * (size + 1)))) {
+    if ((mem_ptr = app_mem_alloc(sizeof(char) * (size + 1)))) {
         snprintf(mem_ptr, (size + 1), "%u", value);
-        mem_legacy_dealloc(sizeof(char));  // to skip the null character
-        if (length != NULL) {
-            *length = size;
-        }
     }
     return mem_ptr;
 }
@@ -63,3 +57,13 @@ void *mem_legacy_alloc_and_align(size_t size, size_t alignment) {
     mem_legacy_align(alignment);
     return mem_legacy_alloc(size);
 }
+
+char *app_mem_strdup(const char *src) {
+    char *dst;
+    size_t length = strlen(src) + 1;
+
+    if ((dst = app_mem_alloc(length)) != NULL) {
+        memcpy(dst, src, length);
+    }
+    return dst;
+}

src/mem_utils.h

@@ -4,6 +4,7 @@
 
 #define MEM_ALLOC_AND_ALIGN_TYPE(type) mem_legacy_alloc_and_align(sizeof(type), __alignof__(type))
 
-char *mem_legacy_alloc_and_format_uint(uint32_t value, uint8_t *const written_chars);
+const char *mem_alloc_and_format_uint(uint32_t value);
 uint8_t mem_legacy_align(size_t alignment);
 void *mem_legacy_alloc_and_align(size_t size, size_t alignment);
+char *app_mem_strdup(const char *s);

src_features/signMessageEIP712/commands_712.c

@@ -225,11 +225,8 @@ uint16_t handle_eip712_filtering(uint8_t p1,
             ret = false;
     }
     if ((p2 > P2_FILT_MESSAGE_INFO) && ret) {
-        if (ui_712_push_new_filter_path(path_crc)) {
-            if (!ui_712_filters_counter_incr()) {
-                ret = false;
-                apdu_response_code = APDU_RESPONSE_INVALID_DATA;
-            }
+        if (!ui_712_push_new_filter_path(path_crc)) {
+            ret = false;
         }
     }
     if (reply_apdu) {

src_features/signMessageEIP712/context_712.c

@@ -19,14 +19,17 @@ s_eip712_context *eip712_context = NULL;
  * @return a boolean indicating if the initialization was successful or not
  */
 bool eip712_context_init(void) {
-    // switch to legacy allocator
-    mem_legacy_init();
+    if (eip712_context != NULL) {
+        eip712_context_deinit();
+        return false;
+    }
 
     // init global variables
-    if ((eip712_context = MEM_ALLOC_AND_ALIGN_TYPE(*eip712_context)) == NULL) {
+    if ((eip712_context = app_mem_alloc(sizeof(*eip712_context))) == NULL) {
         apdu_response_code = APDU_RESPONSE_INSUFFICIENT_MEMORY;
         return false;
     }
+    explicit_bzero(eip712_context, sizeof(*eip712_context));
 
     if (sol_typenames_init() == false) {
         return false;
@@ -44,14 +47,10 @@ bool eip712_context_init(void) {
         return false;
     }
 
-    if (typed_data_init() == false)  // this needs to be initialized last !
-    {
+    if (typed_data_init() == false) {
         return false;
     }
 
-    // Since they are optional, they might not be provided by the JSON data
-    explicit_bzero(eip712_context->contract_addr, sizeof(eip712_context->contract_addr));
-    eip712_context->chain_id = 0;
     eip712_context->go_home_on_failure = true;
 
     struct_state = NOT_INITIALIZED;
@@ -67,8 +66,6 @@ void eip712_context_deinit(void) {
     path_deinit();
     field_hash_deinit();
     ui_712_deinit();
-    // switch back to SDK allocator
-    app_mem_init();
     eip712_context = NULL;
     reset_app_context();
 }

src_features/signMessageEIP712/encode_field.c

@@ -25,7 +25,7 @@ static void *field_encode(const uint8_t *const value,
         apdu_response_code = APDU_RESPONSE_INVALID_DATA;
         return NULL;
     }
-    if ((padded_value = mem_legacy_alloc(EIP_712_ENCODED_FIELD_LENGTH)) != NULL) {
+    if ((padded_value = app_mem_alloc(EIP_712_ENCODED_FIELD_LENGTH)) != NULL) {
         switch (ptype) {
             case MSB:
                 memset(padded_value, pval, EIP_712_ENCODED_FIELD_LENGTH - length);

src_features/signMessageEIP712/field_hash.c

@@ -20,13 +20,17 @@ static s_field_hashing *fh = NULL;
  * @return whether the initialization was successful or not
  */
 bool field_hash_init(void) {
-    if (fh == NULL) {
-        if ((fh = MEM_ALLOC_AND_ALIGN_TYPE(*fh)) == NULL) {
-            apdu_response_code = APDU_RESPONSE_INSUFFICIENT_MEMORY;
-            return false;
-        }
-        fh->state = FHS_IDLE;
+    if (fh != NULL) {
+        field_hash_deinit();
+        return false;
+    }
+
+    if ((fh = app_mem_alloc(sizeof(*fh))) == NULL) {
+        apdu_response_code = APDU_RESPONSE_INSUFFICIENT_MEMORY;
+        return false;
     }
+    explicit_bzero(fh, sizeof(*fh));
+    fh->state = FHS_IDLE;
     return true;
 }
 
@@ -45,18 +49,16 @@ void field_hash_deinit(void) {
  * @param[in,out] data_length the value length
  * @return the data pointer
  */
-static const uint8_t *field_hash_prepare(const void *const field_ptr,
+static const uint8_t *field_hash_prepare(const s_struct_712_field *field_ptr,
                                          const uint8_t *data,
                                          uint8_t *data_length) {
-    e_type field_type;
     cx_err_t error = CX_INTERNAL_ERROR;
 
-    field_type = struct_field_type(field_ptr);
     fh->remaining_size = __builtin_bswap16(*(uint16_t *) &data[0]);  // network byte order
     data += sizeof(uint16_t);
     *data_length -= sizeof(uint16_t);
     fh->state = FHS_WAITING_FOR_MORE;
-    if (IS_DYN(field_type)) {
+    if (IS_DYN(field_ptr->type)) {
         CX_CHECK(cx_keccak_init_no_throw(&global_sha3, 256));
     }
     return data;
@@ -74,16 +76,14 @@ static const uint8_t *field_hash_prepare(const void *const field_ptr,
  * @param[in] data_length the value length
  * @return pointer to the encoded value
  */
-static const uint8_t *field_hash_finalize_static(const void *const field_ptr,
+static const uint8_t *field_hash_finalize_static(const s_struct_712_field *field_ptr,
                                                  const uint8_t *const data,
                                                  uint8_t data_length) {
     uint8_t *value = NULL;
-    e_type field_type;
 
-    field_type = struct_field_type(field_ptr);
-    switch (field_type) {
+    switch (field_ptr->type) {
         case TYPE_SOL_INT:
-            value = encode_int(data, data_length, get_struct_field_typesize(field_ptr));
+            value = encode_int(data, data_length, field_ptr->type_size);
             break;
         case TYPE_SOL_UINT:
             value = encode_uint(data, data_length);
@@ -116,7 +116,7 @@ static uint8_t *field_hash_finalize_dynamic(void) {
     uint8_t *value;
     cx_err_t error = CX_INTERNAL_ERROR;
 
-    if ((value = mem_legacy_alloc(KECCAK256_HASH_BYTESIZE)) == NULL) {
+    if ((value = app_mem_alloc(KECCAK256_HASH_BYTESIZE)) == NULL) {
         apdu_response_code = APDU_RESPONSE_INSUFFICIENT_MEMORY;
         return NULL;
     }
@@ -138,7 +138,7 @@ static uint8_t *field_hash_finalize_dynamic(void) {
  * @param[in] field_type the struct field's type
  * @param[in] hash the field hash
  */
-static void field_hash_feed_parent(e_type field_type, const uint8_t *const hash) {
+static void field_hash_feed_parent(e_type field_type, const uint8_t *hash) {
     uint8_t len;
 
     if (IS_DYN(field_type)) {
@@ -149,11 +149,11 @@ static void field_hash_feed_parent(e_type field_type, const uint8_t *const hash)
 
     // last thing in mem is the hash of the previous field
     // and just before it is the current hash context
-    cx_sha3_t *hash_ctx = (cx_sha3_t *) (hash - sizeof(cx_sha3_t));
+    cx_sha3_t *hash_ctx = get_last_hash_ctx();
     // continue the progressive hash on it
     hash_nbytes(hash, len, (cx_hash_t *) hash_ctx);
     // deallocate it
-    mem_legacy_dealloc(len);
+    app_mem_free((void *) hash);
 }
 
 /**
@@ -166,17 +166,16 @@ static void field_hash_feed_parent(e_type field_type, const uint8_t *const hash)
  * @param[in] data_length the value length
  * @return whether an error occurred or not
  */
-static bool field_hash_domain_special_fields(const void *const field_ptr,
+static bool field_hash_domain_special_fields(const s_struct_712_field *field_ptr,
                                              const uint8_t *const data,
                                              uint8_t data_length) {
     const char *key;
-    uint8_t keylen;
     const char *ethermint_vc = "cosmos";
 
-    key = get_struct_field_keyname(field_ptr, &keylen);
+    key = field_ptr->key_name;
     // copy contract address into context
-    if (strncmp(key, "verifyingContract", keylen) == 0) {
-        switch (struct_field_type(field_ptr)) {
+    if (strncmp(key, "verifyingContract", strlen(key)) == 0) {
+        switch (field_ptr->type) {
             case TYPE_SOL_ADDRESS:
                 if (data_length > sizeof(eip712_context->contract_addr)) {
                     apdu_response_code = APDU_RESPONSE_INVALID_DATA;
@@ -195,14 +194,13 @@ static bool field_hash_domain_special_fields(const void *const field_ptr,
                 break;
             default:
                 apdu_response_code = APDU_RESPONSE_INVALID_DATA;
-                PRINTF("Error: unexpected type for verifyingContract (%u)!\n",
-                       struct_field_type(field_ptr));
+                PRINTF("Error: unexpected type for verifyingContract (%u)!\n", field_ptr->type);
                 return false;
         }
         memcpy(eip712_context->contract_addr, data, data_length);
         explicit_bzero(&eip712_context->contract_addr[data_length],
                        sizeof(eip712_context->contract_addr) - data_length);
-    } else if (strncmp(key, "chainId", keylen) == 0) {
+    } else if (strncmp(key, "chainId", strlen(key)) == 0) {
         eip712_context->chain_id = u64_from_BE(data, data_length);
     }
     return true;
@@ -216,14 +214,12 @@ static bool field_hash_domain_special_fields(const void *const field_ptr,
  * @param[in] data_length the value length
  * @return whether an error occurred or not
  */
-static bool field_hash_finalize(const void *const field_ptr,
+static bool field_hash_finalize(const s_struct_712_field *field_ptr,
                                 const uint8_t *const data,
                                 uint8_t data_length) {
     const uint8_t *value = NULL;
-    e_type field_type;
 
-    field_type = struct_field_type(field_ptr);
-    if (!IS_DYN(field_type)) {
+    if (!IS_DYN(field_ptr->type)) {
         if ((value = field_hash_finalize_static(field_ptr, data, data_length)) == NULL) {
             return false;
         }
@@ -233,7 +229,7 @@ static bool field_hash_finalize(const void *const field_ptr,
         }
     }
 
-    field_hash_feed_parent(field_type, value);
+    field_hash_feed_parent(field_ptr->type, value);
 
     if (path_get_root_type() == ROOT_DOMAIN) {
         if (field_hash_domain_special_fields(field_ptr, data, data_length) == false) {
@@ -255,16 +251,14 @@ static bool field_hash_finalize(const void *const field_ptr,
  * @return whether the data hashing was successful or not
  */
 bool field_hash(const uint8_t *data, uint8_t data_length, bool partial) {
-    const void *field_ptr;
-    e_type field_type;
+    const s_struct_712_field *field_ptr;
     bool first = fh->state == FHS_IDLE;
 
     if ((fh == NULL) || ((field_ptr = path_get_field()) == NULL)) {
         apdu_response_code = APDU_RESPONSE_CONDITION_NOT_SATISFIED;
         return false;
     }
 
-    field_type = struct_field_type(field_ptr);
     // first packet for this frame
     if (first) {
         if (!ui_712_show_raw_key(field_ptr)) {
@@ -283,7 +277,7 @@ bool field_hash(const uint8_t *data, uint8_t data_length, bool partial) {
     }
     fh->remaining_size -= data_length;
     // if a dynamic type -> continue progressive hash
-    if (IS_DYN(field_type)) {
+    if (IS_DYN(field_ptr->type)) {
         hash_nbytes(data, data_length, (cx_hash_t *) &global_sha3);
     }
     if (!ui_712_feed_to_display(field_ptr, data, data_length, first, fh->remaining_size == 0)) {
@@ -299,7 +293,7 @@ bool field_hash(const uint8_t *data, uint8_t data_length, bool partial) {
             return false;
         }
     } else {
-        if (!partial || !IS_DYN(field_type))  // only makes sense if marked as partial
+        if (!partial || !IS_DYN(field_ptr->type))  // only makes sense if marked as partial
         {
             apdu_response_code = APDU_RESPONSE_INVALID_DATA;
             return false;