Clear initialization warning due to non-trivial destructor

1 files changed, 82 insertions, 24 deletions

diff --git a/blake2.cpp b/blake2.cpp
index eb7fc726..73cd4870 100644
--- a/blake2.cpp
+++ b/blake2.cpp
@@ -158,8 +158,8 @@ BLAKE2_ParameterBlock<false>::BLAKE2_ParameterBlock(size_t digestLen, size_t key
     fanout = depth = 1;

     nodeDepth = innerLength = 0;

 

-    memset(leafLength, 0x00, COUNTOF(leafLength));

-    memset(nodeOffset, 0x00, COUNTOF(nodeOffset));

+    std::memset(leafLength, 0x00, COUNTOF(leafLength));

+    std::memset(nodeOffset, 0x00, COUNTOF(nodeOffset));

 

     if (saltStr && saltLen)

     {

@@ -167,11 +167,11 @@ BLAKE2_ParameterBlock<false>::BLAKE2_ParameterBlock(size_t digestLen, size_t key
         const size_t rem = COUNTOF(salt) - saltLen;

         const size_t off = COUNTOF(salt) - rem;

         if (rem)

-            memset(salt+off, 0x00, rem);

+            std::memset(salt+off, 0x00, rem);

     }

     else

     {

-        memset(salt, 0x00, COUNTOF(salt));

+        std::memset(salt, 0x00, COUNTOF(salt));

     }

 

     if (personalizationStr && personalizationLen)

@@ -180,11 +180,11 @@ BLAKE2_ParameterBlock<false>::BLAKE2_ParameterBlock(size_t digestLen, size_t key
         const size_t rem = COUNTOF(personalization) - personalizationLen;

         const size_t off = COUNTOF(personalization) - rem;

         if (rem)

-            memset(personalization+off, 0x00, rem);

+            std::memset(personalization+off, 0x00, rem);

     }

     else

     {

-        memset(personalization, 0x00, COUNTOF(personalization));

+        std::memset(personalization, 0x00, COUNTOF(personalization));

     }

 }

 

@@ -198,9 +198,9 @@ BLAKE2_ParameterBlock<true>::BLAKE2_ParameterBlock(size_t digestLen, size_t keyL
     fanout = depth = 1;

     nodeDepth = innerLength = 0;

 

-    memset(rfu, 0x00, COUNTOF(rfu));

-    memset(leafLength, 0x00, COUNTOF(leafLength));

-    memset(nodeOffset, 0x00, COUNTOF(nodeOffset));

+    std::memset(rfu, 0x00, COUNTOF(rfu));

+    std::memset(leafLength, 0x00, COUNTOF(leafLength));

+    std::memset(nodeOffset, 0x00, COUNTOF(nodeOffset));

 

     if (saltStr && saltLen)

     {

@@ -208,11 +208,11 @@ BLAKE2_ParameterBlock<true>::BLAKE2_ParameterBlock(size_t digestLen, size_t keyL
         const size_t rem = COUNTOF(salt) - saltLen;

         const size_t off = COUNTOF(salt) - rem;

         if (rem)

-            memset(salt+off, 0x00, rem);

+            std::memset(salt+off, 0x00, rem);

     }

     else

     {

-        memset(salt, 0x00, COUNTOF(salt));

+        std::memset(salt, 0x00, COUNTOF(salt));

     }

 

     if (personalizationStr && personalizationLen)

@@ -221,16 +221,16 @@ BLAKE2_ParameterBlock<true>::BLAKE2_ParameterBlock(size_t digestLen, size_t keyL
         const size_t rem = COUNTOF(personalization) - personalizationLen;

         const size_t off = COUNTOF(personalization) - rem;

         if (rem)

-            memset(personalization+off, 0x00, rem);

+            std::memset(personalization+off, 0x00, rem);

     }

     else

     {

-        memset(personalization, 0x00, COUNTOF(personalization));

+        std::memset(personalization, 0x00, COUNTOF(personalization));

     }

 }

 

-template <class W, bool T_64bit>

-void BLAKE2_Base<W, T_64bit>::UncheckedSetKey(const byte *key, unsigned int length, const CryptoPP::NameValuePairs& params)

+template<>  // This specialization lacks rfu[] field

+void BLAKE2_Base<word32, false>::UncheckedSetKey(const byte *key, unsigned int length, const CryptoPP::NameValuePairs& params)

 {

     if (key && length)

     {

@@ -239,7 +239,63 @@ void BLAKE2_Base<W, T_64bit>::UncheckedSetKey(const byte *key, unsigned int leng
 

         const size_t rem = BLOCKSIZE - length;

         if (rem)

-            memset(temp+length, 0x00, rem);

+            std::memset(temp+length, 0x00, rem);

+

+        m_key.swap(temp);

+    }

+    else

+    {

+        m_key.resize(0);

+    }

+

+    ParameterBlock& block = *m_block.data();

+    std::memset(block.leafLength, 0x00, COUNTOF(block.leafLength));

+    std::memset(block.nodeOffset, 0x00, COUNTOF(block.nodeOffset));

+

+    block.nodeDepth = block.innerLength = 0;

+    block.keyLength = (byte)length;

+    block.digestLength = (byte)params.GetIntValueWithDefault(Name::DigestSize(), DIGESTSIZE);

+    block.fanout = block.depth = 1;

+

+    ConstByteArrayParameter t;

+    if (params.GetValue(Name::Salt(), t) && t.begin() && t.size())

+    {

+        memcpy_s(block.salt, COUNTOF(block.salt), t.begin(), t.size());

+        const size_t rem = COUNTOF(block.salt) - t.size();

+        const size_t off = COUNTOF(block.salt) - rem;

+        if (rem)

+            std::memset(block.salt+off, 0x00, rem);

+    }

+    else

+    {

+        std::memset(block.salt, 0x00, COUNTOF(block.salt));

+    }

+

+    if (params.GetValue(Name::Personalization(), t) && t.begin() && t.size())

+    {

+        memcpy_s(block.personalization, COUNTOF(block.personalization), t.begin(), t.size());

+        const size_t rem = COUNTOF(block.personalization) - t.size();

+        const size_t off = COUNTOF(block.personalization) - rem;

+        if (rem)

+            std::memset(block.personalization+off, 0x00, rem);

+    }

+    else

+    {

+        std::memset(block.personalization, 0x00, COUNTOF(block.personalization));

+    }

+}

+

+template<> // This specialization has rfu[] field

+void BLAKE2_Base<word64, true>::UncheckedSetKey(const byte *key, unsigned int length, const CryptoPP::NameValuePairs& params)

+{

+    if (key && length)

+    {

+        AlignedSecByteBlock temp(BLOCKSIZE);

+        memcpy_s(temp, BLOCKSIZE, key, length);

+

+        const size_t rem = BLOCKSIZE - length;

+        if (rem)

+            std::memset(temp+length, 0x00, rem);

 

         m_key.swap(temp);

     }

@@ -248,10 +304,12 @@ void BLAKE2_Base<W, T_64bit>::UncheckedSetKey(const byte *key, unsigned int leng
         m_key.resize(0);

     }

 

-    // Avoid Coverity finding SIZEOF_MISMATCH/suspicious_sizeof

     ParameterBlock& block = *m_block.data();

-    memset(m_block.data(), 0x00, sizeof(ParameterBlock));

+    std::memset(block.leafLength, 0x00, COUNTOF(block.leafLength));

+    std::memset(block.nodeOffset, 0x00, COUNTOF(block.nodeOffset));

+    std::memset(block.rfu, 0x00, COUNTOF(block.rfu));

 

+    block.nodeDepth = block.innerLength = 0;

     block.keyLength = (byte)length;

     block.digestLength = (byte)params.GetIntValueWithDefault(Name::DigestSize(), DIGESTSIZE);

     block.fanout = block.depth = 1;

@@ -263,11 +321,11 @@ void BLAKE2_Base<W, T_64bit>::UncheckedSetKey(const byte *key, unsigned int leng
         const size_t rem = COUNTOF(block.salt) - t.size();

         const size_t off = COUNTOF(block.salt) - rem;

         if (rem)

-            memset(block.salt+off, 0x00, rem);

+            std::memset(block.salt+off, 0x00, rem);

     }

     else

     {

-        memset(block.salt, 0x00, COUNTOF(block.salt));

+        std::memset(block.salt, 0x00, COUNTOF(block.salt));

     }

 

     if (params.GetValue(Name::Personalization(), t) && t.begin() && t.size())

@@ -276,11 +334,11 @@ void BLAKE2_Base<W, T_64bit>::UncheckedSetKey(const byte *key, unsigned int leng
         const size_t rem = COUNTOF(block.personalization) - t.size();

         const size_t off = COUNTOF(block.personalization) - rem;

         if (rem)

-            memset(block.personalization+off, 0x00, rem);

+            std::memset(block.personalization+off, 0x00, rem);

     }

     else

     {

-        memset(block.personalization, 0x00, COUNTOF(block.personalization));

+        std::memset(block.personalization, 0x00, COUNTOF(block.personalization));

     }

 }

 

@@ -300,7 +358,7 @@ std::string BLAKE2_Base_AlgorithmProvider()
 template <class W, bool T_64bit>

 std::string BLAKE2_Base<W, T_64bit>::AlgorithmProvider() const

 {

-	return BLAKE2_Base_AlgorithmProvider();

+    return BLAKE2_Base_AlgorithmProvider();

 }

 

 template <class W, bool T_64bit>

@@ -426,7 +484,7 @@ void BLAKE2_Base<W, T_64bit>::TruncatedFinal(byte *hash, size_t size)
     // Increment counter for tail bytes only

     IncrementCounter(state.length);

 

-    memset(state.buffer + state.length, 0x00, BLOCKSIZE - state.length);

+    std::memset(state.buffer + state.length, 0x00, BLOCKSIZE - state.length);

     Compress(state.buffer);

 

     // Copy to caller buffer