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

adjustments to reverse compatibility

Browse Source
This commit is contained in:
Jacob Barthelmeh
2014-12-19 16:31:01 -07:00
parent 77f167790d
commit 279f149828
11 changed files with 234 additions and 478 deletions
Download Patch File Download Diff File Expand all files Collapse all files

147
ctaocrypt/benchmark/benchmark.c
View File

@@ -93,153 +93,6 @@
/* 4996 warning to use MS extensions e.g., strcpy_s instead of strncpy */ /* 4996 warning to use MS extensions e.g., strcpy_s instead of strncpy */
#pragma warning(disable: 4996) #pragma warning(disable: 4996)
#endif #endif
#include <wolfssl/wolfcrypt/settings.h>
#include <wolfssl/wolfcrypt/types.h>
#ifdef HAVE_CAVIUM
static void wc_Arc4CaviumSetKey(Arc4* arc4, const byte* key, word32 length);
static void wc_Arc4CaviumProcess(Arc4* arc4, byte* out, const byte* in,
word32 length);
#endif
void wc_Arc4SetKey(Arc4* arc4, const byte* key, word32 length)
{
word32 i;
word32 keyIndex = 0, stateIndex = 0;
#ifdef HAVE_CAVIUM
if (arc4->magic == WOLFSSL_ARC4_CAVIUM_MAGIC)
return wc_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 wc_Arc4Process(Arc4* arc4, byte* out, const byte* in, word32 length)
{
word32 x;
word32 y;
#ifdef HAVE_CAVIUM
if (arc4->magic == WOLFSSL_ARC4_CAVIUM_MAGIC)
return wc_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 wc_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 = WOLFSSL_ARC4_CAVIUM_MAGIC;
return 0;
}
/* Free Arc4 from use with Nitrox device */
void wc_Arc4FreeCavium(Arc4* arc4)
{
if (arc4 == NULL)
return;
if (arc4->magic != WOLFSSL_ARC4_CAVIUM_MAGIC)
return;
CspFreeContext(CONTEXT_SSL, arc4->contextHandle, arc4->devId);
arc4->magic = 0;
}
static void wc_Arc4CaviumSetKey(Arc4* arc4, const byte* key, word32 length)
{
word32 requestId;
if (CspInitializeRc4(CAVIUM_BLOCKING, arc4->contextHandle, length,
(byte*)key, &requestId, arc4->devId) != 0) {
WOLFSSL_MSG("Bad Cavium Arc4 Init");
}
}
static void wc_Arc4CaviumProcess(Arc4* arc4, byte* out, const byte* in,
word32 length)
{
cyassl_word offset = 0;
word32 requestId;
while (length > WOLFSSL_MAX_16BIT) {
word16 slen = (word16)WOLFSSL_MAX_16BIT;
if (CspEncryptRc4(CAVIUM_BLOCKING, arc4->contextHandle,CAVIUM_UPDATE,
slen, (byte*)in + offset, out + offset, &requestId,
arc4->devId) != 0) {
WOLFSSL_MSG("Bad Cavium Arc4 Encrypt");
}
length -= WOLFSSL_MAX_16BIT;
offset += WOLFSSL_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) {
WOLFSSL_MSG("Bad Cavium Arc4 Encrypt");
}
}
}
#endif /* HAVE_CAVIUM */
void bench_des(void); void bench_des(void);

324
cyassl/ctaocrypt/ecc.h
View File

