feedc0de/wolfssl
1
0
Fork 0
forked from wolfSSL/wolfssl
Code Pull Requests Activity

new changes

Browse Source
This commit is contained in:
kaleb-himes
2014-12-29 10:27:03 -07:00
parent db383fbbac
commit edf53a1ed0
80 changed files with 7421 additions and 4826 deletions
Download Patch File Download Diff File Expand all files Collapse all files

179
ctaocrypt/src/arc4.c Normal file
View File

@ -0,0 +1,179 @@
/* arc4.c
*
* Copyright (C) 2006-2014 wolfSSL Inc.
*
* This file is part of CyaSSL.
*
* CyaSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* CyaSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <cyassl/ctaocrypt/settings.h>
#ifndef NO_RC4
#include <cyassl/ctaocrypt/arc4.h>
#ifdef HAVE_CAVIUM
static void Arc4CaviumSetKey(Arc4* arc4, const byte* key, word32 length);
static void Arc4CaviumProcess(Arc4* arc4, byte* out, const byte* in,
word32 length);
#endif
void Arc4SetKey(Arc4* arc4, const byte* key, word32 length)
{
word32 i;
word32 keyIndex = 0, stateIndex = 0;
#ifdef HAVE_CAVIUM
if (arc4->magic == CYASSL_ARC4_CAVIUM_MAGIC)
return Arc4CaviumSetKey(arc4, key, length);
#endif
arc4->x = 1;
arc4->y = 0;
for (i = 0; i < ARC4_STATE_SIZE; i++)
arc4->state[i] = (byte)i;
for (i = 0; i < ARC4_STATE_SIZE; i++) {
word32 a = arc4->state[i];
stateIndex += key[keyIndex] + a;
stateIndex &= 0xFF;
arc4->state[i] = arc4->state[stateIndex];
arc4->state[stateIndex] = (byte)a;
if (++keyIndex >= length)
keyIndex = 0;
}
}
static INLINE byte MakeByte(word32* x, word32* y, byte* s)
{
word32 a = s[*x], b;
*y = (*y+a) & 0xff;
b = s[*y];
s[*x] = (byte)b;
s[*y] = (byte)a;
*x = (*x+1) & 0xff;
return s[(a+b) & 0xff];
}
void Arc4Process(Arc4* arc4, byte* out, const byte* in, word32 length)
{
word32 x;
word32 y;
#ifdef HAVE_CAVIUM
if (arc4->magic == CYASSL_ARC4_CAVIUM_MAGIC)
return Arc4CaviumProcess(arc4, out, in, length);
#endif
x = arc4->x;
y = arc4->y;
while(length--)
*out++ = *in++ ^ MakeByte(&x, &y, arc4->state);
arc4->x = (byte)x;
arc4->y = (byte)y;
}
#ifdef HAVE_CAVIUM
#include <cyassl/ctaocrypt/logging.h>
#include "cavium_common.h"
/* Initiliaze Arc4 for use with Nitrox device */
int Arc4InitCavium(Arc4* arc4, int devId)
{
if (arc4 == NULL)
return -1;
if (CspAllocContext(CONTEXT_SSL, &arc4->contextHandle, devId) != 0)
return -1;
arc4->devId = devId;
arc4->magic = CYASSL_ARC4_CAVIUM_MAGIC;
return 0;
}
/* Free Arc4 from use with Nitrox device */
void Arc4FreeCavium(Arc4* arc4)
{
if (arc4 == NULL)
return;
if (arc4->magic != CYASSL_ARC4_CAVIUM_MAGIC)
return;
CspFreeContext(CONTEXT_SSL, arc4->contextHandle, arc4->devId);
arc4->magic = 0;
}
static void Arc4CaviumSetKey(Arc4* arc4, const byte* key, word32 length)
{
word32 requestId;
if (CspInitializeRc4(CAVIUM_BLOCKING, arc4->contextHandle, length,
(byte*)key, &requestId, arc4->devId) != 0) {
CYASSL_MSG("Bad Cavium Arc4 Init");
}
}
static void Arc4CaviumProcess(Arc4* arc4, byte* out, const byte* in,
word32 length)
{
cyassl_word offset = 0;
word32 requestId;
while (length > CYASSL_MAX_16BIT) {
word16 slen = (word16)CYASSL_MAX_16BIT;
if (CspEncryptRc4(CAVIUM_BLOCKING, arc4->contextHandle,CAVIUM_UPDATE,
slen, (byte*)in + offset, out + offset, &requestId,
arc4->devId) != 0) {
CYASSL_MSG("Bad Cavium Arc4 Encrypt");
}
length -= CYASSL_MAX_16BIT;
offset += CYASSL_MAX_16BIT;
}
if (length) {
word16 slen = (word16)length;
if (CspEncryptRc4(CAVIUM_BLOCKING, arc4->contextHandle,CAVIUM_UPDATE,
slen, (byte*)in + offset, out + offset, &requestId,
arc4->devId) != 0) {
CYASSL_MSG("Bad Cavium Arc4 Encrypt");
}
}
}
#endif /* HAVE_CAVIUM */
#endif /* NO_ARC4 */

1621
ctaocrypt/src/camellia.c Normal file
View File

File diff suppressed because it is too large Load Diff

274
ctaocrypt/src/md2.c
View File

