fixes

Author: abenso

.github/workflows/main.yml

@@ -65,7 +65,6 @@ jobs:
           make deps
       - name: Run CMake
         run: mkdir -p build && cd build && cmake -DCMAKE_BUILD_TYPE=Debug .. && make
-      - run: make cpp_test
 
   build_ledger:
     needs: configure

app/src/borsh.h

@@ -30,17 +30,17 @@ extern "C" {
 #define OFFSET_U32 4
 #define OFFSET_U64 8
 
-#define DEFINE_READ_UINT(bits)                                                              \
-    static inline parser_error_t read_u##bits(parser_context_t *ctx, uint##bits##_t *val) { \
-        CHECK_INPUT(ctx);                                                                   \
-        CHECK_INPUT(val);                                                                   \
-        *val = *(uint##bits##_t *)(ctx->buffer.ptr + ctx->offset);                          \
-        CTX_CHECK_AND_ADVANCE(ctx, OFFSET_U##bits);                                         \
-        return parser_ok;                                                                   \
+#define DEFINE_READ_UINT(bits)                                                       \
+    static parser_error_t read_u##bits(parser_context_t *ctx, uint##bits##_t *val) { \
+        CHECK_INPUT(ctx);                                                            \
+        CHECK_INPUT(val);                                                            \
+        *val = *(uint##bits##_t *)(ctx->buffer.ptr + ctx->offset);                   \
+        CTX_CHECK_AND_ADVANCE(ctx, OFFSET_U##bits);                                  \
+        return parser_ok;                                                            \
     }
 
 DEFINE_READ_UINT(8)
-DEFINE_READ_UINT(16)
+// DEFINE_READ_UINT(16) // Removed to fix unused function warning
 DEFINE_READ_UINT(32)
 DEFINE_READ_UINT(64)
 

app/src/crypto_helper.c

@@ -1,5 +1,5 @@
 /*******************************************************************************
- *   (c) 2018 - 2023 Zondax AG
+ *   (c) 2018 - 2025 Zondax AG
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -28,7 +28,7 @@ picohash_ctx_t ctx;
 
 zxerr_t crypto_sha256_init() {
 #if defined(LEDGER_SPECIFIC)
-    memset(&ctx, 0, sizeof(ctx));
+    MEMZERO(&ctx, sizeof(ctx));
     cx_sha256_init_no_throw(&ctx);
 #else
     picohash_init_sha256(&ctx);

app/src/parser_impl.h

@@ -1,5 +1,5 @@
 /*******************************************************************************
- *  (c) 2018 - 2023 Zondax AG
+ *  (c) 2018 - 2025 Zondax AG
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -37,8 +37,10 @@ extern "C" {
     }
 
 #define CTX_CHECK_AND_ADVANCE(CTX, SIZE) \
-    CTX_CHECK((CTX), (SIZE))             \
-    (CTX)->offset += (SIZE);
+    {                                    \
+        CTX_CHECK((CTX), (SIZE))         \
+        (CTX)->offset += (SIZE);         \
+    }
 
 #define MAP_ZXERR_TO_PARSER_ERR(zxerr)                                           \
     ((zxerr) == zxerr_ok                        ? parser_ok                      \

app/src/schema_helper.c

@@ -19,13 +19,15 @@
 #include "borsh.h"
 #include "schema_reader.h"
 /**
- * @brief Find an index in the indices array.
+ * @brief Find the position of a given index in the indices array.
  *
- * @param index The index to find.
- * @param indices The indices array.
- * @return bool True if the index is found, false otherwise.
+ * @param index_leaf The index value to search for.
+ * @param indices Pointer to the indices array structure.
+ * @param index_vec Output: position of the found index in the array (if found).
+ * @param found Output: set to true if the index is found, false otherwise.
+ * @return parser_error_t Error code indicating success or failure.
  */
-bool schema_find_index(uint64_t index_leaf, merkle_leaves_indices_t *indices, uint64_t *index_vec) {
+parser_error_t schema_find_index(uint64_t index_leaf, merkle_leaves_indices_t *indices, uint64_t *index_vec, bool *found) {
     CHECK_INPUT(indices);
     CHECK_INPUT(index_vec);
 
@@ -36,13 +38,15 @@ bool schema_find_index(uint64_t index_leaf, merkle_leaves_indices_t *indices, ui
         if (index_tmp == index_leaf) {
             *index_vec = i;
             indices->indices.offset = 0;
-            return true;
+            *found = true;
+            return parser_ok;
         }
     }
 
     // reset offset
     indices->indices.offset = 0;
-    return false;
+    *found = false;
+    return parser_schema_index_not_found;
 }
 
 /**
@@ -77,30 +81,44 @@ parser_error_t schema_reset_leaf_offset(merkle_leaves_data_t *leaves) {
     return parser_ok;
 }
 
+/**
+ * @brief Get the schema type of a given index in the transaction.
+ *
+ * @param txObj Pointer to the transaction object.
+ * @param index The index to get the schema type for.
+ * @param type Output: the schema type of the index.
+ * @return parser_error_t Error code indicating success or failure.
+ */
 parser_error_t get_schema_type(parser_tx_t *txObj, uint32_t index, uint8_t *type) {
     CHECK_INPUT(txObj);
     CHECK_INPUT(type);
 
-    uint64_t mem_offset = txObj->merkle_proofs.leaves.data.offset;
-    txObj->merkle_proofs.leaves.data.offset = 0;
+    uint64_t mem_offset = txObj->merkle_proof.leaves.data.offset;
+    txObj->merkle_proof.leaves.data.offset = 0;
 
     uint64_t index_vec = 0;
-    if (!schema_find_index(index, &txObj->merkle_proofs.indices, &index_vec)) {
-        return parser_schema_index_not_found;
-    }
+    bool found = false;
+    CHECK_ERROR(schema_find_index(index, &txObj->merkle_proof.indices, &index_vec, &found));
 
-    CHECK_ERROR(schema_move_leaf_offset(&txObj->merkle_proofs.leaves, index_vec));
+    CHECK_ERROR(schema_move_leaf_offset(&txObj->merkle_proof.leaves, index_vec));
 
     uint32_t len = 0;
-    CHECK_ERROR(read_u32(&txObj->merkle_proofs.leaves.data, &len));
+    CHECK_ERROR(read_u32(&txObj->merkle_proof.leaves.data, &len));
 
-    CHECK_ERROR(read_u8(&txObj->merkle_proofs.leaves.data, type));
+    CHECK_ERROR(read_u8(&txObj->merkle_proof.leaves.data, type));
 
-    txObj->merkle_proofs.leaves.data.offset = mem_offset;
+    txObj->merkle_proof.leaves.data.offset = mem_offset;
 
     return parser_ok;
 }
 
+/**
+ * @brief Get the root index of the unsigned transaction.
+ *
+ * @param txObj Pointer to the transaction object.
+ * @param root_index Output: the root index of the unsigned transaction.
+ * @return parser_error_t Error code indicating success or failure.
+ */
 parser_error_t schema_get_unsigned_transaction_index(parser_tx_t *txObj, uint64_t *root_index) {
     CHECK_INPUT(txObj);
 
@@ -117,6 +135,12 @@ parser_error_t schema_get_unsigned_transaction_index(parser_tx_t *txObj, uint64_
     return parser_ok;
 }
 
+/**
+ * @brief Check if a link is a skip link.
+ *
+ * @param link Pointer to the link structure.
+ * @return bool True if the link is a skip link, false otherwise.
+ */
 bool is_link_skip(link_t *link) {
     if (link->tag == LINK_IMMEDIATE && link->data.immediate.type == PRIMITIVE_SKIP) {
         return true;

app/src/schema_helper.h

@@ -22,7 +22,7 @@ extern "C" {
 
 #include "parser_common.h"
 
-bool schema_find_index(uint64_t index_leaf, merkle_leaves_indices_t *indices, uint64_t *index_vec);
+parser_error_t schema_find_index(uint64_t index_leaf, merkle_leaves_indices_t *indices, uint64_t *index_vec, bool *found);
 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);

app/src/schema_proof.c

@@ -1,5 +1,5 @@
 /*******************************************************************************
- *   (c) 2018 - 2024 Zondax AG
+ *   (c) 2018 - 2025 Zondax AG
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -94,9 +94,11 @@ parser_error_t compute_tree_size(uint32_t num_right_siblings, uint32_t index_of_
 }
 
 /**
- * @brief Compute the hash of a leaf node in the proof.
+ * @brief Compute the hash of a leaf node at a given index in the leaves data.
  *
- * @param proof The proof structure containing the leaf node.
+ * @param leaves Pointer to the merkle_leaves_data_t structure containing the leaves data.
+ * @param index The index of the leaf to hash.
+ * @param hash Output buffer for the computed hash (must be at least CX_SHA256_SIZE bytes).
  * @return parser_error_t Error code indicating the result of the operation.
  */
 static parser_error_t hash_index_leaf(merkle_leaves_data_t *leaves, uint64_t index, uint8_t *hash) {
@@ -164,28 +166,32 @@ static parser_error_t get_next_lemma_hash(merkle_lemmas_t *lemmas, uint8_t *hash
 }
 
 /**
- * @brief Check if there are leaves in the range.
+ * @brief Check if there are leaves in the specified range.
  *
- * @param start The start index.
- * @param end The end index.
- * @param indices The indices array.
- * @return bool True if there are leaves in the range, false otherwise.
+ * @param start The start index (inclusive).
+ * @param end The end index (exclusive).
+ * @param indices Pointer to the merkle_leaves_indices_t structure containing the leaf indices.
+ * @param has_leaves Output pointer; set to true if there are leaves in the range, false otherwise.
+ * @return parser_error_t Error code indicating the result of the operation.
  */
-bool has_leaves(uint64_t start, uint64_t end, merkle_leaves_indices_t *indices) {
+static parser_error_t has_leaves(uint64_t start, uint64_t end, merkle_leaves_indices_t *indices, bool *has_leaves) {
     CHECK_INPUT(indices);
+    CHECK_INPUT(has_leaves);
 
     for (uint64_t i = 0; i < indices->entries; i++) {
         uint64_t index_tmp = 0;
         CHECK_ERROR(read_u64(&indices->indices, &index_tmp));
         if (index_tmp >= start && index_tmp < end) {
             indices->indices.offset = 0;
-            return true;
+            *has_leaves = true;
+            return parser_ok;
         }
     }
 
     // reset offset
     indices->indices.offset = 0;
-    return false;
+    *has_leaves = false;
+    return parser_ok;
 }
 
 /**
@@ -194,6 +200,7 @@ bool has_leaves(uint64_t start, uint64_t end, merkle_leaves_indices_t *indices)
  * @param proof The proof structure containing the necessary data.
  * @param index_start The start index.
  * @param index_end The end index.
+ * @param hash Output buffer for the computed hash (must be at least CX_SHA256_SIZE bytes).
  * @return parser_error_t Error code indicating the result of the operation.
  */
 static parser_error_t verify_multiproof_inner(proof_t *proof, uint64_t index_start, uint64_t index_end, uint8_t *hash) {
@@ -207,9 +214,10 @@ static parser_error_t verify_multiproof_inner(proof_t *proof, uint64_t index_sta
     // If this is a single node, return the hash of the node
     if (index_end - index_start == 1) {
         uint64_t index_vec = 0;
-        if (schema_find_index(index_start, &proof->indices, &index_vec)) {
+        bool found = false;
+        CHECK_ERROR(schema_find_index(index_start, &proof->indices, &index_vec, &found));
+        if (found) {
             CHECK_ERROR(hash_index_leaf(&proof->leaves, index_vec, hash));
-
             return parser_ok;
         }
 
@@ -223,8 +231,10 @@ static parser_error_t verify_multiproof_inner(proof_t *proof, uint64_t index_sta
         return parser_unexpected_buffer_end;
     }
 
-    bool left_has_leaves = has_leaves(index_start, mid, &proof->indices);
-    bool right_has_leaves = has_leaves(mid, index_end, &proof->indices);
+    bool left_has_leaves = false;
+    bool right_has_leaves = false;
+    CHECK_ERROR(has_leaves(index_start, mid, &proof->indices, &left_has_leaves));
+    CHECK_ERROR(has_leaves(mid, index_end, &proof->indices, &right_has_leaves));
 
     // Check left subtree
     CHECK_ERROR(checkStack());
@@ -253,8 +263,8 @@ static parser_error_t verify_multiproof_inner(proof_t *proof, uint64_t index_sta
 /**
  * @brief Compute the root hash for a given metadata structure.
  *
- * @param metadata The metadata structure containing the necessary data.
- * @param metadataDigest The output buffer for the computed metadata digest.
+ * @param metadata Pointer to the merkle_proof_t structure containing the necessary data.
+ * @param hash Output buffer for the computed root hash (must be at least CX_SHA256_SIZE bytes).
  * @return parser_error_t Error code indicating the result of the operation.
  */
 parser_error_t get_root_hash(const merkle_proof_t *metadata, uint8_t *hash) {

app/src/schema_proof.h

@@ -1,5 +1,5 @@
 /*******************************************************************************
- *   (c) 2018 - 2024 Zondax AG
+ *   (c) 2018 - 2025 Zondax AG
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -35,7 +35,6 @@ typedef struct {
     uint64_t tree_size;
 } proof_t;
 
-parser_error_t get_single_root_hash(const merkle_proof_t *metadata, uint8_t metadataDigest[CX_SHA256_SIZE]);
 parser_error_t verify_merkle_proofs(const merkle_proof_t *metadata);
 
 #ifdef __cplusplus

app/src/schema_reader.c

@@ -746,7 +746,7 @@ parser_error_t compute_chain_hash(parser_tx_t *txObj) {
     CHECK_ERROR(compute_internal_data_hash(txObj, internal_data_hash));
 
     crypto_sha256_init();
-    crypto_sha256_update(txObj->merkle_proofs.root_hash.ptr, txObj->merkle_proofs.root_hash.len);
+    crypto_sha256_update(txObj->merkle_proof.root_hash.ptr, txObj->merkle_proof.root_hash.len);
     crypto_sha256_update(internal_data_hash, CX_SHA256_SIZE);
     crypto_sha256_update(txObj->schema.extra_metadata_hash.ptr, txObj->schema.extra_metadata_hash.len);
     crypto_sha256_final(computed_chain_hash);
@@ -763,49 +763,49 @@ parser_error_t schema_merkle_proofs_read(parser_context_t *ctx, parser_tx_t *txO
     CHECK_INPUT(txObj);
 
     // read leaf data
-    CHECK_ERROR(read_u32(ctx, &txObj->merkle_proofs.leaves.entries));
+    CHECK_ERROR(read_u32(ctx, &txObj->merkle_proof.leaves.entries));
     const uint8_t *ptr_mem = ctx->buffer.ptr + ctx->offset;
     uint16_t offset_mem = ctx->offset;
-    for (uint32_t i = 0; i < txObj->merkle_proofs.leaves.entries; i++) {
+    for (uint32_t i = 0; i < txObj->merkle_proof.leaves.entries; i++) {
         uint32_t length = 0;
         CHECK_ERROR(read_u32(ctx, &length));
         uint8_t schema_type = 0;
         CHECK_ERROR(read_u8(ctx, (uint8_t *)&schema_type));
         CHECK_ERROR(read_schema_type(ctx, schema_type));
     }
 
-    txObj->merkle_proofs.leaves.data.buffer.ptr = ptr_mem;
-    txObj->merkle_proofs.leaves.data.buffer.len = ctx->offset - offset_mem;
+    txObj->merkle_proof.leaves.data.buffer.ptr = ptr_mem;
+    txObj->merkle_proof.leaves.data.buffer.len = ctx->offset - offset_mem;
 
     // read indices
-    CHECK_ERROR(read_u32(ctx, &txObj->merkle_proofs.indices.entries));
-    if (txObj->merkle_proofs.indices.entries != txObj->merkle_proofs.leaves.entries) {
+    CHECK_ERROR(read_u32(ctx, &txObj->merkle_proof.indices.entries));
+    if (txObj->merkle_proof.indices.entries != txObj->merkle_proof.leaves.entries) {
         return parser_schema_merkle_proofs_indices_mismatch;
     }
     const uint8_t *ptr_mem_indices = ctx->buffer.ptr + ctx->offset;
     uint16_t offset_mem_indices = ctx->offset;
-    for (uint32_t i = 0; i < txObj->merkle_proofs.indices.entries; i++) {
+    for (uint32_t i = 0; i < txObj->merkle_proof.indices.entries; i++) {
         uint64_t index = 0;
         CHECK_ERROR(read_u64(ctx, &index));
     }
-    txObj->merkle_proofs.indices.indices.buffer.ptr = ptr_mem_indices;
-    txObj->merkle_proofs.indices.indices.buffer.len = ctx->offset - offset_mem_indices;
+    txObj->merkle_proof.indices.indices.buffer.ptr = ptr_mem_indices;
+    txObj->merkle_proof.indices.indices.buffer.len = ctx->offset - offset_mem_indices;
 
     // read lemmas
-    CHECK_ERROR(read_u32(ctx, &txObj->merkle_proofs.lemmas.entries));
-    txObj->merkle_proofs.lemmas.data.buffer.ptr = ctx->buffer.ptr + ctx->offset;
-    txObj->merkle_proofs.lemmas.data.buffer.len = txObj->merkle_proofs.lemmas.entries * 32;
-    CTX_CHECK_AND_ADVANCE(ctx, txObj->merkle_proofs.lemmas.data.buffer.len);
+    CHECK_ERROR(read_u32(ctx, &txObj->merkle_proof.lemmas.entries));
+    txObj->merkle_proof.lemmas.data.buffer.ptr = ctx->buffer.ptr + ctx->offset;
+    txObj->merkle_proof.lemmas.data.buffer.len = txObj->merkle_proof.lemmas.entries * 32;
+    CTX_CHECK_AND_ADVANCE(ctx, txObj->merkle_proof.lemmas.data.buffer.len);
 
     // read tree_size
-    CHECK_ERROR(read_u64(ctx, &txObj->merkle_proofs.tree_size));
+    CHECK_ERROR(read_u64(ctx, &txObj->merkle_proof.tree_size));
 
     // read root_hash
-    txObj->merkle_proofs.root_hash.ptr = ctx->buffer.ptr + ctx->offset;
-    txObj->merkle_proofs.root_hash.len = CX_SHA256_SIZE;
-    CTX_CHECK_AND_ADVANCE(ctx, txObj->merkle_proofs.root_hash.len);
+    txObj->merkle_proof.root_hash.ptr = ctx->buffer.ptr + ctx->offset;
+    txObj->merkle_proof.root_hash.len = CX_SHA256_SIZE;
+    CTX_CHECK_AND_ADVANCE(ctx, txObj->merkle_proof.root_hash.len);
 
-    CHECK_ERROR(verify_merkle_proofs(&txObj->merkle_proofs));
+    CHECK_ERROR(verify_merkle_proofs(&txObj->merkle_proof));
 
     return parser_ok;
 }