Fix remaining clang-tidy errors in OpenSSL code paths

The previous build didn't include -DOPENSSL=ON, so clang-tidy errors
in #ifdef HAVE_OPENSSL blocks were missed.

- time_large_trees.cpp: Add braces, const, static_cast for SHA384/512 blocks
- compare_hash_functions.cpp: Replace #define with constexpr, typedef
  with using, std::endl with '\n', split declarations, add braces/const,
  fix narrowing conversions, use nullptr, fix implicit widening
- merklecpp.h: Add const to EVP_Digest return values, replace typedef
  with using for Hash384/Path384/Tree384/Hash512/Path512/Tree512

Co-authored-by: achamayou <4016369+achamayou@users.noreply.github.com>

Author: Copilot

merklecpp.h

@@ -2052,7 +2052,7 @@ namespace merkle
     memcpy(&block[32], r.bytes, 32);
 
     const EVP_MD* md = EVP_sha256();
-    int rc =
+    const int rc =
       EVP_Digest(&block[0], sizeof(block), out.bytes, nullptr, md, nullptr);
     if (rc != 1)
     {
@@ -2074,7 +2074,7 @@ namespace merkle
     memcpy(&block[48], r.bytes, 48);
 
     const EVP_MD* md = EVP_sha384();
-    int rc =
+    const int rc =
       EVP_Digest(&block[0], sizeof(block), out.bytes, nullptr, md, nullptr);
     if (rc != 1)
     {
@@ -2096,7 +2096,7 @@ namespace merkle
     memcpy(&block[64], r.bytes, 64);
 
     const EVP_MD* md = EVP_sha512();
-    int rc =
+    const int rc =
       EVP_Digest(&block[0], sizeof(block), out.bytes, nullptr, md, nullptr);
     if (rc != 1)
     {
@@ -2105,22 +2105,22 @@ namespace merkle
   }
 
   /// @brief Type of hashes in the SHA384 tree type
-  typedef HashT<48> Hash384;
+  using Hash384 = HashT<48>;
 
   /// @brief Type of paths in the SHA384 tree type
-  typedef PathT<48, sha384_openssl> Path384;
+  using Path384 = PathT<48, sha384_openssl>;
 
   /// @brief SHA384 tree with OpenSSL hash function
-  typedef TreeT<48, sha384_openssl> Tree384;
+  using Tree384 = TreeT<48, sha384_openssl>;
 
   /// @brief Type of hashes in the SHA512 tree type
-  typedef HashT<64> Hash512;
+  using Hash512 = HashT<64>;
 
   /// @brief Type of paths in the SHA512 tree type
-  typedef PathT<64, sha512_openssl> Path512;
+  using Path512 = PathT<64, sha512_openssl>;
 
   /// @brief SHA512 tree with OpenSSL hash function
-  typedef TreeT<64, sha512_openssl> Tree512;
+  using Tree512 = TreeT<64, sha512_openssl>;
 #endif
 
   /// @brief Type of hashes in the default tree type

test/compare_hash_functions.cpp

@@ -8,8 +8,8 @@
 #include <iostream>
 #include <merklecpp.h>
 
-#define HSZ 32
-#define PRNTSZ 3
+constexpr size_t HSZ = 32;
+constexpr size_t PRNTSZ = 3;
 
 #ifdef HAVE_EVERCRYPT
 #  include <Hacl_Hash.h>
@@ -47,7 +47,7 @@ typedef merkle::TreeT<32, sha256_evercrypt> EverCryptFullTree;
 #endif
 
 #ifdef HAVE_OPENSSL
-typedef merkle::TreeT<32, merkle::sha256_openssl> OpenSSLFullTree;
+using OpenSSLFullTree = merkle::TreeT<32, merkle::sha256_openssl>;
 #endif
 
 template <
@@ -68,11 +68,11 @@ void compare_roots(
   if (mt1_root != mt2_root)
   {
     std::cout << mt1.num_leaves() << ": " << mt1_root.to_string()
-              << " != " << mt2_root.to_string() << std::endl;
-    std::cout << "mt1: " << std::endl;
-    std::cout << mt1.to_string(PRNTSZ) << std::endl;
-    std::cout << name << ": " << std::endl;
-    std::cout << mt2.to_string(PRNTSZ) << std::endl;
+              << " != " << mt2_root.to_string() << '\n';
+    std::cout << "mt1: " << '\n';
+    std::cout << mt1.to_string(PRNTSZ) << '\n';
+    std::cout << name << ": " << '\n';
+    std::cout << mt2.to_string(PRNTSZ) << '\n';
     throw std::runtime_error("root hash mismatch");
   }
 }
@@ -87,7 +87,8 @@ void compare_compression_hashes()
   const size_t root_interval = 128;
 #endif
 
-  size_t total_inserts = 0, total_roots = 0;
+  size_t total_inserts = 0;
+  size_t total_roots = 0;
 
   for (size_t k = 0; k < num_trees; k++)
   {
@@ -129,7 +130,7 @@ void compare_compression_hashes()
 
   std::cout << num_trees << " trees, " << total_inserts << " inserts, "
             << total_roots << " roots with SHA256 compression function: OK"
-            << std::endl;
+            << '\n';
 }
 
 #if defined(HAVE_OPENSSL) && defined(HAVE_EVERCRYPT)
@@ -143,7 +144,8 @@ void compare_full_hashes()
   const size_t root_interval = 128;
 #  endif
 
-  size_t total_inserts = 0, total_roots = 0;
+  size_t total_inserts = 0;
+  size_t total_roots = 0;
 
   for (size_t k = 0; k < num_trees; k++)
   {
@@ -184,7 +186,7 @@ void compare_full_hashes()
   }
 
   std::cout << num_trees << " trees, " << total_inserts << " inserts, "
-            << total_roots << " roots with full SHA256: OK" << std::endl;
+            << total_roots << " roots with full SHA256: OK" << '\n';
 }
 #endif
 
@@ -197,21 +199,23 @@ void bench(
   size_t j = 0;
   auto start = std::chrono::high_resolution_clock::now();
   T mt;
-  for (auto& h : hashes)
+  for (const auto& h : hashes)
   {
     mt.insert(h);
     if ((j++ % root_interval) == 0)
+    {
       mt.root();
+    }
   }
   mt.root();
   auto stop = std::chrono::high_resolution_clock::now();
-  double seconds =
-    std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() /
+  const double seconds =
+    static_cast<double>(std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count()) /
     1e9;
   std::cout << std::left << std::setw(10) << name << ": "
             << mt.statistics.num_insert << " insertions, "
             << mt.statistics.num_root << " roots in " << seconds << " sec"
-            << std::endl;
+            << '\n';
 }
 
 template <typename T, size_t HASH_SIZE>
@@ -223,21 +227,23 @@ void benchT(
   size_t j = 0;
   auto start = std::chrono::high_resolution_clock::now();
   T mt;
-  for (auto& h : hashes)
+  for (const auto& h : hashes)
   {
     mt.insert(h);
     if ((j++ % root_interval) == 0)
+    {
       mt.root();
+    }
   }
   mt.root();
   auto stop = std::chrono::high_resolution_clock::now();
-  double seconds =
-    std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count() /
+  const double seconds =
+    static_cast<double>(std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count()) /
     1e9;
   std::cout << std::left << std::setw(10) << name << ": "
             << mt.statistics.num_insert << " insertions, "
             << mt.statistics.num_root << " roots in " << seconds << " sec"
-            << std::endl;
+            << '\n';
 }
 
 #ifdef HAVE_EVERCRYPT
@@ -269,7 +275,7 @@ void bench_evercrypt(
     1e9;
   std::cout << std::left << std::setw(10) << name << ": " << num_inserts
             << " insertions, " << num_roots << " roots in " << seconds << " sec"
-            << std::endl;
+            << '\n';
   mt_free_hash(ec_root);
   mt_free(ec_mt);
 }
@@ -280,7 +286,7 @@ int main()
   try
   {
     // std::srand(0);
-    std::srand(std::time(0));
+    std::srand(std::time(nullptr));
 
     compare_compression_hashes();
 
@@ -292,36 +298,36 @@ int main()
     const size_t num_leaves = 128 * 1024;
     const size_t root_interval = 128;
 #else
-    const size_t num_leaves = 16 * 1024 * 1024;
+    const size_t num_leaves = static_cast<size_t>(16) * 1024 * 1024;
     const size_t root_interval = 1024;
 #endif
 
     auto hashes = make_hashes(num_leaves);
 
     std::cout << "--- merklecpp trees with SHA256 compression function: "
-              << std::endl;
+              << '\n';
 
     bench<merkle::Tree>(hashes, "merklecpp", root_interval);
 
 #ifdef HAVE_EVERCRYPT
     bench<EverCryptTree>(hashes, "EverCrypt", root_interval);
 #endif
 
-    std::cout << "--- merklecpp trees with full SHA256: " << std::endl;
+    std::cout << "--- merklecpp trees with full SHA256: " << '\n';
 
 #ifdef HAVE_OPENSSL
     bench<OpenSSLFullTree>(hashes, "OpenSSL", root_interval);
 #endif
 
 #ifdef HAVE_OPENSSL
     {
-      std::cout << "--- merklecpp trees with full SHA384: " << std::endl;
+      std::cout << "--- merklecpp trees with full SHA384: " << '\n';
       auto hashes384 = make_hashesT<48>(num_leaves);
       benchT<merkle::Tree384, 48>(hashes384, "OpenSSL", root_interval);
     }
 
     {
-      std::cout << "--- merklecpp trees with full SHA512: " << std::endl;
+      std::cout << "--- merklecpp trees with full SHA512: " << '\n';
       auto hashes512 = make_hashesT<64>(num_leaves);
       benchT<merkle::Tree512, 64>(hashes512, "OpenSSL", root_interval);
     }
@@ -340,10 +346,10 @@ int main()
     }
 
     std::cout << "--- EverCrypt trees with SHA256 compression function: "
-              << std::endl;
+              << '\n';
     bench_evercrypt<mt_sha256_compress>(ec_hashes, "EverCrypt", root_interval);
 
-    std::cout << "--- EverCrypt trees with full SHA256: " << std::endl;
+    std::cout << "--- EverCrypt trees with full SHA256: " << '\n';
     bench_evercrypt<mt_sha256_evercrypt>(ec_hashes, "EverCrypt", root_interval);
 
     for (auto h : ec_hashes)
@@ -352,12 +358,12 @@ int main()
   }
   catch (std::exception& ex)
   {
-    std::cout << "Error: " << ex.what() << std::endl;
+    std::cout << "Error: " << ex.what() << '\n';
     return 1;
   }
   catch (...)
   {
-    std::cout << "Error" << std::endl;
+    std::cout << "Error" << '\n';
     return 1;
   }
 

