new_build_system (#18)

Reviewed-on: #18

support/src/utils/hash.cpp

@@ -23,47 +23,140 @@
 
 #if defined(PROJECT_ENABLE_LIBSODIUM)
 
-namespace {} // namespace
-
 namespace repertory::utils::encryption {
 auto create_hash_blake2b_256(std::string_view data) -> hash_256_t {
-  return create_hash_blake2b_t<char, hash_256_t>(data);
+  return create_hash_blake2b_t<hash_256_t>(
+      reinterpret_cast<const unsigned char *>(data.data()), data.size());
 }
 
 auto create_hash_blake2b_256(std::wstring_view data) -> hash_256_t {
-  return create_hash_blake2b_t<wchar_t, hash_256_t>(data);
+  return create_hash_blake2b_t<hash_256_t>(
+      reinterpret_cast<const unsigned char *>(data.data()),
+      data.size() * sizeof(wchar_t));
+}
+
+auto create_hash_blake2b_256(const data_buffer &data) -> hash_256_t {
+  return create_hash_blake2b_t<hash_256_t>(
+      reinterpret_cast<const unsigned char *>(data.data()),
+      data.size() * sizeof(data_buffer::value_type));
 }
 
 auto create_hash_blake2b_384(std::string_view data) -> hash_384_t {
-  return create_hash_blake2b_t<char, hash_384_t>(data);
+  return create_hash_blake2b_t<hash_384_t>(
+      reinterpret_cast<const unsigned char *>(data.data()), data.size());
 }
 
 auto create_hash_blake2b_384(std::wstring_view data) -> hash_384_t {
-  return create_hash_blake2b_t<wchar_t, hash_384_t>(data);
+  return create_hash_blake2b_t<hash_384_t>(
+      reinterpret_cast<const unsigned char *>(data.data()),
+      data.size() * sizeof(wchar_t));
+}
+
+auto create_hash_blake2b_384(const data_buffer &data) -> hash_384_t {
+  return create_hash_blake2b_t<hash_384_t>(
+      reinterpret_cast<const unsigned char *>(data.data()),
+      data.size() * sizeof(data_buffer::value_type));
 }
 
 auto create_hash_blake2b_512(std::string_view data) -> hash_512_t {
-  return create_hash_blake2b_t<char, hash_512_t>(data);
+  return create_hash_blake2b_t<hash_512_t>(
+      reinterpret_cast<const unsigned char *>(data.data()), data.size());
 }
 
 auto create_hash_blake2b_512(std::wstring_view data) -> hash_512_t {
-  return create_hash_blake2b_t<wchar_t, hash_512_t>(data);
+  return create_hash_blake2b_t<hash_512_t>(
+      reinterpret_cast<const unsigned char *>(data.data()),
+      data.size() * sizeof(wchar_t));
+}
+
+auto create_hash_blake2b_512(const data_buffer &data) -> hash_512_t {
+  return create_hash_blake2b_t<hash_512_t>(
+      reinterpret_cast<const unsigned char *>(data.data()),
+      data.size() * sizeof(data_buffer::value_type));
 }
 
 auto create_hash_sha256(std::string_view data) -> hash_256_t {
-  return create_hash_sha256_t<char>(data);
+  return create_hash_sha256(
+      reinterpret_cast<const unsigned char *>(data.data()), data.size());
 }
 
 auto create_hash_sha256(std::wstring_view data) -> hash_256_t {
-  return create_hash_sha256_t<wchar_t>(data);
+  return create_hash_sha256(
+      reinterpret_cast<const unsigned char *>(data.data()),
+      data.size() * sizeof(wchar_t));
+}
+
+auto create_hash_sha256(const data_buffer &data) -> hash_256_t {
+  return create_hash_sha256(
+      reinterpret_cast<const unsigned char *>(data.data()),
+      data.size() * sizeof(data_buffer::value_type));
 }
 
 auto create_hash_sha512(std::string_view data) -> hash_512_t {
-  return create_hash_sha512_t<char>(data);
+  return create_hash_sha512(
+      reinterpret_cast<const unsigned char *>(data.data()), data.size());
 }
 
 auto create_hash_sha512(std::wstring_view data) -> hash_512_t {
-  return create_hash_sha512_t<wchar_t>(data);
+  return create_hash_sha512(
+      reinterpret_cast<const unsigned char *>(data.data()),
+      data.size() * sizeof(wchar_t));
+}
+
+auto create_hash_sha512(const data_buffer &data) -> hash_512_t {
+  return create_hash_sha512(
+      reinterpret_cast<const unsigned char *>(data.data()),
+      data.size() * sizeof(data_buffer::value_type));
+}
+
+auto create_hash_sha512(const unsigned char *data,
+                        std::size_t data_size) -> hash_512_t {
+  hash_512_t hash{};
+
+  crypto_hash_sha512_state state{};
+  auto res = crypto_hash_sha512_init(&state);
+  if (res != 0) {
+    throw std::runtime_error("failed to initialize sha-512|" +
+                             std::to_string(res));
+  }
+
+  res = crypto_hash_sha512_update(&state, data, data_size);
+  if (res != 0) {
+    throw std::runtime_error("failed to update sha-512|" + std::to_string(res));
+  }
+
+  res = crypto_hash_sha512_final(&state, hash.data());
+  if (res != 0) {
+    throw std::runtime_error("failed to finalize sha-512|" +
+                             std::to_string(res));
+  }
+
+  return hash;
+}
+
+auto create_hash_sha256(const unsigned char *data,
+                        std::size_t data_size) -> hash_256_t {
+  hash_256_t hash{};
+
+  crypto_hash_sha256_state state{};
+  auto res = crypto_hash_sha256_init(&state);
+  if (res != 0) {
+    throw std::runtime_error("failed to initialize sha-256|" +
+                             std::to_string(res));
+  }
+
+  res = crypto_hash_sha256_update(&state, data, data_size);
+  if (res != 0) {
+    throw std::runtime_error("failed to update sha-256|" + std::to_string(res));
+  }
+
+  res = crypto_hash_sha256_final(&state, hash.data());
+  if (res != 0) {
+    throw std::runtime_error("failed to finalize sha-256|" +
+                             std::to_string(res));
+  }
+
+  return hash;
 }
 } // namespace repertory::utils::encryption