wolfSSL/wolfssl
1
0
Fork 1
mirror of https://github.com/wolfSSL/wolfssl.git synced 2025-07-31 19:24:42 +02:00
Code Issues Packages Projects Releases Wiki 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

3
.gitignore vendored
View File

@@ -1,3 +1,4 @@
ctaocrypt/src/src/
*.swp *.swp
*.lo *.lo
*.la *.la
@@ -36,6 +37,8 @@ fips_test.c
fips fips
ctaocrypt/benchmark/benchmark ctaocrypt/benchmark/benchmark
ctaocrypt/test/testctaocrypt ctaocrypt/test/testctaocrypt
wolfcrypt/benchmark/benchmark
wolfcrypt/test/testwolfcrypt
examples/client/client examples/client/client
examples/echoclient/echoclient examples/echoclient/echoclient
examples/echoserver/echoserver examples/echoserver/echoserver

21
Makefile.am
View File

@@ -60,8 +60,12 @@ EXTRA_DIST+= README.md
EXTRA_DIST+= LICENSING EXTRA_DIST+= LICENSING
#-------------------------------------# #-------------------------------------#
include wolfssl/include.am if BUILD_FIPS
include cyassl/include.am include cyassl/include.am
else
include wolfssl/include.am
endif
#-------------------------------------# #-------------------------------------#
include certs/include.am include certs/include.am
include certs/1024/include.am include certs/1024/include.am
@@ -72,14 +76,23 @@ include swig/include.am
include src/include.am include src/include.am
include support/include.am include support/include.am
#-------------------------------------# #-------------------------------------#
include wolfcrypt/benchmark/include.am if BUILD_FIPS
include ctaocrypt/benchmark/include.am include ctaocrypt/benchmark/include.am
else
include wolfcrypt/benchmark/include.am
endif
#-------------------------------------# #-------------------------------------#
include wolfcrypt/src/include.am if BUILD_FIPS
include ctaocrypt/src/include.am include ctaocrypt/src/include.am
else
include wolfcrypt/src/include.am
endif
#-------------------------------------# #-------------------------------------#
include wolfcrypt/test/include.am if BUILD_FIPS
include ctaocrypt/test/include.am include ctaocrypt/test/include.am
else
include wolfcrypt/test/include.am
endif
#-------------------------------------# #-------------------------------------#
include examples/client/include.am include examples/client/include.am
include examples/server/include.am include examples/server/include.am

2
configure.ac
View File

@@ -1472,7 +1472,7 @@ AC_ARG_ENABLE([smallstack],
if test "x$ENABLED_SMALL_STACK" = "xyes" if test "x$ENABLED_SMALL_STACK" = "xyes"
then then
AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_SMALL_STACK" AM_CFLAGS="$AM_CFLAGS -DCYASSL_SMALL_STACK"
fi fi

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 //#ifdef HAVE_CONFIG_H
#include <config.h> // #include <config.h>
#endif //#endif
//
#include <cyassl/ctaocrypt/settings.h> //#include <cyassl/ctaocrypt/settings.h>
//
#ifdef CYASSL_MD2 //#ifdef CYASSL_MD2
//
#include <cyassl/ctaocrypt/md2.h> //#include <cyassl/ctaocrypt/md2.h>
#include <cyassl/ctaocrypt/error-crypt.h> //#include <cyassl/ctaocrypt/error-crypt.h>
//
#ifdef NO_INLINE //#ifdef NO_INLINE
#include <cyassl/ctaocrypt/misc.h> // #include <cyassl/ctaocrypt/misc.h>
#else //#else
#include <ctaocrypt/src/misc.c> // #include <ctaocrypt/src/misc.c>
#endif //#endif
//
//
void InitMd2(Md2* md2) //void InitMd2(Md2* md2)
{ //{
XMEMSET(md2->X, 0, MD2_X_SIZE); // XMEMSET(md2->X, 0, MD2_X_SIZE);
XMEMSET(md2->C, 0, MD2_BLOCK_SIZE); // XMEMSET(md2->C, 0, MD2_BLOCK_SIZE);
XMEMSET(md2->buffer, 0, MD2_BLOCK_SIZE); // XMEMSET(md2->buffer, 0, MD2_BLOCK_SIZE);
md2->count = 0; // md2->count = 0;
} //}
//
//
void Md2Update(Md2* md2, const byte* data, word32 len) //void Md2Update(Md2* md2, const byte* data, word32 len)
{ //{
static const byte S[256] = // static const byte S[256] =
{ // {
41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6, // 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, // 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, // 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, // 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, // 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, // 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, // 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, // 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, // 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, // 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, // 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, // 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, // 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, // 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, // 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, // 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, // 166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237,
31, 26, 219, 153, 141, 51, 159, 17, 131, 20 // 31, 26, 219, 153, 141, 51, 159, 17, 131, 20
}; // };
//
while (len) { // while (len) {
word32 L = (MD2_PAD_SIZE - md2->count) < len ? // word32 L = (MD2_PAD_SIZE - md2->count) < len ?
(MD2_PAD_SIZE - md2->count) : len; // (MD2_PAD_SIZE - md2->count) : len;
XMEMCPY(md2->buffer + md2->count, data, L); // XMEMCPY(md2->buffer + md2->count, data, L);
md2->count += L; // md2->count += L;
data += L; // data += L;
len -= L; // len -= L;
//
if (md2->count == MD2_PAD_SIZE) { // if (md2->count == MD2_PAD_SIZE) {
int i; // int i;
byte t; // byte t;
//
md2->count = 0; // md2->count = 0;
XMEMCPY(md2->X + MD2_PAD_SIZE, md2->buffer, MD2_PAD_SIZE); // XMEMCPY(md2->X + MD2_PAD_SIZE, md2->buffer, MD2_PAD_SIZE);
t = md2->C[15]; // t = md2->C[15];
//
for(i = 0; i < MD2_PAD_SIZE; i++) { // for(i = 0; i < MD2_PAD_SIZE; i++) {
md2->X[32 + i] = md2->X[MD2_PAD_SIZE + i] ^ md2->X[i]; // md2->X[32 + i] = md2->X[MD2_PAD_SIZE + i] ^ md2->X[i];
t = md2->C[i] ^= S[md2->buffer[i] ^ t]; // t = md2->C[i] ^= S[md2->buffer[i] ^ t];
} // }
//
t=0; // t=0;
for(i = 0; i < 18; i++) { // for(i = 0; i < 18; i++) {
int j; // int j;
for(j = 0; j < MD2_X_SIZE; j += 8) { // for(j = 0; j < MD2_X_SIZE; j += 8) {
t = md2->X[j+0] ^= S[t]; // t = md2->X[j+0] ^= S[t];
t = md2->X[j+1] ^= S[t]; // t = md2->X[j+1] ^= S[t];
t = md2->X[j+2] ^= S[t]; // t = md2->X[j+2] ^= S[t];
t = md2->X[j+3] ^= S[t]; // t = md2->X[j+3] ^= S[t];
t = md2->X[j+4] ^= S[t]; // t = md2->X[j+4] ^= S[t];
t = md2->X[j+5] ^= S[t]; // t = md2->X[j+5] ^= S[t];
t = md2->X[j+6] ^= S[t]; // t = md2->X[j+6] ^= S[t];
t = md2->X[j+7] ^= S[t]; // t = md2->X[j+7] ^= S[t];
} // }
t = (t + i) & 0xFF; // t = (t + i) & 0xFF;
} // }
} // }
} // }
} //}
//
//
void Md2Final(Md2* md2, byte* hash) //void Md2Final(Md2* md2, byte* hash)
{ //{
byte padding[MD2_BLOCK_SIZE]; // byte padding[MD2_BLOCK_SIZE];
word32 padLen = MD2_PAD_SIZE - md2->count; // word32 padLen = MD2_PAD_SIZE - md2->count;
word32 i; // word32 i;
//
for (i = 0; i < padLen; i++) // for (i = 0; i < padLen; i++)
padding[i] = (byte)padLen; // padding[i] = (byte)padLen;
//
Md2Update(md2, padding, padLen); // Md2Update(md2, padding, padLen);
Md2Update(md2, md2->C, MD2_BLOCK_SIZE); // Md2Update(md2, md2->C, MD2_BLOCK_SIZE);
//
XMEMCPY(hash, md2->X, MD2_DIGEST_SIZE); // XMEMCPY(hash, md2->X, MD2_DIGEST_SIZE);
//
InitMd2(md2); // InitMd2(md2);
} //}
//
//
int Md2Hash(const byte* data, word32 len, byte* hash) //int Md2Hash(const byte* data, word32 len, byte* hash)
{ //{
#ifdef CYASSL_SMALL_STACK //#ifdef CYASSL_SMALL_STACK
Md2* md2; // Md2* md2;
#else //#else
Md2 md2[1]; // Md2 md2[1];
#endif //#endif
//
#ifdef CYASSL_SMALL_STACK //#ifdef CYASSL_SMALL_STACK
md2 = (Md2*)XMALLOC(sizeof(Md2), NULL, DYNAMIC_TYPE_TMP_BUFFER); // md2 = (Md2*)XMALLOC(sizeof(Md2), NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (md2 == NULL) // if (md2 == NULL)
return MEMORY_E; // return MEMORY_E;
#endif //#endif
//
InitMd2(md2); // InitMd2(md2);
Md2Update(md2, data, len); // Md2Update(md2, data, len);
Md2Final(md2, hash); // Md2Final(md2, hash);
//
#ifdef CYASSL_SMALL_STACK //#ifdef CYASSL_SMALL_STACK
XFREE(md2, NULL, DYNAMIC_TYPE_TMP_BUFFER); // XFREE(md2, NULL, DYNAMIC_TYPE_TMP_BUFFER);
#endif //#endif
//
return 0; // return 0;
} //}
//
//
#endif /* CYASSL_MD2 */ //#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 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/ */
#ifdef HAVE_CONFIG_H //#ifdef HAVE_CONFIG_H
#include <config.h> // #include <config.h>
#endif //#endif
//
#include <cyassl/ctaocrypt/settings.h> //#include <cyassl/ctaocrypt/settings.h>
//
#ifndef NO_MD4 //#ifndef NO_MD4
//
#include <cyassl/ctaocrypt/md4.h> //#include <cyassl/ctaocrypt/md4.h>
#ifdef NO_INLINE //#ifdef NO_INLINE
#include <cyassl/ctaocrypt/misc.h> // #include <cyassl/ctaocrypt/misc.h>
#else //#else
#include <ctaocrypt/src/misc.c> // #include <ctaocrypt/src/misc.c>
#endif //#endif
//
//
#ifndef min //#ifndef min
//
static INLINE word32 min(word32 a, word32 b) // static INLINE word32 min(word32 a, word32 b)
{ // {
return a > b ? b : a; // return a > b ? b : a;
} // }
//
#endif /* min */ //#endif /* min */
//
//
void InitMd4(Md4* md4) //void InitMd4(Md4* md4)
{ //{
md4->digest[0] = 0x67452301L; // md4->digest[0] = 0x67452301L;
md4->digest[1] = 0xefcdab89L; // md4->digest[1] = 0xefcdab89L;
md4->digest[2] = 0x98badcfeL; // md4->digest[2] = 0x98badcfeL;
md4->digest[3] = 0x10325476L; // md4->digest[3] = 0x10325476L;
//
md4->buffLen = 0; // md4->buffLen = 0;
md4->loLen = 0; // md4->loLen = 0;
md4->hiLen = 0; // md4->hiLen = 0;
} //}
//
//
static void Transform(Md4* md4) //static void Transform(Md4* md4)
{ //{
#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) //#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z))) //#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
#define H(x, y, z) ((x) ^ (y) ^ (z)) //#define H(x, y, z) ((x) ^ (y) ^ (z))
//
/* Copy context->state[] to working vars */ // /* Copy context->state[] to working vars */
word32 A = md4->digest[0]; // word32 A = md4->digest[0];
word32 B = md4->digest[1]; // word32 B = md4->digest[1];
word32 C = md4->digest[2]; // word32 C = md4->digest[2];
word32 D = md4->digest[3]; // word32 D = md4->digest[3];
//
#define function(a,b,c,d,k,s) a=rotlFixed(a+F(b,c,d)+md4->buffer[k],s); //#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(A,B,C,D, 0, 3);
function(D,A,B,C, 1, 7); // function(D,A,B,C, 1, 7);
function(C,D,A,B, 2,11); // function(C,D,A,B, 2,11);
function(B,C,D,A, 3,19); // function(B,C,D,A, 3,19);
function(A,B,C,D, 4, 3); // function(A,B,C,D, 4, 3);
function(D,A,B,C, 5, 7); // function(D,A,B,C, 5, 7);
function(C,D,A,B, 6,11); // function(C,D,A,B, 6,11);
function(B,C,D,A, 7,19); // function(B,C,D,A, 7,19);
function(A,B,C,D, 8, 3); // function(A,B,C,D, 8, 3);
function(D,A,B,C, 9, 7); // function(D,A,B,C, 9, 7);
function(C,D,A,B,10,11); // function(C,D,A,B,10,11);
function(B,C,D,A,11,19); // function(B,C,D,A,11,19);
function(A,B,C,D,12, 3); // function(A,B,C,D,12, 3);
function(D,A,B,C,13, 7); // function(D,A,B,C,13, 7);
function(C,D,A,B,14,11); // function(C,D,A,B,14,11);
function(B,C,D,A,15,19); // function(B,C,D,A,15,19);
//
#undef function //#undef function
#define function(a,b,c,d,k,s) \ //#define function(a,b,c,d,k,s) \
a=rotlFixed(a+G(b,c,d)+md4->buffer[k]+0x5a827999,s); // a=rotlFixed(a+G(b,c,d)+md4->buffer[k]+0x5a827999,s);
//
function(A,B,C,D, 0, 3); // function(A,B,C,D, 0, 3);
function(D,A,B,C, 4, 5); // function(D,A,B,C, 4, 5);
function(C,D,A,B, 8, 9); // function(C,D,A,B, 8, 9);
function(B,C,D,A,12,13); // function(B,C,D,A,12,13);
function(A,B,C,D, 1, 3); // function(A,B,C,D, 1, 3);
function(D,A,B,C, 5, 5); // function(D,A,B,C, 5, 5);
function(C,D,A,B, 9, 9); // function(C,D,A,B, 9, 9);
function(B,C,D,A,13,13); // function(B,C,D,A,13,13);
function(A,B,C,D, 2, 3); // function(A,B,C,D, 2, 3);
function(D,A,B,C, 6, 5); // function(D,A,B,C, 6, 5);
function(C,D,A,B,10, 9); // function(C,D,A,B,10, 9);
function(B,C,D,A,14,13); // function(B,C,D,A,14,13);
function(A,B,C,D, 3, 3); // function(A,B,C,D, 3, 3);
function(D,A,B,C, 7, 5); // function(D,A,B,C, 7, 5);
function(C,D,A,B,11, 9); // function(C,D,A,B,11, 9);
function(B,C,D,A,15,13); // function(B,C,D,A,15,13);
//
#undef function //#undef function
#define function(a,b,c,d,k,s) \ //#define function(a,b,c,d,k,s) \
a=rotlFixed(a+H(b,c,d)+md4->buffer[k]+0x6ed9eba1,s); // a=rotlFixed(a+H(b,c,d)+md4->buffer[k]+0x6ed9eba1,s);
//
function(A,B,C,D, 0, 3); // function(A,B,C,D, 0, 3);
function(D,A,B,C, 8, 9); // function(D,A,B,C, 8, 9);
function(C,D,A,B, 4,11); // function(C,D,A,B, 4,11);
function(B,C,D,A,12,15); // function(B,C,D,A,12,15);
function(A,B,C,D, 2, 3); // function(A,B,C,D, 2, 3);
function(D,A,B,C,10, 9); // function(D,A,B,C,10, 9);
function(C,D,A,B, 6,11); // function(C,D,A,B, 6,11);
function(B,C,D,A,14,15); // function(B,C,D,A,14,15);
function(A,B,C,D, 1, 3); // function(A,B,C,D, 1, 3);
function(D,A,B,C, 9, 9); // function(D,A,B,C, 9, 9);
function(C,D,A,B, 5,11); // function(C,D,A,B, 5,11);
function(B,C,D,A,13,15); // function(B,C,D,A,13,15);
function(A,B,C,D, 3, 3); // function(A,B,C,D, 3, 3);
function(D,A,B,C,11, 9); // function(D,A,B,C,11, 9);
function(C,D,A,B, 7,11); // function(C,D,A,B, 7,11);
function(B,C,D,A,15,15); // function(B,C,D,A,15,15);
//
/* Add the working vars back into digest state[] */ // /* Add the working vars back into digest state[] */
md4->digest[0] += A; // md4->digest[0] += A;
md4->digest[1] += B; // md4->digest[1] += B;
md4->digest[2] += C; // md4->digest[2] += C;
md4->digest[3] += D; // md4->digest[3] += D;
} //}
//
//
static INLINE void AddLength(Md4* md4, word32 len) //static INLINE void AddLength(Md4* md4, word32 len)
{ //{
word32 tmp = md4->loLen; // word32 tmp = md4->loLen;
if ( (md4->loLen += len) < tmp) // if ( (md4->loLen += len) < tmp)
md4->hiLen++; /* carry low to high */ // md4->hiLen++; /* carry low to high */
} //}
//
//
void Md4Update(Md4* md4, const byte* data, word32 len) //void Md4Update(Md4* md4, const byte* data, word32 len)
{ //{
/* do block size increments */ // /* do block size increments */
byte* local = (byte*)md4->buffer; // byte* local = (byte*)md4->buffer;
//
while (len) { // while (len) {
word32 add = min(len, MD4_BLOCK_SIZE - md4->buffLen); // word32 add = min(len, MD4_BLOCK_SIZE - md4->buffLen);
XMEMCPY(&local[md4->buffLen], data, add); // XMEMCPY(&local[md4->buffLen], data, add);
//
md4->buffLen += add; // md4->buffLen += add;
data += add; // data += add;
len -= add; // len -= add;
//
if (md4->buffLen == MD4_BLOCK_SIZE) { // if (md4->buffLen == MD4_BLOCK_SIZE) {
#ifdef BIG_ENDIAN_ORDER // #ifdef BIG_ENDIAN_ORDER
ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE); // ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE);
#endif // #endif
Transform(md4); // Transform(md4);
AddLength(md4, MD4_BLOCK_SIZE); // AddLength(md4, MD4_BLOCK_SIZE);
md4->buffLen = 0; // md4->buffLen = 0;
} // }
} // }
} //}
//
//
void Md4Final(Md4* md4, byte* hash) //void Md4Final(Md4* md4, byte* hash)
{ //{
byte* local = (byte*)md4->buffer; // byte* local = (byte*)md4->buffer;
//
AddLength(md4, md4->buffLen); /* before adding pads */ // AddLength(md4, md4->buffLen); /* before adding pads */
//
local[md4->buffLen++] = 0x80; /* add 1 */ // local[md4->buffLen++] = 0x80; /* add 1 */
//
/* pad with zeros */ // /* pad with zeros */
if (md4->buffLen > MD4_PAD_SIZE) { // if (md4->buffLen > MD4_PAD_SIZE) {
XMEMSET(&local[md4->buffLen], 0, MD4_BLOCK_SIZE - md4->buffLen); // XMEMSET(&local[md4->buffLen], 0, MD4_BLOCK_SIZE - md4->buffLen);
md4->buffLen += MD4_BLOCK_SIZE - md4->buffLen; // md4->buffLen += MD4_BLOCK_SIZE - md4->buffLen;
//
#ifdef BIG_ENDIAN_ORDER // #ifdef BIG_ENDIAN_ORDER
ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE); // ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE);
#endif // #endif
Transform(md4); // Transform(md4);
md4->buffLen = 0; // md4->buffLen = 0;
} // }
XMEMSET(&local[md4->buffLen], 0, MD4_PAD_SIZE - md4->buffLen); // XMEMSET(&local[md4->buffLen], 0, MD4_PAD_SIZE - md4->buffLen);
//
/* put lengths in bits */ // /* put lengths in bits */
md4->hiLen = (md4->loLen >> (8*sizeof(md4->loLen) - 3)) + // md4->hiLen = (md4->loLen >> (8*sizeof(md4->loLen) - 3)) +
(md4->hiLen << 3); // (md4->hiLen << 3);
md4->loLen = md4->loLen << 3; // md4->loLen = md4->loLen << 3;
//
/* store lengths */ // /* store lengths */
#ifdef BIG_ENDIAN_ORDER // #ifdef BIG_ENDIAN_ORDER
ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE); // ByteReverseWords(md4->buffer, md4->buffer, MD4_BLOCK_SIZE);
#endif // #endif
/* ! length ordering dependent on digest endian type ! */ // /* ! length ordering dependent on digest endian type ! */
XMEMCPY(&local[MD4_PAD_SIZE], &md4->loLen, sizeof(word32)); // XMEMCPY(&local[MD4_PAD_SIZE], &md4->loLen, sizeof(word32));
XMEMCPY(&local[MD4_PAD_SIZE + sizeof(word32)], &md4->hiLen, sizeof(word32)); // XMEMCPY(&local[MD4_PAD_SIZE + sizeof(word32)], &md4->hiLen, sizeof(word32));
//
Transform(md4); // Transform(md4);
#ifdef BIG_ENDIAN_ORDER // #ifdef BIG_ENDIAN_ORDER
ByteReverseWords(md4->digest, md4->digest, MD4_DIGEST_SIZE); // ByteReverseWords(md4->digest, md4->digest, MD4_DIGEST_SIZE);
#endif // #endif
XMEMCPY(hash, md4->digest, MD4_DIGEST_SIZE); // XMEMCPY(hash, md4->digest, MD4_DIGEST_SIZE);
//
InitMd4(md4); /* reset state */ // InitMd4(md4); /* reset state */
} //}
//
//
#endif /* NO_MD4 */ //#endif /* NO_MD4 */
//

738
ctaocrypt/src/md5.c
View File

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

3656
ctaocrypt/src/pkcs7.c
View File

File diff suppressed because it is too large Load Diff

6
cyassl-ios.xcodeproj/project.pbxproj
View File

@@ -57,7 +57,7 @@
/* Begin PBXFileReference section */ /* Begin PBXFileReference section */
52397C5C17E0E63200517C9A /* port.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = port.c; path = ctaocrypt/src/port.c; sourceTree = SOURCE_ROOT; }; 52397C5C17E0E63200517C9A /* port.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = port.c; path = ctaocrypt/src/port.c; sourceTree = SOURCE_ROOT; };
52B1344D16F3C9E800C07B32 /* libcyassl-ios.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libcyassl-ios.a"; sourceTree = BUILT_PRODUCTS_DIR; }; 52B1344D16F3C9E800C07B32 /* libwolfssl-ios.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libwolfssl-ios.a"; sourceTree = BUILT_PRODUCTS_DIR; };
52B1347B16F3CCC400C07B32 /* tls.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = tls.c; path = src/tls.c; sourceTree = SOURCE_ROOT; }; 52B1347B16F3CCC400C07B32 /* tls.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = tls.c; path = src/tls.c; sourceTree = SOURCE_ROOT; };
52B1347C16F3CCC400C07B32 /* ssl.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ssl.c; path = src/ssl.c; sourceTree = SOURCE_ROOT; }; 52B1347C16F3CCC400C07B32 /* ssl.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ssl.c; path = src/ssl.c; sourceTree = SOURCE_ROOT; };
52B1347D16F3CCC400C07B32 /* ocsp.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ocsp.c; path = src/ocsp.c; sourceTree = SOURCE_ROOT; }; 52B1347D16F3CCC400C07B32 /* ocsp.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ocsp.c; path = src/ocsp.c; sourceTree = SOURCE_ROOT; };
@@ -115,7 +115,7 @@
52B1344E16F3C9E800C07B32 /* Products */ = { 52B1344E16F3C9E800C07B32 /* Products */ = {
isa = PBXGroup; isa = PBXGroup;
children = ( children = (
52B1344D16F3C9E800C07B32 /* libcyassl-ios.a */, 52B1344D16F3C9E800C07B32 /* libwolfssl-ios.a */,
); );
name = Products; name = Products;
sourceTree = "<group>"; sourceTree = "<group>";
@@ -195,7 +195,7 @@
); );
name = "cyassl-ios"; name = "cyassl-ios";
productName = "cyassl-ios"; productName = "cyassl-ios";
productReference = 52B1344D16F3C9E800C07B32 /* libcyassl-ios.a */; productReference = 52B1344D16F3C9E800C07B32 /* libwolfssl-ios.a */;
productType = "com.apple.product-type.library.static"; productType = "com.apple.product-type.library.static";
}; };
/* End PBXNativeTarget section */ /* End PBXNativeTarget section */

6
cyassl-iphone.xcodeproj/project.pbxproj
View File

@@ -98,7 +98,7 @@
43CB530D116E9FD5000A264B /* iphone-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "iphone-Info.plist"; sourceTree = "<group>"; }; 43CB530D116E9FD5000A264B /* iphone-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "iphone-Info.plist"; sourceTree = "<group>"; };
43D565640F1EC9A600550C88 /* hc128.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; lineEnding = 2; name = hc128.c; path = ctaocrypt/src/hc128.c; sourceTree = "<group>"; }; 43D565640F1EC9A600550C88 /* hc128.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; lineEnding = 2; name = hc128.c; path = ctaocrypt/src/hc128.c; sourceTree = "<group>"; };
43D565660F1EC9CC00550C88 /* rabbit.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; lineEnding = 2; name = rabbit.c; path = ctaocrypt/src/rabbit.c; sourceTree = "<group>"; }; 43D565660F1EC9CC00550C88 /* rabbit.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; lineEnding = 2; name = rabbit.c; path = ctaocrypt/src/rabbit.c; sourceTree = "<group>"; };
D2AAC046055464E500DB518D /* libcyassl.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libcyassl.a; sourceTree = BUILT_PRODUCTS_DIR; }; D2AAC046055464E500DB518D /* libwolfssl.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libwolfssl.a; sourceTree = BUILT_PRODUCTS_DIR; };
/* End PBXFileReference section */ /* End PBXFileReference section */
/* Begin PBXFrameworksBuildPhase section */ /* Begin PBXFrameworksBuildPhase section */
@@ -135,7 +135,7 @@
1AB674ADFE9D54B511CA2CBB /* Products */ = { 1AB674ADFE9D54B511CA2CBB /* Products */ = {
isa = PBXGroup; isa = PBXGroup;
children = ( children = (
D2AAC046055464E500DB518D /* libcyassl.a */, D2AAC046055464E500DB518D /* libwolfssl.a */,
); );
name = Products; name = Products;
sourceTree = "<group>"; sourceTree = "<group>";
@@ -220,7 +220,7 @@
); );
name = cyassl; name = cyassl;
productName = cyassl; productName = cyassl;
productReference = D2AAC046055464E500DB518D /* libcyassl.a */; productReference = D2AAC046055464E500DB518D /* libwolfssl.a */;
productType = "com.apple.product-type.library.static"; productType = "com.apple.product-type.library.static";
}; };
/* End PBXNativeTarget section */ /* End PBXNativeTarget section */

11
cyassl/ctaocrypt/arc4.h
View File

@@ -24,4 +24,15 @@
#include <wolfssl/wolfcrypt/arc4.h> #include <wolfssl/wolfcrypt/arc4.h>
/* for arc4 reverse compatibility */
#ifndef NO_RC4
#include <wolfssl/wolfcrypt/arc4.h>
#define CYASSL_ARC4_CAVIUM_MAGIC WOLFSSL_ARC4_CAVIUM_MAGIC
#define Arc4Process wc_Arc4Process
#define Arc4SetKey wc_Arc4SetKey
#define Arc4InitCavium wc_Arc4InitCavium
#define Arc4FreeCavium wc_Arc4FreeCavium
#endif #endif
#endif /* CTAO_CRYPT_ARC4_H */

33
cyassl/ctaocrypt/blake2.h
View File

@@ -25,34 +25,13 @@
#ifndef CTAOCRYPT_BLAKE2_H #ifndef CTAOCRYPT_BLAKE2_H
#define CTAOCRYPT_BLAKE2_H #define CTAOCRYPT_BLAKE2_H
#include <cyassl/ctaocrypt/blake2-int.h> #include <wolfssl/wolfcrypt/blake2.h>
#ifdef __cplusplus /* for blake2 reverse compatibility */
extern "C" { #ifdef HAVE_BLAKE2
#endif #define InitBlake2b wc_InitBlake2b
#define Blake2bUpdate wc_Blake2bUpdate
/* in bytes, variable digest size up to 512 bits (64 bytes) */ #define Blake2bFinal wc_Blake2bFinal
enum {
BLAKE2B_ID = 7, /* hash type unique */
BLAKE2B_256 = 32 /* 256 bit type, SSL default */
};
/* BLAKE2b digest */
typedef struct Blake2b {
blake2b_state S[1]; /* our state */
word32 digestSz; /* digest size used on init */
} Blake2b;
CYASSL_API int InitBlake2b(Blake2b*, word32);
CYASSL_API int Blake2bUpdate(Blake2b*, const byte*, word32);
CYASSL_API int Blake2bFinal(Blake2b*, byte*, word32);
#ifdef __cplusplus
}
#endif #endif
#endif /* CTAOCRYPT_BLAKE2_H */ #endif /* CTAOCRYPT_BLAKE2_H */

11
cyassl/ctaocrypt/camellia.h
View File

