/src/cryptopp/iterhash.cpp

Source (jump to first uncovered line)
// iterhash.cpp - originally written and placed in the public domain by Wei Dai

#ifndef __GNUC__
#define CRYPTOPP_MANUALLY_INSTANTIATE_TEMPLATES
#endif

#include "iterhash.h"
#include "misc.h"
#include "cpu.h"

NAMESPACE_BEGIN(CryptoPP)

template <class T, class BASE> void IteratedHashBase<T, BASE>::Update(const byte *input, size_t length)
{
  CRYPTOPP_ASSERT(!(input == NULLPTR && length != 0));
  if (length == 0) { return; }

  HashWordType oldCountLo = m_countLo, oldCountHi = m_countHi;
  if ((m_countLo = oldCountLo + HashWordType(length)) < oldCountLo)
    m_countHi++;             // carry from low to high
  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();
  unsigned int num = ModPowerOf2(oldCountLo, blockSize);

  T* dataBuf = this->DataBuf();
  byte* data = (byte *)dataBuf;

  if (num != 0)  // process left over data
  {
    if (num+length >= blockSize)
    {
      if (input)
        {std::memcpy(data+num, input, blockSize-num);}

      HashBlock(dataBuf);
      input += (blockSize-num);
      length -= (blockSize-num);
      num = 0;
      // drop through and do the rest
    }
    else
    {
      if (input && length)
        {std::memcpy(data+num, input, length);}
      return;
    }
  }

  // now process the input data in blocks of blockSize bytes and save the leftovers to m_data
  if (length >= blockSize)
  {
    if (input == data)
    {
      CRYPTOPP_ASSERT(length == blockSize);
      HashBlock(dataBuf);
      return;
    }
    else if (IsAligned<T>(input))
    {
      size_t leftOver = HashMultipleBlocks((T *)(void*)input, length);
      input += (length - leftOver);
      length = leftOver;
    }
    else
    {
      do
      {   // copy input first if it's not aligned correctly
        if (input)
          { std::memcpy(data, input, blockSize); }

        HashBlock(dataBuf);
        input+=blockSize;
        length-=blockSize;
      } while (length >= blockSize);
    }
  }

  if (input && data != input)
    std::memcpy(data, input, length);
}

template <class T, class BASE> byte * IteratedHashBase<T, BASE>::CreateUpdateSpace(size_t &size)
{
  unsigned int blockSize = this->BlockSize();
  unsigned int num = ModPowerOf2(m_countLo, blockSize);
  size = blockSize - num;
  return (byte *)DataBuf() + num;
}

template <class T, class BASE> size_t IteratedHashBase<T, BASE>::HashMultipleBlocks(const T *input, size_t length)
{
  const unsigned int blockSize = this->BlockSize();
  bool noReverse = NativeByteOrderIs(this->GetByteOrder());
  T* dataBuf = this->DataBuf();

  // Alignment checks due to http://github.com/weidai11/cryptopp/issues/690.
  // Sparc requires 8-byte aligned buffer when HashWordType is word64.
  // We also had to provide a GetAlignmentOf specialization for word64 on Sparc.

  do
  {
    if (noReverse)
    {
      if (IsAligned<HashWordType>(input))
      {
        // Sparc bus error with non-aligned input.
        this->HashEndianCorrectedBlock(input);
      }
      else
      {
        std::memcpy(dataBuf, input, blockSize);
        this->HashEndianCorrectedBlock(dataBuf);
      }
    }
    else
    {
      if (IsAligned<HashWordType>(input))
      {
        // Sparc bus error with non-aligned input.
        ByteReverse(dataBuf, input, blockSize);
        this->HashEndianCorrectedBlock(dataBuf);
      }
      else
      {
        std::memcpy(dataBuf, input, blockSize);
        ByteReverse(dataBuf, dataBuf, blockSize);
        this->HashEndianCorrectedBlock(dataBuf);
      }
    }

    input += blockSize/sizeof(T);
    length -= blockSize;
  }
  while (length >= blockSize);
  return length;
}

template <class T, class BASE> void IteratedHashBase<T, BASE>::PadLastBlock(unsigned int lastBlockSize, byte padFirst)
{
  unsigned int blockSize = this->BlockSize();
  unsigned int num = ModPowerOf2(m_countLo, blockSize);
  T* dataBuf = this->DataBuf();
  byte* data = (byte *)dataBuf;

  data[num++] = padFirst;
  if (num <= lastBlockSize)
    std::memset(data+num, 0, lastBlockSize-num);
  else
  {
    std::memset(data+num, 0, blockSize-num);
    HashBlock(dataBuf);
    std::memset(data, 0, lastBlockSize);
  }
}

template <class T, class BASE> void IteratedHashBase<T, BASE>::Restart()
{
  m_countLo = m_countHi = 0;
  Init();
}

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();
  T* stateBuf = this->StateBuf();
  unsigned int blockSize = this->BlockSize();
  ByteOrder order = this->GetByteOrder();

  PadLastBlock(blockSize - 2*sizeof(HashWordType));
  dataBuf[blockSize/sizeof(T)-2+order] = ConditionalByteReverse(order, this->GetBitCountLo());
  dataBuf[blockSize/sizeof(T)-1-order] = ConditionalByteReverse(order, this->GetBitCountHi());

  HashBlock(dataBuf);

  if (IsAligned<HashWordType>(digest) && size%sizeof(HashWordType)==0)
    ConditionalByteReverse<HashWordType>(order, (HashWordType *)(void*)digest, stateBuf, size);
  else
  {
    ConditionalByteReverse<HashWordType>(order, stateBuf, stateBuf, this->DigestSize());
    std::memcpy(digest, stateBuf, size);
  }

  this->Restart();    // reinit for next use
}

#if defined(__GNUC__) || defined(__clang__)
  template class IteratedHashBase<word64, HashTransformation>;
  template class IteratedHashBase<word64, MessageAuthenticationCode>;

  template class IteratedHashBase<word32, HashTransformation>;
  template class IteratedHashBase<word32, MessageAuthenticationCode>;
#endif

NAMESPACE_END

Coverage Report

Created: 2024-11-21 07:03