test/time_large_trees.cpp

@@ -59,13 +59,15 @@ int main()
       {
         mt384.insert(h);
         if ((j384++ % root_interval) == 0)
+        {
           mt384.root();
+        }
       }
       mt384.root();
       auto stop384 = std::chrono::high_resolution_clock::now();
-      double seconds384 =
-        std::chrono::duration_cast<std::chrono::nanoseconds>(stop384 - start384)
-          .count() /
+      const double seconds384 =
+        static_cast<double>(std::chrono::duration_cast<std::chrono::nanoseconds>(stop384 - start384)
+          .count()) /
         1e9;
       std::cout << "SHA384: " << mt384.statistics.to_string() << " in "
                 << seconds384 << " sec" << '\n';
@@ -81,13 +83,15 @@ int main()
       {
         mt512.insert(h);
         if ((j512++ % root_interval) == 0)
+        {
           mt512.root();
+        }
       }
       mt512.root();
       auto stop512 = std::chrono::high_resolution_clock::now();
-      double seconds512 =
-        std::chrono::duration_cast<std::chrono::nanoseconds>(stop512 - start512)
-          .count() /
+      const double seconds512 =
+        static_cast<double>(std::chrono::duration_cast<std::chrono::nanoseconds>(stop512 - start512)
+          .count()) /
         1e9;
       std::cout << "SHA512: " << mt512.statistics.to_string() << " in "
                 << seconds512 << " sec" << '\n';