@@ -24,4 +24,15 @@
#include <wolfssl/wolfcrypt/camellia.h> #include <wolfssl/wolfcrypt/camellia.h>
/* for blake2 reverse compatibility */
#ifdef HAVE_CAMELLIA
#define CamelliaSetKey wc_CamelliaSetKey
#define CamelliaSetIV wc_CamelliaSetIV
#define CamelliaEncryptDirect wc_CamelliaEncryptDirect
#define CamelliaDecryptDirect wc_CamelliaDecryptDirect
#define CamelliaCbcEncrypt wc_CamelliaCbcEncrypt
#define CamelliaCbcDecrypt wc_CamelliaCbcDecrypt
#endif #endif
#endif /* CTAO_CRYPT_CAMELLIA_H */

34
cyassl/ctaocrypt/chacha.h
View File

@@ -22,34 +22,12 @@
#ifndef CTAO_CRYPT_CHACHA_H #ifndef CTAO_CRYPT_CHACHA_H
#define CTAO_CRYPT_CHACHA_H #define CTAO_CRYPT_CHACHA_H
#include "types.h" #include <wolfssl/wolfcrypt/chacha.h>
#ifdef __cplusplus /* for chacha reverse compatibility */
extern "C" { #define Chacha_Process wc_Chacha_Process
#endif #define Chacha_SetKey wc_Chacha_SetKey
#define Chacha_SetIV wc_Chacha_SetIV
#endif /* CTAO_CRYPT_CHACHA_H */
enum {
CHACHA_ENC_TYPE = 7 /* cipher unique type */
};
typedef struct ChaCha {
word32 X[16]; /* state of cipher */
} ChaCha;
CYASSL_API int Chacha_Process(ChaCha* ctx, byte* cipher, const byte* plain,
word32 msglen);
CYASSL_API int Chacha_SetKey(ChaCha* ctx, const byte* key, word32 keySz);
/**
* IV(nonce) changes with each record
* counter is for what value the block counter should start ... usually 0
*/
CYASSL_API int Chacha_SetIV(ChaCha* ctx, const byte* inIv, word32 counter);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif

43
cyassl/ctaocrypt/compress.h
View File

@@ -25,27 +25,32 @@
#ifndef CTAO_CRYPT_COMPRESS_H #ifndef CTAO_CRYPT_COMPRESS_H
#define CTAO_CRYPT_COMPRESS_H #define CTAO_CRYPT_COMPRESS_H
#include <wolfssl/wolfcrypt/compress.h>
#include <cyassl/ctaocrypt/types.h> /* reverse compatibility */
#define Compress wc_Compress
#define DeCompress wc_DeCompress
#ifdef __cplusplus
extern "C" {
#endif
#define COMPRESS_FIXED 1
CYASSL_API int Compress(byte*, word32, const byte*, word32, word32);
CYASSL_API int DeCompress(byte*, word32, const byte*, word32);
#ifdef __cplusplus
} /* extern "C" */
#endif
//#include <cyassl/ctaocrypt/types.h>
//
//
//#ifdef __cplusplus
// extern "C" {
//#endif
//
//
//#define COMPRESS_FIXED 1
//
//
//CYASSL_API int Compress(byte*, word32, const byte*, word32, word32);
//CYASSL_API int DeCompress(byte*, word32, const byte*, word32);
//
//
//#ifdef __cplusplus
// } /* extern "C" */
//#endif
//
//
#endif /* CTAO_CRYPT_COMPRESS_H */ #endif /* CTAO_CRYPT_COMPRESS_H */
#endif /* HAVE_LIBZ */ #endif /* HAVE_LIBZ */

77
cyassl/ctaocrypt/dh.h
View File

@@ -25,41 +25,52 @@
#ifndef CTAO_CRYPT_DH_H #ifndef CTAO_CRYPT_DH_H
#define CTAO_CRYPT_DH_H #define CTAO_CRYPT_DH_H
#include <cyassl/ctaocrypt/types.h> #include <wolfssl/wolfcrypt/dh.h>
#include <cyassl/ctaocrypt/integer.h>
#include <cyassl/ctaocrypt/random.h>
#ifdef __cplusplus /* for dh reverse compatibility */
extern "C" { #define InitDhKey wc_InitDhKey
#endif #define FreeDhKey wc_FreeDhKey
#define DhGenerateKeyPair wc_DhGenerateKeyPair
#define DhAgree wc_DhAgree
#define DhKeyDecode wc_DhKeyDecode
#define DhSetKey wc_DhSetKey
#define DhParamsLoad wc_DhParamsLoad
//#include <cyassl/ctaocrypt/types.h>
/* Diffie-Hellman Key */ //#include <cyassl/ctaocrypt/integer.h>
typedef struct DhKey { //#include <cyassl/ctaocrypt/random.h>
mp_int p, g; /* group parameters */ //
} DhKey; //#ifdef __cplusplus
// extern "C" {
//#endif
CYASSL_API void InitDhKey(DhKey* key); //
CYASSL_API void FreeDhKey(DhKey* key); //
///* Diffie-Hellman Key */
CYASSL_API int DhGenerateKeyPair(DhKey* key, RNG* rng, byte* priv, //typedef struct DhKey {
word32* privSz, byte* pub, word32* pubSz); // mp_int p, g; /* group parameters */
CYASSL_API int DhAgree(DhKey* key, byte* agree, word32* agreeSz, //} DhKey;
const byte* priv, word32 privSz, const byte* otherPub, //
word32 pubSz); //
//CYASSL_API void InitDhKey(DhKey* key);
CYASSL_API int DhKeyDecode(const byte* input, word32* inOutIdx, DhKey* key, //CYASSL_API void FreeDhKey(DhKey* key);
word32); //
CYASSL_API int DhSetKey(DhKey* key, const byte* p, word32 pSz, const byte* g, //CYASSL_API int DhGenerateKeyPair(DhKey* key, RNG* rng, byte* priv,
word32 gSz); // word32* privSz, byte* pub, word32* pubSz);
CYASSL_API int DhParamsLoad(const byte* input, word32 inSz, byte* p, //CYASSL_API int DhAgree(DhKey* key, byte* agree, word32* agreeSz,
word32* pInOutSz, byte* g, word32* gInOutSz); // const byte* priv, word32 privSz, const byte* otherPub,
// word32 pubSz);
//
#ifdef __cplusplus //CYASSL_API int DhKeyDecode(const byte* input, word32* inOutIdx, DhKey* key,
} /* extern "C" */ // word32);
#endif //CYASSL_API int DhSetKey(DhKey* key, const byte* p, word32 pSz, const byte* g,
// word32 gSz);
//CYASSL_API int DhParamsLoad(const byte* input, word32 inSz, byte* p,
// word32* pInOutSz, byte* g, word32* gInOutSz);
//
//
//#ifdef __cplusplus
// } /* extern "C" */
//#endif
#endif /* CTAO_CRYPT_DH_H */ #endif /* CTAO_CRYPT_DH_H */

39
cyassl/ctaocrypt/dsa.h
View File

@@ -25,43 +25,8 @@
#ifndef CTAO_CRYPT_DSA_H #ifndef CTAO_CRYPT_DSA_H
#define CTAO_CRYPT_DSA_H #define CTAO_CRYPT_DSA_H
#include <cyassl/ctaocrypt/types.h> #include <wolfssl/wolfcrypt/dsa.h>
#include <cyassl/ctaocrypt/integer.h>
#include <cyassl/ctaocrypt/random.h>
#ifdef __cplusplus #endif /* CTAO_CRYPT_DSA_H */
extern "C" {
#endif
enum {
DSA_PUBLIC = 0,
DSA_PRIVATE = 1
};
/* DSA */
typedef struct DsaKey {
mp_int p, q, g, y, x;
int type; /* public or private */
} DsaKey;
CYASSL_API void InitDsaKey(DsaKey* key);
CYASSL_API void FreeDsaKey(DsaKey* key);
CYASSL_API int DsaSign(const byte* digest, byte* out, DsaKey* key, RNG* rng);
CYASSL_API int DsaVerify(const byte* digest, const byte* sig, DsaKey* key,
int* answer);
CYASSL_API int DsaPublicKeyDecode(const byte* input, word32* inOutIdx, DsaKey*,
word32);
CYASSL_API int DsaPrivateKeyDecode(const byte* input, word32* inOutIdx, DsaKey*,
word32);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* WOLF_CRYPT_DSA_H */
#endif /* NO_DSA */ #endif /* NO_DSA */

33
cyassl/ctaocrypt/ecc.h
View File

@@ -25,6 +25,39 @@
#define CTAO_CRYPT_ECC_H #define CTAO_CRYPT_ECC_H
#include <wolfssl/wolfcrypt/ecc.h> #include <wolfssl/wolfcrypt/ecc.h>
/* for ecc reverse compatibility */
#ifdef HAVE_ECC
#define ecc_make_key wc_ecc_make_key
#define ecc_shared_secret wc_ecc_shared_secret
#define ecc_sign_hash wc_ecc_sign_hash
#define ecc_verify_hash wc_ecc_verify_hash
#define ecc_init wc_ecc_init
#define ecc_free wc_ecc_free
#define ecc_fp_free wc_ecc_fp_free
#define ecc_export_x963 wc_ecc_export_x963
#define ecc_size wc_ecc_size
#define ecc_sig_size wc_ecc_sig_size
#define ecc_export_x963_ex wc_ecc_export_x963_ex
#define ecc_import_x963 wc_ecc_import_x963
#define ecc_import_private_key wc_ecc_import_private_key
#define ecc_rs_to_sig wc_ecc_rs_to_sig
#define ecc_import_raw wc_ecc_import_raw
#define ecc_export_private_only wc_ecc_export_private_only
#ifdef HAVE_ECC_ENCRYPT
/* ecc encrypt */
#define ecc_ctx_new wc_ecc_ctx_new
#define ecc_ctx_free wc_ecc_ctx_free
#define ecc_ctx_reset wc_ecc_ctx_reset
#define ecc_ctx_get_own_salt wc_ecc_ctx_get_own_salt
#define ecc_ctx_set_peer_salt wc_ecc_ctx_set_peer_salt
#define ecc_ctx_set_info wc_ecc_ctx_set_info
#define ecc_encrypt wc_ecc_encrypt
#define ecc_decrypt wc_ecc_decrypt
#endif /* HAVE_ECC_ENCRYPT */
#endif
// //
//#include <cyassl/ctaocrypt/types.h> //#include <cyassl/ctaocrypt/types.h>
//#include <cyassl/ctaocrypt/integer.h> //#include <cyassl/ctaocrypt/integer.h>

6
cyassl/ctaocrypt/error-crypt.h
View File

@@ -23,6 +23,10 @@
#ifndef CTAO_CRYPT_ERROR_H #ifndef CTAO_CRYPT_ERROR_H
#define CTAO_CRYPT_ERROR_H #define CTAO_CRYPT_ERROR_H
/* for name change and fips compatibility @wc_fips */
#ifndef HAVE_FIPS
#include <wolfssl/wolfcrypt/error-crypt.h>
#else
#include <cyassl/ctaocrypt/types.h> #include <cyassl/ctaocrypt/types.h>
@@ -150,7 +154,7 @@ CYASSL_API const char* CTaoCryptGetErrorString(int error);
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */
#endif #endif
#endif /* HAVE_FIPS */
#endif /* CTAO_CRYPT_ERROR_H */ #endif /* CTAO_CRYPT_ERROR_H */

33
cyassl/ctaocrypt/hc128.h
View File

@@ -25,36 +25,15 @@
#ifndef CTAO_CRYPT_HC128_H #ifndef CTAO_CRYPT_HC128_H
#define CTAO_CRYPT_HC128_H #define CTAO_CRYPT_HC128_H
#include <cyassl/ctaocrypt/types.h> #include <wolfssl/wolfcrypt/hc128.h>
#ifdef __cplusplus /* for hc128 reverse compatibility */
extern "C" { #ifdef HAVE_HC128
#endif #define Hc128_Process wc_Hc128_Process
#define Hc128_SetKey wc_Hc128_SetKey
enum {
HC128_ENC_TYPE = 6 /* cipher unique type */
};
/* HC-128 stream cipher */
typedef struct HC128 {
word32 T[1024]; /* P[i] = T[i]; Q[i] = T[1024 + i ]; */
word32 X[16];
word32 Y[16];
word32 counter1024; /* counter1024 = i mod 1024 at the ith step */
word32 key[8];
word32 iv[8];
} HC128;
CYASSL_API int Hc128_Process(HC128*, byte*, const byte*, word32);
CYASSL_API int Hc128_SetKey(HC128*, const byte* key, const byte* iv);
#ifdef __cplusplus
} /* extern "C" */
#endif #endif
#endif /* CTAO_CRYPT_HC128_H */ #endif /* CTAO_CRYPT_HC128_H */
#endif /* HAVE_HC128 */ #endif /* HAVE_HC128 */

88
cyassl/ctaocrypt/logging.h
View File

@@ -25,46 +25,50 @@
#ifndef CYASSL_LOGGING_H #ifndef CYASSL_LOGGING_H
#define CYASSL_LOGGING_H #define CYASSL_LOGGING_H
/* for fips compatibility @wc_fips */
#ifdef __cplusplus #ifndef HAVE_FIPS
extern "C" { #include <wolfssl/wolfcrypt/logging.h>
#endif #else
#ifdef __cplusplus
extern "C" {
enum CYA_Log_Levels { #endif
ERROR_LOG = 0,
INFO_LOG,
ENTER_LOG, enum CYA_Log_Levels {
LEAVE_LOG, ERROR_LOG = 0,
OTHER_LOG INFO_LOG,
}; ENTER_LOG,
LEAVE_LOG,
typedef void (*CyaSSL_Logging_cb)(const int logLevel, OTHER_LOG
const char *const logMessage); };
CYASSL_API int CyaSSL_SetLoggingCb(CyaSSL_Logging_cb log_function); typedef void (*CyaSSL_Logging_cb)(const int logLevel,
const char *const logMessage);
#ifdef DEBUG_CYASSL CYASSL_API int CyaSSL_SetLoggingCb(CyaSSL_Logging_cb log_function);
void CYASSL_ENTER(const char* msg);
void CYASSL_LEAVE(const char* msg, int ret); #ifdef DEBUG_CYASSL
void CYASSL_ERROR(int); void CYASSL_ENTER(const char* msg);
void CYASSL_MSG(const char* msg); void CYASSL_LEAVE(const char* msg, int ret);
#else /* DEBUG_CYASSL */ void CYASSL_ERROR(int);
void CYASSL_MSG(const char* msg);
#define CYASSL_ENTER(m)
#define CYASSL_LEAVE(m, r) #else /* DEBUG_CYASSL */
#define CYASSL_ERROR(e) #define CYASSL_ENTER(m)
#define CYASSL_MSG(m) #define CYASSL_LEAVE(m, r)
#endif /* DEBUG_CYASSL */ #define CYASSL_ERROR(e)
#define CYASSL_MSG(m)
#ifdef __cplusplus
} #endif /* DEBUG_CYASSL */
#endif
#ifdef __cplusplus
}
#endif
#endif /* HAVE_FIPS*/
#endif /* CYASSL_MEMORY_H */ #endif /* CYASSL_MEMORY_H */

75
cyassl/ctaocrypt/md2.h
View File

@@ -20,46 +20,53 @@
*/ */
/* check for old macro */
#if !defined(CYASSL_MD2) && defined(WOLFSSL_MD2)
#define CYASSL_MD2
#endif
#ifdef CYASSL_MD2 #ifdef CYASSL_MD2
#ifndef CTAO_CRYPT_MD2_H #ifndef CTAO_CRYPT_MD2_H
#define CTAO_CRYPT_MD2_H #define CTAO_CRYPT_MD2_H
#include <cyassl/ctaocrypt/types.h> #include <wolfssl/wolfcrypt/md2.h>
#ifdef __cplusplus //#include <cyassl/ctaocrypt/types.h>
extern "C" { //
#endif //#ifdef __cplusplus
// extern "C" {
//#endif
/* in bytes */ //
enum { //
MD2 = 6, /* hash type unique */ ///* in bytes */
MD2_BLOCK_SIZE = 16, //enum {
MD2_DIGEST_SIZE = 16, // MD2 = 6, /* hash type unique */
MD2_PAD_SIZE = 16, // MD2_BLOCK_SIZE = 16,
MD2_X_SIZE = 48 // MD2_DIGEST_SIZE = 16,
}; // MD2_PAD_SIZE = 16,
// MD2_X_SIZE = 48
//};
/* Md2 digest */ //
typedef struct Md2 { //
word32 count; /* bytes % PAD_SIZE */ ///* Md2 digest */
byte X[MD2_X_SIZE]; //typedef struct Md2 {
byte C[MD2_BLOCK_SIZE]; // word32 count; /* bytes % PAD_SIZE */
byte buffer[MD2_BLOCK_SIZE]; // byte X[MD2_X_SIZE];
} Md2; // byte C[MD2_BLOCK_SIZE];
// byte buffer[MD2_BLOCK_SIZE];
//} Md2;
CYASSL_API void InitMd2(Md2*); //
CYASSL_API void Md2Update(Md2*, const byte*, word32); //
CYASSL_API void Md2Final(Md2*, byte*); //CYASSL_API void InitMd2(Md2*);
CYASSL_API int Md2Hash(const byte*, word32, byte*); //CYASSL_API void Md2Update(Md2*, const byte*, word32);
//CYASSL_API void Md2Final(Md2*, byte*);
//CYASSL_API int Md2Hash(const byte*, word32, byte*);
#ifdef __cplusplus //
} /* extern "C" */ //
#endif //#ifdef __cplusplus
// } /* extern "C" */
//#endif
#endif /* CTAO_CRYPT_MD2_H */ #endif /* CTAO_CRYPT_MD2_H */
#endif /* CYASSL_MD2 */ #endif /* CYASSL_MD2 */

66
cyassl/ctaocrypt/md4.h
View File

@@ -25,39 +25,41 @@
#ifndef CTAO_CRYPT_MD4_H #ifndef CTAO_CRYPT_MD4_H
#define CTAO_CRYPT_MD4_H #define CTAO_CRYPT_MD4_H
#include <cyassl/ctaocrypt/types.h> #include <wolfssl/wolfcrypt/md4.h>
#ifdef __cplusplus //#include <cyassl/ctaocrypt/types.h>
extern "C" { //
#endif //#ifdef __cplusplus
// extern "C" {
//#endif
/* in bytes */ //
enum { //
MD4_BLOCK_SIZE = 64, ///* in bytes */
MD4_DIGEST_SIZE = 16, //enum {
MD4_PAD_SIZE = 56 // MD4_BLOCK_SIZE = 64,
}; // MD4_DIGEST_SIZE = 16,
// MD4_PAD_SIZE = 56
//};
/* MD4 digest */ //
typedef struct Md4 { //
word32 buffLen; /* in bytes */ ///* MD4 digest */
word32 loLen; /* length in bytes */ //typedef struct Md4 {
word32 hiLen; /* length in bytes */ // word32 buffLen; /* in bytes */
word32 digest[MD4_DIGEST_SIZE / sizeof(word32)]; // word32 loLen; /* length in bytes */
word32 buffer[MD4_BLOCK_SIZE / sizeof(word32)]; // word32 hiLen; /* length in bytes */
} Md4; // word32 digest[MD4_DIGEST_SIZE / sizeof(word32)];
// word32 buffer[MD4_BLOCK_SIZE / sizeof(word32)];
//} Md4;
CYASSL_API void InitMd4(Md4*); //
CYASSL_API void Md4Update(Md4*, const byte*, word32); //
CYASSL_API void Md4Final(Md4*, byte*); //CYASSL_API void InitMd4(Md4*);
//CYASSL_API void Md4Update(Md4*, const byte*, word32);
//CYASSL_API void Md4Final(Md4*, byte*);
#ifdef __cplusplus //
} /* extern "C" */ //
#endif //#ifdef __cplusplus
// } /* extern "C" */
//#endif
#endif /* CTAO_CRYPT_MD4_H */ #endif /* CTAO_CRYPT_MD4_H */

89
cyassl/ctaocrypt/md5.h
View File

@@ -24,51 +24,54 @@
#ifndef CTAO_CRYPT_MD5_H #ifndef CTAO_CRYPT_MD5_H
#define CTAO_CRYPT_MD5_H #define CTAO_CRYPT_MD5_H
#include <cyassl/ctaocrypt/types.h> #include <wolfssl/wolfcrypt/md5.h>
#ifdef __cplusplus
extern "C" {
#endif
/* in bytes */ //#include <cyassl/ctaocrypt/types.h>
enum { //
#ifdef STM32F2_HASH //#ifdef __cplusplus
MD5_REG_SIZE = 4, /* STM32 register size, bytes */ // extern "C" {
#endif //#endif
MD5 = 0, /* hash type unique */ //
MD5_BLOCK_SIZE = 64, //
MD5_DIGEST_SIZE = 16, ///* in bytes */
MD5_PAD_SIZE = 56 //enum {
}; //#ifdef STM32F2_HASH
// MD5_REG_SIZE = 4, /* STM32 register size, bytes */
#ifdef CYASSL_PIC32MZ_HASH //#endif
#include "port/pic32/pic32mz-crypt.h" // MD5 = 0, /* hash type unique */
#endif // MD5_BLOCK_SIZE = 64,
// MD5_DIGEST_SIZE = 16,
/* MD5 digest */ // MD5_PAD_SIZE = 56
typedef struct Md5 { //};
word32 buffLen; /* in bytes */ //
word32 loLen; /* length in bytes */ //#ifdef CYASSL_PIC32MZ_HASH
word32 hiLen; /* length in bytes */ //#include "port/pic32/pic32mz-crypt.h"
word32 buffer[MD5_BLOCK_SIZE / sizeof(word32)]; //#endif
#ifndef CYASSL_PIC32MZ_HASH //
word32 digest[MD5_DIGEST_SIZE / sizeof(word32)]; ///* MD5 digest */
#else //typedef struct Md5 {
word32 digest[PIC32_HASH_SIZE / sizeof(word32)]; // word32 buffLen; /* in bytes */
pic32mz_desc desc ; /* Crypt Engine descripter */ // word32 loLen; /* length in bytes */
#endif // word32 hiLen; /* length in bytes */
} Md5; // word32 buffer[MD5_BLOCK_SIZE / sizeof(word32)];
// #ifndef CYASSL_PIC32MZ_HASH
CYASSL_API void InitMd5(Md5*); // word32 digest[MD5_DIGEST_SIZE / sizeof(word32)];
CYASSL_API void Md5Update(Md5*, const byte*, word32); // #else
CYASSL_API void Md5Final(Md5*, byte*); // word32 digest[PIC32_HASH_SIZE / sizeof(word32)];
CYASSL_API int Md5Hash(const byte*, word32, byte*); // pic32mz_desc desc ; /* Crypt Engine descripter */
// #endif
//} Md5;
#ifdef __cplusplus //
} /* extern "C" */ //CYASSL_API void InitMd5(Md5*);
#endif //CYASSL_API void Md5Update(Md5*, const byte*, word32);
//CYASSL_API void Md5Final(Md5*, byte*);
//CYASSL_API int Md5Hash(const byte*, word32, byte*);
//
//
//#ifdef __cplusplus
// } /* extern "C" */
//#endif
#endif /* CTAO_CRYPT_MD5_H */ #endif /* CTAO_CRYPT_MD5_H */
#endif /* NO_MD5 */ #endif /* NO_MD5 */

6
cyassl/ctaocrypt/memory.h
View File

@@ -26,7 +26,11 @@
#define CYASSL_MEMORY_H #define CYASSL_MEMORY_H
#include <stdlib.h> #include <stdlib.h>
/* for fips compatibility @wc_fips */
#ifndef HAVE_FIPS
#include <wolfssl/wolfcrypt/memory.h> #include <wolfssl/wolfcrypt/memory.h>
#else
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@@ -53,4 +57,6 @@ CYASSL_API void* CyaSSL_Realloc(void *ptr, size_t size);
} }
#endif #endif
#endif /* HAVE_FIPS */
#endif /* CYASSL_MEMORY_H */ #endif /* CYASSL_MEMORY_H */

102
cyassl/ctaocrypt/pkcs7.h
View File

@@ -25,97 +25,19 @@
#ifndef CTAO_CRYPT_PKCS7_H #ifndef CTAO_CRYPT_PKCS7_H
#define CTAO_CRYPT_PKCS7_H #define CTAO_CRYPT_PKCS7_H
#include <cyassl/ctaocrypt/types.h> #include <wolfssl/wolfcrypt/pkcs7.h>
#include <cyassl/ctaocrypt/asn.h>
#include <cyassl/ctaocrypt/asn_public.h>
#include <cyassl/ctaocrypt/random.h>
#include <cyassl/ctaocrypt/des3.h>
#ifdef __cplusplus /* for pkcs7 reverse compatibility */
extern "C" { #define SetContentType wc_SetContentType
#endif #define GetContentType wc_GetContentType
#define CreateRecipientInfo wc_CreateRecipientInfo
/* PKCS#7 content types, ref RFC 2315 (Section 14) */ #define PKCS7_InitWithCert wc_PKCS7_InitWithCert
enum PKCS7_TYPES { #define PKCS7_Free wc_PKCS7_Free
PKCS7_MSG = 650, /* 1.2.840.113549.1.7 */ #define PKCS7_EncodeData wc_PKCS7_EncodeData
DATA = 651, /* 1.2.840.113549.1.7.1 */ #define PKCS7_EncodeSignedData wc_PKCS7_EncodeSignedData
SIGNED_DATA = 652, /* 1.2.840.113549.1.7.2 */ #define PKCS7_VerifySignedData wc_PKCS7_VerifySignedData
ENVELOPED_DATA = 653, /* 1.2.840.113549.1.7.3 */ #define PKCS7_EncodeEnvelopedData wc_PKCS7_EncodeEnvelopedData
SIGNED_AND_ENVELOPED_DATA = 654, /* 1.2.840.113549.1.7.4 */ #define PKCS7_DecodeEnvelopedData wc_PKCS7_DecodeEnvelopedData
DIGESTED_DATA = 655, /* 1.2.840.113549.1.7.5 */
ENCRYPTED_DATA = 656 /* 1.2.840.113549.1.7.6 */
};
enum Pkcs7_Misc {
PKCS7_NONCE_SZ = 16,
MAX_ENCRYPTED_KEY_SZ = 512, /* max enc. key size, RSA <= 4096 */
MAX_CONTENT_KEY_LEN = DES3_KEYLEN, /* highest current cipher is 3DES */
MAX_RECIP_SZ = MAX_VERSION_SZ +
MAX_SEQ_SZ + ASN_NAME_MAX + MAX_SN_SZ +
MAX_SEQ_SZ + MAX_ALGO_SZ + 1 + MAX_ENCRYPTED_KEY_SZ
};
typedef struct PKCS7Attrib {
byte* oid;
word32 oidSz;
byte* value;
word32 valueSz;
} PKCS7Attrib;
typedef struct PKCS7 {
byte* content; /* inner content, not owner */
word32 contentSz; /* content size */
int contentOID; /* PKCS#7 content type OID sum */
RNG* rng;
int hashOID;
int encryptOID; /* key encryption algorithm OID */
byte* singleCert; /* recipient cert, DER, not owner */
word32 singleCertSz; /* size of recipient cert buffer, bytes */
byte issuerHash[SHA_SIZE]; /* hash of all alt Names */
byte* issuer; /* issuer name of singleCert */
word32 issuerSz; /* length of issuer name */
byte issuerSn[MAX_SN_SZ]; /* singleCert's serial number */
word32 issuerSnSz; /* length of serial number */
byte publicKey[512];
word32 publicKeySz;
byte* privateKey; /* private key, DER, not owner */
word32 privateKeySz; /* size of private key buffer, bytes */
PKCS7Attrib* signedAttribs;
word32 signedAttribsSz;
} PKCS7;
CYASSL_LOCAL int SetContentType(int pkcs7TypeOID, byte* output);
CYASSL_LOCAL int GetContentType(const byte* input, word32* inOutIdx,
word32* oid, word32 maxIdx);
CYASSL_LOCAL int CreateRecipientInfo(const byte* cert, word32 certSz,
int keyEncAlgo, int blockKeySz,
RNG* rng, byte* contentKeyPlain,
byte* contentKeyEnc,
int* keyEncSz, byte* out, word32 outSz);
CYASSL_API int PKCS7_InitWithCert(PKCS7* pkcs7, byte* cert, word32 certSz);
CYASSL_API void PKCS7_Free(PKCS7* pkcs7);
CYASSL_API int PKCS7_EncodeData(PKCS7* pkcs7, byte* output, word32 outputSz);
CYASSL_API int PKCS7_EncodeSignedData(PKCS7* pkcs7,
byte* output, word32 outputSz);
CYASSL_API int PKCS7_VerifySignedData(PKCS7* pkcs7,
byte* pkiMsg, word32 pkiMsgSz);
CYASSL_API int PKCS7_EncodeEnvelopedData(PKCS7* pkcs7,
byte* output, word32 outputSz);
CYASSL_API int PKCS7_DecodeEnvelopedData(PKCS7* pkcs7, byte* pkiMsg,
word32 pkiMsgSz, byte* output,
word32 outputSz);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* CTAO_CRYPT_PKCS7_H */ #endif /* CTAO_CRYPT_PKCS7_H */

52
cyassl/ctaocrypt/poly1305.h
View File

@@ -25,57 +25,7 @@
#ifndef CTAO_CRYPT_POLY1305_H #ifndef CTAO_CRYPT_POLY1305_H
#define CTAO_CRYPT_POLY1305_H #define CTAO_CRYPT_POLY1305_H
#include <cyassl/ctaocrypt/types.h> #include <wolfssl/wolfcrypt/poly1305.h>
#ifdef __cplusplus
extern "C" {
#endif
/* auto detect between 32bit / 64bit */
#define HAS_SIZEOF_INT128_64BIT (defined(__SIZEOF_INT128__) && defined(__LP64__))
#define HAS_MSVC_64BIT (defined(_MSC_VER) && defined(_M_X64))
#define HAS_GCC_4_4_64BIT (defined(__GNUC__) && defined(__LP64__) && \
((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4))))
#if (HAS_SIZEOF_INT128_64BIT || HAS_MSVC_64BIT || HAS_GCC_4_4_64BIT)
#define POLY130564
#else
#define POLY130532
#endif
enum {
POLY1305 = 7,
POLY1305_BLOCK_SIZE = 16,
POLY1305_DIGEST_SIZE = 16,
POLY1305_PAD_SIZE = 56
};
/* Poly1305 state */
typedef struct Poly1305 {
#if defined(POLY130564)
word64 r[3];
word64 h[3];
word64 pad[2];
#else
word32 r[5];
word32 h[5];
word32 pad[4];
#endif
size_t leftover;
unsigned char buffer[POLY1305_BLOCK_SIZE];
unsigned char final;
} Poly1305;
/* does init */
CYASSL_API int Poly1305SetKey(Poly1305* poly1305, const byte* key, word32 kySz);
CYASSL_API int Poly1305Update(Poly1305* poly1305, const byte*, word32);
CYASSL_API int Poly1305Final(Poly1305* poly1305, byte* tag);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* CTAO_CRYPT_POLY1305_H */ #endif /* CTAO_CRYPT_POLY1305_H */

