feedc0de/wolfssl
1
0
Fork 0
forked from wolfSSL/wolfssl
Code Pull Requests 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.])
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
AC_ARG_ENABLE([asynccrypt],
@ -6967,11 +6978,13 @@ if test "$ENABLED_ASYNCCRYPT" = "yes"
then
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 test "x$ENABLED_CAVIUM" = "xno" && test "x$ENABLED_INTEL_QA" = "xno"
# If no async backend (hardware or software) has been explicitly enabled,
# 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
# Async threading is Linux specific
AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_ASYNC_CRYPT_TEST"
AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_ASYNC_CRYPT_SW"
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,
(const byte*)aes->devKey, aes->keylen,
(byte*)aes->reg, AES_BLOCK_SIZE);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
if (wc_AsyncTestInit(&aes->asyncDev, ASYNC_TEST_AES_CBC_ENCRYPT)) {
WC_ASYNC_TEST* testDev = &aes->asyncDev.test;
testDev->aes.aes = aes;
testDev->aes.out = out;
testDev->aes.in = in;
testDev->aes.sz = sz;
#else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncSwInit(&aes->asyncDev, ASYNC_SW_AES_CBC_ENCRYPT)) {
WC_ASYNC_SW* sw = &aes->asyncDev.sw;
sw->aes.aes = aes;
sw->aes.out = out;
sw->aes.in = in;
sw->aes.sz = sz;
return WC_PENDING_E;
}
#endif
@ -4163,13 +4163,13 @@ int wc_AesSetIV(Aes* aes, const byte* iv)
return IntelQaSymAesCbcDecrypt(&aes->asyncDev, out, in, sz,
(const byte*)aes->devKey, aes->keylen,
(byte*)aes->reg, AES_BLOCK_SIZE);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
if (wc_AsyncTestInit(&aes->asyncDev, ASYNC_TEST_AES_CBC_DECRYPT)) {
WC_ASYNC_TEST* testDev = &aes->asyncDev.test;
testDev->aes.aes = aes;
testDev->aes.out = out;
testDev->aes.in = in;
testDev->aes.sz = sz;
#else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncSwInit(&aes->asyncDev, ASYNC_SW_AES_CBC_DECRYPT)) {
WC_ASYNC_SW* sw = &aes->asyncDev.sw;
sw->aes.aes = aes;
sw->aes.out = out;
sw->aes.in = in;
sw->aes.sz = sz;
return WC_PENDING_E;
}
#endif
@ -7825,19 +7825,19 @@ int wc_AesGcmEncrypt(Aes* aes, byte* out, const byte* in, word32 sz,
return IntelQaSymAesGcmEncrypt(&aes->asyncDev, out, in, sz,
(const byte*)aes->devKey, aes->keylen, iv, ivSz,
authTag, authTagSz, authIn, authInSz);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
if (wc_AsyncTestInit(&aes->asyncDev, ASYNC_TEST_AES_GCM_ENCRYPT)) {
WC_ASYNC_TEST* testDev = &aes->asyncDev.test;
testDev->aes.aes = aes;
testDev->aes.out = out;
testDev->aes.in = in;
testDev->aes.sz = sz;
testDev->aes.iv = iv;
testDev->aes.ivSz = ivSz;
testDev->aes.authTag = authTag;
testDev->aes.authTagSz = authTagSz;
testDev->aes.authIn = authIn;
testDev->aes.authInSz = authInSz;
#else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncSwInit(&aes->asyncDev, ASYNC_SW_AES_GCM_ENCRYPT)) {
WC_ASYNC_SW* sw = &aes->asyncDev.sw;
sw->aes.aes = aes;
sw->aes.out = out;
sw->aes.in = in;
sw->aes.sz = sz;
sw->aes.iv = iv;
sw->aes.ivSz = ivSz;
sw->aes.authTag = authTag;
sw->aes.authTagSz = authTagSz;
sw->aes.authIn = authIn;
sw->aes.authInSz = authInSz;
return WC_PENDING_E;
}
#endif
@ -8370,19 +8370,19 @@ int wc_AesGcmDecrypt(Aes* aes, byte* out, const byte* in, word32 sz,
return IntelQaSymAesGcmDecrypt(&aes->asyncDev, out, in, sz,
(const byte*)aes->devKey, aes->keylen, iv, ivSz,
authTag, authTagSz, authIn, authInSz);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
if (wc_AsyncTestInit(&aes->asyncDev, ASYNC_TEST_AES_GCM_DECRYPT)) {
WC_ASYNC_TEST* testDev = &aes->asyncDev.test;
testDev->aes.aes = aes;
testDev->aes.out = out;
testDev->aes.in = in;
testDev->aes.sz = sz;
testDev->aes.iv = iv;
testDev->aes.ivSz = ivSz;
testDev->aes.authTag = (byte*)authTag;
testDev->aes.authTagSz = authTagSz;
testDev->aes.authIn = authIn;
testDev->aes.authInSz = authInSz;
#else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncSwInit(&aes->asyncDev, ASYNC_SW_AES_GCM_DECRYPT)) {
WC_ASYNC_SW* sw = &aes->asyncDev.sw;
sw->aes.aes = aes;
sw->aes.out = out;
sw->aes.in = in;
sw->aes.sz = sz;
sw->aes.iv = iv;
sw->aes.ivSz = ivSz;
sw->aes.authTag = (byte*)authTag;
sw->aes.authTagSz = authTagSz;
sw->aes.authIn = authIn;
sw->aes.authInSz = authInSz;
return WC_PENDING_E;
}
#endif

28
wolfcrypt/src/des3.c
View File

@ -1703,13 +1703,13 @@
#elif defined(HAVE_INTEL_QA)
return IntelQaSymDes3CbcEncrypt(&des->asyncDev, out, in, sz,
(const byte*)des->devKey, DES3_KEYLEN, (byte*)des->reg, DES3_IVLEN);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
if (wc_AsyncTestInit(&des->asyncDev, ASYNC_TEST_DES3_CBC_ENCRYPT)) {
WC_ASYNC_TEST* testDev = &des->asyncDev.test;
testDev->des.des = des;
testDev->des.out = out;
testDev->des.in = in;
testDev->des.sz = sz;
#else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncSwInit(&des->asyncDev, ASYNC_SW_DES3_CBC_ENCRYPT)) {
WC_ASYNC_SW* sw = &des->asyncDev.sw;
sw->des.des = des;
sw->des.out = out;
sw->des.in = in;
sw->des.sz = sz;
return WC_PENDING_E;
}
#endif
@ -1754,13 +1754,13 @@
#elif defined(HAVE_INTEL_QA)
return IntelQaSymDes3CbcDecrypt(&des->asyncDev, out, in, sz,
(const byte*)des->devKey, DES3_KEYLEN, (byte*)des->reg, DES3_IVLEN);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
if (wc_AsyncTestInit(&des->asyncDev, ASYNC_TEST_DES3_CBC_DECRYPT)) {
WC_ASYNC_TEST* testDev = &des->asyncDev.test;
testDev->des.des = des;
testDev->des.out = out;
testDev->des.in = in;
testDev->des.sz = sz;
#else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncSwInit(&des->asyncDev, ASYNC_SW_DES3_CBC_DECRYPT)) {
WC_ASYNC_SW* sw = &des->asyncDev.sw;
sw->des.des = des;
sw->des.out = out;
sw->des.in = in;
sw->des.sz = sz;
return WC_PENDING_E;
}
#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)
/* TODO: Not implemented - use software for now */
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
if (wc_AsyncTestInit(&key->asyncDev, ASYNC_TEST_DH_GEN)) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test;
testDev->dhGen.key = key;
testDev->dhGen.rng = rng;
testDev->dhGen.priv = priv;
testDev->dhGen.privSz = privSz;
testDev->dhGen.pub = pub;
testDev->dhGen.pubSz = pubSz;
#else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncSwInit(&key->asyncDev, ASYNC_SW_DH_GEN)) {
WC_ASYNC_SW* sw = &key->asyncDev.sw;
sw->dhGen.key = key;
sw->dhGen.rng = rng;
sw->dhGen.priv = priv;
sw->dhGen.privSz = privSz;
sw->dhGen.pub = pub;
sw->dhGen.pubSz = pubSz;
return WC_PENDING_E;
}
#endif
@ -2184,16 +2184,16 @@ static int wc_DhAgree_Async(DhKey* key, byte* agree, word32* agreeSz,
#elif defined(HAVE_CAVIUM)
/* TODO: Not implemented - use software for now */
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
if (wc_AsyncTestInit(&key->asyncDev, ASYNC_TEST_DH_AGREE)) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test;
testDev->dhAgree.key = key;
testDev->dhAgree.agree = agree;
testDev->dhAgree.agreeSz = agreeSz;
testDev->dhAgree.priv = priv;
testDev->dhAgree.privSz = privSz;
testDev->dhAgree.otherPub = otherPub;
testDev->dhAgree.pubSz = pubSz;
#else /* WOLFSSL_ASYNC_CRYPT_SW */
if (wc_AsyncSwInit(&key->asyncDev, ASYNC_SW_DH_AGREE)) {
WC_ASYNC_SW* sw = &key->asyncDev.sw;
sw->dhAgree.key = key;
sw->dhAgree.agree = agree;
sw->dhAgree.agreeSz = agreeSz;
sw->dhAgree.priv = priv;
sw->dhAgree.privSz = privSz;
sw->dhAgree.otherPub = otherPub;
sw->dhAgree.pubSz = pubSz;
return WC_PENDING_E;
}
#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();
return err;
}
#elif defined(WOLFSSL_ASYNC_CRYPT_TEST)
if (wc_AsyncTestInit(&private_key->asyncDev, ASYNC_TEST_ECC_SHARED_SEC)) {
WC_ASYNC_TEST* testDev = &private_key->asyncDev.test;
testDev->eccSharedSec.private_key = private_key;
testDev->eccSharedSec.public_point = point;
testDev->eccSharedSec.out = out;
testDev->eccSharedSec.outLen = outlen;
#elif defined(WOLFSSL_ASYNC_CRYPT_SW)
if (wc_AsyncSwInit(&private_key->asyncDev, ASYNC_SW_ECC_SHARED_SEC)) {
WC_ASYNC_SW* sw = &private_key->asyncDev.sw;
sw->eccSharedSec.private_key = private_key;
sw->eccSharedSec.public_point = point;
sw->eccSharedSec.out = out;
sw->eccSharedSec.outLen = outlen;
wc_ecc_curve_free(curve);
FREE_CURVE_SPECS();
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)
/* Implemented in ecc_make_pub_ex for the pub calc */
#else
if (wc_AsyncTestInit(&key->asyncDev, ASYNC_TEST_ECC_MAKE)) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test;
testDev->eccMake.rng = rng;
testDev->eccMake.key = key;
testDev->eccMake.size = keysize;
testDev->eccMake.curve_id = curve_id;
if (wc_AsyncSwInit(&key->asyncDev, ASYNC_SW_ECC_MAKE)) {
WC_ASYNC_SW* sw = &key->asyncDev.sw;
sw->eccMake.rng = rng;
sw->eccMake.key = key;
sw->eccMake.size = keysize;
sw->eccMake.curve_id = curve_id;
return WC_PENDING_E;
}
#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 */
NitroxEccRsSplit(key, &r->raw, &s->raw);
#endif
#ifndef WOLFSSL_ASYNC_CRYPT_TEST
/* only do this if not simulator, since it overwrites result */
#ifndef WOLFSSL_ASYNC_CRYPT_SW
/* only do this if not software, since it overwrites result */
wc_bigint_to_mp(&r->raw, r);
wc_bigint_to_mp(&s->raw, s);
#endif
@ -6465,16 +6465,16 @@ int wc_ecc_sign_hash_ex(const byte* in, word32 inlen, WC_RNG* rng,
#endif
#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 (wc_AsyncTestInit(&key->asyncDev, ASYNC_TEST_ECC_SIGN)) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test;
testDev->eccSign.in = in;
testDev->eccSign.inSz = inlen;
testDev->eccSign.rng = rng;
testDev->eccSign.key = key;
testDev->eccSign.r = r;
testDev->eccSign.s = s;
if (wc_AsyncSwInit(&key->asyncDev, ASYNC_SW_ECC_SIGN)) {
WC_ASYNC_SW* sw = &key->asyncDev.sw;
sw->eccSign.in = in;
sw->eccSign.inSz = inlen;
sw->eccSign.rng = rng;
sw->eccSign.key = key;
sw->eccSign.r = r;
sw->eccSign.s = s;
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;
#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 (wc_AsyncTestInit(&key->asyncDev, ASYNC_TEST_ECC_VERIFY)) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test;
testDev->eccVerify.r = r;
testDev->eccVerify.s = s;
testDev->eccVerify.hash = hash;
testDev->eccVerify.hashlen = hashlen;
testDev->eccVerify.stat = res;
testDev->eccVerify.key = key;
if (wc_AsyncSwInit(&key->asyncDev, ASYNC_SW_ECC_VERIFY)) {
WC_ASYNC_SW* sw = &key->asyncDev.sw;
sw->eccVerify.r = r;
sw->eccVerify.s = s;
sw->eccVerify.hash = hash;
sw->eccVerify.hashlen = hashlen;
sw->eccVerify.stat = res;
sw->eccVerify.key = key;
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;
#ifdef WOLFSSL_ASYNC_CRYPT_TEST
if (wc_AsyncTestInit(&key->asyncDev, ASYNC_TEST_RSA_FUNC)) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test;
testDev->rsaFunc.in = in;
testDev->rsaFunc.inSz = inLen;
testDev->rsaFunc.out = out;
testDev->rsaFunc.outSz = outLen;
testDev->rsaFunc.type = type;
testDev->rsaFunc.key = key;
testDev->rsaFunc.rng = rng;
#ifdef WOLFSSL_ASYNC_CRYPT_SW
if (wc_AsyncSwInit(&key->asyncDev, ASYNC_SW_RSA_FUNC)) {
WC_ASYNC_SW* sw = &key->asyncDev.sw;
sw->rsaFunc.in = in;
sw->rsaFunc.inSz = inLen;
sw->rsaFunc.out = out;
sw->rsaFunc.outSz = outLen;
sw->rsaFunc.type = type;
sw->rsaFunc.key = key;
sw->rsaFunc.rng = rng;
return WC_PENDING_E;
}
#endif /* WOLFSSL_ASYNC_CRYPT_TEST */
#endif /* WOLFSSL_ASYNC_CRYPT_SW */
switch(type) {
#ifndef WOLFSSL_RSA_PUBLIC_ONLY
@ -2788,7 +2788,7 @@ static int wc_RsaFunctionAsync(const byte* in, word32 inLen, byte* out,
&key->u.raw,
out, outLen);
#endif
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
#else /* WOLFSSL_ASYNC_CRYPT_SW */
ret = wc_RsaFunctionSync(in, inLen, out, outLen, type, key, rng);
#endif
break;
@ -2806,7 +2806,7 @@ static int wc_RsaFunctionAsync(const byte* in, word32 inLen, byte* out,
ret = IntelQaRsaPublic(&key->asyncDev, in, inLen,
&key->e.raw, &key->n.raw,
out, outLen);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
#else /* WOLFSSL_ASYNC_CRYPT_SW */
ret = wc_RsaFunctionSync(in, inLen, out, outLen, type, key, rng);
#endif
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);
goto out;
#else
if (wc_AsyncTestInit(&key->asyncDev, ASYNC_TEST_RSA_MAKE)) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test;
testDev->rsaMake.rng = rng;
testDev->rsaMake.key = key;
testDev->rsaMake.size = size;
testDev->rsaMake.e = e;
if (wc_AsyncSwInit(&key->asyncDev, ASYNC_SW_RSA_MAKE)) {
WC_ASYNC_SW* sw = &key->asyncDev.sw;
sw->rsaMake.rng = rng;
sw->rsaMake.key = key;
sw->rsaMake.size = size;
sw->rsaMake.e = e;
err = WC_PENDING_E;
goto out;
}

12
wolfssl/wolfcrypt/settings.h
View File

@ -2241,21 +2241,21 @@ extern void uITRON4_free(void *p) ;
/* Asynchronous Crypto */
#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 */
#undef HAVE_WOLF_EVENT
#define HAVE_WOLF_EVENT
#ifdef WOLFSSL_ASYNC_CRYPT_TEST
#ifdef WOLFSSL_ASYNC_CRYPT_SW
#define WC_ASYNC_DEV_SIZE 168
#else
#define WC_ASYNC_DEV_SIZE 336
#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 */
#if !defined(ECC_CACHE_CURVE)
#define ECC_CACHE_CURVE