Refactor SHA1 utility with exception handling

Author: Easton97-Jens

src/utils/sha1.h

@@ -3,7 +3,7 @@
  * Copyright (c) 2015 - 2021 Trustwave Holdings, Inc. (http://www.trustwave.com/)
  *
  * You may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
+ * the License. You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
@@ -17,75 +17,78 @@
 #define SRC_UTILS_SHA1_H_
 
 #include <array>
+#include <exception>
 #include <string>
 #include <string_view>
-#include <stdexcept>
 
 #include "src/utils/string.h"
 #include "mbedtls/md.h"
 
 namespace modsecurity::Utils {
 
+class DigestCalculationException : public std::exception {
+ public:
+    explicit DigestCalculationException(const char *message) noexcept
+        : m_message(message) { }
+
+    const char *what() const noexcept override {
+        return m_message;
+    }
+
+ private:
+    const char *m_message;
+};
+
+
 template<mbedtls_md_type_t DigestType, int DigestSize>
 class DigestImpl {
  public:
-
     static std::string digest(const std::string& input) {
-        return digestHelper(input, [](const auto digest) { 
-            return std::string(digest);
-        });
+        const auto digestBytes = calculateDigest(input);
+        return std::string(digestBytes.begin(), digestBytes.end());
     }
 
     static void digestReplace(std::string& value) {
-        digestHelper(value, [&value](const auto digest) mutable { 
-            value = digest;
-        });
+        const auto digestBytes = calculateDigest(value);
+        value.assign(digestBytes.begin(), digestBytes.end());
     }
 
-    static std::string hexdigest(const std::string &input) {
-        return digestHelper(input, [](const auto digest) { 
-            return utils::string::string_to_hex(digest);
-        });
+    static std::string hexdigest(const std::string& input) {
+        const auto digestBytes = calculateDigest(input);
+        const std::string digestString(digestBytes.begin(), digestBytes.end());
+        return utils::string::string_to_hex(digestString);
     }
 
-private:
-
-    template<typename ConvertOp>
-    static auto digestHelper(std::string_view input,
-        ConvertOp convertOp) {
+ private:
+    static std::array<unsigned char, DigestSize> calculateDigest(
+        std::string_view input) {
+        std::array<unsigned char, DigestSize> digestBytes = {};
 
-        std::array<unsigned char, DigestSize> digest = {};
-
-        const auto *mdInfo = mbedtls_md_info_from_type(DigestType);
+        const mbedtls_md_info_t *mdInfo = mbedtls_md_info_from_type(DigestType);
         if (mdInfo == nullptr) {
-            throw std::runtime_error(
+            throw DigestCalculationException(
                 "mbedtls_md_info_from_type() returned nullptr");
         }
 
-        const int ret = mbedtls_md(
-            mdInfo,
-            reinterpret_cast<const unsigned char *>(input.data()),
-            input.size(),
-            digest.data());
+        const auto *inputBytes =
+            static_cast<const unsigned char *>(static_cast<const void *>(input.data()));
 
-        if (ret != 0) {
-            throw std::runtime_error(
-                "mbedtls_md() failed with error code: " + std::to_string(ret));
+        if (const int ret = mbedtls_md(
+                mdInfo,
+                inputBytes,
+                input.size(),
+                digestBytes.data()); ret != 0) {
+            throw DigestCalculationException("mbedtls_md() failed");
         }
 
-        // mbedtls uses unsigned char buffers, while string_view expects char.
-        const auto *digestChars =
-            reinterpret_cast<const char *>(digest.data());
-
-        return convertOp(std::string_view(digestChars, DigestSize));
+        return digestBytes;
     }
 };
 
 
 class Sha1 : public DigestImpl<MBEDTLS_MD_SHA1, 20> {
 };
 
-
 }  // namespace modsecurity::Utils
 
 #endif  // SRC_UTILS_SHA1_H_