arne
/
cryptopp
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Back-off on Hash asserts (GH #652) 

The asserts were a little aggressive and caused very noisy Debug runs. The library itself was one of the biggest offenders.
pull/655/head
Jeffrey Walton 2018-05-05 22:56:15 -04:00
parent 3deb24b7de
commit 3159969808
No known key found for this signature in database
GPG Key ID: B36AB348921B1838
6 changed files with 35 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
blake2.cpp
View File

@ -356,6 +356,9 @@ void BLAKE2_Base<W, T_64bit>::Restart(const BLAKE2_ParameterBlock<T_64bit>& bloc
template <class W, bool T_64bit>
void BLAKE2_Base<W, T_64bit>::Update(const byte *input, size_t length)
{
CRYPTOPP_ASSERT(input != NULLPTR);
if (length == 0) { return; }
State& state = *m_state.data();
if (state.length + length > BLOCKSIZE)
{
@ -390,6 +393,7 @@ void BLAKE2_Base<W, T_64bit>::Update(const byte *input, size_t length)
template <class W, bool T_64bit>
void BLAKE2_Base<W, T_64bit>::TruncatedFinal(byte *hash, size_t size)
{
CRYPTOPP_ASSERT(hash != NULLPTR);
this->ThrowIfInvalidTruncatedSize(size);
// Set last block unconditionally

37
iterhash.cpp
View File

@ -10,14 +10,16 @@
NAMESPACE_BEGIN(CryptoPP)
template <class T, class BASE> void IteratedHashBase<T, BASE>::Update(const byte *input, size_t len)
template <class T, class BASE> void IteratedHashBase<T, BASE>::Update(const byte *input, size_t length)
{
CRYPTOPP_ASSERT((input && len) || !(input || len));
CRYPTOPP_ASSERT(!(input == NULLPTR && length != 0));
if (length == 0) { return; }
HashWordType oldCountLo = m_countLo, oldCountHi = m_countHi;
if ((m_countLo = oldCountLo + HashWordType(len)) < oldCountLo)
if ((m_countLo = oldCountLo + HashWordType(length)) < oldCountLo)
m_countHi++; // carry from low to high
m_countHi += (HashWordType)SafeRightShift<8*sizeof(HashWordType)>(len);
if (m_countHi < oldCountHi || SafeRightShift<2*8*sizeof(HashWordType)>(len) != 0)
m_countHi += (HashWordType)SafeRightShift<8*sizeof(HashWordType)>(length);
if (m_countHi < oldCountHi || SafeRightShift<2*8*sizeof(HashWordType)>(length) != 0)
throw HashInputTooLong(this->AlgorithmName());
const unsigned int blockSize = this->BlockSize();
@ -29,36 +31,36 @@ template <class T, class BASE> void IteratedHashBase<T, BASE>::Update(const byte
if (num != 0) // process left over data
{
if (num+len >= blockSize)
if (num+length >= blockSize)
{
if (data && input) {memcpy(data+num, input, blockSize-num);}
HashBlock(dataBuf);
input += (blockSize-num);
len -= (blockSize-num);
length -= (blockSize-num);
num = 0;
// drop through and do the rest
}
else
{
if (data && input && len) {memcpy(data+num, input, len);}
if (data && input && length) {memcpy(data+num, input, length);}
return;
}
}
// now process the input data in blocks of blockSize bytes and save the leftovers to m_data
if (len >= blockSize)
if (length >= blockSize)
{
if (input == data)
{
CRYPTOPP_ASSERT(len == blockSize);
CRYPTOPP_ASSERT(length == blockSize);
HashBlock(dataBuf);
return;
}
else if (IsAligned<T>(input))
{
size_t leftOver = HashMultipleBlocks((T *)(void*)input, len);
input += (len - leftOver);
len = leftOver;
size_t leftOver = HashMultipleBlocks((T *)(void*)input, length);
input += (length - leftOver);
length = leftOver;
}
else
do
@ -66,12 +68,12 @@ template <class T, class BASE> void IteratedHashBase<T, BASE>::Update(const byte
if (data && input) memcpy(data, input, blockSize);
HashBlock(dataBuf);
input+=blockSize;
len-=blockSize;
} while (len >= blockSize);
length-=blockSize;
} while (length >= blockSize);
}
if (data && input && len && data != input)
memcpy(data, input, len);
if (data && input && data != input)
memcpy(data, input, length);
}
template <class T, class BASE> byte * IteratedHashBase<T, BASE>::CreateUpdateSpace(size_t &size)
@ -129,6 +131,7 @@ template <class T, class BASE> void IteratedHashBase<T, BASE>::Restart()
template <class T, class BASE> void IteratedHashBase<T, BASE>::TruncatedFinal(byte *digest, size_t size)
{
CRYPTOPP_ASSERT(digest != NULLPTR);
this->ThrowIfInvalidTruncatedSize(size);
T* dataBuf = this->DataBuf();

5
keccak.cpp
View File

@ -251,8 +251,8 @@ static void KeccakF1600(word64 *state)
void Keccak::Update(const byte *input, size_t length)
{
CRYPTOPP_ASSERT((input && length) || !(input || length));
if (!length) { return; }
CRYPTOPP_ASSERT(!(input == NULLPTR && length != 0));
if (length == 0) { return; }
size_t spaceLeft;
while (length >= (spaceLeft = r() - m_counter))
@ -278,6 +278,7 @@ void Keccak::Restart()
void Keccak::TruncatedFinal(byte *hash, size_t size)
{
CRYPTOPP_ASSERT(hash != NULLPTR);
ThrowIfInvalidTruncatedSize(size);
m_state.BytePtr()[m_counter] ^= 1;

5
sha3.cpp
View File

@ -251,8 +251,8 @@ static void KeccakF1600(word64 *state)
void SHA3::Update(const byte *input, size_t length)
{
CRYPTOPP_ASSERT((input && length) || !(input || length));
if (!length) { return; }
CRYPTOPP_ASSERT(!(input == NULLPTR && length != 0));
if (length == 0) { return; }
size_t spaceLeft;
while (length >= (spaceLeft = r() - m_counter))
@ -278,6 +278,7 @@ void SHA3::Restart()
void SHA3::TruncatedFinal(byte *hash, size_t size)
{
CRYPTOPP_ASSERT(hash != NULLPTR);
ThrowIfInvalidTruncatedSize(size);
m_state.BytePtr()[m_counter] ^= 0x06;

1
tiger.cpp
View File

@ -25,6 +25,7 @@ void Tiger::InitState(HashWordType *state)
void Tiger::TruncatedFinal(byte *hash, size_t size)
{
CRYPTOPP_ASSERT(hash != NULLPTR);
ThrowIfInvalidTruncatedSize(size);
PadLastBlock(56, 0x01);

4
whrlpool.cpp
View File

@ -96,6 +96,7 @@ void Whirlpool::InitState(HashWordType *state)
void Whirlpool::TruncatedFinal(byte *hash, size_t size)
{
CRYPTOPP_ASSERT(hash != NULLPTR);
ThrowIfInvalidTruncatedSize(size);
PadLastBlock(32);
@ -407,6 +408,9 @@ const word64 Whirlpool_C[4*256+R] = {
// Whirlpool basic transformation. Transforms state based on block.
void Whirlpool::Transform(word64 *digest, const word64 *block)
{
CRYPTOPP_ASSERT(digest != NULLPTR);
CRYPTOPP_ASSERT(block != NULLPTR);
#if CRYPTOPP_SSE2_ASM_AVAILABLE
if (HasSSE2())
{