1 files changed, 30 insertions, 27 deletions

diff --git a/src/lib/hash/mdx_hash/mdx_hash.cpp b/src/lib/hash/mdx_hash/mdx_hash.cpp
index 7d163dbfb..75893d51a 100644
--- a/src/lib/hash/mdx_hash/mdx_hash.cpp
+++ b/src/lib/hash/mdx_hash/mdx_hash.cpp
@@ -1,6 +1,6 @@
 /*
 * Merkle-Damgard Hash Function
-* (C) 1999-2008 Jack Lloyd
+* (C) 1999-2008,2018 Jack Lloyd
 *
 * Botan is released under the Simplified BSD License (see license.txt)
 */
@@ -15,16 +15,19 @@ namespace Botan {
 * MDx_HashFunction Constructor
 */
 MDx_HashFunction::MDx_HashFunction(size_t block_len,
-                                   bool byte_end,
-                                   bool bit_end,
-                                   size_t cnt_size) :
-   m_buffer(block_len),
+                                   bool byte_big_endian,
+                                   bool bit_big_endian,
+                                   uint8_t cnt_size) :
+   m_pad_char(bit_big_endian == true ? 0x80 : 0x01),
+   m_counter_size(cnt_size),
+   m_count_big_endian(byte_big_endian),
+   m_block_len(block_len),
    m_count(0),
-   m_position(0),
-   BIG_BYTE_ENDIAN(byte_end),
-   BIG_BIT_ENDIAN(bit_end),
-   COUNT_SIZE(cnt_size)
+   m_buffer(m_block_len),
+   m_position(0)
    {
+   if(m_counter_size < 8 || m_counter_size > m_block_len)
+      throw Invalid_State("MDx_HashFunction invalid counter length");
    }
 
 /*
@@ -47,22 +50,24 @@ void MDx_HashFunction::add_data(const uint8_t input[], size_t length)
       {
       buffer_insert(m_buffer, m_position, input, length);
 
-      if(m_position + length >= m_buffer.size())
+      if(m_position + length >= m_block_len)
          {
          compress_n(m_buffer.data(), 1);
-         input += (m_buffer.size() - m_position);
-         length -= (m_buffer.size() - m_position);
+         input += (m_block_len - m_position);
+         length -= (m_block_len - m_position);
          m_position = 0;
          }
       }
 
-   const size_t full_blocks = length / m_buffer.size();
-   const size_t remaining   = length % m_buffer.size();
+   const size_t full_blocks = length / m_block_len;
+   const size_t remaining   = length % m_block_len;
 
-   if(full_blocks)
+   if(full_blocks > 0)
+      {
       compress_n(input, full_blocks);
+      }
 
-   buffer_insert(m_buffer, m_position, input + full_blocks * m_buffer.size(), remaining);
+   buffer_insert(m_buffer, m_position, input + full_blocks * m_block_len, remaining);
    m_position += remaining;
    }
 
@@ -71,16 +76,16 @@ void MDx_HashFunction::add_data(const uint8_t input[], size_t length)
 */
 void MDx_HashFunction::final_result(uint8_t output[])
    {
-   clear_mem(&m_buffer[m_position], m_buffer.size() - m_position);
-   m_buffer[m_position] = (BIG_BIT_ENDIAN ? 0x80 : 0x01);
+   clear_mem(&m_buffer[m_position], m_block_len - m_position);
+   m_buffer[m_position] = m_pad_char;
 
-   if(m_position >= m_buffer.size() - COUNT_SIZE)
+   if(m_position >= m_block_len - m_counter_size)
       {
       compress_n(m_buffer.data(), 1);
       zeroise(m_buffer);
       }
 
-   write_count(&m_buffer[m_buffer.size() - COUNT_SIZE]);
+   write_count(&m_buffer[m_block_len - m_counter_size]);
 
    compress_n(m_buffer.data(), 1);
    copy_out(output);
@@ -92,17 +97,15 @@ void MDx_HashFunction::final_result(uint8_t output[])
 */
 void MDx_HashFunction::write_count(uint8_t out[])
    {
-   if(COUNT_SIZE < 8)
-      throw Invalid_State("MDx_HashFunction::write_count: COUNT_SIZE < 8");
-   if(COUNT_SIZE >= output_length() || COUNT_SIZE >= hash_block_size())
-      throw Invalid_Argument("MDx_HashFunction: COUNT_SIZE is too big");
+   BOTAN_ASSERT_NOMSG(m_counter_size <= output_length());
+   BOTAN_ASSERT_NOMSG(m_counter_size >= 8);
 
    const uint64_t bit_count = m_count * 8;
 
-   if(BIG_BYTE_ENDIAN)
-      store_be(bit_count, out + COUNT_SIZE - 8);
+   if(m_count_big_endian)
+      store_be(bit_count, out + m_counter_size - 8);
    else
-      store_le(bit_count, out + COUNT_SIZE - 8);
+      store_le(bit_count, out + m_counter_size - 8);
    }
 
 }