From 959386422e893aa21c6afbc0386584e6bb307750 Mon Sep 17 00:00:00 2001 From: Hayden Roche Date: Tue, 30 Aug 2022 14:28:09 -0700 Subject: [PATCH] Migrate async names from "test" to "software." See async PR 52. --- configure.ac | 19 +++++++-- wolfcrypt/src/aes.c | 80 ++++++++++++++++++------------------ wolfcrypt/src/des3.c | 28 ++++++------- wolfcrypt/src/dh.c | 38 ++++++++--------- wolfcrypt/src/ecc.c | 66 ++++++++++++++--------------- wolfcrypt/src/rsa.c | 38 ++++++++--------- wolfssl/wolfcrypt/settings.h | 12 +++--- 7 files changed, 147 insertions(+), 134 deletions(-) diff --git a/configure.ac b/configure.ac index 169548347..488e33a4c 100644 --- a/configure.ac +++ b/configure.ac @@ -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 diff --git a/wolfcrypt/src/aes.c b/wolfcrypt/src/aes.c index cc1055d43..97380894d 100644 --- a/wolfcrypt/src/aes.c +++ b/wolfcrypt/src/aes.c @@ -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 diff --git a/wolfcrypt/src/des3.c b/wolfcrypt/src/des3.c index 98945cc8f..e2753e46b 100644 --- a/wolfcrypt/src/des3.c +++ b/wolfcrypt/src/des3.c @@ -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 diff --git a/wolfcrypt/src/dh.c b/wolfcrypt/src/dh.c index 685691266..facc43245 100644 --- a/wolfcrypt/src/dh.c +++ b/wolfcrypt/src/dh.c @@ -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 diff --git a/wolfcrypt/src/ecc.c b/wolfcrypt/src/ecc.c index 4c3ed5eb0..de860fe2d 100644 --- a/wolfcrypt/src/ecc.c +++ b/wolfcrypt/src/ecc.c @@ -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; } } diff --git a/wolfcrypt/src/rsa.c b/wolfcrypt/src/rsa.c index 5c6425da3..6bbbc520c 100644 --- a/wolfcrypt/src/rsa.c +++ b/wolfcrypt/src/rsa.c @@ -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; } diff --git a/wolfssl/wolfcrypt/settings.h b/wolfssl/wolfcrypt/settings.h index b79f27021..25080fb70 100644 --- a/wolfssl/wolfcrypt/settings.h +++ b/wolfssl/wolfcrypt/settings.h @@ -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