void Sha256Final(Sha256* sha256, byte* hash) { byte* local = (byte*)sha256->buffer; AddLength(sha256, sha256->buffLen); /* before adding pads */ local[sha256->buffLen++] = 0x80; /* add 1 */ /* pad with zeros */ if (sha256->buffLen > SHA256_PAD_SIZE) { XMEMSET(&local[sha256->buffLen], 0, SHA256_BLOCK_SIZE - sha256->buffLen); sha256->buffLen += SHA256_BLOCK_SIZE - sha256->buffLen; #if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU) ByteReverseBytes(local, local, SHA256_BLOCK_SIZE); #endif XTRANSFORM(sha256, local); sha256->buffLen = 0; } XMEMSET(&local[sha256->buffLen], 0, SHA256_PAD_SIZE - sha256->buffLen); /* put lengths in bits */ sha256->hiLen = (sha256->loLen >> (8*sizeof(sha256->loLen) - 3)) + (sha256->hiLen << 3); sha256->loLen = sha256->loLen << 3; /* store lengths */ #if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU) ByteReverseBytes(local, local, SHA256_BLOCK_SIZE); #endif /* ! length ordering dependent on digest endian type ! */ XMEMCPY(&local[SHA256_PAD_SIZE], &sha256->hiLen, sizeof(word32)); XMEMCPY(&local[SHA256_PAD_SIZE + sizeof(word32)], &sha256->loLen, sizeof(word32)); #ifdef FREESCALE_MMCAU /* Kinetis requires only these bytes reversed */ ByteReverseBytes(&local[SHA256_PAD_SIZE], &local[SHA256_PAD_SIZE], 2 * sizeof(word32)); #endif XTRANSFORM(sha256, local); #ifdef LITTLE_ENDIAN_ORDER ByteReverseWords(sha256->digest, sha256->digest, SHA256_DIGEST_SIZE); #endif XMEMCPY(hash, sha256->digest, SHA256_DIGEST_SIZE); InitSha256(sha256); /* reset state */ }
void RipeMdFinal(RipeMd* ripemd, byte* hash) { byte* local = (byte*)ripemd->buffer; AddLength(ripemd, ripemd->buffLen); /* before adding pads */ local[ripemd->buffLen++] = 0x80; /* add 1 */ /* pad with zeros */ if (ripemd->buffLen > RIPEMD_PAD_SIZE) { XMEMSET(&local[ripemd->buffLen], 0, RIPEMD_BLOCK_SIZE - ripemd->buffLen); ripemd->buffLen += RIPEMD_BLOCK_SIZE - ripemd->buffLen; #ifdef BIG_ENDIAN_ORDER ByteReverseBytes(local, local, RIPEMD_BLOCK_SIZE); #endif Transform(ripemd); ripemd->buffLen = 0; } XMEMSET(&local[ripemd->buffLen], 0, RIPEMD_PAD_SIZE - ripemd->buffLen); /* put lengths in bits */ ripemd->loLen = ripemd->loLen << 3; ripemd->hiLen = (ripemd->loLen >> (8*sizeof(ripemd->loLen) - 3)) + (ripemd->hiLen << 3); /* store lengths */ #ifdef BIG_ENDIAN_ORDER ByteReverseBytes(local, local, RIPEMD_BLOCK_SIZE); #endif /* ! length ordering dependent on digest endian type ! */ XMEMCPY(&local[RIPEMD_PAD_SIZE], &ripemd->loLen, sizeof(word32)); XMEMCPY(&local[RIPEMD_PAD_SIZE + sizeof(word32)], &ripemd->hiLen, sizeof(word32)); Transform(ripemd); #ifdef BIG_ENDIAN_ORDER ByteReverseWords(ripemd->digest, ripemd->digest, RIPEMD_DIGEST_SIZE); #endif XMEMCPY(hash, ripemd->digest, RIPEMD_DIGEST_SIZE); InitRipeMd(ripemd); /* reset state */ }
void Md5Final(Md5* md5, byte* hash) { byte* local = (byte*)md5->buffer; AddLength(md5, md5->buffLen); /* before adding pads */ local[md5->buffLen++] = 0x80; /* add 1 */ /* pad with zeros */ if (md5->buffLen > MD5_PAD_SIZE) { XMEMSET(&local[md5->buffLen], 0, MD5_BLOCK_SIZE - md5->buffLen); md5->buffLen += MD5_BLOCK_SIZE - md5->buffLen; #ifdef BIG_ENDIAN_ORDER ByteReverseBytes(local, local, MD5_BLOCK_SIZE); #endif Transform(md5); md5->buffLen = 0; } XMEMSET(&local[md5->buffLen], 0, MD5_PAD_SIZE - md5->buffLen); /* put lengths in bits */ md5->loLen = md5->loLen << 3; md5->hiLen = (md5->loLen >> (8*sizeof(md5->loLen) - 3)) + (md5->hiLen << 3); /* store lengths */ #ifdef BIG_ENDIAN_ORDER ByteReverseBytes(local, local, MD5_BLOCK_SIZE); #endif /* ! length ordering dependent on digest endian type ! */ XMEMCPY(&local[MD5_PAD_SIZE], &md5->loLen, sizeof(word32)); XMEMCPY(&local[MD5_PAD_SIZE + sizeof(word32)], &md5->hiLen, sizeof(word32)); Transform(md5); #ifdef BIG_ENDIAN_ORDER ByteReverseWords(md5->digest, md5->digest, MD5_DIGEST_SIZE); #endif XMEMCPY(hash, md5->digest, MD5_DIGEST_SIZE); InitMd5(md5); /* reset state */ }
void ShaFinal(Sha* sha, byte* hash) { byte* local = (byte*)sha->buffer; AddLength(sha, sha->buffLen); /* before adding pads */ local[sha->buffLen++] = 0x80; /* add 1 */ /* pad with zeros */ if (sha->buffLen > SHA_PAD_SIZE) { XMEMSET(&local[sha->buffLen], 0, SHA_BLOCK_SIZE - sha->buffLen); sha->buffLen += SHA_BLOCK_SIZE - sha->buffLen; #ifdef LITTLE_ENDIAN_ORDER ByteReverseBytes(local, local, SHA_BLOCK_SIZE); #endif Transform(sha); sha->buffLen = 0; } XMEMSET(&local[sha->buffLen], 0, SHA_PAD_SIZE - sha->buffLen); /* put lengths in bits */ sha->hiLen = (sha->loLen >> (8*sizeof(sha->loLen) - 3)) + (sha->hiLen << 3); sha->loLen = sha->loLen << 3; /* store lengths */ #ifdef LITTLE_ENDIAN_ORDER ByteReverseBytes(local, local, SHA_BLOCK_SIZE); #endif /* ! length ordering dependent on digest endian type ! */ XMEMCPY(&local[SHA_PAD_SIZE], &sha->hiLen, sizeof(word32)); XMEMCPY(&local[SHA_PAD_SIZE + sizeof(word32)], &sha->loLen, sizeof(word32)); Transform(sha); #ifdef LITTLE_ENDIAN_ORDER ByteReverseWords(sha->digest, sha->digest, SHA_DIGEST_SIZE); #endif XMEMCPY(hash, sha->digest, SHA_DIGEST_SIZE); InitSha(sha); /* reset state */ }
void Sha256Final(Sha256* sha256, byte* hash) { byte* local = (byte*)sha256->buffer; AddLength(sha256, sha256->buffLen); /* before adding pads */ local[sha256->buffLen++] = 0x80; /* add 1 */ /* pad with zeros */ if (sha256->buffLen > SHA256_PAD_SIZE) { memset(&local[sha256->buffLen], 0, SHA256_BLOCK_SIZE - sha256->buffLen); sha256->buffLen += SHA256_BLOCK_SIZE - sha256->buffLen; #ifdef LITTLE_ENDIAN_ORDER ByteReverseBytes(local, local, SHA256_BLOCK_SIZE); #endif Transform(sha256); sha256->buffLen = 0; } memset(&local[sha256->buffLen], 0, SHA256_PAD_SIZE - sha256->buffLen); /* put lengths in bits */ sha256->loLen = sha256->loLen << 3; sha256->hiLen = (sha256->loLen >> (8*sizeof(sha256->loLen) - 3)) + (sha256->hiLen << 3); /* store lengths */ #ifdef LITTLE_ENDIAN_ORDER ByteReverseBytes(local, local, SHA256_BLOCK_SIZE); #endif memcpy(&local[SHA256_PAD_SIZE], &sha256->hiLen, sizeof(word32)); memcpy(&local[SHA256_PAD_SIZE + sizeof(word32)], &sha256->loLen, sizeof(word32)); Transform(sha256); #ifdef LITTLE_ENDIAN_ORDER ByteReverseWords(sha256->digest, sha256->digest, SHA256_DIGEST_SIZE); #endif memcpy(hash, sha256->digest, SHA256_DIGEST_SIZE); InitSha256(sha256); /* reset state */ }
void Md4Final(Md4* md4, byte* hash) { byte* local = (byte*)md4->buffer; AddLength(md4, md4->buffLen); /* before adding pads */ local[md4->buffLen++] = 0x80; /* add 1 */ /* pad with zeros */ if (md4->buffLen > MD4_PAD_SIZE) { memset(&local[md4->buffLen], 0, MD4_BLOCK_SIZE - md4->buffLen); md4->buffLen += MD4_BLOCK_SIZE - md4->buffLen; #ifdef BIG_ENDIAN_ORDER ByteReverseBytes(local, local, MD4_BLOCK_SIZE); #endif Transform(md4); md4->buffLen = 0; } memset(&local[md4->buffLen], 0, MD4_PAD_SIZE - md4->buffLen); /* put lengths in bits */ md4->loLen = md4->loLen << 3; md4->hiLen = (md4->loLen >> (8*sizeof(md4->loLen) - 3)) + (md4->hiLen << 3); /* store lengths */ #ifdef BIG_ENDIAN_ORDER ByteReverseBytes(local, local, MD4_BLOCK_SIZE); #endif memcpy(&local[MD4_PAD_SIZE], &md4->loLen, sizeof(word32)); memcpy(&local[MD4_PAD_SIZE + sizeof(word32)], &md4->hiLen, sizeof(word32)); Transform(md4); #ifdef BIG_ENDIAN_ORDER ByteReverseWords(md4->digest, md4->digest, MD4_DIGEST_SIZE); #endif memcpy(hash, md4->digest, MD4_DIGEST_SIZE); InitMd4(md4); /* reset state */ }
void Md5Update(Md5* md5, const byte* data, word32 len) { /* do block size increments */ byte* local = (byte*)md5->buffer; while (len) { word32 add = min(len, MD5_BLOCK_SIZE - md5->buffLen); XMEMCPY(&local[md5->buffLen], data, add); md5->buffLen += add; data += add; len -= add; if (md5->buffLen == MD5_BLOCK_SIZE) { #ifdef BIG_ENDIAN_ORDER ByteReverseBytes(local, local, MD5_BLOCK_SIZE); #endif Transform(md5); AddLength(md5, MD5_BLOCK_SIZE); md5->buffLen = 0; } } }
void ShaUpdate(Sha* sha, const byte* data, word32 len) { /* do block size increments */ byte* local = (byte*)sha->buffer; while (len) { word32 add = min(len, SHA_BLOCK_SIZE - sha->buffLen); XMEMCPY(&local[sha->buffLen], data, add); sha->buffLen += add; data += add; len -= add; if (sha->buffLen == SHA_BLOCK_SIZE) { #ifdef LITTLE_ENDIAN_ORDER ByteReverseBytes(local, local, SHA_BLOCK_SIZE); #endif Transform(sha); AddLength(sha, SHA_BLOCK_SIZE); sha->buffLen = 0; } } }
void RipeMdUpdate(RipeMd* ripemd, const byte* data, word32 len) { /* do block size increments */ byte* local = (byte*)ripemd->buffer; while (len) { word32 add = min(len, RIPEMD_BLOCK_SIZE - ripemd->buffLen); XMEMCPY(&local[ripemd->buffLen], data, add); ripemd->buffLen += add; data += add; len -= add; if (ripemd->buffLen == RIPEMD_BLOCK_SIZE) { #ifdef BIG_ENDIAN_ORDER ByteReverseBytes(local, local, RIPEMD_BLOCK_SIZE); #endif Transform(ripemd); AddLength(ripemd, RIPEMD_BLOCK_SIZE); ripemd->buffLen = 0; } } }
void ShaUpdate(Sha* sha, const byte* data, word32 len) { /* do block size increments */ byte* local = (byte*)sha->buffer; while (len) { word32 add = min(len, SHA_BLOCK_SIZE - sha->buffLen); XMEMCPY(&local[sha->buffLen], data, add); sha->buffLen += add; data += add; len -= add; if (sha->buffLen == SHA_BLOCK_SIZE) { #if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU) ByteReverseBytes(local, local, SHA_BLOCK_SIZE); #endif XTRANSFORM(sha, local); AddLength(sha, SHA_BLOCK_SIZE); sha->buffLen = 0; } } }