wolfSSL/wolfssl
1
0
Fork 1
mirror of https://github.com/wolfSSL/wolfssl.git synced 2025-08-02 12:14:38 +02:00
Code Issues Packages Projects Releases Wiki Activity

Migrate async names from "test" to "software."

Browse Source 
See async PR 52.
This commit is contained in:
Hayden Roche
2022-08-30 14:28:09 -07:00
parent ba8ffc765d
commit 959386422e
7 changed files with 147 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
configure.ac
View File

@@ -6955,6 +6955,17 @@ then
AC_MSG_ERROR([please use --with-libz if enabling mcapi.]) AC_MSG_ERROR([please use --with-libz if enabling mcapi.])
fi fi
# Asynchronous crypto using software (i.e. not hardware). Required for
# non-blocking crypto with TLS/DTLS.
AC_ARG_ENABLE([asynccrypt-sw],
[AS_HELP_STRING([--enable-asynccrypt-sw],[Enable asynchronous software-based crypto (default: disabled)])],
[ ENABLED_ASYNCCRYPT_SW=$enableval ],
[ ENABLED_ASYNCCRYPT_SW=no ]
)
if test "$ENABLED_ASYNCCRYPT_SW" = "yes"
then
AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_ASYNC_CRYPT_SW"
fi
# Asynchronous Crypto # Asynchronous Crypto
AC_ARG_ENABLE([asynccrypt], AC_ARG_ENABLE([asynccrypt],
@@ -6967,11 +6978,13 @@ if test "$ENABLED_ASYNCCRYPT" = "yes"
then then
AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_ASYNC_CRYPT -DHAVE_WOLF_EVENT -DHAVE_WOLF_BIGINT -DWOLFSSL_NO_HASH_RAW" AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_ASYNC_CRYPT -DHAVE_WOLF_EVENT -DHAVE_WOLF_BIGINT -DWOLFSSL_NO_HASH_RAW"
# if no async hardware then use simulator for testing # If no async backend (hardware or software) has been explicitly enabled,
if test "x$ENABLED_CAVIUM" = "xno" && test "x$ENABLED_INTEL_QA" = "xno" # use the software backend for testing.
if test "x$ENABLED_CAVIUM" = "xno" && test "x$ENABLED_INTEL_QA" = "xno" &&
test "x$ENABLED_ASYNCCRYPT_SW" = "xno"
then then
# Async threading is Linux specific # Async threading is Linux specific
AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_ASYNC_CRYPT_TEST" AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_ASYNC_CRYPT_SW"
fi fi
fi fi

80
wolfcrypt/src/aes.c
View File

@@ -4038,13 +4038,13 @@ int wc_AesSetIV(Aes* aes, const byte* iv)
return IntelQaSymAesCbcEncrypt(&aes->asyncDev, out, in, sz, return IntelQaSymAesCbcEncrypt(&aes->asyncDev, out, in, sz,
(const byte*)aes->devKey, aes->keylen, (const byte*)aes->devKey, aes->keylen,
(byte*)aes->reg, AES_BLOCK_SIZE); (byte*)aes->reg, AES_BLOCK_SIZE);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */ #else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncTestInit(&aes->asyncDev, ASYNC_TEST_AES_CBC_ENCRYPT)) { if (wc_AsyncSwInit(&aes->asyncDev, ASYNC_SW_AES_CBC_ENCRYPT)) {
WC_ASYNC_TEST* testDev = &aes->asyncDev.test; WC_ASYNC_SW* sw = &aes->asyncDev.sw;
testDev->aes.aes = aes; sw->aes.aes = aes;
testDev->aes.out = out; sw->aes.out = out;
testDev->aes.in = in; sw->aes.in = in;
testDev->aes.sz = sz; sw->aes.sz = sz;
return WC_PENDING_E; return WC_PENDING_E;
} }
#endif #endif
@@ -4163,13 +4163,13 @@ int wc_AesSetIV(Aes* aes, const byte* iv)
return IntelQaSymAesCbcDecrypt(&aes->asyncDev, out, in, sz, return IntelQaSymAesCbcDecrypt(&aes->asyncDev, out, in, sz,
(const byte*)aes->devKey, aes->keylen, (const byte*)aes->devKey, aes->keylen,
(byte*)aes->reg, AES_BLOCK_SIZE); (byte*)aes->reg, AES_BLOCK_SIZE);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */ #else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncTestInit(&aes->asyncDev, ASYNC_TEST_AES_CBC_DECRYPT)) { if (wc_AsyncSwInit(&aes->asyncDev, ASYNC_SW_AES_CBC_DECRYPT)) {
WC_ASYNC_TEST* testDev = &aes->asyncDev.test; WC_ASYNC_SW* sw = &aes->asyncDev.sw;
testDev->aes.aes = aes; sw->aes.aes = aes;
testDev->aes.out = out; sw->aes.out = out;
testDev->aes.in = in; sw->aes.in = in;
testDev->aes.sz = sz; sw->aes.sz = sz;
return WC_PENDING_E; return WC_PENDING_E;
} }
#endif #endif
@@ -7825,19 +7825,19 @@ int wc_AesGcmEncrypt(Aes* aes, byte* out, const byte* in, word32 sz,
return IntelQaSymAesGcmEncrypt(&aes->asyncDev, out, in, sz, return IntelQaSymAesGcmEncrypt(&aes->asyncDev, out, in, sz,
(const byte*)aes->devKey, aes->keylen, iv, ivSz, (const byte*)aes->devKey, aes->keylen, iv, ivSz,
authTag, authTagSz, authIn, authInSz); authTag, authTagSz, authIn, authInSz);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */ #else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncTestInit(&aes->asyncDev, ASYNC_TEST_AES_GCM_ENCRYPT)) { if (wc_AsyncSwInit(&aes->asyncDev, ASYNC_SW_AES_GCM_ENCRYPT)) {
WC_ASYNC_TEST* testDev = &aes->asyncDev.test; WC_ASYNC_SW* sw = &aes->asyncDev.sw;
testDev->aes.aes = aes; sw->aes.aes = aes;
testDev->aes.out = out; sw->aes.out = out;
testDev->aes.in = in; sw->aes.in = in;
testDev->aes.sz = sz; sw->aes.sz = sz;
testDev->aes.iv = iv; sw->aes.iv = iv;
testDev->aes.ivSz = ivSz; sw->aes.ivSz = ivSz;
testDev->aes.authTag = authTag; sw->aes.authTag = authTag;
testDev->aes.authTagSz = authTagSz; sw->aes.authTagSz = authTagSz;
testDev->aes.authIn = authIn; sw->aes.authIn = authIn;
testDev->aes.authInSz = authInSz; sw->aes.authInSz = authInSz;
return WC_PENDING_E; return WC_PENDING_E;
} }
#endif #endif
@@ -8370,19 +8370,19 @@ int wc_AesGcmDecrypt(Aes* aes, byte* out, const byte* in, word32 sz,
return IntelQaSymAesGcmDecrypt(&aes->asyncDev, out, in, sz, return IntelQaSymAesGcmDecrypt(&aes->asyncDev, out, in, sz,
(const byte*)aes->devKey, aes->keylen, iv, ivSz, (const byte*)aes->devKey, aes->keylen, iv, ivSz,
authTag, authTagSz, authIn, authInSz); authTag, authTagSz, authIn, authInSz);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */ #else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncTestInit(&aes->asyncDev, ASYNC_TEST_AES_GCM_DECRYPT)) { if (wc_AsyncSwInit(&aes->asyncDev, ASYNC_SW_AES_GCM_DECRYPT)) {
WC_ASYNC_TEST* testDev = &aes->asyncDev.test; WC_ASYNC_SW* sw = &aes->asyncDev.sw;
testDev->aes.aes = aes; sw->aes.aes = aes;
testDev->aes.out = out; sw->aes.out = out;
testDev->aes.in = in; sw->aes.in = in;
testDev->aes.sz = sz; sw->aes.sz = sz;
testDev->aes.iv = iv; sw->aes.iv = iv;
testDev->aes.ivSz = ivSz; sw->aes.ivSz = ivSz;
testDev->aes.authTag = (byte*)authTag; sw->aes.authTag = (byte*)authTag;
testDev->aes.authTagSz = authTagSz; sw->aes.authTagSz = authTagSz;
testDev->aes.authIn = authIn; sw->aes.authIn = authIn;
testDev->aes.authInSz = authInSz; sw->aes.authInSz = authInSz;
return WC_PENDING_E; return WC_PENDING_E;
} }
#endif #endif