38
cyassl/ctaocrypt/rabbit.h
View File

@@ -25,41 +25,15 @@
#ifndef CTAO_CRYPT_RABBIT_H #ifndef CTAO_CRYPT_RABBIT_H
#define CTAO_CRYPT_RABBIT_H #define CTAO_CRYPT_RABBIT_H
#include <cyassl/ctaocrypt/types.h> #include <wolfssl/wolfcrypt/rabbit.h>
#ifdef __cplusplus /* for rabbit reverse compatibility */
extern "C" { #ifndef NO_RABBIT
#endif #define RabbitProcess wc_RabbitProcess
#define RabbitSetKey wc_RabbitSetKey
enum {
RABBIT_ENC_TYPE = 5 /* cipher unique type */
};
/* Rabbit Context */
typedef struct RabbitCtx {
word32 x[8];
word32 c[8];
word32 carry;
} RabbitCtx;
/* Rabbit stream cipher */
typedef struct Rabbit {
RabbitCtx masterCtx;
RabbitCtx workCtx;
} Rabbit;
CYASSL_API int RabbitProcess(Rabbit*, byte*, const byte*, word32);
CYASSL_API int RabbitSetKey(Rabbit*, const byte* key, const byte* iv);
#ifdef __cplusplus
} /* extern "C" */
#endif #endif
#endif /* CTAO_CRYPT_RABBIT_H */ #endif /* CTAO_CRYPT_RABBIT_H */
#endif /* NO_RABBIT */ #endif /* NO_RABBIT */

9
cyassl/ctaocrypt/ripemd.h
View File

@@ -27,5 +27,14 @@
#include <wolfssl/wolfcrypt/ripemd.h> #include <wolfssl/wolfcrypt/ripemd.h>
/* for ripemd reverse compatibility */
#ifdef WOLFSSL_RIPEMD
#define CYASSL_RIPEMD /* @TODO */
#define InitRipeMd wc_InitRipeMd
#define RipeMdUpdate wc_RipeMdUpdate
#define RipeMdFinal wc_RipeMdFinal
#endif
#endif /* CTAO_CRYPT_RIPEMD_H */ #endif /* CTAO_CRYPT_RIPEMD_H */
#endif /* CYASSL_RIPEMD */ #endif /* CYASSL_RIPEMD */

1
cyassl/ctaocrypt/settings.h
View File

@@ -100,7 +100,6 @@
/* #define CYASSL_PICOTCP_DEMO */ /* #define CYASSL_PICOTCP_DEMO */
#include <cyassl/ctaocrypt/visibility.h> #include <cyassl/ctaocrypt/visibility.h>
#include <wolfssl/wolfcrypt/settings.h>
#ifdef IPHONE #ifdef IPHONE
#define SIZEOF_LONG_LONG 8 #define SIZEOF_LONG_LONG 8

194
cyassl/ssl.h
View File

@@ -88,7 +88,6 @@
#define WOLFSSL_MAX_ERROR_SZ CYASSL_MAX_ERROR_SZ #define WOLFSSL_MAX_ERROR_SZ CYASSL_MAX_ERROR_SZ
/* src/ssl.c */ /* src/ssl.c */
#ifdef CYASSL_SSL_H
#define CYASSL_CRL WOLFSSL_CRL #define CYASSL_CRL WOLFSSL_CRL
#define CYASSL_SSLV3 WOLFSSL_SSLV3 #define CYASSL_SSLV3 WOLFSSL_SSLV3
#define CYASSL_TLSV1 WOLFSSL_TLSV1 #define CYASSL_TLSV1 WOLFSSL_TLSV1
@@ -121,7 +120,6 @@
#define CyaSSL_CertManagerDisableOCSP wolfSSL_CertManagerDisableOCSP #define CyaSSL_CertManagerDisableOCSP wolfSSL_CertManagerDisableOCSP
#define CyaSSL_get_current_cipher_suite wolfSSL_get_current_cipher_suite #define CyaSSL_get_current_cipher_suite wolfSSL_get_current_cipher_suite
#define CyaSSL_CTX_load_verify_locations wolfSSL_CTX_load_verify_locations #define CyaSSL_CTX_load_verify_locations wolfSSL_CTX_load_verify_locations
#endif /* CYASSL_SSL_H */
/* io.c */ /* io.c */
#define CYASSL_CBIO_ERR_ISR WOLFSSL_CBIO_ERR_ISR #define CYASSL_CBIO_ERR_ISR WOLFSSL_CBIO_ERR_ISR
@@ -156,9 +154,12 @@
#define CyaSSL_ERR_reason_error_string wolfSSL_ERR_reason_error_string #define CyaSSL_ERR_reason_error_string wolfSSL_ERR_reason_error_string
/* fips defines */ /* fips defines */
#define WOLFSSL_LEAVE CYASSL_LEAVE //defined in logging
#define WOLFSSL_ERROR CYASSL_ERROR //#define WOLFSSL_LEAVE CYASSL_LEAVE
#define WOLFSSL_GENERAL_ALIGNMENT CYASSL_GENERAL_ALIGNMENT //#define WOLFSSL_ERROR CYASSL_ERROR
//defined in settings.h
//#define WOLFSSL_GENERAL_ALIGNMENT CYASSL_GENERAL_ALIGNMENT
#define wolfcrypt_test ctaocrypt_test #define wolfcrypt_test ctaocrypt_test
@@ -329,10 +330,11 @@
#define CyaSSL_dtls_get_current_timeout wolfSSL_dtls_get_current_timeout #define CyaSSL_dtls_get_current_timeout wolfSSL_dtls_get_current_timeout
/* Memory Abstraction Layer */ /* Memory Abstraction Layer */
#define CyaSSL_Free wolfSSL_Free //#define CyaSSL_Free wolfSSL_Free
#define CyaSSL_Malloc wolfSSL_Malloc //#define CyaSSL_Malloc wolfSSL_Malloc
#define CyaSSL_Realloc wolfSSL_Realloc //#define CyaSSL_Realloc wolfSSL_Realloc
#define CyaSSL_SetAllocators wolfSSL_SetAllocators //#define CyaSSL_SetAllocators wolfSSL_SetAllocators
/* moved to wolfssl/wolfcrypt/memory.h */
/* Certificate Manager */ /* Certificate Manager */
#define CyaSSL_CertManagerNew wolfSSL_CertManagerNew #define CyaSSL_CertManagerNew wolfSSL_CertManagerNew
@@ -390,125 +392,15 @@
#undef WOLFSSL_API #undef WOLFSSL_API
#define WOLFSSL_API CYASSL_API #define WOLFSSL_API CYASSL_API
#define WOLFSSL_ENTER(x) CYASSL_ENTER(x) /* @TODO*/
#define WOLFSSL_BIT_SIZE CYASSL_BIT_SIZE /* @TODO*/ #define WOLFSSL_BIT_SIZE CYASSL_BIT_SIZE /* @TODO*/
/* wrapper around macros until they are changed in cyassl code /* wrapper around macros until they are changed in cyassl code
* needs investigation in regards to macros in fips */ * needs investigation in regards to macros in fips */
#define WOLFSSL_MAX_16BIT CYASSL_MAX_16BIT #define WOLFSSL_MAX_16BIT CYASSL_MAX_16BIT
#define WOLFSSL_MSG(x) CYASSL_MSG(x)
#define NO_WOLFSSL_ALLOC_ALIGN NO_CYASSL_ALLOC_ALIGN /* @TODO*/ #define NO_WOLFSSL_ALLOC_ALIGN NO_CYASSL_ALLOC_ALIGN /* @TODO*/
/* for arc4 reverse compatibility */
#ifndef NO_RC4
#include <wolfssl/wolfcrypt/arc4.h>
#define CYASSL_ARC4_CAVIUM_MAGIC WOLFSSL_ARC4_CAVIUM_MAGIC
#define Arc4Process wc_Arc4Process
#define Arc4SetKey wc_Arc4SetKey
#define Arc4InitCavium wc_Arc4InitCavium
#define Arc4FreeCavium wc_Arc4FreeCavium
#endif
/* for chacha reverse compatibility */
#ifdef HAVE_CHACHA
#define ChachaProcess wc_ChachaProcess
#define ChachaSetKey wc_ChachaSetKey
#define Chacha_SetIV wc_Chacha_SetIV
#endif
/* for DH reverse compatibility */
#ifndef NO_DH
#define InitDhKey wc_InitDhKey
#define FreeDhKey wc_FreeDhKey
#define DhGenerateKeyPair wc_DhGenerateKeyPair
#endif
/* for DSA reverse compatibility */
#ifndef NO_DSA
#define InitDsaKey wc_InitDsaKey
#define FreeDsaKey wc_FreeDsaKey
#define DsaSign wc_DsaSign
#define DsaVerify wc_DsaVerify
#define DsaPublicKeyDecode wc_DsaPublicKeyDecode
#define DsaPrivateKeyDecode wc_DsaPrivateKeyDecode
#endif
/* for hc128 reverse compatibility */
#ifdef HAVE_HC128
#define Hc128_Process wc_Hc128_Process
#define Hc128_SetKey wc_Hc128_SetKey
#endif
/* for md2 reverse compatibility */
#define CYASSL_MD2 WOLFSSL_MD2 /* @TODO */
//#ifdef WOLFSSL_MD2
#define InitMd2 wc_InitMd2
#define Md2Update wc_Md2Update
#define Md2Final wc_Md2Final
#define Md2Hash wc_Md2Hash
//#endif
/* for md4 reverse compatibility */
#ifndef NO_MD4
#define InitMd4 wc_InitMd4
#define Md4Update wc_Md4Update
#define Md4Final wc_Md4Final
#endif
/* for md5 reverse compatibility */
#ifndef NO_MD5
#define InitMd5 wc_InitMd5
#define Md5Update wc_Md5Update
#define Md5Final wc_Md5Final
#define Md5Hash wc_Md5Hash
#endif
/* for poly1305 reverse compatibility */
#ifdef HAVE_POLY1305
#define Poly1305SetKey wc_Poly1305SetKey
#define Poly1305Update wc_Poly1305Update
#define Poly1305Final wc_Poly1305Final
#endif
/* for rabbit reverse compatibility */
#ifndef NO_RABBIT
#define RabbitProcess wc_RabbitProcess
#define RabbitSetKey wc_RabbitSetKey
#endif
/* for ripemd reverse compatibility */
#ifdef WOLFSSL_RIPEMD
#define CYASSL_RIPEMD /* @TODO */
#define InitRipeMd wc_InitRipeMd
#define RipeMdUpdate wc_RipeMdUpdate
#define RipeMdFinal wc_RipeMdFinal
#endif
/* for pkcs7 reverse compatibility */
#ifdef HAVE_PKCS7
#define SetContentType wc_SetContentType
#define GetContentType wc_GetContentType
#define CreateRecipientInfo wc_CreateRecipientInfo
#define PKCS7_InitWithCert wc_PKCS7_InitWithCert
#define PKCS7_Free wc_PKCS7_Free
#define PKCS7_EncodeData wc_PKCS7_EncodeData
#define PKCS7_EncodeSignedData wc_PKCS7_EncodeSignedData
#define PKCS7_VerifySignedData wc_PKCS7_VerifySignedData
#define PKCS7_EncodeEnvelopedData wc_PKCS7_EncodeEnvelopedData
#define PKCS7_DecodeEnvelopedData wc_PKCS7_DecodeEnvelopedData
#endif
/* for pwdbased reverse compatibility */ /* for pwdbased reverse compatibility */
#ifndef NO_PWDBASED #ifndef NO_PWDBASED
@@ -518,65 +410,6 @@
#endif #endif
/* for blake2 reverse compatibility */
#ifdef HAVE_BLAKE2
#define InitBlake2b wc_InitBlake2b
#define Blake2bUpdate wc_Blake2bUpdate
#define Blake2bFinal wc_Blake2bFinal
#endif
/* for blake2 reverse compatibility */
#ifdef HAVE_CAMELLIA
#define CamelliaSetKey wc_CamelliaSetKey
#define CamelliaSetIV wc_CamelliaSetIV
#define CamelliaEncryptDirect wc_CamelliaEncryptDirect
#define CamelliaDecryptDirect wc_CamelliaDecryptDirect
#define CamelliaCbcEncrypt wc_CamelliaCbcEncrypt
#define CamelliaCbcDecrypt wc_CamelliaCbcDecrypt
#endif
/* for chacha reverse compatibility */
#ifdef HAVE_CHACHA
#define Chacha_Process wc_Chacha_Process
#define Chacha_SetKey wc_Chacha_SetKey
#define Chacha_SetIV wc_Chacha_SetIV
#endif
/* for ecc reverse compatibility */
#ifdef HAVE_ECC
#define ecc_make_key wc_ecc_make_key
#define ecc_shared_secret wc_ecc_shared_secret
#define ecc_sign_hash wc_ecc_sign_hash
#define ecc_verify_hash wc_ecc_verify_hash
#define ecc_init wc_ecc_init
#define ecc_free wc_ecc_free
#define ecc_fp_free wc_ecc_fp_free
#define ecc_export_x963 wc_ecc_export_x963
#define ecc_export_x963_ex wc_ecc_export_x963_ex
#define ecc_import_x963 wc_ecc_import_x963
#define ecc_import_private_key wc_ecc_import_private_key
#define ecc_rs_to_sig wc_ecc_rs_to_sig
#define ecc_import_raw wc_ecc_import_raw
#define ecc_export_private_only wc_ecc_export_private_only
#define ecc_size wc_ecc_size
#define ecc_sig_size wc_ecc_sig_size
#ifdef HAVE_ECC_ENCRYPT
/* ecc encrypt */
//ecEncCtx* wc_ecc_ctx_new(int flags, RNG* rng);
//void wc_ecc_ctx_free(ecEncCtx*);
//int wc_ecc_ctx_reset(ecEncCtx*, RNG*); /* reset for use again w/o alloc/free */
//const byte* wc_ecc_ctx_get_own_salt(ecEncCtx*);
//int wc_ecc_ctx_set_peer_salt(ecEncCtx*, const byte* salt);
//int wc_ecc_ctx_set_info(ecEncCtx*, const byte* info, int sz);
//int wc_ecc_encrypt(ecc_key* privKey, ecc_key* pubKey, const byte* msg,
//int wc_ecc_decrypt(ecc_key* privKey, ecc_key* pubKey, const byte* msg,
#endif /* HAVE_ECC_ENCRYPT */
#endif
/* examples/client/client.h */ /* examples/client/client.h */
#define CYASSL_THREAD WOLFSSL_THREAD #define CYASSL_THREAD WOLFSSL_THREAD
@@ -584,6 +417,11 @@
#define LIBCYASSL_VERSION_STRING LIBWOLFSSL_VERSION_STRING #define LIBCYASSL_VERSION_STRING LIBWOLFSSL_VERSION_STRING
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */
#endif #endif

1
examples/server/server.c
View File

