feedc0de/wolfssl
1
0
Fork 0
forked from wolfSSL/wolfssl
Code Pull Requests Activity

Fix DSA public decode to allow extra buffer (in case private key is passed in). Fixes for clang-tidy "value stored never read". Allow showing line number and conditional with DEBUG_WOLFSSL_VERBOSE on TEST_RES_CHECK.

Browse Source
This commit is contained in:
David Garske
2022-11-29 10:22:01 -08:00
parent 7310eb102f
commit b2f9838af4
3 changed files with 171 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

303
tests/api.c
View File

@@ -410,9 +410,20 @@ typedef struct testVector {
* @return When condition is true: TEST_SUCCESS. * @return When condition is true: TEST_SUCCESS.
* @return When condition is false: TEST_FAIL. * @return When condition is false: TEST_FAIL.
*/ */
#ifdef DEBUG_WOLFSSL_VERBOSE
#define XSTRINGIFY(s) STRINGIFY(s)
#define STRINGIFY(s) #s
#define TEST_RES_CHECK(check) ({ \
int _ret = (check) ? TEST_SUCCESS : TEST_FAIL; \
if (_ret == TEST_FAIL) { \
fprintf(stderr, " check \"%s\" at %d ", \
XSTRINGIFY(check), __LINE__); \
} \
_ret; })
#else
#define TEST_RES_CHECK(check) \ #define TEST_RES_CHECK(check) \
((check) ? TEST_SUCCESS : TEST_FAIL) ((check) ? TEST_SUCCESS : TEST_FAIL)
#endif /* DEBUG_WOLFSSL_VERBOSE */
#define TEST_STRING "Everyone gets Friday off." #define TEST_STRING "Everyone gets Friday off."
#define TEST_STRING_SZ 25 #define TEST_STRING_SZ 25
@@ -17095,6 +17106,7 @@ static int test_wc_ChaCha20Poly1305_aead(void)
plaintext, sizeof(plaintext), generatedCiphertext, NULL); plaintext, sizeof(plaintext), generatedCiphertext, NULL);
if (ret == BAD_FUNC_ARG) { if (ret == BAD_FUNC_ARG) {
ret = 0; ret = 0;
(void)ret; /* suppress never read */
} }
ret = wc_ChaCha20Poly1305_Decrypt(key, iv, aad, sizeof(aad), cipher, ret = wc_ChaCha20Poly1305_Decrypt(key, iv, aad, sizeof(aad), cipher,
@@ -20998,8 +21010,8 @@ static int test_wc_DsaPublicPrivateKeyDecode(void)
DsaKey key; DsaKey key;
word32 bytes; word32 bytes;
word32 idx = 0; word32 idx = 0;
int priv = WOLFSSL_FATAL_ERROR; int priv = 0;
int pub = WOLFSSL_FATAL_ERROR; int pub = 0;
int ret = 0; int ret = 0;
#ifdef USE_CERT_BUFFERS_1024 #ifdef USE_CERT_BUFFERS_1024
@@ -21039,7 +21051,7 @@ static int test_wc_DsaPublicPrivateKeyDecode(void)
if (priv == BAD_FUNC_ARG) { if (priv == BAD_FUNC_ARG) {
priv = wc_DsaPrivateKeyDecode(tmp, &idx, &key, bytes); priv = wc_DsaPrivateKeyDecode(tmp, &idx, &key, bytes);
} }
if (priv == ASN_PARSE_E) { if (priv == ASN_PARSE_E || priv == BUFFER_E) {
priv = 0; priv = 0;
} }
else { else {
@@ -21054,6 +21066,7 @@ static int test_wc_DsaPublicPrivateKeyDecode(void)
if (ret == 0) { if (ret == 0) {
idx = 0; /* Reset */ idx = 0; /* Reset */
pub = wc_DsaPublicKeyDecode(tmp, &idx, &key, bytes); pub = wc_DsaPublicKeyDecode(tmp, &idx, &key, bytes);
/* Test bad args. */ /* Test bad args. */
if (pub == 0) { if (pub == 0) {
pub = wc_DsaPublicKeyDecode(NULL, &idx, &key, bytes); pub = wc_DsaPublicKeyDecode(NULL, &idx, &key, bytes);
@@ -21066,7 +21079,7 @@ static int test_wc_DsaPublicPrivateKeyDecode(void)
if (pub == BAD_FUNC_ARG) { if (pub == BAD_FUNC_ARG) {
pub = wc_DsaPublicKeyDecode(tmp, &idx, &key, bytes); pub = wc_DsaPublicKeyDecode(tmp, &idx, &key, bytes);
} }
if (pub == ASN_PARSE_E) { if (pub == ASN_PARSE_E || pub == BUFFER_E) {
pub = 0; pub = 0;
} }
else { else {
@@ -21078,8 +21091,8 @@ static int test_wc_DsaPublicPrivateKeyDecode(void)
wc_FreeDsaKey(&key); wc_FreeDsaKey(&key);
res = TEST_RES_CHECK(ret == 0); res = TEST_RES_CHECK(ret == 0 && pub == 0 && priv == 0);
#endif #endif /* !NO_DSA */
return res; return res;
} /* END test_wc_DsaPublicPrivateKeyDecode */ } /* END test_wc_DsaPublicPrivateKeyDecode */
@@ -21325,12 +21338,12 @@ static int test_wc_DsaKeyToPublicDer(void)
ret = WOLFSSL_FATAL_ERROR; ret = WOLFSSL_FATAL_ERROR;
} }
XFREE(der,NULL,DYNAMIC_TYPE_TMP_BUFFER); XFREE(der, NULL, DYNAMIC_TYPE_TMP_BUFFER);
wc_FreeDsaKey(&genKey); wc_FreeDsaKey(&genKey);
res = TEST_RES_CHECK(ret == 0); res = TEST_RES_CHECK(ret == 0);
#endif /* !defined(NO_DSA) && defined(WOLFSSL_KEY_GEN) */ #endif /* !NO_DSA && WOLFSSL_KEY_GEN */
#endif /* HAVE_SELFTEST */ #endif /* !HAVE_SELFTEST */
return res; return res;
} /* END test_wc_DsaKeyToPublicDer */ } /* END test_wc_DsaKeyToPublicDer */
@@ -24821,7 +24834,7 @@ static int test_wc_ecc_signVerify_hash(void)
wc_ecc_fp_free(); wc_ecc_fp_free();
#endif #endif
res = TEST_RES_CHECK(ret == 0); res = TEST_RES_CHECK(ret == 0 && signH == 0 && verifyH == 0);
#endif #endif
return res; return res;
} /* END test_wc_ecc_sign_hash */ } /* END test_wc_ecc_sign_hash */
@@ -44571,41 +44584,47 @@ static int test_wolfSSL_EVP_PKEY_assign(void)
(void)pkey; (void)pkey;
#ifndef NO_RSA #ifndef NO_RSA
type = EVP_PKEY_RSA; if (res == TEST_SKIPPED || res == TEST_SUCCESS) {
AssertNotNull(pkey = wolfSSL_EVP_PKEY_new()); type = EVP_PKEY_RSA;
AssertNotNull(rsa = wolfSSL_RSA_new()); AssertNotNull(pkey = wolfSSL_EVP_PKEY_new());
AssertIntEQ(wolfSSL_EVP_PKEY_assign(NULL,type,rsa), WOLFSSL_FAILURE); AssertNotNull(rsa = wolfSSL_RSA_new());
AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,type,NULL), WOLFSSL_FAILURE); AssertIntEQ(wolfSSL_EVP_PKEY_assign(NULL,type,rsa), WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,-1,rsa), WOLFSSL_FAILURE); AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,type,NULL), WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,type,rsa), WOLFSSL_SUCCESS); AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,-1,rsa), WOLFSSL_FAILURE);
wolfSSL_EVP_PKEY_free(pkey); AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,type,rsa), WOLFSSL_SUCCESS);
res = TEST_RES_CHECK(1); wolfSSL_EVP_PKEY_free(pkey);
res = TEST_RES_CHECK(1);
}
#endif /* NO_RSA */ #endif /* NO_RSA */
#ifndef NO_DSA #ifndef NO_DSA
type = EVP_PKEY_DSA; if (res == TEST_SKIPPED || res == TEST_SUCCESS) {
AssertNotNull(pkey = wolfSSL_EVP_PKEY_new()); type = EVP_PKEY_DSA;
AssertNotNull(dsa = wolfSSL_DSA_new()); AssertNotNull(pkey = wolfSSL_EVP_PKEY_new());
AssertIntEQ(wolfSSL_EVP_PKEY_assign(NULL,type,dsa), WOLFSSL_FAILURE); AssertNotNull(dsa = wolfSSL_DSA_new());
AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,type,NULL), WOLFSSL_FAILURE); AssertIntEQ(wolfSSL_EVP_PKEY_assign(NULL,type,dsa), WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,-1,dsa), WOLFSSL_FAILURE); AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,type,NULL), WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,type,dsa), WOLFSSL_SUCCESS); AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,-1,dsa), WOLFSSL_FAILURE);
wolfSSL_EVP_PKEY_free(pkey); AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,type,dsa), WOLFSSL_SUCCESS);
res = TEST_RES_CHECK(1); wolfSSL_EVP_PKEY_free(pkey);
res = TEST_RES_CHECK(1);
}
#endif /* NO_DSA */ #endif /* NO_DSA */
#ifdef HAVE_ECC #ifdef HAVE_ECC
type = EVP_PKEY_EC; if (res == TEST_SKIPPED || res == TEST_SUCCESS) {
AssertNotNull(pkey = wolfSSL_EVP_PKEY_new()); type = EVP_PKEY_EC;
AssertNotNull(ecKey = wolfSSL_EC_KEY_new()); AssertNotNull(pkey = wolfSSL_EVP_PKEY_new());
AssertIntEQ(wolfSSL_EVP_PKEY_assign(NULL,type,ecKey), WOLFSSL_FAILURE); AssertNotNull(ecKey = wolfSSL_EC_KEY_new());
AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,type,NULL), WOLFSSL_FAILURE); AssertIntEQ(wolfSSL_EVP_PKEY_assign(NULL,type,ecKey), WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,-1,ecKey), WOLFSSL_FAILURE); AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,type,NULL), WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,type,ecKey), WOLFSSL_FAILURE); AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,-1,ecKey), WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_EC_KEY_generate_key(ecKey), 1); AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,type,ecKey), WOLFSSL_FAILURE);
AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,type,ecKey), WOLFSSL_SUCCESS); AssertIntEQ(wolfSSL_EC_KEY_generate_key(ecKey), 1);
wolfSSL_EVP_PKEY_free(pkey); AssertIntEQ(wolfSSL_EVP_PKEY_assign(pkey,type,ecKey), WOLFSSL_SUCCESS);
res = TEST_RES_CHECK(1); wolfSSL_EVP_PKEY_free(pkey);
res = TEST_RES_CHECK(1);
}
#endif /* HAVE_ECC */ #endif /* HAVE_ECC */
(void)type; (void)type;
@@ -45187,78 +45206,92 @@ static int test_wolfSSL_EVP_CIPHER_block_size(void)
int res = TEST_SKIPPED; int res = TEST_SKIPPED;
#ifdef HAVE_AES_CBC #ifdef HAVE_AES_CBC
#ifdef WOLFSSL_AES_128 if (res == TEST_SKIPPED || res == TEST_SUCCESS) {
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_128_cbc()), AES_BLOCK_SIZE); #ifdef WOLFSSL_AES_128
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_128_cbc()), AES_BLOCK_SIZE);
#ifdef WOLFSSL_AES_192 #endif
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_192_cbc()), AES_BLOCK_SIZE); #ifdef WOLFSSL_AES_192
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_192_cbc()), AES_BLOCK_SIZE);
#ifdef WOLFSSL_AES_256 #endif
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_256_cbc()), AES_BLOCK_SIZE); #ifdef WOLFSSL_AES_256
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_256_cbc()), AES_BLOCK_SIZE);
res = TEST_RES_CHECK(1); #endif
res = TEST_RES_CHECK(1);
}
#endif #endif
#ifdef HAVE_AESGCM #ifdef HAVE_AESGCM
#ifdef WOLFSSL_AES_128 if (res == TEST_SKIPPED || res == TEST_SUCCESS) {
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_128_gcm()), 1); #ifdef WOLFSSL_AES_128
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_128_gcm()), 1);
#ifdef WOLFSSL_AES_192 #endif
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_192_gcm()), 1); #ifdef WOLFSSL_AES_192
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_192_gcm()), 1);
#ifdef WOLFSSL_AES_256 #endif
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_256_gcm()), 1); #ifdef WOLFSSL_AES_256
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_256_gcm()), 1);
res = TEST_RES_CHECK(1); #endif
res = TEST_RES_CHECK(1);
}
#endif #endif
#ifdef WOLFSSL_AES_COUNTER #ifdef WOLFSSL_AES_COUNTER
#ifdef WOLFSSL_AES_128 if (res == TEST_SKIPPED || res == TEST_SUCCESS) {
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_128_ctr()), 1); #ifdef WOLFSSL_AES_128
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_128_ctr()), 1);
#ifdef WOLFSSL_AES_192 #endif
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_192_ctr()), 1); #ifdef WOLFSSL_AES_192
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_192_ctr()), 1);
#ifdef WOLFSSL_AES_256 #endif
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_256_ctr()), 1); #ifdef WOLFSSL_AES_256
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_256_ctr()), 1);
res = TEST_RES_CHECK(1); #endif
res = TEST_RES_CHECK(1);
}
#endif #endif
#ifdef HAVE_AES_ECB #ifdef HAVE_AES_ECB
#ifdef WOLFSSL_AES_128 if (res == TEST_SKIPPED || res == TEST_SUCCESS) {
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_128_ecb()), AES_BLOCK_SIZE); #ifdef WOLFSSL_AES_128
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_128_ecb()), AES_BLOCK_SIZE);
#ifdef WOLFSSL_AES_192 #endif
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_192_ecb()), AES_BLOCK_SIZE); #ifdef WOLFSSL_AES_192
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_192_ecb()), AES_BLOCK_SIZE);
#ifdef WOLFSSL_AES_256 #endif
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_256_ecb()), AES_BLOCK_SIZE); #ifdef WOLFSSL_AES_256
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_256_ecb()), AES_BLOCK_SIZE);
res = TEST_RES_CHECK(1); #endif
res = TEST_RES_CHECK(1);
}
#endif #endif
#ifdef WOLFSSL_AES_OFB #ifdef WOLFSSL_AES_OFB
#ifdef WOLFSSL_AES_128 if (res == TEST_SKIPPED || res == TEST_SUCCESS) {
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_128_ofb()), 1); #ifdef WOLFSSL_AES_128
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_128_ofb()), 1);
#ifdef WOLFSSL_AES_192 #endif
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_192_ofb()), 1); #ifdef WOLFSSL_AES_192
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_192_ofb()), 1);
#ifdef WOLFSSL_AES_256 #endif
AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_256_ofb()), 1); #ifdef WOLFSSL_AES_256
#endif AssertIntEQ(EVP_CIPHER_block_size(EVP_aes_256_ofb()), 1);
res = TEST_RES_CHECK(1); #endif
res = TEST_RES_CHECK(1);
}
#endif #endif
#ifndef NO_RC4 #ifndef NO_RC4
AssertIntEQ(EVP_CIPHER_block_size(wolfSSL_EVP_rc4()), 1); if (res == TEST_SKIPPED || res == TEST_SUCCESS) {
res = TEST_RES_CHECK(1); AssertIntEQ(EVP_CIPHER_block_size(wolfSSL_EVP_rc4()), 1);
res = TEST_RES_CHECK(1);
}
#endif #endif
#if defined(HAVE_CHACHA) && defined(HAVE_POLY1305) #if defined(HAVE_CHACHA) && defined(HAVE_POLY1305)
AssertIntEQ(EVP_CIPHER_block_size(wolfSSL_EVP_chacha20_poly1305()), 1); if (res == TEST_SKIPPED || res == TEST_SUCCESS) {
res = TEST_RES_CHECK(1); AssertIntEQ(EVP_CIPHER_block_size(wolfSSL_EVP_chacha20_poly1305()), 1);
res = TEST_RES_CHECK(1);
}
#endif #endif
return res; return res;
@@ -54951,52 +54984,56 @@ static int test_wolfSSL_d2i_DHparams(void)
/* Test 2048 bit parameters */ /* Test 2048 bit parameters */
#ifdef HAVE_FFDHE_2048 #ifdef HAVE_FFDHE_2048
f = XFOPEN(params1, "rb"); if (res == TEST_SKIPPED || res == TEST_SUCCESS) {
AssertTrue(f != XBADFILE); f = XFOPEN(params1, "rb");
len = (long)XFREAD(buf, 1, sizeof(buf), f); AssertTrue(f != XBADFILE);
XFCLOSE(f); len = (long)XFREAD(buf, 1, sizeof(buf), f);
XFCLOSE(f);
/* Valid case */ /* Valid case */
AssertNotNull(dh = wolfSSL_d2i_DHparams(NULL, &pt, len)); AssertNotNull(dh = wolfSSL_d2i_DHparams(NULL, &pt, len));
AssertNotNull(dh->p); AssertNotNull(dh->p);
AssertNotNull(dh->g); AssertNotNull(dh->g);
AssertTrue(pt == buf); AssertTrue(pt == buf);
AssertIntEQ(DH_set_length(NULL, BN_num_bits(dh->p)), 0); AssertIntEQ(DH_set_length(NULL, BN_num_bits(dh->p)), 0);
AssertIntEQ(DH_set_length(dh, BN_num_bits(dh->p)), 1); AssertIntEQ(DH_set_length(dh, BN_num_bits(dh->p)), 1);
AssertIntEQ(DH_generate_key(dh), WOLFSSL_SUCCESS); AssertIntEQ(DH_generate_key(dh), WOLFSSL_SUCCESS);
/* Invalid cases */ /* Invalid cases */
AssertNull(wolfSSL_d2i_DHparams(NULL, NULL, len)); AssertNull(wolfSSL_d2i_DHparams(NULL, NULL, len));
AssertNull(wolfSSL_d2i_DHparams(NULL, &pt, -1)); AssertNull(wolfSSL_d2i_DHparams(NULL, &pt, -1));
AssertNull(wolfSSL_d2i_DHparams(NULL, &pt, 10)); AssertNull(wolfSSL_d2i_DHparams(NULL, &pt, 10));
DH_free(dh); DH_free(dh);
*buf = 0; *buf = 0;
pt = buf; pt = buf;
res = TEST_RES_CHECK(1); res = TEST_RES_CHECK(1);
}
#endif /* HAVE_FFDHE_2048 */ #endif /* HAVE_FFDHE_2048 */
/* Test 3072 bit parameters */ /* Test 3072 bit parameters */
#ifdef HAVE_FFDHE_3072 #ifdef HAVE_FFDHE_3072
f = XFOPEN(params2, "rb"); if (res == TEST_SKIPPED || res == TEST_SUCCESS) {
AssertTrue(f != XBADFILE); f = XFOPEN(params2, "rb");
len = (long)XFREAD(buf, 1, sizeof(buf), f); AssertTrue(f != XBADFILE);
XFCLOSE(f); len = (long)XFREAD(buf, 1, sizeof(buf), f);
XFCLOSE(f);
/* Valid case */ /* Valid case */
AssertNotNull(dh = wolfSSL_d2i_DHparams(&dh, &pt, len)); AssertNotNull(dh = wolfSSL_d2i_DHparams(&dh, &pt, len));
AssertNotNull(dh->p); AssertNotNull(dh->p);
AssertNotNull(dh->g); AssertNotNull(dh->g);
AssertTrue(pt != buf); AssertTrue(pt != buf);
AssertIntEQ(DH_generate_key(dh), 1); AssertIntEQ(DH_generate_key(dh), 1);
/* Invalid cases */ /* Invalid cases */
AssertNull(wolfSSL_d2i_DHparams(NULL, NULL, len)); AssertNull(wolfSSL_d2i_DHparams(NULL, NULL, len));
AssertNull(wolfSSL_d2i_DHparams(NULL, &pt, -1)); AssertNull(wolfSSL_d2i_DHparams(NULL, &pt, -1));
DH_free(dh); DH_free(dh);
res = TEST_RES_CHECK(1); res = TEST_RES_CHECK(1);
}
#endif /* HAVE_FFDHE_3072 */ #endif /* HAVE_FFDHE_3072 */
#endif /* !HAVE_FIPS || HAVE_FIPS_VERSION > 2 */ #endif /* !HAVE_FIPS || HAVE_FIPS_VERSION > 2 */
@@ -55200,7 +55237,7 @@ static int test_openssl_generate_key_and_cert(void)
int res = TEST_SKIPPED; int res = TEST_SKIPPED;
#if defined(OPENSSL_EXTRA) #if defined(OPENSSL_EXTRA)
#if !defined(NO_RSA) #if !defined(NO_RSA)
{ if (res == TEST_SKIPPED || res == TEST_SUCCESS) {
EVP_PKEY* pkey = EVP_PKEY_new(); EVP_PKEY* pkey = EVP_PKEY_new();
int key_length = 2048; int key_length = 2048;
BIGNUM* exponent = BN_new(); BIGNUM* exponent = BN_new();
@@ -55244,12 +55281,12 @@ static int test_openssl_generate_key_and_cert(void)
} }
EVP_PKEY_free(pkey); EVP_PKEY_free(pkey);
res = TEST_RES_CHECK(1);
} }
res = TEST_RES_CHECK(1);
#endif /* !NO_RSA */ #endif /* !NO_RSA */
#ifdef HAVE_ECC #ifdef HAVE_ECC
{ if (res == TEST_SKIPPED || res == TEST_SUCCESS) {
EVP_PKEY* pkey = EVP_PKEY_new(); EVP_PKEY* pkey = EVP_PKEY_new();
EC_KEY* ec_key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1); EC_KEY* ec_key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
@@ -55269,8 +55306,8 @@ static int test_openssl_generate_key_and_cert(void)
#endif #endif
EVP_PKEY_free(pkey); EVP_PKEY_free(pkey);
res = TEST_RES_CHECK(1);
} }
res = TEST_RES_CHECK(1);
#endif /* HAVE_ECC */ #endif /* HAVE_ECC */
#endif /* OPENSSL_EXTRA */ #endif /* OPENSSL_EXTRA */
return res; return res;

