remove unsigned parser

Author: abenso

app/src/common/actions.h

@@ -19,14 +19,13 @@
 #include <stdint.h>
 
 #include "apdu_codes.h"
+#include "borsh.h"
 #include "coin.h"
+#include "common_txdef.h"
 #include "crypto.h"
 #include "tx.h"
 #include "zxerror.h"
 
-#include "common_txdef.h"
-#include "borsh.h"
-
 extern uint16_t action_addrResponseLen;
 
 __Z_INLINE zxerr_t app_fill_address() {

app/src/common/tx.c

@@ -24,7 +24,7 @@
 #include "zxmacros.h"
 
 #if defined(TARGET_NANOX) || defined(TARGET_NANOS2) || defined(TARGET_STAX) || defined(TARGET_FLEX)
-#define RAM_BUFFER_SIZE 8192
+#define RAM_BUFFER_SIZE 4096
 #define FLASH_BUFFER_SIZE 16384
 #elif defined(TARGET_NANOS)
 #define RAM_BUFFER_SIZE 256
@@ -116,4 +116,3 @@ zxerr_t tx_getItem(int8_t displayIdx, char *outKey, uint16_t outKeyLen, char *ou
 const uint8_t *get_txn_raw() { return tx_obj.unsigned_transaction_raw.buffer.ptr; }
 
 uint16_t get_txn_len() { return tx_obj.unsigned_transaction_raw.buffer.len; }
-

app/src/parser_impl.c

@@ -16,18 +16,18 @@
 
 #include "parser_impl.h"
 
+#include "borsh.h"
+#include "schema_display.h"
 #include "schema_reader.h"
 #include "unsigned_transaction_reader.h"
 #include "zxerror.h"
-#include "borsh.h"
 
 parser_error_t _read(parser_context_t *c, parser_tx_t *v) {
-    CHECK_ERROR(merkle_proofs_read(c, v));
+    CHECK_ERROR(schema_merkle_proofs_read(c, v));
     CHECK_ERROR(schema_extra_data_read(c, v));
-    CHECK_ERROR(unsigned_transaction_read(c, v));
+    CHECK_ERROR(schema_parser_transaction(c, v));
     CHECK_ERROR(schema_chain_hash_read(c, v));
 
-    // TODO: check that we have consumxed all data
     if (c->offset != c->buffer.len) {
         print_string("Failed to parse unsigned transaction\n");
         return parser_unexpected_error;

app/src/schema_display.c

@@ -22,9 +22,9 @@ extern "C" {
 
 #include "parser_common.h"
 
-parser_error_t schema_display_generic_by_index(parser_tx_t *txObj, uint32_t start_index);
-parser_error_t schema_display_by_primitive(parser_tx_t *txObj, primitive_t *primitive);
-parser_error_t schema_display(parser_tx_t *txObj, uint32_t start_index);
+parser_error_t schema_display_generic_by_index(parser_context_t *ctx, parser_tx_t *txObj, uint32_t start_index);
+parser_error_t schema_display_by_primitive(parser_context_t *ctx, parser_tx_t *txObj, primitive_t *primitive);
+parser_error_t schema_parser_transaction(parser_context_t *ctx, parser_tx_t *txObj);
 
 #ifdef __cplusplus
 }

app/src/schema_display.h

@@ -101,6 +101,22 @@ parser_error_t get_schema_type(parser_tx_t *txObj, uint32_t index, uint8_t *type
     return parser_ok;
 }
 
+parser_error_t schema_get_unsigned_transaction_index(parser_tx_t *txObj, uint64_t *root_index) {
+    CHECK_INPUT(txObj);
+
+    // Get root index
+    if (txObj->schema.root_type_indices.qty <= ROLLUP_ROOTS_UNSIGNED_TRANSACTION) {
+        return parser_root_type_indices_overflow;
+    }
+
+    for (uint8_t i = 0; i <= (uint16_t)ROLLUP_ROOTS_UNSIGNED_TRANSACTION; i++) {
+        CHECK_ERROR(read_u64(&txObj->schema.root_type_indices.indices, root_index));
+    }
+    txObj->schema.root_type_indices.indices.offset = 0;
+
+    return parser_ok;
+}
+
 bool is_link_skip(link_t *link) {
     if (link->tag == LINK_IMMEDIATE && link->data.immediate.type == PRIMITIVE_SKIP) {
         return true;

app/src/schema_helper.c

@@ -26,6 +26,7 @@ bool schema_find_index(uint64_t index_leaf, merkle_leaves_indices_t *indices, ui
 parser_error_t schema_move_leaf_offset(merkle_leaves_data_t *leaves, uint64_t index);
 parser_error_t schema_reset_leaf_offset(merkle_leaves_data_t *leaves);
 parser_error_t get_schema_type(parser_tx_t *txObj, uint32_t index, uint8_t *type);
+parser_error_t schema_get_unsigned_transaction_index(parser_tx_t *txObj, uint64_t *root_index);
 bool is_link_skip(link_t *link);
 
 #ifdef __cplusplus

app/src/schema_helper.h

@@ -20,6 +20,7 @@
 #include "crypto_helper.h"
 #include "schema_helper.h"
 #include "schema_proof.h"
+#include "stack_manager.h"
 
 parser_error_t read_fixed_point_display(parser_context_t *ctx, fixed_point_display_t *display) {
     CHECK_INPUT(display);
@@ -393,6 +394,8 @@ parser_error_t read_enum(parser_context_t *ctx, schema_enum_t *schema_enum) {
     print_buffer(&schema_enum->type_name, "type_name");
     print_buffer_str(&schema_enum->type_name, "type_name_str");
 
+    checkStack();
+
     // read variants_qty
     CHECK_ERROR(read_u32(ctx, &schema_enum->variants_qty));
     print_u32("variants_qty:", schema_enum->variants_qty);
@@ -702,6 +705,7 @@ parser_error_t read_schema_type(parser_context_t *ctx, uint8_t type) {
         case LINKING_SCHEME_ENUM:
             print_string("READING ENUM");
             schema_enum_t enum_type = {0};
+            checkStack();
             CHECK_ERROR(read_enum(ctx, &enum_type));
             print_string("READING ENUM DONE\n");
             break;
@@ -859,10 +863,12 @@ parser_error_t compute_chain_hash(parser_tx_t *txObj) {
 }
 
 // | borsh(leaves_data) | borsh(indices_leaves) | borsh(lemmas) | borsh(tree_size) | borsh(root_hash)  | borsh(chain_hash)
-parser_error_t merkle_proofs_read(parser_context_t *ctx, parser_tx_t *txObj) {
+parser_error_t schema_merkle_proofs_read(parser_context_t *ctx, parser_tx_t *txObj) {
     CHECK_INPUT(ctx);
     CHECK_INPUT(txObj);
 
+    checkStack();
+
     // read leaf data
     CHECK_ERROR(read_u32(ctx, &txObj->merkle_proofs.leaves.entries));
     print_u32("leaves.qty:", txObj->merkle_proofs.leaves.entries);
@@ -873,10 +879,12 @@ parser_error_t merkle_proofs_read(parser_context_t *ctx, parser_tx_t *txObj) {
         CHECK_ERROR(read_u32(ctx, &length));
         print_u32("length:", length);
         uint8_t schema_type = 0;
+        checkStack();
         CHECK_ERROR(read_u8(ctx, (uint8_t *)&schema_type));
         print_u8("schema.type:", schema_type);
         CHECK_ERROR(read_schema_type(ctx, schema_type));
     }
+    return parser_unexpected_error;
     txObj->merkle_proofs.leaves.data.buffer.ptr = ptr_mem;
     txObj->merkle_proofs.leaves.data.buffer.len = ctx->offset - offset_mem;
     print_buffer(&txObj->merkle_proofs.leaves.data.buffer, "leaves data");

app/src/schema_reader.c

@@ -33,9 +33,10 @@ parser_error_t read_name_registry(parser_context_t *ctx, name_registry_t *name_r
 parser_error_t read_named_field(parser_context_t *ctx, named_field_t *field);
 parser_error_t read_unnamed_field(parser_context_t *ctx, unnamed_field_t *field);
 parser_error_t read_registry(parser_context_t *ctx, registry_t *registry);
+parser_error_t get_schema_unsigned_transaction_index(parser_tx_t *txObj, uint64_t *root_index);
 
 parser_error_t metadata_read(parser_context_t *ctx, parser_tx_t *txObj);
-parser_error_t merkle_proofs_read(parser_context_t *ctx, parser_tx_t *txObj);
+parser_error_t schema_merkle_proofs_read(parser_context_t *ctx, parser_tx_t *txObj);
 parser_error_t schema_extra_data_read(parser_context_t *ctx, parser_tx_t *txObj);
 parser_error_t schema_chain_hash_read(parser_context_t *ctx, parser_tx_t *txObj);
 

app/src/schema_reader.h

@@ -0,0 +1,74 @@
+/*******************************************************************************
+ *   (c) 2018 - 2024 Zondax AG
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ ********************************************************************************/
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "parser_common.h"
+#include "zxmacros.h"
+
+#if defined(LEDGER_SPECIFIC)
+#define STACK_SHIFT 0x20
+#define MINIMUM_STACK 0x400
+#else
+static int16_t recursionDepthCounter = 0;
+#define MAX_RECURSION_DEPTH 50
+#endif
+
+/**
+ * @brief Checks the available stack space to prevent stack overflow.
+ *
+ * @return parser_error_t Returns parser_running_out_of_stack if stack space is insufficient, otherwise parser_ok.
+ */
+parser_error_t checkStack() {
+#if defined(LEDGER_SPECIFIC)
+    // NOLINTNEXTLINE(readability-identifier-length): here `p` is fine
+    void *p = NULL;
+    const uint32_t availableStack = (uint32_t)((void *)&p) + STACK_SHIFT - (uint32_t)&app_stack_canary;
+    ZEMU_LOGF(50, "Check: available stack: %d\n", availableStack)
+    if (availableStack <= MINIMUM_STACK) {
+        return parser_running_out_of_stack;
+    }
+#else
+    if (recursionDepthCounter >= MAX_RECURSION_DEPTH) {
+        return parser_running_out_of_stack;
+    }
+    recursionDepthCounter++;
+#endif
+    return parser_ok;
+}
+
+/**
+ * @brief Frees the stack space by decrementing the recursion depth counter.
+ *
+ * @return parser_error_t Always returns parser_ok.
+ */
+parser_error_t freeStack(uint8_t depth) {
+#if !defined(LEDGER_SPECIFIC)
+    if (recursionDepthCounter > 0) {
+        recursionDepthCounter -= depth;
+    }
+#else
+    (void)depth;
+    void *p = NULL;
+    const uint32_t availableStack = (uint32_t)((void *)&p) - (uint32_t)&app_stack_canary;
+    ZEMU_LOGF(50, "Free: available stack: %d\n", availableStack)
+    if (availableStack <= MINIMUM_STACK) {
+        return parser_running_out_of_stack;
+    }
+#endif
+    return parser_ok;
+}