Convert all usage to the class

Author: mborland

include/boost/crypt/hash/md5.hpp

@@ -51,58 +51,9 @@ static constexpr boost::crypt::array<boost::crypt::uint32_t, 64> K {
         0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
 };
 
-// TODO(mborland): Replace the loop with the known statements
-auto md5_body(const boost::crypt::array<boost::crypt::uint32_t, 16>& blocks,
-              boost::crypt::uint32_t& a, boost::crypt::uint32_t& b,
-              boost::crypt::uint32_t& c, boost::crypt::uint32_t& d) noexcept
-{
-    boost::crypt::uint32_t A {a};
-    boost::crypt::uint32_t B {b};
-    boost::crypt::uint32_t C {c};
-    boost::crypt::uint32_t D {d};
-
-    for (boost::crypt::uint32_t i {}; i < 64U; ++i)
-    {
-        boost::crypt::uint32_t F {};
-        boost::crypt::uint32_t g {};
-
-        if (i <= 15U)
-        {
-            F = (B & C) | ((~B) & D);
-            g = i;
-        }
-        else if (i <= 31U)
-        {
-            F = (D & B) | ((~D) & C);
-            g = (5U * i + 1U) % 16U;
-        }
-        else if (i <= 47U)
-        {
-            F = B ^ C ^ D;
-            g = (3U * i + 5U) % 16U;
-        }
-        else
-        {
-            F = C ^ (B | (~D));
-            g = (7U * i) % 16U;
-        }
-
-        BOOST_CRYPT_ASSERT(i <= 63U);
-
-        F = F + A + K[i] + blocks[g];
-        A = D;
-        D = C;
-        C = B;
-        B = B + rotl(F, S[i]);
-    }
-
-    a += A;
-    b += B;
-    c += C;
-    d += D;
-}
+} // namespace detail
 
-class md5
+class md5_hasher
 {
 private:
     boost::crypt::uint32_t a0_ {0x67452301};
@@ -124,6 +75,8 @@ class md5
     template <typename ForwardIter>
     constexpr auto md5_copy_data(ForwardIter data, boost::crypt::size_t offset, boost::crypt::size_t size) noexcept;
 
+    constexpr auto md5_body() noexcept -> void;
+
 public:
     constexpr auto init() noexcept -> void;
 
@@ -138,7 +91,7 @@ class md5
     constexpr auto get_digest(DigestType digest, boost::crypt::size_t digest_size) noexcept;
 };
 
-constexpr auto md5::init() noexcept -> void
+constexpr auto md5_hasher::init() noexcept -> void
 {
     a0_ = 0x67452301U;
     b0_ = 0xefcdab89U;
@@ -152,7 +105,7 @@ constexpr auto md5::init() noexcept -> void
     blocks_.fill(0U);
 }
 
-constexpr auto md5::md5_convert_buffer_to_blocks() noexcept
+constexpr auto md5_hasher::md5_convert_buffer_to_blocks() noexcept
 {
     boost::crypt::size_t buffer_index {};
     for (auto& block : blocks_)
@@ -169,17 +122,17 @@ constexpr auto md5::md5_convert_buffer_to_blocks() noexcept
 }
 
 template <typename ForwardIter>
-constexpr auto md5::md5_copy_data(ForwardIter data, boost::crypt::size_t offset, boost::crypt::size_t size) noexcept
+constexpr auto md5_hasher::md5_copy_data(ForwardIter data, boost::crypt::size_t offset, boost::crypt::size_t size) noexcept
 {
     for (boost::crypt::size_t i {}; i < size; ++i)
     {
         BOOST_CRYPT_ASSERT(offset + i < buffer_.size());
-        buffer_[offset + i] = static_cast<boost::crypt::uint8_t>(*(data + i));
+        buffer_[offset + i] = static_cast<boost::crypt::uint8_t>(*(data + static_cast<boost::crypt::ptrdiff_t>(i)));
     }
 }
 
 template <typename ForwardIter>
-constexpr auto md5::md5_update(ForwardIter data, boost::crypt::size_t size) noexcept
+constexpr auto md5_hasher::md5_update(ForwardIter data, boost::crypt::size_t size) noexcept
 {
     const auto input_bits {size << 3U}; // Convert size to bits
     const auto old_low {low_};
@@ -203,16 +156,16 @@ constexpr auto md5::md5_update(ForwardIter data, boost::crypt::size_t size) noex
 
         md5_copy_data(data, used, available);
         md5_convert_buffer_to_blocks();
-        md5_body(blocks_, a0_, b0_, c0_, d0_);
-        data += available;
+        md5_body();
+        data += static_cast<boost::crypt::ptrdiff_t>(available);
         size -= available;
     }
 
     while (size >= 64U)
     {
         md5_copy_data(data, 0U, 64U);
         md5_convert_buffer_to_blocks();
-        md5_body(blocks_, a0_, b0_, c0_, d0_);
+        md5_body();
         data += 64U;
         size -= 64U;
     }
