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

Merge pull request #1101 from dgarske/fix_bench_async

Browse Source 
Fixes for async multi-threading
This commit is contained in:
toddouska
2017-08-16 10:15:55 -07:00
committed by GitHub
parent ad4849d692 1f80fb952f
commit 53e05786da
17 changed files with 846 additions and 744 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
configure.ac
View File

@@ -213,6 +213,8 @@ then
enable_aeskeywrap=yes
enable_x963kdf=yes
enable_scrypt=yes
AM_CFLAGS="-DHAVE_AES_DECRYPT $AM_CFLAGS"
fi
AM_CONDITIONAL([BUILD_ALL], [test "x$ENABLED_ALL" = "xyes"])

414
src/internal.c
View File

@@ -3038,6 +3038,13 @@ int RsaSign(WOLFSSL* ssl, const byte* in, word32 inSz, byte* out,
WOLFSSL_ENTER("RsaSign");
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
return ret;
#endif
#if defined(WC_RSA_PSS)
if (sigAlgo == rsa_pss_sa_algo) {
enum wc_HashType hashType = WC_HASH_TYPE_NONE;
@@ -3072,9 +3079,9 @@ int RsaSign(WOLFSSL* ssl, const byte* in, word32 inSz, byte* out,
ret = wc_RsaSSL_Sign(in, inSz, out, *outSz, key, ssl->rng);
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev);
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -3104,6 +3111,13 @@ int RsaVerify(WOLFSSL* ssl, byte* in, word32 inSz, byte** out, int sigAlgo,
WOLFSSL_ENTER("RsaVerify");
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
return ret;
#endif
#if defined(WC_RSA_PSS)
if (sigAlgo == rsa_pss_sa_algo) {
enum wc_HashType hashType = WC_HASH_TYPE_NONE;
@@ -3135,9 +3149,9 @@ int RsaVerify(WOLFSSL* ssl, byte* in, word32 inSz, byte** out, int sigAlgo,
}
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev);
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -3168,6 +3182,13 @@ int VerifyRsaSign(WOLFSSL* ssl, byte* verifySig, word32 sigSz,
return BUFFER_E;
}
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
return ret;
#endif
#if defined(WC_RSA_PSS)
if (sigAlgo == rsa_pss_sa_algo) {
enum wc_HashType hashType = WC_HASH_TYPE_NONE;
@@ -3200,9 +3221,9 @@ int VerifyRsaSign(WOLFSSL* ssl, byte* verifySig, word32 sigSz,
}
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev);
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -3223,6 +3244,13 @@ int RsaDec(WOLFSSL* ssl, byte* in, word32 inSz, byte** out, word32* outSz,
WOLFSSL_ENTER("RsaDec");
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
return ret;
#endif
#ifdef HAVE_PK_CALLBACKS
if (ssl->ctx->RsaDecCb) {
ret = ssl->ctx->RsaDecCb(ssl, in, inSz, out, keyBuf, keySz,
@@ -3240,9 +3268,9 @@ int RsaDec(WOLFSSL* ssl, byte* in, word32 inSz, byte** out, word32* outSz,
}
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev);
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -3269,6 +3297,13 @@ int RsaEnc(WOLFSSL* ssl, const byte* in, word32 inSz, byte* out, word32* outSz,
WOLFSSL_ENTER("RsaEnc");
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
return ret;
#endif
#ifdef HAVE_PK_CALLBACKS
if (ssl->ctx->RsaEncCb) {
ret = ssl->ctx->RsaEncCb(ssl, in, inSz, out, outSz, keyBuf, keySz,
@@ -3281,9 +3316,9 @@ int RsaEnc(WOLFSSL* ssl, const byte* in, word32 inSz, byte* out, word32* outSz,
}
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev);
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -3314,6 +3349,13 @@ int EccSign(WOLFSSL* ssl, const byte* in, word32 inSz, byte* out,
WOLFSSL_ENTER("EccSign");
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
return ret;
#endif
#if defined(HAVE_PK_CALLBACKS)
if (ssl->ctx->EccSignCb) {
ret = ssl->ctx->EccSignCb(ssl, in, inSz, out, outSz, keyBuf,
@@ -3326,9 +3368,9 @@ int EccSign(WOLFSSL* ssl, const byte* in, word32 inSz, byte* out,
}
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev);
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -3350,6 +3392,13 @@ int EccVerify(WOLFSSL* ssl, const byte* in, word32 inSz, const byte* out,
WOLFSSL_ENTER("EccVerify");
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
return ret;
#endif
#ifdef HAVE_PK_CALLBACKS
if (ssl->ctx->EccVerifyCb) {
ret = ssl->ctx->EccVerifyCb(ssl, in, inSz, out, outSz, keyBuf, keySz,
@@ -3362,9 +3411,9 @@ int EccVerify(WOLFSSL* ssl, const byte* in, word32 inSz, const byte* out,
}
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev);
}
else
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -3436,9 +3485,13 @@ int EccSharedSecret(WOLFSSL* ssl, ecc_key* priv_key, ecc_key* pub_key,
int side, void* ctx)
{
int ret;
#ifdef WOLFSSL_ASYNC_CRYPT
WC_ASYNC_DEV* asyncDev;
#ifdef HAVE_PK_CALLBACKS
ecc_key* otherKey = NULL;
#endif
#ifdef WOLFSSL_ASYNC_CRYPT
WC_ASYNC_DEV* asyncDev = &priv_key->asyncDev;
#endif
(void)ssl;
(void)pubKeyDer;
(void)pubKeySz;
@@ -3449,30 +3502,37 @@ int EccSharedSecret(WOLFSSL* ssl, ecc_key* priv_key, ecc_key* pub_key,
#ifdef HAVE_PK_CALLBACKS
if (ssl->ctx->EccSharedSecretCb) {
ecc_key* otherKey = NULL;
ret = EccGetKey(ssl, &otherKey);
if (ret == 0) {
ret = ssl->ctx->EccSharedSecretCb(ssl, otherKey, pubKeyDer,
pubKeySz, out, outlen, side, ctx);
}
if (ret != 0)
return ret;
#ifdef WOLFSSL_ASYNC_CRYPT
asyncDev = &otherKey->asyncDev;
#endif
}
#endif
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
return ret;
#endif
#ifdef HAVE_PK_CALLBACKS
if (ssl->ctx->EccSharedSecretCb) {
ret = ssl->ctx->EccSharedSecretCb(ssl, otherKey, pubKeyDer,
pubKeySz, out, outlen, side, ctx);
}
else
#endif
{
ret = wc_ecc_shared_secret(priv_key, pub_key, out, outlen);
#ifdef WOLFSSL_ASYNC_CRYPT
asyncDev = &priv_key->asyncDev;
#endif
}
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, asyncDev);
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -3488,6 +3548,13 @@ int EccMakeKey(WOLFSSL* ssl, ecc_key* key, ecc_key* peer)
WOLFSSL_ENTER("EccMakeKey");
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_NONE);
if (ret != 0)
return ret;
#endif
if (peer == NULL) {
keySz = ssl->eccTempKeySz;
}
@@ -3506,9 +3573,9 @@ int EccMakeKey(WOLFSSL* ssl, ecc_key* key, ecc_key* peer)
}
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev, WC_ASYNC_FLAG_NONE);
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev);
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -3544,6 +3611,13 @@ int Ed25519Sign(WOLFSSL* ssl, const byte* in, word32 inSz, byte* out,
WOLFSSL_ENTER("Ed25519Sign");
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
return ret;
#endif
#if defined(HAVE_PK_CALLBACKS)
if (ssl->ctx->Ed25519SignCb) {
ret = ssl->ctx->Ed25519SignCb(ssl, in, inSz, out, outSz, keyBuf,
@@ -3556,9 +3630,9 @@ int Ed25519Sign(WOLFSSL* ssl, const byte* in, word32 inSz, byte* out,
}
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev);
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -3592,6 +3666,13 @@ int Ed25519Verify(WOLFSSL* ssl, const byte* in, word32 inSz, const byte* msg,
WOLFSSL_ENTER("Ed25519Verify");
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
return ret;
#endif
#ifdef HAVE_PK_CALLBACKS
if (ssl->ctx->Ed25519VerifyCb) {
ret = ssl->ctx->Ed25519VerifyCb(ssl, in, inSz, msg, msgSz, keyBuf,
@@ -3605,9 +3686,9 @@ int Ed25519Verify(WOLFSSL* ssl, const byte* in, word32 inSz, const byte* msg,
}
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev);
}
else
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -3673,6 +3754,13 @@ static int X25519SharedSecret(WOLFSSL* ssl, curve25519_key* priv_key,
WOLFSSL_ENTER("X25519SharedSecret");
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &priv_key->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
return ret;
#endif
#ifdef HAVE_PK_CALLBACKS
if (ssl->ctx->X25519SharedSecretCb) {
curve25519_key* otherKey = NULL;
@@ -3691,10 +3779,9 @@ static int X25519SharedSecret(WOLFSSL* ssl, curve25519_key* priv_key,
}
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &priv_key->asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, &priv_key->asyncDev);
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -3712,14 +3799,21 @@ static int X25519MakeKey(WOLFSSL* ssl, curve25519_key* key,
WOLFSSL_ENTER("X25519MakeKey");
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &key->asyncDev, WC_ASYNC_FLAG_NONE);
if (ret != 0)
return ret;
#endif
ret = wc_curve25519_make_key(ssl->rng, CURVE25519_KEYSIZE, key);
if (ret == 0)
ssl->ecdhCurveOID = ECC_X25519_OID;
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev, WC_ASYNC_FLAG_NONE);
ret = wolfSSL_AsyncPush(ssl, &key->asyncDev);
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -3742,12 +3836,19 @@ int DhGenKeyPair(WOLFSSL* ssl, DhKey* dhKey,
WOLFSSL_ENTER("DhGenKeyPair");
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &dhKey->asyncDev, WC_ASYNC_FLAG_NONE);
if (ret != 0)
return ret;
#endif
ret = wc_DhGenerateKeyPair(dhKey, ssl->rng, priv, privSz, pub, pubSz);
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &dhKey->asyncDev, WC_ASYNC_FLAG_NONE);
ret = wolfSSL_AsyncPush(ssl, &dhKey->asyncDev);
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -3767,12 +3868,19 @@ int DhAgree(WOLFSSL* ssl, DhKey* dhKey,
WOLFSSL_ENTER("DhAgree");
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &dhKey->asyncDev, WC_ASYNC_FLAG_NONE);
if (ret != 0)
return ret;
#endif
ret = wc_DhAgree(dhKey, agree, agreeSz, priv, privSz, otherPub, otherPubSz);
/* Handle async pending response */
#if defined(WOLFSSL_ASYNC_CRYPT)
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &dhKey->asyncDev, WC_ASYNC_FLAG_NONE);
ret = wolfSSL_AsyncPush(ssl, &dhKey->asyncDev);
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@@ -7686,6 +7794,7 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx,
{
int ret = 0;
#ifdef WOLFSSL_ASYNC_CRYPT
WC_ASYNC_DEV* asyncDev;
ProcPeerCertArgs* args = (ProcPeerCertArgs*)ssl->async.args;
typedef char args_test[sizeof(ssl->async.args) >= sizeof(*args) ? 1 : -1];
(void)sizeof(args_test);
@@ -7916,18 +8025,29 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx,
args->dCertInit = 1;
}
ret = ParseCertRelative(args->dCert, CERT_TYPE, 0,
ssl->ctx->cm);
if (ret != 0) {
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl,
args->dCert->sigCtx.asyncDev,
#ifdef WOLFSSL_ASYNC_CRYPT
do {
/* intialize event */
asyncDev = args->dCert->sigCtx.asyncDev;
if (asyncDev) {
ret = wolfSSL_AsyncInit(ssl, asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
break;
}
#endif
goto exit_ppc;
}
#endif
ret = ParseCertRelative(args->dCert, CERT_TYPE, 0,
ssl->ctx->cm);
if (ret != 0 && ret != WC_PENDING_E)
goto exit_ppc;
#ifdef WOLFSSL_ASYNC_CRYPT
if (asyncDev && ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, asyncDev);
goto exit_ppc;
}
} while (ret == WC_PENDING_E && asyncDev == NULL)
#endif
#ifndef NO_SKID
if (args->dCert->extAuthKeyIdSet) {
@@ -7981,18 +8101,29 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx,
args->dCertInit = 1;
}
ret = ParseCertRelative(args->dCert, CERT_TYPE, 0,
ssl->ctx->cm);
if (ret != 0) {
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl,
args->dCert->sigCtx.asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
#ifdef WOLFSSL_ASYNC_CRYPT
do {
/* intialize event */
asyncDev = args->dCert->sigCtx.asyncDev;
if (asyncDev) {
ret = wolfSSL_AsyncInit(ssl, asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
goto exit_ppc;
}
#endif
goto exit_ppc;
}
#endif
ret = ParseCertRelative(args->dCert, CERT_TYPE, 0,
ssl->ctx->cm);
if (ret != 0 && ret != WC_PENDING_E) {
goto exit_ppc;
}
#ifdef WOLFSSL_ASYNC_CRYPT
if (asyncDev && ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, asyncDev);
goto exit_ppc;
}
} while (ret == WC_PENDING_E && asyncDev == NULL);
#endif
#ifndef NO_SKID
subjectHash = args->dCert->extSubjKeyId;
@@ -8025,15 +8156,25 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx,
args->dCertInit = 1;
}
ret = ParseCertRelative(args->dCert, CERT_TYPE,
#ifdef WOLFSSL_ASYNC_CRYPT
do {
/* intialize event */
asyncDev = args->dCert->sigCtx.asyncDev;
if (asyncDev) {
ret = wolfSSL_AsyncInit(ssl, asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
goto exit_ppc;
}
#endif
ret = ParseCertRelative(args->dCert, CERT_TYPE,
!ssl->options.verifyNone, ssl->ctx->cm);
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl,
args->dCert->sigCtx.asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
goto exit_ppc;
}
if (asyncDev && ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, asyncDev);
goto exit_ppc;
}
} while (ret == WC_PENDING_E && asyncDev == NULL);
#endif
#ifndef NO_SKID
@@ -8217,16 +8358,27 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx,
#ifdef WOLFSSL_TRUST_PEER_CERT
if (!haveTrustPeer)
#endif
{ /* only parse if not already present in dCert from above */
ret = ParseCertRelative(args->dCert, CERT_TYPE,
{
#ifdef WOLFSSL_ASYNC_CRYPT
do {
/* intialize event */
asyncDev = args->dCert->sigCtx.asyncDev;
if (asyncDev) {
ret = wolfSSL_AsyncInit(ssl, asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
goto exit_ppc;
}
#endif
/* only parse if not already present in dCert from above */
ret = ParseCertRelative(args->dCert, CERT_TYPE,
!ssl->options.verifyNone, ssl->ctx->cm);
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl,
args->dCert->sigCtx.asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
goto exit_ppc;
}
if (asyncDev && ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, asyncDev);
goto exit_ppc;
}
} while (ret == WC_PENDING_E && asyncDev == NULL);
#endif
}
@@ -10478,12 +10630,18 @@ static INLINE int EncryptDo(WOLFSSL* ssl, byte* out, const byte* input,
#ifdef BUILD_DES3
case wolfssl_triple_des:
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
asyncDev = &ssl->encrypt.des3->asyncDev;
ret = wolfSSL_AsyncInit(ssl, asyncDev, event_flags);
if (ret != 0)
break;
#endif
ret = wc_Des3_CbcEncrypt(ssl->encrypt.des3, out, input, sz);
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
asyncDev = &ssl->encrypt.des3->asyncDev;
if (asyncOkay)
ret = wolfSSL_AsyncPush(ssl, asyncDev, event_flags);
if (ret == WC_PENDING_E && asyncOkay) {
ret = wolfSSL_AsyncPush(ssl, asyncDev);
}
#endif
break;
@@ -10491,13 +10649,18 @@ static INLINE int EncryptDo(WOLFSSL* ssl, byte* out, const byte* input,
#ifdef BUILD_AES
case wolfssl_aes:
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
asyncDev = &ssl->encrypt.aes->asyncDev;
ret = wolfSSL_AsyncInit(ssl, asyncDev, event_flags);
if (ret != 0)
break;
#endif
ret = wc_AesCbcEncrypt(ssl->encrypt.aes, out, input, sz);
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
asyncDev = &ssl->encrypt.aes->asyncDev;
if (asyncOkay)
ret = wolfSSL_AsyncPush(ssl, asyncDev, event_flags);
break;
if (ret == WC_PENDING_E && asyncOkay) {
ret = wolfSSL_AsyncPush(ssl, asyncDev);
}
#endif
break;
@@ -10509,6 +10672,15 @@ static INLINE int EncryptDo(WOLFSSL* ssl, byte* out, const byte* input,
{
wc_AesAuthEncryptFunc aes_auth_fn;
const byte* additionalSrc;
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
asyncDev = &ssl->encrypt.aes->asyncDev;
ret = wolfSSL_AsyncInit(ssl, asyncDev, event_flags);
if (ret != 0)
break;
#endif
#if defined(BUILD_AESGCM) && defined(HAVE_AESCCM)
aes_auth_fn = (ssl->specs.bulk_cipher_algorithm == wolfssl_aes_gcm)
? wc_AesGcmEncrypt : wc_AesCcmEncrypt;
@@ -10550,10 +10722,8 @@ static INLINE int EncryptDo(WOLFSSL* ssl, byte* out, const byte* input,
ssl->specs.aead_mac_size,
ssl->encrypt.additional, AEAD_AUTH_DATA_SZ);
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
asyncDev = &ssl->encrypt.aes->asyncDev;
if (asyncOkay)
ret = wolfSSL_AsyncPush(ssl, asyncDev, event_flags);
if (ret == WC_PENDING_E && asyncOkay) {
ret = wolfSSL_AsyncPush(ssl, asyncDev);
}
#endif
}
@@ -10724,11 +10894,18 @@ static INLINE int DecryptDo(WOLFSSL* ssl, byte* plain, const byte* input,
#ifdef BUILD_DES3
case wolfssl_triple_des:
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &ssl->decrypt.des3->asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
break;
#endif
ret = wc_Des3_CbcDecrypt(ssl->decrypt.des3, plain, input, sz);
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &ssl->decrypt.des3->asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, &ssl->decrypt.des3->asyncDev);
}
#endif
break;
@@ -10736,11 +10913,18 @@ static INLINE int DecryptDo(WOLFSSL* ssl, byte* plain, const byte* input,
#ifdef BUILD_AES
case wolfssl_aes:
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &ssl->decrypt.aes->asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
break;
#endif
ret = wc_AesCbcDecrypt(ssl->decrypt.aes, plain, input, sz);
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &ssl->decrypt.aes->asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, &ssl->decrypt.aes->asyncDev);
}
#endif
break;
@@ -10751,6 +10935,15 @@ static INLINE int DecryptDo(WOLFSSL* ssl, byte* plain, const byte* input,
case wolfssl_aes_ccm: /* GCM AEAD macros use same size as CCM */
{
wc_AesAuthDecryptFunc aes_auth_fn;
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &ssl->decrypt.aes->asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
break;
#endif
#if defined(BUILD_AESGCM) && defined(HAVE_AESCCM)
aes_auth_fn = (ssl->specs.bulk_cipher_algorithm == wolfssl_aes_gcm)
? wc_AesGcmDecrypt : wc_AesCcmDecrypt;
@@ -10785,9 +10978,7 @@ static INLINE int DecryptDo(WOLFSSL* ssl, byte* plain, const byte* input,
ssl->decrypt.additional, AEAD_AUTH_DATA_SZ)) < 0) {
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl,
&ssl->decrypt.aes->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
break;
ret = wolfSSL_AsyncPush(ssl, &ssl->decrypt.aes->asyncDev);
}
#endif
}
@@ -24433,7 +24624,7 @@ int wolfSSL_AsyncPop(WOLFSSL* ssl, byte* state)
return ret;
}
int wolfSSL_AsyncPush(WOLFSSL* ssl, WC_ASYNC_DEV* asyncDev, word32 flags)
int wolfSSL_AsyncInit(WOLFSSL* ssl, WC_ASYNC_DEV* asyncDev, word32 flags)
{
int ret;
WOLF_EVENT* event;
@@ -24447,13 +24638,30 @@ int wolfSSL_AsyncPush(WOLFSSL* ssl, WC_ASYNC_DEV* asyncDev, word32 flags)
/* init event */
ret = wolfAsync_EventInit(event, WOLF_EVENT_TYPE_ASYNC_WOLFSSL, ssl, flags);
if (ret == 0) {
ssl->async.dev = asyncDev;
/* place event into queue */
ret = wolfAsync_EventQueuePush(&ssl->ctx->event_queue, event);
WOLFSSL_LEAVE("wolfSSL_AsyncInit", ret);
return ret;
}
int wolfSSL_AsyncPush(WOLFSSL* ssl, WC_ASYNC_DEV* asyncDev)
{
int ret;
WOLF_EVENT* event;
if (ssl == NULL || asyncDev == NULL) {
return BAD_FUNC_ARG;
}
/* grab event pointer */
event = &asyncDev->event;
/* store reference to active async operation */
ssl->async.dev = asyncDev;
/* place event into queue */
ret = wolfAsync_EventQueuePush(&ssl->ctx->event_queue, event);
/* success means return WC_PENDING_E */
if (ret == 0) {
ret = WC_PENDING_E;

48
src/tls13.c
View File

@@ -1618,25 +1618,35 @@ static int EncryptTls13(WOLFSSL* ssl, byte* output, const byte* input,
switch (ssl->specs.bulk_cipher_algorithm) {
#ifdef BUILD_AESGCM
case wolfssl_aes_gcm:
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
asyncDev = &ssl->encrypt.aes->asyncDev;
ret = wolfSSL_AsyncInit(ssl, asyncDev, event_flags);
if (ret != 0)
break;
#endif
nonceSz = AESGCM_NONCE_SZ;
ret = wc_AesGcmEncrypt(ssl->encrypt.aes, output, input,
dataSz, ssl->encrypt.nonce, nonceSz,
output + dataSz, macSz, NULL, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
asyncDev = &ssl->encrypt.aes->asyncDev;
#endif
break;
#endif
#ifdef HAVE_AESCCM
case wolfssl_aes_ccm:
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
asyncDev = &ssl->encrypt.aes->asyncDev;
ret = wolfSSL_AsyncInit(ssl, asyncDev, event_flags);
if (ret != 0)
break;
#endif
nonceSz = AESCCM_NONCE_SZ;
ret = wc_AesCcmEncrypt(ssl->encrypt.aes, output, input,
dataSz, ssl->encrypt.nonce, nonceSz,
output + dataSz, macSz, NULL, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
asyncDev = &ssl->encrypt.aes->asyncDev;
#endif
break;
#endif
@@ -1663,9 +1673,7 @@ static int EncryptTls13(WOLFSSL* ssl, byte* output, const byte* input,
}
else {
/* If pending, then leave and return will resume below */
ret = wolfSSL_AsyncPush(ssl, asyncDev, event_flags);
return ret;
return wolfSSL_AsyncPush(ssl, asyncDev);
}
}
#endif
@@ -1824,14 +1832,21 @@ int DecryptTls13(WOLFSSL* ssl, byte* output, const byte* input, word16 sz)
switch (ssl->specs.bulk_cipher_algorithm) {
#ifdef BUILD_AESGCM
case wolfssl_aes_gcm:
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &ssl->decrypt.aes->asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
break;
#endif
nonceSz = AESGCM_NONCE_SZ;
ret = wc_AesGcmDecrypt(ssl->decrypt.aes, output, input,
dataSz, ssl->decrypt.nonce, nonceSz,
input + dataSz, macSz, NULL, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &ssl->decrypt.aes->asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, &ssl->decrypt.aes->asyncDev);
}
#endif
break;
@@ -1839,14 +1854,21 @@ int DecryptTls13(WOLFSSL* ssl, byte* output, const byte* input, word16 sz)
#ifdef HAVE_AESCCM
case wolfssl_aes_ccm:
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
ret = wolfSSL_AsyncInit(ssl, &ssl->decrypt.aes->asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
break;
#endif
nonceSz = AESCCM_NONCE_SZ;
ret = wc_AesCcmDecrypt(ssl->decrypt.aes, output, input,
dataSz, ssl->decrypt.nonce, nonceSz,
input + dataSz, macSz, NULL, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E) {
ret = wolfSSL_AsyncPush(ssl, &ssl->decrypt.aes->asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
ret = wolfSSL_AsyncPush(ssl, &ssl->decrypt.aes->asyncDev);
}
#endif
break;

65
tests/api.c
View File

@@ -4969,9 +4969,15 @@ static int test_wc_Md5HmacFinal (void)
printf(testingFmt, "wc_HmacFinal() with MD5");
ret = wc_HmacSetKey(&hmac, MD5, (byte*)key, (word32)XSTRLEN(key));
if (ret != 0) {
ret = wc_HmacInit(&hmac, NULL, INVALID_DEVID);
if (ret != 0)
flag = ret;
if (!flag) {
ret = wc_HmacSetKey(&hmac, MD5, (byte*)key, (word32)XSTRLEN(key));
if (ret != 0) {
flag = ret;
}
}
if (!flag) {
@@ -5010,6 +5016,9 @@ static int test_wc_Md5HmacFinal (void)
}
}
#endif
wc_HmacFree(&hmac);
printf(resultFmt, flag == 0 ? passed : failed);
#endif
@@ -5042,9 +5051,15 @@ static int test_wc_ShaHmacFinal (void)
printf(testingFmt, "wc_HmacFinal() with SHA");
ret = wc_HmacSetKey(&hmac, SHA, (byte*)key, (word32)XSTRLEN(key));
if (ret != 0) {
ret = wc_HmacInit(&hmac, NULL, INVALID_DEVID);
if (ret != 0)
flag = ret;
if (!flag) {
ret = wc_HmacSetKey(&hmac, SHA, (byte*)key, (word32)XSTRLEN(key));
if (ret != 0) {
flag = ret;
}
}
if (!flag) {
@@ -5083,6 +5098,9 @@ static int test_wc_ShaHmacFinal (void)
}
}
#endif
wc_HmacFree(&hmac);
printf(resultFmt, flag == 0 ? passed : failed);
#endif
@@ -5116,9 +5134,15 @@ static int test_wc_Sha224HmacFinal (void)
printf(testingFmt, "wc_HmacFinal() with SHA224");
ret = wc_HmacSetKey(&hmac, SHA224, (byte*)key, (word32)XSTRLEN(key));
if (ret != 0) {
ret = wc_HmacInit(&hmac, NULL, INVALID_DEVID);
if (ret != 0)
flag = ret;
if (!flag) {
ret = wc_HmacSetKey(&hmac, SHA224, (byte*)key, (word32)XSTRLEN(key));
if (ret != 0) {
flag = ret;
}
}
if (!flag) {
@@ -5157,6 +5181,9 @@ static int test_wc_Sha224HmacFinal (void)
}
}
#endif
wc_HmacFree(&hmac);
printf(resultFmt, flag == 0 ? passed : failed);
#endif
@@ -5189,9 +5216,15 @@ static int test_wc_Sha256HmacFinal (void)
printf(testingFmt, "wc_HmacFinal() with SHA256");
ret = wc_HmacSetKey(&hmac, SHA256, (byte*)key, (word32)XSTRLEN(key));
if (ret != 0) {
ret = wc_HmacInit(&hmac, NULL, INVALID_DEVID);
if (ret != 0)
flag = ret;
if (!flag) {
ret = wc_HmacSetKey(&hmac, SHA256, (byte*)key, (word32)XSTRLEN(key));
if (ret != 0) {
flag = ret;
}
}
if (!flag) {
@@ -5230,6 +5263,9 @@ static int test_wc_Sha256HmacFinal (void)
}
}
#endif
wc_HmacFree(&hmac);
printf(resultFmt, flag == 0 ? passed : failed);
#endif
@@ -5263,9 +5299,15 @@ static int test_wc_Sha384HmacFinal (void)
printf(testingFmt, "wc_HmacFinal() with SHA384");
ret = wc_HmacSetKey(&hmac, SHA384, (byte*)key, (word32)XSTRLEN(key));
if (ret != 0) {
ret = wc_HmacInit(&hmac, NULL, INVALID_DEVID);
if (ret != 0)
flag = ret;
if (!flag) {
ret = wc_HmacSetKey(&hmac, SHA384, (byte*)key, (word32)XSTRLEN(key));
if (ret != 0) {
flag = ret;
}
}
if (!flag) {
@@ -5303,6 +5345,9 @@ static int test_wc_Sha384HmacFinal (void)
}
}
#endif
wc_HmacFree(&hmac);
printf(resultFmt, flag == 0 ? passed : failed);
#endif

840
wolfcrypt/benchmark/benchmark.c
View File

File diff suppressed because it is too large Load Diff

37
wolfcrypt/src/aes.c
View File

@@ -2822,9 +2822,8 @@ int wc_AesSetIV(Aes* aes, const byte* iv)
(const byte*)aes->asyncKey, aes->keylen,
(const byte*)aes->asyncIv, AES_BLOCK_SIZE);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
WC_ASYNC_TEST* testDev = &aes->asyncDev.test;
if (testDev->type == ASYNC_TEST_NONE) {
testDev->type = ASYNC_TEST_AES_CBC_ENCRYPT;
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;
@@ -2913,9 +2912,8 @@ int wc_AesSetIV(Aes* aes, const byte* iv)
(const byte*)aes->asyncKey, aes->keylen,
(const byte*)aes->asyncIv, AES_BLOCK_SIZE);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
WC_ASYNC_TEST* testDev = &aes->asyncDev.test;
if (testDev->type == ASYNC_TEST_NONE) {
testDev->type = ASYNC_TEST_AES_CBC_DECRYPT;
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;
@@ -3165,7 +3163,7 @@ int wc_AesEcbDecrypt(Aes* aes, byte* out, const byte* in, word32 sz)
byte out_block[AES_BLOCK_SIZE];
int odd, even, blocks;
byte *tmp;
if (aes == NULL || out == NULL || in == NULL) {
return BAD_FUNC_ARG;
}
@@ -5494,7 +5492,7 @@ static int AES_GCM_decrypt(const unsigned char *in, unsigned char *out,
for (; i < nbytes/16/8; i++) {
r0 = _mm_setzero_si128();
r1 = _mm_setzero_si128();
tmp1 = _mm_shuffle_epi8(ctr1, BSWAP_EPI64);
tmp2 = _mm_add_epi32(ctr1, ONE);
tmp2 = _mm_shuffle_epi8(tmp2, BSWAP_EPI64);
@@ -7078,9 +7076,8 @@ int wc_AesGcmEncrypt(Aes* aes, byte* out, const byte* in, word32 sz,
(const byte*)aes->asyncKey, aes->keylen, iv, ivSz,
authTag, authTagSz, authIn, authInSz);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
WC_ASYNC_TEST* testDev = &aes->asyncDev.test;
if (testDev->type == ASYNC_TEST_NONE) {
testDev->type = ASYNC_TEST_AES_GCM_ENCRYPT;
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;
@@ -7091,6 +7088,7 @@ int wc_AesGcmEncrypt(Aes* aes, byte* out, const byte* in, word32 sz,
testDev->aes.authTagSz = authTagSz;
testDev->aes.authIn = authIn;
testDev->aes.authInSz = authInSz;
return WC_PENDING_E;
}
#endif
}
@@ -7340,9 +7338,8 @@ int wc_AesGcmDecrypt(Aes* aes, byte* out, const byte* in, word32 sz,
(const byte*)aes->asyncKey, aes->keylen, iv, ivSz,
authTag, authTagSz, authIn, authInSz);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
WC_ASYNC_TEST* testDev = &aes->asyncDev.test;
if (testDev->type == ASYNC_TEST_NONE) {
testDev->type = ASYNC_TEST_AES_GCM_DECRYPT;
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;
@@ -7900,6 +7897,10 @@ int wc_AesKeyWrap(const byte* key, word32 keySz, const byte* in, word32 inSz,
XMEMCPY(r, in, inSz);
XMEMSET(t, 0, sizeof(t));
ret = wc_AesInit(&aes, NULL, INVALID_DEVID);
if (ret != 0)
return ret;
ret = wc_AesSetKey(&aes, key, keySz, NULL, AES_ENCRYPTION);
if (ret != 0)
return ret;
@@ -7926,6 +7927,8 @@ int wc_AesKeyWrap(const byte* key, word32 keySz, const byte* in, word32 inSz,
/* C[0] = A */
XMEMCPY(out, tmp, KEYWRAP_BLOCK_SIZE);
wc_AesFree(&aes);
return inSz + KEYWRAP_BLOCK_SIZE;
}
@@ -7967,6 +7970,10 @@ int wc_AesKeyUnWrap(const byte* key, word32 keySz, const byte* in, word32 inSz,
XMEMCPY(out, in + KEYWRAP_BLOCK_SIZE, inSz - KEYWRAP_BLOCK_SIZE);
XMEMSET(t, 0, sizeof(t));
ret = wc_AesInit(&aes, NULL, INVALID_DEVID);
if (ret != 0)
return ret;
ret = wc_AesSetKey(&aes, key, keySz, NULL, AES_DECRYPTION);
if (ret != 0)
return ret;
@@ -7992,6 +7999,8 @@ int wc_AesKeyUnWrap(const byte* key, word32 keySz, const byte* in, word32 inSz,
}
}
wc_AesFree(&aes);
/* verify IV */
if (XMEMCMP(tmp, expIv, KEYWRAP_BLOCK_SIZE) != 0)
return BAD_KEYWRAP_IV_E;

37
wolfcrypt/src/asn.c
View File

@@ -4566,25 +4566,25 @@ static int ConfirmSignature(SignatureCtx* sigCtx,
if (sigCtx->key.rsa == NULL || sigCtx->plain == NULL) {
ERROR_OUT(MEMORY_E, exit_cs);
}
if ((ret = wc_InitRsaKey_ex(sigCtx->key.rsa, sigCtx->heap,
sigCtx->devId)) != 0) {
goto exit_cs;
}
if (sigSz > MAX_ENCODED_SIG_SZ) {
WOLFSSL_MSG("Verify Signature is too big");
ERROR_OUT(BUFFER_E, exit_cs);
}
if ((ret = wc_RsaPublicKeyDecode(key, &idx, sigCtx->key.rsa,
keySz)) != 0) {
WOLFSSL_MSG("ASN Key decode error RSA");
goto exit_cs;
}
XMEMCPY(sigCtx->plain, sig, sigSz);
sigCtx->out = NULL;
#ifdef WOLFSSL_ASYNC_CRYPT
sigCtx->asyncDev = &sigCtx->key.rsa->asyncDev;
#endif
break;
}
#endif /* !NO_RSA */
@@ -4597,7 +4597,6 @@ static int ConfirmSignature(SignatureCtx* sigCtx,
if (sigCtx->key.ecc == NULL) {
ERROR_OUT(MEMORY_E, exit_cs);
}
if ((ret = wc_ecc_init_ex(sigCtx->key.ecc, sigCtx->heap,
sigCtx->devId)) < 0) {
goto exit_cs;
@@ -4607,6 +4606,9 @@ static int ConfirmSignature(SignatureCtx* sigCtx,
WOLFSSL_MSG("ASN Key import error ECC");
goto exit_cs;
}
#ifdef WOLFSSL_ASYNC_CRYPT
sigCtx->asyncDev = &sigCtx->key.ecc->asyncDev;
#endif
break;
}
#endif /* HAVE_ECC */
@@ -4620,7 +4622,6 @@ static int ConfirmSignature(SignatureCtx* sigCtx,
if (sigCtx->key.ed25519 == NULL) {
ERROR_OUT(MEMORY_E, exit_cs);
}
if ((ret = wc_ed25519_init(sigCtx->key.ed25519)) < 0) {
goto exit_cs;
}
@@ -4629,6 +4630,9 @@ static int ConfirmSignature(SignatureCtx* sigCtx,
WOLFSSL_MSG("ASN Key import error ED25519");
goto exit_cs;
}
#ifdef WOLFSSL_ASYNC_CRYPT
sigCtx->asyncDev = &sigCtx->key.ed25519->asyncDev;
#endif
break;
}
#endif
@@ -4643,6 +4647,15 @@ static int ConfirmSignature(SignatureCtx* sigCtx,
}
sigCtx->state = SIG_STATE_DO;
#ifdef WOLFSSL_ASYNC_CRYPT
if (sigCtx->devId != INVALID_DEVID) {
/* always return here, so we can properly init the async
context back in SSL world */
ret = WC_PENDING_E;
goto exit_cs;
}
#endif
} /* SIG_STATE_KEY */
FALL_THROUGH;
@@ -4654,10 +4667,6 @@ static int ConfirmSignature(SignatureCtx* sigCtx,
{
ret = wc_RsaSSL_VerifyInline(sigCtx->plain, sigSz,
&sigCtx->out, sigCtx->key.rsa);
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E)
sigCtx->asyncDev = &sigCtx->key.rsa->asyncDev;
#endif
break;
}
#endif /* !NO_RSA */
@@ -4666,10 +4675,6 @@ static int ConfirmSignature(SignatureCtx* sigCtx,
{
ret = wc_ecc_verify_hash(sig, sigSz, sigCtx->digest,
sigCtx->digestSz, &sigCtx->verify, sigCtx->key.ecc);
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E)
sigCtx->asyncDev = &sigCtx->key.ecc->asyncDev;
#endif
break;
}
#endif /* HAVE_ECC */
@@ -4678,10 +4683,6 @@ static int ConfirmSignature(SignatureCtx* sigCtx,
{
ret = wc_ed25519_verify_msg(sig, sigSz, buf, bufSz,
&sigCtx->verify, sigCtx->key.ed25519);
#ifdef WOLFSSL_ASYNC_CRYPT
if (ret == WC_PENDING_E)
sigCtx->asyncDev = &sigCtx->key.ecc->asyncDev;
#endif
break;
}
#endif

10
wolfcrypt/src/des3.c
View File

@@ -1582,9 +1582,8 @@
return IntelQaSymDes3CbcEncrypt(&des->asyncDev, out, in, sz,
des->key_raw, DES3_KEYLEN, (byte*)des->iv_raw, DES3_IVLEN);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
WC_ASYNC_TEST* testDev = &des->asyncDev.test;
if (testDev->type == ASYNC_TEST_NONE) {
testDev->type = ASYNC_TEST_DES3_CBC_ENCRYPT;
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;
@@ -1625,9 +1624,8 @@
return IntelQaSymDes3CbcDecrypt(&des->asyncDev, out, in, sz,
des->key_raw, DES3_KEYLEN, (byte*)des->iv_raw, DES3_IVLEN);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
WC_ASYNC_TEST* testDev = &des->asyncDev.test;
if (testDev->type == ASYNC_TEST_NONE) {
testDev->type = ASYNC_TEST_DES3_CBC_DECRYPT;
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;

10
wolfcrypt/src/dh.c
View File

@@ -687,9 +687,8 @@ static int wc_DhGenerateKeyPair_Async(DhKey* key, WC_RNG* rng,
/* TODO: Not implemented - use software for now */
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
WC_ASYNC_TEST* testDev = &key->asyncDev.test;
if (testDev->type == ASYNC_TEST_NONE) {
testDev->type = ASYNC_TEST_DH_GEN;
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;
@@ -836,9 +835,8 @@ static int wc_DhAgree_Async(DhKey* key, byte* agree, word32* agreeSz,
ret = IntelQaDhAgree(&key->asyncDev, &key->p.raw,
agree, agreeSz, priv, privSz, otherPub, pubSz);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
WC_ASYNC_TEST* testDev = &key->asyncDev.test;
if (testDev->type == ASYNC_TEST_NONE) {
testDev->type = ASYNC_TEST_DH_AGREE;
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;

73
wolfcrypt/src/ecc.c
View File

@@ -1117,12 +1117,23 @@ static int wc_ecc_curve_load(const ecc_set_type* dp, ecc_curve_spec** pCurve,
if (x == ECC_CURVE_INVALID)
return ECC_BAD_ARG_E;
#if !defined(SINGLE_THREADED)
ret = wc_LockMutex(&ecc_curve_cache_mutex);
if (ret != 0) {
return ret;
}
#endif
/* make sure cache has been allocated */
if (ecc_curve_spec_cache[x] == NULL) {
ecc_curve_spec_cache[x] = (ecc_curve_spec*)XMALLOC(
sizeof(ecc_curve_spec), NULL, DYNAMIC_TYPE_ECC);
if (ecc_curve_spec_cache[x] == NULL)
if (ecc_curve_spec_cache[x] == NULL) {
#if defined(ECC_CACHE_CURVE) && !defined(SINGLE_THREADED)
wc_UnLockMutex(&ecc_curve_cache_mutex);
#endif
return MEMORY_E;
}
XMEMSET(ecc_curve_spec_cache[x], 0, sizeof(ecc_curve_spec));
}
@@ -1149,13 +1160,6 @@ static int wc_ecc_curve_load(const ecc_set_type* dp, ecc_curve_spec** pCurve,
}
curve->dp = dp; /* set dp info */
#if defined(ECC_CACHE_CURVE) && !defined(SINGLE_THREADED)
ret = wc_LockMutex(&ecc_curve_cache_mutex);
if (ret != 0) {
return MEMORY_E;
}
#endif
/* determine items to load */
load_items = (~curve->load_mask & load_mask);
curve->load_mask |= load_items;
@@ -2803,9 +2807,8 @@ static int wc_ecc_shared_secret_gen_async(ecc_key* private_key,
&curve->Af->raw, &curve->Bf->raw, &curve->prime->raw,
private_key->dp->cofactor);
#else /* WOLFSSL_ASYNC_CRYPT_TEST */
WC_ASYNC_TEST* testDev = &private_key->asyncDev.test;
if (testDev->type == ASYNC_TEST_NONE) {
testDev->type = ASYNC_TEST_ECC_SHARED_SEC;
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;
@@ -2895,13 +2898,6 @@ int wc_ecc_shared_secret_ex(ecc_key* private_key, ecc_point* point,
case ECC_STATE_SHARED_SEC_RES:
private_key->state = ECC_STATE_SHARED_SEC_RES;
err = 0;
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_ECC)
if (private_key->asyncDev.marker == WOLFSSL_ASYNC_MARKER_ECC) {
#if defined(HAVE_CAVIUM) || defined(HAVE_INTEL_QA)
err = private_key->asyncDev.event.ret;
#endif
}
#endif
break;
default:
@@ -3017,9 +3013,8 @@ int wc_ecc_make_key_ex(WC_RNG* rng, int keysize, ecc_key* key, int curve_id)
#elif defined(HAVE_INTEL_QA)
/* TODO: Not implemented */
#else
WC_ASYNC_TEST* testDev = &key->asyncDev.test;
if (testDev->type == ASYNC_TEST_NONE) {
testDev->type = ASYNC_TEST_ECC_MAKE;
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;
@@ -3465,9 +3460,8 @@ int wc_ecc_sign_hash_ex(const byte* in, word32 inlen, WC_RNG* rng,
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_ECC) && \
defined(WOLFSSL_ASYNC_CRYPT_TEST)
if (key->asyncDev.marker == WOLFSSL_ASYNC_MARKER_ECC) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test;
if (testDev->type == ASYNC_TEST_NONE) {
testDev->type = ASYNC_TEST_ECC_SIGN;
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;
@@ -4011,9 +4005,8 @@ int wc_ecc_verify_hash_ex(mp_int *r, mp_int *s, const byte* hash,
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_ECC) && \
defined(WOLFSSL_ASYNC_CRYPT_TEST)
if (key->asyncDev.marker == WOLFSSL_ASYNC_MARKER_ECC) {
WC_ASYNC_TEST* testDev = &key->asyncDev.test;
if (testDev->type == ASYNC_TEST_NONE) {
testDev->type = ASYNC_TEST_ECC_VERIFY;
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;
@@ -7175,15 +7168,10 @@ int wc_ecc_encrypt(ecc_key* privKey, ecc_key* pubKey, const byte* msg,
}
#endif
#if defined(WOLFSSL_ASYNC_CRYPT)
ret = 0;
#endif
do {
#if defined(WOLFSSL_ASYNC_CRYPT)
ret = wc_AsyncWait(ret, &privKey->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
#endif
ret = wc_ecc_shared_secret(privKey, pubKey, sharedSecret, &sharedSz);
} while (ret == WC_PENDING_E);
ret = wc_ecc_shared_secret(privKey, pubKey, sharedSecret, &sharedSz);
#if defined(WOLFSSL_ASYNC_CRYPT)
ret = wc_AsyncWait(ret, &privKey->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
#endif
if (ret == 0) {
switch (ctx->kdfAlgo) {
case ecHKDF_SHA256 :
@@ -7338,15 +7326,10 @@ int wc_ecc_decrypt(ecc_key* privKey, ecc_key* pubKey, const byte* msg,
}
#endif
#if defined(WOLFSSL_ASYNC_CRYPT)
ret = 0;
#endif
do {
#if defined(WOLFSSL_ASYNC_CRYPT)
ret = wc_AsyncWait(ret, &privKey->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
#endif
ret = wc_ecc_shared_secret(privKey, pubKey, sharedSecret, &sharedSz);
} while (ret == WC_PENDING_E);
ret = wc_ecc_shared_secret(privKey, pubKey, sharedSecret, &sharedSz);
#if defined(WOLFSSL_ASYNC_CRYPT)
ret = wc_AsyncWait(ret, &privKey->asyncDev, WC_ASYNC_FLAG_CALL_AGAIN);
#endif
if (ret == 0) {
switch (ctx->kdfAlgo) {
case ecHKDF_SHA256 :

10
wolfcrypt/src/rsa.c
View File

@@ -1289,9 +1289,8 @@ static int wc_RsaFunctionAsync(const byte* in, word32 inLen, byte* out,
(void)rng;
#ifdef WOLFSSL_ASYNC_CRYPT_TEST
WC_ASYNC_TEST* testDev = &key->asyncDev.test;
if (testDev->type == ASYNC_TEST_NONE) {
testDev->type = ASYNC_TEST_RSA_FUNC;
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;
@@ -1870,9 +1869,8 @@ int wc_MakeRsaKey(RsaKey* key, int size, long e, WC_RNG* rng)
#elif defined(HAVE_INTEL_QA)
/* TODO: Not implemented */
#else
WC_ASYNC_TEST* testDev = &key->asyncDev.test;
if (testDev->type == ASYNC_TEST_NONE) {
testDev->type = ASYNC_TEST_RSA_MAKE;
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;

12
wolfcrypt/src/wolfevent.c
View File

@@ -41,8 +41,8 @@ int wolfEvent_Init(WOLF_EVENT* event, WOLF_EVENT_TYPE type, void* context)
return BAD_FUNC_ARG;
}
if (event->pending) {
WOLFSSL_MSG("event already pending!");
if (event->state == WOLF_EVENT_STATE_PENDING) {
WOLFSSL_MSG("Event already pending!");
return BAD_COND_E;
}
@@ -99,10 +99,6 @@ int wolfEventQueue_Push(WOLF_EVENT_QUEUE* queue, WOLF_EVENT* event)
}
#endif
/* Setup event */
event->next = NULL;
event->pending = 1;
ret = wolfEventQueue_Add(queue, event);
#ifndef SINGLE_THREADED
@@ -145,6 +141,8 @@ int wolfEventQueue_Add(WOLF_EVENT_QUEUE* queue, WOLF_EVENT* event)
return BAD_FUNC_ARG;
}
event->next = NULL; /* added to end */
event->prev = NULL;
if (queue->tail == NULL) {
queue->head = event;
}
@@ -218,7 +216,7 @@ int wolfEventQueue_Poll(WOLF_EVENT_QUEUE* queue, void* context_filter,
if (ret < 0) break; /* exit for */
/* If event is done then process */
if (event->done) {
if (event->state == WOLF_EVENT_STATE_DONE) {
/* remove from queue */
ret = wolfEventQueue_Remove(queue, event);
if (ret < 0) break; /* exit for */

5
wolfcrypt/test/test.c
View File

@@ -6748,6 +6748,11 @@ int rsa_test(void)
DECLARE_VAR(out, byte, RSA_TEST_BYTES, HEAP_HINT);
DECLARE_VAR(plain, byte, RSA_TEST_BYTES, HEAP_HINT);
#ifdef WOLFSSL_ASYNC_CRYPT
if (in == NULL)
return MEMORY_E;
#endif
/* initialize stack structures */
XMEMSET(&rng, 0, sizeof(rng));
XMEMSET(&key, 0, sizeof(key));

4
wolfssl/internal.h
View File

@@ -3820,9 +3820,9 @@ WOLFSSL_LOCAL int AllocKey(WOLFSSL* ssl, int type, void** pKey);
WOLFSSL_LOCAL void FreeKey(WOLFSSL* ssl, int type, void** pKey);
#ifdef WOLFSSL_ASYNC_CRYPT
WOLFSSL_LOCAL int wolfSSL_AsyncInit(WOLFSSL* ssl, WC_ASYNC_DEV* asyncDev, word32 flags);
WOLFSSL_LOCAL int wolfSSL_AsyncPop(WOLFSSL* ssl, byte* state);
WOLFSSL_LOCAL int wolfSSL_AsyncPush(WOLFSSL* ssl, WC_ASYNC_DEV* asyncDev,
word32 flags);
WOLFSSL_LOCAL int wolfSSL_AsyncPush(WOLFSSL* ssl, WC_ASYNC_DEV* asyncDev);
#endif

6
wolfssl/test.h
View File

@@ -1385,7 +1385,7 @@ static INLINE void CaCb(unsigned char* der, int sz, int type)
#ifdef HAVE_STACK_SIZE
typedef THREAD_RETURN WOLFSSL_THREAD (*thread_func)(void* args);
#define STACK_CHECK_VAL 0x01
static INLINE int StackSizeCheck(func_args* args, thread_func tf)
{
@@ -1405,7 +1405,7 @@ static INLINE int StackSizeCheck(func_args* args, thread_func tf)
if (ret != 0 || myStack == NULL)
err_sys("posix_memalign failed\n");
XMEMSET(myStack, 0x01, stackSize);
XMEMSET(myStack, STACK_CHECK_VAL, stackSize);
ret = pthread_attr_init(&myAttr);
if (ret != 0)
@@ -1426,7 +1426,7 @@ static INLINE int StackSizeCheck(func_args* args, thread_func tf)
err_sys("pthread_join failed");
for (i = 0; i < stackSize; i++) {
if (myStack[i] != 0x01) {
if (myStack[i] != STACK_CHECK_VAL) {
break;
}
}

2
wolfssl/wolfcrypt/types.h
View File

@@ -257,7 +257,7 @@
VAR_TYPE* VAR_NAME = (VAR_TYPE*)XMALLOC(sizeof(VAR_TYPE) * VAR_SIZE, HEAP, DYNAMIC_TYPE_WOLF_BIGINT);
#define DECLARE_VAR_INIT(VAR_NAME, VAR_TYPE, VAR_SIZE, INIT_VALUE, HEAP) \
VAR_TYPE* VAR_NAME = ({ \
VAR_TYPE* ptr = XMALLOC(sizeof(VAR_TYPE) * VAR_SIZE, HEAP, DYNAMIC_TYPE_WOLF_BIGINT); \
VAR_TYPE* ptr = (VAR_TYPE*)XMALLOC(sizeof(VAR_TYPE) * VAR_SIZE, HEAP, DYNAMIC_TYPE_WOLF_BIGINT); \
if (ptr && INIT_VALUE) { \
XMEMCPY(ptr, INIT_VALUE, sizeof(VAR_TYPE) * VAR_SIZE); \
} \

15
wolfssl/wolfcrypt/wolfevent.h
View File

@@ -55,6 +55,12 @@ typedef enum WOLF_EVENT_TYPE {
#endif /* WOLFSSL_ASYNC_CRYPT */
} WOLF_EVENT_TYPE;
typedef enum WOLF_EVENT_STATE {
WOLF_EVENT_STATE_READY,
WOLF_EVENT_STATE_PENDING,
WOLF_EVENT_STATE_DONE,
} WOLF_EVENT_STATE;
struct WOLF_EVENT {
/* double linked list */
WOLF_EVENT* next;
@@ -69,15 +75,14 @@ struct WOLF_EVENT {
} dev;
#ifdef HAVE_CAVIUM
CavReqId reqId;
#endif
#ifndef WC_NO_ASYNC_THREADING
pthread_t threadId;
#endif
int ret; /* Async return code */
unsigned int flags;
WOLF_EVENT_TYPE type;
/* event flags */
WOLF_EVENT_FLAG pending:1;
WOLF_EVENT_FLAG done:1;
/* Future event flags can go here */
WOLF_EVENT_STATE state;
};
enum WOLF_POLL_FLAGS {