28
wolfcrypt/src/des3.c
View File

@@ -1703,13 +1703,13 @@
#elif defined(HAVE_INTEL_QA) #elif defined(HAVE_INTEL_QA)
return IntelQaSymDes3CbcEncrypt(&des->asyncDev, out, in, sz, return IntelQaSymDes3CbcEncrypt(&des->asyncDev, out, in, sz,
(const byte*)des->devKey, DES3_KEYLEN, (byte*)des->reg, DES3_IVLEN); (const byte*)des->devKey, DES3_KEYLEN, (byte*)des->reg, DES3_IVLEN);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */ #else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncTestInit(&des->asyncDev, ASYNC_TEST_DES3_CBC_ENCRYPT)) { if (wc_AsyncSwInit(&des->asyncDev, ASYNC_SW_DES3_CBC_ENCRYPT)) {
WC_ASYNC_TEST* testDev = &des->asyncDev.test; WC_ASYNC_SW* sw = &des->asyncDev.sw;
testDev->des.des = des; sw->des.des = des;
testDev->des.out = out; sw->des.out = out;
testDev->des.in = in; sw->des.in = in;
testDev->des.sz = sz; sw->des.sz = sz;
return WC_PENDING_E; return WC_PENDING_E;
} }
#endif #endif
@@ -1754,13 +1754,13 @@
#elif defined(HAVE_INTEL_QA) #elif defined(HAVE_INTEL_QA)
return IntelQaSymDes3CbcDecrypt(&des->asyncDev, out, in, sz, return IntelQaSymDes3CbcDecrypt(&des->asyncDev, out, in, sz,
(const byte*)des->devKey, DES3_KEYLEN, (byte*)des->reg, DES3_IVLEN); (const byte*)des->devKey, DES3_KEYLEN, (byte*)des->reg, DES3_IVLEN);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */ #else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncTestInit(&des->asyncDev, ASYNC_TEST_DES3_CBC_DECRYPT)) { if (wc_AsyncSwInit(&des->asyncDev, ASYNC_SW_DES3_CBC_DECRYPT)) {
WC_ASYNC_TEST* testDev = &des->asyncDev.test; WC_ASYNC_SW* sw = &des->asyncDev.sw;
testDev->des.des = des; sw->des.des = des;
testDev->des.out = out; sw->des.out = out;
testDev->des.in = in; sw->des.in = in;
testDev->des.sz = sz; sw->des.sz = sz;
return WC_PENDING_E; return WC_PENDING_E;
} }
#endif #endif