@@ -224,7 +177,7 @@ constexpr auto md5::md5_update(ForwardIter data, boost::crypt::size_t size) noex
 }
 
 template <typename DigestType>
-constexpr auto md5::get_digest(DigestType digest, boost::crypt::size_t digest_size) noexcept
+constexpr auto md5_hasher::get_digest(DigestType digest, boost::crypt::size_t digest_size) noexcept
 {
     auto used {(low_ >> 3U) & 0x3F}; // Number of bytes used in buffer
     buffer_[used++] = 0x80;
@@ -234,7 +187,7 @@ constexpr auto md5::get_digest(DigestType digest, boost::crypt::size_t digest_si
     {
         fill_array(buffer_.begin() + used, buffer_.end(), static_cast<boost::crypt::uint8_t>(0));
         md5_convert_buffer_to_blocks();
-        md5_body(blocks_, a0_, b0_, c0_, d0_);
+        md5_body();
         used = 0;
         buffer_.fill(0);
     }
@@ -256,140 +209,79 @@ constexpr auto md5::get_digest(DigestType digest, boost::crypt::size_t digest_si
     buffer_[63] = static_cast<boost::crypt::uint8_t>((total_bits >> 56) & 0xFF);
 
     md5_convert_buffer_to_blocks();
-    md5_body(blocks_, a0_, b0_, c0_, d0_);
+    md5_body();
 
     if (digest_size >= 4)
     {
-        digest[0] = swap_endian(a0_);
-        digest[1] = swap_endian(b0_);
-        digest[2] = swap_endian(c0_);
-        digest[3] = swap_endian(d0_);
+        digest[0] = detail::swap_endian(a0_);
+        digest[1] = detail::swap_endian(b0_);
+        digest[2] = detail::swap_endian(c0_);
+        digest[3] = detail::swap_endian(d0_);
     }
 }
 
 template <typename ByteType>
-constexpr auto md5::process_byte(ByteType byte) noexcept
+constexpr auto md5_hasher::process_byte(ByteType byte) noexcept
     BOOST_CRYPT_REQUIRES_CONVERSION(ByteType, boost::crypt::uint8_t)
 {
     md5_update(&byte, 1UL);
 }
 
 template <typename ForwardIter>
-constexpr auto md5::process_bytes(ForwardIter buffer, boost::crypt::size_t byte_count) noexcept
+constexpr auto md5_hasher::process_bytes(ForwardIter buffer, boost::crypt::size_t byte_count) noexcept
 {
     md5_update(buffer, byte_count);
 }
 
-template <typename ResultType, typename ForwardIterator>
-auto md5_impl(ForwardIterator first, ForwardIterator last) -> ResultType
+// TODO(mborland): Replace the loop with the known statements
+constexpr auto md5_hasher::md5_body() noexcept -> void
 {
-    // Initial MD5 buffer values
-    boost::crypt::uint32_t a0 {0x67452301};
-    boost::crypt::uint32_t b0 {0xefcdab89};
-    boost::crypt::uint32_t c0 {0x98badcfe};
-    boost::crypt::uint32_t d0 {0x10325476};
-
-    boost::crypt::array<boost::crypt::uint32_t, 16> blocks {};
-
-    // Store the original 'first' to compute the total message length
-    const auto total_message_length {static_cast<boost::crypt::uint64_t>(last - first) * 8UL};
-
-    // Handles the empty case with known values
-    if (first == last)
-    {
-        return ResultType{0xd41d8cd9, 0x8f00b204, 0xe9800998, 0xecf8427e};
-    }
+    boost::crypt::uint32_t A {a0_};
+    boost::crypt::uint32_t B {b0_};
+    boost::crypt::uint32_t C {c0_};
+    boost::crypt::uint32_t D {d0_};
 
-    while (first != last)
+    for (boost::crypt::uint32_t i {}; i < 64U; ++i)
     {
-        boost::crypt::size_t current_block = 0;
+        boost::crypt::uint32_t F {};
+        boost::crypt::uint32_t g {};
 
-        // Process as many full 64-byte blocks as possible
-        if (last - first >= 64)
+        if (i <= 15U)
+        {
+            F = (B & C) | ((~B) & D);
+            g = i;
+        }
+        else if (i <= 31U)
         {
-            for (auto& block : blocks)
-            {
-                block = static_cast<boost::crypt::uint32_t>(
-                        static_cast<boost::crypt::uint32_t>(*first) +
-                        (static_cast<boost::crypt::uint32_t>(*(first + 1U)) << 8U) +
-                        (static_cast<boost::crypt::uint32_t>(*(first + 2U)) << 16U) +
-                        (static_cast<boost::crypt::uint32_t>(*(first + 3U)) << 24U)
-                );
-
-                first += 4U;
-            }
-            md5_body(blocks, a0, b0, c0, d0);
+            F = (D & B) | ((~D) & C);
+            g = (5U * i + 1U) % 16U;
+        }
+        else if (i <= 47U)
+        {
+            F = B ^ C ^ D;
+            g = (3U * i + 5U) % 16U;
         }
         else
         {
-            // Process remaining bytes
-            // Initialize blocks to zero
-            blocks.fill(0);
-
-            // Process complete 4-byte chunks
-            while (last - first >= 4)
-            {
-                blocks[current_block] = static_cast<boost::crypt::uint32_t>(
-                        static_cast<boost::crypt::uint32_t>(*first) +
-                        (static_cast<boost::crypt::uint32_t>(*(first + 1U)) << 8U) +
-                        (static_cast<boost::crypt::uint32_t>(*(first + 2U)) << 16U) +
-                        (static_cast<boost::crypt::uint32_t>(*(first + 3U)) << 24U)
-                );
-
-                first += 4U;
-                ++current_block;
-            }
-
-            // Process remaining bytes (less than 4)
-            blocks[current_block] = 0;
-            auto byte_offset = 0U;
-            while (first != last)
-            {
-                blocks[current_block] |= static_cast<boost::crypt::uint32_t>(*first) << (8U * byte_offset);
-                ++first;
-                ++byte_offset;
-            }
-
-            // Append the '1' bit (0x80) after the last byte
-            blocks[current_block] |= static_cast<boost::crypt::uint32_t>(0x80) << (8U * byte_offset);
-            ++current_block;
-
-            // Check if there is enough space to append the length
-            if (current_block > 14U)
-            {
-                // Not enough space, process this block and start a new one
-                md5_body(blocks, a0, b0, c0, d0);
-                blocks.fill(0);
-                current_block = 0;
-            }
-
-            // Pad with zeros until block[14]
-            while (current_block < 14U)
-            {
-                blocks[current_block] = 0;
-                ++current_block;
-            }
-
-            // Append the 64-bit length in bits in little-endian format
-            blocks[14] = static_cast<boost::crypt::uint32_t>(total_message_length & 0xFFFFFFFF);
-            blocks[15] = static_cast<boost::crypt::uint32_t>((total_message_length >> 32) & 0xFFFFFFFF);
-
-            // Process the final block
-            md5_body(blocks, a0, b0, c0, d0);
-
-            // Break out of the loop as we've processed all data
-            break;
+            F = C ^ (B | (~D));
+            g = (7U * i) % 16U;
         }
+
+        BOOST_CRYPT_ASSERT(i <= 63U);
+
+        F = F + A + detail::K[i] + blocks_[g];
+        A = D;
+        D = C;
+        C = B;
+        B = B + detail::rotl(F, detail::S[i]);
     }
 
-    return ResultType {swap_endian(a0),
-                       swap_endian(b0),
-                       swap_endian(c0),
-                       swap_endian(d0)};
+    a0_ += A;
+    b0_ += B;
+    c0_ += C;
+    d0_ += D;
 }
 
-} // namespace detail
-
 template <typename ResultType = boost::crypt::array<boost::crypt::uint32_t, 4>, typename T>
 ResultType md5(T begin, T end)
 {
@@ -402,7 +294,12 @@ ResultType md5(T begin, T end)
         return ResultType{0xd41d8cd9, 0x8f00b204, 0xe9800998, 0xecf8427e};
     }
 
-    return detail::md5_impl<ResultType>(begin, end);
+    boost::crypt::md5_hasher hasher;
+    hasher.process_bytes(begin, static_cast<boost::crypt::size_t>(end - begin));
+    ResultType result;
+    hasher.get_digest(result.begin(), result.size());
+
+    return result;
 }
 
 template <typename ResultType = boost::crypt::array<boost::crypt::uint32_t, 4>>
@@ -414,20 +311,20 @@ ResultType md5(const char* str)
     }
 
     const auto message_len {std::strlen(str)};
-    return detail::md5_impl<ResultType>(str, str + message_len);
+    return md5<ResultType>(str, str + message_len);
 }
 
 template <typename ResultType = boost::crypt::array<boost::crypt::uint32_t, 4>>
 ResultType md5(const std::string& str)
 {
-    return md5(str.begin(), str.end());
+    return md5<ResultType>(str.begin(), str.end());
 }
 
 #ifdef BOOST_CRYPT_HAS_STRING_VIEW
 template <typename ResultType = boost::crypt::array<boost::crypt::uint32_t, 4>>
 ResultType md5(const std::string_view& str)
 {
-    return md5(str.begin(), str.end());
+    return md5<ResultType>(str.begin(), str.end());
 }
 #endif
 

test/test_md5.cpp

@@ -85,7 +85,7 @@ void bad_input()
 
 void test_class()
 {
-    boost::crypt::detail::md5 hasher;
+    boost::crypt::md5_hasher hasher;
 
     for (const auto& test_value : test_values)
     {