int wc_Sha256Final(Sha256* sha256, byte* hash) { byte* local = (byte*)sha256->buffer; int ret; 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) ByteReverseWords(sha256->buffer, sha256->buffer, SHA256_BLOCK_SIZE); #endif ret = XTRANSFORM(sha256, local); if (ret != 0) return ret; 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) ByteReverseWords(sha256->buffer, sha256->buffer, 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 */ ByteReverseWords(&sha256->buffer[SHA256_PAD_SIZE/sizeof(word32)], &sha256->buffer[SHA256_PAD_SIZE/sizeof(word32)], 2 * sizeof(word32)); #endif ret = XTRANSFORM(sha256, local); if (ret != 0) return ret; #ifdef LITTLE_ENDIAN_ORDER ByteReverseWords(sha256->digest, sha256->digest, SHA256_DIGEST_SIZE); #endif XMEMCPY(hash, sha256->digest, SHA256_DIGEST_SIZE); return wc_InitSha256(sha256); /* reset state */ }
int wc_Des3_SetKey(Des3* des, const byte* key, const byte* iv, int dir) { word32 *dkey1 = des->key[0]; word32 *dreg = des->reg ; XMEMCPY(dkey1, key, 24); ByteReverseWords(dkey1, dkey1, 24); XMEMCPY(dreg, iv, 8); ByteReverseWords(dreg, dreg, 8) ; return 0; }
int wc_Des_SetKey(Des* des, const byte* key, const byte* iv, int dir) { word32 *dkey = des->key ; word32 *dreg = des->reg ; XMEMCPY((byte *)dkey, (byte *)key, 8); ByteReverseWords(dkey, dkey, 8); XMEMCPY((byte *)dreg, (byte *)iv, 8); ByteReverseWords(dreg, dreg, 8); return 0; }
int wc_RipeMdFinal(RipeMd* ripemd, byte* hash) { byte* local; if (ripemd == NULL || hash == NULL) { return BAD_FUNC_ARG; } 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 ByteReverseWords(ripemd->buffer, ripemd->buffer, 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 ByteReverseWords(ripemd->buffer, ripemd->buffer, 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); return wc_InitRipeMd(ripemd); /* reset state */ }
void Des3_SetKey(Des3* des, const byte* key, const byte* iv, int dir) { word32 *dkey1 = des->key[0]; word32 *dkey2 = des->key[1]; word32 *dkey3 = des->key[2]; XMEMCPY(dkey1, key, 8); /* set key 1 */ XMEMCPY(dkey2, key + 8, 8); /* set key 2 */ XMEMCPY(dkey3, key + 16, 8); /* set key 3 */ ByteReverseWords(dkey1, dkey1, 8); ByteReverseWords(dkey2, dkey2, 8); ByteReverseWords(dkey3, dkey3, 8); Des3_SetIV(des, iv); }
int wc_Sha256Update(Sha256 *sha256, const byte *data, word32 len) { /* do block size increments */ byte *local = (byte *)sha256->buffer; while (len) { word32 add = min(len, SHA256_BLOCK_SIZE - sha256->buffLen); XMEMCPY(&local[sha256->buffLen], data, add); sha256->buffLen += add; data += add; len -= add; if (sha256->buffLen == SHA256_BLOCK_SIZE) { int ret; ByteReverseWords(sha256->buffer, sha256->buffer, SHA256_BLOCK_SIZE); ret = XTRANSFORM(sha256, local); if (ret != 0) return ret; AddLength(sha256, SHA256_BLOCK_SIZE); sha256->buffLen = 0; } } return 0; }
static WC_INLINE void wc_Stm32_Hash_GetDigest(byte* hash, int digestSize) { word32 digest[HASH_MAX_DIGEST/sizeof(word32)]; /* get digest result */ digest[0] = HASH->HR[0]; digest[1] = HASH->HR[1]; digest[2] = HASH->HR[2]; digest[3] = HASH->HR[3]; if (digestSize >= 20) { digest[4] = HASH->HR[4]; #ifdef HASH_DIGEST if (digestSize >= 28) { digest[5] = HASH_DIGEST->HR[5]; digest[6] = HASH_DIGEST->HR[6]; if (digestSize == 32) digest[7] = HASH_DIGEST->HR[7]; } #endif } ByteReverseWords(digest, digest, digestSize); XMEMCPY(hash, digest, digestSize); }
int wc_ShaFinal(Sha* sha, byte* hash) { __IO uint16_t nbvalidbitsdata = 0; /* finish reading any trailing bytes into FIFO */ if (sha->buffLen) { HASH_DataIn(*(uint32_t*)sha->buffer); sha->loLen += sha->buffLen; } /* calculate number of valid bits in last word of input data */ nbvalidbitsdata = 8 * (sha->loLen % SHA_REG_SIZE); /* configure number of valid bits in last word of the data */ HASH_SetLastWordValidBitsNbr(nbvalidbitsdata); /* start HASH processor */ HASH_StartDigest(); /* wait until Busy flag == RESET */ while (HASH_GetFlagStatus(HASH_FLAG_BUSY) != RESET) {} /* read message digest */ sha->digest[0] = HASH->HR[0]; sha->digest[1] = HASH->HR[1]; sha->digest[2] = HASH->HR[2]; sha->digest[3] = HASH->HR[3]; sha->digest[4] = HASH->HR[4]; ByteReverseWords(sha->digest, sha->digest, SHA_DIGEST_SIZE); XMEMCPY(hash, sha->digest, SHA_DIGEST_SIZE); return wc_InitSha(sha); /* reset state */ }
int wc_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) ByteReverseWords(sha->buffer, sha->buffer, SHA_BLOCK_SIZE); #endif XTRANSFORM(sha, local); AddLength(sha, SHA_BLOCK_SIZE); sha->buffLen = 0; } } return 0; }
void Md5Final(Md5* md5, byte* hash) { __IO uint16_t nbvalidbitsdata = 0; /* finish reading any trailing bytes into FIFO */ if (md5->buffLen > 0) { HASH_DataIn(*(uint32_t*)md5->buffer); md5->loLen += md5->buffLen; } /* calculate number of valid bits in last word of input data */ nbvalidbitsdata = 8 * (md5->loLen % MD5_REG_SIZE); /* configure number of valid bits in last word of the data */ HASH_SetLastWordValidBitsNbr(nbvalidbitsdata); /* start HASH processor */ HASH_StartDigest(); /* wait until Busy flag == RESET */ while (HASH_GetFlagStatus(HASH_FLAG_BUSY) != RESET) {} /* read message digest */ md5->digest[0] = HASH->HR[0]; md5->digest[1] = HASH->HR[1]; md5->digest[2] = HASH->HR[2]; md5->digest[3] = HASH->HR[3]; ByteReverseWords(md5->digest, md5->digest, MD5_DIGEST_SIZE); XMEMCPY(hash, md5->digest, MD5_DIGEST_SIZE); InitMd5(md5); /* reset state */ }
int wc_RipeMdUpdate(RipeMd* ripemd, const byte* data, word32 len) { /* do block size increments */ byte* local; if (ripemd == NULL || (data == NULL && len > 0)) { return BAD_FUNC_ARG; } 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 ByteReverseWords(ripemd->buffer, ripemd->buffer, RIPEMD_BLOCK_SIZE); #endif Transform(ripemd); AddLength(ripemd, RIPEMD_BLOCK_SIZE); ripemd->buffLen = 0; } } return 0; }
int wc_Sha256Final(Sha256 *sha256, byte *hash) { byte *local = (byte *)sha256->buffer; int ret; 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; ByteReverseWords(sha256->buffer, sha256->buffer, SHA256_BLOCK_SIZE); ret = XTRANSFORM(sha256, local); if (ret != 0) return ret; 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 */ ByteReverseWords(sha256->buffer, sha256->buffer, SHA256_BLOCK_SIZE); /* ! 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)); ret = XTRANSFORM(sha256, local); if (ret != 0) return ret; ByteReverseWords(sha256->digest, sha256->digest, SHA256_DIGEST_SIZE); XMEMCPY(hash, sha256->digest, SHA256_DIGEST_SIZE); return wc_InitSha256(sha256); /* reset state */ }
void Des_SetKey(Des* des, const byte* key, const byte* iv, int dir) { word32 *dkey = des->key; XMEMCPY(dkey, key, 8); ByteReverseWords(dkey, dkey, 8); Des_SetIV(des, iv); }
void wc_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) { XMEMSET(&local[md4->buffLen], 0, MD4_BLOCK_SIZE - md4->buffLen); md4->buffLen += MD4_BLOCK_SIZE - md4->buffLen; #ifdef BIG_ENDIAN_ORDER ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE); #endif Transform(md4); md4->buffLen = 0; } XMEMSET(&local[md4->buffLen], 0, MD4_PAD_SIZE - md4->buffLen); /* put lengths in bits */ md4->hiLen = (md4->loLen >> (8*sizeof(md4->loLen) - 3)) + (md4->hiLen << 3); md4->loLen = md4->loLen << 3; /* store lengths */ #ifdef BIG_ENDIAN_ORDER ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE); #endif /* ! length ordering dependent on digest endian type ! */ XMEMCPY(&local[MD4_PAD_SIZE], &md4->loLen, sizeof(word32)); XMEMCPY(&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 XMEMCPY(hash, md4->digest, MD4_DIGEST_SIZE); wc_InitMd4(md4); /* 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; #if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU) ByteReverseWords(md5->buffer, md5->buffer, MD5_BLOCK_SIZE); #endif XTRANSFORM(md5, local); md5->buffLen = 0; } XMEMSET(&local[md5->buffLen], 0, MD5_PAD_SIZE - md5->buffLen); /* put lengths in bits */ md5->hiLen = (md5->loLen >> (8*sizeof(md5->loLen) - 3)) + (md5->hiLen << 3); md5->loLen = md5->loLen << 3; /* store lengths */ #if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU) ByteReverseWords(md5->buffer, md5->buffer, 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)); XTRANSFORM(md5, local); #ifdef BIG_ENDIAN_ORDER ByteReverseWords(md5->digest, md5->digest, MD5_DIGEST_SIZE); #endif XMEMCPY(hash, md5->digest, MD5_DIGEST_SIZE); InitMd5(md5); /* reset state */ }
int wc_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; #if defined(LITTLE_ENDIAN_ORDER) ByteReverseWords(sha->buffer, sha->buffer, SHA_BLOCK_SIZE); #endif XTRANSFORM(sha, local); 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 */ #if defined(LITTLE_ENDIAN_ORDER) ByteReverseWords(sha->buffer, sha->buffer, 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)); XTRANSFORM(sha, local); #ifdef LITTLE_ENDIAN_ORDER ByteReverseWords(sha->digest, sha->digest, SHA_DIGEST_SIZE); #endif XMEMCPY(hash, sha->digest, SHA_DIGEST_SIZE); return wc_InitSha(sha); /* 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) { memset(&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; } memset(&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 ! */ memcpy(&local[RIPEMD_PAD_SIZE], &ripemd->loLen, sizeof(word32)); memcpy(&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 memcpy(hash, ripemd->digest, RIPEMD_DIGEST_SIZE); InitRipeMd(ripemd); /* 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) { XMEMSET(&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; } XMEMSET(&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 /* ! 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)); Transform(sha256); #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 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) { memset(&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; } memset(&local[sha->buffLen], 0, SHA_PAD_SIZE - sha->buffLen); /* put lengths in bits */ sha->loLen = sha->loLen << 3; sha->hiLen = (sha->loLen >> (8*sizeof(sha->loLen) - 3)) + (sha->hiLen << 3); /* store lengths */ #ifdef LITTLE_ENDIAN_ORDER ByteReverseBytes(local, local, SHA_BLOCK_SIZE); #endif memcpy(&local[SHA_PAD_SIZE], &sha->hiLen, sizeof(word32)); memcpy(&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 memcpy(hash, sha->digest, SHA_DIGEST_SIZE); InitSha(sha); /* 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) { #if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU) ByteReverseWords(md5->buffer, md5->buffer, MD5_BLOCK_SIZE); #endif XTRANSFORM(md5, local); AddLength(md5, MD5_BLOCK_SIZE); md5->buffLen = 0; } } }
void wc_Md4Update(Md4* md4, const byte* data, word32 len) { /* do block size increments */ byte* local = (byte*)md4->buffer; while (len) { word32 add = min(len, MD4_BLOCK_SIZE - md4->buffLen); XMEMCPY(&local[md4->buffLen], data, add); md4->buffLen += add; data += add; len -= add; if (md4->buffLen == MD4_BLOCK_SIZE) { #ifdef BIG_ENDIAN_ORDER ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE); #endif Transform(md4); AddLength(md4, MD4_BLOCK_SIZE); md4->buffLen = 0; } } }
void DesCrypt(Des* des, byte* out, const byte* in, word32 sz, int dir, int mode) { word32 *dkey, *iv; CRYP_InitTypeDef DES_CRYP_InitStructure; CRYP_KeyInitTypeDef DES_CRYP_KeyInitStructure; CRYP_IVInitTypeDef DES_CRYP_IVInitStructure; dkey = des->key; iv = des->reg; /* crypto structure initialization */ CRYP_KeyStructInit(&DES_CRYP_KeyInitStructure); CRYP_StructInit(&DES_CRYP_InitStructure); CRYP_IVStructInit(&DES_CRYP_IVInitStructure); /* reset registers to their default values */ CRYP_DeInit(); /* set direction, mode, and datatype */ if (dir == DES_ENCRYPTION) { DES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Encrypt; } else { /* DES_DECRYPTION */ DES_CRYP_InitStructure.CRYP_AlgoDir = CRYP_AlgoDir_Decrypt; } if (mode == DES_CBC) { DES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_DES_CBC; } else { /* DES_ECB */ DES_CRYP_InitStructure.CRYP_AlgoMode = CRYP_AlgoMode_DES_ECB; } DES_CRYP_InitStructure.CRYP_DataType = CRYP_DataType_8b; CRYP_Init(&DES_CRYP_InitStructure); /* load key into correct registers */ DES_CRYP_KeyInitStructure.CRYP_Key1Left = dkey[0]; DES_CRYP_KeyInitStructure.CRYP_Key1Right = dkey[1]; CRYP_KeyInit(&DES_CRYP_KeyInitStructure); /* set iv */ ByteReverseWords(iv, iv, DES_BLOCK_SIZE); DES_CRYP_IVInitStructure.CRYP_IV0Left = iv[0]; DES_CRYP_IVInitStructure.CRYP_IV0Right = iv[1]; CRYP_IVInit(&DES_CRYP_IVInitStructure); /* enable crypto processor */ CRYP_Cmd(ENABLE); while (sz > 0) { /* flush IN/OUT FIFOs */ CRYP_FIFOFlush(); /* if input and output same will overwrite input iv */ XMEMCPY(des->tmp, in + sz - DES_BLOCK_SIZE, DES_BLOCK_SIZE); CRYP_DataIn(*(uint32_t*)&in[0]); CRYP_DataIn(*(uint32_t*)&in[4]); /* wait until the complete message has been processed */ while(CRYP_GetFlagStatus(CRYP_FLAG_BUSY) != RESET) {} *(uint32_t*)&out[0] = CRYP_DataOut(); *(uint32_t*)&out[4] = CRYP_DataOut(); /* store iv for next call */ XMEMCPY(des->reg, des->tmp, DES_BLOCK_SIZE); sz -= DES_BLOCK_SIZE; in += DES_BLOCK_SIZE; out += DES_BLOCK_SIZE; } /* disable crypto processor */ CRYP_Cmd(DISABLE); }
void DesCrypt(word32 *key, word32 *iv, byte* out, const byte* in, word32 sz, int dir, int algo, int cryptoalgo) { securityAssociation *sa_p ; bufferDescriptor *bd_p ; const byte *in_p, *in_l ; byte *out_p, *out_l ; volatile securityAssociation sa __attribute__((aligned (8))); volatile bufferDescriptor bd __attribute__((aligned (8))); /* get uncached address */ in_l = in; out_l = out ; sa_p = KVA0_TO_KVA1(&sa) ; bd_p = KVA0_TO_KVA1(&bd) ; in_p = KVA0_TO_KVA1(in_l) ; out_p= KVA0_TO_KVA1(out_l); if(PIC32MZ_IF_RAM(in_p)) XMEMCPY((void *)in_p, (void *)in, sz); XMEMSET((void *)out_p, 0, sz); /* Set up the Security Association */ XMEMSET((byte *)KVA0_TO_KVA1(&sa), 0, sizeof(sa)); sa_p->SA_CTRL.ALGO = algo ; sa_p->SA_CTRL.LNC = 1; sa_p->SA_CTRL.LOADIV = 1; sa_p->SA_CTRL.FB = 1; sa_p->SA_CTRL.ENCTYPE = dir ; /* Encryption/Decryption */ sa_p->SA_CTRL.CRYPTOALGO = cryptoalgo; sa_p->SA_CTRL.KEYSIZE = 1 ; /* KEY is 192 bits */ XMEMCPY((byte *)KVA0_TO_KVA1(&sa.SA_ENCKEY[algo==PIC32_ALGO_TDES ? 2 : 6]), (byte *)key, algo==PIC32_ALGO_TDES ? 24 : 8); XMEMCPY((byte *)KVA0_TO_KVA1(&sa.SA_ENCIV[2]), (byte *)iv, 8); XMEMSET((byte *)KVA0_TO_KVA1(&bd), 0, sizeof(bd)); /* Set up the Buffer Descriptor */ bd_p->BD_CTRL.BUFLEN = sz; bd_p->BD_CTRL.LIFM = 1; bd_p->BD_CTRL.SA_FETCH_EN = 1; bd_p->BD_CTRL.LAST_BD = 1; bd_p->BD_CTRL.PKT_INT_EN = 1; bd_p->BD_CTRL.DESC_EN = 1; bd_p->SA_ADDR = (unsigned int)KVA_TO_PA(&sa) ; /* (unsigned int)sa_p; */ bd_p->SRCADDR = (unsigned int)KVA_TO_PA(in) ; /* (unsigned int)in_p; */ bd_p->DSTADDR = (unsigned int)KVA_TO_PA(out); /* (unsigned int)out_p; */ bd_p->NXTPTR = (unsigned int)KVA_TO_PA(&bd); bd_p->MSGLEN = sz ; /* Fire in the hole! */ CECON = 1 << 6; while (CECON); CEPOLLCON = 10; // 10 SYSCLK delay between BD checks /* Run the engine */ CEBDPADDR = (unsigned int)KVA_TO_PA(&bd) ; /* (unsigned int)bd_p ; */ CEINTEN = 0x07; #if ((__PIC32_FEATURE_SET0 == 'E') && (__PIC32_FEATURE_SET1 == 'C')) // No output swap CECON = 0x27; #else CECON = 0xa7; #endif WAIT_ENGINE ; if((cryptoalgo == PIC32_CRYPTOALGO_CBC) || (cryptoalgo == PIC32_CRYPTOALGO_TCBC)|| (cryptoalgo == PIC32_CRYPTOALGO_RCBC)) { /* set iv for the next call */ if(dir == PIC32_ENCRYPTION) { XMEMCPY((void *)iv, (void*)&(out_p[sz-DES_IVLEN]), DES_IVLEN) ; } else { ByteReverseWords((word32*)iv, (word32 *)&(in_p[sz-DES_IVLEN]), DES_IVLEN); } } #if ((__PIC32_FEATURE_SET0 == 'E') && (__PIC32_FEATURE_SET1 == 'C')) // No output swap ByteReverseWords((word32*)out, (word32 *)KVA0_TO_KVA1(out), sz); #else SYS_DEVCON_DataCacheInvalidate((word32)out, sz); #endif }