38
wolfcrypt/src/dh.c
View File

@@ -1431,15 +1431,15 @@ static int wc_DhGenerateKeyPair_Async(DhKey* key, WC_RNG* rng,
#elif defined(HAVE_CAVIUM) #elif defined(HAVE_CAVIUM)
/* TODO: Not implemented - use software for now */ /* TODO: Not implemented - use software for now */
#else /* WOLFSSL_ASYNC_CRYPT_TEST */ #else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncTestInit(&key->asyncDev, ASYNC_TEST_DH_GEN)) { if (wc_AsyncSwInit(&key->asyncDev, ASYNC_SW_DH_GEN)) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test; WC_ASYNC_SW* sw = &key->asyncDev.sw;
testDev->dhGen.key = key; sw->dhGen.key = key;
testDev->dhGen.rng = rng; sw->dhGen.rng = rng;
testDev->dhGen.priv = priv; sw->dhGen.priv = priv;
testDev->dhGen.privSz = privSz; sw->dhGen.privSz = privSz;
testDev->dhGen.pub = pub; sw->dhGen.pub = pub;
testDev->dhGen.pubSz = pubSz; sw->dhGen.pubSz = pubSz;
return WC_PENDING_E; return WC_PENDING_E;
} }
#endif #endif
@@ -2184,16 +2184,16 @@ static int wc_DhAgree_Async(DhKey* key, byte* agree, word32* agreeSz,
#elif defined(HAVE_CAVIUM) #elif defined(HAVE_CAVIUM)
/* TODO: Not implemented - use software for now */ /* TODO: Not implemented - use software for now */
#else /* WOLFSSL_ASYNC_CRYPT_TEST */ #else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncTestInit(&key->asyncDev, ASYNC_TEST_DH_AGREE)) { if (wc_AsyncSwInit(&key->asyncDev, ASYNC_SW_DH_AGREE)) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test; WC_ASYNC_SW* sw = &key->asyncDev.sw;
testDev->dhAgree.key = key; sw->dhAgree.key = key;
testDev->dhAgree.agree = agree; sw->dhAgree.agree = agree;
testDev->dhAgree.agreeSz = agreeSz; sw->dhAgree.agreeSz = agreeSz;
testDev->dhAgree.priv = priv; sw->dhAgree.priv = priv;
testDev->dhAgree.privSz = privSz; sw->dhAgree.privSz = privSz;
testDev->dhAgree.otherPub = otherPub; sw->dhAgree.otherPub = otherPub;
testDev->dhAgree.pubSz = pubSz; sw->dhAgree.pubSz = pubSz;
return WC_PENDING_E; return WC_PENDING_E;
} }
#endif #endif