2
wolfcrypt/src/asn.c
View File

@@ -10395,7 +10395,7 @@ int wc_DsaPublicKeyDecode(const byte* input, word32* inOutIdx, DsaKey* key,
for (i = 0; i < DSA_INTS - 1; i++) for (i = 0; i < DSA_INTS - 1; i++)
GetASN_MP(&dataASN[(int)DSAKEYASN_IDX_VER + i], GetDsaInt(key, i)); GetASN_MP(&dataASN[(int)DSAKEYASN_IDX_VER + i], GetDsaInt(key, i));
/* Parse as simple form. */ /* Parse as simple form. */
ret = GetASN_Items(dsaKeyASN, dataASN, dsaPublicKeyASN_Length, 1, input, ret = GetASN_Items(dsaKeyASN, dataASN, dsaPublicKeyASN_Length, 0, input,
inOutIdx, inSz); inOutIdx, inSz);
if (ret != 0) { if (ret != 0) {
/* Clear dynamic data items. */ /* Clear dynamic data items. */

2
wolfssl/wolfcrypt/mem_track.h
View File

@@ -558,8 +558,6 @@ int StackSizeHWMReset(void)
fprintf(stderr, "%ld\t%s\n", (long int)HWM, msg); \ fprintf(stderr, "%ld\t%s\n", (long int)HWM, msg); \
StackSizeHWMReset(); \ StackSizeHWMReset(); \
}) })
\
#define STACK_SIZE_CHECKPOINT_WITH_MAX_CHECK(max, ...) ({ \ #define STACK_SIZE_CHECKPOINT_WITH_MAX_CHECK(max, ...) ({ \
ssize_t HWM = StackSizeHWM_OffsetCorrected(); \ ssize_t HWM = StackSizeHWM_OffsetCorrected(); \