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

fix codebase for -Wvla -Wdeclaration-after-statement; fix some whitespace.

Browse Source
This commit is contained in:
Daniel Pouzzner
2022-04-01 14:44:10 -05:00
parent bd0e222fec
commit ae3996fd0e
6 changed files with 300 additions and 239 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/internal.c
View File

@ -10938,7 +10938,6 @@ static int ProcessCSR(WOLFSSL* ssl, byte* input, word32* inOutIdx,
{ {
int ret = 0; int ret = 0;
OcspRequest* request; OcspRequest* request;
WOLFSSL_ENTER("ProcessCSR");
#ifdef WOLFSSL_SMALL_STACK #ifdef WOLFSSL_SMALL_STACK
CertStatus* status; CertStatus* status;
@ -10950,6 +10949,8 @@ static int ProcessCSR(WOLFSSL* ssl, byte* input, word32* inOutIdx,
OcspResponse response[1]; OcspResponse response[1];
#endif #endif
WOLFSSL_ENTER("ProcessCSR");
do { do {
#ifdef HAVE_CERTIFICATE_STATUS_REQUEST #ifdef HAVE_CERTIFICATE_STATUS_REQUEST
if (ssl->status_request) { if (ssl->status_request) {

257
tests/api.c
View File

@ -3651,10 +3651,10 @@ static void test_wolfSSL_EVP_ENCODE_CTX_new(void)
{ {
#if defined(OPENSSL_EXTRA) && \ #if defined(OPENSSL_EXTRA) && \
( defined(WOLFSSL_BASE64_ENCODE) || defined(WOLFSSL_BASE64_DECODE)) ( defined(WOLFSSL_BASE64_ENCODE) || defined(WOLFSSL_BASE64_DECODE))
printf(testingFmt, "EVP_ENCODE_CTX_new()");
EVP_ENCODE_CTX* ctx = NULL; EVP_ENCODE_CTX* ctx = NULL;
printf(testingFmt, "EVP_ENCODE_CTX_new()");
AssertNotNull( ctx = EVP_ENCODE_CTX_new()); AssertNotNull( ctx = EVP_ENCODE_CTX_new());
AssertIntEQ( ctx->remaining,0); AssertIntEQ( ctx->remaining,0);
AssertIntEQ( ctx->data[0],0); AssertIntEQ( ctx->data[0],0);
@ -3668,9 +3668,10 @@ static void test_wolfSSL_EVP_ENCODE_CTX_free(void)
{ {
#if defined(OPENSSL_EXTRA) && \ #if defined(OPENSSL_EXTRA) && \
( defined(WOLFSSL_BASE64_ENCODE) || defined(WOLFSSL_BASE64_DECODE)) ( defined(WOLFSSL_BASE64_ENCODE) || defined(WOLFSSL_BASE64_DECODE))
printf(testingFmt, "EVP_ENCODE_CTX_free()");
EVP_ENCODE_CTX* ctx = NULL; EVP_ENCODE_CTX* ctx = NULL;
printf(testingFmt, "EVP_ENCODE_CTX_free()");
AssertNotNull( ctx = EVP_ENCODE_CTX_new()); AssertNotNull( ctx = EVP_ENCODE_CTX_new());
EVP_ENCODE_CTX_free(ctx); EVP_ENCODE_CTX_free(ctx);
printf(resultFmt, passed); printf(resultFmt, passed);
@ -3680,9 +3681,10 @@ static void test_wolfSSL_EVP_ENCODE_CTX_free(void)
static void test_wolfSSL_EVP_EncodeInit(void) static void test_wolfSSL_EVP_EncodeInit(void)
{ {
#if defined(OPENSSL_EXTRA) && defined(WOLFSSL_BASE64_ENCODE) #if defined(OPENSSL_EXTRA) && defined(WOLFSSL_BASE64_ENCODE)
printf(testingFmt, "EVP_EncodeInit()");
EVP_ENCODE_CTX* ctx = NULL; EVP_ENCODE_CTX* ctx = NULL;
printf(testingFmt, "EVP_EncodeInit()");
AssertNotNull( ctx = EVP_ENCODE_CTX_new()); AssertNotNull( ctx = EVP_ENCODE_CTX_new());
AssertIntEQ( ctx->remaining,0); AssertIntEQ( ctx->remaining,0);
AssertIntEQ( ctx->data[0],0); AssertIntEQ( ctx->data[0],0);
@ -3705,7 +3707,6 @@ static void test_wolfSSL_EVP_EncodeInit(void)
static void test_wolfSSL_EVP_EncodeUpdate(void) static void test_wolfSSL_EVP_EncodeUpdate(void)
{ {
#if defined(OPENSSL_EXTRA) && defined(WOLFSSL_BASE64_ENCODE) #if defined(OPENSSL_EXTRA) && defined(WOLFSSL_BASE64_ENCODE)
printf(testingFmt, "EVP_EncodeUpdate()");
int outl; int outl;
int total; int total;
@ -3723,6 +3724,9 @@ static void test_wolfSSL_EVP_EncodeUpdate(void)
unsigned char encOutBuff[300]; unsigned char encOutBuff[300];
EVP_ENCODE_CTX* ctx = NULL; EVP_ENCODE_CTX* ctx = NULL;
printf(testingFmt, "EVP_EncodeUpdate()");
AssertNotNull( ctx = EVP_ENCODE_CTX_new()); AssertNotNull( ctx = EVP_ENCODE_CTX_new());
EVP_EncodeInit(ctx); EVP_EncodeInit(ctx);
@ -3909,10 +3913,10 @@ static void test_wolfSSL_EVP_EncodeFinal(void)
static void test_wolfSSL_EVP_DecodeInit(void) static void test_wolfSSL_EVP_DecodeInit(void)
{ {
#if defined(OPENSSL_EXTRA) && defined(WOLFSSL_BASE64_DECODE) #if defined(OPENSSL_EXTRA) && defined(WOLFSSL_BASE64_DECODE)
printf(testingFmt, "EVP_DecodeInit()");
EVP_ENCODE_CTX* ctx = NULL; EVP_ENCODE_CTX* ctx = NULL;
printf(testingFmt, "EVP_DecodeInit()");
AssertNotNull( ctx = EVP_ENCODE_CTX_new()); AssertNotNull( ctx = EVP_ENCODE_CTX_new());
AssertIntEQ( ctx->remaining,0); AssertIntEQ( ctx->remaining,0);
AssertIntEQ( ctx->data[0],0); AssertIntEQ( ctx->data[0],0);
@ -3935,19 +3939,22 @@ static void test_wolfSSL_EVP_DecodeInit(void)
static void test_wolfSSL_EVP_DecodeUpdate(void) static void test_wolfSSL_EVP_DecodeUpdate(void)
{ {
#if defined(OPENSSL_EXTRA) && defined(WOLFSSL_BASE64_DECODE) #if defined(OPENSSL_EXTRA) && defined(WOLFSSL_BASE64_DECODE)
printf(testingFmt, "EVP_DecodeUpdate()");
int outl; int outl;
unsigned char decOutBuff[300]; unsigned char decOutBuff[300];
EVP_ENCODE_CTX* ctx = EVP_ENCODE_CTX_new(); EVP_ENCODE_CTX* ctx;
EVP_DecodeInit(ctx);
const unsigned char enc1[] = static const unsigned char enc1[] =
{"VGhpcyBpcyBhIGJhc2U2NCBkZWNvZGluZyB0ZXN0Lg==\n"}; {"VGhpcyBpcyBhIGJhc2U2NCBkZWNvZGluZyB0ZXN0Lg==\n"};
/* const unsigned char plain1[] = /* const unsigned char plain1[] =
{"This is a base64 decoding test."} */ {"This is a base64 decoding test."} */
printf(testingFmt, "EVP_DecodeUpdate()");
ctx = EVP_ENCODE_CTX_new();
EVP_DecodeInit(ctx);
/* illegal parameter tests */ /* illegal parameter tests */
/* pass NULL as ctx */ /* pass NULL as ctx */
@ -4013,9 +4020,10 @@ static void test_wolfSSL_EVP_DecodeUpdate(void)
/* decode correct base64 string */ /* decode correct base64 string */
const unsigned char enc2[] = {
static const unsigned char enc2[] =
{"VGhpcyBpcyBhIGJhc2U2NCBkZWNvZGluZyB0ZXN0Lg==\n"}; {"VGhpcyBpcyBhIGJhc2U2NCBkZWNvZGluZyB0ZXN0Lg==\n"};
const unsigned char plain2[] = static const unsigned char plain2[] =
{"This is a base64 decoding test."}; {"This is a base64 decoding test."};
EVP_EncodeInit(ctx); EVP_EncodeInit(ctx);
@ -4043,17 +4051,18 @@ static void test_wolfSSL_EVP_DecodeUpdate(void)
AssertIntEQ(XSTRNCMP( (const char*)plain2,(const char*)decOutBuff, AssertIntEQ(XSTRNCMP( (const char*)plain2,(const char*)decOutBuff,
sizeof(plain2) -1 ),0); sizeof(plain2) -1 ),0);
AssertIntEQ(EVP_DecodeBlock(decOutBuff, enc2, sizeof(enc2)), AssertIntEQ(EVP_DecodeBlock(decOutBuff, enc2, sizeof(enc2)),
sizeof(plain2)-1); sizeof(plain2)-1);
AssertIntEQ(XSTRNCMP( (const char*)plain2,(const char*)decOutBuff, AssertIntEQ(XSTRNCMP( (const char*)plain2,(const char*)decOutBuff,
sizeof(plain2) -1 ),0); sizeof(plain2) -1 ),0);
}
/* decode correct base64 string which does not have '\n' in its last*/ /* decode correct base64 string which does not have '\n' in its last*/
const unsigned char enc3[] = {
static const unsigned char enc3[] =
{"VGhpcyBpcyBhIGJhc2U2NCBkZWNvZGluZyB0ZXN0Lg=="}; /* 44 chars */ {"VGhpcyBpcyBhIGJhc2U2NCBkZWNvZGluZyB0ZXN0Lg=="}; /* 44 chars */
const unsigned char plain3[] = static const unsigned char plain3[] =
{"This is a base64 decoding test."}; /* 31 chars */ {"This is a base64 decoding test."}; /* 31 chars */
EVP_EncodeInit(ctx); EVP_EncodeInit(ctx);
@ -4085,15 +4094,16 @@ static void test_wolfSSL_EVP_DecodeUpdate(void)
AssertIntEQ(EVP_DecodeBlock(decOutBuff, enc3, sizeof(enc3)-1), AssertIntEQ(EVP_DecodeBlock(decOutBuff, enc3, sizeof(enc3)-1),
sizeof(plain3)-1); sizeof(plain3)-1);
AssertIntEQ(XSTRNCMP( (const char*)plain2,(const char*)decOutBuff, AssertIntEQ(XSTRNCMP( (const char*)plain3,(const char*)decOutBuff,
sizeof(plain3) -1 ),0); sizeof(plain3) -1 ),0);
}
/* decode string which has a padding char ('=') in the illegal position*/ /* decode string which has a padding char ('=') in the illegal position*/
const unsigned char enc4[] = {
static const unsigned char enc4[] =
{"VGhpcyBpcyBhIGJhc2U2N=CBkZWNvZGluZyB0ZXN0Lg==\n"}; {"VGhpcyBpcyBhIGJhc2U2N=CBkZWNvZGluZyB0ZXN0Lg==\n"};
EVP_EncodeInit(ctx); EVP_EncodeInit(ctx);
AssertIntEQ( AssertIntEQ(
@ -4106,14 +4116,15 @@ static void test_wolfSSL_EVP_DecodeUpdate(void)
-1 /* expected result code -1: error */ -1 /* expected result code -1: error */
); );
AssertIntEQ(outl,0); AssertIntEQ(outl,0);
AssertIntEQ(EVP_DecodeBlock(decOutBuff, enc4, sizeof(enc4)-1), -1); AssertIntEQ(EVP_DecodeBlock(decOutBuff, enc4, sizeof(enc4)-1), -1);
}
/* small data decode test */ /* small data decode test */
const unsigned char enc00[] = {"VG"}; {
const unsigned char enc01[] = {"g=\n"}; static const unsigned char enc00[] = {"VG"};
const unsigned char plain4[] = {"Th"}; static const unsigned char enc01[] = {"g=\n"};
static const unsigned char plain4[] = {"Th"};
EVP_EncodeInit(ctx); EVP_EncodeInit(ctx);
@ -4157,6 +4168,7 @@ static void test_wolfSSL_EVP_DecodeUpdate(void)
(const char*)decOutBuff, (const char*)decOutBuff,
(const char*)plain4,sizeof(plain4)-1 ), (const char*)plain4,sizeof(plain4)-1 ),
0); 0);
}
EVP_ENCODE_CTX_free(ctx); EVP_ENCODE_CTX_free(ctx);
@ -6074,8 +6086,6 @@ static void test_wolfSSL_CTX_verifyDepth_ServerClient(void)
static void test_client_get_finished(void* args, cbType cb) static void test_client_get_finished(void* args, cbType cb)
{ {
(void) args;
(void) cb;
#if defined(OPENSSL_ALL) || defined(WOLFSSL_HAPROXY) || defined(WOLFSSL_WPAS) #if defined(OPENSSL_ALL) || defined(WOLFSSL_HAPROXY) || defined(WOLFSSL_WPAS)
SOCKET_T sockfd = 0; SOCKET_T sockfd = 0;
callback_functions* cbf; callback_functions* cbf;
@ -6090,6 +6100,9 @@ static void test_client_get_finished(void* args, cbType cb)
WOLFSSL_METHOD* method = NULL; WOLFSSL_METHOD* method = NULL;
size_t msg_len = 0; size_t msg_len = 0;
(void) args;
(void) cb;
((func_args*)args)->return_code = TEST_FAIL; ((func_args*)args)->return_code = TEST_FAIL;
cbf = ((func_args*)args)->callbacks; cbf = ((func_args*)args)->callbacks;
@ -6215,6 +6228,9 @@ done:
CloseSocket(sockfd); CloseSocket(sockfd);
return; return;
#else
(void)args;
(void)cb;
#endif #endif
} }
@ -7536,30 +7552,36 @@ static void test_wolfSSL_UseMaxFragment(void)
!defined(NO_FILESYSTEM) && !defined(NO_RSA) !defined(NO_FILESYSTEM) && !defined(NO_RSA)
#ifndef NO_WOLFSSL_SERVER #ifndef NO_WOLFSSL_SERVER
WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfSSLv23_server_method()); WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfSSLv23_server_method());
AssertTrue(wolfSSL_CTX_use_certificate_file(ctx, svrCertFile, WOLFSSL_FILETYPE_PEM));
AssertTrue(wolfSSL_CTX_use_PrivateKey_file(ctx, svrKeyFile, WOLFSSL_FILETYPE_PEM));
#else #else
WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfSSLv23_client_method()); WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfSSLv23_client_method());
#endif #endif
WOLFSSL *ssl = wolfSSL_new(ctx); WOLFSSL *ssl;
#ifdef OPENSSL_EXTRA #ifdef OPENSSL_EXTRA
int (*UseMaxFragment)(SSL *s, uint8_t mode); int (*UseMaxFragment)(SSL *s, uint8_t mode);
int (*CTX_UseMaxFragment)(SSL_CTX *c, uint8_t mode); int (*CTX_UseMaxFragment)(SSL_CTX *c, uint8_t mode);
CTX_UseMaxFragment = SSL_CTX_set_tlsext_max_fragment_length;
UseMaxFragment = SSL_set_tlsext_max_fragment_length;
#else #else
int (*UseMaxFragment)(WOLFSSL *s, unsigned char mode); int (*UseMaxFragment)(WOLFSSL *s, unsigned char mode);
int (*CTX_UseMaxFragment)(WOLFSSL_CTX *c, unsigned char mode); int (*CTX_UseMaxFragment)(WOLFSSL_CTX *c, unsigned char mode);
#endif
UseMaxFragment = wolfSSL_UseMaxFragment; #ifndef NO_WOLFSSL_SERVER
CTX_UseMaxFragment = wolfSSL_CTX_UseMaxFragment; AssertTrue(wolfSSL_CTX_use_certificate_file(ctx, svrCertFile, WOLFSSL_FILETYPE_PEM));
AssertTrue(wolfSSL_CTX_use_PrivateKey_file(ctx, svrKeyFile, WOLFSSL_FILETYPE_PEM));
#endif #endif
AssertNotNull(ctx); AssertNotNull(ctx);
ssl = wolfSSL_new(ctx);
AssertNotNull(ssl); AssertNotNull(ssl);
#ifdef OPENSSL_EXTRA
CTX_UseMaxFragment = SSL_CTX_set_tlsext_max_fragment_length;
UseMaxFragment = SSL_set_tlsext_max_fragment_length;
#else
UseMaxFragment = wolfSSL_UseMaxFragment;
CTX_UseMaxFragment = wolfSSL_CTX_UseMaxFragment;
#endif
/* error cases */ /* error cases */
AssertIntNE(WOLFSSL_SUCCESS, CTX_UseMaxFragment(NULL, WOLFSSL_MFL_2_9)); AssertIntNE(WOLFSSL_SUCCESS, CTX_UseMaxFragment(NULL, WOLFSSL_MFL_2_9));
AssertIntNE(WOLFSSL_SUCCESS, UseMaxFragment( NULL, WOLFSSL_MFL_2_9)); AssertIntNE(WOLFSSL_SUCCESS, UseMaxFragment( NULL, WOLFSSL_MFL_2_9));
@ -7609,14 +7631,19 @@ static void test_wolfSSL_UseTruncatedHMAC(void)
!defined(NO_FILESYSTEM) && !defined(NO_RSA) !defined(NO_FILESYSTEM) && !defined(NO_RSA)
#ifndef NO_WOLFSSL_SERVER #ifndef NO_WOLFSSL_SERVER
WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfSSLv23_server_method()); WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfSSLv23_server_method());
AssertTrue(wolfSSL_CTX_use_certificate_file(ctx, svrCertFile, WOLFSSL_FILETYPE_PEM));
AssertTrue(wolfSSL_CTX_use_PrivateKey_file(ctx, svrKeyFile, WOLFSSL_FILETYPE_PEM));
#else #else
WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfSSLv23_client_method()); WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfSSLv23_client_method());
#endif #endif
WOLFSSL *ssl = wolfSSL_new(ctx); WOLFSSL *ssl;
AssertNotNull(ctx); AssertNotNull(ctx);
#ifndef NO_WOLFSSL_SERVER
AssertTrue(wolfSSL_CTX_use_certificate_file(ctx, svrCertFile, WOLFSSL_FILETYPE_PEM));
AssertTrue(wolfSSL_CTX_use_PrivateKey_file(ctx, svrKeyFile, WOLFSSL_FILETYPE_PEM));
#endif
ssl = wolfSSL_new(ctx);
AssertNotNull(ssl); AssertNotNull(ssl);
/* error cases */ /* error cases */
@ -25391,14 +25418,14 @@ static int test_wc_ecc_encryptDecrypt (void)
ecc_key srvKey, cliKey, tmpKey; ecc_key srvKey, cliKey, tmpKey;
WC_RNG rng; WC_RNG rng;
const char* msg = "EccBlock Size 16"; const char* msg = "EccBlock Size 16";
word32 msgSz = (word32)XSTRLEN(msg); word32 msgSz = (word32)XSTRLEN("EccBlock Size 16");
#ifdef WOLFSSL_ECIES_OLD #ifdef WOLFSSL_ECIES_OLD
byte out[XSTRLEN(msg) + WC_SHA256_DIGEST_SIZE]; byte out[(sizeof("EccBlock Size 16") - 1) + WC_SHA256_DIGEST_SIZE];
#else #else
byte out[KEY20 * 2 + 1 + XSTRLEN(msg) + WC_SHA256_DIGEST_SIZE]; byte out[KEY20 * 2 + 1 + (sizeof("EccBlock Size 16") - 1) + WC_SHA256_DIGEST_SIZE];
#endif #endif
word32 outSz = (word32)sizeof(out); word32 outSz = (word32)sizeof(out);
byte plain[XSTRLEN(msg) + 1]; byte plain[sizeof("EccBlock Size 16")];
word32 plainSz = (word32)sizeof(plain); word32 plainSz = (word32)sizeof(plain);
int keySz = KEY20; int keySz = KEY20;
@ -26974,8 +27001,9 @@ static void test_wc_PKCS7_InitWithCert (void)
#endif #endif
#ifdef HAVE_ECC #ifdef HAVE_ECC
{
/* bad test case from ZD 11011, malformed cert gives bad ECC key */ /* bad test case from ZD 11011, malformed cert gives bad ECC key */
unsigned char certWithInvalidEccKey[] = { static unsigned char certWithInvalidEccKey[] = {
0x30, 0x82, 0x03, 0x5F, 0x30, 0x82, 0x03, 0x04, 0xA0, 0x03, 0x02, 0x01, 0x30, 0x82, 0x03, 0x5F, 0x30, 0x82, 0x03, 0x04, 0xA0, 0x03, 0x02, 0x01,
0x02, 0x02, 0x14, 0x61, 0xB3, 0x1E, 0x59, 0xF3, 0x68, 0x6C, 0xA4, 0x79, 0x02, 0x02, 0x14, 0x61, 0xB3, 0x1E, 0x59, 0xF3, 0x68, 0x6C, 0xA4, 0x79,
0x42, 0x83, 0x2F, 0x1A, 0x50, 0x71, 0x03, 0xBE, 0x31, 0xAA, 0x2C, 0x30, 0x42, 0x83, 0x2F, 0x1A, 0x50, 0x71, 0x03, 0xBE, 0x31, 0xAA, 0x2C, 0x30,
@ -27072,6 +27100,7 @@ static void test_wc_PKCS7_InitWithCert (void)
AssertIntLT(wc_PKCS7_InitWithCert(pkcs7, certWithInvalidEccKey, AssertIntLT(wc_PKCS7_InitWithCert(pkcs7, certWithInvalidEccKey,
sizeof(certWithInvalidEccKey)), 0); sizeof(certWithInvalidEccKey)), 0);
#endif #endif
}
printf(resultFmt, passed); printf(resultFmt, passed);
@ -28055,6 +28084,7 @@ static void test_wc_PKCS7_EncodeDecodeEnvelopedData (void)
(void)keyFile; (void)keyFile;
(void)certFile; (void)certFile;
{
const pkcs7EnvelopedVector testVectors[] = { const pkcs7EnvelopedVector testVectors[] = {
/* DATA is a global variable defined in the makefile. */ /* DATA is a global variable defined in the makefile. */
#if !defined(NO_RSA) #if !defined(NO_RSA)
@ -28139,6 +28169,7 @@ static void test_wc_PKCS7_EncodeDecodeEnvelopedData (void)
AssertNotNull(pkcs7 = wc_PKCS7_New(HEAP_HINT, devId)); AssertNotNull(pkcs7 = wc_PKCS7_New(HEAP_HINT, devId));
} }
} /* END test loop. */ } /* END test loop. */
}
/* Test bad args. */ /* Test bad args. */
AssertIntEQ(wc_PKCS7_EncodeEnvelopedData(NULL, output, AssertIntEQ(wc_PKCS7_EncodeEnvelopedData(NULL, output,
@ -29381,8 +29412,7 @@ static int test_wc_HashSetFlags(void)
wc_HashAlg hash; wc_HashAlg hash;
word32 flags = 0; word32 flags = 0;
int i, j; int i, j;
printf(testingFmt, "wc_HashSetFlags()"); int notSupportedLen;
/* enum for holding supported algorithms, #ifndef's restrict if disabled */ /* enum for holding supported algorithms, #ifndef's restrict if disabled */
enum wc_HashType enumArray[] = { enum wc_HashType enumArray[] = {
@ -29420,6 +29450,8 @@ static int test_wc_HashSetFlags(void)
/* dynamically finds the length */ /* dynamically finds the length */
int enumlen = (sizeof(enumArray)/sizeof(enum wc_HashType)); int enumlen = (sizeof(enumArray)/sizeof(enum wc_HashType));
printf(testingFmt, "wc_HashSetFlags()");
/* For loop to test various arguments... */ /* For loop to test various arguments... */
for (i = 0; i < enumlen; i++) { for (i = 0; i < enumlen; i++) {
ret = wc_HashInit(&hash, enumArray[i]); ret = wc_HashInit(&hash, enumArray[i]);
@ -29442,7 +29474,7 @@ static int test_wc_HashSetFlags(void)
} }
/* For loop to test not supported cases */ /* For loop to test not supported cases */
int notSupportedLen = (sizeof(notSupported)/sizeof(enum wc_HashType)); notSupportedLen = (sizeof(notSupported)/sizeof(enum wc_HashType));
for (j = 0; ret == 0 && j < notSupportedLen; j++){ for (j = 0; ret == 0 && j < notSupportedLen; j++){
ret = wc_HashInit(&hash, notSupported[j]); ret = wc_HashInit(&hash, notSupported[j]);
if (ret == 0) { if (ret == 0) {
@ -29483,8 +29515,6 @@ static int test_wc_HashGetFlags(void)
wc_HashAlg hash; wc_HashAlg hash;
word32 flags = 0; word32 flags = 0;
int i, j; int i, j;
printf(testingFmt, "wc_HashGetFlags()");
/* enum for holding supported algorithms, #ifndef's restrict if disabled */ /* enum for holding supported algorithms, #ifndef's restrict if disabled */
enum wc_HashType enumArray[] = { enum wc_HashType enumArray[] = {
@ -29519,6 +29549,9 @@ static int test_wc_HashGetFlags(void)
WC_HASH_TYPE_NONE, WC_HASH_TYPE_NONE,
}; };
int enumlen = (sizeof(enumArray)/sizeof(enum wc_HashType)); int enumlen = (sizeof(enumArray)/sizeof(enum wc_HashType));
int notSupportedLen;
printf(testingFmt, "wc_HashGetFlags()");
/* For loop to test various arguments... */ /* For loop to test various arguments... */
for (i = 0; i < enumlen; i++) { for (i = 0; i < enumlen; i++) {
@ -29543,7 +29576,7 @@ static int test_wc_HashGetFlags(void)
} }
} }
/* For loop to test not supported cases */ /* For loop to test not supported cases */
int notSupportedLen = (sizeof(notSupported)/sizeof(enum wc_HashType)); notSupportedLen = (sizeof(notSupported)/sizeof(enum wc_HashType));
for (j = 0; ret == 0 && j < notSupportedLen; j++){ for (j = 0; ret == 0 && j < notSupportedLen; j++){
ret = wc_HashInit(&hash, notSupported[j]); ret = wc_HashInit(&hash, notSupported[j]);
if (ret == 0) { if (ret == 0) {
@ -34684,11 +34717,13 @@ static void test_wolfSSL_BN(void)
/* set b back to 2 */ /* set b back to 2 */
AssertIntEQ(BN_set_word(b, 2), SSL_SUCCESS); AssertIntEQ(BN_set_word(b, 2), SSL_SUCCESS);
{
/* BN_mod_inverse test */ /* BN_mod_inverse test */
BIGNUM *r = BN_new(); BIGNUM *r = BN_new();
BIGNUM *val = BN_mod_inverse(r,b,c,NULL); BIGNUM *val = BN_mod_inverse(r,b,c,NULL);
AssertIntEQ((int)(BN_get_word(r) & 0x03), 3); AssertIntEQ((int)(BN_get_word(r) & 0x03), 3);
BN_free(val); BN_free(val);
}
#if !defined(WOLFSSL_SP_MATH) && (!defined(WOLFSSL_SP_MATH_ALL) || \ #if !defined(WOLFSSL_SP_MATH) && (!defined(WOLFSSL_SP_MATH_ALL) || \
defined(WOLFSSL_SP_INT_NEGATIVE)) defined(WOLFSSL_SP_INT_NEGATIVE))
@ -35858,6 +35893,7 @@ static void test_wolfSSL_DES_ecb_encrypt(void)
wolfSSL_DES_ecb_encrypt(&input1,&output1,&key,DES_ENCRYPT); wolfSSL_DES_ecb_encrypt(&input1,&output1,&key,DES_ENCRYPT);
wolfSSL_DES_ecb_encrypt(&input2,&output2,&key,DES_ENCRYPT); wolfSSL_DES_ecb_encrypt(&input2,&output2,&key,DES_ENCRYPT);
{
/* Decrypt messages */ /* Decrypt messages */
int ret1 = 0; int ret1 = 0;
int ret2 = 0; int ret2 = 0;
@ -35867,6 +35903,7 @@ static void test_wolfSSL_DES_ecb_encrypt(void)
wolfSSL_DES_ecb_encrypt(&output2,&back2,&key,DES_DECRYPT); wolfSSL_DES_ecb_encrypt(&output2,&back2,&key,DES_DECRYPT);
ret2 = XMEMCMP((unsigned char *) back2,(unsigned char *) input2,sizeof(WOLFSSL_DES_cblock)); ret2 = XMEMCMP((unsigned char *) back2,(unsigned char *) input2,sizeof(WOLFSSL_DES_cblock));
AssertIntEQ(ret2,0); AssertIntEQ(ret2,0);
}
printf(resultFmt, passed); printf(resultFmt, passed);
#endif #endif
@ -36923,23 +36960,10 @@ static void test_wolfSSL_X509_PUBKEY_DSA(void)
word32 bytes; word32 bytes;
#ifdef USE_CERT_BUFFERS_1024 #ifdef USE_CERT_BUFFERS_1024
byte tmp[ONEK_BUF]; byte tmp[ONEK_BUF];
XMEMSET(tmp, 0, sizeof(tmp));
XMEMCPY(tmp, dsa_key_der_1024, sizeof_dsa_key_der_1024);
bytes = sizeof_dsa_key_der_1024;
#elif defined(USE_CERT_BUFFERS_2048) #elif defined(USE_CERT_BUFFERS_2048)
byte tmp[TWOK_BUF]; byte tmp[TWOK_BUF];
XMEMSET(tmp, 0, sizeof(tmp));
XMEMCPY(tmp, dsa_key_der_2048, sizeof_dsa_key_der_2048);
bytes = sizeof_dsa_key_der_2048;
#else #else
byte tmp[TWOK_BUF]; byte tmp[TWOK_BUF];
XMEMSET(tmp, 0, sizeof(tmp));
XFILE fp = XFOPEN("./certs/dsa2048.der", "rb");
if (fp == XBADFILE) {
return WOLFSSL_BAD_FILE;
}
bytes = (word32) XFREAD(tmp, 1, sizeof(tmp), fp);
XFCLOSE(fp);
#endif /* END USE_CERT_BUFFERS_1024 */ #endif /* END USE_CERT_BUFFERS_1024 */
const unsigned char* dsaKeyDer = tmp; const unsigned char* dsaKeyDer = tmp;
@ -36956,6 +36980,27 @@ static void test_wolfSSL_X509_PUBKEY_DSA(void)
printf(testingFmt, "wolfSSL_X509_PUBKEY_DSA"); printf(testingFmt, "wolfSSL_X509_PUBKEY_DSA");
#ifdef USE_CERT_BUFFERS_1024
XMEMSET(tmp, 0, sizeof(tmp));
XMEMCPY(tmp, dsa_key_der_1024, sizeof_dsa_key_der_1024);
bytes = sizeof_dsa_key_der_1024;
#elif defined(USE_CERT_BUFFERS_2048)
XMEMSET(tmp, 0, sizeof(tmp));
XMEMCPY(tmp, dsa_key_der_2048, sizeof_dsa_key_der_2048);
bytes = sizeof_dsa_key_der_2048;
#else
{
XFILE fp;
XMEMSET(tmp, 0, sizeof(tmp));
fp = XFOPEN("./certs/dsa2048.der", "rb");
if (fp == XBADFILE) {
return WOLFSSL_BAD_FILE;
}
bytes = (word32) XFREAD(tmp, 1, sizeof(tmp), fp);
XFCLOSE(fp);
}
#endif
/* Initialize pkey with der format dsa key */ /* Initialize pkey with der format dsa key */
AssertNotNull(d2i_PrivateKey(EVP_PKEY_DSA, &evpKey, &dsaKeyDer, bytes)); AssertNotNull(d2i_PrivateKey(EVP_PKEY_DSA, &evpKey, &dsaKeyDer, bytes));
@ -37781,11 +37826,12 @@ static int test_wc_ERR_print_errors_fp (void)
#if (defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE)) && \ #if (defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE)) && \
(!defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM)) (!defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM))
long sz; long sz;
XFILE fp;
printf(testingFmt, "wc_ERR_print_errors_fp()"); printf(testingFmt, "wc_ERR_print_errors_fp()");
WOLFSSL_ERROR(BAD_FUNC_ARG); WOLFSSL_ERROR(BAD_FUNC_ARG);
XFILE fp = XFOPEN("./tests/test-log-dump-to-file.txt", "ar"); fp = XFOPEN("./tests/test-log-dump-to-file.txt", "ar");
wc_ERR_print_errors_fp(fp); wc_ERR_print_errors_fp(fp);
#if defined(DEBUG_WOLFSSL) #if defined(DEBUG_WOLFSSL)
AssertTrue(XFSEEK(fp, 0, XSEEK_END) == 0); AssertTrue(XFSEEK(fp, 0, XSEEK_END) == 0);
@ -39059,15 +39105,14 @@ static void test_wolfSSL_BIO_connect(void)
static void test_wolfSSL_BIO_tls(void) static void test_wolfSSL_BIO_tls(void)
{ {
#if !defined(NO_BIO) && defined(OPENSSL_EXTRA) && !defined(NO_WOLFSSL_CLIENT) #if !defined(NO_BIO) && defined(OPENSSL_EXTRA) && !defined(NO_WOLFSSL_CLIENT)
printf(testingFmt, "test_wolfSSL_BIO_tls()");
SSL_CTX* ctx; SSL_CTX* ctx;
SSL *ssl; SSL *ssl;
BIO *readBio; BIO *readBio;
BIO *writeBio; BIO *writeBio;
int ret, err = 0; int ret, err = 0;
printf(testingFmt, "test_wolfSSL_BIO_tls()");
AssertNotNull(ctx = SSL_CTX_new(SSLv23_method())); AssertNotNull(ctx = SSL_CTX_new(SSLv23_method()));
AssertNotNull(ssl = SSL_new(ctx)); AssertNotNull(ssl = SSL_new(ctx));
@ -42590,6 +42635,7 @@ static void test_wolfSSL_AES_cbc_encrypt(void)
#endif /* WOLFSSL_AES_128 */ #endif /* WOLFSSL_AES_128 */
#ifdef WOLFSSL_AES_192 #ifdef WOLFSSL_AES_192
{
/* Test vectors from NIST Special Publication 800-38A, 2001 Edition /* Test vectors from NIST Special Publication 800-38A, 2001 Edition
* Appendix F.2.3 */ * Appendix F.2.3 */
@ -42632,8 +42678,10 @@ static void test_wolfSSL_AES_cbc_encrypt(void)
printf(resultFmt, "passed"); printf(resultFmt, "passed");
#endif #endif
}
#endif /* WOLFSSL_AES_192 */ #endif /* WOLFSSL_AES_192 */
#ifdef WOLFSSL_AES_256 #ifdef WOLFSSL_AES_256
{
/* Test vectors from NIST Special Publication 800-38A, 2001 Edition, /* Test vectors from NIST Special Publication 800-38A, 2001 Edition,
* Appendix F.2.5 */ * Appendix F.2.5 */
byte iv256tmp[AES_BLOCK_SIZE] = {0}; byte iv256tmp[AES_BLOCK_SIZE] = {0};
@ -42679,6 +42727,7 @@ static void test_wolfSSL_AES_cbc_encrypt(void)
#endif #endif
#if defined(HAVE_AES_KEYWRAP) && !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) #if defined(HAVE_AES_KEYWRAP) && !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST)
{
byte wrapCipher[sizeof(key256) + KEYWRAP_BLOCK_SIZE] = { 0 }; byte wrapCipher[sizeof(key256) + KEYWRAP_BLOCK_SIZE] = { 0 };
byte wrapPlain[sizeof(key256)] = { 0 }; byte wrapPlain[sizeof(key256)] = { 0 };
byte wrapIV[KEYWRAP_BLOCK_SIZE] = { 0 }; byte wrapIV[KEYWRAP_BLOCK_SIZE] = { 0 };
@ -42710,7 +42759,9 @@ static void test_wolfSSL_AES_cbc_encrypt(void)
sizeof(wrapCipher)), sizeof(wrapPlain)); sizeof(wrapCipher)), sizeof(wrapPlain));
AssertIntEQ(XMEMCMP(wrapPlain, key256, sizeof(key256)), 0); AssertIntEQ(XMEMCMP(wrapPlain, key256, sizeof(key256)), 0);
printf(resultFmt, "passed"); printf(resultFmt, "passed");
}
#endif /* HAVE_AES_KEYWRAP */ #endif /* HAVE_AES_KEYWRAP */
}
#endif /* WOLFSSL_AES_256 */ #endif /* WOLFSSL_AES_256 */
#endif #endif
} }
@ -44727,8 +44778,7 @@ static void test_wolfSSL_EVP_BytesToKey(void)
byte iv[AES_BLOCK_SIZE] = {0}; byte iv[AES_BLOCK_SIZE] = {0};
int sz = 5; int sz = 5;
int count = 0; int count = 0;
const EVP_MD* md; const EVP_MD* md = "SHA256";
md = "SHA256";
const EVP_CIPHER *type; const EVP_CIPHER *type;
const unsigned char *salt = (unsigned char *)"salt1234"; const unsigned char *salt = (unsigned char *)"salt1234";
const byte data[] = { const byte data[] = {
@ -44766,11 +44816,11 @@ static void test_IncCtr(void)
int arg = 0; int arg = 0;
void *ptr = NULL; void *ptr = NULL;
printf(testingFmt, "IncCtr");
EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new(); EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
const EVP_CIPHER *init = EVP_aes_128_gcm(); const EVP_CIPHER *init = EVP_aes_128_gcm();
printf(testingFmt, "IncCtr");
AssertNotNull(ctx); AssertNotNull(ctx);
wolfSSL_EVP_CIPHER_CTX_init(ctx); wolfSSL_EVP_CIPHER_CTX_init(ctx);
AssertIntEQ(EVP_CipherInit(ctx, init, key, iv, 1), WOLFSSL_SUCCESS); AssertIntEQ(EVP_CipherInit(ctx, init, key, iv, 1), WOLFSSL_SUCCESS);
@ -44820,8 +44870,8 @@ static void test_wolfSSL_OBJ_ln(void)
#ifdef HAVE_ECC #ifdef HAVE_ECC
#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2)) #if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
{ {
size_t nCurves = 27; EC_builtin_curve r[27];
EC_builtin_curve r[nCurves]; size_t nCurves = sizeof(r) / sizeof(r[0]);
nCurves = EC_get_builtin_curves(r,nCurves); nCurves = EC_get_builtin_curves(r,nCurves);
for (i = 0; i < nCurves; i++) { for (i = 0; i < nCurves; i++) {
@ -45939,13 +45989,14 @@ static void test_wolfSSL_EVP_PKEY_derive(void)
#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2)) #if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
#if (!defined(NO_DH) && defined(WOLFSSL_DH_EXTRA)) || defined(HAVE_ECC) #if (!defined(NO_DH) && defined(WOLFSSL_DH_EXTRA)) || defined(HAVE_ECC)
printf(testingFmt, "wolfSSL_EVP_PKEY_derive()");
EVP_PKEY_CTX *ctx; EVP_PKEY_CTX *ctx;
unsigned char *skey; unsigned char *skey;
size_t skeylen; size_t skeylen;
EVP_PKEY *pkey, *peerkey; EVP_PKEY *pkey, *peerkey;
const unsigned char* key; const unsigned char* key;
printf(testingFmt, "wolfSSL_EVP_PKEY_derive()");
#if !defined(NO_DH) && defined(WOLFSSL_DH_EXTRA) #if !defined(NO_DH) && defined(WOLFSSL_DH_EXTRA)
/* DH */ /* DH */
key = dh_key_der_2048; key = dh_key_der_2048;
@ -50055,6 +50106,7 @@ static void test_wolfSSL_d2i_ASN1_INTEGER(void)
AssertNull((a = wolfSSL_d2i_ASN1_INTEGER(&b, &p, sizeof(garbageDer)))); AssertNull((a = wolfSSL_d2i_ASN1_INTEGER(&b, &p, sizeof(garbageDer))));
AssertNull(b); AssertNull(b);
{
/* Check i2d error conditions */ /* Check i2d error conditions */
/* NULL input. */ /* NULL input. */
byte* p2 = NULL; byte* p2 = NULL;
@ -50072,6 +50124,7 @@ static void test_wolfSSL_d2i_ASN1_INTEGER(void)
/* NULL output buffer. */ /* NULL output buffer. */
AssertIntLT(wolfSSL_i2d_ASN1_INTEGER(a, NULL), 0); AssertIntLT(wolfSSL_i2d_ASN1_INTEGER(a, NULL), 0);
wolfSSL_ASN1_INTEGER_free(a); wolfSSL_ASN1_INTEGER_free(a);
}
for (i = 0; i < NUM_TEST_VECTORS; ++i) { for (i = 0; i < NUM_TEST_VECTORS; ++i) {
p = testVectors[i].der; p = testVectors[i].der;
@ -51734,10 +51787,10 @@ static void test_wolfSSL_CTX_get_min_proto_version(void)
static void test_wolfSSL_security_level(void) static void test_wolfSSL_security_level(void)
{ {
#if defined(OPENSSL_EXTRA) #if defined(OPENSSL_EXTRA)
printf(testingFmt, "test_wolfSSL_security_level()");
SSL_CTX *ctx; SSL_CTX *ctx;
printf(testingFmt, "test_wolfSSL_security_level()");
#ifdef WOLFSSL_TLS13 #ifdef WOLFSSL_TLS13
#ifdef NO_WOLFSSL_SERVER #ifdef NO_WOLFSSL_SERVER
AssertNotNull(ctx = wolfSSL_CTX_new(wolfTLSv1_3_client_method())); AssertNotNull(ctx = wolfSSL_CTX_new(wolfTLSv1_3_client_method()));
@ -51761,13 +51814,13 @@ static void test_wolfSSL_security_level(void)
static void test_wolfSSL_SSL_in_init(void) static void test_wolfSSL_SSL_in_init(void)
{ {
#if defined(OPENSSL_ALL) && !defined(NO_BIO) #if defined(OPENSSL_ALL) && !defined(NO_BIO)
printf(testingFmt, "test_wolfSSL_SSL_in_init()");
SSL_CTX* ctx; SSL_CTX* ctx;
SSL* ssl; SSL* ssl;
const char* testCertFile; const char* testCertFile;
const char* testKeyFile; const char* testKeyFile;
printf(testingFmt, "test_wolfSSL_SSL_in_init()");
#ifdef WOLFSSL_TLS13 #ifdef WOLFSSL_TLS13
#ifdef NO_WOLFSSL_SERVER #ifdef NO_WOLFSSL_SERVER
AssertNotNull(ctx = wolfSSL_CTX_new(wolfTLSv1_3_client_method())); AssertNotNull(ctx = wolfSSL_CTX_new(wolfTLSv1_3_client_method()));
@ -51811,10 +51864,11 @@ static void test_wolfSSL_SSL_in_init(void)
static void test_wolfSSL_EC_curve(void) static void test_wolfSSL_EC_curve(void)
{ {
#if defined(OPENSSL_EXTRA) && defined(HAVE_ECC) #if defined(OPENSSL_EXTRA) && defined(HAVE_ECC)
printf(testingFmt, "test_wolfSSL_EC_curve()");
int nid = NID_secp160k1; int nid = NID_secp160k1;
const char* nid_name; const char* nid_name;
printf(testingFmt, "test_wolfSSL_EC_curve()");
AssertNotNull(nid_name = EC_curve_nid2nist(nid)); AssertNotNull(nid_name = EC_curve_nid2nist(nid));
AssertIntEQ(XMEMCMP(nid_name, "K-160", XSTRLEN("K-160")), 0); AssertIntEQ(XMEMCMP(nid_name, "K-160", XSTRLEN("K-160")), 0);
@ -51828,10 +51882,13 @@ static void test_wolfSSL_CTX_set_timeout(void)
{ {
#if !defined(NO_WOLFSSL_SERVER) && !defined(NO_SESSION_CACHE) #if !defined(NO_WOLFSSL_SERVER) && !defined(NO_SESSION_CACHE)
int timeout; int timeout;
(void)timeout;
printf(testingFmt, "test_wolfSSL_CTX_set_timeout()");
WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfSSLv23_server_method()); WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfSSLv23_server_method());
(void)timeout;
printf(testingFmt, "test_wolfSSL_CTX_set_timeout()");
AssertNotNull(ctx); AssertNotNull(ctx);
#if defined(WOLFSSL_ERROR_CODE_OPENSSL) #if defined(WOLFSSL_ERROR_CODE_OPENSSL)
@ -51860,9 +51917,10 @@ static void test_wolfSSL_CTX_set_timeout(void)
static void test_wolfSSL_OpenSSL_version(void) static void test_wolfSSL_OpenSSL_version(void)
{ {
#if defined(OPENSSL_EXTRA) #if defined(OPENSSL_EXTRA)
printf(testingFmt, "test_wolfSSL_OpenSSL_version()");
const char* ver; const char* ver;
printf(testingFmt, "test_wolfSSL_OpenSSL_version()");
#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L #if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L
AssertNotNull(ver = OpenSSL_version(0)); AssertNotNull(ver = OpenSSL_version(0));
#else #else
@ -51877,11 +51935,11 @@ static void test_wolfSSL_OpenSSL_version(void)
static void test_CONF_CTX_CMDLINE(void) static void test_CONF_CTX_CMDLINE(void)
{ {
#if defined(OPENSSL_ALL) #if defined(OPENSSL_ALL)
printf(testingFmt, "test_CONF_CTX_CMDLINE");
SSL_CTX* ctx = NULL; SSL_CTX* ctx = NULL;
SSL_CONF_CTX* cctx = NULL; SSL_CONF_CTX* cctx = NULL;
printf(testingFmt, "test_CONF_CTX_CMDLINE");
AssertNotNull(cctx = SSL_CONF_CTX_new()); AssertNotNull(cctx = SSL_CONF_CTX_new());
AssertNotNull(ctx = wolfSSL_CTX_new(wolfSSLv23_server_method())); AssertNotNull(ctx = wolfSSL_CTX_new(wolfSSLv23_server_method()));
@ -51958,11 +52016,11 @@ static void test_CONF_CTX_CMDLINE(void)
static void test_CONF_CTX_FILE(void) static void test_CONF_CTX_FILE(void)
{ {
#if defined(OPENSSL_ALL) #if defined(OPENSSL_ALL)
printf(testingFmt, "test_CONF_CTX_FILE");
SSL_CTX* ctx = NULL; SSL_CTX* ctx = NULL;
SSL_CONF_CTX* cctx = NULL; SSL_CONF_CTX* cctx = NULL;
printf(testingFmt, "test_CONF_CTX_FILE");
AssertNotNull(cctx = SSL_CONF_CTX_new()); AssertNotNull(cctx = SSL_CONF_CTX_new());
AssertNotNull(ctx = wolfSSL_CTX_new(wolfSSLv23_server_method())); AssertNotNull(ctx = wolfSSL_CTX_new(wolfSSLv23_server_method()));
SSL_CONF_CTX_set_ssl_ctx(cctx, ctx); SSL_CONF_CTX_set_ssl_ctx(cctx, ctx);
@ -52110,12 +52168,13 @@ static void test_wolfSSL_CRYPTO_get_ex_new_index(void)
static void test_wolfSSL_set_psk_use_session_callback(void) static void test_wolfSSL_set_psk_use_session_callback(void)
{ {
#if defined(OPENSSL_EXTRA) && !defined(NO_PSK) #if defined(OPENSSL_EXTRA) && !defined(NO_PSK)
printf(testingFmt, "test_wolfSSL_set_psk_use_session_callback()");
SSL_CTX* ctx; SSL_CTX* ctx;
SSL* ssl; SSL* ssl;
const char* testCertFile; const char* testCertFile;
const char* testKeyFile; const char* testKeyFile;
printf(testingFmt, "test_wolfSSL_set_psk_use_session_callback()");
#ifdef WOLFSSL_TLS13 #ifdef WOLFSSL_TLS13
#ifdef NO_WOLFSSL_SERVER #ifdef NO_WOLFSSL_SERVER
AssertNotNull(ctx = wolfSSL_CTX_new(wolfTLSv1_3_client_method())); AssertNotNull(ctx = wolfSSL_CTX_new(wolfTLSv1_3_client_method()));
@ -52167,13 +52226,6 @@ static void test_wolfSSL_DH(void)
BIGNUM* g; BIGNUM* g;
BIGNUM* pub; BIGNUM* pub;
BIGNUM* priv; BIGNUM* priv;
(void)dh;
(void)p;
(void)q;
(void)g;
(void)pub;
(void)priv;
#if defined(OPENSSL_ALL) && defined(WOLFSSL_KEY_GEN) #if defined(OPENSSL_ALL) && defined(WOLFSSL_KEY_GEN)
#if !defined(HAVE_FIPS) || \ #if !defined(HAVE_FIPS) || \
(defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION > 2)) (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION > 2))
@ -52217,6 +52269,14 @@ static void test_wolfSSL_DH(void)
DH_free(dh); DH_free(dh);
#endif #endif
#endif #endif
(void)dh;
(void)p;
(void)q;
(void)g;
(void)pub;
(void)priv;
printf(testingFmt, "test_wolfSSL_DH"); printf(testingFmt, "test_wolfSSL_DH");
dh = wolfSSL_DH_new(); dh = wolfSSL_DH_new();
@ -52315,8 +52375,8 @@ static void test_wolfSSL_EVP_shake256(void)
{ {
#if defined(OPENSSL_EXTRA) && defined(WOLFSSL_SHA3) && \ #if defined(OPENSSL_EXTRA) && defined(WOLFSSL_SHA3) && \
defined(WOLFSSL_SHAKE256) defined(WOLFSSL_SHAKE256)
printf(testingFmt, "test_wolfSSL_EVP_shake256");
const EVP_MD* md = NULL; const EVP_MD* md = NULL;
printf(testingFmt, "test_wolfSSL_EVP_shake256");
md = EVP_shake256(); md = EVP_shake256();
AssertTrue(md != NULL); AssertTrue(md != NULL);
AssertIntEQ(XSTRNCMP(md, "SHAKE256", XSTRLEN("SHAKE256")), 0); AssertIntEQ(XSTRNCMP(md, "SHAKE256", XSTRLEN("SHAKE256")), 0);
@ -52327,11 +52387,11 @@ static void test_wolfSSL_EVP_shake256(void)
static void test_EVP_blake2(void) static void test_EVP_blake2(void)
{ {
#if defined(OPENSSL_EXTRA) && (defined(HAVE_BLAKE2) || defined(HAVE_BLAKE2S)) #if defined(OPENSSL_EXTRA) && (defined(HAVE_BLAKE2) || defined(HAVE_BLAKE2S))
printf(testingFmt, "test_EVP_blake2");
const EVP_MD* md = NULL; const EVP_MD* md = NULL;
(void)md; (void)md;
printf(testingFmt, "test_EVP_blake2");
#if defined(HAVE_BLAKE2) #if defined(HAVE_BLAKE2)
md = EVP_blake2b512(); md = EVP_blake2b512();
AssertTrue(md != NULL); AssertTrue(md != NULL);
@ -52459,9 +52519,6 @@ static void test_SSL_CIPHER_get_xxx(void)
{ {
#if defined(OPENSSL_ALL) && !defined(NO_CERTS) && \ #if defined(OPENSSL_ALL) && !defined(NO_CERTS) && \
!defined(NO_FILESYSTEM) !defined(NO_FILESYSTEM)
printf(testingFmt, "test_SSL_CIPHER_get_xxx");
const SSL_CIPHER* cipher = NULL; const SSL_CIPHER* cipher = NULL;
STACK_OF(SSL_CIPHER) *supportedCiphers = NULL; STACK_OF(SSL_CIPHER) *supportedCiphers = NULL;
int i, numCiphers = 0; int i, numCiphers = 0;
@ -52494,6 +52551,8 @@ static void test_SSL_CIPHER_get_xxx(void)
(void)testCertFile; (void)testCertFile;
(void)testKeyFile; (void)testKeyFile;
printf(testingFmt, "test_SSL_CIPHER_get_xxx");
#if defined(WOLFSSL_TLS13) #if defined(WOLFSSL_TLS13)
cipher_id = "TLS13-AES128-GCM-SHA256"; cipher_id = "TLS13-AES128-GCM-SHA256";
expect_nid1 = NID_auth_rsa; expect_nid1 = NID_auth_rsa;

3
wolfcrypt/src/evp.c
View File

@ -3457,10 +3457,11 @@ int wolfSSL_EVP_PBE_scrypt(const char *pass, size_t passlen,
word64 N, word64 r, word64 p, word64 N, word64 r, word64 p,
word64 maxmem, unsigned char *key, size_t keylen) word64 maxmem, unsigned char *key, size_t keylen)
{ {
(void)maxmem;
int ret; int ret;
int exp = 0; int exp = 0;
(void)maxmem;
WOLFSSL_ENTER("wolfSSL_EVP_PBE_scrypt"); WOLFSSL_ENTER("wolfSSL_EVP_PBE_scrypt");
if (r > INT32_MAX || p > INT32_MAX) { if (r > INT32_MAX || p > INT32_MAX) {

2
wolfssl/wolfcrypt/types.h
View File

@ -552,7 +552,7 @@ decouple library dependencies with standard string, memory and so on.
#define WC_DECLARE_ARRAY_DYNAMIC_DEC(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ #define WC_DECLARE_ARRAY_DYNAMIC_DEC(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
VAR_TYPE* VAR_NAME[VAR_ITEMS]; \ VAR_TYPE* VAR_NAME[VAR_ITEMS]; \
int idx##VAR_NAME, inner_idx_##VAR_NAME; int idx##VAR_NAME, inner_idx_##VAR_NAME
#define WC_DECLARE_ARRAY_DYNAMIC_EXE(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \ #define WC_DECLARE_ARRAY_DYNAMIC_EXE(VAR_NAME, VAR_TYPE, VAR_ITEMS, VAR_SIZE, HEAP) \
for (idx##VAR_NAME=0; idx##VAR_NAME<(VAR_ITEMS); idx##VAR_NAME++) { \ for (idx##VAR_NAME=0; idx##VAR_NAME<(VAR_ITEMS); idx##VAR_NAME++) { \
(VAR_NAME)[idx##VAR_NAME] = (VAR_TYPE*)XMALLOC(VAR_SIZE, (HEAP), DYNAMIC_TYPE_TMP_BUFFER); \ (VAR_NAME)[idx##VAR_NAME] = (VAR_TYPE*)XMALLOC(VAR_SIZE, (HEAP), DYNAMIC_TYPE_TMP_BUFFER); \