66
wolfcrypt/src/ecc.c
View File

@@ -4609,13 +4609,13 @@ static int wc_ecc_shared_secret_gen_async(ecc_key* private_key,
FREE_CURVE_SPECS(); FREE_CURVE_SPECS();
return err; return err;
} }
#elif defined(WOLFSSL_ASYNC_CRYPT_TEST) #elif defined(WOLFSSL_ASYNC_CRYPT_SW)
if (wc_AsyncTestInit(&private_key->asyncDev, ASYNC_TEST_ECC_SHARED_SEC)) { if (wc_AsyncSwInit(&private_key->asyncDev, ASYNC_SW_ECC_SHARED_SEC)) {
WC_ASYNC_TEST* testDev = &private_key->asyncDev.test; WC_ASYNC_SW* sw = &private_key->asyncDev.sw;
testDev->eccSharedSec.private_key = private_key; sw->eccSharedSec.private_key = private_key;
testDev->eccSharedSec.public_point = point; sw->eccSharedSec.public_point = point;
testDev->eccSharedSec.out = out; sw->eccSharedSec.out = out;
testDev->eccSharedSec.outLen = outlen; sw->eccSharedSec.outLen = outlen;
wc_ecc_curve_free(curve); wc_ecc_curve_free(curve);
FREE_CURVE_SPECS(); FREE_CURVE_SPECS();
return WC_PENDING_E; return WC_PENDING_E;
@@ -5188,12 +5188,12 @@ static int _ecc_make_key_ex(WC_RNG* rng, int keysize, ecc_key* key,
#elif defined(HAVE_INTEL_QA) #elif defined(HAVE_INTEL_QA)
/* Implemented in ecc_make_pub_ex for the pub calc */ /* Implemented in ecc_make_pub_ex for the pub calc */
#else #else
if (wc_AsyncTestInit(&key->asyncDev, ASYNC_TEST_ECC_MAKE)) { if (wc_AsyncSwInit(&key->asyncDev, ASYNC_SW_ECC_MAKE)) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test; WC_ASYNC_SW* sw = &key->asyncDev.sw;
testDev->eccMake.rng = rng; sw->eccMake.rng = rng;
testDev->eccMake.key = key; sw->eccMake.key = key;
testDev->eccMake.size = keysize; sw->eccMake.size = keysize;
testDev->eccMake.curve_id = curve_id; sw->eccMake.curve_id = curve_id;
return WC_PENDING_E; return WC_PENDING_E;
} }
#endif #endif
@@ -5903,8 +5903,8 @@ static int wc_ecc_sign_hash_async(const byte* in, word32 inlen, byte* out,
/* Nitrox requires r and s in sep buffer, so split it */ /* Nitrox requires r and s in sep buffer, so split it */
NitroxEccRsSplit(key, &r->raw, &s->raw); NitroxEccRsSplit(key, &r->raw, &s->raw);
#endif #endif
#ifndef WOLFSSL_ASYNC_CRYPT_TEST #ifndef WOLFSSL_ASYNC_CRYPT_SW
/* only do this if not simulator, since it overwrites result */ /* only do this if not software, since it overwrites result */
wc_bigint_to_mp(&r->raw, r); wc_bigint_to_mp(&r->raw, r);
wc_bigint_to_mp(&s->raw, s); wc_bigint_to_mp(&s->raw, s);
#endif #endif
@@ -6465,16 +6465,16 @@ int wc_ecc_sign_hash_ex(const byte* in, word32 inlen, WC_RNG* rng,
#endif #endif
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_ECC) && \ #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_ECC) && \
defined(WOLFSSL_ASYNC_CRYPT_TEST) defined(WOLFSSL_ASYNC_CRYPT_SW)
if (key->asyncDev.marker == WOLFSSL_ASYNC_MARKER_ECC) { if (key->asyncDev.marker == WOLFSSL_ASYNC_MARKER_ECC) {
if (wc_AsyncTestInit(&key->asyncDev, ASYNC_TEST_ECC_SIGN)) { if (wc_AsyncSwInit(&key->asyncDev, ASYNC_SW_ECC_SIGN)) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test; WC_ASYNC_SW* sw = &key->asyncDev.sw;
testDev->eccSign.in = in; sw->eccSign.in = in;
testDev->eccSign.inSz = inlen; sw->eccSign.inSz = inlen;
testDev->eccSign.rng = rng; sw->eccSign.rng = rng;
testDev->eccSign.key = key; sw->eccSign.key = key;
testDev->eccSign.r = r; sw->eccSign.r = r;
testDev->eccSign.s = s; sw->eccSign.s = s;
return WC_PENDING_E; return WC_PENDING_E;
} }
} }
@@ -7851,16 +7851,16 @@ int wc_ecc_verify_hash_ex(mp_int *r, mp_int *s, const byte* hash,
keySz = key->dp->size; keySz = key->dp->size;
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_ECC) && \ #if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_ECC) && \
defined(WOLFSSL_ASYNC_CRYPT_TEST) defined(WOLFSSL_ASYNC_CRYPT_SW)
if (key->asyncDev.marker == WOLFSSL_ASYNC_MARKER_ECC) { if (key->asyncDev.marker == WOLFSSL_ASYNC_MARKER_ECC) {
if (wc_AsyncTestInit(&key->asyncDev, ASYNC_TEST_ECC_VERIFY)) { if (wc_AsyncSwInit(&key->asyncDev, ASYNC_SW_ECC_VERIFY)) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test; WC_ASYNC_SW* sw = &key->asyncDev.sw;
testDev->eccVerify.r = r; sw->eccVerify.r = r;
testDev->eccVerify.s = s; sw->eccVerify.s = s;
testDev->eccVerify.hash = hash; sw->eccVerify.hash = hash;
testDev->eccVerify.hashlen = hashlen; sw->eccVerify.hashlen = hashlen;
testDev->eccVerify.stat = res; sw->eccVerify.stat = res;
testDev->eccVerify.key = key; sw->eccVerify.key = key;
return WC_PENDING_E; return WC_PENDING_E;
} }
} }

38
wolfcrypt/src/rsa.c
View File

@@ -2752,19 +2752,19 @@ static int wc_RsaFunctionAsync(const byte* in, word32 inLen, byte* out,
(void)rng; (void)rng;
#ifdef WOLFSSL_ASYNC_CRYPT_TEST #ifdef WOLFSSL_ASYNC_CRYPT_SW
if (wc_AsyncTestInit(&key->asyncDev, ASYNC_TEST_RSA_FUNC)) { if (wc_AsyncSwInit(&key->asyncDev, ASYNC_SW_RSA_FUNC)) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test; WC_ASYNC_SW* sw = &key->asyncDev.sw;
testDev->rsaFunc.in = in; sw->rsaFunc.in = in;
testDev->rsaFunc.inSz = inLen; sw->rsaFunc.inSz = inLen;
testDev->rsaFunc.out = out; sw->rsaFunc.out = out;
testDev->rsaFunc.outSz = outLen; sw->rsaFunc.outSz = outLen;
testDev->rsaFunc.type = type; sw->rsaFunc.type = type;
testDev->rsaFunc.key = key; sw->rsaFunc.key = key;
testDev->rsaFunc.rng = rng; sw->rsaFunc.rng = rng;
return WC_PENDING_E; return WC_PENDING_E;
} }
#endif /* WOLFSSL_ASYNC_CRYPT_TEST */ #endif /* WOLFSSL_ASYNC_CRYPT_SW */
switch(type) { switch(type) {
#ifndef WOLFSSL_RSA_PUBLIC_ONLY #ifndef WOLFSSL_RSA_PUBLIC_ONLY
@@ -2788,7 +2788,7 @@ static int wc_RsaFunctionAsync(const byte* in, word32 inLen, byte* out,
&key->u.raw, &key->u.raw,
out, outLen); out, outLen);
#endif #endif
#else /* WOLFSSL_ASYNC_CRYPT_TEST */ #else /* WOLFSSL_ASYNC_CRYPT_SW */
ret = wc_RsaFunctionSync(in, inLen, out, outLen, type, key, rng); ret = wc_RsaFunctionSync(in, inLen, out, outLen, type, key, rng);
#endif #endif
break; break;
@@ -2806,7 +2806,7 @@ static int wc_RsaFunctionAsync(const byte* in, word32 inLen, byte* out,
ret = IntelQaRsaPublic(&key->asyncDev, in, inLen, ret = IntelQaRsaPublic(&key->asyncDev, in, inLen,
&key->e.raw, &key->n.raw, &key->e.raw, &key->n.raw,
out, outLen); out, outLen);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */ #else /* WOLFSSL_ASYNC_CRYPT_SW */
ret = wc_RsaFunctionSync(in, inLen, out, outLen, type, key, rng); ret = wc_RsaFunctionSync(in, inLen, out, outLen, type, key, rng);
#endif #endif
break; break;
@@ -4647,12 +4647,12 @@ int wc_MakeRsaKey(RsaKey* key, int size, long e, WC_RNG* rng)
err = IntelQaRsaKeyGen(&key->asyncDev, key, size, e, rng); err = IntelQaRsaKeyGen(&key->asyncDev, key, size, e, rng);
goto out; goto out;
#else #else
if (wc_AsyncTestInit(&key->asyncDev, ASYNC_TEST_RSA_MAKE)) { if (wc_AsyncSwInit(&key->asyncDev, ASYNC_SW_RSA_MAKE)) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test; WC_ASYNC_SW* sw = &key->asyncDev.sw;
testDev->rsaMake.rng = rng; sw->rsaMake.rng = rng;
testDev->rsaMake.key = key; sw->rsaMake.key = key;
testDev->rsaMake.size = size; sw->rsaMake.size = size;
testDev->rsaMake.e = e; sw->rsaMake.e = e;
err = WC_PENDING_E; err = WC_PENDING_E;
goto out; goto out;
} }

12
wolfssl/wolfcrypt/settings.h
View File

@@ -2241,21 +2241,21 @@ extern void uITRON4_free(void *p) ;
/* Asynchronous Crypto */ /* Asynchronous Crypto */
#ifdef WOLFSSL_ASYNC_CRYPT #ifdef WOLFSSL_ASYNC_CRYPT
#if !defined(HAVE_CAVIUM) && !defined(HAVE_INTEL_QA) && \
!defined(WOLFSSL_ASYNC_CRYPT_SW)
#error No async backend defined with WOLFSSL_ASYNC_CRYPT!
#endif
/* Make sure wolf events are enabled */ /* Make sure wolf events are enabled */
#undef HAVE_WOLF_EVENT #undef HAVE_WOLF_EVENT
#define HAVE_WOLF_EVENT #define HAVE_WOLF_EVENT
#ifdef WOLFSSL_ASYNC_CRYPT_TEST #ifdef WOLFSSL_ASYNC_CRYPT_SW
#define WC_ASYNC_DEV_SIZE 168 #define WC_ASYNC_DEV_SIZE 168
#else #else
#define WC_ASYNC_DEV_SIZE 336 #define WC_ASYNC_DEV_SIZE 336
#endif #endif
#if !defined(HAVE_CAVIUM) && !defined(HAVE_INTEL_QA) && \
!defined(WOLFSSL_ASYNC_CRYPT_TEST)
#error No async hardware defined with WOLFSSL_ASYNC_CRYPT!
#endif
/* Enable ECC_CACHE_CURVE for ASYNC */ /* Enable ECC_CACHE_CURVE for ASYNC */
#if !defined(ECC_CACHE_CURVE) #if !defined(ECC_CACHE_CURVE)
#define ECC_CACHE_CURVE #define ECC_CACHE_CURVE