Make checksumming more flexible

Author: mhx

include/dwarfs/checksum.h

@@ -22,31 +22,63 @@
 #pragma once
 
 #include <cstddef>
+#include <memory>
 #include <stdexcept>
 
+#include "dwarfs/error.h"
+
 namespace dwarfs {
 
-enum class checksum_algorithm {
-  SHA1,
-  SHA2_512_256,
-  XXH3_64,
-};
+class checksum {
+ public:
+  enum class algorithm {
+    SHA1,
+    SHA2_512_256,
+    XXH3_64,
+  };
+
+  static constexpr size_t digest_size(algorithm alg) {
+    switch (alg) {
+    case algorithm::SHA1:
+      return 20;
+    case algorithm::SHA2_512_256:
+      return 32;
+    case algorithm::XXH3_64:
+      return 8;
+    }
+    DWARFS_CHECK(false, "unknown algorithm");
+  }
+
+  static bool
+  compute(algorithm alg, void const* data, size_t size, void* digest);
+
+  static bool
+  verify(algorithm alg, void const* data, size_t size, void const* digest);
+
+  checksum(algorithm alg);
 
-constexpr size_t checksum_size(checksum_algorithm alg) {
-  switch (alg) {
-  case checksum_algorithm::SHA1:
-    return 20;
-  case checksum_algorithm::SHA2_512_256:
-    return 32;
-  case checksum_algorithm::XXH3_64:
-    return 8;
+  checksum& update(void const* data, size_t size) {
+    impl_->update(data, size);
+    return *this;
   }
-  throw std::logic_error("unknown algorithm");
-}
 
-bool compute_checksum(checksum_algorithm alg, void const* data, size_t size,
-                      void* result);
-bool verify_checksum(checksum_algorithm alg, void const* data, size_t size,
-                     const void* checksum);
+  bool finalize(void* digest) const { return impl_->finalize(digest); }
+
+  bool verify(void const* digest) const;
+
+  algorithm type() const { return alg_; }
+
+  class impl {
+   public:
+    virtual ~impl() = default;
+
+    virtual void update(void const* data, size_t size) = 0;
+    virtual bool finalize(void* digest) = 0;
+  };
+
+ private:
+  std::unique_ptr<impl> impl_;
+  algorithm const alg_;
+};
 
 } // namespace dwarfs

src/dwarfs/checksum.cpp

@@ -35,52 +35,134 @@ namespace dwarfs {
 namespace {
 
 bool compute_evp(const EVP_MD* algorithm, void const* data, size_t size,
-                 void* result, unsigned int* digest_size) {
-  return EVP_Digest(data, size, reinterpret_cast<unsigned char*>(result),
+                 void* digest, unsigned int* digest_size) {
+  return EVP_Digest(data, size, reinterpret_cast<unsigned char*>(digest),
                     digest_size, algorithm, nullptr);
 }
 
-bool compute_xxh3_64(void const* data, size_t size, void* result) {
-  auto checksum = XXH3_64bits(data, size);
-  static_assert(checksum_size(checksum_algorithm::XXH3_64) == sizeof(checksum));
-  ::memcpy(result, &checksum, sizeof(checksum));
+bool compute_xxh3_64(void const* data, size_t size, void* digest) {
+  auto hash = XXH3_64bits(data, size);
+  static_assert(checksum::digest_size(checksum::algorithm::XXH3_64) ==
+                sizeof(hash));
+  ::memcpy(digest, &hash, sizeof(hash));
   return true;
 }
 
+class checksum_evp : public checksum::impl {
+ public:
+  checksum_evp(EVP_MD const* evp, checksum::algorithm alg)
+      : context_(EVP_MD_CTX_new())
+      , dig_size_(checksum::digest_size(alg)) {
+    EVP_DigestInit_ex(context_, evp, nullptr);
+  }
+
+  ~checksum_evp() override { EVP_MD_CTX_destroy(context_); }
+
+  void update(void const* data, size_t size) override {
+    DWARFS_CHECK(EVP_DigestUpdate(context_, data, size),
+                 "EVP_DigestUpdate() failed");
+  }
+
+  bool finalize(void* digest) override {
+    unsigned int dig_size = 0;
+    bool rv = EVP_DigestFinal_ex(
+        context_, reinterpret_cast<unsigned char*>(digest), &dig_size);
+
+    if (rv) {
+      DWARFS_CHECK(
+          dig_size_ == dig_size,
+          fmt::format("digest size mismatch: {0} != {1}", dig_size_, dig_size));
+    }
+
+    return rv;
+  }
+
+ private:
+  EVP_MD_CTX* context_;
+  size_t const dig_size_;
+};
+
+class checksum_xxh3_64 : public checksum::impl {
+ public:
+  checksum_xxh3_64()
+      : state_(XXH3_createState()) {
+    DWARFS_CHECK(XXH3_64bits_reset(state_) == XXH_OK,
+                 "XXH3_64bits_reset() failed");
+  }
+
+  ~checksum_xxh3_64() override { XXH3_freeState(state_); }
+
+  void update(void const* data, size_t size) override {
+    auto err = XXH3_64bits_update(state_, data, size);
+    DWARFS_CHECK(err == XXH_OK, fmt::format("XXH3_64bits_update() failed: {}",
+                                            static_cast<int>(err)));
+  }
+
+  bool finalize(void* digest) override {
+    auto hash = XXH3_64bits_digest(state_);
+    ::memcpy(digest, &hash, sizeof(hash));
+    return true;
+  }
+
+ private:
+  XXH3_state_t* state_;
+};
+
 } // namespace
 
-bool compute_checksum(checksum_algorithm alg, void const* data, size_t size,
-                      void* result) {
+bool checksum::compute(algorithm alg, void const* data, size_t size,
+                       void* digest) {
   bool rv = false;
-  unsigned int digest_size = 0;
+  unsigned int dig_size = 0;
 
   switch (alg) {
-  case checksum_algorithm::SHA1:
-    rv = compute_evp(EVP_sha1(), data, size, result, &digest_size);
+  case algorithm::SHA1:
+    rv = compute_evp(EVP_sha1(), data, size, digest, &dig_size);
     break;
-  case checksum_algorithm::SHA2_512_256:
-    rv = compute_evp(EVP_sha512_256(), data, size, result, &digest_size);
+  case algorithm::SHA2_512_256:
+    rv = compute_evp(EVP_sha512_256(), data, size, digest, &dig_size);
     break;
-  case checksum_algorithm::XXH3_64:
-    rv = compute_xxh3_64(data, size, result);
+  case algorithm::XXH3_64:
+    rv = compute_xxh3_64(data, size, digest);
     break;
   }
 
-  if (rv && digest_size > 0) {
-    DWARFS_CHECK(checksum_size(alg) == digest_size,
+  if (rv && dig_size > 0) {
+    DWARFS_CHECK(digest_size(alg) == dig_size,
                  fmt::format("digest size mismatch: {0} != {1} [{2}]",
-                             checksum_size(alg), digest_size,
+                             digest_size(alg), dig_size,
                              static_cast<int>(alg)));
   }
 
   return rv;
 }
 
-bool verify_checksum(checksum_algorithm alg, void const* data, size_t size,
-                     const void* checksum) {
+bool checksum::verify(algorithm alg, void const* data, size_t size,
+                      const void* digest) {
+  char tmp[EVP_MAX_MD_SIZE];
+  return compute(alg, data, size, tmp) &&
+         ::memcmp(digest, tmp, digest_size(alg)) == 0;
+}
+
+checksum::checksum(algorithm alg)
+    : alg_(alg) {
+  switch (alg) {
+  case algorithm::SHA1:
+    impl_ = std::make_unique<checksum_evp>(EVP_sha1(), alg);
+    break;
+  case algorithm::SHA2_512_256:
+    impl_ = std::make_unique<checksum_evp>(EVP_sha512_256(), alg);
+    break;
+  case algorithm::XXH3_64:
+    impl_ = std::make_unique<checksum_xxh3_64>();
+    break;
+  }
+  DWARFS_CHECK(false, "unknown algorithm");
+}
+
+bool checksum::verify(void const* digest) const {
   char tmp[EVP_MAX_MD_SIZE];
-  return compute_checksum(alg, data, size, tmp) &&
-         ::memcmp(checksum, tmp, checksum_size(alg)) == 0;
+  return impl_->finalize(tmp) && ::memcmp(digest, tmp, digest_size(alg_)) == 0;
 }
 
 } // namespace dwarfs

src/dwarfs/entry.cpp

@@ -162,16 +162,16 @@ uint32_t file::inode_num() const { return inode_->num(); }
 void file::accept(entry_visitor& v, bool) { v.visit(this); }
 
 void file::scan(os_access& os, progress& prog) {
-  constexpr auto alg = checksum_algorithm::SHA1;
-  static_assert(checksum_size(alg) == sizeof(data::hash_type));
+  constexpr auto alg = checksum::algorithm::SHA1;
+  static_assert(checksum::digest_size(alg) == sizeof(data::hash_type));
 
   if (size_t s = size(); s > 0) {
     prog.original_size += s;
     auto mm = os.map_file(path(), s);
-    DWARFS_CHECK(compute_checksum(alg, mm->as<void>(), s, &data_->hash[0]),
+    DWARFS_CHECK(checksum::compute(alg, mm->as<void>(), s, &data_->hash[0]),
                  "checksum computation failed");
   } else {
-    DWARFS_CHECK(compute_checksum(alg, nullptr, 0, &data_->hash[0]),
+    DWARFS_CHECK(checksum::compute(alg, nullptr, 0, &data_->hash[0]),
                  "checksum computation failed");
   }
 }