mirrors
/
wolfssl
mirror of https://github.com/wolfSSL/wolfssl
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixes for refactor to initialize the asyncDev.event prior to call for ParseCertRelative, ConfirmSignature and ECC shared secret (return code). Scan-build and G++ fixes.

This commit is contained in:
David Garske 2017-08-15 15:58:22 -07:00
parent b32be20110
commit ccc226eae4
6 changed files with 106 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

145
src/internal.c
View File

@ -7780,6 +7780,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);
@ -8011,27 +8012,28 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx,
}
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
if (args->dCert->sigCtx.asyncDev) {
ret = wolfSSL_AsyncInit(ssl,
args->dCert->sigCtx.asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
break;
}
#endif
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);
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) {
@ -8086,27 +8088,28 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx,
}
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
if (args->dCert->sigCtx.asyncDev) {
ret = wolfSSL_AsyncInit(ssl,
args->dCert->sigCtx.asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
break;
}
#endif
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);
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;
@ -8140,24 +8143,24 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx,
}
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
if (args->dCert->sigCtx.asyncDev) {
ret = wolfSSL_AsyncInit(ssl,
args->dCert->sigCtx.asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
goto exit_ppc;
}
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,
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);
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
@ -8343,25 +8346,25 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx,
#endif
{
#ifdef WOLFSSL_ASYNC_CRYPT
/* intialize event */
if (args->dCert->sigCtx.asyncDev) {
ret = wolfSSL_AsyncInit(ssl,
args->dCert->sigCtx.asyncDev,
WC_ASYNC_FLAG_CALL_AGAIN);
if (ret != 0)
goto exit_ppc;
}
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,
/* 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);
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
}

12
wolfcrypt/src/aes.c
View File

@ -7897,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;
@ -7923,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;
}
@ -7964,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;
@ -7989,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;

10
wolfcrypt/src/asn.c
View File

@ -4697,10 +4697,12 @@ static int ConfirmSignature(SignatureCtx* sigCtx,
sigCtx->state = SIG_STATE_DO;
#ifdef WOLFSSL_ASYNC_CRYPT
/* always return here, so we can properly init the async
context back in SSL world */
ret = WC_PENDING_E;
goto exit_cs;
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;

33
wolfcrypt/src/ecc.c
View File

@ -2898,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:
@ -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 :

5
wolfcrypt/test/test.c
View File

@ -6740,6 +6740,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));

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); \
} \