@ -20,140 +20,140 @@
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <cyassl/ctaocrypt/settings.h>
#ifdef CYASSL_MD2
#include <cyassl/ctaocrypt/md2.h>
#include <cyassl/ctaocrypt/error-crypt.h>
#ifdef NO_INLINE
#include <cyassl/ctaocrypt/misc.h>
#else
#include <ctaocrypt/src/misc.c>
#endif
void InitMd2(Md2* md2)
{
XMEMSET(md2->X, 0, MD2_X_SIZE);
XMEMSET(md2->C, 0, MD2_BLOCK_SIZE);
XMEMSET(md2->buffer, 0, MD2_BLOCK_SIZE);
md2->count = 0;
}
void Md2Update(Md2* md2, const byte* data, word32 len)
{
static const byte S[256] =
{
41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6,
19, 98, 167, 5, 243, 192, 199, 115, 140, 152, 147, 43, 217, 188,
76, 130, 202, 30, 155, 87, 60, 253, 212, 224, 22, 103, 66, 111, 24,
138, 23, 229, 18, 190, 78, 196, 214, 218, 158, 222, 73, 160, 251,
245, 142, 187, 47, 238, 122, 169, 104, 121, 145, 21, 178, 7, 63,
148, 194, 16, 137, 11, 34, 95, 33, 128, 127, 93, 154, 90, 144, 50,
39, 53, 62, 204, 231, 191, 247, 151, 3, 255, 25, 48, 179, 72, 165,
181, 209, 215, 94, 146, 42, 172, 86, 170, 198, 79, 184, 56, 210,
150, 164, 125, 182, 118, 252, 107, 226, 156, 116, 4, 241, 69, 157,
112, 89, 100, 113, 135, 32, 134, 91, 207, 101, 230, 45, 168, 2, 27,
96, 37, 173, 174, 176, 185, 246, 28, 70, 97, 105, 52, 64, 126, 15,
85, 71, 163, 35, 221, 81, 175, 58, 195, 92, 249, 206, 186, 197,
234, 38, 44, 83, 13, 110, 133, 40, 132, 9, 211, 223, 205, 244, 65,
129, 77, 82, 106, 220, 55, 200, 108, 193, 171, 250, 36, 225, 123,
8, 12, 189, 177, 74, 120, 136, 149, 139, 227, 99, 232, 109, 233,
203, 213, 254, 59, 0, 29, 57, 242, 239, 183, 14, 102, 88, 208, 228,
166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237,
31, 26, 219, 153, 141, 51, 159, 17, 131, 20
};
while (len) {
word32 L = (MD2_PAD_SIZE - md2->count) < len ?
(MD2_PAD_SIZE - md2->count) : len;
XMEMCPY(md2->buffer + md2->count, data, L);
md2->count += L;
data += L;
len -= L;
if (md2->count == MD2_PAD_SIZE) {
int i;
byte t;
md2->count = 0;
XMEMCPY(md2->X + MD2_PAD_SIZE, md2->buffer, MD2_PAD_SIZE);
t = md2->C[15];
for(i = 0; i < MD2_PAD_SIZE; i++) {
md2->X[32 + i] = md2->X[MD2_PAD_SIZE + i] ^ md2->X[i];
t = md2->C[i] ^= S[md2->buffer[i] ^ t];
}
t=0;
for(i = 0; i < 18; i++) {
int j;
for(j = 0; j < MD2_X_SIZE; j += 8) {
t = md2->X[j+0] ^= S[t];
t = md2->X[j+1] ^= S[t];
t = md2->X[j+2] ^= S[t];
t = md2->X[j+3] ^= S[t];
t = md2->X[j+4] ^= S[t];
t = md2->X[j+5] ^= S[t];
t = md2->X[j+6] ^= S[t];
t = md2->X[j+7] ^= S[t];
}
t = (t + i) & 0xFF;
}
}
}
}
void Md2Final(Md2* md2, byte* hash)
{
byte padding[MD2_BLOCK_SIZE];
word32 padLen = MD2_PAD_SIZE - md2->count;
word32 i;
for (i = 0; i < padLen; i++)
padding[i] = (byte)padLen;
Md2Update(md2, padding, padLen);
Md2Update(md2, md2->C, MD2_BLOCK_SIZE);
XMEMCPY(hash, md2->X, MD2_DIGEST_SIZE);
InitMd2(md2);
}
int Md2Hash(const byte* data, word32 len, byte* hash)
{
#ifdef CYASSL_SMALL_STACK
Md2* md2;
#else
Md2 md2[1];
#endif
#ifdef CYASSL_SMALL_STACK
md2 = (Md2*)XMALLOC(sizeof(Md2), NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (md2 == NULL)
return MEMORY_E;
#endif
InitMd2(md2);
Md2Update(md2, data, len);
Md2Final(md2, hash);
#ifdef CYASSL_SMALL_STACK
XFREE(md2, NULL, DYNAMIC_TYPE_TMP_BUFFER);
#endif
return 0;
}
#endif /* CYASSL_MD2 */
//#ifdef HAVE_CONFIG_H
// #include <config.h>
//#endif
//
//#include <cyassl/ctaocrypt/settings.h>
//
//#ifdef CYASSL_MD2
//
//#include <cyassl/ctaocrypt/md2.h>
//#include <cyassl/ctaocrypt/error-crypt.h>
//
//#ifdef NO_INLINE
// #include <cyassl/ctaocrypt/misc.h>
//#else
// #include <ctaocrypt/src/misc.c>
//#endif
//
//
//void InitMd2(Md2* md2)
//{
// XMEMSET(md2->X, 0, MD2_X_SIZE);
// XMEMSET(md2->C, 0, MD2_BLOCK_SIZE);
// XMEMSET(md2->buffer, 0, MD2_BLOCK_SIZE);
// md2->count = 0;
//}
//
//
//void Md2Update(Md2* md2, const byte* data, word32 len)
//{
// static const byte S[256] =
// {
// 41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6,
// 19, 98, 167, 5, 243, 192, 199, 115, 140, 152, 147, 43, 217, 188,
// 76, 130, 202, 30, 155, 87, 60, 253, 212, 224, 22, 103, 66, 111, 24,
// 138, 23, 229, 18, 190, 78, 196, 214, 218, 158, 222, 73, 160, 251,
// 245, 142, 187, 47, 238, 122, 169, 104, 121, 145, 21, 178, 7, 63,
// 148, 194, 16, 137, 11, 34, 95, 33, 128, 127, 93, 154, 90, 144, 50,
// 39, 53, 62, 204, 231, 191, 247, 151, 3, 255, 25, 48, 179, 72, 165,
// 181, 209, 215, 94, 146, 42, 172, 86, 170, 198, 79, 184, 56, 210,
// 150, 164, 125, 182, 118, 252, 107, 226, 156, 116, 4, 241, 69, 157,
// 112, 89, 100, 113, 135, 32, 134, 91, 207, 101, 230, 45, 168, 2, 27,
// 96, 37, 173, 174, 176, 185, 246, 28, 70, 97, 105, 52, 64, 126, 15,
// 85, 71, 163, 35, 221, 81, 175, 58, 195, 92, 249, 206, 186, 197,
// 234, 38, 44, 83, 13, 110, 133, 40, 132, 9, 211, 223, 205, 244, 65,
// 129, 77, 82, 106, 220, 55, 200, 108, 193, 171, 250, 36, 225, 123,
// 8, 12, 189, 177, 74, 120, 136, 149, 139, 227, 99, 232, 109, 233,
// 203, 213, 254, 59, 0, 29, 57, 242, 239, 183, 14, 102, 88, 208, 228,
// 166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237,
// 31, 26, 219, 153, 141, 51, 159, 17, 131, 20
// };
//
// while (len) {
// word32 L = (MD2_PAD_SIZE - md2->count) < len ?
// (MD2_PAD_SIZE - md2->count) : len;
// XMEMCPY(md2->buffer + md2->count, data, L);
// md2->count += L;
// data += L;
// len -= L;
//
// if (md2->count == MD2_PAD_SIZE) {
// int i;
// byte t;
//
// md2->count = 0;
// XMEMCPY(md2->X + MD2_PAD_SIZE, md2->buffer, MD2_PAD_SIZE);
// t = md2->C[15];
//
// for(i = 0; i < MD2_PAD_SIZE; i++) {
// md2->X[32 + i] = md2->X[MD2_PAD_SIZE + i] ^ md2->X[i];
// t = md2->C[i] ^= S[md2->buffer[i] ^ t];
// }
//
// t=0;
// for(i = 0; i < 18; i++) {
// int j;
// for(j = 0; j < MD2_X_SIZE; j += 8) {
// t = md2->X[j+0] ^= S[t];
// t = md2->X[j+1] ^= S[t];
// t = md2->X[j+2] ^= S[t];
// t = md2->X[j+3] ^= S[t];
// t = md2->X[j+4] ^= S[t];
// t = md2->X[j+5] ^= S[t];
// t = md2->X[j+6] ^= S[t];
// t = md2->X[j+7] ^= S[t];
// }
// t = (t + i) & 0xFF;
// }
// }
// }
//}
//
//
//void Md2Final(Md2* md2, byte* hash)
//{
// byte padding[MD2_BLOCK_SIZE];
// word32 padLen = MD2_PAD_SIZE - md2->count;
// word32 i;
//
// for (i = 0; i < padLen; i++)
// padding[i] = (byte)padLen;
//
// Md2Update(md2, padding, padLen);
// Md2Update(md2, md2->C, MD2_BLOCK_SIZE);
//
// XMEMCPY(hash, md2->X, MD2_DIGEST_SIZE);
//
// InitMd2(md2);
//}
//
//
//int Md2Hash(const byte* data, word32 len, byte* hash)
//{
//#ifdef CYASSL_SMALL_STACK
// Md2* md2;
//#else
// Md2 md2[1];
//#endif
//
//#ifdef CYASSL_SMALL_STACK
// md2 = (Md2*)XMALLOC(sizeof(Md2), NULL, DYNAMIC_TYPE_TMP_BUFFER);
// if (md2 == NULL)
// return MEMORY_E;
//#endif
//
// InitMd2(md2);
// Md2Update(md2, data, len);
// Md2Final(md2, hash);
//
//#ifdef CYASSL_SMALL_STACK
// XFREE(md2, NULL, DYNAMIC_TYPE_TMP_BUFFER);
//#endif
//
// return 0;
//}
//
//
//#endif /* CYASSL_MD2 */

396
ctaocrypt/src/md4.c
View File

@ -19,201 +19,201 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <cyassl/ctaocrypt/settings.h>
#ifndef NO_MD4
#include <cyassl/ctaocrypt/md4.h>
#ifdef NO_INLINE
#include <cyassl/ctaocrypt/misc.h>
#else
#include <ctaocrypt/src/misc.c>
#endif
#ifndef min
static INLINE word32 min(word32 a, word32 b)
{
return a > b ? b : a;
}
#endif /* min */
void InitMd4(Md4* md4)
{
md4->digest[0] = 0x67452301L;
md4->digest[1] = 0xefcdab89L;
md4->digest[2] = 0x98badcfeL;
md4->digest[3] = 0x10325476L;
md4->buffLen = 0;
md4->loLen = 0;
md4->hiLen = 0;
}
static void Transform(Md4* md4)
{
#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
/* Copy context->state[] to working vars */
word32 A = md4->digest[0];
word32 B = md4->digest[1];
word32 C = md4->digest[2];
word32 D = md4->digest[3];
#define function(a,b,c,d,k,s) a=rotlFixed(a+F(b,c,d)+md4->buffer[k],s);
function(A,B,C,D, 0, 3);
function(D,A,B,C, 1, 7);
function(C,D,A,B, 2,11);
function(B,C,D,A, 3,19);
function(A,B,C,D, 4, 3);
function(D,A,B,C, 5, 7);
function(C,D,A,B, 6,11);
function(B,C,D,A, 7,19);
function(A,B,C,D, 8, 3);
function(D,A,B,C, 9, 7);
function(C,D,A,B,10,11);
function(B,C,D,A,11,19);
function(A,B,C,D,12, 3);
function(D,A,B,C,13, 7);
function(C,D,A,B,14,11);
function(B,C,D,A,15,19);
#undef function
#define function(a,b,c,d,k,s) \
a=rotlFixed(a+G(b,c,d)+md4->buffer[k]+0x5a827999,s);
function(A,B,C,D, 0, 3);
function(D,A,B,C, 4, 5);
function(C,D,A,B, 8, 9);
function(B,C,D,A,12,13);
function(A,B,C,D, 1, 3);
function(D,A,B,C, 5, 5);
function(C,D,A,B, 9, 9);
function(B,C,D,A,13,13);
function(A,B,C,D, 2, 3);
function(D,A,B,C, 6, 5);
function(C,D,A,B,10, 9);
function(B,C,D,A,14,13);
function(A,B,C,D, 3, 3);
function(D,A,B,C, 7, 5);
function(C,D,A,B,11, 9);
function(B,C,D,A,15,13);
#undef function
#define function(a,b,c,d,k,s) \
a=rotlFixed(a+H(b,c,d)+md4->buffer[k]+0x6ed9eba1,s);
function(A,B,C,D, 0, 3);
function(D,A,B,C, 8, 9);
function(C,D,A,B, 4,11);
function(B,C,D,A,12,15);
function(A,B,C,D, 2, 3);
function(D,A,B,C,10, 9);
function(C,D,A,B, 6,11);
function(B,C,D,A,14,15);
function(A,B,C,D, 1, 3);
function(D,A,B,C, 9, 9);
function(C,D,A,B, 5,11);
function(B,C,D,A,13,15);
function(A,B,C,D, 3, 3);
function(D,A,B,C,11, 9);
function(C,D,A,B, 7,11);
function(B,C,D,A,15,15);
/* Add the working vars back into digest state[] */
md4->digest[0] += A;
md4->digest[1] += B;
md4->digest[2] += C;
md4->digest[3] += D;
}
static INLINE void AddLength(Md4* md4, word32 len)
{
word32 tmp = md4->loLen;
if ( (md4->loLen += len) < tmp)
md4->hiLen++; /* carry low to high */
}
void 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 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);
InitMd4(md4); /* reset state */
}
#endif /* NO_MD4 */
//#ifdef HAVE_CONFIG_H
// #include <config.h>
//#endif
//
//#include <cyassl/ctaocrypt/settings.h>
//
//#ifndef NO_MD4
//
//#include <cyassl/ctaocrypt/md4.h>
//#ifdef NO_INLINE
// #include <cyassl/ctaocrypt/misc.h>
//#else
// #include <ctaocrypt/src/misc.c>
//#endif
//
//
//#ifndef min
//
// static INLINE word32 min(word32 a, word32 b)
// {
// return a > b ? b : a;
// }
//
//#endif /* min */
//
//
//void InitMd4(Md4* md4)
//{
// md4->digest[0] = 0x67452301L;
// md4->digest[1] = 0xefcdab89L;
// md4->digest[2] = 0x98badcfeL;
// md4->digest[3] = 0x10325476L;
//
// md4->buffLen = 0;
// md4->loLen = 0;
// md4->hiLen = 0;
//}
//
//
//static void Transform(Md4* md4)
//{
//#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
//#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
//#define H(x, y, z) ((x) ^ (y) ^ (z))
//
// /* Copy context->state[] to working vars */
// word32 A = md4->digest[0];
// word32 B = md4->digest[1];
// word32 C = md4->digest[2];
// word32 D = md4->digest[3];
//
//#define function(a,b,c,d,k,s) a=rotlFixed(a+F(b,c,d)+md4->buffer[k],s);
// function(A,B,C,D, 0, 3);
// function(D,A,B,C, 1, 7);
// function(C,D,A,B, 2,11);
// function(B,C,D,A, 3,19);
// function(A,B,C,D, 4, 3);
// function(D,A,B,C, 5, 7);
// function(C,D,A,B, 6,11);
// function(B,C,D,A, 7,19);
// function(A,B,C,D, 8, 3);
// function(D,A,B,C, 9, 7);
// function(C,D,A,B,10,11);
// function(B,C,D,A,11,19);
// function(A,B,C,D,12, 3);
// function(D,A,B,C,13, 7);
// function(C,D,A,B,14,11);
// function(B,C,D,A,15,19);
//
//#undef function
//#define function(a,b,c,d,k,s) \
// a=rotlFixed(a+G(b,c,d)+md4->buffer[k]+0x5a827999,s);
//
// function(A,B,C,D, 0, 3);
// function(D,A,B,C, 4, 5);
// function(C,D,A,B, 8, 9);
// function(B,C,D,A,12,13);
// function(A,B,C,D, 1, 3);
// function(D,A,B,C, 5, 5);
// function(C,D,A,B, 9, 9);
// function(B,C,D,A,13,13);
// function(A,B,C,D, 2, 3);
// function(D,A,B,C, 6, 5);
// function(C,D,A,B,10, 9);
// function(B,C,D,A,14,13);
// function(A,B,C,D, 3, 3);
// function(D,A,B,C, 7, 5);
// function(C,D,A,B,11, 9);
// function(B,C,D,A,15,13);
//
//#undef function
//#define function(a,b,c,d,k,s) \
// a=rotlFixed(a+H(b,c,d)+md4->buffer[k]+0x6ed9eba1,s);
//
// function(A,B,C,D, 0, 3);
// function(D,A,B,C, 8, 9);
// function(C,D,A,B, 4,11);
// function(B,C,D,A,12,15);
// function(A,B,C,D, 2, 3);
// function(D,A,B,C,10, 9);
// function(C,D,A,B, 6,11);
// function(B,C,D,A,14,15);
// function(A,B,C,D, 1, 3);
// function(D,A,B,C, 9, 9);
// function(C,D,A,B, 5,11);
// function(B,C,D,A,13,15);
// function(A,B,C,D, 3, 3);
// function(D,A,B,C,11, 9);
// function(C,D,A,B, 7,11);
// function(B,C,D,A,15,15);
//
// /* Add the working vars back into digest state[] */
// md4->digest[0] += A;
// md4->digest[1] += B;
// md4->digest[2] += C;
// md4->digest[3] += D;
//}
//
//
//static INLINE void AddLength(Md4* md4, word32 len)
//{
// word32 tmp = md4->loLen;
// if ( (md4->loLen += len) < tmp)
// md4->hiLen++; /* carry low to high */
//}
//
//
//void 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 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);
//
// InitMd4(md4); /* reset state */
//}
//
//
//#endif /* NO_MD4 */
//