@@ -24,167 +24,169 @@
#ifndef CTAO_CRYPT_ECC_H #ifndef CTAO_CRYPT_ECC_H
#define CTAO_CRYPT_ECC_H #define CTAO_CRYPT_ECC_H
#include <cyassl/ctaocrypt/types.h> #include <wolfssl/wolfcrypt/ecc.h>
#include <cyassl/ctaocrypt/integer.h> //
#include <cyassl/ctaocrypt/random.h> //#include <cyassl/ctaocrypt/types.h>
//#include <cyassl/ctaocrypt/integer.h>
#ifdef __cplusplus //#include <cyassl/ctaocrypt/random.h>
extern "C" { //
#endif //#ifdef __cplusplus
// extern "C" {
//#endif
enum { //
ECC_PUBLICKEY = 1, //
ECC_PRIVATEKEY = 2, //enum {
ECC_MAXNAME = 16, /* MAX CURVE NAME LENGTH */ // ECC_PUBLICKEY = 1,
SIG_HEADER_SZ = 6, /* ECC signature header size */ // ECC_PRIVATEKEY = 2,
ECC_BUFSIZE = 256, /* for exported keys temp buffer */ // ECC_MAXNAME = 16, /* MAX CURVE NAME LENGTH */
ECC_MINSIZE = 20, /* MIN Private Key size */ // SIG_HEADER_SZ = 6, /* ECC signature header size */
ECC_MAXSIZE = 66 /* MAX Private Key size */ // ECC_BUFSIZE = 256, /* for exported keys temp buffer */
}; // ECC_MINSIZE = 20, /* MIN Private Key size */
// ECC_MAXSIZE = 66 /* MAX Private Key size */
//};
/* ECC set type defined a NIST GF(p) curve */ //
typedef struct { //
int size; /* The size of the curve in octets */ ///* ECC set type defined a NIST GF(p) curve */
const char* name; /* name of this curve */ //typedef struct {
const char* prime; /* prime that defines the field, curve is in (hex) */ // int size; /* The size of the curve in octets */
const char* Af; /* fields A param (hex) */ // const char* name; /* name of this curve */
const char* Bf; /* fields B param (hex) */ // const char* prime; /* prime that defines the field, curve is in (hex) */
const char* order; /* order of the curve (hex) */ // const char* Af; /* fields A param (hex) */
const char* Gx; /* x coordinate of the base point on curve (hex) */ // const char* Bf; /* fields B param (hex) */
const char* Gy; /* y coordinate of the base point on curve (hex) */ // const char* order; /* order of the curve (hex) */
} ecc_set_type; // const char* Gx; /* x coordinate of the base point on curve (hex) */
// const char* Gy; /* y coordinate of the base point on curve (hex) */
//} ecc_set_type;
/* A point on an ECC curve, stored in Jacbobian format such that (x,y,z) => //
(x/z^2, y/z^3, 1) when interpreted as affine */ //
typedef struct { ///* A point on an ECC curve, stored in Jacbobian format such that (x,y,z) =>
mp_int x; /* The x coordinate */ // (x/z^2, y/z^3, 1) when interpreted as affine */
mp_int y; /* The y coordinate */ //typedef struct {
mp_int z; /* The z coordinate */ // mp_int x; /* The x coordinate */
} ecc_point; // mp_int y; /* The y coordinate */
// mp_int z; /* The z coordinate */
//} ecc_point;
/* An ECC Key */ //
typedef struct { //
int type; /* Public or Private */ ///* An ECC Key */
int idx; /* Index into the ecc_sets[] for the parameters of //typedef struct {
this curve if -1, this key is using user supplied // int type; /* Public or Private */
curve in dp */ // int idx; /* Index into the ecc_sets[] for the parameters of
const ecc_set_type* dp; /* domain parameters, either points to NIST // this curve if -1, this key is using user supplied
curves (idx >= 0) or user supplied */ // curve in dp */
ecc_point pubkey; /* public key */ // const ecc_set_type* dp; /* domain parameters, either points to NIST
mp_int k; /* private key */ // curves (idx >= 0) or user supplied */
} ecc_key; // ecc_point pubkey; /* public key */
// mp_int k; /* private key */
//} ecc_key;
/* ECC predefined curve sets */ //
extern const ecc_set_type ecc_sets[]; //
///* ECC predefined curve sets */
//extern const ecc_set_type ecc_sets[];
CYASSL_API //
int ecc_make_key(RNG* rng, int keysize, ecc_key* key); //
CYASSL_API //CYASSL_API
int ecc_shared_secret(ecc_key* private_key, ecc_key* public_key, byte* out, //int ecc_make_key(RNG* rng, int keysize, ecc_key* key);
word32* outlen); //CYASSL_API
CYASSL_API //int ecc_shared_secret(ecc_key* private_key, ecc_key* public_key, byte* out,
int ecc_sign_hash(const byte* in, word32 inlen, byte* out, word32 *outlen, // word32* outlen);
RNG* rng, ecc_key* key); //CYASSL_API
CYASSL_API //int ecc_sign_hash(const byte* in, word32 inlen, byte* out, word32 *outlen,
int ecc_verify_hash(const byte* sig, word32 siglen, const byte* hash, // RNG* rng, ecc_key* key);
word32 hashlen, int* stat, ecc_key* key); //CYASSL_API
CYASSL_API //int ecc_verify_hash(const byte* sig, word32 siglen, const byte* hash,
void ecc_init(ecc_key* key); // word32 hashlen, int* stat, ecc_key* key);
CYASSL_API //CYASSL_API
void ecc_free(ecc_key* key); //void ecc_init(ecc_key* key);
CYASSL_API //CYASSL_API
void ecc_fp_free(void); //void ecc_free(ecc_key* key);
//CYASSL_API
//void ecc_fp_free(void);
/* ASN key helpers */ //
CYASSL_API //
int ecc_export_x963(ecc_key*, byte* out, word32* outLen); ///* ASN key helpers */
CYASSL_API //CYASSL_API
int ecc_export_x963_ex(ecc_key*, byte* out, word32* outLen, int compressed); //int ecc_export_x963(ecc_key*, byte* out, word32* outLen);
/* extended functionality with compressed option */ //CYASSL_API
CYASSL_API //int ecc_export_x963_ex(ecc_key*, byte* out, word32* outLen, int compressed);
int ecc_import_x963(const byte* in, word32 inLen, ecc_key* key); // /* extended functionality with compressed option */
CYASSL_API //CYASSL_API
int ecc_import_private_key(const byte* priv, word32 privSz, const byte* pub, //int ecc_import_x963(const byte* in, word32 inLen, ecc_key* key);
word32 pubSz, ecc_key* key); //CYASSL_API
CYASSL_API //int ecc_import_private_key(const byte* priv, word32 privSz, const byte* pub,
int ecc_rs_to_sig(const char* r, const char* s, byte* out, word32* outlen); // word32 pubSz, ecc_key* key);
CYASSL_API //CYASSL_API
int ecc_import_raw(ecc_key* key, const char* qx, const char* qy, //int ecc_rs_to_sig(const char* r, const char* s, byte* out, word32* outlen);
const char* d, const char* curveName); //CYASSL_API
//int ecc_import_raw(ecc_key* key, const char* qx, const char* qy,
CYASSL_API // const char* d, const char* curveName);
int ecc_export_private_only(ecc_key* key, byte* out, word32* outLen); //
//CYASSL_API
/* size helper */ //int ecc_export_private_only(ecc_key* key, byte* out, word32* outLen);
CYASSL_API //
int ecc_size(ecc_key* key); ///* size helper */
CYASSL_API //CYASSL_API
int ecc_sig_size(ecc_key* key); //int ecc_size(ecc_key* key);
//CYASSL_API
//int ecc_sig_size(ecc_key* key);
#ifdef HAVE_ECC_ENCRYPT //
/* ecc encrypt */ //
//#ifdef HAVE_ECC_ENCRYPT
enum ecEncAlgo { ///* ecc encrypt */
ecAES_128_CBC = 1, /* default */ //
ecAES_256_CBC = 2 //enum ecEncAlgo {
}; // ecAES_128_CBC = 1, /* default */
// ecAES_256_CBC = 2
enum ecKdfAlgo { //};
ecHKDF_SHA256 = 1, /* default */ //
ecHKDF_SHA1 = 2 //enum ecKdfAlgo {
}; // ecHKDF_SHA256 = 1, /* default */
// ecHKDF_SHA1 = 2
enum ecMacAlgo { //};
ecHMAC_SHA256 = 1, /* default */ //
ecHMAC_SHA1 = 2 //enum ecMacAlgo {
}; // ecHMAC_SHA256 = 1, /* default */
// ecHMAC_SHA1 = 2
enum { //};
KEY_SIZE_128 = 16, //
KEY_SIZE_256 = 32, //enum {
IV_SIZE_64 = 8, // KEY_SIZE_128 = 16,
EXCHANGE_SALT_SZ = 16, // KEY_SIZE_256 = 32,
EXCHANGE_INFO_SZ = 23 // IV_SIZE_64 = 8,
}; // EXCHANGE_SALT_SZ = 16,
// EXCHANGE_INFO_SZ = 23
enum ecFlags { //};
REQ_RESP_CLIENT = 1, //
REQ_RESP_SERVER = 2 //enum ecFlags {
}; // REQ_RESP_CLIENT = 1,
// REQ_RESP_SERVER = 2
//};
typedef struct ecEncCtx ecEncCtx; //
//
CYASSL_API //typedef struct ecEncCtx ecEncCtx;
ecEncCtx* ecc_ctx_new(int flags, RNG* rng); //
CYASSL_API //CYASSL_API
void ecc_ctx_free(ecEncCtx*); //ecEncCtx* ecc_ctx_new(int flags, RNG* rng);
CYASSL_API //CYASSL_API
int ecc_ctx_reset(ecEncCtx*, RNG*); /* reset for use again w/o alloc/free */ //void ecc_ctx_free(ecEncCtx*);
//CYASSL_API
CYASSL_API //int ecc_ctx_reset(ecEncCtx*, RNG*); /* reset for use again w/o alloc/free */
const byte* ecc_ctx_get_own_salt(ecEncCtx*); //
CYASSL_API //CYASSL_API
int ecc_ctx_set_peer_salt(ecEncCtx*, const byte* salt); //const byte* ecc_ctx_get_own_salt(ecEncCtx*);
CYASSL_API //CYASSL_API
int ecc_ctx_set_info(ecEncCtx*, const byte* info, int sz); //int ecc_ctx_set_peer_salt(ecEncCtx*, const byte* salt);
//CYASSL_API
CYASSL_API //int ecc_ctx_set_info(ecEncCtx*, const byte* info, int sz);
int ecc_encrypt(ecc_key* privKey, ecc_key* pubKey, const byte* msg, //
word32 msgSz, byte* out, word32* outSz, ecEncCtx* ctx); //CYASSL_API
CYASSL_API //int ecc_encrypt(ecc_key* privKey, ecc_key* pubKey, const byte* msg,
int ecc_decrypt(ecc_key* privKey, ecc_key* pubKey, const byte* msg, // word32 msgSz, byte* out, word32* outSz, ecEncCtx* ctx);
word32 msgSz, byte* out, word32* outSz, ecEncCtx* ctx); //CYASSL_API
//int ecc_decrypt(ecc_key* privKey, ecc_key* pubKey, const byte* msg,
#endif /* HAVE_ECC_ENCRYPT */ // word32 msgSz, byte* out, word32* outSz, ecEncCtx* ctx);
//
//#endif /* HAVE_ECC_ENCRYPT */
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */

3
cyassl/ctaocrypt/visibility.h
View File

@@ -42,8 +42,7 @@
#ifdef CYASSL_DLL #ifdef CYASSL_DLL
#define CYASSL_API extern __declspec(dllexport) #define CYASSL_API extern __declspec(dllexport)
#else #else
//#define CYASSL_API #define CYASSL_API
#define CYASSL_API:
#endif #endif
#define CYASSL_LOCAL #define CYASSL_LOCAL
#else #else

43
cyassl/ssl.h
View File

@@ -386,8 +386,10 @@
#define CYASSL_SMALL_STACK #define CYASSL_SMALL_STACK
#endif #endif
/* change visibility to be compatible with CyaSSL visibility */
#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_ENTER(x) CYASSL_ENTER(x) /* @TODO*/
#define WOLFSSL_BIT_SIZE CYASSL_BIT_SIZE /* @TODO*/ #define WOLFSSL_BIT_SIZE CYASSL_BIT_SIZE /* @TODO*/
@@ -535,6 +537,47 @@
#endif #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
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */
#endif #endif

3
src/include.am
View File

@@ -179,8 +179,7 @@ src_libwolfssl_la_SOURCES += ctaocrypt/src/integer.c \
endif endif
if BUILD_ECC if BUILD_ECC
src_libwolfssl_la_SOURCES += ctaocrypt/src/ecc.c \ src_libwolfssl_la_SOURCES += wolfcrypt/src/ecc.c
wolfcrypt/src/ecc.c
endif endif
if BUILD_LIBZ if BUILD_LIBZ

151
wolfcrypt/benchmark/benchmark.c
View File

@@ -94,157 +94,6 @@
#pragma warning(disable: 4996) #pragma warning(disable: 4996)
#endif #endif
//#ifndef NO_RC4
//#include <wolfssl/wolfcrypt/settings.h>
//#include <wolfssl/wolfcrypt/types.h>
//#endif
//
//#ifdef HAVE_CAVIUM
// static void wc_wc_Arc4CaviumSetKey(Arc4* arc4, const byte* key, word32 length);
// static void wc_wc_Arc4CaviumProcess(Arc4* arc4, byte* out, const byte* in,
// word32 length);
//#endif
//
//
//void wc_wc_Arc4SetKey(Arc4* arc4, const byte* key, word32 length)
//{
// word32 i;
// word32 keyIndex = 0, stateIndex = 0;
//
//#ifdef HAVE_CAVIUM
// if (arc4->magic == WOLFSSL_ARC4_CAVIUM_MAGIC)
// return wc_wc_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 wc_wc_Arc4Process(Arc4* arc4, byte* out, const byte* in, word32 length)
//{
// word32 x;
// word32 y;
//
//#ifdef HAVE_CAVIUM
// if (arc4->magic == WOLFSSL_ARC4_CAVIUM_MAGIC)
// return wc_wc_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 wc_Arc4 for use with Nitrox device */
//int wc_wc_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 = WOLFSSL_ARC4_CAVIUM_MAGIC;
//
// return 0;
//}
//
//
///* Free wc_Arc4 from use with Nitrox device */
//void wc_wc_Arc4FreeCavium(Arc4* arc4)
//{
// if (arc4 == NULL)
// return;
//
// if (arc4->magic != WOLFSSL_ARC4_CAVIUM_MAGIC)
// return;
//
// CspFreeContext(CONTEXT_SSL, arc4->contextHandle, arc4->devId);
// arc4->magic = 0;
//}
//
//
//static void wc_wc_Arc4CaviumSetKey(Arc4* arc4, const byte* key, word32 length)
//{
// word32 requestId;
//
// if (CspInitializeRc4(CAVIUM_BLOCKING, arc4->contextHandle, length,
// (byte*)key, &requestId, arc4->devId) != 0) {
// WOLFSSL_MSG("Bad Cavium wc_Arc4 Init");
// }
//}
//
//
//static void wc_wc_Arc4CaviumProcess(Arc4* arc4, byte* out, const byte* in,
// word32 length)
//{
// cyassl_word offset = 0;
// word32 requestId;
//
// while (length > WOLFSSL_MAX_16BIT) {
// word16 slen = (word16)WOLFSSL_MAX_16BIT;
// if (CspEncryptRc4(CAVIUM_BLOCKING, arc4->contextHandle,CAVIUM_UPDATE,
// slen, (byte*)in + offset, out + offset, &requestId,
// arc4->devId) != 0) {
// WOLFSSL_MSG("Bad Cavium wc_Arc4 Encrypt");
// }
// length -= WOLFSSL_MAX_16BIT;
// offset += WOLFSSL_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) {
// WOLFSSL_MSG("Bad Cavium wc_Arc4 Encrypt");
// }
// }
//}
//
//#endif /* HAVE_CAVIUM */
void bench_des(void); void bench_des(void);
void bench_arc4(void); void bench_arc4(void);

12
wolfcrypt/src/chacha.c
View File

@@ -29,17 +29,17 @@
#include <config.h> #include <config.h>
#endif #endif
#include <cyassl/ctaocrypt/settings.h> #include <wolfssl/wolfcrypt/settings.h>
#ifdef HAVE_CHACHA #ifdef HAVE_CHACHA
#include <cyassl/ctaocrypt/chacha.h> #include <wolfssl/wolfcrypt/chacha.h>
#include <cyassl/ctaocrypt/error-crypt.h> #include <wolfssl/wolfcrypt/error-crypt.h>
#include <cyassl/ctaocrypt/logging.h> #include <wolfssl/wolfcrypt/logging.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
#ifdef CHACHA_AEAD_TEST #ifdef CHACHA_AEAD_TEST

2
wolfcrypt/src/ecc.c
View File

@@ -2221,7 +2221,7 @@ int wc_ecc_export_x963(ecc_key* key, byte* out, word32* outLen)
/* export public ECC key in ANSI X9.63 format, extended with /* export public ECC key in ANSI X9.63 format, extended with
* compression option */ * compression option */
int wc_wc_ecc_export_x963_ex(ecc_key* key, byte* out, word32* outLen, int compressed) int wc_ecc_export_x963_ex(ecc_key* key, byte* out, word32* outLen, int compressed)
{ {
if (compressed == 0) if (compressed == 0)
return wc_ecc_export_x963(key, out, outLen); return wc_ecc_export_x963(key, out, outLen);

12
wolfcrypt/src/poly1305.c
View File

@@ -26,16 +26,16 @@
#include <config.h> #include <config.h>
#endif #endif
#include <cyassl/ctaocrypt/settings.h> #include <wolfssl/wolfcrypt/settings.h>
#ifdef HAVE_POLY1305 #ifdef HAVE_POLY1305
#include <cyassl/ctaocrypt/poly1305.h> #include <wolfssl/wolfcrypt/poly1305.h>
#include <cyassl/ctaocrypt/error-crypt.h> #include <wolfssl/wolfcrypt/error-crypt.h>
#include <cyassl/ctaocrypt/logging.h> #include <wolfssl/wolfcrypt/logging.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
#ifdef CHACHA_AEAD_TEST #ifdef CHACHA_AEAD_TEST
#include <stdio.h> #include <stdio.h>

12
wolfssl/wolfcrypt/chacha.h
View File

@@ -47,6 +47,18 @@ WOLFSSL_API int wc_Chacha_SetKey(ChaCha* ctx, const byte* key, word32 keySz);
*/ */
WOLFSSL_API int wc_Chacha_SetIV(ChaCha* ctx, const byte* inIv, word32 counter); WOLFSSL_API int wc_Chacha_SetIV(ChaCha* ctx, const byte* inIv, word32 counter);
#ifdef __cplusplus
WOLFSSL_API int wc_Chacha_Process(ChaCha* ctx, byte* cipher, const byte* plain,
word32 msglen);
WOLFSSL_API int wc_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
*/
WOLFSSL_API int wc_Chacha_SetIV(ChaCha* ctx, const byte* inIv, word32 counter);
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */
#endif #endif

3
wolfssl/wolfcrypt/visibility.h
View File

@@ -42,8 +42,7 @@
#ifdef WOLFSSL_DLL #ifdef WOLFSSL_DLL
#define WOLFSSL_API extern __declspec(dllexport) #define WOLFSSL_API extern __declspec(dllexport)
#else #else
//#define WOLFSSL_API #define WOLFSSL_API
#define WOLFSSL_API:
#endif #endif
#define WOLFSSL_LOCAL #define WOLFSSL_LOCAL
#else #else