@@ -1,3 +1,4 @@
#include <wolfssl/test.h>
/* server.c /* server.c
* *
* Copyright (C) 2006-2014 wolfSSL Inc. * Copyright (C) 2006-2014 wolfSSL Inc.

4
mcapi/include.am
View File

@@ -7,8 +7,8 @@ check_PROGRAMS += mcapi/test
noinst_PROGRAMS += mcapi/test noinst_PROGRAMS += mcapi/test
mcapi_test_SOURCES = mcapi/crypto.c \ mcapi_test_SOURCES = mcapi/crypto.c \
mcapi/mcapi_test.c mcapi/mcapi_test.c
mcapi_test_LDADD = src/libcyassl.la mcapi_test_LDADD = src/libwolfssl.la
mcapi_test_DEPENDENCIES = src/libcyassl.la mcapi_test_DEPENDENCIES = src/libwolfssl.la
endif endif
noinst_HEADERS += mcapi/crypto.h noinst_HEADERS += mcapi/crypto.h

8
rpm/spec.in
View File

@@ -66,10 +66,10 @@ mkdir -p $RPM_BUILD_ROOT/
%{_docdir}/cyassl/example/echoclient.c %{_docdir}/cyassl/example/echoclient.c
%{_docdir}/cyassl/example/client.c %{_docdir}/cyassl/example/client.c
%{_docdir}/cyassl/README.txt %{_docdir}/cyassl/README.txt
%{_libdir}/libcyassl.la %{_libdir}/libwolfssl.la
%{_libdir}/libcyassl.so %{_libdir}/libwolfssl.so
%{_libdir}/libcyassl.so.5 %{_libdir}/libwolfssl.so.5
%{_libdir}/libcyassl.so.5.0.5 %{_libdir}/libwolfssl.so.5.0.5
%files devel %files devel
%defattr(-,root,root,-) %defattr(-,root,root,-)

92
src/include.am
View File

@@ -71,13 +71,15 @@ src_libwolfssl_la_SOURCES += \
endif endif
if BUILD_MEMORY if BUILD_MEMORY
src_libwolfssl_la_SOURCES += ctaocrypt/src/memory.c \ if BUILD_FIPS
wolfcrypt/src/memory.c src_libwolfssl_la_SOURCES += ctaocrypt/src/memory.c
else
src_libwolfssl_la_SOURCES += wolfcrypt/src/memory.c
endif
endif endif
if BUILD_DH if BUILD_DH
src_libwolfssl_la_SOURCES += ctaocrypt/src/dh.c \ src_libwolfssl_la_SOURCES += wolfcrypt/src/dh.c
wolfcrypt/src/dh.c
endif endif
if BUILD_ASN if BUILD_ASN
@@ -97,8 +99,7 @@ endif
endif endif
if BUILD_POLY1305 if BUILD_POLY1305
src_libwolfssl_la_SOURCES += ctaocrypt/src/poly1305.c \ src_libwolfssl_la_SOURCES += wolfcrypt/src/poly1305.c
wolfcrypt/src/poly1305.c
endif endif
if BUILD_RC4 if BUILD_RC4
@@ -106,23 +107,28 @@ src_libwolfssl_la_SOURCES += wolfcrypt/src/arc4.c
endif endif
if BUILD_MD4 if BUILD_MD4
src_libwolfssl_la_SOURCES += ctaocrypt/src/md4.c \ if BUILD_FIPS
wolfcrypt/src/md4.c src_libwolfssl_la_SOURCES += ctaocrypt/src/md4.c
else
src_libwolfssl_la_SOURCES += wolfcrypt/src/md4.c
endif
endif endif
if BUILD_MD5 if BUILD_MD5
src_libwolfssl_la_SOURCES += ctaocrypt/src/md5.c \ src_libwolfssl_la_SOURCES += ctaocrypt/src/md5.c
wolfcrypt/src/md5.c src_libwolfssl_la_SOURCES += wolfcrypt/src/md5.c
endif endif
if BUILD_PWDBASED if BUILD_PWDBASED
src_libwolfssl_la_SOURCES += ctaocrypt/src/pwdbased.c \ if BUILD_FIPS
wolfcrypt/src/pwdbased.c src_libwolfssl_la_SOURCES += ctaocrypt/src/pwdbased.c
else
src_libwolfssl_la_SOURCES += wolfcrypt/src/pwdbased.c
endif
endif endif
if BUILD_DSA if BUILD_DSA
src_libwolfssl_la_SOURCES += ctaocrypt/src/dsa.c \ src_libwolfssl_la_SOURCES += wolfcrypt/src/dsa.c
wolfcrypt/src/dsa.c
endif endif
if BUILD_AESNI if BUILD_AESNI
@@ -130,18 +136,19 @@ src_libwolfssl_la_SOURCES += ctaocrypt/src/aes_asm.s
endif endif
if BUILD_CAMELLIA if BUILD_CAMELLIA
src_libwolfssl_la_SOURCES += ctaocrypt/src/camellia.c \ src_libwolfssl_la_SOURCES += wolfcrypt/src/camellia.c
wolfcrypt/src/camellia.c
endif endif
if BUILD_MD2 if BUILD_MD2
src_libwolfssl_la_SOURCES += ctaocrypt/src/md2.c \ if BUILD_FIPS
wolfcrypt/src/md2.c src_libwolfssl_la_SOURCES += ctaocrypt/src/md2.c
else
src_libwolfssl_la_SOURCES += wolfcrypt/src/md2.c
endif
endif endif
if BUILD_RIPEMD if BUILD_RIPEMD
src_libwolfssl_la_SOURCES += ctaocrypt/src/ripemd.c \ src_libwolfssl_la_SOURCES += wolfcrypt/src/ripemd.c
wolfcrypt/src/ripemd.c
endif endif
if BUILD_BLAKE2 if BUILD_BLAKE2
@@ -149,33 +156,40 @@ src_libwolfssl_la_SOURCES += wolfcrypt/src/blake2b.c
endif endif
if BUILD_HC128 if BUILD_HC128
src_libwolfssl_la_SOURCES += ctaocrypt/src/hc128.c \ if BUILD_FIPS
ctaocrypt/src/hc128.c src_libwolfssl_la_SOURCES += ctaocrypt/src/hc128.c
else
src_libwolfssl_la_SOURCES += wolfcrypt/src/hc128.c
endif
endif endif
if BUILD_RABBIT if BUILD_RABBIT
src_libwolfssl_la_SOURCES += ctaocrypt/src/rabbit.c \ src_libwolfssl_la_SOURCES += wolfcrypt/src/rabbit.c
wolfcrypt/src/rabbit.c
endif endif
if BUILD_CHACHA if BUILD_CHACHA
src_libwolfssl_la_SOURCES += ctaocrypt/src/chacha.c \ src_libwolfssl_la_SOURCES += wolfcrypt/src/chacha.c
wolfcrypt/src/chacha.c
endif endif
if !BUILD_INLINE if !BUILD_INLINE
src_libwolfssl_la_SOURCES += ctaocrypt/src/misc.c \ if BUILD_FIPS
wolfcrypt/src/misc.c src_libwolfssl_la_SOURCES += ctaocrypt/src/misc.c
else
src_libwolfssl_la_SOURCES += wolfcrypt/src/misc.c
endif
endif endif
if BUILD_FASTMATH if BUILD_FASTMATH
src_libwolfssl_la_SOURCES += ctaocrypt/src/tfm.c \ src_libwolfssl_la_SOURCES += ctaocrypt/src/tfm.c
wolfcrypt/src/tfm.c src_libwolfssl_la_SOURCES += wolfcrypt/src/tfm.c
endif endif
if BUILD_SLOWMATH if BUILD_SLOWMATH
src_libwolfssl_la_SOURCES += ctaocrypt/src/integer.c \ if BUILD_FIPS
wolfcrypt/src/integer.c src_libwolfssl_la_SOURCES += ctaocrypt/src/integer.c
else
src_libwolfssl_la_SOURCES += wolfcrypt/src/integer.c
endif
endif endif
if BUILD_ECC if BUILD_ECC
@@ -183,13 +197,19 @@ src_libwolfssl_la_SOURCES += wolfcrypt/src/ecc.c
endif endif
if BUILD_LIBZ if BUILD_LIBZ
src_libwolfssl_la_SOURCES += ctaocrypt/src/compress.c \ if BUILD_FIPS
wolfcrypt/src/compress.c src_libwolfssl_la_SOURCES += ctaocrypt/src/compress.c
else
src_libwolfssl_la_SOURCES += wolfcrypt/src/compress.c
endif
endif endif
if BUILD_PKCS7 if BUILD_PKCS7
src_libwolfssl_la_SOURCES += ctaocrypt/src/pkcs7.c \ if BUILD_FIPS
wolfcrypt/src/pkcs7.c src_libwolfssl_la_SOURCES += ctaocrypt/src/pkcs7.c
else
src_libwolfssl_la_SOURCES += wolfcrypt/src/pkcs7.c
endif
endif endif

18
src/internal.c
View File

@@ -20,7 +20,7 @@
*/ */
/* Name change compatibility layer */ /* Name change compatibility layer */
#include <cyassl/ssl.h> //#include <cyassl/ssl.h>
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
@@ -587,8 +587,8 @@ void FreeCiphers(WOLFSSL* ssl)
#ifdef BUILD_AES #ifdef BUILD_AES
#ifdef HAVE_CAVIUM #ifdef HAVE_CAVIUM
if (ssl->devId != NO_CAVIUM_DEVICE) { if (ssl->devId != NO_CAVIUM_DEVICE) {
AesFreeCavium(ssl->encrypt.aes); wc_AesFreeCavium(ssl->encrypt.aes);
AesFreeCavium(ssl->decrypt.aes); wc_AesFreeCavium(ssl->decrypt.aes);
} }
#endif #endif
XFREE(ssl->encrypt.aes, ssl->heap, DYNAMIC_TYPE_CIPHER); XFREE(ssl->encrypt.aes, ssl->heap, DYNAMIC_TYPE_CIPHER);
@@ -5662,7 +5662,7 @@ static INLINE int Encrypt(WOLFSSL* ssl, byte* out, const byte* input, word16 sz)
#ifdef BUILD_AES #ifdef BUILD_AES
case wolfssl_aes: case wolfssl_aes:
return AesCbcEncrypt(ssl->encrypt.aes, out, input, sz); return wc_AesCbcEncrypt(ssl->encrypt.aes, out, input, sz);
#endif #endif
#ifdef BUILD_AESGCM #ifdef BUILD_AESGCM
@@ -5697,7 +5697,7 @@ static INLINE int Encrypt(WOLFSSL* ssl, byte* out, const byte* input, word16 sz)
ssl->keys.aead_enc_imp_IV, AEAD_IMP_IV_SZ); ssl->keys.aead_enc_imp_IV, AEAD_IMP_IV_SZ);
XMEMCPY(nonce + AEAD_IMP_IV_SZ, XMEMCPY(nonce + AEAD_IMP_IV_SZ,
ssl->keys.aead_exp_IV, AEAD_EXP_IV_SZ); ssl->keys.aead_exp_IV, AEAD_EXP_IV_SZ);
gcmRet = AesGcmEncrypt(ssl->encrypt.aes, gcmRet = wc_AesGcmEncrypt(ssl->encrypt.aes,
out + AEAD_EXP_IV_SZ, input + AEAD_EXP_IV_SZ, out + AEAD_EXP_IV_SZ, input + AEAD_EXP_IV_SZ,
sz - AEAD_EXP_IV_SZ - ssl->specs.aead_mac_size, sz - AEAD_EXP_IV_SZ - ssl->specs.aead_mac_size,
nonce, AEAD_NONCE_SZ, nonce, AEAD_NONCE_SZ,
@@ -5743,7 +5743,7 @@ static INLINE int Encrypt(WOLFSSL* ssl, byte* out, const byte* input, word16 sz)
ssl->keys.aead_enc_imp_IV, AEAD_IMP_IV_SZ); ssl->keys.aead_enc_imp_IV, AEAD_IMP_IV_SZ);
XMEMCPY(nonce + AEAD_IMP_IV_SZ, XMEMCPY(nonce + AEAD_IMP_IV_SZ,
ssl->keys.aead_exp_IV, AEAD_EXP_IV_SZ); ssl->keys.aead_exp_IV, AEAD_EXP_IV_SZ);
AesCcmEncrypt(ssl->encrypt.aes, wc_AesCcmEncrypt(ssl->encrypt.aes,
out + AEAD_EXP_IV_SZ, input + AEAD_EXP_IV_SZ, out + AEAD_EXP_IV_SZ, input + AEAD_EXP_IV_SZ,
sz - AEAD_EXP_IV_SZ - ssl->specs.aead_mac_size, sz - AEAD_EXP_IV_SZ - ssl->specs.aead_mac_size,
nonce, AEAD_NONCE_SZ, nonce, AEAD_NONCE_SZ,
@@ -5821,7 +5821,7 @@ static INLINE int Decrypt(WOLFSSL* ssl, byte* plain, const byte* input,
#ifdef BUILD_AES #ifdef BUILD_AES
case wolfssl_aes: case wolfssl_aes:
return AesCbcDecrypt(ssl->decrypt.aes, plain, input, sz); return wc_AesCbcDecrypt(ssl->decrypt.aes, plain, input, sz);
#endif #endif
#ifdef BUILD_AESGCM #ifdef BUILD_AESGCM
@@ -5848,7 +5848,7 @@ static INLINE int Decrypt(WOLFSSL* ssl, byte* plain, const byte* input,
additional + AEAD_LEN_OFFSET); additional + AEAD_LEN_OFFSET);
XMEMCPY(nonce, ssl->keys.aead_dec_imp_IV, AEAD_IMP_IV_SZ); XMEMCPY(nonce, ssl->keys.aead_dec_imp_IV, AEAD_IMP_IV_SZ);
XMEMCPY(nonce + AEAD_IMP_IV_SZ, input, AEAD_EXP_IV_SZ); XMEMCPY(nonce + AEAD_IMP_IV_SZ, input, AEAD_EXP_IV_SZ);
if (AesGcmDecrypt(ssl->decrypt.aes, if (wc_AesGcmDecrypt(ssl->decrypt.aes,
plain + AEAD_EXP_IV_SZ, plain + AEAD_EXP_IV_SZ,
input + AEAD_EXP_IV_SZ, input + AEAD_EXP_IV_SZ,
sz - AEAD_EXP_IV_SZ - ssl->specs.aead_mac_size, sz - AEAD_EXP_IV_SZ - ssl->specs.aead_mac_size,
@@ -5889,7 +5889,7 @@ static INLINE int Decrypt(WOLFSSL* ssl, byte* plain, const byte* input,
additional + AEAD_LEN_OFFSET); additional + AEAD_LEN_OFFSET);
XMEMCPY(nonce, ssl->keys.aead_dec_imp_IV, AEAD_IMP_IV_SZ); XMEMCPY(nonce, ssl->keys.aead_dec_imp_IV, AEAD_IMP_IV_SZ);
XMEMCPY(nonce + AEAD_IMP_IV_SZ, input, AEAD_EXP_IV_SZ); XMEMCPY(nonce + AEAD_IMP_IV_SZ, input, AEAD_EXP_IV_SZ);
if (AesCcmDecrypt(ssl->decrypt.aes, if (wc_AesCcmDecrypt(ssl->decrypt.aes,
plain + AEAD_EXP_IV_SZ, plain + AEAD_EXP_IV_SZ,
input + AEAD_EXP_IV_SZ, input + AEAD_EXP_IV_SZ,
sz - AEAD_EXP_IV_SZ - ssl->specs.aead_mac_size, sz - AEAD_EXP_IV_SZ - ssl->specs.aead_mac_size,

4
sslSniffer/sslSnifferTest/include.am
View File

@@ -5,8 +5,8 @@
if BUILD_SNIFFTEST if BUILD_SNIFFTEST
noinst_PROGRAMS += sslSniffer/sslSnifferTest/snifftest noinst_PROGRAMS += sslSniffer/sslSnifferTest/snifftest
sslSniffer_sslSnifferTest_snifftest_SOURCES = sslSniffer/sslSnifferTest/snifftest.c sslSniffer_sslSnifferTest_snifftest_SOURCES = sslSniffer/sslSnifferTest/snifftest.c
sslSniffer_sslSnifferTest_snifftest_LDADD = src/libcyassl.la -lpcap sslSniffer_sslSnifferTest_snifftest_LDADD = src/libwolfssl.la -lpcap
sslSniffer_sslSnifferTest_snifftest_DEPENDENCIES = src/libcyassl.la sslSniffer_sslSnifferTest_snifftest_DEPENDENCIES = src/libwolfssl.la
endif endif
EXTRA_DIST += sslSniffer/sslSniffer.vcproj EXTRA_DIST += sslSniffer/sslSniffer.vcproj
EXTRA_DIST += sslSniffer/sslSniffer.vcxproj EXTRA_DIST += sslSniffer/sslSniffer.vcxproj

4
tests/include.am
View File

@@ -14,8 +14,8 @@ tests_unit_test_SOURCES = \
examples/client/client.c \ examples/client/client.c \
examples/server/server.c examples/server/server.c
tests_unit_test_CFLAGS = -DNO_MAIN_DRIVER $(AM_CFLAGS) tests_unit_test_CFLAGS = -DNO_MAIN_DRIVER $(AM_CFLAGS)
tests_unit_test_LDADD = src/libcyassl.la tests_unit_test_LDADD = src/libwolfssl.la
tests_unit_test_DEPENDENCIES = src/libcyassl.la tests_unit_test_DEPENDENCIES = src/libwolfssl.la
endif endif
EXTRA_DIST += tests/unit.h EXTRA_DIST += tests/unit.h
EXTRA_DIST += tests/test.conf \ EXTRA_DIST += tests/test.conf \

4
tests/unit.c
View File

@@ -1,4 +1,8 @@
/* unit.c unit tests driver */ /* unit.c unit tests driver */
/* Name change compatibility layer */
#include <cyassl/ssl.h>
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
#include <config.h> #include <config.h>
#endif #endif

6
testsuite/include.am
View File

@@ -7,15 +7,15 @@ if BUILD_EXAMPLES
check_PROGRAMS += testsuite/testsuite.test check_PROGRAMS += testsuite/testsuite.test
noinst_PROGRAMS += testsuite/testsuite.test noinst_PROGRAMS += testsuite/testsuite.test
testsuite_testsuite_test_SOURCES = \ testsuite_testsuite_test_SOURCES = \
ctaocrypt/test/test.c \ wolfcrypt/test/test.c \
examples/client/client.c \ examples/client/client.c \
examples/echoclient/echoclient.c \ examples/echoclient/echoclient.c \
examples/echoserver/echoserver.c \ examples/echoserver/echoserver.c \
examples/server/server.c \ examples/server/server.c \
testsuite/testsuite.c testsuite/testsuite.c
testsuite_testsuite_test_CFLAGS = -DNO_MAIN_DRIVER $(AM_CFLAGS) testsuite_testsuite_test_CFLAGS = -DNO_MAIN_DRIVER $(AM_CFLAGS)
testsuite_testsuite_test_LDADD = src/libcyassl.la testsuite_testsuite_test_LDADD = src/libwolfssl.la
testsuite_testsuite_test_DEPENDENCIES = src/libcyassl.la testsuite_testsuite_test_DEPENDENCIES = src/libwolfssl.la
endif endif
EXTRA_DIST += testsuite/testsuite.sln EXTRA_DIST += testsuite/testsuite.sln
EXTRA_DIST += testsuite/testsuite-ntru.vcproj EXTRA_DIST += testsuite/testsuite-ntru.vcproj

6
testsuite/testsuite-ntru.vcproj
View File

@@ -42,7 +42,7 @@
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="0" Optimization="0"
AdditionalIncludeDirectories="../;../NTRU/include" AdditionalIncludeDirectories="../;../NTRU/include"
PreprocessorDefinitions="NO_MAIN_DRIVER;CYASSL_RIPEMD;CYASSL_SHA512;OPENSSL_EXTRA;HAVE_NTRU;NO_PSK;WIN32" PreprocessorDefinitions="NO_MAIN_DRIVER;WOLFSSL_RIPEMD;WOLFSSL_SHA512;OPENSSL_EXTRA;HAVE_NTRU;NO_PSK;WIN32"
MinimalRebuild="true" MinimalRebuild="true"
BasicRuntimeChecks="3" BasicRuntimeChecks="3"
RuntimeLibrary="3" RuntimeLibrary="3"
@@ -118,7 +118,7 @@
Optimization="2" Optimization="2"
EnableIntrinsicFunctions="true" EnableIntrinsicFunctions="true"
AdditionalIncludeDirectories="../;../NTRU/include" AdditionalIncludeDirectories="../;../NTRU/include"
PreprocessorDefinitions="NO_MAIN_DRIVER;CYASSL_RIPEMD;CYASSL_SHA512;OPENSSL_EXTRA;HAVE_NTRU;NO_PSK;WIN32" PreprocessorDefinitions="NO_MAIN_DRIVER;WOLFSSL_RIPEMD;WOLFSSL_SHA512;OPENSSL_EXTRA;HAVE_NTRU;NO_PSK;WIN32"
RuntimeLibrary="2" RuntimeLibrary="2"
EnableFunctionLevelLinking="true" EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0" UsePrecompiledHeader="0"
@@ -193,7 +193,7 @@
> >
</File> </File>
<File <File
RelativePath="..\ctaocrypt\test\test.c" RelativePath="..\wolfcrypt\test\test.c"
> >
</File> </File>
<File <File

50
testsuite/testsuite.c
View File

@@ -2,14 +2,14 @@
* *
* Copyright (C) 2006-2014 wolfSSL Inc. * Copyright (C) 2006-2014 wolfSSL Inc.
* *
* This file is part of CyaSSL. * This file is part of wolfSSL.
* *
* CyaSSL is free software; you can redistribute it and/or modify * wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* CyaSSL is distributed in the hope that it will be useful, * wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
@@ -23,15 +23,15 @@
#include <config.h> #include <config.h>
#endif #endif
#include <cyassl/ctaocrypt/settings.h> #include <wolfssl/wolfcrypt/settings.h>
#include <cyassl/test.h> #include <wolfssl/test.h>
#include "ctaocrypt/test/test.h" #include "wolfcrypt/test/test.h"
#ifndef SINGLE_THREADED #ifndef SINGLE_THREADED
#include <cyassl/openssl/ssl.h> #include <wolfssl/openssl/ssl.h>
#include <cyassl/ctaocrypt/sha256.h> #include <wolfssl/wolfcrypt/sha256.h>
#include "examples/echoclient/echoclient.h" #include "examples/echoclient/echoclient.h"
#include "examples/echoserver/echoserver.h" #include "examples/echoserver/echoserver.h"
@@ -88,12 +88,12 @@ int testsuite_test(int argc, char** argv)
server_args.argc = argc; server_args.argc = argc;
server_args.argv = argv; server_args.argv = argv;
CyaSSL_Init(); wolfSSL_Init();
#if defined(DEBUG_CYASSL) && !defined(HAVE_VALGRIND) #if defined(DEBUG_WOLFSSL) && !defined(HAVE_VALGRIND)
CyaSSL_Debugging_ON(); wolfSSL_Debugging_ON();
#endif #endif
#if !defined(CYASSL_TIRTOS) #if !defined(WOLFSSL_TIRTOS)
if (CurrentDir("testsuite") || CurrentDir("_build")) if (CurrentDir("testsuite") || CurrentDir("_build"))
ChangeDirBack(1); ChangeDirBack(1);
else if (CurrentDir("Debug") || CurrentDir("Release")) else if (CurrentDir("Debug") || CurrentDir("Release"))
@@ -103,18 +103,18 @@ int testsuite_test(int argc, char** argv)
/* Debug or Release */ /* Debug or Release */
#endif #endif
#ifdef CYASSL_TIRTOS #ifdef WOLFSSL_TIRTOS
fdOpenSession(Task_self()); fdOpenSession(Task_self());
#endif #endif
server_args.signal = &ready; server_args.signal = &ready;
InitTcpReady(&ready); InitTcpReady(&ready);
/* CTaoCrypt test */ /* wc_ test */
ctaocrypt_test(&server_args); wolfcrypt_test(&server_args);
if (server_args.return_code != 0) return server_args.return_code; if (server_args.return_code != 0) return server_args.return_code;
/* Simple CyaSSL client server test */ /* Simple wolfSSL client server test */
simple_test(&server_args); simple_test(&server_args);
if (server_args.return_code != 0) return server_args.return_code; if (server_args.return_code != 0) return server_args.return_code;
@@ -148,7 +148,7 @@ int testsuite_test(int argc, char** argv)
echoclient_test(&echo_args); echoclient_test(&echo_args);
if (echo_args.return_code != 0) return echo_args.return_code; if (echo_args.return_code != 0) return echo_args.return_code;
#ifdef CYASSL_DTLS #ifdef WOLFSSL_DTLS
wait_tcp_ready(&server_args); wait_tcp_ready(&server_args);
#endif #endif
/* send quit to echoserver */ /* send quit to echoserver */
@@ -165,7 +165,7 @@ int testsuite_test(int argc, char** argv)
{ {
char ciphers[1024]; char ciphers[1024];
XMEMSET(ciphers, 0, sizeof(ciphers)); XMEMSET(ciphers, 0, sizeof(ciphers));
CyaSSL_get_ciphers(ciphers, sizeof(ciphers)-1); wolfSSL_get_ciphers(ciphers, sizeof(ciphers)-1);
printf("ciphers = %s\n", ciphers); printf("ciphers = %s\n", ciphers);
} }
@@ -180,10 +180,10 @@ int testsuite_test(int argc, char** argv)
return EXIT_FAILURE; return EXIT_FAILURE;
} }
CyaSSL_Cleanup(); wolfSSL_Cleanup();
FreeTcpReady(&ready); FreeTcpReady(&ready);
#ifdef CYASSL_TIRTOS #ifdef WOLFSSL_TIRTOS
fdCloseSession(Task_self()); fdCloseSession(Task_self());
#endif #endif
@@ -237,8 +237,8 @@ void simple_test(func_args* args)
cliArgs.return_code = 0; cliArgs.return_code = 0;
strcpy(svrArgs.argv[0], "SimpleServer"); strcpy(svrArgs.argv[0], "SimpleServer");
#if !defined(USE_WINDOWS_API) && !defined(CYASSL_SNIFFER) && \ #if !defined(USE_WINDOWS_API) && !defined(WOLFSSL_SNIFFER) && \
!defined(CYASSL_TIRTOS) !defined(WOLFSSL_TIRTOS)
strcpy(svrArgs.argv[svrArgs.argc++], "-p"); strcpy(svrArgs.argv[svrArgs.argc++], "-p");
strcpy(svrArgs.argv[svrArgs.argc++], "0"); strcpy(svrArgs.argv[svrArgs.argc++], "0");
#endif #endif
@@ -296,7 +296,7 @@ void start_thread(THREAD_FUNC fun, func_args* args, THREAD_TYPE* thread)
#if defined(_POSIX_THREADS) && !defined(__MINGW32__) #if defined(_POSIX_THREADS) && !defined(__MINGW32__)
pthread_create(thread, 0, fun, args); pthread_create(thread, 0, fun, args);
return; return;
#elif defined(CYASSL_TIRTOS) #elif defined(WOLFSSL_TIRTOS)
/* Initialize the defaults and set the parameters. */ /* Initialize the defaults and set the parameters. */
Task_Params taskParams; Task_Params taskParams;
Task_Params_init(&taskParams); Task_Params_init(&taskParams);
@@ -317,7 +317,7 @@ void join_thread(THREAD_TYPE thread)
{ {
#if defined(_POSIX_THREADS) && !defined(__MINGW32__) #if defined(_POSIX_THREADS) && !defined(__MINGW32__)
pthread_join(thread, 0); pthread_join(thread, 0);
#elif defined(CYASSL_TIRTOS) #elif defined(WOLFSSL_TIRTOS)
while(1) { while(1) {
if (Task_getMode(thread) == Task_Mode_TERMINATED) { if (Task_getMode(thread) == Task_Mode_TERMINATED) {
Task_sleep(5); Task_sleep(5);
@@ -420,7 +420,7 @@ int main(int argc, char** argv)
/* Relative to Workspace, Build/Products */ /* Relative to Workspace, Build/Products */
/* Debug or Release */ /* Debug or Release */
ctaocrypt_test(&server_args); wolfcrypt_test(&server_args);
if (server_args.return_code != 0) return server_args.return_code; if (server_args.return_code != 0) return server_args.return_code;
printf("\nAll tests passed!\n"); printf("\nAll tests passed!\n");

6
testsuite/testsuite.vcproj
View File

@@ -42,7 +42,7 @@
Name="VCCLCompilerTool" Name="VCCLCompilerTool"
Optimization="0" Optimization="0"
AdditionalIncludeDirectories="../" AdditionalIncludeDirectories="../"
PreprocessorDefinitions="NO_MAIN_DRIVER;CYASSL_RIPEMD;CYASSL_SHA512;OPENSSL_EXTRA;NO_PSK" PreprocessorDefinitions="NO_MAIN_DRIVER;WOLFSSL_RIPEMD;WOLFSSL_SHA512;OPENSSL_EXTRA;NO_PSK"
MinimalRebuild="true" MinimalRebuild="true"
BasicRuntimeChecks="3" BasicRuntimeChecks="3"
RuntimeLibrary="3" RuntimeLibrary="3"
@@ -117,7 +117,7 @@
Optimization="2" Optimization="2"
EnableIntrinsicFunctions="true" EnableIntrinsicFunctions="true"
AdditionalIncludeDirectories="../" AdditionalIncludeDirectories="../"
PreprocessorDefinitions="NO_MAIN_DRIVER;CYASSL_RIPEMD;CYASSL_SHA512;OPENSSL_EXTRA;NO_PSK" PreprocessorDefinitions="NO_MAIN_DRIVER;WOLFSSL_RIPEMD;WOLFSSL_SHA512;OPENSSL_EXTRA;NO_PSK"
RuntimeLibrary="2" RuntimeLibrary="2"
EnableFunctionLevelLinking="true" EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0" UsePrecompiledHeader="0"
@@ -191,7 +191,7 @@
> >
</File> </File>
<File <File
RelativePath="..\ctaocrypt\test\test.c" RelativePath="..\wolfcrypt\test\test.c"
> >
</File> </File>
<File <File

12
testsuite/testsuite.vcxproj
View File

@@ -85,7 +85,7 @@
<ClCompile> <ClCompile>
<Optimization>Disabled</Optimization> <Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> <AdditionalIncludeDirectories>../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NO_MAIN_DRIVER;CYASSL_RIPEMD;CYASSL_SHA512;OPENSSL_EXTRA;NO_PSK;%(PreprocessorDefinitions)</PreprocessorDefinitions> <PreprocessorDefinitions>NO_MAIN_DRIVER;WOLFSSL_RIPEMD;WOLFSSL_SHA512;OPENSSL_EXTRA;NO_PSK;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MinimalRebuild>true</MinimalRebuild> <MinimalRebuild>true</MinimalRebuild>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks> <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary> <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
@@ -104,7 +104,7 @@
<ClCompile> <ClCompile>
<Optimization>Disabled</Optimization> <Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> <AdditionalIncludeDirectories>../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NO_MAIN_DRIVER;CYASSL_RIPEMD;CYASSL_SHA512;OPENSSL_EXTRA;NO_PSK;%(PreprocessorDefinitions)</PreprocessorDefinitions> <PreprocessorDefinitions>NO_MAIN_DRIVER;WOLFSSL_RIPEMD;WOLFSSL_SHA512;OPENSSL_EXTRA;NO_PSK;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks> <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary> <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
<PrecompiledHeader> <PrecompiledHeader>
@@ -123,7 +123,7 @@
<Optimization>MaxSpeed</Optimization> <Optimization>MaxSpeed</Optimization>
<IntrinsicFunctions>true</IntrinsicFunctions> <IntrinsicFunctions>true</IntrinsicFunctions>
<AdditionalIncludeDirectories>../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> <AdditionalIncludeDirectories>../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NO_MAIN_DRIVER;CYASSL_RIPEMD;CYASSL_SHA512;OPENSSL_EXTRA;NO_PSK;%(PreprocessorDefinitions)</PreprocessorDefinitions> <PreprocessorDefinitions>NO_MAIN_DRIVER;WOLFSSL_RIPEMD;WOLFSSL_SHA512;OPENSSL_EXTRA;NO_PSK;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary> <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<FunctionLevelLinking>true</FunctionLevelLinking> <FunctionLevelLinking>true</FunctionLevelLinking>
<PrecompiledHeader /> <PrecompiledHeader />
@@ -144,7 +144,7 @@
<Optimization>MaxSpeed</Optimization> <Optimization>MaxSpeed</Optimization>
<IntrinsicFunctions>true</IntrinsicFunctions> <IntrinsicFunctions>true</IntrinsicFunctions>
<AdditionalIncludeDirectories>../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> <AdditionalIncludeDirectories>../;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>NO_MAIN_DRIVER;CYASSL_RIPEMD;CYASSL_SHA512;OPENSSL_EXTRA;NO_PSK;%(PreprocessorDefinitions)</PreprocessorDefinitions> <PreprocessorDefinitions>NO_MAIN_DRIVER;WOLFSSL_RIPEMD;WOLFSSL_SHA512;OPENSSL_EXTRA;NO_PSK;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary> <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
<FunctionLevelLinking>true</FunctionLevelLinking> <FunctionLevelLinking>true</FunctionLevelLinking>
<PrecompiledHeader> <PrecompiledHeader>
@@ -165,11 +165,11 @@
<ClCompile Include="..\examples\echoclient\echoclient.c" /> <ClCompile Include="..\examples\echoclient\echoclient.c" />
<ClCompile Include="..\examples\echoserver\echoserver.c" /> <ClCompile Include="..\examples\echoserver\echoserver.c" />
<ClCompile Include="..\examples\server\server.c" /> <ClCompile Include="..\examples\server\server.c" />
<ClCompile Include="..\ctaocrypt\test\test.c" /> <ClCompile Include="..\wolfcrypt\test\test.c" />
<ClCompile Include="testsuite.c" /> <ClCompile Include="testsuite.c" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ProjectReference Include="..\cyassl.vcxproj"> <ProjectReference Include="..\wolfssl.vcxproj">
<Project>{73973223-5ee8-41ca-8e88-1d60e89a237b}</Project> <Project>{73973223-5ee8-41ca-8e88-1d60e89a237b}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly> <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
</ProjectReference> </ProjectReference>

217
wolfcrypt/benchmark/benchmark.c
View File

@@ -19,18 +19,14 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/ */
/* CTaoCrypt benchmark */ /* wolfCrypt benchmark */
/* wolfssl_cyassl compatibility layer */
#include <cyassl/ssl.h>
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
#include <config.h> #include <config.h>
#endif #endif
#include <cyassl/ctaocrypt/settings.h> #include <wolfssl/wolfcrypt/settings.h>
#include <string.h> #include <string.h>
@@ -41,6 +37,7 @@
#include <stdio.h> #include <stdio.h>
#endif #endif
#include <wolfssl/wolfcrypt/random.h>
#include <wolfssl/wolfcrypt/des3.h> #include <wolfssl/wolfcrypt/des3.h>
#include <wolfssl/wolfcrypt/arc4.h> #include <wolfssl/wolfcrypt/arc4.h>
#include <wolfssl/wolfcrypt/hc128.h> #include <wolfssl/wolfcrypt/hc128.h>
@@ -68,18 +65,18 @@
#include "ntru_crypto.h" #include "ntru_crypto.h"
#endif #endif
#if defined(CYASSL_MDK_ARM) #if defined(WOLFSSL_MDK_ARM)
extern FILE * CyaSSL_fopen(const char *fname, const char *mode) ; extern FILE * wolfSSL_fopen(const char *fname, const char *mode) ;
#define fopen CyaSSL_fopen #define fopen wolfSSL_fopen
#endif #endif
#if defined(USE_CERT_BUFFERS_1024) || defined(USE_CERT_BUFFERS_2048) #if defined(USE_CERT_BUFFERS_1024) || defined(USE_CERT_BUFFERS_2048)
/* include test cert and key buffers for use with NO_FILESYSTEM */ /* include test cert and key buffers for use with NO_FILESYSTEM */
#if defined(CYASSL_MDK_ARM) #if defined(WOLFSSL_MDK_ARM)
#include "cert_data.h" /* use certs_test.c for initial data, #include "cert_data.h" /* use certs_test.c for initial data,
so other commands can share the data. */ so other commands can share the data. */
#else #else
#include <cyassl/certs_test.h> #include <wolfssl/certs_test.h>
#endif #endif
#endif #endif
@@ -152,8 +149,8 @@ static int OpenNitroxDevice(int dma_mode,int dev_id)
#endif #endif
#if defined(DEBUG_CYASSL) && !defined(HAVE_VALGRIND) #if defined(DEBUG_WOLfSSL) && !defined(HAVE_VALGRIND)
CYASSL_API int CyaSSL_Debugging_ON(); WOLFSSL_API int wolfSSL_Debugging_ON();
#endif #endif
/* so embedded projects can pull in tests on their own */ /* so embedded projects can pull in tests on their own */
@@ -169,8 +166,8 @@ int benchmark_test(void *args)
{ {
#endif #endif
#if defined(DEBUG_CYASSL) && !defined(HAVE_VALGRIND) #if defined(DEBUG_WOLFSSL) && !defined(HAVE_VALGRIND)
CyaSSL_Debugging_ON(); wolfSSL_Debugging_ON();
#endif #endif
#ifdef HAVE_CAVIUM #ifdef HAVE_CAVIUM
@@ -188,7 +185,7 @@ int benchmark_test(void *args)
bench_aesgcm(); bench_aesgcm();
#endif #endif
#ifdef CYASSL_AES_COUNTER #ifdef WOLFSSL_AES_COUNTER
bench_aesctr(); bench_aesctr();
#endif #endif
@@ -228,13 +225,13 @@ int benchmark_test(void *args)
#ifndef NO_SHA256 #ifndef NO_SHA256
bench_sha256(); bench_sha256();
#endif #endif
#ifdef CYASSL_SHA384 #ifdef WOLFSSL_SHA384
bench_sha384(); bench_sha384();
#endif #endif
#ifdef CYASSL_SHA512 #ifdef WOLFSSL_SHA512
bench_sha512(); bench_sha512();
#endif #endif
#ifdef CYASSL_RIPEMD #ifdef WOLFSSL_RIPEMD
bench_ripemd(); bench_ripemd();
#endif #endif
#ifdef HAVE_BLAKE2 #ifdef HAVE_BLAKE2
@@ -255,7 +252,7 @@ int benchmark_test(void *args)
bench_dh(); bench_dh();
#endif #endif
#if defined(CYASSL_KEY_GEN) && !defined(NO_RSA) #if defined(WOLFSSL_KEY_GEN) && !defined(NO_RSA)
bench_rsaKeyGen(); bench_rsaKeyGen();
#endif #endif
@@ -335,13 +332,13 @@ void bench_aes(int show)
int ret; int ret;
#ifdef HAVE_CAVIUM #ifdef HAVE_CAVIUM
if (AesInitCavium(&enc, CAVIUM_DEV_ID) != 0) { if (wc_AesInitCavium(&enc, CAVIUM_DEV_ID) != 0) {
printf("aes init cavium failed\n"); printf("aes init cavium failed\n");
return; return;
} }
#endif #endif
ret = AesSetKey(&enc, key, 16, iv, AES_ENCRYPTION); ret = wc_AesSetKey(&enc, key, 16, iv, AES_ENCRYPTION);
if (ret != 0) { if (ret != 0) {
printf("AesSetKey failed, ret = %d\n", ret); printf("AesSetKey failed, ret = %d\n", ret);
return; return;
@@ -349,7 +346,7 @@ void bench_aes(int show)
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) for(i = 0; i < numBlocks; i++)
AesCbcEncrypt(&enc, plain, cipher, sizeof(plain)); wc_AesCbcEncrypt(&enc, plain, cipher, sizeof(plain));
total = current_time(0) - start; total = current_time(0) - start;
@@ -363,7 +360,7 @@ void bench_aes(int show)
printf("AES %d %s took %5.3f seconds, %7.3f MB/s\n", numBlocks, printf("AES %d %s took %5.3f seconds, %7.3f MB/s\n", numBlocks,
blockType, total, persec); blockType, total, persec);
#ifdef HAVE_CAVIUM #ifdef HAVE_CAVIUM
AesFreeCavium(&enc); wc_AesFreeCavium(&enc);
#endif #endif
} }
#endif #endif
@@ -382,11 +379,11 @@ void bench_aesgcm(void)
double start, total, persec; double start, total, persec;
int i; int i;
AesGcmSetKey(&enc, key, 16); wc_AesGcmSetKey(&enc, key, 16);
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) for(i = 0; i < numBlocks; i++)
AesGcmEncrypt(&enc, cipher, plain, sizeof(plain), iv, 12, wc_AesGcmEncrypt(&enc, cipher, plain, sizeof(plain), iv, 12,
tag, 16, additional, 13); tag, 16, additional, 13);
total = current_time(0) - start; total = current_time(0) - start;
@@ -402,18 +399,18 @@ void bench_aesgcm(void)
} }
#endif #endif
#ifdef CYASSL_AES_COUNTER #ifdef WOLFSSL_AES_COUNTER
void bench_aesctr(void) void bench_aesctr(void)
{ {
Aes enc; Aes enc;
double start, total, persec; double start, total, persec;
int i; int i;
AesSetKeyDirect(&enc, key, AES_BLOCK_SIZE, iv, AES_ENCRYPTION); wc_AesSetKeyDirect(&enc, key, AES_BLOCK_SIZE, iv, AES_ENCRYPTION);
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) for(i = 0; i < numBlocks; i++)
AesCtrEncrypt(&enc, plain, cipher, sizeof(plain)); wc_AesCtrEncrypt(&enc, plain, cipher, sizeof(plain));
total = current_time(0) - start; total = current_time(0) - start;
@@ -437,11 +434,11 @@ void bench_aesccm(void)
double start, total, persec; double start, total, persec;
int i; int i;
AesCcmSetKey(&enc, key, 16); wc_AesCcmSetKey(&enc, key, 16);
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) for(i = 0; i < numBlocks; i++)
AesCcmEncrypt(&enc, cipher, plain, sizeof(plain), iv, 12, wc_AesCcmEncrypt(&enc, cipher, plain, sizeof(plain), iv, 12,
tag, 16, additional, 13); tag, 16, additional, 13);
total = current_time(0) - start; total = current_time(0) - start;
@@ -468,7 +465,7 @@ void bench_poly1305()
int ret; int ret;
ret = Poly1305SetKey(&enc, key, 32); ret = wc_Poly1305SetKey(&enc, key, 32);
if (ret != 0) { if (ret != 0) {
printf("Poly1305SetKey failed, ret = %d\n", ret); printf("Poly1305SetKey failed, ret = %d\n", ret);
return; return;
@@ -476,9 +473,9 @@ void bench_poly1305()
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) for(i = 0; i < numBlocks; i++)
Poly1305Update(&enc, plain, sizeof(plain)); wc_Poly1305Update(&enc, plain, sizeof(plain));
Poly1305Final(&enc, mac); wc_Poly1305Final(&enc, mac);
total = current_time(0) - start; total = current_time(0) - start;
persec = 1 / total * numBlocks; persec = 1 / total * numBlocks;
@@ -500,7 +497,7 @@ void bench_camellia(void)
double start, total, persec; double start, total, persec;
int i, ret; int i, ret;
ret = CamelliaSetKey(&cam, key, 16, iv); ret = wc_CamelliaSetKey(&cam, key, 16, iv);
if (ret != 0) { if (ret != 0) {
printf("CamelliaSetKey failed, ret = %d\n", ret); printf("CamelliaSetKey failed, ret = %d\n", ret);
return; return;
@@ -508,7 +505,7 @@ void bench_camellia(void)
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) for(i = 0; i < numBlocks; i++)
CamelliaCbcEncrypt(&cam, plain, cipher, sizeof(plain)); wc_CamelliaCbcEncrypt(&cam, plain, cipher, sizeof(plain));
total = current_time(0) - start; total = current_time(0) - start;
@@ -532,10 +529,10 @@ void bench_des(void)
int i, ret; int i, ret;
#ifdef HAVE_CAVIUM #ifdef HAVE_CAVIUM
if (Des3_InitCavium(&enc, CAVIUM_DEV_ID) != 0) if (wc_Des3_InitCavium(&enc, CAVIUM_DEV_ID) != 0)
printf("des3 init cavium failed\n"); printf("des3 init cavium failed\n");
#endif #endif
ret = Des3_SetKey(&enc, key, iv, DES_ENCRYPTION); ret = wc_Des3_SetKey(&enc, key, iv, DES_ENCRYPTION);
if (ret != 0) { if (ret != 0) {
printf("Des3_SetKey failed, ret = %d\n", ret); printf("Des3_SetKey failed, ret = %d\n", ret);
return; return;
@@ -543,7 +540,7 @@ void bench_des(void)
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) for(i = 0; i < numBlocks; i++)
Des3_CbcEncrypt(&enc, plain, cipher, sizeof(plain)); wc_Des3_CbcEncrypt(&enc, plain, cipher, sizeof(plain));
total = current_time(0) - start; total = current_time(0) - start;
@@ -556,7 +553,7 @@ void bench_des(void)
printf("3DES %d %s took %5.3f seconds, %7.3f MB/s\n", numBlocks, printf("3DES %d %s took %5.3f seconds, %7.3f MB/s\n", numBlocks,
blockType, total, persec); blockType, total, persec);
#ifdef HAVE_CAVIUM #ifdef HAVE_CAVIUM
Des3_FreeCavium(&enc); wc_Des3_FreeCavium(&enc);
#endif #endif
} }
#endif #endif
@@ -603,11 +600,11 @@ void bench_hc128(void)
double start, total, persec; double start, total, persec;
int i; int i;
Hc128_SetKey(&enc, key, iv); wc_Hc128_SetKey(&enc, key, iv);
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) for(i = 0; i < numBlocks; i++)
Hc128_Process(&enc, cipher, plain, sizeof(plain)); wc_Hc128_Process(&enc, cipher, plain, sizeof(plain));
total = current_time(0) - start; total = current_time(0) - start;
persec = 1 / total * numBlocks; persec = 1 / total * numBlocks;
@@ -629,11 +626,11 @@ void bench_rabbit(void)
double start, total, persec; double start, total, persec;
int i; int i;
RabbitSetKey(&enc, key, iv); wc_RabbitSetKey(&enc, key, iv);
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) for(i = 0; i < numBlocks; i++)
RabbitProcess(&enc, cipher, plain, sizeof(plain)); wc_RabbitProcess(&enc, cipher, plain, sizeof(plain));
total = current_time(0) - start; total = current_time(0) - start;
persec = 1 / total * numBlocks; persec = 1 / total * numBlocks;
@@ -655,12 +652,12 @@ void bench_chacha(void)
double start, total, persec; double start, total, persec;
int i; int i;
Chacha_SetKey(&enc, key, 16); wc_Chacha_SetKey(&enc, key, 16);
start = current_time(1); start = current_time(1);
for (i = 0; i < numBlocks; i++) { for (i = 0; i < numBlocks; i++) {
Chacha_SetIV(&enc, iv, 0); wc_Chacha_SetIV(&enc, iv, 0);
Chacha_Process(&enc, cipher, plain, sizeof(plain)); wc_Chacha_Process(&enc, cipher, plain, sizeof(plain));
} }
total = current_time(0) - start; total = current_time(0) - start;
persec = 1 / total * numBlocks; persec = 1 / total * numBlocks;
@@ -683,13 +680,13 @@ void bench_md5(void)
double start, total, persec; double start, total, persec;
int i; int i;
InitMd5(&hash); wc_InitMd5(&hash);
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) for(i = 0; i < numBlocks; i++)
Md5Update(&hash, plain, sizeof(plain)); wc_Md5Update(&hash, plain, sizeof(plain));
Md5Final(&hash, digest); wc_Md5Final(&hash, digest);
total = current_time(0) - start; total = current_time(0) - start;
persec = 1 / total * numBlocks; persec = 1 / total * numBlocks;
@@ -712,7 +709,7 @@ void bench_sha(void)
double start, total, persec; double start, total, persec;
int i, ret; int i, ret;
ret = InitSha(&hash); ret = wc_InitSha(&hash);
if (ret != 0) { if (ret != 0) {
printf("InitSha failed, ret = %d\n", ret); printf("InitSha failed, ret = %d\n", ret);
return; return;
@@ -720,9 +717,9 @@ void bench_sha(void)
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) for(i = 0; i < numBlocks; i++)
ShaUpdate(&hash, plain, sizeof(plain)); wc_ShaUpdate(&hash, plain, sizeof(plain));
ShaFinal(&hash, digest); wc_ShaFinal(&hash, digest);
total = current_time(0) - start; total = current_time(0) - start;
persec = 1 / total * numBlocks; persec = 1 / total * numBlocks;
@@ -745,7 +742,7 @@ void bench_sha256(void)
double start, total, persec; double start, total, persec;
int i, ret; int i, ret;
ret = InitSha256(&hash); ret = wc_InitSha256(&hash);
if (ret != 0) { if (ret != 0) {
printf("InitSha256 failed, ret = %d\n", ret); printf("InitSha256 failed, ret = %d\n", ret);
return; return;
@@ -753,14 +750,14 @@ void bench_sha256(void)
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) { for(i = 0; i < numBlocks; i++) {
ret = Sha256Update(&hash, plain, sizeof(plain)); ret = wc_Sha256Update(&hash, plain, sizeof(plain));
if (ret != 0) { if (ret != 0) {
printf("Sha256Update failed, ret = %d\n", ret); printf("Sha256Update failed, ret = %d\n", ret);
return; return;
} }
} }
ret = Sha256Final(&hash, digest); ret = wc_Sha256Final(&hash, digest);
if (ret != 0) { if (ret != 0) {
printf("Sha256Final failed, ret = %d\n", ret); printf("Sha256Final failed, ret = %d\n", ret);
return; return;
@@ -778,7 +775,7 @@ void bench_sha256(void)
} }
#endif #endif
#ifdef CYASSL_SHA384 #ifdef WOLFSSL_SHA384
void bench_sha384(void) void bench_sha384(void)
{ {
Sha384 hash; Sha384 hash;
@@ -786,7 +783,7 @@ void bench_sha384(void)
double start, total, persec; double start, total, persec;
int i, ret; int i, ret;
ret = InitSha384(&hash); ret = wc_InitSha384(&hash);
if (ret != 0) { if (ret != 0) {
printf("InitSha384 failed, ret = %d\n", ret); printf("InitSha384 failed, ret = %d\n", ret);
return; return;
@@ -794,14 +791,14 @@ void bench_sha384(void)
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) { for(i = 0; i < numBlocks; i++) {
ret = Sha384Update(&hash, plain, sizeof(plain)); ret = wc_Sha384Update(&hash, plain, sizeof(plain));
if (ret != 0) { if (ret != 0) {
printf("Sha384Update failed, ret = %d\n", ret); printf("Sha384Update failed, ret = %d\n", ret);
return; return;
} }
} }
ret = Sha384Final(&hash, digest); ret = wc_Sha384Final(&hash, digest);
if (ret != 0) { if (ret != 0) {
printf("Sha384Final failed, ret = %d\n", ret); printf("Sha384Final failed, ret = %d\n", ret);
return; return;
@@ -819,7 +816,7 @@ void bench_sha384(void)
} }
#endif #endif
#ifdef CYASSL_SHA512 #ifdef WOLFSSL_SHA512
void bench_sha512(void) void bench_sha512(void)
{ {
Sha512 hash; Sha512 hash;
@@ -827,7 +824,7 @@ void bench_sha512(void)
double start, total, persec; double start, total, persec;
int i, ret; int i, ret;
ret = InitSha512(&hash); ret = wc_InitSha512(&hash);
if (ret != 0) { if (ret != 0) {
printf("InitSha512 failed, ret = %d\n", ret); printf("InitSha512 failed, ret = %d\n", ret);
return; return;
@@ -835,14 +832,14 @@ void bench_sha512(void)
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) { for(i = 0; i < numBlocks; i++) {
ret = Sha512Update(&hash, plain, sizeof(plain)); ret = wc_Sha512Update(&hash, plain, sizeof(plain));
if (ret != 0) { if (ret != 0) {
printf("Sha512Update failed, ret = %d\n", ret); printf("Sha512Update failed, ret = %d\n", ret);
return; return;
} }
} }
ret = Sha512Final(&hash, digest); ret = wc_Sha512Final(&hash, digest);
if (ret != 0) { if (ret != 0) {
printf("Sha512Final failed, ret = %d\n", ret); printf("Sha512Final failed, ret = %d\n", ret);
return; return;
@@ -860,7 +857,7 @@ void bench_sha512(void)
} }
#endif #endif
#ifdef CYASSL_RIPEMD #ifdef WOLFSSL_RIPEMD
void bench_ripemd(void) void bench_ripemd(void)
{ {
RipeMd hash; RipeMd hash;
@@ -868,13 +865,13 @@ void bench_ripemd(void)
double start, total, persec; double start, total, persec;
int i; int i;
InitRipeMd(&hash); wc_InitRipeMd(&hash);
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) for(i = 0; i < numBlocks; i++)
RipeMdUpdate(&hash, plain, sizeof(plain)); wc_RipeMdUpdate(&hash, plain, sizeof(plain));
RipeMdFinal(&hash, digest); wc_RipeMdFinal(&hash, digest);
total = current_time(0) - start; total = current_time(0) - start;
persec = 1 / total * numBlocks; persec = 1 / total * numBlocks;
@@ -897,7 +894,7 @@ void bench_blake2(void)
double start, total, persec; double start, total, persec;
int i, ret; int i, ret;
ret = InitBlake2b(&b2b, 64); ret = wc_InitBlake2b(&b2b, 64);
if (ret != 0) { if (ret != 0) {
printf("InitBlake2b failed, ret = %d\n", ret); printf("InitBlake2b failed, ret = %d\n", ret);
return; return;
@@ -905,14 +902,14 @@ void bench_blake2(void)
start = current_time(1); start = current_time(1);
for(i = 0; i < numBlocks; i++) { for(i = 0; i < numBlocks; i++) {
ret = Blake2bUpdate(&b2b, plain, sizeof(plain)); ret = wc_Blake2bUpdate(&b2b, plain, sizeof(plain));
if (ret != 0) { if (ret != 0) {
printf("Blake2bUpdate failed, ret = %d\n", ret); printf("Blake2bUpdate failed, ret = %d\n", ret);
return; return;
} }
} }
ret = Blake2bFinal(&b2b, digest, 64); ret = wc_Blake2bFinal(&b2b, digest, 64);
if (ret != 0) { if (ret != 0) {
printf("Blake2bFinal failed, ret = %d\n", ret); printf("Blake2bFinal failed, ret = %d\n", ret);
return; return;
@@ -932,7 +929,7 @@ void bench_blake2(void)
#if !defined(NO_RSA) || !defined(NO_DH) \ #if !defined(NO_RSA) || !defined(NO_DH) \
|| defined(CYASSL_KEYGEN) || defined(HAVE_ECC) || defined(WOLFSSL_KEYGEN) || defined(HAVE_ECC)
static RNG rng; static RNG rng;
#endif #endif
@@ -940,7 +937,7 @@ static RNG rng;
#if !defined(USE_CERT_BUFFERS_1024) && !defined(USE_CERT_BUFFERS_2048) #if !defined(USE_CERT_BUFFERS_1024) && !defined(USE_CERT_BUFFERS_2048)
#if defined(CYASSL_MDK_SHELL) #if defined(WOLFSSL_MDK_SHELL)
static char *certRSAname = "certs/rsa2048.der"; static char *certRSAname = "certs/rsa2048.der";
/* set by shell command */ /* set by shell command */
static void set_Bench_RSA_File(char * cert) { certRSAname = cert ; } static void set_Bench_RSA_File(char * cert) { certRSAname = cert ; }
@@ -988,25 +985,25 @@ void bench_rsa(void)
#ifdef HAVE_CAVIUM #ifdef HAVE_CAVIUM
if (RsaInitCavium(&rsaKey, CAVIUM_DEV_ID) != 0) if (wc_RsaInitCavium(&rsaKey, CAVIUM_DEV_ID) != 0)
printf("RSA init cavium failed\n"); printf("RSA init cavium failed\n");
#endif #endif
ret = InitRng(&rng); ret = wc_InitRng(&rng);
if (ret < 0) { if (ret < 0) {
printf("InitRNG failed\n"); printf("InitRNG failed\n");
return; return;
} }
ret = InitRsaKey(&rsaKey, 0); ret = wc_InitRsaKey(&rsaKey, 0);
if (ret < 0) { if (ret < 0) {
printf("InitRsaKey failed\n"); printf("InitRsaKey failed\n");
return; return;
} }
ret = RsaPrivateKeyDecode(tmp, &idx, &rsaKey, (word32)bytes); ret = wc_RsaPrivateKeyDecode(tmp, &idx, &rsaKey, (word32)bytes);
start = current_time(1); start = current_time(1);
for (i = 0; i < ntimes; i++) for (i = 0; i < ntimes; i++)
ret = RsaPublicEncrypt(message,len,enc,sizeof(enc), &rsaKey, &rng); ret = wc_RsaPublicEncrypt(message,len,enc,sizeof(enc), &rsaKey, &rng);
total = current_time(0) - start; total = current_time(0) - start;
each = total / ntimes; /* per second */ each = total / ntimes; /* per second */
@@ -1024,7 +1021,7 @@ void bench_rsa(void)
for (i = 0; i < ntimes; i++) { for (i = 0; i < ntimes; i++) {
byte out[512]; /* for up to 4096 bit */ byte out[512]; /* for up to 4096 bit */
RsaPrivateDecrypt(enc, (word32)ret, out, sizeof(out), &rsaKey); wc_RsaPrivateDecrypt(enc, (word32)ret, out, sizeof(out), &rsaKey);
} }
total = current_time(0) - start; total = current_time(0) - start;
@@ -1034,9 +1031,9 @@ void bench_rsa(void)
printf("RSA %d decryption took %6.3f milliseconds, avg over %d" printf("RSA %d decryption took %6.3f milliseconds, avg over %d"
" iterations\n", rsaKeySz, milliEach, ntimes); " iterations\n", rsaKeySz, milliEach, ntimes);
FreeRsaKey(&rsaKey); wc_FreeRsaKey(&rsaKey);
#ifdef HAVE_CAVIUM #ifdef HAVE_CAVIUM
RsaFreeCavium(&rsaKey); wc_RsaFreeCavium(&rsaKey);
#endif #endif
} }
#endif #endif
@@ -1046,7 +1043,7 @@ void bench_rsa(void)
#if !defined(USE_CERT_BUFFERS_1024) && !defined(USE_CERT_BUFFERS_2048) #if !defined(USE_CERT_BUFFERS_1024) && !defined(USE_CERT_BUFFERS_2048)
#if defined(CYASSL_MDK_SHELL) #if defined(WOLFSSL_MDK_SHELL)
static char *certDHname = "certs/dh2048.der"; static char *certDHname = "certs/dh2048.der";
/* set by shell command */ /* set by shell command */
void set_Bench_DH_File(char * cert) { certDHname = cert ; } void set_Bench_DH_File(char * cert) { certDHname = cert ; }
@@ -1093,7 +1090,7 @@ void bench_dh(void)
return; return;
} }
ret = InitRng(&rng); ret = wc_InitRng(&rng);
if (ret < 0) { if (ret < 0) {
printf("InitRNG failed\n"); printf("InitRNG failed\n");
return; return;
@@ -1102,8 +1099,8 @@ void bench_dh(void)
#endif /* USE_CERT_BUFFERS */ #endif /* USE_CERT_BUFFERS */
InitDhKey(&dhKey); wc_InitDhKey(&dhKey);
bytes = DhKeyDecode(tmp, &idx, &dhKey, (word32)bytes); bytes = wc_DhKeyDecode(tmp, &idx, &dhKey, (word32)bytes);
if (bytes != 0) { if (bytes != 0) {
printf("dhekydecode failed, can't benchmark\n"); printf("dhekydecode failed, can't benchmark\n");
#if !defined(USE_CERT_BUFFERS_1024) && !defined(USE_CERT_BUFFERS_2048) #if !defined(USE_CERT_BUFFERS_1024) && !defined(USE_CERT_BUFFERS_2048)
@@ -1115,7 +1112,7 @@ void bench_dh(void)
start = current_time(1); start = current_time(1);
for (i = 0; i < ntimes; i++) for (i = 0; i < ntimes; i++)
DhGenerateKeyPair(&dhKey, &rng, priv, &privSz, pub, &pubSz); wc_DhGenerateKeyPair(&dhKey, &rng, priv, &privSz, pub, &pubSz);
total = current_time(0) - start; total = current_time(0) - start;
each = total / ntimes; /* per second */ each = total / ntimes; /* per second */
@@ -1124,11 +1121,11 @@ void bench_dh(void)
printf("DH %d key generation %6.3f milliseconds, avg over %d" printf("DH %d key generation %6.3f milliseconds, avg over %d"
" iterations\n", dhKeySz, milliEach, ntimes); " iterations\n", dhKeySz, milliEach, ntimes);
DhGenerateKeyPair(&dhKey, &rng, priv2, &privSz2, pub2, &pubSz2); wc_DhGenerateKeyPair(&dhKey, &rng, priv2, &privSz2, pub2, &pubSz2);
start = current_time(1); start = current_time(1);
for (i = 0; i < ntimes; i++) for (i = 0; i < ntimes; i++)
DhAgree(&dhKey, agree, &agreeSz, priv, privSz, pub2, pubSz2); wc_DhAgree(&dhKey, agree, &agreeSz, priv, privSz, pub2, pubSz2);
total = current_time(0) - start; total = current_time(0) - start;
each = total / ntimes; /* per second */ each = total / ntimes; /* per second */
@@ -1140,11 +1137,11 @@ void bench_dh(void)
#if !defined(USE_CERT_BUFFERS_1024) && !defined(USE_CERT_BUFFERS_2048) #if !defined(USE_CERT_BUFFERS_1024) && !defined(USE_CERT_BUFFERS_2048)
fclose(file); fclose(file);
#endif #endif
FreeDhKey(&dhKey); wc_FreeDhKey(&dhKey);
} }
#endif #endif
#if defined(CYASSL_KEY_GEN) && !defined(NO_RSA) #if defined(WOLFSSL_KEY_GEN) && !defined(NO_RSA)
void bench_rsaKeyGen(void) void bench_rsaKeyGen(void)
{ {
RsaKey genKey; RsaKey genKey;
@@ -1155,9 +1152,9 @@ void bench_rsaKeyGen(void)
start = current_time(1); start = current_time(1);
for(i = 0; i < genTimes; i++) { for(i = 0; i < genTimes; i++) {
InitRsaKey(&genKey, 0); wc_InitRsaKey(&genKey, 0);
MakeRsaKey(&genKey, 1024, 65537, &rng); wc_MakeRsaKey(&genKey, 1024, 65537, &rng);
FreeRsaKey(&genKey); wc_FreeRsaKey(&genKey);
} }
total = current_time(0) - start; total = current_time(0) - start;
@@ -1171,9 +1168,9 @@ void bench_rsaKeyGen(void)
start = current_time(1); start = current_time(1);
for(i = 0; i < genTimes; i++) { for(i = 0; i < genTimes; i++) {
InitRsaKey(&genKey, 0); wc_InitRsaKey(&genKey, 0);
MakeRsaKey(&genKey, 2048, 65537, &rng); wc_MakeRsaKey(&genKey, 2048, 65537, &rng);
FreeRsaKey(&genKey); wc_FreeRsaKey(&genKey);
} }
total = current_time(0) - start; total = current_time(0) - start;
@@ -1182,7 +1179,7 @@ void bench_rsaKeyGen(void)
printf("RSA 2048 key generation %6.3f milliseconds, avg over %d" printf("RSA 2048 key generation %6.3f milliseconds, avg over %d"
" iterations\n", milliEach, genTimes); " iterations\n", milliEach, genTimes);
} }
#endif /* CYASSL_KEY_GEN */ #endif /* WOLFSSL_KEY_GEN */
#ifdef HAVE_NTRU #ifdef HAVE_NTRU
byte GetEntropy(ENTROPY_CMD cmd, byte* out); byte GetEntropy(ENTROPY_CMD cmd, byte* out);
@@ -1385,7 +1382,7 @@ void bench_eccKeyGen(void)
double start, total, each, milliEach; double start, total, each, milliEach;
int i, ret; int i, ret;
ret = InitRng(&rng); ret = wc_InitRng(&rng);
if (ret < 0) { if (ret < 0) {
printf("InitRNG failed\n"); printf("InitRNG failed\n");
return; return;
@@ -1394,8 +1391,8 @@ void bench_eccKeyGen(void)
start = current_time(1); start = current_time(1);
for(i = 0; i < genTimes; i++) { for(i = 0; i < genTimes; i++) {
ecc_make_key(&rng, 32, &genKey); wc_ecc_make_key(&rng, 32, &genKey);
ecc_free(&genKey); wc_ecc_free(&genKey);
} }
total = current_time(0) - start; total = current_time(0) - start;
@@ -1417,21 +1414,21 @@ void bench_eccKeyAgree(void)
byte digest[32]; byte digest[32];
word32 x = 0; word32 x = 0;
ecc_init(&genKey); wc_ecc_init(&genKey);
ecc_init(&genKey2); wc_ecc_init(&genKey2);
ret = InitRng(&rng); ret = wc_InitRng(&rng);
if (ret < 0) { if (ret < 0) {
printf("InitRNG failed\n"); printf("InitRNG failed\n");
return; return;
} }
ret = ecc_make_key(&rng, 32, &genKey); ret = wc_ecc_make_key(&rng, 32, &genKey);
if (ret != 0) { if (ret != 0) {
printf("ecc_make_key failed\n"); printf("ecc_make_key failed\n");
return; return;
} }
ret = ecc_make_key(&rng, 32, &genKey2); ret = wc_ecc_make_key(&rng, 32, &genKey2);
if (ret != 0) { if (ret != 0) {
printf("ecc_make_key failed\n"); printf("ecc_make_key failed\n");
return; return;
@@ -1442,7 +1439,7 @@ void bench_eccKeyAgree(void)
for(i = 0; i < agreeTimes; i++) { for(i = 0; i < agreeTimes; i++) {
x = sizeof(shared); x = sizeof(shared);
ret = ecc_shared_secret(&genKey, &genKey2, shared, &x); ret = wc_ecc_shared_secret(&genKey, &genKey2, shared, &x);
if (ret != 0) { if (ret != 0) {
printf("ecc_shared_secret failed\n"); printf("ecc_shared_secret failed\n");
return; return;
@@ -1464,7 +1461,7 @@ void bench_eccKeyAgree(void)
for(i = 0; i < agreeTimes; i++) { for(i = 0; i < agreeTimes; i++) {
x = sizeof(sig); x = sizeof(sig);
ret = ecc_sign_hash(digest, sizeof(digest), sig, &x, &rng, &genKey); ret = wc_ecc_sign_hash(digest, sizeof(digest), sig, &x, &rng, &genKey);
if (ret != 0) { if (ret != 0) {
printf("ecc_sign_hash failed\n"); printf("ecc_sign_hash failed\n");
return; return;
@@ -1481,7 +1478,7 @@ void bench_eccKeyAgree(void)
for(i = 0; i < agreeTimes; i++) { for(i = 0; i < agreeTimes; i++) {
int verify = 0; int verify = 0;
ret = ecc_verify_hash(sig, x, digest, sizeof(digest), &verify, &genKey); ret = wc_ecc_verify_hash(sig, x, digest, sizeof(digest), &verify, &genKey);
if (ret != 0) { if (ret != 0) {
printf("ecc_verify_hash failed\n"); printf("ecc_verify_hash failed\n");
return; return;
@@ -1494,8 +1491,8 @@ void bench_eccKeyAgree(void)
printf("EC-DSA verify time %6.3f milliseconds, avg over %d" printf("EC-DSA verify time %6.3f milliseconds, avg over %d"
" iterations\n", milliEach, agreeTimes); " iterations\n", milliEach, agreeTimes);
ecc_free(&genKey2); wc_ecc_free(&genKey2);
ecc_free(&genKey); wc_ecc_free(&genKey);
} }
#endif /* HAVE_ECC */ #endif /* HAVE_ECC */

12
wolfcrypt/src/aes.c
View File

@@ -181,7 +181,6 @@ void wc_AesFreeCavium(Aes* aes)
#ifdef HAVE_FIPS #ifdef HAVE_FIPS
/* fips wrapper calls, user can call direct */
int wc_AesSetKey_fips(Aes* aes, const byte* key, word32 len, int wc_AesSetKey_fips(Aes* aes, const byte* key, word32 len,
const byte* iv, int dir) const byte* iv, int dir)
{ {
@@ -233,17 +232,6 @@ void wc_AesFreeCavium(Aes* aes)
return AesGcmDecrypt_fips(aes, out, in, sz, iv, ivSz, return AesGcmDecrypt_fips(aes, out, in, sz, iv, ivSz,
authTag, authTagSz, authIn, authInSz); authTag, authTagSz, authIn, authInSz);
} }
#ifndef FIPS_NO_WRAPPERS
/* if not impl or fips.c impl wrapper force fips calls if fips build */
#define AesSetKey AesSetKey_fips
#define AesSetIV AesSetIV_fips
#define AesCbcEncrypt AesCbcEncrypt_fips
#define AesCbcDecrypt AesCbcDecrypt_fips
#define AesGcmSetKey AesGcmSetKey_fips
#define AesGcmEncrypt AesGcmEncrypt_fips
#define AesGcmDecrypt AesGcmDecrypt_fips
#endif /* FIPS_NO_WRAPPERS */
#endif /* HAVE_FIPS */ #endif /* HAVE_FIPS */

169
wolfcrypt/src/compress.c Normal file
View File

@@ -0,0 +1,169 @@
/* compress.c
*
* Copyright (C) 2006-2014 wolfSSL Inc.
*
* This file is part of wolfSSL. (formerly known as CyaSSL)
wc_*
* wolfSSL 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.
*
* wolfSSL 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 <wolfssl/wolfcrypt/settings.h>
#ifdef HAVE_LIBZ
#include <wolfssl/wolfcrypt/compress.h>
#include <wolfssl/wolfcrypt/error-crypt.h>
#include <wolfssl/wolfcrypt/logging.h>
#ifdef NO_INLINE
#include <wolfssl/wolfcrypt/misc.h>
#else
#include <wolfcrypt/src/misc.c>
#endif
#include <zlib.h>
/* alloc user allocs to work with zlib */
static void* myAlloc(void* opaque, unsigned int item, unsigned int size)
{
(void)opaque;
return XMALLOC(item * size, opaque, DYNAMIC_TYPE_LIBZ);
}
static void myFree(void* opaque, void* memory)
{
(void)opaque;
XFREE(memory, opaque, DYNAMIC_TYPE_LIBZ);
}
#ifdef HAVE_MCAPI
#define DEFLATE_DEFAULT_WINDOWBITS 11
#define DEFLATE_DEFAULT_MEMLEVEL 1
#else
#define DEFLATE_DEFAULT_WINDOWBITS 15
#define DEFLATE_DEFAULT_MEMLEVEL 8
#endif
int wc_Compress(byte* out, word32 outSz, const byte* in, word32 inSz, word32 flags)
/*
* out - pointer to destination buffer
* outSz - size of destination buffer
* in - pointer to source buffer to compress
* inSz - size of source to compress
* flags - flags to control how compress operates
*
* return:
* negative - error code
* positive - bytes stored in out buffer
*
* Note, the output buffer still needs to be larger than the input buffer.
* The right chunk of data won't compress at all, and the lookup table will
* add to the size of the output. The libz code says the compressed
* buffer should be srcSz + 0.1% + 12.
*/
{
z_stream stream;
int result = 0;
stream.next_in = (Bytef*)in;
stream.avail_in = (uInt)inSz;
#ifdef MAXSEG_64K
/* Check for source > 64K on 16-bit machine: */
if ((uLong)stream.avail_in != inSz) return COMPRESS_INIT_E;
#endif
stream.next_out = out;
stream.avail_out = (uInt)outSz;
if ((uLong)stream.avail_out != outSz) return COMPRESS_INIT_E;
stream.zalloc = (alloc_func)myAlloc;
stream.zfree = (free_func)myFree;
stream.opaque = (voidpf)0;
if (deflateInit2(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
DEFLATE_DEFAULT_WINDOWBITS, DEFLATE_DEFAULT_MEMLEVEL,
flags ? Z_FIXED : Z_DEFAULT_STRATEGY) != Z_OK)
return COMPRESS_INIT_E;
if (deflate(&stream, Z_FINISH) != Z_STREAM_END) {
deflateEnd(&stream);
return COMPRESS_E;
}
result = (int)stream.total_out;
if (deflateEnd(&stream) != Z_OK)
result = COMPRESS_E;
return result;
}
int wc_DeCompress(byte* out, word32 outSz, const byte* in, word32 inSz)
/*
* out - pointer to destination buffer
* outSz - size of destination buffer
* in - pointer to source buffer to compress
* inSz - size of source to compress
* flags - flags to control how compress operates
*
* return:
* negative - error code
* positive - bytes stored in out buffer
*/
{
z_stream stream;
int result = 0;
stream.next_in = (Bytef*)in;
stream.avail_in = (uInt)inSz;
/* Check for source > 64K on 16-bit machine: */
if ((uLong)stream.avail_in != inSz) return DECOMPRESS_INIT_E;
stream.next_out = out;
stream.avail_out = (uInt)outSz;
if ((uLong)stream.avail_out != outSz) return DECOMPRESS_INIT_E;
stream.zalloc = (alloc_func)myAlloc;
stream.zfree = (free_func)myFree;
stream.opaque = (voidpf)0;
if (inflateInit2(&stream, DEFLATE_DEFAULT_WINDOWBITS) != Z_OK)
return DECOMPRESS_INIT_E;
if (inflate(&stream, Z_FINISH) != Z_STREAM_END) {
inflateEnd(&stream);
return DECOMPRESS_E;
}
result = (int)stream.total_out;
if (inflateEnd(&stream) != Z_OK)
result = DECOMPRESS_E;
return result;
}
#endif /* HAVE_LIBZ */

8
wolfcrypt/src/dh.c
View File

@@ -23,12 +23,12 @@
#include <config.h> #include <config.h>
#endif #endif
#include <cyassl/ctaocrypt/settings.h> #include <wolfssl/wolfcrypt/settings.h>
#ifndef NO_DH #ifndef NO_DH
#include <cyassl/ctaocrypt/dh.h> #include <wolfssl/wolfcrypt/dh.h>
#include <cyassl/ctaocrypt/error-crypt.h> #include <wolfssl/wolfcrypt/error-crypt.h>
#ifndef USER_MATH_LIB #ifndef USER_MATH_LIB
#include <math.h> #include <math.h>
@@ -139,7 +139,7 @@ int wc_DhGenerateKeyPair(DhKey* key, RNG* rng, byte* priv, word32* privSz,
return (ret != 0) ? ret : GeneratePublic(key, priv, *privSz, pub, pubSz); return (ret != 0) ? ret : GeneratePublic(key, priv, *privSz, pub, pubSz);
} }
int DhAgree(DhKey* key, byte* agree, word32* agreeSz, const byte* priv, int wc_DhAgree(DhKey* key, byte* agree, word32* agreeSz, const byte* priv,
word32 privSz, const byte* otherPub, word32 pubSz) word32 privSz, const byte* otherPub, word32 pubSz)
{ {
int ret = 0; int ret = 0;

34
wolfcrypt/src/logging.c
View File

@@ -23,19 +23,19 @@
#include <config.h> #include <config.h>
#endif #endif
#include <cyassl/ctaocrypt/settings.h> #include <wolfssl/wolfcrypt/settings.h>
/* submitted by eof */ /* submitted by eof */
#include <cyassl/ctaocrypt/logging.h> #include <wolfssl/wolfcrypt/logging.h>
#include <cyassl/ctaocrypt/error-crypt.h> #include <wolfssl/wolfcrypt/error-crypt.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
CYASSL_API int CyaSSL_Debugging_ON(void); WOLFSSL_API int wolfSSL_Debugging_ON(void);
CYASSL_API void CyaSSL_Debugging_OFF(void); WOLFSSL_API void wolfSSL_Debugging_OFF(void);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
@@ -44,13 +44,13 @@
#ifdef DEBUG_CYASSL #ifdef DEBUG_CYASSL
/* Set these to default values initially. */ /* Set these to default values initially. */
static CyaSSL_Logging_cb log_function = 0; static wolfSSL_Logging_cb log_function = 0;
static int loggingEnabled = 0; static int loggingEnabled = 0;
#endif /* DEBUG_CYASSL */ #endif /* DEBUG_CYASSL */
int CyaSSL_SetLoggingCb(CyaSSL_Logging_cb f) int wolfSSL_SetLoggingCb(wolfSSL_Logging_cb f)
{ {
#ifdef DEBUG_CYASSL #ifdef DEBUG_CYASSL
int res = 0; int res = 0;
@@ -68,7 +68,7 @@ int CyaSSL_SetLoggingCb(CyaSSL_Logging_cb f)
} }
int CyaSSL_Debugging_ON(void) int wolfSSL_Debugging_ON(void)
{ {
#ifdef DEBUG_CYASSL #ifdef DEBUG_CYASSL
loggingEnabled = 1; loggingEnabled = 1;
@@ -79,7 +79,7 @@ int CyaSSL_Debugging_ON(void)
} }
void CyaSSL_Debugging_OFF(void) void wolfSSL_Debugging_OFF(void)
{ {
#ifdef DEBUG_CYASSL #ifdef DEBUG_CYASSL
loggingEnabled = 0; loggingEnabled = 0;
@@ -123,40 +123,40 @@ static void cyassl_log(const int logLevel, const char *const logMessage)
} }
void CYASSL_MSG(const char* msg) void WOLFSSL_MSG(const char* msg)
{ {
if (loggingEnabled) if (loggingEnabled)
cyassl_log(INFO_LOG , msg); cyassl_log(INFO_LOG , msg);
} }
void CYASSL_ENTER(const char* msg) void WOLFSSL_ENTER(const char* msg)
{ {
if (loggingEnabled) { if (loggingEnabled) {
char buffer[80]; char buffer[80];
sprintf(buffer, "CyaSSL Entering %s", msg); sprintf(buffer, "wolfSSL Entering %s", msg);
cyassl_log(ENTER_LOG , buffer); cyassl_log(ENTER_LOG , buffer);
} }
} }
void CYASSL_LEAVE(const char* msg, int ret) void WOLFSSL_LEAVE(const char* msg, int ret)
{ {
if (loggingEnabled) { if (loggingEnabled) {
char buffer[80]; char buffer[80];
sprintf(buffer, "CyaSSL Leaving %s, return %d", msg, ret); sprintf(buffer, "wolfSSL Leaving %s, return %d", msg, ret);
cyassl_log(LEAVE_LOG , buffer); cyassl_log(LEAVE_LOG , buffer);
} }
} }
void CYASSL_ERROR(int error) void WOLFSSL_ERROR(int error)
{ {
if (loggingEnabled) { if (loggingEnabled) {
char buffer[80]; char buffer[80];
sprintf(buffer, "CyaSSL error occured, error = %d", error); sprintf(buffer, "wolfSSL error occured, error = %d", error);
cyassl_log(ERROR_LOG , buffer); cyassl_log(ERROR_LOG , buffer);
} }
} }
#endif /* DEBUG_CYASSL */ #endif /* DEBUG_WOLFSSL */

7
wolfcrypt/src/md2.c
View File

@@ -26,8 +26,7 @@
#include <wolfssl/wolfcrypt/settings.h> #include <wolfssl/wolfcrypt/settings.h>
//#ifdef WOLFSSL_MD2 #ifdef WOLFSSL_MD2
//@TODO
#include <wolfssl/wolfcrypt/md2.h> #include <wolfssl/wolfcrypt/md2.h>
#include <wolfssl/wolfcrypt/error-crypt.h> #include <wolfssl/wolfcrypt/error-crypt.h>
@@ -157,5 +156,5 @@ int wc_Md2Hash(const byte* data, word32 len, byte* hash)
} }
//@TODO #endif /* WOLFSSL_MD2 */
//#endif /* WOLFSSL_MD2 */

8
wolfcrypt/src/md4.c
View File

@@ -23,15 +23,15 @@
#include <config.h> #include <config.h>
#endif #endif
#include <cyassl/ctaocrypt/settings.h> #include <wolfssl/wolfcrypt/settings.h>
#ifndef NO_MD4 #ifndef NO_MD4
#include <cyassl/ctaocrypt/md4.h> #include <wolfssl/wolfcrypt/md4.h>
#ifdef NO_INLINE #ifdef NO_INLINE
#include <cyassl/ctaocrypt/misc.h> #include <wolfssl/wolfcrypt/misc.h>
#else #else
#include <ctaocrypt/src/misc.c> #include <wolfcrypt/src/misc.c>
#endif #endif

19
wolfcrypt/src/memory.c
View File

@@ -2,14 +2,14 @@
* *
* Copyright (C) 2006-2014 wolfSSL Inc. * Copyright (C) 2006-2014 wolfSSL Inc.
* *
* This file is part of CyaSSL. * This file is part of wolfSSL. (formerly known as CyaSSL)
* *
* CyaSSL is free software; you can redistribute it and/or modify * wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* CyaSSL is distributed in the hope that it will be useful, * wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
@@ -25,8 +25,15 @@
#include <wolfssl/wolfcrypt/settings.h> #include <wolfssl/wolfcrypt/settings.h>
//#ifdef USE_WOLFSSL_MEMORY /* check old macros @wc_fips */
//@TODO #if defined(USE_CYASSL_MEMORY) && !defined(USE_WOLFSSL_MEMORY)
#define USE_WOLFSSL_MEMORY
#endif
#if defined(CYASSL_MALLOC_CHECK) && !defined(WOLFSSL_MALLOC_CHECK)
#define WOLFSSL_MALLOC_CHECK
#endif
#ifdef USE_WOLFSSL_MEMORY
#include <wolfssl/wolfcrypt/memory.h> #include <wolfssl/wolfcrypt/memory.h>
#include <wolfssl/wolfcrypt/error-crypt.h> #include <wolfssl/wolfcrypt/error-crypt.h>
@@ -102,7 +109,7 @@ void* wolfSSL_Realloc(void *ptr, size_t size)
return res; return res;
} }
//#endif /* USE_WOLFSSL_MEMORY */ #endif /* USE_WOLFSSL_MEMORY */
#ifdef HAVE_IO_POOL #ifdef HAVE_IO_POOL

18
wolfcrypt/src/pkcs7.c
View File

@@ -23,13 +23,13 @@
#include <config.h> #include <config.h>
#endif #endif
#include <cyassl/ctaocrypt/settings.h> #include <wolfssl/wolfcrypt/settings.h>
#ifdef HAVE_PKCS7 #ifdef HAVE_PKCS7
#include <cyassl/ctaocrypt/pkcs7.h> #include <wolfssl/wolfcrypt/pkcs7.h>
#include <cyassl/ctaocrypt/error-crypt.h> #include <wolfssl/wolfcrypt/error-crypt.h>
#include <cyassl/ctaocrypt/logging.h> #include <wolfssl/wolfcrypt/logging.h>
#ifndef min #ifndef min
static INLINE word32 min(word32 a, word32 b) static INLINE word32 min(word32 a, word32 b)
@@ -41,7 +41,7 @@
/* placed ASN.1 contentType OID into *output, return idx on success, /* placed ASN.1 contentType OID into *output, return idx on success,
* 0 upon failure */ * 0 upon failure */
WOLFSSL_LOCAL int wc_setContentType(int pkcs7TypeOID, byte* output) WOLFSSL_LOCAL int wc_SetContentType(int pkcs7TypeOID, byte* output)
{ {
/* PKCS#7 content types, RFC 2315, section 14 */ /* PKCS#7 content types, RFC 2315, section 14 */
static const byte pkcs7[] = { 0x2A, 0x86, 0x48, 0x86, 0xF7, static const byte pkcs7[] = { 0x2A, 0x86, 0x48, 0x86, 0xF7,
@@ -147,7 +147,7 @@ int wc_GetContentType(const byte* input, word32* inOutIdx, word32* oid,
/* init PKCS7 struct with recipient cert, decode into DecodedCert */ /* init PKCS7 struct with recipient cert, decode into DecodedCert */
int wc_PKS7_InitWithCert(PKCS7* pkcs7, byte* cert, word32 certSz) int wc_PKCS7_InitWithCert(PKCS7* pkcs7, byte* cert, word32 certSz)
{ {
int ret = 0; int ret = 0;
@@ -789,7 +789,7 @@ int wc_PKCS7_VerifySignedData(PKCS7* pkcs7, byte* pkiMsg, word32 pkiMsgSz)
cert = &pkiMsg[idx]; cert = &pkiMsg[idx];
certSz += (certIdx - idx); certSz += (certIdx - idx);
} }
wc_PKS7_InitWithCert(pkcs7, cert, certSz); wc_PKCS7_InitWithCert(pkcs7, cert, certSz);
} }
idx += length; idx += length;
} }
@@ -1222,7 +1222,7 @@ int wc_PKCS7_EncodeEnvelopedData(PKCS7* pkcs7, byte* output, word32 outputSz)
}; };
/* outer content type */ /* outer content type */
outerContentTypeSz = wc_setContentType(ENVELOPED_DATA, outerContentType); outerContentTypeSz = wc_SetContentType(ENVELOPED_DATA, outerContentType);
/* version, defined as 0 in RFC 2315 */ /* version, defined as 0 in RFC 2315 */
verSz = SetMyVersion(0, ver, 0); verSz = SetMyVersion(0, ver, 0);
@@ -1279,7 +1279,7 @@ int wc_PKCS7_EncodeEnvelopedData(PKCS7* pkcs7, byte* output, word32 outputSz)
} }
/* EncryptedContentInfo */ /* EncryptedContentInfo */
contentTypeSz = wc_setContentType(pkcs7->contentOID, contentType); contentTypeSz = wc_SetContentType(pkcs7->contentOID, contentType);
if (contentTypeSz == 0) { if (contentTypeSz == 0) {
#ifdef WOLFSSL_SMALL_STACK #ifdef WOLFSSL_SMALL_STACK
XFREE(recip, NULL, DYNAMMIC_TYPE_TMP_BUFFER); XFREE(recip, NULL, DYNAMMIC_TYPE_TMP_BUFFER);

2
wolfcrypt/src/rsa.c
View File

@@ -183,7 +183,7 @@ int wc_RsaFlattenPublicKey(RsaKey* key, byte* a, word32* aSz, byte* b,
} }
int wc_ RsaSSL_Sign_fips(const byte* in, word32 inLen, byte* out, int wc_RsaSSL_Sign_fips(const byte* in, word32 inLen, byte* out,
word32 outLen, RsaKey* key, RNG* rng) word32 outLen, RsaKey* key, RNG* rng)
{ {
return RsaSSL_Sign_fips(in, inLen, out, outLen, key, rng); return RsaSSL_Sign_fips(in, inLen, out, outLen, key, rng);

88
wolfcrypt/src/sha.c
View File

@@ -0,0 +1,88 @@
/* sha.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 <wolfssl/wolfcrypt/settings.h>
#if !defined(NO_SHA)
#ifdef HAVE_FIPS
/* set NO_WRAPPERS before headers, use direct internal f()s not wrappers */
#define FIPS_NO_WRAPPERS
#endif
#include <wolfssl/wolfcrypt/sha.h>
#include <wolfssl/wolfcrypt/logging.h>
#include <wolfssl/wolfcrypt/error-crypt.h>
#ifdef NO_INLINE
#include <wolfssl/wolfcrypt/misc.h>
#else
#include <wolfcrypt/src/misc.c>
#endif
int wc_InitSha(Sha* sha)
{
return InitSha(sha);
}
int wc_ShaUpdate(Sha* sha, const byte* data, word32 len)
{
return ShaUpdate(sha, data, len);
}
int wc_ShaFinal(Sha* sha, byte* hash)
{
return ShaFinal(sha, hash);
}
int wc_ShaHash(const byte* data, word32 len, byte* hash)
{
return ShaHash(data, len, hash);
}
/* fips wrapper calls, user can call direct */
#ifdef HAVE_FIPS
int wc_InitSha_fips(Sha* sha)
{
return InitSha_fips(sha);
}
int wc_ShaUpdate_fips(Sha* sha, const byte* data, word32 len)
{
return ShaUpdate_fips(sha, data, len);
}
int wc_ShaFinal_fips(Sha* sha, byte* out)
{
return ShaFinal_fips(sha,out);
}
#endif /* HAVE_FIPS */
#endif /* NO_SHA */

58
wolfcrypt/src/sha256.c
View File

@@ -0,0 +1,58 @@
/* sha256.c
*
* Copyright (C) 2006-2014 wolfSSL Inc.
*
* This file is part of wolfSSL. (formerly known as CyaSSL)
*
* wolfSSL 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.
*
* wolfSSL 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
*/
/* code submitted by raphael.huck@efixo.com */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <wolfssl/wolfcrypt/settings.h>
#include <wolfssl/wolfcrypt/sha256.h>
#if !defined(NO_SHA256)
int wc_InitSha256(Sha256* sha)
{
return InitSha256(sha);
}
int wc_Sha256Update(Sha256* sha, const byte* data, word32 len)
{
return Sha256Update(sha, data, len);
}
int wc_Sha256Final(Sha256* sha, byte* out)
{
return Sha256Final(sha, out);
}
int wc_Sha256Hash(const byte* data, word32 len, byte* out)
{
return Sha256Hash(data, len, out);
}
#endif

90
wolfcrypt/src/sha512.c Normal file
View File

@@ -0,0 +1,90 @@
/* sha512.c
*
* Copyright (C) 2006-2014 wolfSSL Inc.
*
* This file is part of wolfSSL. (formerly known as CyaSSL)
*
* wolfSSL 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.
*
* wolfSSL 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 <wolfssl/wolfcrypt/settings.h>
#include <wolfssl/wolfcrypt/sha512.h>
#ifdef WOLFSSL_SHA512
#ifdef __cplusplus
extern "C" {
#endif
int wc_InitSha512(Sha512* sha)
{
return InitSha512(sha);
}
int wc_Sha512Update(Sha512* sha, const byte* data, word32 len)
{
return Sha512Update(sha, data, len);
}
int wc_Sha512Final(Sha512* sha, byte* out)
{
return Sha512Final(sha, out);
}
int wc_Sha512Hash(const byte* data, word32 len, byte* out)
{
return Sha512Hash(data, len, out);
}
#if defined(WOLFSSL_SHA384) || defined(HAVE_AESGCM)
int wc_InitSha384(Sha384* sha)
{
return InitSha384(sha);
}
int wc_Sha384Update(Sha384* sha, const byte* data, word32 len)
{
return Sha384Update(sha, data, len);
}
int wc_Sha384Final(Sha384* sha, byte* out)
{
return Sha384Final(sha, out);
}
int wc_Sha384Hash(const byte* data, word32 len, byte* out)
{
return Sha384Hash(data, len, out);
}
#endif /* WOLFSSL_SHA384 */
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* WOLFSSL_SHA512 */

11
wolfcrypt/test/include.am~
View File

@@ -1,11 +0,0 @@
# vim:ft=automake
# All paths should be given relative to the root
noinst_PROGRAMS+= wolfcrypt/test/testwolfcrypt
wolfcrypt_test_testwolfcrypt_SOURCES = wolfcrypt/test/test.c
wolfcrypt_test_testwolfcrypt_LDADD = src/libcyassl.la
wolfcrypt_test_testwolfcrypt_DEPENDENCIES = src/libcyassl.la
noinst_HEADERS += wolfcrypt/test/test.h
EXTRA_DIST += wolfcrypt/test/test.sln
EXTRA_DIST += wolfcrypt/test/test.vcproj
DISTCLEANFILES+= wolfcrypt/test/.libs/testwolfcrypt

543
wolfcrypt/test/test.c
View File

File diff suppressed because it is too large Load Diff

20
wolfssl/wolfcrypt/aes.h
View File

@@ -106,16 +106,16 @@
word32 sz, const byte* iv, word32 ivSz, word32 sz, const byte* iv, word32 ivSz,
const byte* authTag, word32 authTagSz, const byte* authTag, word32 authTagSz,
const byte* authIn, word32 authInSz); const byte* authIn, word32 authInSz);
#ifndef FIPS_NO_WRAPPERS // #ifndef FIPS_NO_WRAPPERS
/* if not impl or fips.c impl wrapper force fips calls if fips build */ // /* if not impl or fips.c impl wrapper force fips calls if fips build */
#define AesSetKey AesSetKey_fips // #define AesSetKey AesSetKey_fips
#define AesSetIV AesSetIV_fips // #define AesSetIV AesSetIV_fips
#define AesCbcEncrypt AesCbcEncrypt_fips // #define AesCbcEncrypt AesCbcEncrypt_fips
#define AesCbcDecrypt AesCbcDecrypt_fips // #define AesCbcDecrypt AesCbcDecrypt_fips
#define AesGcmSetKey AesGcmSetKey_fips // #define AesGcmSetKey AesGcmSetKey_fips
#define AesGcmEncrypt AesGcmEncrypt_fips // #define AesGcmEncrypt AesGcmEncrypt_fips
#define AesGcmDecrypt AesGcmDecrypt_fips // #define AesGcmDecrypt AesGcmDecrypt_fips
#endif /* FIPS_NO_WRAPPERS */ // #endif /* FIPS_NO_WRAPPERS */
#endif /* HAVE_FIPS */ #endif /* HAVE_FIPS */

26
wolfssl/wolfcrypt/asn.h
View File

@@ -2,14 +2,14 @@
* *
* Copyright (C) 2006-2014 wolfSSL Inc. * Copyright (C) 2006-2014 wolfSSL Inc.
* *
* This file is part of CyaSSL. * This file is part of wolfSSL. (formerly known as CyaSSL)
* *
* CyaSSL is free software; you can redistribute it and/or modify * wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* CyaSSL is distributed in the hope that it will be useful, * wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
@@ -21,18 +21,18 @@
#ifndef NO_ASN #ifndef NO_ASN
#ifndef CTAO_CRYPT_ASN_H #ifndef WOLF_CRYPT_ASN_H
#define CTAO_CRYPT_ASN_H #define WOLF_CRYPT_ASN_H
#include <cyassl/ctaocrypt/types.h> #include <wolfssl/wolfcrypt/types.h>
#include <cyassl/ctaocrypt/rsa.h> #include <wolfssl/wolfcrypt/rsa.h>
#include <cyassl/ctaocrypt/dh.h> #include <wolfssl/wolfcrypt/dh.h>
#include <cyassl/ctaocrypt/dsa.h> #include <wolfssl/wolfcrypt/dsa.h>
#include <cyassl/ctaocrypt/sha.h> #include <wolfssl/wolfcrypt/sha.h>
#include <cyassl/ctaocrypt/md5.h> #include <wolfssl/wolfcrypt/md5.h>
#include <cyassl/ctaocrypt/asn_public.h> /* public interface */ #include <wolfssl/wolfcrypt/asn_public.h> /* public interface */
#ifdef HAVE_ECC #ifdef HAVE_ECC
#include <cyassl/ctaocrypt/ecc.h> #include <wolfssl/wolfcrypt/ecc.h>
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus

18
wolfssl/wolfcrypt/compress.h
View File

@@ -2,14 +2,14 @@
* *
* Copyright (C) 2006-2014 wolfSSL Inc. * Copyright (C) 2006-2014 wolfSSL Inc.
* *
* This file is part of CyaSSL. * This file is part of wolfSSL. (formerly known as CyaSSL)
* *
* CyaSSL is free software; you can redistribute it and/or modify * wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* CyaSSL is distributed in the hope that it will be useful, * wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
@@ -22,11 +22,11 @@
#ifdef HAVE_LIBZ #ifdef HAVE_LIBZ
#ifndef CTAO_CRYPT_COMPRESS_H #ifndef WOLF_CRYPT_COMPRESS_H
#define CTAO_CRYPT_COMPRESS_H #define WOLF_CRYPT_COMPRESS_H
#include <cyassl/ctaocrypt/types.h> #include <wolfssl/wolfcrypt/types.h>
#ifdef __cplusplus #ifdef __cplusplus
@@ -37,8 +37,8 @@
#define COMPRESS_FIXED 1 #define COMPRESS_FIXED 1
CYASSL_API int Compress(byte*, word32, const byte*, word32, word32); WOLFSSL_API int wc_Compress(byte*, word32, const byte*, word32, word32);
CYASSL_API int DeCompress(byte*, word32, const byte*, word32); WOLFSSL_API int wc_DeCompress(byte*, word32, const byte*, word32);
#ifdef __cplusplus #ifdef __cplusplus
@@ -46,7 +46,7 @@ CYASSL_API int DeCompress(byte*, word32, const byte*, word32);
#endif #endif
#endif /* CTAO_CRYPT_COMPRESS_H */ #endif /* WOLF_CRYPT_COMPRESS_H */
#endif /* HAVE_LIBZ */ #endif /* HAVE_LIBZ */

8
wolfssl/wolfcrypt/dsa.h
View File

@@ -29,6 +29,14 @@
#include <wolfssl/wolfcrypt/integer.h> #include <wolfssl/wolfcrypt/integer.h>
#include <wolfssl/wolfcrypt/random.h> #include <wolfssl/wolfcrypt/random.h>
/* for DSA reverse compatibility */
#define InitDsaKey wc_InitDsaKey
#define FreeDsaKey wc_FreeDsaKey
#define DsaSign wc_DsaSign
#define DsaVerify wc_DsaVerify
#define DsaPublicKeyDecode wc_DsaPublicKeyDecode
#define DsaPrivateKeyDecode wc_DsaPrivateKeyDecode
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif

19
wolfssl/wolfcrypt/error-crypt.h
View File

@@ -2,14 +2,14 @@
* *
* Copyright (C) 2006-2014 wolfSSL Inc. * Copyright (C) 2006-2014 wolfSSL Inc.
* *
* This file is part of CyaSSL. * This file is part of wolfSSL. (formerly known as CyaSSL)
* *
* CyaSSL is free software; you can redistribute it and/or modify * wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* CyaSSL is distributed in the hope that it will be useful, * wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
@@ -23,8 +23,11 @@
#ifndef WOLF_CRYPT_ERROR_H #ifndef WOLF_CRYPT_ERROR_H
#define WOLF_CRYPT_ERROR_H #define WOLF_CRYPT_ERROR_H
/* compatibility and fips @wc_fips */
#ifndef HAVE_FIPS
#include <wolfssl/wolfcrypt/types.h> #include <wolfssl/wolfcrypt/types.h>
#define CTaoCryptErrorString wc_CryptErrorString
#define CTaoCryptGetErrorString wc_CryptGetErrorString
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@@ -150,7 +153,11 @@ WOLFSSL_API const char* wc_GetErrorString(int error);
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */
#endif #endif
#else
#endif /* CTAO_CRYPT_ERROR_H */ #include <cyassl/ctaocrypt/error-crypt.h>
#define wc_ErrorString CTaoCryptErrorString
#define wc_GetErrorString CTaoCryptGetErrorString
#endif /* HAVE_FIPS */
#endif /* WOLF_CRYPT_ERROR_H */

3
wolfssl/wolfcrypt/hmac.h
View File

@@ -27,9 +27,6 @@
/* for fips */ /* for fips */
#include <cyassl/ctaocrypt/hmac.h> #include <cyassl/ctaocrypt/hmac.h>
#if defined(WOLFSSL_SHA512) && !defined(CYASSL_SHA512)
#define CYASSL_SHA512
#endif
#ifdef HAVE_CAVIUM #ifdef HAVE_CAVIUM

108
wolfssl/wolfcrypt/logging.h
View File

@@ -2,14 +2,14 @@
* *
* Copyright (C) 2006-2014 wolfSSL Inc. * Copyright (C) 2006-2014 wolfSSL Inc.
* *
* This file is part of CyaSSL. * This file is part of wolfSSL. (formerly known as CyaSSL)
* *
* CyaSSL is free software; you can redistribute it and/or modify * wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* CyaSSL is distributed in the hope that it will be useful, * wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
@@ -22,49 +22,67 @@
/* submitted by eof */ /* submitted by eof */
#ifndef CYASSL_LOGGING_H #ifndef WOLFSSL_LOGGING_H
#define CYASSL_LOGGING_H #define WOLFSSL_LOGGING_H
/* for reverse compatibility @wc_fips */
#ifndef HAVE_FIPS
#include <wolfssl/wolfcrypt/types.h>
#define CYASSL_LEAVE WOLFSSL_LEAVE
#define CYASSL_ERROR WOLFSSL_ERROR
#define CYASSL_ENTER WOLFSSL_ENTER
#define CYASSL_MSG WOLFSSL_MSG
#ifdef __cplusplus /* check old macros possibly declared */
extern "C" { #if defined(CYASSL_DEBUG) && !defined(DEBUG_WOLFSSL)
#define DEBUG_WOLFSSL
#endif
#ifdef __cplusplus
extern "C" {
#endif
enum CYA_Log_Levels {
ERROR_LOG = 0,
INFO_LOG,
ENTER_LOG,
LEAVE_LOG,
OTHER_LOG
};
typedef void (*wolfSSL_Logging_cb)(const int logLevel,
const char *const logMessage);
WOLFSSL_API int wolfSSL_SetLoggingCb(wolfSSL_Logging_cb log_function);
#ifdef DEBUG_WOLFSSL
void WOLFSSL_ENTER(const char* msg);
void WOLFSSL_LEAVE(const char* msg, int ret);
void WOLFSSL_ERROR(int);
void WOLFSSL_MSG(const char* msg);
#else /* DEBUG_WOLFSSL */
#define WOLFSSL_ENTER(m)
#define WOLFSSL_LEAVE(m, r)
#define WOLFSSL_ERROR(e)
#define WOLFSSL_MSG(m)
#endif /* DEBUG_WOLFSSL */
#ifdef __cplusplus
}
#endif
#else /* if using fips use old logging file */
#include <cyassl/ctaocrypt/logging.h>
#define WOLFSSL_LEAVE CYASSL_LEAVE
#define WOLFSSL_ERROR CYASSL_ERROR
#define WOLFSSL_ENTER CYASSL_ENTER
#define WOLFSSL_MSG CYASSL_MSG
#endif #endif
#endif /* WOLFSSL_MEMORY_H */
enum CYA_Log_Levels {
ERROR_LOG = 0,
INFO_LOG,
ENTER_LOG,
LEAVE_LOG,
OTHER_LOG
};
typedef void (*CyaSSL_Logging_cb)(const int logLevel,
const char *const logMessage);
CYASSL_API int CyaSSL_SetLoggingCb(CyaSSL_Logging_cb log_function);
#ifdef DEBUG_CYASSL
void CYASSL_ENTER(const char* msg);
void CYASSL_LEAVE(const char* msg, int ret);
void CYASSL_ERROR(int);
void CYASSL_MSG(const char* msg);
#else /* DEBUG_CYASSL */
#define CYASSL_ENTER(m)
#define CYASSL_LEAVE(m, r)
#define CYASSL_ERROR(e)
#define CYASSL_MSG(m)
#endif /* DEBUG_CYASSL */
#ifdef __cplusplus
}
#endif
#endif /* CYASSL_MEMORY_H */

30
wolfssl/wolfcrypt/md2.h
View File

@@ -2,14 +2,14 @@
* *
* Copyright (C) 2006-2014 wolfSSL Inc. * Copyright (C) 2006-2014 wolfSSL Inc.
* *
* This file is part of CyaSSL. * This file is part of wolfSSL. (formerly known as CyaSSL)
* *
* CyaSSL is free software; you can redistribute it and/or modify * wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* CyaSSL is distributed in the hope that it will be useful, * wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
@@ -19,15 +19,29 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/ */
/* check for old macro */
#if defined(CYASSL_MD2) && !defined(WOLFSSL_MD2)
#define WOLFSSL_MD2
#endif
//#ifdef WOLFSSL_MD2 #ifdef WOLFSSL_MD2
//@TODO
#ifndef WOLF_CRYPT_MD2_H #ifndef WOLF_CRYPT_MD2_H
#define WOLF_CRYPT_MD2_H #define WOLF_CRYPT_MD2_H
#include <wolfssl/wolfcrypt/types.h> #include <wolfssl/wolfcrypt/types.h>
/* for md2 reverse compatibility */
#ifdef WOLFSSL_MD2
#define InitMd2 wc_InitMd2
#define Md2Update wc_Md2Update
#define Md2Final wc_Md2Final
#define Md2Hash wc_Md2Hash
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
@@ -62,6 +76,6 @@ WOLFSSL_API int wc_Md2Hash(const byte*, word32, byte*);
} /* extern "C" */ } /* extern "C" */
#endif #endif
#endif /* CTAO_CRYPT_MD2_H */ #endif /* WOLF_CRYPT_MD2_H */
//@TODO #endif /* WOLFSSL_MD2 */
//#endif /* CYASSL_MD2 */

27
wolfssl/wolfcrypt/md4.h
View File

@@ -2,14 +2,14 @@
* *
* Copyright (C) 2006-2014 wolfSSL Inc. * Copyright (C) 2006-2014 wolfSSL Inc.
* *
* This file is part of CyaSSL. * This file is part of wolfSSL. (formerly known as CyaSSL)
* *
* CyaSSL is free software; you can redistribute it and/or modify * wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* CyaSSL is distributed in the hope that it will be useful, * wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
@@ -22,10 +22,17 @@
#ifndef NO_MD4 #ifndef NO_MD4
#ifndef CTAO_CRYPT_MD4_H #ifndef WOLF_CRYPT_MD4_H
#define CTAO_CRYPT_MD4_H #define WOLF_CRYPT_MD4_H
#include <cyassl/ctaocrypt/types.h> #include <wolfssl/wolfcrypt/types.h>
/* for md4 reverse compatibility */
#ifndef NO_MD4
#define InitMd4 wc_InitMd4
#define Md4Update wc_Md4Update
#define Md4Final wc_Md4Final
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@@ -50,16 +57,16 @@ typedef struct Md4 {
} Md4; } Md4;
CYASSL_API void InitMd4(Md4*); WOLFSSL_API void wc_InitMd4(Md4*);
CYASSL_API void Md4Update(Md4*, const byte*, word32); WOLFSSL_API void wc_Md4Update(Md4*, const byte*, word32);
CYASSL_API void Md4Final(Md4*, byte*); WOLFSSL_API void wc_Md4Final(Md4*, byte*);
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */
#endif #endif
#endif /* CTAO_CRYPT_MD4_H */ #endif /* WOLF_CRYPT_MD4_H */
#endif /* NO_MD4 */ #endif /* NO_MD4 */

72
wolfssl/wolfcrypt/md5.h
View File

@@ -2,14 +2,14 @@
* *
* Copyright (C) 2006-2014 wolfSSL Inc. * Copyright (C) 2006-2014 wolfSSL Inc.
* *
* This file is part of CyaSSL. * This file is part of wolfSSL. (formerly known as CyaSSL)
* *
* CyaSSL is free software; you can redistribute it and/or modify * wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* CyaSSL is distributed in the hope that it will be useful, * wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
@@ -26,41 +26,47 @@
#include <wolfssl/wolfcrypt/types.h> #include <wolfssl/wolfcrypt/types.h>
#include <cyassl/ctaocrypt/md5.h> /* for md5 reverse compatibility */
#ifndef NO_MD5
#define InitMd5 wc_InitMd5
#define Md5Update wc_Md5Update
#define Md5Final wc_Md5Final
#define Md5Hash wc_Md5Hash
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
///* in bytes */ /* in bytes */
//enum { enum {
//#ifdef STM32F2_HASH #ifdef STM32F2_HASH
// MD5_REG_SIZE = 4, /* STM32 register size, bytes */ MD5_REG_SIZE = 4, /* STM32 register size, bytes */
//#endif #endif
// MD5 = 0, /* hash type unique */ MD5 = 0, /* hash type unique */
// MD5_BLOCK_SIZE = 64, MD5_BLOCK_SIZE = 64,
// MD5_DIGEST_SIZE = 16, MD5_DIGEST_SIZE = 16,
// MD5_PAD_SIZE = 56 MD5_PAD_SIZE = 56
//}; };
//
//#ifdef CYASSL_PIC32MZ_HASH #ifdef CYASSL_PIC32MZ_HASH
//#include "port/pic32/pic32mz-crypt.h" #include "port/pic32/pic32mz-crypt.h"
//#endif #endif
//
///* MD5 digest */ /* MD5 digest */
//typedef struct Md5 { typedef struct Md5 {
// word32 buffLen; /* in bytes */ word32 buffLen; /* in bytes */
// word32 loLen; /* length in bytes */ word32 loLen; /* length in bytes */
// word32 hiLen; /* length in bytes */ word32 hiLen; /* length in bytes */
// word32 buffer[MD5_BLOCK_SIZE / sizeof(word32)]; word32 buffer[MD5_BLOCK_SIZE / sizeof(word32)];
// #ifndef CYASSL_PIC32MZ_HASH #ifndef CYASSL_PIC32MZ_HASH
// word32 digest[MD5_DIGEST_SIZE / sizeof(word32)]; word32 digest[MD5_DIGEST_SIZE / sizeof(word32)];
// #else #else
// word32 digest[PIC32_HASH_SIZE / sizeof(word32)]; word32 digest[PIC32_HASH_SIZE / sizeof(word32)];
// pic32mz_desc desc ; /* Crypt Engine descripter */ pic32mz_desc desc ; /* Crypt Engine descripter */
// #endif #endif
//} Md5; } Md5;
WOLFSSL_API void wc_InitMd5(Md5*); WOLFSSL_API void wc_InitMd5(Md5*);
WOLFSSL_API void wc_Md5Update(Md5*, const byte*, word32); WOLFSSL_API void wc_Md5Update(Md5*, const byte*, word32);
@@ -72,5 +78,5 @@ WOLFSSL_API int wc_Md5Hash(const byte*, word32, byte*);
} /* extern "C" */ } /* extern "C" */
#endif #endif
#endif /* CTAO_CRYPT_MD5_H */ #endif /* WOLF_CRYPT_MD5_H */
#endif /* NO_MD5 */ #endif /* NO_MD5 */

60
wolfssl/wolfcrypt/memory.h
View File

@@ -27,29 +27,47 @@
#include <stdlib.h> #include <stdlib.h>
#ifdef __cplusplus /* compatibility and fips @wc_fips */
extern "C" { #ifndef HAVE_FIPS
#endif #include <wolfssl/wolfcrypt/types.h>
#define CyaSSL_Malloc_cb wolfSSL_Malloc_cb
#define CyaSSL_Free_cb wolfSSL_Free_cb
#define CyaSSL_Realloc_cb wolfSSL_Realloc_cb
#define CyaSSL_SetAllocators wolfSSL_SetAllocators
/* Public in case user app wants to use XMALLOC/XFREE */
#define CyaSSL_Malloc wolfSSL_Malloc
#define CyaSSL_Free wolfSSL_Free
#define CyaSSL_Realloc wolfSSL_Realloc
typedef void *(*wolfSSL_Malloc_cb)(size_t size); typedef void *(*wolfSSL_Malloc_cb)(size_t size);
typedef void (*wolfSSL_Free_cb)(void *ptr); typedef void (*wolfSSL_Free_cb)(void *ptr);
typedef void *(*wolfSSL_Realloc_cb)(void *ptr, size_t size); typedef void *(*wolfSSL_Realloc_cb)(void *ptr, size_t size);
/* Public set function */ /* Public set function */
WOLFSSL_API int wolfSSL_SetAllocators(wolfSSL_Malloc_cb malloc_function, WOLFSSL_API int wolfSSL_SetAllocators(wolfSSL_Malloc_cb malloc_function,
wolfSSL_Free_cb free_function, wolfSSL_Free_cb free_function,
wolfSSL_Realloc_cb realloc_function); wolfSSL_Realloc_cb realloc_function);
/* Public in case user app wants to use XMALLOC/XFREE */ /* Public in case user app wants to use XMALLOC/XFREE */
WOLFSSL_API void* wolfSSL_Malloc(size_t size); WOLFSSL_API void* wolfSSL_Malloc(size_t size);
WOLFSSL_API void wolfSSL_Free(void *ptr); WOLFSSL_API void wolfSSL_Free(void *ptr);
WOLFSSL_API void* wolfSSL_Realloc(void *ptr, size_t size); WOLFSSL_API void* wolfSSL_Realloc(void *ptr, size_t size);
#else
#include <cyassl/ctaocrypt/memory.h>
#ifdef __cplusplus /* when using fips map wolfSSL to CyaSSL*/
} #define wolfSSL_Malloc_cb CyaSSL_Malloc_cb
#define wolfSSL_Free_cb CyaSSL_Free_cb
#define wolfSSL_Realloc_cb CyaSSL_Realloc_cb
#define wolfSSL_SetAllocators CyaSSL_SetAllocators
/* Public in case user app wants to use XMALLOC/XFREE */
#define wolfSSL_Malloc CyaSSL_Malloc
#define wolfSSL_Free CyaSSL_Free
#define wolfSSL_Realloc CyaSSL_Realloc
#endif #endif
#endif /* WOLFSSL_MEMORY_H */ #endif /* WOLFSSL_MEMORY_H */

44
wolfssl/wolfcrypt/pkcs7.h
View File

@@ -2,15 +2,15 @@
* *
* Copyright (C) 2006-2014 wolfSSL Inc. * Copyright (C) 2006-2014 wolfSSL Inc.
* *
* This file is part of CyaSSL. * This file is part of wolfSSL. (formerly known as CyaSSL)
* *
* CyaSSL is free software; you can redistribute it and/or modify * wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* CyaSSL is distributed in the hope that it will be useful, * wolfSSL is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
@@ -22,14 +22,14 @@
#ifdef HAVE_PKCS7 #ifdef HAVE_PKCS7
#ifndef CTAO_CRYPT_PKCS7_H #ifndef WOLF_CRYPT_PKCS7_H
#define CTAO_CRYPT_PKCS7_H #define WOLF_CRYPT_PKCS7_H
#include <cyassl/ctaocrypt/types.h> #include <wolfssl/wolfcrypt/types.h>
#include <cyassl/ctaocrypt/asn.h> #include <wolfssl/wolfcrypt/asn.h>
#include <cyassl/ctaocrypt/asn_public.h> #include <wolfssl/wolfcrypt/asn_public.h>
#include <cyassl/ctaocrypt/random.h> #include <wolfssl/wolfcrypt/random.h>
#include <cyassl/ctaocrypt/des3.h> #include <wolfssl/wolfcrypt/des3.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@@ -91,25 +91,25 @@ typedef struct PKCS7 {
} PKCS7; } PKCS7;
CYASSL_LOCAL int SetContentType(int pkcs7TypeOID, byte* output); WOLFSSL_LOCAL int wc_SetContentType(int pkcs7TypeOID, byte* output);
CYASSL_LOCAL int GetContentType(const byte* input, word32* inOutIdx, WOLFSSL_LOCAL int wc_GetContentType(const byte* input, word32* inOutIdx,
word32* oid, word32 maxIdx); word32* oid, word32 maxIdx);
CYASSL_LOCAL int CreateRecipientInfo(const byte* cert, word32 certSz, WOLFSSL_LOCAL int wc_CreateRecipientInfo(const byte* cert, word32 certSz,
int keyEncAlgo, int blockKeySz, int keyEncAlgo, int blockKeySz,
RNG* rng, byte* contentKeyPlain, RNG* rng, byte* contentKeyPlain,
byte* contentKeyEnc, byte* contentKeyEnc,
int* keyEncSz, byte* out, word32 outSz); int* keyEncSz, byte* out, word32 outSz);
CYASSL_API int PKCS7_InitWithCert(PKCS7* pkcs7, byte* cert, word32 certSz); WOLFSSL_API int wc_PKCS7_InitWithCert(PKCS7* pkcs7, byte* cert, word32 certSz);
CYASSL_API void PKCS7_Free(PKCS7* pkcs7); WOLFSSL_API void wc_PKCS7_Free(PKCS7* pkcs7);
CYASSL_API int PKCS7_EncodeData(PKCS7* pkcs7, byte* output, word32 outputSz); WOLFSSL_API int wc_PKCS7_EncodeData(PKCS7* pkcs7, byte* output, word32 outputSz);
CYASSL_API int PKCS7_EncodeSignedData(PKCS7* pkcs7, WOLFSSL_API int wc_PKCS7_EncodeSignedData(PKCS7* pkcs7,
byte* output, word32 outputSz); byte* output, word32 outputSz);
CYASSL_API int PKCS7_VerifySignedData(PKCS7* pkcs7, WOLFSSL_API int wc_PKCS7_VerifySignedData(PKCS7* pkcs7,
byte* pkiMsg, word32 pkiMsgSz); byte* pkiMsg, word32 pkiMsgSz);
CYASSL_API int PKCS7_EncodeEnvelopedData(PKCS7* pkcs7, WOLFSSL_API int wc_PKCS7_EncodeEnvelopedData(PKCS7* pkcs7,
byte* output, word32 outputSz); byte* output, word32 outputSz);
CYASSL_API int PKCS7_DecodeEnvelopedData(PKCS7* pkcs7, byte* pkiMsg, WOLFSSL_API int wc_PKCS7_DecodeEnvelopedData(PKCS7* pkcs7, byte* pkiMsg,
word32 pkiMsgSz, byte* output, word32 pkiMsgSz, byte* output,
word32 outputSz); word32 outputSz);
@@ -117,7 +117,7 @@ CYASSL_API int PKCS7_DecodeEnvelopedData(PKCS7* pkcs7, byte* pkiMsg,
} /* extern "C" */ } /* extern "C" */
#endif #endif
#endif /* CTAO_CRYPT_PKCS7_H */ #endif /* WOLF_CRYPT_PKCS7_H */
#endif /* HAVE_PKCS7 */ #endif /* HAVE_PKCS7 */

5
wolfssl/wolfcrypt/poly1305.h
View File

@@ -27,6 +27,11 @@
#include <wolfssl/wolfcrypt/types.h> #include <wolfssl/wolfcrypt/types.h>
/* for poly1305 reverse compatibility */
#define Poly1305SetKey wc_Poly1305SetKey
#define Poly1305Update wc_Poly1305Update
#define Poly1305Final wc_Poly1305Final
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif

10
wolfssl/wolfcrypt/random.h
View File

@@ -25,16 +25,6 @@
#include <wolfssl/wolfcrypt/types.h> #include <wolfssl/wolfcrypt/types.h>
#if defined(HAVE_HASHDRBG) || defined(NO_RC4)
#ifdef NO_SHA256
#error "Hash DRBG requires SHA-256."
#endif /* NO_SHA256 */
#include <cyassl/ctaocrypt/sha256.h>
#else /* HAVE_HASHDRBG || NO_RC4 */
#include <cyassl/ctaocrypt/arc4.h>
#endif /* HAVE_HASHDRBG || NO_RC4 */
/* for fips */ /* for fips */
#include <cyassl/ctaocrypt/random.h> #include <cyassl/ctaocrypt/random.h>

41
wolfssl/wolfcrypt/rsa.h
View File

@@ -27,11 +27,6 @@
/* for fips */ /* for fips */
#include <cyassl/ctaocrypt/rsa.h> #include <cyassl/ctaocrypt/rsa.h>
//#include <cyassl/ctaocrypt/types.h>
//#include <cyassl/ctaocrypt/integer.h>
//#include <cyassl/ctaocrypt/random.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
@@ -75,41 +70,27 @@ WOLFSSL_API int wc_RsaFlattenPublicKey(RsaKey*, byte*, word32*, byte*,
#ifdef HAVE_FIPS #ifdef HAVE_FIPS
/* fips wrapper calls, user can call direct */ /* fips wrapper calls, user can call direct */
WOLFSSL_API int InitRsaKey_fips(RsaKey* key, void*); WOLFSSL_API int wc_InitRsaKey_fips(RsaKey* key, void*);
WOLFSSL_API int FreeRsaKey_fips(RsaKey* key); WOLFSSL_API int wc_FreeRsaKey_fips(RsaKey* key);
WOLFSSL_API int RsaPublicEncrypt_fips(const byte* in,word32 inLen,byte* out, WOLFSSL_API int wc_RsaPublicEncrypt_fips(const byte* in,word32 inLen,byte* out,
word32 outLen, RsaKey* key, RNG* rng); word32 outLen, RsaKey* key, RNG* rng);
WOLFSSL_API int RsaPrivateDecryptInline_fips(byte* in, word32 inLen, WOLFSSL_API int wc_RsaPrivateDecryptInline_fips(byte* in, word32 inLen,
byte** out, RsaKey* key); byte** out, RsaKey* key);
WOLFSSL_API int RsaPrivateDecrypt_fips(const byte* in, word32 inLen, WOLFSSL_API int wc_RsaPrivateDecrypt_fips(const byte* in, word32 inLen,
byte* out,word32 outLen,RsaKey* key); byte* out,word32 outLen,RsaKey* key);
WOLFSSL_API int RsaSSL_Sign_fips(const byte* in, word32 inLen, byte* out, WOLFSSL_API int wc_RsaSSL_Sign_fips(const byte* in, word32 inLen, byte* out,
word32 outLen, RsaKey* key, RNG* rng); word32 outLen, RsaKey* key, RNG* rng);
WOLFSSL_API int RsaSSL_VerifyInline_fips(byte* in, word32 inLen, byte** out, WOLFSSL_API int wc_RsaSSL_VerifyInline_fips(byte* in, word32 inLen, byte** out,
RsaKey* key); RsaKey* key);
WOLFSSL_API int RsaSSL_Verify_fips(const byte* in, word32 inLen, byte* out, WOLFSSL_API int wc_RsaSSL_Verify_fips(const byte* in, word32 inLen, byte* out,
word32 outLen, RsaKey* key); word32 outLen, RsaKey* key);
WOLFSSL_API int RsaEncryptSize_fips(RsaKey* key); WOLFSSL_API int wc_RsaEncryptSize_fips(RsaKey* key);
WOLFSSL_API int RsaPrivateKeyDecode_fips(const byte* input, word32* inOutIdx, WOLFSSL_API int wc_RsaPrivateKeyDecode_fips(const byte* input, word32* inOutIdx,
RsaKey*, word32); RsaKey*, word32);
WOLFSSL_API int RsaPublicKeyDecode_fips(const byte* input, word32* inOutIdx, WOLFSSL_API int wc_RsaPublicKeyDecode_fips(const byte* input, word32* inOutIdx,
RsaKey*, word32); RsaKey*, word32);
#ifndef FIPS_NO_WRAPPERS
/* if not impl or fips.c impl wrapper force fips calls if fips build */
#define InitRsaKey InitRsaKey_fips
#define FreeRsaKey FreeRsaKey_fips
#define RsaPublicEncrypt RsaPublicEncrypt_fips
#define RsaPrivateDecryptInline RsaPrivateDecryptInline_fips
#define RsaPrivateDecrypt RsaPrivateDecrypt_fips
#define RsaSSL_Sign RsaSSL_Sign_fips
#define RsaSSL_VerifyInline RsaSSL_VerifyInline_fips
#define RsaSSL_Verify RsaSSL_Verify_fips
#define RsaEncryptSize RsaEncryptSize_fips
/* no implicit KeyDecodes since in asn.c (not rsa.c) */
#endif /* FIPS_NO_WRAPPERS */
#endif /* HAVE_FIPS */ #endif /* HAVE_FIPS */

711
wolfssl/wolfcrypt/settings.h
View File

@@ -26,7 +26,716 @@
#ifndef WOLF_CRYPT_SETTINGS_H #ifndef WOLF_CRYPT_SETTINGS_H
#define WOLF_CRYPT_SETTINGS_H #define WOLF_CRYPT_SETTINGS_H
#ifdef __cplusplus
extern "C" {
#endif
/* Uncomment next line if using IPHONE */
/* #define IPHONE */
/* Uncomment next line if using ThreadX */
/* #define THREADX */
/* Uncomment next line if using Micrium ucOS */
/* #define MICRIUM */
/* Uncomment next line if using Mbed */
/* #define MBED */
/* Uncomment next line if using Microchip PIC32 ethernet starter kit */
/* #define MICROCHIP_PIC32 */
/* Uncomment next line if using Microchip TCP/IP stack, version 5 */
/* #define MICROCHIP_TCPIP_V5 */
/* Uncomment next line if using Microchip TCP/IP stack, version 6 or later */
/* #define MICROCHIP_TCPIP */
/* Uncomment next line if using PIC32MZ Crypto Engine */
/* #define WOLFSSL_MICROCHIP_PIC32MZ */
/* Uncomment next line if using FreeRTOS */
/* #define FREERTOS */
/* Uncomment next line if using FreeRTOS Windows Simulator */
/* #define FREERTOS_WINSIM */
/* Uncomment next line if using RTIP */
/* #define EBSNET */
/* Uncomment next line if using lwip */
/* #define WOLFSSL_LWIP */
/* Uncomment next line if building wolfSSL for a game console */
/* #define WOLFSSL_GAME_BUILD */
/* Uncomment next line if building wolfSSL for LSR */
/* #define WOLFSSL_LSR */
/* Uncomment next line if building wolfSSL for Freescale MQX/RTCS/MFS */
/* #define FREESCALE_MQX */
/* Uncomment next line if using STM32F2 */
/* #define WOLFSSL_STM32F2 */
/* Uncomment next line if using Comverge settings */
/* #define COMVERGE */
/* Uncomment next line if using QL SEP settings */
/* #define WOLFSSL_QL */
/* Uncomment next line if building for EROAD */
/* #define WOLFSSL_EROAD */
/* Uncomment next line if building for IAR EWARM */
/* #define WOLFSSL_IAR_ARM */
/* Uncomment next line if using TI-RTOS settings */
/* #define WOLFSSL_TIRTOS */
/* Uncomment next line if building with PicoTCP */
/* #define WOLFSSL_PICOTCP */
/* Uncomment next line if building for PicoTCP demo bundle */
/* #define WOLFSSL_PICOTCP_DEMO */
#include <wolfssl/wolfcrypt/visibility.h> #include <wolfssl/wolfcrypt/visibility.h>
#include <cyassl/ctaocrypt/settings.h>
#ifdef IPHONE
#define SIZEOF_LONG_LONG 8
#endif
#ifdef WOLFSSL_USER_SETTINGS
#include <user_settings.h>
#endif
#ifdef COMVERGE
#define THREADX
#define HAVE_NETX
#define WOLFSSL_USER_IO
#define NO_WRITEV
#define NO_DEV_RANDOM
#define NO_FILESYSTEM
#define NO_SHA512
#define NO_DH
#define NO_DSA
#define NO_HC128
#define NO_RSA
#define NO_SESSION_CACHE
#define HAVE_ECC
#endif
#ifdef THREADX
#define SIZEOF_LONG_LONG 8
#endif
#ifdef HAVE_NETX
#include "nx_api.h"
#endif
#if defined(HAVE_LWIP_NATIVE) /* using LwIP native TCP socket */
#define WOLFSSL_LWIP
#define NO_WRITEV
#define SINGLE_THREADED
#define WOLFSSL_USER_IO
#define NO_FILESYSTEM
#endif
#if defined(WOLFSSL_IAR_ARM)
#define NO_MAIN_DRIVER
#define SINGLE_THREADED
#define USE_CERT_BUFFERS_1024
#define BENCH_EMBEDDED
#define NO_FILESYSTEM
#define NO_WRITEV
#define WOLFSSL_USER_IO
#define BENCH_EMBEDDED
#endif
#ifdef MICROCHIP_PIC32
/* #define WOLFSSL_MICROCHIP_PIC32MZ */
#define SIZEOF_LONG_LONG 8
#define SINGLE_THREADED
#define WOLFSSL_USER_IO
#define NO_WRITEV
#define NO_DEV_RANDOM
#define NO_FILESYSTEM
#define USE_FAST_MATH
#define TFM_TIMING_RESISTANT
#endif
#ifdef WOLFSSL_MICROCHIP_PIC32MZ
#define WOLFSSL_PIC32MZ_CE
#define WOLFSSL_PIC32MZ_CRYPT
#define HAVE_AES_ENGINE
#define WOLFSSL_PIC32MZ_RNG
/* #define WOLFSSL_PIC32MZ_HASH */
#define WOLFSSL_AES_COUNTER
#define HAVE_AESGCM
#define NO_BIG_INT
#endif
#ifdef MICROCHIP_TCPIP_V5
/* include timer functions */
#include "TCPIP Stack/TCPIP.h"
#endif
#ifdef MICROCHIP_TCPIP
/* include timer, NTP functions */
#ifdef MICROCHIP_MPLAB_HARMONY
#include "tcpip/tcpip.h"
#else
#include "system/system_services.h"
#include "tcpip/sntp.h"
#endif
#endif
#ifdef MBED
#define WOLFSSL_USER_IO
#define NO_FILESYSTEM
#define NO_CERT
#define USE_CERT_BUFFERS_1024
#define NO_WRITEV
#define NO_DEV_RANDOM
#define NO_SHA512
#define NO_DH
#define NO_DSA
#define NO_HC128
#define HAVE_ECC
#define NO_SESSION_CACHE
#define WOLFSSL_CMSIS_RTOS
#endif
#ifdef WOLFSSL_EROAD
#define FREESCALE_MQX
#define FREESCALE_MMCAU
#define SINGLE_THREADED
#define NO_STDIO_FILESYSTEM
#define WOLFSSL_LEANPSK
#define HAVE_NULL_CIPHER
#define NO_OLD_TLS
#define NO_ASN
#define NO_BIG_INT
#define NO_RSA
#define NO_DSA
#define NO_DH
#define NO_CERTS
#define NO_PWDBASED
#define NO_DES3
#define NO_MD4
#define NO_RC4
#define NO_MD5
#define NO_SESSION_CACHE
#define NO_MAIN_DRIVER
#endif
#ifdef WOLFSSL_PICOTCP
#define errno pico_err
#include "pico_defines.h"
#include "pico_stack.h"
#include "pico_constants.h"
#define CUSTOM_RAND_GENERATE pico_rand
#endif
#ifdef WOLFSSL_PICOTCP_DEMO
#define WOLFSSL_STM32
#define USE_FAST_MATH
#define TFM_TIMING_RESISTANT
#define XMALLOC(s, h, type) PICO_ZALLOC((s))
#define XFREE(p, h, type) PICO_FREE((p))
#define SINGLE_THREADED
#define NO_WRITEV
#define WOLFSSL_USER_IO
#define NO_DEV_RANDOM
#define NO_FILESYSTEM
#endif
#ifdef FREERTOS_WINSIM
#define FREERTOS
#define USE_WINDOWS_API
#endif
/* Micrium will use Visual Studio for compilation but not the Win32 API */
#if defined(_WIN32) && !defined(MICRIUM) && !defined(FREERTOS) \
&& !defined(EBSNET) && !defined(WOLFSSL_EROAD)
#define USE_WINDOWS_API
#endif
#if defined(WOLFSSL_LEANPSK) && !defined(XMALLOC_USER)
#include <stdlib.h>
#define XMALLOC(s, h, type) malloc((s))
#define XFREE(p, h, type) free((p))
#define XREALLOC(p, n, h, t) realloc((p), (n))
#endif
#if defined(XMALLOC_USER) && defined(SSN_BUILDING_LIBYASSL)
#undef XMALLOC
#define XMALLOC yaXMALLOC
#undef XFREE
#define XFREE yaXFREE
#undef XREALLOC
#define XREALLOC yaXREALLOC
#endif
#ifdef FREERTOS
#ifndef NO_WRITEV
#define NO_WRITEV
#endif
#ifndef NO_SHA512
#define NO_SHA512
#endif
#ifndef NO_DH
#define NO_DH
#endif
#ifndef NO_DSA
#define NO_DSA
#endif
#ifndef NO_HC128
#define NO_HC128
#endif
#ifndef SINGLE_THREADED
#include "FreeRTOS.h"
#include "semphr.h"
#endif
#endif
#ifdef WOLFSSL_TIRTOS
#define SIZEOF_LONG_LONG 8
#define NO_WRITEV
#define NO_WOLFSSL_DIR
#define USE_FAST_MATH
#define TFM_TIMING_RESISTANT
#define NO_DEV_RANDOM
#define NO_FILESYSTEM
#define USE_CERT_BUFFERS_2048
#define NO_ERROR_STRINGS
#define USER_TIME
#ifdef __IAR_SYSTEMS_ICC__
#pragma diag_suppress=Pa089
#elif !defined(__GNUC__)
/* Suppress the sslpro warning */
#pragma diag_suppress=11
#endif
#include <ti/ndk/nettools/mytime/mytime.h>
#endif
#ifdef EBSNET
#include "rtip.h"
/* #define DEBUG_WOLFSSL */
#define NO_WOLFSSL_DIR /* tbd */
#if (POLLOS)
#define SINGLE_THREADED
#endif
#if (RTPLATFORM)
#if (!RTP_LITTLE_ENDIAN)
#define BIG_ENDIAN_ORDER
#endif
#else
#if (!KS_LITTLE_ENDIAN)
#define BIG_ENDIAN_ORDER
#endif
#endif
#if (WINMSP3)
#undef SIZEOF_LONG
#define SIZEOF_LONG_LONG 8
#else
#sslpro: settings.h - please implement SIZEOF_LONG and SIZEOF_LONG_LONG
#endif
#define XMALLOC(s, h, type) ((void *)rtp_malloc((s), SSL_PRO_MALLOC))
#define XFREE(p, h, type) (rtp_free(p))
#define XREALLOC(p, n, h, t) realloc((p), (n))
#endif /* EBSNET */
#ifdef WOLFSSL_GAME_BUILD
#define SIZEOF_LONG_LONG 8
#if defined(__PPU) || defined(__XENON)
#define BIG_ENDIAN_ORDER
#endif
#endif
#ifdef WOLFSSL_LSR
#define HAVE_WEBSERVER
#define SIZEOF_LONG_LONG 8
#define WOLFSSL_LOW_MEMORY
#define NO_WRITEV
#define NO_SHA512
#define NO_DH
#define NO_DSA
#define NO_HC128
#define NO_DEV_RANDOM
#define NO_WOLFSSL_DIR
#define NO_RABBIT
#ifndef NO_FILESYSTEM
#define LSR_FS
#include "inc/hw_types.h"
#include "fs.h"
#endif
#define WOLFSSL_LWIP
#include <errno.h> /* for tcp errno */
#define WOLFSSL_SAFERTOS
#if defined(__IAR_SYSTEMS_ICC__)
/* enum uses enum */
#pragma diag_suppress=Pa089
#endif
#endif
#ifdef WOLFSSL_SAFERTOS
#ifndef SINGLE_THREADED
#include "SafeRTOS/semphr.h"
#endif
#include "SafeRTOS/heap.h"
#define XMALLOC(s, h, type) pvPortMalloc((s))
#define XFREE(p, h, type) vPortFree((p))
#define XREALLOC(p, n, h, t) pvPortRealloc((p), (n))
#endif
#ifdef WOLFSSL_LOW_MEMORY
#undef RSA_LOW_MEM
#define RSA_LOW_MEM
#undef WOLFSSL_SMALL_STACK
#define WOLFSSL_SMALL_STACK
#undef TFM_TIMING_RESISTANT
#define TFM_TIMING_RESISTANT
#endif
#ifdef FREESCALE_MQX
#define SIZEOF_LONG_LONG 8
#define NO_WRITEV
#define NO_DEV_RANDOM
#define NO_RABBIT
#define NO_WOLFSSL_DIR
#define USE_FAST_MATH
#define TFM_TIMING_RESISTANT
#define FREESCALE_K70_RNGA
/* #define FREESCALE_K53_RNGB */
#include "mqx.h"
#ifndef NO_FILESYSTEM
#include "mfs.h"
#include "fio.h"
#endif
#ifndef SINGLE_THREADED
#include "mutex.h"
#endif
#define XMALLOC(s, h, t) (void *)_mem_alloc_system((s))
#define XFREE(p, h, t) {void* xp = (p); if ((xp)) _mem_free((xp));}
/* Note: MQX has no realloc, using fastmath above */
#endif
#ifdef WOLFSSL_STM32F2
#define SIZEOF_LONG_LONG 8
#define NO_DEV_RANDOM
#define NO_WOLFSSL_DIR
#define NO_RABBIT
#define STM32F2_RNG
#define STM32F2_CRYPTO
#define KEIL_INTRINSICS
#endif
#ifdef MICRIUM
#include "stdlib.h"
#include "net_cfg.h"
#include "ssl_cfg.h"
#include "net_secure_os.h"
#define WOLFSSL_TYPES
typedef CPU_INT08U byte;
typedef CPU_INT16U word16;
typedef CPU_INT32U word32;
#if (NET_SECURE_MGR_CFG_WORD_SIZE == CPU_WORD_SIZE_32)
#define SIZEOF_LONG 4
#undef SIZEOF_LONG_LONG
#else
#undef SIZEOF_LONG
#define SIZEOF_LONG_LONG 8
#endif
#define STRING_USER
#define XSTRLEN(pstr) ((CPU_SIZE_T)Str_Len((CPU_CHAR *)(pstr)))
#define XSTRNCPY(pstr_dest, pstr_src, len_max) \
((CPU_CHAR *)Str_Copy_N((CPU_CHAR *)(pstr_dest), \
(CPU_CHAR *)(pstr_src), (CPU_SIZE_T)(len_max)))
#define XSTRNCMP(pstr_1, pstr_2, len_max) \
((CPU_INT16S)Str_Cmp_N((CPU_CHAR *)(pstr_1), \
(CPU_CHAR *)(pstr_2), (CPU_SIZE_T)(len_max)))
#define XSTRSTR(pstr, pstr_srch) \
((CPU_CHAR *)Str_Str((CPU_CHAR *)(pstr), \
(CPU_CHAR *)(pstr_srch)))
#define XMEMSET(pmem, data_val, size) \
((void)Mem_Set((void *)(pmem), (CPU_INT08U) (data_val), \
(CPU_SIZE_T)(size)))
#define XMEMCPY(pdest, psrc, size) ((void)Mem_Copy((void *)(pdest), \
(void *)(psrc), (CPU_SIZE_T)(size)))
#define XMEMCMP(pmem_1, pmem_2, size) \
(((CPU_BOOLEAN)Mem_Cmp((void *)(pmem_1), (void *)(pmem_2), \
(CPU_SIZE_T)(size))) ? DEF_NO : DEF_YES)
#define XMEMMOVE XMEMCPY
#if (NET_SECURE_MGR_CFG_EN == DEF_ENABLED)
#define MICRIUM_MALLOC
#define XMALLOC(s, h, type) ((void *)NetSecure_BlkGet((CPU_INT08U)(type), \
(CPU_SIZE_T)(s), (void *)0))
#define XFREE(p, h, type) (NetSecure_BlkFree((CPU_INT08U)(type), \
(p), (void *)0))
#define XREALLOC(p, n, h, t) realloc((p), (n))
#endif
#if (NET_SECURE_MGR_CFG_FS_EN == DEF_ENABLED)
#undef NO_FILESYSTEM
#else
#define NO_FILESYSTEM
#endif
#if (SSL_CFG_TRACE_LEVEL == WOLFSSL_TRACE_LEVEL_DBG)
#define DEBUG_WOLFSSL
#else
#undef DEBUG_WOLFSSL
#endif
#if (SSL_CFG_OPENSSL_EN == DEF_ENABLED)
#define OPENSSL_EXTRA
#else
#undef OPENSSL_EXTRA
#endif
#if (SSL_CFG_MULTI_THREAD_EN == DEF_ENABLED)
#undef SINGLE_THREADED
#else
#define SINGLE_THREADED
#endif
#if (SSL_CFG_DH_EN == DEF_ENABLED)
#undef NO_DH
#else
#define NO_DH
#endif
#if (SSL_CFG_DSA_EN == DEF_ENABLED)
#undef NO_DSA
#else
#define NO_DSA
#endif
#if (SSL_CFG_PSK_EN == DEF_ENABLED)
#undef NO_PSK
#else
#define NO_PSK
#endif
#if (SSL_CFG_3DES_EN == DEF_ENABLED)
#undef NO_DES
#else
#define NO_DES
#endif
#if (SSL_CFG_AES_EN == DEF_ENABLED)
#undef NO_AES
#else
#define NO_AES
#endif
#if (SSL_CFG_RC4_EN == DEF_ENABLED)
#undef NO_RC4
#else
#define NO_RC4
#endif
#if (SSL_CFG_RABBIT_EN == DEF_ENABLED)
#undef NO_RABBIT
#else
#define NO_RABBIT
#endif
#if (SSL_CFG_HC128_EN == DEF_ENABLED)
#undef NO_HC128
#else
#define NO_HC128
#endif
#if (CPU_CFG_ENDIAN_TYPE == CPU_ENDIAN_TYPE_BIG)
#define BIG_ENDIAN_ORDER
#else
#undef BIG_ENDIAN_ORDER
#define LITTLE_ENDIAN_ORDER
#endif
#if (SSL_CFG_MD4_EN == DEF_ENABLED)
#undef NO_MD4
#else
#define NO_MD4
#endif
#if (SSL_CFG_WRITEV_EN == DEF_ENABLED)
#undef NO_WRITEV
#else
#define NO_WRITEV
#endif
#if (SSL_CFG_USER_RNG_SEED_EN == DEF_ENABLED)
#define NO_DEV_RANDOM
#else
#undef NO_DEV_RANDOM
#endif
#if (SSL_CFG_USER_IO_EN == DEF_ENABLED)
#define WOLFSSL_USER_IO
#else
#undef WOLFSSL_USER_IO
#endif
#if (SSL_CFG_DYNAMIC_BUFFERS_EN == DEF_ENABLED)
#undef LARGE_STATIC_BUFFERS
#undef STATIC_CHUNKS_ONLY
#else
#define LARGE_STATIC_BUFFERS
#define STATIC_CHUNKS_ONLY
#endif
#if (SSL_CFG_DER_LOAD_EN == DEF_ENABLED)
#define WOLFSSL_DER_LOAD
#else
#undef WOLFSSL_DER_LOAD
#endif
#if (SSL_CFG_DTLS_EN == DEF_ENABLED)
#define WOLFSSL_DTLS
#else
#undef WOLFSSL_DTLS
#endif
#if (SSL_CFG_CALLBACKS_EN == DEF_ENABLED)
#define WOLFSSL_CALLBACKS
#else
#undef WOLFSSL_CALLBACKS
#endif
#if (SSL_CFG_FAST_MATH_EN == DEF_ENABLED)
#define USE_FAST_MATH
#else
#undef USE_FAST_MATH
#endif
#if (SSL_CFG_TFM_TIMING_RESISTANT_EN == DEF_ENABLED)
#define TFM_TIMING_RESISTANT
#else
#undef TFM_TIMING_RESISTANT
#endif
#endif /* MICRIUM */
#ifdef WOLFSSL_QL
#ifndef WOLFSSL_SEP
#define WOLFSSL_SEP
#endif
#ifndef OPENSSL_EXTRA
#define OPENSSL_EXTRA
#endif
#ifndef SESSION_CERTS
#define SESSION_CERTS
#endif
#ifndef HAVE_AESCCM
#define HAVE_AESCCM
#endif
#ifndef ATOMIC_USER
#define ATOMIC_USER
#endif
#ifndef WOLFSSL_DER_LOAD
#define WOLFSSL_DER_LOAD
#endif
#ifndef KEEP_PEER_CERT
#define KEEP_PEER_CERT
#endif
#ifndef HAVE_ECC
#define HAVE_ECC
#endif
#ifndef SESSION_INDEX
#define SESSION_INDEX
#endif
#endif /* WOLFSSL_QL */
#if !defined(XMALLOC_USER) && !defined(MICRIUM_MALLOC) && \
!defined(WOLFSSL_LEANPSK) && !defined(NO_CYASSL_MEMORY)
#define USE_WOLFSSL_MEMORY
#endif
#if defined(OPENSSL_EXTRA) && !defined(NO_CERTS)
#undef KEEP_PEER_CERT
#define KEEP_PEER_CERT
#endif
/* stream ciphers except arc4 need 32bit alignment, intel ok without */
#ifndef XSTREAM_ALIGNMENT
#if defined(__x86_64__) || defined(__ia64__) || defined(__i386__)
#define NO_XSTREAM_ALIGNMENT
#else
#define XSTREAM_ALIGNMENT
#endif
#endif
/* FreeScale MMCAU hardware crypto has 4 byte alignment */
#ifdef FREESCALE_MMCAU
#define WOLFSSL_MMCAU_ALIGNMENT 4
#endif
/* if using hardware crypto and have alignment requirements, specify the
requirement here. The record header of SSL/TLS will prvent easy alignment.
This hint tries to help as much as possible. */
#ifndef WOLFSSL_GENERAL_ALIGNMENT
#ifdef WOLFSSL_AESNI
#define WOLFSSL_GENERAL_ALIGNMENT 16
#elif defined(XSTREAM_ALIGNMENT)
#define WOLFSSL_GENERAL_ALIGNMENT 4
#elif defined(FREESCALE_MMCAU)
#define WOLFSSL_GENERAL_ALIGNMENT CYASSL_MMCAU_ALIGNMENT
#else
#define WOLFSSL_GENERAL_ALIGNMENT 0
#endif
#endif
#ifdef HAVE_CRL
/* not widely supported yet */
#undef NO_SKID
#define NO_SKID
#endif
#ifdef __INTEL_COMPILER
#pragma warning(disable:2259) /* explicit casts to smaller sizes, disable */
#endif
/* Place any other flags or defines here */
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif #endif

67
wolfssl/wolfcrypt/sha.h
View File

@@ -2,14 +2,14 @@
* *
* Copyright (C) 2006-2014 wolfSSL Inc. * Copyright (C) 2006-2014 wolfSSL Inc.
* *
* This file is part of CyaSSL. * This file is part of wolfSSL. (formerly known as CyaSSL)
* *
* CyaSSL is free software; you can redistribute it and/or modify * wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* CyaSSL is distributed in the hope that it will be useful, * wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
@@ -22,62 +22,35 @@
#ifndef NO_SHA #ifndef NO_SHA
#ifndef CTAO_CRYPT_SHA_H #ifndef WOLF_CRYPT_SHA_H
#define CTAO_CRYPT_SHA_H #define WOLF_CRYPT_SHA_H
#include <cyassl/ctaocrypt/types.h>
#include <wolfssl/wolfcrypt/types.h>
/* for fips */
#include <cyassl/ctaocrypt/sha.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
WOLFSSL_API int wc_InitSha(Sha*);
/* in bytes */ WOLFSSL_API int wc_ShaUpdate(Sha*, const byte*, word32);
enum { WOLFSSL_API int wc_ShaFinal(Sha*, byte*);
#ifdef STM32F2_HASH WOLFSSL_API int wc_ShaHash(const byte*, word32, byte*);
SHA_REG_SIZE = 4, /* STM32 register size, bytes */
#endif
SHA = 1, /* hash type unique */
SHA_BLOCK_SIZE = 64,
SHA_DIGEST_SIZE = 20,
SHA_PAD_SIZE = 56
};
#ifdef CYASSL_PIC32MZ_HASH
#include "port/pic32/pic32mz-crypt.h"
#endif
/* Sha digest */
typedef struct Sha {
word32 buffLen; /* in bytes */
word32 loLen; /* length in bytes */
word32 hiLen; /* length in bytes */
word32 buffer[SHA_BLOCK_SIZE / sizeof(word32)];
#ifndef CYASSL_PIC32MZ_HASH
word32 digest[SHA_DIGEST_SIZE / sizeof(word32)];
#else
word32 digest[PIC32_HASH_SIZE / sizeof(word32)];
pic32mz_desc desc; /* Crypt Engine descripter */
#endif
} Sha;
CYASSL_API int InitSha(Sha*);
CYASSL_API int ShaUpdate(Sha*, const byte*, word32);
CYASSL_API int ShaFinal(Sha*, byte*);
CYASSL_API int ShaHash(const byte*, word32, byte*);
#ifdef HAVE_FIPS #ifdef HAVE_FIPS
/* fips wrapper calls, user can call direct */ /* fips wrapper calls, user can call direct */
CYASSL_API int InitSha_fips(Sha*); WOLFSSL_API int wc_InitSha_fips(Sha*);
CYASSL_API int ShaUpdate_fips(Sha*, const byte*, word32); WOLFSSL_API int wc_ShaUpdate_fips(Sha*, const byte*, word32);
CYASSL_API int ShaFinal_fips(Sha*, byte*); WOLFSSL_API int wc_ShaFinal_fips(Sha*, byte*);
#ifndef FIPS_NO_WRAPPERS #ifndef FIPS_NO_WRAPPERS
/* if not impl or fips.c impl wrapper force fips calls if fips build */ /* if not impl or fips.c impl wrapper force fips calls if fips build */
#define InitSha InitSha_fips #define wc_InitSha wc_InitSha_fips
#define ShaUpdate ShaUpdate_fips #define wc_ShaUpdate wc_ShaUpdate_fips
#define ShaFinal ShaFinal_fips #define wc_ShaFinal wc_ShaFinal_fips
#endif /* FIPS_NO_WRAPPERS */ #endif /* FIPS_NO_WRAPPERS */
#endif /* HAVE_FIPS */ #endif /* HAVE_FIPS */

78
wolfssl/wolfcrypt/sha256.h
View File

@@ -1,15 +1,13 @@
/* sha256.h /* sha256.h
* *
* Copyright (C) 2006-2014 wolfSSL Inc. * This file is part of wolfSSL. (formerly known as CyaSSL)
* *
* This file is part of CyaSSL. * wolfSSL is free software; you can redistribute it and/or modify
*
* CyaSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* CyaSSL is distributed in the hope that it will be useful, * wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
@@ -25,67 +23,35 @@
#ifndef NO_SHA256 #ifndef NO_SHA256
#ifndef CTAO_CRYPT_SHA256_H #ifndef WOLF_CRYPT_SHA256_H
#define CTAO_CRYPT_SHA256_H #define WOLF_CRYPT_SHA256_H
#include <cyassl/ctaocrypt/types.h>
/* for fips */
#include <cyassl/ctaocrypt/sha256.h>
//#ifndef HAVE_FIPS
#include <wolfssl/wolfcrypt/types.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifdef CYASSL_PIC32MZ_HASH WOLFSSL_API int wc_InitSha256(Sha256*);
#include "port/pic32/pic32mz-crypt.h" WOLFSSL_API int wc_Sha256Update(Sha256*, const byte*, word32);
#endif WOLFSSL_API int wc_Sha256Final(Sha256*, byte*);
WOLFSSL_API int wc_Sha256Hash(const byte*, word32, byte*);
/* in bytes */
enum {
SHA256 = 2, /* hash type unique */
SHA256_BLOCK_SIZE = 64,
SHA256_DIGEST_SIZE = 32,
SHA256_PAD_SIZE = 56
};
/* Sha256 digest */
typedef struct Sha256 {
word32 buffLen; /* in bytes */
word32 loLen; /* length in bytes */
word32 hiLen; /* length in bytes */
word32 digest[SHA256_DIGEST_SIZE / sizeof(word32)];
word32 buffer[SHA256_BLOCK_SIZE / sizeof(word32)];
#ifdef CYASSL_PIC32MZ_HASH
pic32mz_desc desc ; /* Crypt Engine descripter */
#endif
} Sha256;
CYASSL_API int InitSha256(Sha256*);
CYASSL_API int Sha256Update(Sha256*, const byte*, word32);
CYASSL_API int Sha256Final(Sha256*, byte*);
CYASSL_API int Sha256Hash(const byte*, word32, byte*);
#ifdef HAVE_FIPS
/* fips wrapper calls, user can call direct */
CYASSL_API int InitSha256_fips(Sha256*);
CYASSL_API int Sha256Update_fips(Sha256*, const byte*, word32);
CYASSL_API int Sha256Final_fips(Sha256*, byte*);
#ifndef FIPS_NO_WRAPPERS
/* if not impl or fips.c impl wrapper force fips calls if fips build */
#define InitSha256 InitSha256_fips
#define Sha256Update Sha256Update_fips
#define Sha256Final Sha256Final_fips
#endif /* FIPS_NO_WRAPPERS */
#endif /* HAVE_FIPS */
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */
#endif #endif
//#else
//#define wc_InitSha256 wc_InitSha256Sha256*);
//#define int wc_Sha256Update(Swc_Sha256Updateha256*, const byte*, word32);
//#define int wc_Sha256Final(wc_Sha256FinalSha256*, byte*);
//#define int wc_Sha256Hash(wc_Sha256Hashconst byte*, word32, byte*);
//
//#endif /* HAVE_FIPS */
#endif /* CTAO_CRYPT_SHA256_H */ #endif /* WOLF_CRYPT_SHA256_H */
#endif /* NO_SHA256 */ #endif /* NO_SHA256 */

108
wolfssl/wolfcrypt/sha512.h
View File

@@ -2,14 +2,14 @@
* *
* Copyright (C) 2006-2014 wolfSSL Inc. * Copyright (C) 2006-2014 wolfSSL Inc.
* *
* This file is part of CyaSSL. * This file is part of wolfSSL. (formerly known as CyaSSL)
* *
* CyaSSL is free software; you can redistribute it and/or modify * wolfSSL is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* CyaSSL is distributed in the hope that it will be useful, * wolfSSL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
@@ -19,76 +19,54 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/ */
/* check for old macro */
#if defined(CYASSL_SHA512) && !defined(WOLFSSL_SHA512)
#define WOLFSSL_SHA512
#endif
#if defined(CYASSL_SHA384) && !defined(WOLFSSL_SHA384)
#define WOLFSSL_SHA384
#endif
#ifdef CYASSL_SHA512 #ifdef WOLFSSL_SHA512
#ifndef CTAO_CRYPT_SHA512_H #ifndef WOLF_CRYPT_SHA512_H
#define CTAO_CRYPT_SHA512_H #define WOLF_CRYPT_SHA512_H
#include <wolfssl/wolfcrypt/types.h>
/* since using old code turn on old macros @wc_fips */
#if !defined(CYASSL_SHA512)
#define CYASSL_SHA512
#endif
#if !defined(CYASSL_SHA384) && defined(WOLFSSL_SHA384)
#define CYASSL_SHA384
#endif
/* for fips */
#include <cyassl/ctaocrypt/sha512.h>
#include <cyassl/ctaocrypt/types.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
WOLFSSL_API int wc_InitSha512(Sha512*);
WOLFSSL_API int wc_Sha512Update(Sha512*, const byte*, word32);
WOLFSSL_API int wc_Sha512Final(Sha512*, byte*);
WOLFSSL_API int wc_Sha512Hash(const byte*, word32, byte*);
/* in bytes */ #if defined(WOLFSSL_SHA384) || defined(HAVE_AESGCM)
enum {
SHA512 = 4, /* hash type unique */
SHA512_BLOCK_SIZE = 128,
SHA512_DIGEST_SIZE = 64,
SHA512_PAD_SIZE = 112
};
WOLFSSL_API int wc_InitSha384(Sha384*);
/* Sha512 digest */ WOLFSSL_API int wc_Sha384Update(Sha384*, const byte*, word32);
typedef struct Sha512 { WOLFSSL_API int wc_Sha384Final(Sha384*, byte*);
word32 buffLen; /* in bytes */ WOLFSSL_API int wc_Sha384Hash(const byte*, word32, byte*);
word32 loLen; /* length in bytes */
word32 hiLen; /* length in bytes */
word64 digest[SHA512_DIGEST_SIZE / sizeof(word64)];
word64 buffer[SHA512_BLOCK_SIZE / sizeof(word64)];
} Sha512;
CYASSL_API int InitSha512(Sha512*);
CYASSL_API int Sha512Update(Sha512*, const byte*, word32);
CYASSL_API int Sha512Final(Sha512*, byte*);
CYASSL_API int Sha512Hash(const byte*, word32, byte*);
#if defined(CYASSL_SHA384) || defined(HAVE_AESGCM)
/* in bytes */
enum {
SHA384 = 5, /* hash type unique */
SHA384_BLOCK_SIZE = 128,
SHA384_DIGEST_SIZE = 48,
SHA384_PAD_SIZE = 112
};
/* Sha384 digest */
typedef struct Sha384 {
word32 buffLen; /* in bytes */
word32 loLen; /* length in bytes */
word32 hiLen; /* length in bytes */
word64 digest[SHA512_DIGEST_SIZE / sizeof(word64)]; /* for transform 512 */
word64 buffer[SHA384_BLOCK_SIZE / sizeof(word64)];
} Sha384;
CYASSL_API int InitSha384(Sha384*);
CYASSL_API int Sha384Update(Sha384*, const byte*, word32);
CYASSL_API int Sha384Final(Sha384*, byte*);
CYASSL_API int Sha384Hash(const byte*, word32, byte*);
#ifdef HAVE_FIPS #ifdef HAVE_FIPS
/* fips wrapper calls, user can call direct */ /* fips wrapper calls, user can call direct */
CYASSL_API int InitSha512_fips(Sha512*); WOLFSSL_API int wc_InitSha512_fips(Sha512*);
CYASSL_API int Sha512Update_fips(Sha512*, const byte*, word32); WOLFSSL_API int wc_Sha512Update_fips(Sha512*, const byte*, word32);
CYASSL_API int Sha512Final_fips(Sha512*, byte*); WOLFSSL_API int wc_Sha512Final_fips(Sha512*, byte*);
#ifndef FIPS_NO_WRAPPERS #ifndef FIPS_NO_WRAPPERS
/* if not impl or fips.c impl wrapper force fips calls if fips build */ /* if not impl or fips.c impl wrapper force fips calls if fips build */
#define InitSha512 InitSha512_fips #define InitSha512 InitSha512_fips
@@ -97,9 +75,9 @@ CYASSL_API int Sha384Hash(const byte*, word32, byte*);
#endif /* FIPS_NO_WRAPPERS */ #endif /* FIPS_NO_WRAPPERS */
/* fips wrapper calls, user can call direct */ /* fips wrapper calls, user can call direct */
CYASSL_API int InitSha384_fips(Sha384*); WOLFSSL_API int wc_InitSha384_fips(Sha384*);
CYASSL_API int Sha384Update_fips(Sha384*, const byte*, word32); WOLFSSL_API int wc_Sha384Update_fips(Sha384*, const byte*, word32);
CYASSL_API int Sha384Final_fips(Sha384*, byte*); WOLFSSL_API int wc_Sha384Final_fips(Sha384*, byte*);
#ifndef FIPS_NO_WRAPPERS #ifndef FIPS_NO_WRAPPERS
/* if not impl or fips.c impl wrapper force fips calls if fips build */ /* if not impl or fips.c impl wrapper force fips calls if fips build */
#define InitSha384 InitSha384_fips #define InitSha384 InitSha384_fips
@@ -110,11 +88,11 @@ CYASSL_API int Sha384Hash(const byte*, word32, byte*);
#endif /* HAVE_FIPS */ #endif /* HAVE_FIPS */
#endif /* CYASSL_SHA384 */ #endif /* WOLFSSL_SHA384 */
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */
#endif #endif
#endif /* CTAO_CRYPT_SHA512_H */ #endif /* WOLF_CRYPT_SHA512_H */
#endif /* CYASSL_SHA512 */ #endif /* WOLFSSL_SHA512 */

1351
wolfssl/wolfcrypt/tfm.h
View File

File diff suppressed because it is too large Load Diff