738
ctaocrypt/src/md5.c
View File

@ -20,372 +20,372 @@
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <cyassl/ctaocrypt/settings.h>
#if !defined(NO_MD5)
#ifdef CYASSL_PIC32MZ_HASH
#define InitMd5 InitMd5_sw
#define Md5Update Md5Update_sw
#define Md5Final Md5Final_sw
#endif
#include <cyassl/ctaocrypt/md5.h>
#include <cyassl/ctaocrypt/error-crypt.h>
#ifdef NO_INLINE
#include <cyassl/ctaocrypt/misc.h>
#else
#include <ctaocrypt/src/misc.c>
#endif
#ifdef FREESCALE_MMCAU
#include "cau_api.h"
#define XTRANSFORM(S,B) cau_md5_hash_n((B), 1, (unsigned char*)(S)->digest)
#else
#define XTRANSFORM(S,B) Transform((S))
#endif
#ifdef STM32F2_HASH
/*
* STM32F2 hardware MD5 support through the STM32F2 standard peripheral
* library. Documentation located in STM32F2xx Standard Peripheral Library
* document (See note in README).
*/
#include "stm32f2xx.h"
void InitMd5(Md5* md5)
{
/* STM32F2 struct notes:
* md5->buffer = first 4 bytes used to hold partial block if needed
* md5->buffLen = num bytes currently stored in md5->buffer
* md5->loLen = num bytes that have been written to STM32 FIFO
*/
XMEMSET(md5->buffer, 0, MD5_REG_SIZE);
md5->buffLen = 0;
md5->loLen = 0;
/* initialize HASH peripheral */
HASH_DeInit();
/* configure algo used, algo mode, datatype */
HASH->CR &= ~ (HASH_CR_ALGO | HASH_CR_DATATYPE | HASH_CR_MODE);
HASH->CR |= (HASH_AlgoSelection_MD5 | HASH_AlgoMode_HASH
| HASH_DataType_8b);
/* reset HASH processor */
HASH->CR |= HASH_CR_INIT;
}
void Md5Update(Md5* md5, const byte* data, word32 len)
{
word32 i = 0;
word32 fill = 0;
word32 diff = 0;
/* if saved partial block is available */
if (md5->buffLen > 0) {
fill = 4 - md5->buffLen;
/* if enough data to fill, fill and push to FIFO */
if (fill <= len) {
XMEMCPY((byte*)md5->buffer + md5->buffLen, data, fill);
HASH_DataIn(*(uint32_t*)md5->buffer);
data += fill;
len -= fill;
md5->loLen += 4;
md5->buffLen = 0;
} else {
/* append partial to existing stored block */
XMEMCPY((byte*)md5->buffer + md5->buffLen, data, len);
md5->buffLen += len;
return;
}
}
/* write input block in the IN FIFO */
for (i = 0; i < len; i += 4)
{
diff = len - i;
if (diff < 4) {
/* store incomplete last block, not yet in FIFO */
XMEMSET(md5->buffer, 0, MD5_REG_SIZE);
XMEMCPY((byte*)md5->buffer, data, diff);
md5->buffLen = diff;
} else {
HASH_DataIn(*(uint32_t*)data);
data+=4;
}
}
/* keep track of total data length thus far */
md5->loLen += (len - md5->buffLen);
}
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 */
}
#else /* CTaoCrypt software implementation */
#ifndef min
static INLINE word32 min(word32 a, word32 b)
{
return a > b ? b : a;
}
#endif /* min */
void InitMd5(Md5* md5)
{
md5->digest[0] = 0x67452301L;
md5->digest[1] = 0xefcdab89L;
md5->digest[2] = 0x98badcfeL;
md5->digest[3] = 0x10325476L;
md5->buffLen = 0;
md5->loLen = 0;
md5->hiLen = 0;
}
#ifndef FREESCALE_MMCAU
static void Transform(Md5* md5)
{
#define F1(x, y, z) (z ^ (x & (y ^ z)))
#define F2(x, y, z) F1(z, x, y)
#define F3(x, y, z) (x ^ y ^ z)
#define F4(x, y, z) (y ^ (x | ~z))
#define MD5STEP(f, w, x, y, z, data, s) \
w = rotlFixed(w + f(x, y, z) + data, s) + x
/* Copy context->state[] to working vars */
word32 a = md5->digest[0];
word32 b = md5->digest[1];
word32 c = md5->digest[2];
word32 d = md5->digest[3];
MD5STEP(F1, a, b, c, d, md5->buffer[0] + 0xd76aa478, 7);
MD5STEP(F1, d, a, b, c, md5->buffer[1] + 0xe8c7b756, 12);
MD5STEP(F1, c, d, a, b, md5->buffer[2] + 0x242070db, 17);
MD5STEP(F1, b, c, d, a, md5->buffer[3] + 0xc1bdceee, 22);
MD5STEP(F1, a, b, c, d, md5->buffer[4] + 0xf57c0faf, 7);
MD5STEP(F1, d, a, b, c, md5->buffer[5] + 0x4787c62a, 12);
MD5STEP(F1, c, d, a, b, md5->buffer[6] + 0xa8304613, 17);
MD5STEP(F1, b, c, d, a, md5->buffer[7] + 0xfd469501, 22);
MD5STEP(F1, a, b, c, d, md5->buffer[8] + 0x698098d8, 7);
MD5STEP(F1, d, a, b, c, md5->buffer[9] + 0x8b44f7af, 12);
MD5STEP(F1, c, d, a, b, md5->buffer[10] + 0xffff5bb1, 17);
MD5STEP(F1, b, c, d, a, md5->buffer[11] + 0x895cd7be, 22);
MD5STEP(F1, a, b, c, d, md5->buffer[12] + 0x6b901122, 7);
MD5STEP(F1, d, a, b, c, md5->buffer[13] + 0xfd987193, 12);
MD5STEP(F1, c, d, a, b, md5->buffer[14] + 0xa679438e, 17);
MD5STEP(F1, b, c, d, a, md5->buffer[15] + 0x49b40821, 22);
MD5STEP(F2, a, b, c, d, md5->buffer[1] + 0xf61e2562, 5);
MD5STEP(F2, d, a, b, c, md5->buffer[6] + 0xc040b340, 9);
MD5STEP(F2, c, d, a, b, md5->buffer[11] + 0x265e5a51, 14);
MD5STEP(F2, b, c, d, a, md5->buffer[0] + 0xe9b6c7aa, 20);
MD5STEP(F2, a, b, c, d, md5->buffer[5] + 0xd62f105d, 5);
MD5STEP(F2, d, a, b, c, md5->buffer[10] + 0x02441453, 9);
MD5STEP(F2, c, d, a, b, md5->buffer[15] + 0xd8a1e681, 14);
MD5STEP(F2, b, c, d, a, md5->buffer[4] + 0xe7d3fbc8, 20);
MD5STEP(F2, a, b, c, d, md5->buffer[9] + 0x21e1cde6, 5);
MD5STEP(F2, d, a, b, c, md5->buffer[14] + 0xc33707d6, 9);
MD5STEP(F2, c, d, a, b, md5->buffer[3] + 0xf4d50d87, 14);
MD5STEP(F2, b, c, d, a, md5->buffer[8] + 0x455a14ed, 20);
MD5STEP(F2, a, b, c, d, md5->buffer[13] + 0xa9e3e905, 5);
MD5STEP(F2, d, a, b, c, md5->buffer[2] + 0xfcefa3f8, 9);
MD5STEP(F2, c, d, a, b, md5->buffer[7] + 0x676f02d9, 14);
MD5STEP(F2, b, c, d, a, md5->buffer[12] + 0x8d2a4c8a, 20);
MD5STEP(F3, a, b, c, d, md5->buffer[5] + 0xfffa3942, 4);
MD5STEP(F3, d, a, b, c, md5->buffer[8] + 0x8771f681, 11);
MD5STEP(F3, c, d, a, b, md5->buffer[11] + 0x6d9d6122, 16);
MD5STEP(F3, b, c, d, a, md5->buffer[14] + 0xfde5380c, 23);
MD5STEP(F3, a, b, c, d, md5->buffer[1] + 0xa4beea44, 4);
MD5STEP(F3, d, a, b, c, md5->buffer[4] + 0x4bdecfa9, 11);
MD5STEP(F3, c, d, a, b, md5->buffer[7] + 0xf6bb4b60, 16);
MD5STEP(F3, b, c, d, a, md5->buffer[10] + 0xbebfbc70, 23);
MD5STEP(F3, a, b, c, d, md5->buffer[13] + 0x289b7ec6, 4);
MD5STEP(F3, d, a, b, c, md5->buffer[0] + 0xeaa127fa, 11);
MD5STEP(F3, c, d, a, b, md5->buffer[3] + 0xd4ef3085, 16);
MD5STEP(F3, b, c, d, a, md5->buffer[6] + 0x04881d05, 23);
MD5STEP(F3, a, b, c, d, md5->buffer[9] + 0xd9d4d039, 4);
MD5STEP(F3, d, a, b, c, md5->buffer[12] + 0xe6db99e5, 11);
MD5STEP(F3, c, d, a, b, md5->buffer[15] + 0x1fa27cf8, 16);
MD5STEP(F3, b, c, d, a, md5->buffer[2] + 0xc4ac5665, 23);
MD5STEP(F4, a, b, c, d, md5->buffer[0] + 0xf4292244, 6);
MD5STEP(F4, d, a, b, c, md5->buffer[7] + 0x432aff97, 10);
MD5STEP(F4, c, d, a, b, md5->buffer[14] + 0xab9423a7, 15);
MD5STEP(F4, b, c, d, a, md5->buffer[5] + 0xfc93a039, 21);
MD5STEP(F4, a, b, c, d, md5->buffer[12] + 0x655b59c3, 6);
MD5STEP(F4, d, a, b, c, md5->buffer[3] + 0x8f0ccc92, 10);
MD5STEP(F4, c, d, a, b, md5->buffer[10] + 0xffeff47d, 15);
MD5STEP(F4, b, c, d, a, md5->buffer[1] + 0x85845dd1, 21);
MD5STEP(F4, a, b, c, d, md5->buffer[8] + 0x6fa87e4f, 6);
MD5STEP(F4, d, a, b, c, md5->buffer[15] + 0xfe2ce6e0, 10);
MD5STEP(F4, c, d, a, b, md5->buffer[6] + 0xa3014314, 15);
MD5STEP(F4, b, c, d, a, md5->buffer[13] + 0x4e0811a1, 21);
MD5STEP(F4, a, b, c, d, md5->buffer[4] + 0xf7537e82, 6);
MD5STEP(F4, d, a, b, c, md5->buffer[11] + 0xbd3af235, 10);
MD5STEP(F4, c, d, a, b, md5->buffer[2] + 0x2ad7d2bb, 15);
MD5STEP(F4, b, c, d, a, md5->buffer[9] + 0xeb86d391, 21);
/* Add the working vars back into digest state[] */
md5->digest[0] += a;
md5->digest[1] += b;
md5->digest[2] += c;
md5->digest[3] += d;
}
#endif /* FREESCALE_MMCAU */
static INLINE void AddLength(Md5* md5, word32 len)
{
word32 tmp = md5->loLen;
if ( (md5->loLen += len) < tmp)
md5->hiLen++; /* carry low to high */
}
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 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 */
}
#endif /* STM32F2_HASH */
int Md5Hash(const byte* data, word32 len, byte* hash)
{
#ifdef CYASSL_SMALL_STACK
Md5* md5;
#else
Md5 md5[1];
#endif
#ifdef CYASSL_SMALL_STACK
md5 = (Md5*)XMALLOC(sizeof(Md5), NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (md5 == NULL)
return MEMORY_E;
#endif
InitMd5(md5);
Md5Update(md5, data, len);
Md5Final(md5, hash);
#ifdef CYASSL_SMALL_STACK
XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER);
#endif
return 0;
}
#endif /* NO_MD5 */
//#ifdef HAVE_CONFIG_H
// #include <config.h>
//#endif
//
//#include <cyassl/ctaocrypt/settings.h>
//
//#if !defined(NO_MD5)
//
//#ifdef CYASSL_PIC32MZ_HASH
//#define InitMd5 InitMd5_sw
//#define Md5Update Md5Update_sw
//#define Md5Final Md5Final_sw
//#endif
//
//#include <cyassl/ctaocrypt/md5.h>
//#include <cyassl/ctaocrypt/error-crypt.h>
//
//#ifdef NO_INLINE
// #include <cyassl/ctaocrypt/misc.h>
//#else
// #include <ctaocrypt/src/misc.c>
//#endif
//
//#ifdef FREESCALE_MMCAU
// #include "cau_api.h"
// #define XTRANSFORM(S,B) cau_md5_hash_n((B), 1, (unsigned char*)(S)->digest)
//#else
// #define XTRANSFORM(S,B) Transform((S))
//#endif
//
//
//#ifdef STM32F2_HASH
// /*
// * STM32F2 hardware MD5 support through the STM32F2 standard peripheral
// * library. Documentation located in STM32F2xx Standard Peripheral Library
// * document (See note in README).
// */
// #include "stm32f2xx.h"
//
// void InitMd5(Md5* md5)
// {
// /* STM32F2 struct notes:
// * md5->buffer = first 4 bytes used to hold partial block if needed
// * md5->buffLen = num bytes currently stored in md5->buffer
// * md5->loLen = num bytes that have been written to STM32 FIFO
// */
// XMEMSET(md5->buffer, 0, MD5_REG_SIZE);
//
// md5->buffLen = 0;
// md5->loLen = 0;
//
// /* initialize HASH peripheral */
// HASH_DeInit();
//
// /* configure algo used, algo mode, datatype */
// HASH->CR &= ~ (HASH_CR_ALGO | HASH_CR_DATATYPE | HASH_CR_MODE);
// HASH->CR |= (HASH_AlgoSelection_MD5 | HASH_AlgoMode_HASH
// | HASH_DataType_8b);
//
// /* reset HASH processor */
// HASH->CR |= HASH_CR_INIT;
// }
//
// void Md5Update(Md5* md5, const byte* data, word32 len)
// {
// word32 i = 0;
// word32 fill = 0;
// word32 diff = 0;
//
// /* if saved partial block is available */
// if (md5->buffLen > 0) {
// fill = 4 - md5->buffLen;
//
// /* if enough data to fill, fill and push to FIFO */
// if (fill <= len) {
// XMEMCPY((byte*)md5->buffer + md5->buffLen, data, fill);
// HASH_DataIn(*(uint32_t*)md5->buffer);
//
// data += fill;
// len -= fill;
// md5->loLen += 4;
// md5->buffLen = 0;
// } else {
// /* append partial to existing stored block */
// XMEMCPY((byte*)md5->buffer + md5->buffLen, data, len);
// md5->buffLen += len;
// return;
// }
// }
//
// /* write input block in the IN FIFO */
// for (i = 0; i < len; i += 4)
// {
// diff = len - i;
// if (diff < 4) {
// /* store incomplete last block, not yet in FIFO */
// XMEMSET(md5->buffer, 0, MD5_REG_SIZE);
// XMEMCPY((byte*)md5->buffer, data, diff);
// md5->buffLen = diff;
// } else {
// HASH_DataIn(*(uint32_t*)data);
// data+=4;
// }
// }
//
// /* keep track of total data length thus far */
// md5->loLen += (len - md5->buffLen);
// }
//
// 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 */
// }
//
//#else /* CTaoCrypt software implementation */
//
//#ifndef min
//
// static INLINE word32 min(word32 a, word32 b)
// {
// return a > b ? b : a;
// }
//
//#endif /* min */
//
//
//void InitMd5(Md5* md5)
//{
// md5->digest[0] = 0x67452301L;
// md5->digest[1] = 0xefcdab89L;
// md5->digest[2] = 0x98badcfeL;
// md5->digest[3] = 0x10325476L;
//
// md5->buffLen = 0;
// md5->loLen = 0;
// md5->hiLen = 0;
//}
//
//#ifndef FREESCALE_MMCAU
//
//static void Transform(Md5* md5)
//{
//#define F1(x, y, z) (z ^ (x & (y ^ z)))
//#define F2(x, y, z) F1(z, x, y)
//#define F3(x, y, z) (x ^ y ^ z)
//#define F4(x, y, z) (y ^ (x | ~z))
//
//#define MD5STEP(f, w, x, y, z, data, s) \
// w = rotlFixed(w + f(x, y, z) + data, s) + x
//
// /* Copy context->state[] to working vars */
// word32 a = md5->digest[0];
// word32 b = md5->digest[1];
// word32 c = md5->digest[2];
// word32 d = md5->digest[3];
//
// MD5STEP(F1, a, b, c, d, md5->buffer[0] + 0xd76aa478, 7);
// MD5STEP(F1, d, a, b, c, md5->buffer[1] + 0xe8c7b756, 12);
// MD5STEP(F1, c, d, a, b, md5->buffer[2] + 0x242070db, 17);
// MD5STEP(F1, b, c, d, a, md5->buffer[3] + 0xc1bdceee, 22);
// MD5STEP(F1, a, b, c, d, md5->buffer[4] + 0xf57c0faf, 7);
// MD5STEP(F1, d, a, b, c, md5->buffer[5] + 0x4787c62a, 12);
// MD5STEP(F1, c, d, a, b, md5->buffer[6] + 0xa8304613, 17);
// MD5STEP(F1, b, c, d, a, md5->buffer[7] + 0xfd469501, 22);
// MD5STEP(F1, a, b, c, d, md5->buffer[8] + 0x698098d8, 7);
// MD5STEP(F1, d, a, b, c, md5->buffer[9] + 0x8b44f7af, 12);
// MD5STEP(F1, c, d, a, b, md5->buffer[10] + 0xffff5bb1, 17);
// MD5STEP(F1, b, c, d, a, md5->buffer[11] + 0x895cd7be, 22);
// MD5STEP(F1, a, b, c, d, md5->buffer[12] + 0x6b901122, 7);
// MD5STEP(F1, d, a, b, c, md5->buffer[13] + 0xfd987193, 12);
// MD5STEP(F1, c, d, a, b, md5->buffer[14] + 0xa679438e, 17);
// MD5STEP(F1, b, c, d, a, md5->buffer[15] + 0x49b40821, 22);
//
// MD5STEP(F2, a, b, c, d, md5->buffer[1] + 0xf61e2562, 5);
// MD5STEP(F2, d, a, b, c, md5->buffer[6] + 0xc040b340, 9);
// MD5STEP(F2, c, d, a, b, md5->buffer[11] + 0x265e5a51, 14);
// MD5STEP(F2, b, c, d, a, md5->buffer[0] + 0xe9b6c7aa, 20);
// MD5STEP(F2, a, b, c, d, md5->buffer[5] + 0xd62f105d, 5);
// MD5STEP(F2, d, a, b, c, md5->buffer[10] + 0x02441453, 9);
// MD5STEP(F2, c, d, a, b, md5->buffer[15] + 0xd8a1e681, 14);
// MD5STEP(F2, b, c, d, a, md5->buffer[4] + 0xe7d3fbc8, 20);
// MD5STEP(F2, a, b, c, d, md5->buffer[9] + 0x21e1cde6, 5);
// MD5STEP(F2, d, a, b, c, md5->buffer[14] + 0xc33707d6, 9);
// MD5STEP(F2, c, d, a, b, md5->buffer[3] + 0xf4d50d87, 14);
// MD5STEP(F2, b, c, d, a, md5->buffer[8] + 0x455a14ed, 20);
// MD5STEP(F2, a, b, c, d, md5->buffer[13] + 0xa9e3e905, 5);
// MD5STEP(F2, d, a, b, c, md5->buffer[2] + 0xfcefa3f8, 9);
// MD5STEP(F2, c, d, a, b, md5->buffer[7] + 0x676f02d9, 14);
// MD5STEP(F2, b, c, d, a, md5->buffer[12] + 0x8d2a4c8a, 20);
//
// MD5STEP(F3, a, b, c, d, md5->buffer[5] + 0xfffa3942, 4);
// MD5STEP(F3, d, a, b, c, md5->buffer[8] + 0x8771f681, 11);
// MD5STEP(F3, c, d, a, b, md5->buffer[11] + 0x6d9d6122, 16);
// MD5STEP(F3, b, c, d, a, md5->buffer[14] + 0xfde5380c, 23);
// MD5STEP(F3, a, b, c, d, md5->buffer[1] + 0xa4beea44, 4);
// MD5STEP(F3, d, a, b, c, md5->buffer[4] + 0x4bdecfa9, 11);
// MD5STEP(F3, c, d, a, b, md5->buffer[7] + 0xf6bb4b60, 16);
// MD5STEP(F3, b, c, d, a, md5->buffer[10] + 0xbebfbc70, 23);
// MD5STEP(F3, a, b, c, d, md5->buffer[13] + 0x289b7ec6, 4);
// MD5STEP(F3, d, a, b, c, md5->buffer[0] + 0xeaa127fa, 11);
// MD5STEP(F3, c, d, a, b, md5->buffer[3] + 0xd4ef3085, 16);
// MD5STEP(F3, b, c, d, a, md5->buffer[6] + 0x04881d05, 23);
// MD5STEP(F3, a, b, c, d, md5->buffer[9] + 0xd9d4d039, 4);
// MD5STEP(F3, d, a, b, c, md5->buffer[12] + 0xe6db99e5, 11);
// MD5STEP(F3, c, d, a, b, md5->buffer[15] + 0x1fa27cf8, 16);
// MD5STEP(F3, b, c, d, a, md5->buffer[2] + 0xc4ac5665, 23);
//
// MD5STEP(F4, a, b, c, d, md5->buffer[0] + 0xf4292244, 6);
// MD5STEP(F4, d, a, b, c, md5->buffer[7] + 0x432aff97, 10);
// MD5STEP(F4, c, d, a, b, md5->buffer[14] + 0xab9423a7, 15);
// MD5STEP(F4, b, c, d, a, md5->buffer[5] + 0xfc93a039, 21);
// MD5STEP(F4, a, b, c, d, md5->buffer[12] + 0x655b59c3, 6);
// MD5STEP(F4, d, a, b, c, md5->buffer[3] + 0x8f0ccc92, 10);
// MD5STEP(F4, c, d, a, b, md5->buffer[10] + 0xffeff47d, 15);
// MD5STEP(F4, b, c, d, a, md5->buffer[1] + 0x85845dd1, 21);
// MD5STEP(F4, a, b, c, d, md5->buffer[8] + 0x6fa87e4f, 6);
// MD5STEP(F4, d, a, b, c, md5->buffer[15] + 0xfe2ce6e0, 10);
// MD5STEP(F4, c, d, a, b, md5->buffer[6] + 0xa3014314, 15);
// MD5STEP(F4, b, c, d, a, md5->buffer[13] + 0x4e0811a1, 21);
// MD5STEP(F4, a, b, c, d, md5->buffer[4] + 0xf7537e82, 6);
// MD5STEP(F4, d, a, b, c, md5->buffer[11] + 0xbd3af235, 10);
// MD5STEP(F4, c, d, a, b, md5->buffer[2] + 0x2ad7d2bb, 15);
// MD5STEP(F4, b, c, d, a, md5->buffer[9] + 0xeb86d391, 21);
//
// /* Add the working vars back into digest state[] */
// md5->digest[0] += a;
// md5->digest[1] += b;
// md5->digest[2] += c;
// md5->digest[3] += d;
//}
//
//#endif /* FREESCALE_MMCAU */
//
//
//static INLINE void AddLength(Md5* md5, word32 len)
//{
// word32 tmp = md5->loLen;
// if ( (md5->loLen += len) < tmp)
// md5->hiLen++; /* carry low to high */
//}
//
//
//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 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 */
//}
//
//#endif /* STM32F2_HASH */
//
//
//int Md5Hash(const byte* data, word32 len, byte* hash)
//{
//#ifdef CYASSL_SMALL_STACK
// Md5* md5;
//#else
// Md5 md5[1];
//#endif
//
//#ifdef CYASSL_SMALL_STACK
// md5 = (Md5*)XMALLOC(sizeof(Md5), NULL, DYNAMIC_TYPE_TMP_BUFFER);
// if (md5 == NULL)
// return MEMORY_E;
//#endif
//
// InitMd5(md5);
// Md5Update(md5, data, len);
// Md5Final(md5, hash);
//
//#ifdef CYASSL_SMALL_STACK
// XFREE(md5, NULL, DYNAMIC_TYPE_TMP_BUFFER);
//#endif
//
// return 0;
//}
//
//#endif /* NO_MD5 */

3656
ctaocrypt/src/pkcs7.c
View File

File diff suppressed because it is too large Load Diff