template <class T, class BASE> void IteratedHashBase<T, BASE>::TruncatedFinal(byte *digest, size_t size) { 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()); memcpy(digest, stateBuf, size); } this->Restart(); // reinit for next use }
void Tiger::Final(byte *hash) { PadLastBlock(56, 0x01); CorrectEndianess(data, data, 56); data[7] = countLo; Transform(digest, data); CorrectEndianess(digest, digest, DigestSize()); memcpy(hash, digest, DigestSize()); Reinit(); // reinit for next use }
void RIPEMD160::Final (byte *hash) { PadLastBlock(56); CorrectEndianess(data, data, 56); data[14] = countLo; data[15] = countHi; Transform(digest, data); CorrectEndianess(digest, digest, DIGESTSIZE); memcpy(hash, digest, DIGESTSIZE); Init(); // reinit for next use }
void TTMAC_Base::TruncatedFinal(byte *hash, size_t size) { PadLastBlock(BlockSize() - 2*sizeof(HashWordType)); CorrectEndianess(m_data, m_data, BlockSize() - 2*sizeof(HashWordType)); m_data[m_data.size()-2] = GetBitCountLo(); m_data[m_data.size()-1] = GetBitCountHi(); Transform(m_digest, m_data, true); word32 t2 = m_digest[2]; word32 t3 = m_digest[3]; if (size != DIGESTSIZE) { switch (size) { case 16: m_digest[3] += m_digest[1] + m_digest[4]; case 12: m_digest[2] += m_digest[0] + t3; case 8: m_digest[0] += m_digest[1] + t3; m_digest[1] += m_digest[4] + t2; break; case 4: m_digest[0] += m_digest[1] + m_digest[2] + m_digest[3] + m_digest[4]; break; case 0: // Used by HashTransformation::Restart() break; default: throw InvalidArgument("TTMAC_Base: can't truncate a Two-Track-MAC 20 byte digest to " + IntToString(size) + " bytes"); break; } } CorrectEndianess(m_digest, m_digest, size); memcpy(hash, m_digest, size); Restart(); // reinit for next use }
void PanamaHash<B>::TruncatedFinal(byte *hash, unsigned int size) { ThrowIfInvalidTruncatedSize(size); PadLastBlock(BLOCKSIZE, 0x01); vTransform(m_data); Iterate(32); // pull ConditionalByteReverse(B::ToEnum(), m_state+9, m_state+9, DIGESTSIZE); memcpy(hash, m_state+9, size); Restart(); // reinit for next use }
void PanamaHash<B>::TruncatedFinal(byte *hash, unsigned int size) { this->ThrowIfInvalidTruncatedSize(size); PadLastBlock(this->BLOCKSIZE, 0x01); HashEndianCorrectedBlock(this->m_data); this->Iterate(32); // pull ConditionalByteReverse(B::ToEnum(), this->m_state+9, this->m_state+9, DIGESTSIZE); memcpy(hash, this->m_state+9, size); this->Restart(); // reinit for next use }
void Tiger::TruncatedFinal(byte *hash, unsigned int size) { ThrowIfInvalidTruncatedSize(size); PadLastBlock(56, 0x01); CorrectEndianess(m_data, m_data, 56); m_data[7] = GetBitCountLo(); Transform(m_digest, m_data); CorrectEndianess(m_digest, m_digest, DigestSize()); memcpy(hash, m_digest, size); Restart(); // reinit for next use }
template <class T, class BASE> void IteratedHashBase<T, BASE>::TruncatedFinal(byte *digest, size_t size) { this->ThrowIfInvalidTruncatedSize(size); PadLastBlock(this->BlockSize() - 2*sizeof(HashWordType)); ByteOrder order = this->GetByteOrder(); ConditionalByteReverse<HashWordType>(order, this->m_data, this->m_data, this->BlockSize() - 2*sizeof(HashWordType)); this->m_data[this->m_data.size()-2] = order ? this->GetBitCountHi() : this->GetBitCountLo(); this->m_data[this->m_data.size()-1] = order ? this->GetBitCountLo() : this->GetBitCountHi(); HashEndianCorrectedBlock(this->m_data); ConditionalByteReverse<HashWordType>(order, this->m_digest, this->m_digest, this->DigestSize()); memcpy(digest, this->m_digest, size); this->Restart(); // reinit for next use }
void HAVAL::Final (byte *hash) { PadLastBlock(118, 1); // first byte of padding for HAVAL is 1 instead of 0x80 CorrectEndianess(data, data, 120); data[29] &= 0xffff; data[29] |= ((word32)digestSize<<25) | ((word32)pass<<19) | ((word32)VERSION<<16); data[30] = countLo; data[31] = countHi; vTransform(data); Tailor(digestSize*8); CorrectEndianess(digest, digest, digestSize); memcpy(hash, digest, digestSize); Reinit(); // reinit for next use }
void PanamaHash<B>::TruncatedFinal(byte *hash, size_t size) { this->ThrowIfInvalidTruncatedSize(size); PadLastBlock(this->BLOCKSIZE, 0x01); HashEndianCorrectedBlock(this->m_data); this->Iterate(32); // pull FixedSizeSecBlock<word32, 8> buf; this->Iterate(1, NULL, buf, NULL); memcpy(hash, buf, size); this->Restart(); // reinit for next use }
void Whirlpool::TruncatedFinal(byte *hash, size_t size) { ThrowIfInvalidTruncatedSize(size); PadLastBlock(32); CorrectEndianess(m_data, m_data, 32); m_data[m_data.size()-4] = 0; m_data[m_data.size()-3] = 0; m_data[m_data.size()-2] = GetBitCountHi(); m_data[m_data.size()-1] = GetBitCountLo(); Transform(m_digest, m_data); CorrectEndianess(m_digest, m_digest, DigestSize()); memcpy(hash, m_digest, size); Restart(); // reinit for next use }
void HAVAL::TruncatedFinal(byte *hash, unsigned int size) { ThrowIfInvalidTruncatedSize(size); PadLastBlock(118, 1); // first byte of padding for HAVAL is 1 instead of 0x80 CorrectEndianess(m_data, m_data, 120); m_data[29] &= 0xffff; m_data[29] |= ((word32)digestSize<<25) | ((word32)pass<<19) | ((word32)HAVAL_VERSION<<16); m_data[30] = GetBitCountLo(); m_data[31] = GetBitCountHi(); vTransform(m_data); Tailor(digestSize*8); CorrectEndianess(m_digest, m_digest, digestSize); memcpy(hash, m_digest, size); Restart(); // reinit for next use }
void MD5MAC::Final (byte *hash) { PadLastBlock(56); CorrectEndianess(data, data, 56); data[14] = countLo; data[15] = countHi; Transform(digest, data, key+4); unsigned i; for (i=0; i<4; i++) data[i] = key[8+i]; for (i=0; i<12; i++) data[i+4] = T[i] ^ key[8+i%4]; Transform(digest, data, key+4); CorrectEndianess(digest, digest, DIGESTSIZE); memcpy(hash, digest, DIGESTSIZE); Init(); // reinit for next use }
void MD5MAC_Base::TruncatedFinal(byte *hash, size_t size) { ThrowIfInvalidTruncatedSize(size); PadLastBlock(56); CorrectEndianess(m_data, m_data, 56); m_data[14] = GetBitCountLo(); m_data[15] = GetBitCountHi(); Transform(m_digest, m_data, m_key+4); unsigned i; for (i=0; i<4; i++) m_data[i] = m_key[8+i]; for (i=0; i<12; i++) m_data[i+4] = T[i] ^ m_key[8+i%4]; Transform(m_digest, m_data, m_key+4); CorrectEndianess(m_digest, m_digest, DIGESTSIZE); memcpy(hash, m_digest, size); Restart(); // reinit for next use }