EverCBOR wrapper in historical test (#7563)

Co-authored-by: Amaury Chamayou <amaury@xargs.fr>

Author: maxtropets

src/crypto/cbor.cpp

@@ -304,6 +304,19 @@ namespace ccf::cbor
     return as_string;
   }
 
+  bool simple_to_boolean(const Simple& value)
+  {
+    switch (value)
+    {
+      case SimpleValue::False:
+        return false;
+      case SimpleValue::True:
+        return true;
+      default:
+        throw CBORDecodeError("Simple value cannot be matched to boolean");
+    }
+  }
+
   const Value& ValueImpl::array_at(size_t index) const
   {
     if (!std::holds_alternative<Array>(value))

src/crypto/cbor.h

@@ -76,6 +76,7 @@ namespace ccf::cbor
 
   Value parse(std::span<const uint8_t> raw);
   std::string to_string(const Value& value);
+  bool simple_to_boolean(const Simple& value);
 
   decltype(auto) rethrow_with_msg(auto&& f, std::string_view msg = {})
   {

src/node/test/historical_queries.cpp

@@ -10,6 +10,7 @@
 #include "ccf/crypto/rsa_key_pair.h"
 #include "ccf/pal/locking.h"
 #include "ccf/receipt.h"
+#include "crypto/cbor.h"
 #include "crypto/openssl/hash.h"
 #include "ds/messaging.h"
 #include "ds/test/stub_writer.h"
@@ -254,90 +255,49 @@ size_t get_cache_limit_for_entries(
 
 struct MerkleProofData
 {
+  using PathItem =
+    std::pair</* left/right */ bool, /* digest */ std::vector<uint8_t>>;
+
   std::vector<uint8_t> write_set_digest;
   std::string commit_evidence;
   std::vector<uint8_t> claims_digest;
-  std::vector<std::pair<int64_t, std::vector<uint8_t>>> path;
+  std::vector<PathItem> path;
 };
 
-std::vector<uint8_t> bstring_to_bytes(QCBORItem& item)
-{
-  return {
-    static_cast<const uint8_t*>(item.val.string.ptr),
-    static_cast<const uint8_t*>(item.val.string.ptr) + item.val.string.len};
-}
-
-std::string tstring_to_string(QCBORItem& item)
-{
-  return {
-    static_cast<const char*>(item.val.string.ptr),
-    static_cast<const char*>(item.val.string.ptr) + item.val.string.len};
-}
-
 MerkleProofData decode_merkle_proof(const std::vector<uint8_t>& encoded)
 {
-  q_useful_buf_c buf{encoded.data(), encoded.size()};
-  QCBORDecodeContext ctx;
-  QCBORDecode_Init(&ctx, buf, QCBOR_DECODE_MODE_NORMAL);
-  struct q_useful_buf_c params;
-  QCBORDecode_EnterMap(&ctx, NULL);
-  QCBORDecode_EnterArrayFromMapN(
-    &ctx, ccf::MerkleProofLabel::MERKLE_PROOF_LEAF_LABEL);
-  QCBORItem item;
   MerkleProofData data;
 
-  QCBORDecode_GetNext(&ctx, &item);
-  REQUIRE(item.uDataType == QCBOR_TYPE_BYTE_STRING);
-  data.write_set_digest = bstring_to_bytes(item);
+  auto decoded = ccf::cbor::parse(encoded);
 
-  QCBORDecode_GetNext(&ctx, &item);
-  REQUIRE(item.uDataType == QCBOR_TYPE_TEXT_STRING);
-  data.commit_evidence = tstring_to_string(item);
+  const auto& leaf = decoded->map_at(
+    ccf::cbor::make_signed(ccf::MerkleProofLabel::MERKLE_PROOF_LEAF_LABEL));
 
-  QCBORDecode_GetNext(&ctx, &item);
-  REQUIRE(item.uDataType == QCBOR_TYPE_BYTE_STRING);
-  data.claims_digest = bstring_to_bytes(item);
+  REQUIRE_EQ(leaf->size(), 3);
 
-  QCBORDecode_ExitArray(&ctx);
-  QCBORDecode_EnterArrayFromMapN(
-    &ctx, ccf::MerkleProofLabel::MERKLE_PROOF_PATH_LABEL);
+  const auto& wsd = leaf->array_at(0)->as_bytes();
+  data.write_set_digest.assign(wsd.begin(), wsd.end());
 
-  for (;;)
-  {
-    QCBORDecode_EnterArray(&ctx, &item);
-    if (QCBORDecode_GetError(&ctx) != QCBOR_SUCCESS)
-      break;
+  data.commit_evidence = leaf->array_at(1)->as_string();
 
-    std::pair<int64_t, std::vector<uint8_t>> path_item;
+  const auto& cd = leaf->array_at(2)->as_bytes();
+  data.claims_digest.assign(cd.begin(), cd.end());
 
-    REQUIRE(QCBORDecode_GetNext(&ctx, &item) == QCBOR_SUCCESS);
-    if (item.uDataType == CBOR_SIMPLEV_TRUE)
-    {
-      path_item.first = true;
-    }
-    else if (item.uDataType == CBOR_SIMPLEV_FALSE)
-    {
-      path_item.first = false;
-    }
-    else
-    {
-      // Not a valid CBOR boolean
-      REQUIRE(false);
-    }
+  const auto& path = decoded->map_at(
+    ccf::cbor::make_signed(ccf::MerkleProofLabel::MERKLE_PROOF_PATH_LABEL));
 
-    REQUIRE(QCBORDecode_GetNext(&ctx, &item) == QCBOR_SUCCESS);
-    REQUIRE(item.uDataType == QCBOR_TYPE_BYTE_STRING);
-    path_item.second = bstring_to_bytes(item);
-
-    data.path.push_back(path_item);
-    QCBORDecode_ExitArray(&ctx);
+  for (size_t i = 0; i < path->size(); i++)
+  {
+    const auto& node = path->array_at(i);
+    const auto& dir = node->array_at(0)->as_simple();
+    const auto& hash = node->array_at(1)->as_bytes();
+
+    MerkleProofData::PathItem item;
+    item.first = ccf::cbor::simple_to_boolean(dir);
+    item.second.assign(hash.begin(), hash.end());
+    data.path.push_back(item);
   }
 
-  QCBORDecode_ExitArray(&ctx);
-  QCBORDecode_ExitMap(&ctx);
-
-  REQUIRE(QCBORDecode_Finish(&ctx) == QCBOR_ERR_NO_MORE_ITEMS);
-
   return data;
 }