wolfSSL/wolfssl
1
0
Fork 1
mirror of https://github.com/wolfSSL/wolfssl.git synced 2026-07-10 21:40:52 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #10845 from danielinux/mcdc-test-coverage

Browse Source 
Infrastructure for Mc/Dc test coverage + AES coverage campaign
This commit is contained in:
David Garske
2026-07-09 09:40:43 -07:00
committed by GitHub
parent 9e72e8d718 c1500f8622
commit 2dfb38f92c
21 changed files with 4447 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/api.c
+546 -2
View File
@@ -33,6 +33,9 @@
#include <wolfssl/wolfcrypt/logging.h>
#include <wolfssl/wolfcrypt/hash.h>
#ifdef WOLF_CRYPTO_CB
#include <wolfssl/wolfcrypt/cryptocb.h>
#endif
#if defined(WOLFSSL_STATIC_MEMORY)
#include <wolfssl/wolfcrypt/memory.h>
@@ -4575,6 +4578,279 @@ static int test_wolfSSL_CTX_ticket_API(void)
return EXPECT_RESULT();
}
static int test_wolfSSL_session_cache_api_direct(void)
{
EXPECT_DECLS;
#if !defined(NO_SESSION_CACHE) && !defined(NO_TLS) && \
(!defined(NO_WOLFSSL_CLIENT) || !defined(NO_WOLFSSL_SERVER))
WOLFSSL_CTX* ctx = NULL;
WOLFSSL* ssl = NULL;
byte shortId[] = "server-id";
byte longId[SERVER_ID_LEN + 8];
#ifdef OPENSSL_EXTRA
/* Only read back via wolfSSL_CTX_get_session_cache_mode(), itself
* OPENSSL_EXTRA-only; declare in the same scope to avoid -Wunused. */
long mode = 0;
#endif
XMEMSET(longId, 0xA5, sizeof(longId));
ExpectIntEQ(wolfSSL_CTX_set_session_cache_mode(NULL,
WOLFSSL_SESS_CACHE_OFF), WOLFSSL_FAILURE);
#ifdef OPENSSL_EXTRA
ExpectIntEQ(wolfSSL_CTX_get_session_cache_mode(NULL), 0);
#endif
ExpectIntEQ(wolfSSL_set_session(NULL, NULL), WOLFSSL_FAILURE);
ExpectIntEQ(wolfSSL_SetServerID(NULL, shortId, sizeof(shortId), 0),
BAD_FUNC_ARG);
#ifndef NO_WOLFSSL_CLIENT
ExpectNotNull(ctx = wolfSSL_CTX_new(wolfSSLv23_client_method()));
#elif !defined(NO_WOLFSSL_SERVER)
ExpectNotNull(ctx = wolfSSL_CTX_new(wolfSSLv23_server_method()));
/* A client CTX yields a usable WOLFSSL* cert-free, but a server needs a
* cert+key or wolfSSL_new() has no usable cipher suite and returns NULL
* (e.g. minimal server-only builds). Load the test server cert/key. */
#if !defined(NO_CERTS) && !defined(NO_RSA) && !defined(NO_FILESYSTEM)
ExpectIntEQ(wolfSSL_CTX_use_certificate_file(ctx, svrCertFile,
WOLFSSL_FILETYPE_PEM), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_use_PrivateKey_file(ctx, svrKeyFile,
WOLFSSL_FILETYPE_PEM), WOLFSSL_SUCCESS);
#elif !defined(NO_CERTS) && !defined(NO_RSA) && defined(USE_CERT_BUFFERS_2048)
ExpectIntEQ(wolfSSL_CTX_use_certificate_buffer(ctx, server_cert_der_2048,
sizeof_server_cert_der_2048, WOLFSSL_FILETYPE_ASN1), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_use_PrivateKey_buffer(ctx, server_key_der_2048,
sizeof_server_key_der_2048, WOLFSSL_FILETYPE_ASN1), WOLFSSL_SUCCESS);
#endif
#endif
ExpectNotNull(ssl = wolfSSL_new(ctx));
#ifdef OPENSSL_EXTRA
mode = wolfSSL_CTX_get_session_cache_mode(ctx);
ExpectIntEQ(mode & WOLFSSL_SESS_CACHE_SERVER, WOLFSSL_SESS_CACHE_SERVER);
#endif
ExpectIntEQ(wolfSSL_CTX_set_session_cache_mode(ctx,
WOLFSSL_SESS_CACHE_NO_AUTO_CLEAR |
WOLFSSL_SESS_CACHE_NO_INTERNAL_STORE |
WOLFSSL_SESS_CACHE_NO_INTERNAL_LOOKUP), WOLFSSL_SUCCESS);
#ifdef OPENSSL_EXTRA
mode = wolfSSL_CTX_get_session_cache_mode(ctx);
ExpectIntEQ(mode & WOLFSSL_SESS_CACHE_NO_AUTO_CLEAR,
WOLFSSL_SESS_CACHE_NO_AUTO_CLEAR);
ExpectIntEQ(mode & WOLFSSL_SESS_CACHE_NO_INTERNAL_STORE,
WOLFSSL_SESS_CACHE_NO_INTERNAL_STORE);
ExpectIntEQ(mode & WOLFSSL_SESS_CACHE_NO_INTERNAL_LOOKUP,
WOLFSSL_SESS_CACHE_NO_INTERNAL_LOOKUP);
#endif
ExpectIntEQ(wolfSSL_CTX_set_session_cache_mode(ctx,
WOLFSSL_SESS_CACHE_OFF), WOLFSSL_SUCCESS);
#ifdef OPENSSL_EXTRA
mode = wolfSSL_CTX_get_session_cache_mode(ctx);
ExpectIntEQ(mode & WOLFSSL_SESS_CACHE_SERVER, 0);
ExpectIntEQ(mode & WOLFSSL_SESS_CACHE_NO_INTERNAL_STORE,
WOLFSSL_SESS_CACHE_NO_INTERNAL_STORE);
ExpectIntEQ(mode & WOLFSSL_SESS_CACHE_NO_INTERNAL_LOOKUP,
WOLFSSL_SESS_CACHE_NO_INTERNAL_LOOKUP);
#endif
ExpectIntEQ(wolfSSL_set_session(ssl, NULL), WOLFSSL_FAILURE);
ExpectIntEQ(wolfSSL_SetServerID(ssl, NULL, sizeof(shortId), 0),
BAD_FUNC_ARG);
ExpectIntEQ(wolfSSL_SetServerID(ssl, shortId, 0, 0), BAD_FUNC_ARG);
#ifndef NO_CLIENT_CACHE
ExpectIntEQ(wolfSSL_SetServerID(ssl, shortId, (int)sizeof(shortId), 1),
WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_SetServerID(ssl, longId, (int)sizeof(longId), 1),
WOLFSSL_SUCCESS);
#endif
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
#endif
return EXPECT_RESULT();
}
static int test_wolfSSL_crl_ocsp_object_api(void)
{
EXPECT_DECLS;
#if !defined(NO_CERTS) && !defined(NO_TLS) && \
(!defined(NO_WOLFSSL_CLIENT) || !defined(NO_WOLFSSL_SERVER))
WOLFSSL_CTX* clientCtx = NULL;
WOLFSSL_CTX* serverCtx = NULL;
WOLFSSL* clientSsl = NULL;
WOLFSSL* serverSsl = NULL;
#ifndef NO_WOLFSSL_CLIENT
ExpectNotNull(clientCtx = wolfSSL_CTX_new(wolfSSLv23_client_method()));
ExpectNotNull(clientSsl = wolfSSL_new(clientCtx));
#endif
#ifndef NO_WOLFSSL_SERVER
ExpectNotNull(serverCtx = wolfSSL_CTX_new(wolfSSLv23_server_method()));
serverSsl = wolfSSL_new(serverCtx);
#endif
#ifdef HAVE_CRL
ExpectIntEQ(wolfSSL_CTX_LoadCRLBuffer(NULL, (const unsigned char*)"x", 1,
WOLFSSL_FILETYPE_PEM), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_CTX_EnableCRL(NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_CTX_DisableCRL(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_CTX_SetCRL_Cb(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_CTX_SetCRL_ErrorCb(NULL, NULL, NULL),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
#ifdef HAVE_CRL_IO
ExpectIntEQ(wolfSSL_CTX_SetCRL_IOCb(NULL, NULL),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
#endif
ExpectIntEQ(wolfSSL_EnableCRL(NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_DisableCRL(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_SetCRL_Cb(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_SetCRL_ErrorCb(NULL, NULL, NULL),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_LoadCRLBuffer(NULL, (const unsigned char*)"x", 1,
WOLFSSL_FILETYPE_PEM), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
#ifndef NO_FILESYSTEM
ExpectIntEQ(wolfSSL_LoadCRL(NULL, "./certs/crl", WOLFSSL_FILETYPE_PEM, 0),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_LoadCRLFile(NULL, "./certs/crl/cliCrl.pem",
WOLFSSL_FILETYPE_PEM), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
#endif
#ifndef NO_WOLFSSL_CLIENT
ExpectIntNE(wolfSSL_CTX_LoadCRLBuffer(clientCtx, (const unsigned char*)"x",
0, WOLFSSL_FILETYPE_PEM), WOLFSSL_SUCCESS);
ExpectIntNE(wolfSSL_CTX_LoadCRLBuffer(clientCtx, (const unsigned char*)"x",
1, WOLFSSL_FILETYPE_PEM), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_EnableCRL(clientCtx, 0), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_DisableCRL(clientCtx), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_SetCRL_Cb(clientCtx, NULL), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_SetCRL_ErrorCb(clientCtx, NULL, NULL),
WOLFSSL_SUCCESS);
#ifdef HAVE_CRL_IO
ExpectIntEQ(wolfSSL_CTX_SetCRL_IOCb(clientCtx, NULL), WOLFSSL_SUCCESS);
#endif
ExpectIntEQ(wolfSSL_EnableCRL(clientSsl, 0), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_DisableCRL(clientSsl), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_SetCRL_Cb(clientSsl, NULL), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_SetCRL_ErrorCb(clientSsl, NULL, NULL), WOLFSSL_SUCCESS);
ExpectIntNE(wolfSSL_LoadCRLBuffer(clientSsl, (const unsigned char*)"x", 0,
WOLFSSL_FILETYPE_PEM), WOLFSSL_SUCCESS);
ExpectIntNE(wolfSSL_LoadCRLBuffer(clientSsl, (const unsigned char*)"x", 1,
WOLFSSL_FILETYPE_PEM), WOLFSSL_SUCCESS);
#ifdef HAVE_CRL_IO
ExpectIntEQ(wolfSSL_SetCRL_IOCb(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_SetCRL_IOCb(clientSsl, NULL), WOLFSSL_SUCCESS);
#endif
#endif
#endif
#ifdef HAVE_OCSP
ExpectIntEQ(wolfSSL_CTX_EnableOCSP(NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_CTX_DisableOCSP(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_CTX_SetOCSP_OverrideURL(NULL, "http://dummy.test"),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_CTX_SetOCSP_Cb(NULL, NULL, NULL, NULL),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
#if defined(HAVE_CERTIFICATE_STATUS_REQUEST) || \
defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
ExpectIntEQ(wolfSSL_CTX_EnableOCSPStapling(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_CTX_DisableOCSPStapling(NULL),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
#endif
ExpectIntEQ(wolfSSL_EnableOCSP(NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_DisableOCSP(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
#if defined(HAVE_CERTIFICATE_STATUS_REQUEST) || \
defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
ExpectIntEQ(wolfSSL_EnableOCSPStapling(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_DisableOCSPStapling(NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
#endif
ExpectIntEQ(wolfSSL_SetOCSP_OverrideURL(NULL, "http://dummy.test"),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_SetOCSP_Cb(NULL, NULL, NULL, NULL),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
#ifndef NO_WOLFSSL_CLIENT
ExpectIntEQ(wolfSSL_CTX_EnableOCSP(clientCtx, WOLFSSL_OCSP_NO_NONCE),
WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_DisableOCSP(clientCtx), WOLFSSL_SUCCESS);
#if defined(HAVE_CERTIFICATE_STATUS_REQUEST) || \
defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
ExpectIntEQ(wolfSSL_CTX_EnableOCSPStapling(clientCtx), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_DisableOCSPStapling(clientCtx), WOLFSSL_SUCCESS);
#endif
ExpectIntEQ(wolfSSL_CTX_SetOCSP_OverrideURL(clientCtx, "http://dummy.test"),
WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_SetOCSP_OverrideURL(clientCtx, ""),
WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_SetOCSP_OverrideURL(clientCtx, NULL),
WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_SetOCSP_Cb(clientCtx, NULL, NULL, clientCtx),
WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_EnableOCSP(clientSsl, WOLFSSL_OCSP_NO_NONCE),
WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_DisableOCSP(clientSsl), WOLFSSL_SUCCESS);
#if defined(HAVE_CERTIFICATE_STATUS_REQUEST) || \
defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
ExpectIntEQ(wolfSSL_EnableOCSPStapling(clientSsl), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_DisableOCSPStapling(clientSsl), WOLFSSL_SUCCESS);
#endif
ExpectIntEQ(wolfSSL_SetOCSP_OverrideURL(clientSsl, "http://dummy.test"),
WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_SetOCSP_OverrideURL(clientSsl, ""), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_SetOCSP_OverrideURL(clientSsl, NULL), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_SetOCSP_Cb(clientSsl, NULL, NULL, clientCtx),
WOLFSSL_SUCCESS);
ExpectPtrEq(clientSsl->ocspIOCtx, clientCtx);
#endif
#endif
/* wolfSSL[_CTX]_UseOCSPStapling (CSR) is a client-side API. */
#if defined(HAVE_CERTIFICATE_STATUS_REQUEST) && !defined(NO_WOLFSSL_CLIENT)
ExpectIntEQ(wolfSSL_UseOCSPStapling(NULL, WOLFSSL_CSR_OCSP, 0),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
#ifndef NO_WOLFSSL_SERVER
ExpectIntEQ(wolfSSL_CTX_UseOCSPStapling(serverCtx, WOLFSSL_CSR_OCSP, 0),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
if (serverSsl != NULL) {
ExpectIntEQ(wolfSSL_UseOCSPStapling(serverSsl, WOLFSSL_CSR_OCSP, 0),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
}
#endif
#ifndef NO_WOLFSSL_CLIENT
ExpectIntEQ(wolfSSL_UseOCSPStapling(clientSsl, WOLFSSL_CSR_OCSP, 0),
WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_UseOCSPStapling(clientCtx, WOLFSSL_CSR_OCSP, 0),
WOLFSSL_SUCCESS);
#endif
#endif
/* wolfSSL[_CTX]_UseOCSPStaplingV2 (CSR2) is a client-side API. */
#if defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2) && !defined(NO_WOLFSSL_CLIENT)
ExpectIntEQ(wolfSSL_UseOCSPStaplingV2(NULL, WOLFSSL_CSR2_OCSP, 0),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
#ifndef NO_WOLFSSL_SERVER
ExpectIntEQ(wolfSSL_CTX_UseOCSPStaplingV2(serverCtx, WOLFSSL_CSR2_OCSP, 0),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
if (serverSsl != NULL) {
ExpectIntEQ(wolfSSL_UseOCSPStaplingV2(serverSsl, WOLFSSL_CSR2_OCSP, 0),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
}
#endif
#ifndef NO_WOLFSSL_CLIENT
ExpectIntEQ(wolfSSL_UseOCSPStaplingV2(clientSsl, WOLFSSL_CSR2_OCSP, 0),
WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_UseOCSPStaplingV2(clientCtx, WOLFSSL_CSR2_OCSP, 0),
WOLFSSL_SUCCESS);
#endif
#endif
wolfSSL_free(clientSsl);
wolfSSL_free(serverSsl);
wolfSSL_CTX_free(clientCtx);
wolfSSL_CTX_free(serverCtx);
#endif
return EXPECT_RESULT();
}
static int test_wolfSSL_set_minmax_proto_version(void)
{
EXPECT_DECLS;
@@ -21265,6 +21541,49 @@ static int test_wolfSSL_NCONF(void)
#endif
return EXPECT_RESULT();
}
static int test_wolfSSL_NCONF_negative_paths(void)
{
EXPECT_DECLS;
/* Like its NCONF/TXT_DB siblings this sits inside the enclosing
* OPENSSL_ALL block (and its TEST_DECL is OPENSSL_ALL-gated), so the
* inner guard only narrows on the BIO dependency. */
#if !defined(NO_FILESYSTEM) && !defined(NO_BIO)
const char* confFile = "./tests/NCONF_test.cnf";
const char* missingFile = "./tests/NCONF_missing.cnf";
const char* value = NULL;
CONF* conf = NULL;
long eline = 0;
long num = 0;
ExpectIntEQ(NCONF_load(NULL, confFile, &eline), WOLFSSL_FAILURE);
ExpectIntEQ(NCONF_get_number(NULL, NULL, "port", &num), WOLFSSL_FAILURE);
ExpectNull(NCONF_get_section(NULL, "default"));
ExpectNotNull(conf = NCONF_new(NULL));
ExpectIntEQ(NCONF_load(conf, missingFile, &eline), WOLFSSL_FAILURE);
ExpectIntEQ(NCONF_get_number(conf, NULL, NULL, &num), WOLFSSL_FAILURE);
ExpectIntEQ(NCONF_get_number(conf, NULL, "port", NULL), WOLFSSL_FAILURE);
ExpectIntEQ(NCONF_load(conf, confFile, &eline), 1);
value = NCONF_get_string(conf, "missing", "port");
ExpectTrue(value == NULL || XSTRCMP(value, "1234") == 0);
ExpectNull(NCONF_get_string(conf, NULL, "missing-name"));
if (NCONF_get_number(conf, "missing", "port", &num) == 1) {
ExpectIntEQ(num, 1234);
}
else {
ExpectIntEQ(NCONF_get_number(conf, "missing", "port", &num),
WOLFSSL_FAILURE);
}
ExpectNull(NCONF_get_section(conf, NULL));
ExpectNull(NCONF_get_section(conf, "missing"));
ExpectNotNull(NCONF_get_section(conf, "default"));
NCONF_free(conf);
#endif
return EXPECT_RESULT();
}
#endif /* OPENSSL_ALL */
static int test_wolfSSL_d2i_and_i2d_PublicKey(void)
@@ -28559,26 +28878,37 @@ static int test_wolfSSL_OpenSSL_version(void)
static int test_CONF_CTX_CMDLINE(void)
{
EXPECT_DECLS;
#if defined(OPENSSL_ALL) && !defined(NO_TLS) && !defined(NO_WOLFSSL_SERVER)
#if (defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_TLS) && \
!defined(NO_WOLFSSL_SERVER)
SSL_CTX* ctx = NULL;
SSL_CONF_CTX* cctx = NULL;
SSL_CONF_CTX* noCertCtx = NULL;
ExpectNotNull(cctx = SSL_CONF_CTX_new());
ExpectNotNull(noCertCtx = SSL_CONF_CTX_new());
ExpectNotNull(ctx = wolfSSL_CTX_new(wolfSSLv23_server_method()));
SSL_CONF_CTX_set_ssl_ctx(cctx, ctx);
SSL_CONF_CTX_set_ssl_ctx(noCertCtx, ctx);
/* set flags */
ExpectIntEQ(SSL_CONF_CTX_set_flags(cctx, WOLFSSL_CONF_FLAG_CMDLINE),
WOLFSSL_CONF_FLAG_CMDLINE);
ExpectIntEQ(SSL_CONF_CTX_set_flags(cctx, WOLFSSL_CONF_FLAG_CERTIFICATE),
WOLFSSL_CONF_FLAG_CMDLINE | WOLFSSL_CONF_FLAG_CERTIFICATE);
ExpectIntEQ(SSL_CONF_CTX_set_flags(noCertCtx, WOLFSSL_CONF_FLAG_CMDLINE),
WOLFSSL_CONF_FLAG_CMDLINE);
ExpectIntEQ(SSL_CONF_cmd_value_type(cctx, "-cipher"),
WOLFSSL_CONF_TYPE_STRING);
ExpectIntEQ(SSL_CONF_cmd_value_type(cctx, "-missing"),
WOLFSSL_CONF_TYPE_UNKNOWN);
/* cmd invalid command */
ExpectIntEQ(SSL_CONF_cmd(cctx, "foo", "foobar"), -2);
ExpectIntEQ(SSL_CONF_cmd(cctx, "foo", NULL), -2);
ExpectIntEQ(SSL_CONF_cmd(cctx, NULL, NULL), WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
ExpectIntEQ(SSL_CONF_cmd(cctx, NULL, "foobar"), WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
ExpectIntEQ(SSL_CONF_cmd(NULL, "-curves", "foobar"), WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
ExpectIntEQ(SSL_CONF_cmd(cctx, "-sigalgs", "RSA+SHA256"), -2);
/* cmd Certificate and Private Key*/
{
@@ -28590,6 +28920,8 @@ static int test_CONF_CTX_CMDLINE(void)
ExpectIntEQ(SSL_CONF_cmd(cctx, "-cert", ourCert), WOLFSSL_SUCCESS);
ExpectIntEQ(SSL_CONF_cmd(cctx, "-key", NULL), -3);
ExpectIntEQ(SSL_CONF_cmd(cctx, "-key", ourKey), WOLFSSL_SUCCESS);
ExpectIntEQ(SSL_CONF_cmd(noCertCtx, "-cert", ourCert), -2);
ExpectIntEQ(SSL_CONF_cmd(noCertCtx, "-key", ourKey), -2);
ExpectIntEQ(SSL_CONF_CTX_finish(cctx), WOLFSSL_SUCCESS);
#endif
}
@@ -28601,6 +28933,8 @@ static int test_CONF_CTX_CMDLINE(void)
ExpectIntEQ(SSL_CONF_cmd(cctx, "-curves", NULL), -3);
ExpectIntEQ(SSL_CONF_cmd(cctx, "-curves", curve), WOLFSSL_SUCCESS);
ExpectIntNE(SSL_CONF_cmd(cctx, "-curves", "invalidcurve"),
WOLFSSL_SUCCESS);
ExpectIntEQ(SSL_CONF_CTX_finish(cctx), WOLFSSL_SUCCESS);
#endif
}
@@ -28611,6 +28945,8 @@ static int test_CONF_CTX_CMDLINE(void)
ExpectIntEQ(SSL_CONF_cmd(cctx, "-cipher", NULL), -3);
ExpectIntEQ(SSL_CONF_cmd(cctx, "-cipher", cipher), WOLFSSL_SUCCESS);
ExpectIntNE(SSL_CONF_cmd(cctx, "-cipher", "wolfssl-invalid-cipher"),
WOLFSSL_SUCCESS);
ExpectIntEQ(SSL_CONF_CTX_finish(cctx), WOLFSSL_SUCCESS);
}
@@ -28627,6 +28963,7 @@ static int test_CONF_CTX_CMDLINE(void)
}
SSL_CTX_free(ctx);
SSL_CONF_CTX_free(noCertCtx);
SSL_CONF_CTX_free(cctx);
#endif /* OPENSSL_EXTRA */
return EXPECT_RESULT();
@@ -28635,25 +28972,36 @@ static int test_CONF_CTX_CMDLINE(void)
static int test_CONF_CTX_FILE(void)
{
EXPECT_DECLS;
#if defined(OPENSSL_ALL) && !defined(NO_TLS) && !defined(NO_WOLFSSL_SERVER)
#if (defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_TLS) && \
!defined(NO_WOLFSSL_SERVER)
SSL_CTX* ctx = NULL;
SSL_CONF_CTX* cctx = NULL;
SSL_CONF_CTX* noCertCtx = NULL;
ExpectNotNull(cctx = SSL_CONF_CTX_new());
ExpectNotNull(noCertCtx = SSL_CONF_CTX_new());
ExpectNotNull(ctx = wolfSSL_CTX_new(wolfSSLv23_server_method()));
SSL_CONF_CTX_set_ssl_ctx(cctx, ctx);
SSL_CONF_CTX_set_ssl_ctx(noCertCtx, ctx);
/* set flags */
ExpectIntEQ(SSL_CONF_CTX_set_flags(cctx, WOLFSSL_CONF_FLAG_FILE),
WOLFSSL_CONF_FLAG_FILE);
ExpectIntEQ(SSL_CONF_CTX_set_flags(cctx, WOLFSSL_CONF_FLAG_CERTIFICATE),
WOLFSSL_CONF_FLAG_FILE | WOLFSSL_CONF_FLAG_CERTIFICATE);
ExpectIntEQ(SSL_CONF_CTX_set_flags(noCertCtx, WOLFSSL_CONF_FLAG_FILE),
WOLFSSL_CONF_FLAG_FILE);
ExpectIntEQ(SSL_CONF_cmd_value_type(cctx, "CipherString"),
WOLFSSL_CONF_TYPE_STRING);
ExpectIntEQ(SSL_CONF_cmd_value_type(cctx, "missing"),
WOLFSSL_CONF_TYPE_UNKNOWN);
/* sanity check */
ExpectIntEQ(SSL_CONF_cmd(cctx, "foo", "foobar"), -2);
ExpectIntEQ(SSL_CONF_cmd(cctx, "foo", NULL), -2);
ExpectIntEQ(SSL_CONF_cmd(cctx, NULL, NULL), WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
ExpectIntEQ(SSL_CONF_cmd(cctx, NULL, "foobar"), WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
ExpectIntEQ(SSL_CONF_cmd(NULL, "-curves", "foobar"), WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
ExpectIntEQ(SSL_CONF_cmd(cctx, "SignatureAlgorithms", "RSA+SHA256"), -2);
/* cmd Certificate and Private Key*/
{
@@ -28667,6 +29015,8 @@ static int test_CONF_CTX_FILE(void)
ExpectIntEQ(SSL_CONF_cmd(cctx, "Certificate", ourCert),
WOLFSSL_SUCCESS);
ExpectIntEQ(SSL_CONF_cmd(cctx, "PrivateKey", ourKey), WOLFSSL_SUCCESS);
ExpectIntEQ(SSL_CONF_cmd(noCertCtx, "Certificate", ourCert), -2);
ExpectIntEQ(SSL_CONF_cmd(noCertCtx, "PrivateKey", ourKey), -2);
ExpectIntEQ(SSL_CONF_CTX_finish(cctx), WOLFSSL_SUCCESS);
#endif
}
@@ -28678,6 +29028,8 @@ static int test_CONF_CTX_FILE(void)
ExpectIntEQ(SSL_CONF_cmd(cctx, "Curves", NULL), -3);
ExpectIntEQ(SSL_CONF_cmd(cctx, "Curves", curve), WOLFSSL_SUCCESS);
ExpectIntNE(SSL_CONF_cmd(cctx, "Curves", "invalidcurve"),
WOLFSSL_SUCCESS);
ExpectIntEQ(SSL_CONF_CTX_finish(cctx), WOLFSSL_SUCCESS);
#endif
}
@@ -28689,6 +29041,8 @@ static int test_CONF_CTX_FILE(void)
ExpectIntEQ(SSL_CONF_cmd(cctx, "CipherString", NULL), -3);
ExpectIntEQ(SSL_CONF_cmd(cctx, "CipherString", cipher),
WOLFSSL_SUCCESS);
ExpectIntNE(SSL_CONF_cmd(cctx, "CipherString", "wolfssl-invalid-cipher"),
WOLFSSL_SUCCESS);
ExpectIntEQ(SSL_CONF_CTX_finish(cctx), WOLFSSL_SUCCESS);
}
@@ -28706,6 +29060,7 @@ static int test_CONF_CTX_FILE(void)
}
SSL_CTX_free(ctx);
SSL_CONF_CTX_free(noCertCtx);
SSL_CONF_CTX_free(cctx);
#endif /* OPENSSL_EXTRA */
return EXPECT_RESULT();
@@ -30038,6 +30393,105 @@ static int test_CryptoCb_Func(int thisDevId, wc_CryptoInfo* info, void* ctx)
return ret;
}
/* These callback helpers are only referenced by test_wc_CryptoCb_registry,
* whose body is compiled only under WOLF_CRYPTO_CB + WOLFSSL_TEST_STATIC_BUILD
* (it calls WOLFSSL_LOCAL cryptocb helpers). Match that guard so they are not
* flagged as unused in cryptocb-enabled non-static builds. */
#if defined(WOLF_CRYPTO_CB) && defined(WOLFSSL_TEST_STATIC_BUILD)
static int test_CryptoCb_NoOp_Func(int devId, wc_CryptoInfo* info, void* ctx)
{
(void)devId;
(void)info;
(void)ctx;
return WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
}
#ifdef WOLF_CRYPTO_CB_CMD
static int test_CryptoCb_RegisterUnavailable_Func(int devId, wc_CryptoInfo* info,
void* ctx)
{
(void)devId;
(void)ctx;
if (info != NULL && info->algo_type == WC_ALGO_TYPE_NONE &&
info->cmd.type == WC_CRYPTOCB_CMD_TYPE_REGISTER) {
return WC_NO_ERR_TRACE(NOT_COMPILED_IN);
}
return WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
}
static int test_CryptoCb_RegisterFail_Func(int devId, wc_CryptoInfo* info,
void* ctx)
{
(void)devId;
(void)ctx;
if (info != NULL && info->algo_type == WC_ALGO_TYPE_NONE &&
info->cmd.type == WC_CRYPTOCB_CMD_TYPE_REGISTER) {
return BAD_FUNC_ARG;
}
return WC_NO_ERR_TRACE(CRYPTOCB_UNAVAILABLE);
}
#endif /* WOLF_CRYPTO_CB_CMD */
#endif /* WOLF_CRYPTO_CB && WOLFSSL_TEST_STATIC_BUILD */
static int test_wc_CryptoCb_registry(void)
{
EXPECT_DECLS;
/* This test asserts on wc_CryptoCb_GetDevIdAtIndex()/Init()/Cleanup(), which
* are WOLFSSL_LOCAL (hidden visibility) and only link into the test binary when
* the library is built with test-static visibility. Guard on
* WOLFSSL_TEST_STATIC_BUILD so normal (shared) builds don't fail at link. */
#if defined(WOLF_CRYPTO_CB) && defined(WOLFSSL_TEST_STATIC_BUILD)
int rc = 0;
int devId = 41;
int added = 0;
wc_CryptoCb_Init();
ExpectIntEQ(wc_CryptoCb_GetDevIdAtIndex(0), INVALID_DEVID);
ExpectIntEQ(wc_CryptoCb_RegisterDevice(devId, test_CryptoCb_NoOp_Func,
NULL), 0);
ExpectIntEQ(wc_CryptoCb_GetDevIdAtIndex(0), devId);
/* Re-registering the same device id updates the entry instead of growing
* the device table. */
ExpectIntEQ(wc_CryptoCb_RegisterDevice(devId, NULL, (void*)1), 0);
ExpectIntEQ(wc_CryptoCb_GetDevIdAtIndex(0), devId);
wc_CryptoCb_UnRegisterDevice(INVALID_DEVID);
ExpectIntEQ(wc_CryptoCb_GetDevIdAtIndex(0), devId);
#ifdef WOLF_CRYPTO_CB_CMD
ExpectIntEQ(wc_CryptoCb_RegisterDevice(devId + 1,
test_CryptoCb_RegisterUnavailable_Func, NULL), 0);
ExpectIntEQ(wc_CryptoCb_GetDevIdAtIndex(1), devId + 1);
ExpectIntEQ(wc_CryptoCb_RegisterDevice(devId + 2,
test_CryptoCb_RegisterFail_Func, NULL), BAD_FUNC_ARG);
ExpectIntEQ(wc_CryptoCb_GetDevIdAtIndex(2), INVALID_DEVID);
#endif
/* Fill the remaining registration table until it reports full. */
for (devId += 3; devId < 64; devId++) {
rc = wc_CryptoCb_RegisterDevice(devId, test_CryptoCb_NoOp_Func, NULL);
if (rc != 0) {
break;
}
added++;
}
ExpectIntGT(added, 0);
ExpectIntEQ(rc, BUFFER_E);
wc_CryptoCb_Cleanup();
ExpectIntEQ(wc_CryptoCb_GetDevIdAtIndex(0), INVALID_DEVID);
#endif
return EXPECT_RESULT();
}
/* tlsVer: WOLFSSL_TLSV1_2 or WOLFSSL_TLSV1_3 */
static int test_wc_CryptoCb_TLS(int tlsVer,
const char* cliCaPemFile, const char* cliCertPemFile,
@@ -34351,6 +34805,19 @@ static int test_ocsp_callback_fails_cb(void* ctx, const char* url, int urlSz,
(void)ocspRespBuf;
return WOLFSSL_CBIO_ERR_GENERAL;
}
static int test_ocsp_callback_missing_resp_cb(void* ctx, const char* url,
int urlSz, byte* ocspReqBuf, int ocspReqSz,
byte** ocspRespBuf)
{
(void)ctx;
(void)url;
(void)urlSz;
(void)ocspReqBuf;
(void)ocspReqSz;
if (ocspRespBuf != NULL)
*ocspRespBuf = NULL;
return 0;
}
static int test_ocsp_callback_fails(void)
{
WOLFSSL_CTX *ctx_c = NULL;
@@ -34381,11 +34848,51 @@ static int test_ocsp_callback_fails(void)
return EXPECT_RESULT();
}
static int test_ocsp_callback_missing_resp(void)
{
WOLFSSL_CTX *ctx_c = NULL;
WOLFSSL_CTX *ctx_s = NULL;
WOLFSSL *ssl_c = NULL;
WOLFSSL *ssl_s = NULL;
struct test_memio_ctx test_ctx;
EXPECT_DECLS;
XMEMSET(&test_ctx, 0, sizeof(test_ctx));
ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, &ctx_s, &ssl_c, &ssl_s,
wolfTLSv1_2_client_method, wolfTLSv1_2_server_method), 0);
ExpectIntEQ(wolfSSL_CTX_EnableOCSPStapling(ctx_c), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_EnableOCSPStapling(ctx_s), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_UseOCSPStapling(ssl_c, WOLFSSL_CSR_OCSP, 0),
WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_SetOCSP_OverrideURL(ctx_s, "http://dummy.test"),
WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_EnableOCSP(ctx_s, WOLFSSL_OCSP_NO_NONCE |
WOLFSSL_OCSP_URL_OVERRIDE), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CTX_load_verify_locations(ctx_s, caCertFile, 0),
WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_SetOCSP_Cb(ssl_s, test_ocsp_callback_missing_resp_cb,
NULL, NULL), WOLFSSL_SUCCESS);
ExpectIntEQ(test_memio_do_handshake(ssl_c, ssl_s, 10, NULL), -1);
ExpectIntEQ(wolfSSL_get_error(ssl_s, -1),
WC_NO_ERR_TRACE(OCSP_INVALID_STATUS));
wolfSSL_free(ssl_c);
wolfSSL_free(ssl_s);
wolfSSL_CTX_free(ctx_c);
wolfSSL_CTX_free(ctx_s);
return EXPECT_RESULT();
}
#else
static int test_ocsp_callback_fails(void)
{
return TEST_SKIPPED;
}
static int test_ocsp_callback_missing_resp(void)
{
return TEST_SKIPPED;
}
#endif /* defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && \
defined(HAVE_OCSP) && \
defined(HAVE_CERTIFICATE_STATUS_REQUEST) */
@@ -34410,9 +34917,29 @@ static int test_wolfSSL_SSLDisableRead(void)
XMEMSET(&test_ctx, 0, sizeof(test_ctx));
wolfSSL_SSLSetIORecv(NULL, test_wolfSSL_SSLDisableRead_recv);
wolfSSL_SSLSetIOSend(NULL, test_memio_write_cb);
wolfSSL_CTX_SetIORecv(NULL, test_wolfSSL_SSLDisableRead_recv);
wolfSSL_CTX_SetIOSend(NULL, test_memio_write_cb);
wolfSSL_SetIOReadCtx(NULL, &test_ctx);
wolfSSL_SetIOWriteCtx(NULL, &test_ctx);
wolfSSL_SSLDisableRead(NULL);
wolfSSL_SSLEnableRead(NULL);
ExpectNull(wolfSSL_GetIOReadCtx(NULL));
ExpectNull(wolfSSL_GetIOWriteCtx(NULL));
ExpectIntEQ(test_memio_setup(&test_ctx, &ctx_c, NULL, &ssl_c, NULL,
wolfTLS_client_method, NULL), 0);
wolfSSL_CTX_SetIORecv(ctx_c, test_wolfSSL_SSLDisableRead_recv);
wolfSSL_CTX_SetIOSend(ctx_c, test_memio_write_cb);
ExpectPtrEq(ctx_c->CBIORecv, test_wolfSSL_SSLDisableRead_recv);
ExpectPtrEq(ctx_c->CBIOSend, test_memio_write_cb);
wolfSSL_SSLSetIORecv(ssl_c, test_wolfSSL_SSLDisableRead_recv);
wolfSSL_SSLSetIOSend(ssl_c, test_memio_write_cb);
wolfSSL_SetIOReadCtx(ssl_c, &test_ctx);
wolfSSL_SetIOWriteCtx(ssl_c, &test_ctx);
ExpectPtrEq(wolfSSL_GetIOReadCtx(ssl_c), &test_ctx);
ExpectPtrEq(wolfSSL_GetIOWriteCtx(ssl_c), &test_ctx);
wolfSSL_SSLDisableRead(ssl_c);
/* Disabling reading should not even go into the IO layer */
@@ -36103,6 +36630,7 @@ TEST_CASE testCases[] = {
#ifdef OPENSSL_ALL
TEST_DECL(test_wolfSSL_TXT_DB),
TEST_DECL(test_wolfSSL_NCONF),
TEST_DECL(test_wolfSSL_NCONF_negative_paths),
#endif
TEST_DECL(test_wolfSSL_CRYPTO_memcmp),
@@ -36195,6 +36723,7 @@ TEST_CASE testCases[] = {
TEST_DECL(test_wolfSSL_crypto_policy_ciphers),
TEST_DECL(test_wolfSSL_SSL_in_init),
TEST_DECL(test_wolfSSL_CTX_set_timeout),
TEST_DECL(test_wolfSSL_session_cache_api_direct),
TEST_DECL(test_wolfSSL_set_psk_use_session_callback),
TEST_DECL(test_CONF_CTX_FILE),
@@ -36263,6 +36792,7 @@ TEST_CASE testCases[] = {
TEST_DECL(test_wolfSSL_CTX_trust_peer_cert),
TEST_DECL(test_wolfSSL_CTX_LoadCRL),
TEST_DECL(test_wolfSSL_CTX_LoadCRL_largeCRLnum),
TEST_DECL(test_wolfSSL_crl_ocsp_object_api),
TEST_DECL(test_wolfSSL_crl_update_cb),
TEST_DECL(test_wolfSSL_CTX_SetTmpDH_file),
TEST_DECL(test_wolfSSL_CTX_SetTmpDH_buffer),
@@ -36413,6 +36943,7 @@ TEST_CASE testCases[] = {
TEST_DECL(test_wolfSSL_UseOCSPStaplingV2),
TEST_DECL(test_self_signed_stapling),
TEST_DECL(test_ocsp_callback_fails),
TEST_DECL(test_ocsp_callback_missing_resp),
/* Multicast */
TEST_DECL(test_wolfSSL_mcast),
@@ -36444,6 +36975,19 @@ TEST_CASE testCases[] = {
/* Can't memory test as client/server Asserts in thread. */
TEST_DECL(test_prioritize_psk),
/* test_wc_CryptoCb_registry is defined only inside the
* WOLF_CRYPTO_CB + HAVE_IO_TESTS_DEPENDENCIES block below; register it under
* the same condition so it is neither undeclared (when absent) nor
* defined-but-unused. */
#if defined(WOLF_CRYPTO_CB) && defined(HAVE_IO_TESTS_DEPENDENCIES) && \
(!defined(WOLF_CRYPTO_CB_ONLY_SHA256) && !defined(WOLF_CRYPTO_CB_ONLY_AES) && \
!defined(WOLF_CRYPTO_CB_ONLY_ECC) && !defined(WOLF_CRYPTO_CB_ONLY_RSA) && \
!defined(WOLF_CRYPTO_CB_ONLY_SHA512))
/* Can't memory test as client/server hangs. */
TEST_DECL(test_wc_CryptoCb_registry),
#endif
/* test_wc_CryptoCb has an unconditional shell (body self-guards); register
* unconditionally, as on master. */
/* Can't memory test as client/server hangs. */
TEST_DECL(test_wc_CryptoCb),
/* Can't memory test as client/server hangs. */
tests/api/test_aes.c
+2218
View File
File diff suppressed because it is too large Load Diff
tests/api/test_aes.h
+32 -2
View File
@@ -56,6 +56,21 @@ int test_wc_AesGcmStream(void);
int test_wc_AesGcmStream_MidStreamState(void);
int test_wc_AesGcmStream_ReinitAfterFinal(void);
int test_wc_AesGcmStream_BadAuthTag(void);
int test_wc_AesKeyWrapVectors(void);
int test_wc_AesKeyWrapDecisionCoverage(void);
int test_wc_AesGcmDecisionCoverage(void);
int test_wc_AesFeatureCoverage(void);
int test_wc_AesSetKeyArgMcdc(void);
int test_wc_AesModesArgMcdc(void);
int test_wc_AesGcmArgMcdc(void);
int test_wc_AesGmacArgMcdc(void);
int test_wc_AesCcmArgMcdc(void);
int test_wc_AesXtsArgMcdc(void);
int test_wc_AesCmacArgMcdc(void);
int test_wc_AesKeyExportArgMcdc(void);
#if defined(WOLFSSL_AES_SIV) && defined(WOLFSSL_AES_128)
int test_wc_AesSivArgMcdc(void);
#endif
int test_wc_AesCcmSetKey(void);
int test_wc_AesCcmEncryptDecrypt(void);
int test_wc_AesCcmEncryptDecrypt_InPlace(void);
@@ -76,6 +91,7 @@ int test_wc_AesEaxVectors(void);
int test_wc_AesEaxEncryptAuth(void);
int test_wc_AesEaxDecryptAuth(void);
int test_wc_AesEaxStream(void);
int test_wc_AesEaxArgMcdc(void);
#endif /* WOLFSSL_AES_EAX && WOLFSSL_AES_256*/
#if defined(WOLFSSL_AES_SIV) && defined(WOLFSSL_AES_128)
int test_wc_AesSivEncryptDecrypt(void);
@@ -179,6 +195,18 @@ int test_wc_CryptoCb_Tls13_Key_No_Zero_Without_Offload(void);
TEST_DECL_GROUP("aes", test_wc_AesGcmStream_MidStreamState), \
TEST_DECL_GROUP("aes", test_wc_AesGcmStream_ReinitAfterFinal), \
TEST_DECL_GROUP("aes", test_wc_AesGcmStream_BadAuthTag), \
TEST_DECL_GROUP("aes", test_wc_AesKeyWrapVectors), \
TEST_DECL_GROUP("aes", test_wc_AesKeyWrapDecisionCoverage), \
TEST_DECL_GROUP("aes", test_wc_AesGcmDecisionCoverage), \
TEST_DECL_GROUP("aes", test_wc_AesFeatureCoverage), \
TEST_DECL_GROUP("aes", test_wc_AesSetKeyArgMcdc), \
TEST_DECL_GROUP("aes", test_wc_AesModesArgMcdc), \
TEST_DECL_GROUP("aes", test_wc_AesGcmArgMcdc), \
TEST_DECL_GROUP("aes", test_wc_AesGmacArgMcdc), \
TEST_DECL_GROUP("aes", test_wc_AesCcmArgMcdc), \
TEST_DECL_GROUP("aes", test_wc_AesXtsArgMcdc), \
TEST_DECL_GROUP("aes", test_wc_AesCmacArgMcdc), \
TEST_DECL_GROUP("aes", test_wc_AesKeyExportArgMcdc), \
TEST_DECL_GROUP("aes", test_wc_AesCcmSetKey), \
TEST_DECL_GROUP("aes", test_wc_AesCcmEncryptDecrypt), \
TEST_DECL_GROUP("aes", test_wc_AesCcmEncryptDecrypt_InPlace), \
@@ -210,12 +238,14 @@ int test_wc_CryptoCb_Tls13_Key_No_Zero_Without_Offload(void);
TEST_DECL_GROUP("aes-eax", test_wc_AesEaxVectors), \
TEST_DECL_GROUP("aes-eax", test_wc_AesEaxEncryptAuth), \
TEST_DECL_GROUP("aes-eax", test_wc_AesEaxDecryptAuth), \
TEST_DECL_GROUP("aes-eax", test_wc_AesEaxStream)
TEST_DECL_GROUP("aes-eax", test_wc_AesEaxStream), \
TEST_DECL_GROUP("aes-eax", test_wc_AesEaxArgMcdc)
#endif /* WOLFSSL_AES_EAX */
#if defined(WOLFSSL_AES_SIV) && defined(WOLFSSL_AES_128)
#define TEST_AES_SIV_DECLS \
TEST_DECL_GROUP("aes-siv", test_wc_AesSivEncryptDecrypt)
TEST_DECL_GROUP("aes-siv", test_wc_AesSivEncryptDecrypt), \
TEST_DECL_GROUP("aes-siv", test_wc_AesSivArgMcdc)
#endif /* WOLFSSL_AES_SIV && WOLFSSL_AES_128 */
#define TEST_GMAC_DECLS \
tests/api/test_asn.c
+267
View File
@@ -34,6 +34,9 @@
#ifdef HAVE_ED448
#include <wolfssl/wolfcrypt/ed448.h>
#endif
#ifdef HAVE_ECC
#include <wolfssl/wolfcrypt/ecc.h>
#endif
#ifdef HAVE_DILITHIUM
#include <wolfssl/wolfcrypt/dilithium.h>
#endif
@@ -2214,3 +2217,267 @@ int test_ToTraditional_ex_mldsa_bad_params(void)
#endif
return EXPECT_RESULT();
}
/*
* MC/DC wave 2 - decision-targeted negative paths for PKCS#8 wrap/parse
* and RSA key decode. Targets argument-check, short-buffer, and
* truncated-DER decision branches in wolfcrypt/src/asn.c without touching
* the library source.
*/
int test_wc_AsnDecisionCoverage(void)
{
EXPECT_DECLS;
#if !defined(NO_ASN) && !defined(NO_RSA) && \
(defined(USE_CERT_BUFFERS_1024) || defined(USE_CERT_BUFFERS_2048)) && \
!defined(HAVE_FIPS)
/* ---- wc_RsaPublicKeyDecode: truncated / bad-arg decision branches ---- */
{
RsaKey key;
const byte* derKey;
word32 derKeySz;
word32 idx;
XMEMSET(&key, 0, sizeof(key));
ExpectIntEQ(wc_InitRsaKey(&key, HEAP_HINT), 0);
#ifdef USE_CERT_BUFFERS_2048
derKey = client_keypub_der_2048;
derKeySz = (word32)sizeof_client_keypub_der_2048;
#else
derKey = client_keypub_der_1024;
derKeySz = (word32)sizeof_client_keypub_der_1024;
#endif
/* Null arg branches. */
idx = 0;
ExpectIntEQ(wc_RsaPublicKeyDecode(NULL, &idx, &key, derKeySz),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RsaPublicKeyDecode(derKey, NULL, &key, derKeySz),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RsaPublicKeyDecode(derKey, &idx, NULL, derKeySz),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Truncated input: header says more data than buffer length. */
idx = 0;
ExpectIntLT(wc_RsaPublicKeyDecode(derKey, &idx, &key, 4), 0);
/* wc_RsaPublicKeyDecodeRaw null-arg branches. */
{
static const byte nBuf[] = { 0xC0 };
static const byte eBuf[] = { 0x01, 0x00, 0x01 };
ExpectIntEQ(wc_RsaPublicKeyDecodeRaw(NULL, sizeof(nBuf),
eBuf, sizeof(eBuf), &key), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RsaPublicKeyDecodeRaw(nBuf, sizeof(nBuf),
NULL, sizeof(eBuf), &key), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RsaPublicKeyDecodeRaw(nBuf, sizeof(nBuf),
eBuf, sizeof(eBuf), NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
}
DoExpectIntEQ(wc_FreeRsaKey(&key), 0);
}
/* ---- wc_GetPkcs8TraditionalOffset: argument-check branches ---- */
{
byte buf[8] = { 0x30, 0x82, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00 };
word32 idx;
idx = 0;
ExpectIntEQ(wc_GetPkcs8TraditionalOffset(NULL, &idx, sizeof(buf)),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_GetPkcs8TraditionalOffset(buf, NULL, sizeof(buf)),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* idx >= sz decision branch - any negative return exercises the
* short-input guard (BUFFER_E in current code, but we do not pin
* the exact code here). */
idx = sizeof(buf);
ExpectIntLT(wc_GetPkcs8TraditionalOffset(buf, &idx, sizeof(buf)), 0);
/* Non-PKCS#8 blob: malformed DER decision branch. */
{
byte bogus[4] = { 0x00, 0x00, 0x00, 0x00 };
idx = 0;
ExpectIntLT(wc_GetPkcs8TraditionalOffset(bogus, &idx,
sizeof(bogus)), 0);
}
}
/* ---- wc_CreatePKCS8Key: size-query and bad-arg branches ----
* Uses the existing RSA private key DER from certs_test.h to avoid
* runtime key generation (which requires WOLFSSL_KEY_GEN and a usable
* RNG and is not available in every retained lane). */
{
#ifdef USE_CERT_BUFFERS_2048
const byte* rsaDer = client_key_der_2048;
word32 rsaDerSz = (word32)sizeof_client_key_der_2048;
#else
const byte* rsaDer = client_key_der_1024;
word32 rsaDerSz = (word32)sizeof_client_key_der_1024;
#endif
byte pkcs8[2048];
word32 pkcs8Sz;
/* Size-query: out == NULL should return LENGTH_ONLY_E and set
* outSz. */
pkcs8Sz = 0;
ExpectIntEQ(wc_CreatePKCS8Key(NULL, &pkcs8Sz, (byte*)rsaDer,
rsaDerSz, RSAk, NULL, 0),
WC_NO_ERR_TRACE(LENGTH_ONLY_E));
ExpectIntGT(pkcs8Sz, 0);
/* Null outSz branch. */
ExpectIntEQ(wc_CreatePKCS8Key(pkcs8, NULL, (byte*)rsaDer, rsaDerSz,
RSAk, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
}
#endif /* !NO_ASN && !NO_RSA && cert-buffers && !HAVE_FIPS */
return EXPECT_RESULT();
}
/*
* MC/DC wave 2 - feature-oriented positive paths to lift asn.c MC/DC by
* exercising real cert parsing, PKCS#8 round trips, ECC key decoding, and
* PEM<->DER conversions on the static cert buffers (no new fixtures).
*/
int test_wc_AsnFeatureCoverage(void)
{
EXPECT_DECLS;
#if !defined(NO_ASN) && !defined(NO_RSA) && \
defined(USE_CERT_BUFFERS_2048) && !defined(HAVE_FIPS)
/* ---- DecodedCert: full client cert parse, with subject + pubkey ---- */
{
struct DecodedCert cert;
byte pubKey[512];
word32 pubKeySz = sizeof(pubKey);
char subject[256];
word32 subjectSz = sizeof(subject);
wc_InitDecodedCert(&cert, client_cert_der_2048,
sizeof_client_cert_der_2048, NULL);
ExpectIntEQ(wc_ParseCert(&cert, CERT_TYPE, NO_VERIFY, NULL), 0);
ExpectIntEQ(wc_GetPubKeyDerFromCert(&cert, pubKey, &pubKeySz), 0);
ExpectIntGT(pubKeySz, 0);
ExpectIntEQ(wc_GetDecodedCertSubject(&cert, subject, &subjectSz), 0);
wc_FreeDecodedCert(&cert);
}
/* ---- DecodedCert: server cert parse and SubjectPublicKeyInfo extract -- */
{
struct DecodedCert cert;
byte spki[1024];
word32 spkiSz = sizeof(spki);
wc_InitDecodedCert(&cert, server_cert_der_2048,
sizeof_server_cert_der_2048, NULL);
ExpectIntEQ(wc_ParseCert(&cert, CERT_TYPE, NO_VERIFY, NULL), 0);
wc_FreeDecodedCert(&cert);
/* Some retained builds return 0 on success and write spkiSz; others
* return spkiSz directly. Accept any non-negative result and require
* a non-zero output size. */
ExpectIntGE(wc_GetSubjectPubKeyInfoDerFromCert(server_cert_der_2048,
sizeof_server_cert_der_2048, spki, &spkiSz), 0);
ExpectIntGT(spkiSz, 0);
}
/* ---- PKCS#8: round trip wrap then offset extract ---- */
{
byte pkcs8[2048];
word32 pkcs8Sz = 0;
word32 idx;
int wrapSz;
/* Size query first. */
ExpectIntEQ(wc_CreatePKCS8Key(NULL, &pkcs8Sz,
(byte*)client_key_der_2048, sizeof_client_key_der_2048, RSAk,
NULL, 0), WC_NO_ERR_TRACE(LENGTH_ONLY_E));
ExpectIntGT(pkcs8Sz, 0);
wrapSz = wc_CreatePKCS8Key(pkcs8, &pkcs8Sz,
(byte*)client_key_der_2048, sizeof_client_key_der_2048, RSAk,
NULL, 0);
ExpectIntGT(wrapSz, 0);
if (wrapSz > 0) {
idx = 0;
ExpectIntGE(wc_GetPkcs8TraditionalOffset(pkcs8, &idx,
(word32)wrapSz), 0);
ExpectIntGT(idx, 0);
}
}
/* ---- CA cert parse: exercises CA-specific decision branches ---- */
{
struct DecodedCert caCert;
wc_InitDecodedCert(&caCert, ca_cert_der_2048, sizeof_ca_cert_der_2048,
NULL);
ExpectIntEQ(wc_ParseCert(&caCert, CA_TYPE, NO_VERIFY, NULL), 0);
wc_FreeDecodedCert(&caCert);
}
/* ---- Parse server cert a second time with CERT_TYPE + verify off ----
* to touch ParseCertRelative decision branches that the first pass skips.
*/
{
struct DecodedCert cert2;
wc_InitDecodedCert(&cert2, server_cert_der_2048,
sizeof_server_cert_der_2048, NULL);
ExpectIntEQ(wc_ParseCert(&cert2, CERT_TYPE, NO_VERIFY, NULL), 0);
wc_FreeDecodedCert(&cert2);
}
/* ---- PEM<->DER conversion round trip on the client cert ---- */
#ifdef WOLFSSL_DER_TO_PEM
{
byte pem[4096];
int pemSz;
pemSz = wc_DerToPem(client_cert_der_2048, sizeof_client_cert_der_2048,
pem, sizeof(pem), CERT_TYPE);
ExpectIntGT(pemSz, 0);
#ifdef WOLFSSL_PEM_TO_DER
if (pemSz > 0) {
byte der[2048];
int derSz;
derSz = wc_CertPemToDer(pem, pemSz, der, sizeof(der), CERT_TYPE);
ExpectIntGT(derSz, 0);
if (derSz > 0)
ExpectBufEQ(der, client_cert_der_2048,
sizeof_client_cert_der_2048);
}
#endif
}
#endif /* WOLFSSL_DER_TO_PEM */
#endif /* !NO_ASN && !NO_RSA && USE_CERT_BUFFERS_2048 && !HAVE_FIPS */
#if !defined(NO_ASN) && defined(HAVE_ECC) && \
defined(USE_CERT_BUFFERS_256) && !defined(HAVE_FIPS)
/* ---- ECC private + public key DER decode round trip ---- */
{
ecc_key ecKey;
word32 idx = 0;
byte pubKeyDer[256];
int derSz;
XMEMSET(&ecKey, 0, sizeof(ecKey));
ExpectIntEQ(wc_ecc_init(&ecKey), 0);
ExpectIntEQ(wc_EccPrivateKeyDecode(ecc_clikey_der_256, &idx, &ecKey,
sizeof_ecc_clikey_der_256), 0);
derSz = wc_EccPublicKeyToDer(&ecKey, pubKeyDer, sizeof(pubKeyDer), 1);
ExpectIntGT(derSz, 0);
if (derSz > 0) {
ecc_key pubOnly;
word32 idx2 = 0;
XMEMSET(&pubOnly, 0, sizeof(pubOnly));
ExpectIntEQ(wc_ecc_init(&pubOnly), 0);
ExpectIntEQ(wc_EccPublicKeyDecode(pubKeyDer, &idx2, &pubOnly,
(word32)derSz), 0);
wc_ecc_free(&pubOnly);
}
wc_ecc_free(&ecKey);
}
#endif /* !NO_ASN && HAVE_ECC && USE_CERT_BUFFERS_256 && !HAVE_FIPS */
return EXPECT_RESULT();
}
tests/api/test_asn.h
+5 -1
View File
@@ -42,6 +42,8 @@ int test_ToTraditional_ex_handcrafted(void);
int test_ToTraditional_ex_roundtrip(void);
int test_ToTraditional_ex_negative(void);
int test_ToTraditional_ex_mldsa_bad_params(void);
int test_wc_AsnDecisionCoverage(void);
int test_wc_AsnFeatureCoverage(void);
#define TEST_ASN_DECLS \
TEST_DECL_GROUP("asn", test_SetAsymKeyDer), \
@@ -61,6 +63,8 @@ int test_ToTraditional_ex_mldsa_bad_params(void);
TEST_DECL_GROUP("asn", test_ToTraditional_ex_handcrafted), \
TEST_DECL_GROUP("asn", test_ToTraditional_ex_roundtrip), \
TEST_DECL_GROUP("asn", test_ToTraditional_ex_negative), \
TEST_DECL_GROUP("asn", test_ToTraditional_ex_mldsa_bad_params)
TEST_DECL_GROUP("asn", test_ToTraditional_ex_mldsa_bad_params), \
TEST_DECL_GROUP("asn", test_wc_AsnDecisionCoverage), \
TEST_DECL_GROUP("asn", test_wc_AsnFeatureCoverage)
#endif /* WOLFCRYPT_TEST_ASN_H */
tests/api/test_certman.c
+15 -2
View File
@@ -716,20 +716,29 @@ int test_wolfSSL_CertManagerSetVerify(void)
ExpectNotNull(cm = wolfSSL_CertManagerNew());
wolfSSL_CertManagerSetVerify(cm, myVerify);
#if defined(NO_WOLFSSL_CLIENT) && defined(NO_WOLFSSL_SERVER)
ExpectIntEQ(wolfSSL_CertManagerLoadCA(cm, ca_cert, NULL), -1);
#else
ExpectIntEQ(wolfSSL_CertManagerLoadCA(cm, ca_cert, NULL),
WOLFSSL_SUCCESS);
/* Exercise the baseline verification path before the callback overrides
* the result, so the expired-cert failure remains visible to MC/DC. */
ExpectIntNE(wolfSSL_CertManagerVerify(cm, expiredCert,
CERT_FILETYPE), WOLFSSL_SUCCESS);
#endif
wolfSSL_CertManagerSetVerify(cm, myVerify);
/* Use the test CB that always accepts certs */
myVerifyAction = VERIFY_OVERRIDE_ERROR;
ExpectIntEQ(wolfSSL_CertManagerVerify(cm, expiredCert,
CERT_FILETYPE), WOLFSSL_SUCCESS);
wolfSSL_CertManagerSetVerify(cm, NULL);
ExpectIntNE(wolfSSL_CertManagerVerify(cm, expiredCert,
CERT_FILETYPE), WOLFSSL_SUCCESS);
wolfSSL_CertManagerSetVerify(cm, myVerify);
#ifdef WOLFSSL_ALWAYS_VERIFY_CB
{
const char* verifyCert = "./certs/server-cert.der";
@@ -2425,6 +2434,10 @@ int test_wolfSSL_CertManagerCRL(void)
WOLFSSL_FILETYPE_ASN1), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wolfSSL_CertManagerLoadCRLBuffer(cm, crl_buff, -1,
WOLFSSL_FILETYPE_ASN1), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntNE(wolfSSL_CertManagerLoadCRLBuffer(cm, crl_buff, 0,
WOLFSSL_FILETYPE_ASN1), WOLFSSL_SUCCESS);
ExpectIntNE(wolfSSL_CertManagerLoadCRLBuffer(cm, crl_buff,
sizeof(crl_buff) - 1, WOLFSSL_FILETYPE_ASN1), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_CertManagerFreeCRL(NULL),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
tests/api/test_ocsp.c
+128
View File
@@ -26,6 +26,7 @@
#include <wolfssl/internal.h>
#include <wolfssl/ocsp.h>
#include <wolfssl/ssl.h>
#include <wolfssl/wolfio.h>
#include <wolfssl/wolfcrypt/asn.h>
#if defined(HAVE_OCSP) && !defined(NO_SHA) && !defined(NO_RSA)
@@ -45,6 +46,38 @@ struct test_conf {
int targetCertSz;
};
struct wolfio_http_test_ctx {
const char* data;
int dataSz;
int offset;
int maxChunk;
int finalRet;
};
static int wolfio_http_test_io_cb(char* buf, int sz, void* ctx)
{
struct wolfio_http_test_ctx* ioCtx = (struct wolfio_http_test_ctx*)ctx;
int copySz;
if (ioCtx == NULL)
return WOLFSSL_FATAL_ERROR;
if (ioCtx->offset >= ioCtx->dataSz)
return ioCtx->finalRet;
copySz = ioCtx->dataSz - ioCtx->offset;
if (copySz > sz)
copySz = sz;
if (ioCtx->maxChunk > 0 && copySz > ioCtx->maxChunk)
copySz = ioCtx->maxChunk;
if (copySz <= 0)
return WOLFSSL_FATAL_ERROR;
XMEMCPY(buf, ioCtx->data + ioCtx->offset, (size_t)copySz);
ioCtx->offset += copySz;
return copySz;
}
static int ocsp_cb(void* ctx, const char* url, int urlSz, unsigned char* req,
int reqSz, unsigned char** respBuf)
{
@@ -100,6 +133,26 @@ int test_ocsp_response_parsing(void)
EXPECT_DECLS;
struct test_conf conf;
int expectedRet;
char urlName[80];
char urlPath[80];
word16 urlPort = 0;
byte reqBuf[256];
byte httpBuf[128];
byte* httpResp = NULL;
static const char* ocspAppStrList[] = {
"application/ocsp-response",
NULL
};
struct wolfio_http_test_ctx ioCtx;
static const char validHttpResp[] =
"HTTP/1.1 200 OK\r\n"
"Content-Type: application/ocsp-response\r\n"
"Content-Length: 3\r\n"
"\r\n"
"abc";
static const char headerEarlyEndResp[] =
"HTTP/1.1 200 OK\r\n"
"\r\n";
conf.resp = (unsigned char*)resp;
conf.respSz = sizeof(resp);
@@ -161,6 +214,81 @@ int test_ocsp_response_parsing(void)
conf.targetCertSz = sizeof(intermediate1_ca_cert_pem);
ExpectIntEQ(test_ocsp_response_with_cm(&conf, WOLFSSL_SUCCESS),
TEST_SUCCESS);
/* Truncated and empty responses should be rejected during decode. */
conf.resp = (unsigned char*)resp;
conf.respSz = sizeof(resp) - 1;
conf.ca0 = root_ca_cert_pem;
conf.ca0Sz = sizeof(root_ca_cert_pem);
conf.ca1 = NULL;
conf.ca1Sz = 0;
conf.targetCert = intermediate1_ca_cert_pem;
conf.targetCertSz = sizeof(intermediate1_ca_cert_pem);
ExpectIntEQ(test_ocsp_response_with_cm(&conf, OCSP_LOOKUP_FAIL),
TEST_SUCCESS);
conf.resp = (unsigned char*)resp;
conf.respSz = 0;
conf.ca0 = root_ca_cert_pem;
conf.ca0Sz = sizeof(root_ca_cert_pem);
conf.ca1 = NULL;
conf.ca1Sz = 0;
conf.targetCert = intermediate1_ca_cert_pem;
conf.targetCertSz = sizeof(intermediate1_ca_cert_pem);
ExpectIntEQ(test_ocsp_response_with_cm(&conf, OCSP_LOOKUP_FAIL),
TEST_SUCCESS);
/* wolfio helpers used by OCSP/CRL lookup should reject malformed inputs
* and accept a compact valid HTTP response. */
XMEMSET(urlName, 0, sizeof(urlName));
XMEMSET(urlPath, 0, sizeof(urlPath));
ExpectIntEQ(wolfIO_DecodeUrl(NULL, 0, urlName, urlPath, &urlPort), -1);
ExpectIntEQ(urlName[0], 0);
ExpectIntEQ(urlPath[0], 0);
ExpectIntEQ(urlPort, 0);
ExpectIntEQ(wolfIO_DecodeUrl("http://example.com:abc/", 23,
urlName, urlPath, &urlPort), WOLFSSL_FATAL_ERROR);
ExpectIntEQ(wolfIO_DecodeUrl("http://example.com/ocsp",
(int)XSTRLEN("http://example.com/ocsp"), urlName, urlPath, &urlPort),
0);
ExpectBufEQ(urlName, "example.com", (int)sizeof("example.com"));
ExpectBufEQ(urlPath, "/ocsp", (int)sizeof("/ocsp"));
ExpectIntEQ(urlPort, 80);
ExpectIntEQ(wolfIO_HttpBuildRequest("POST", "example.com", "/ocsp", 5, 3,
"application/ocsp-request", reqBuf, 8), 0);
ExpectIntGT(wolfIO_HttpBuildRequest("POST", "example.com", "/ocsp", 5, 3,
"application/ocsp-request", reqBuf, (int)sizeof(reqBuf)), 0);
XMEMSET(&ioCtx, 0, sizeof(ioCtx));
ioCtx.data = validHttpResp;
ioCtx.dataSz = (int)sizeof(validHttpResp) - 1;
ioCtx.maxChunk = 7;
ioCtx.finalRet = WOLFSSL_FATAL_ERROR;
ExpectIntEQ(wolfIO_HttpProcessResponseGenericIO(wolfio_http_test_io_cb,
&ioCtx, ocspAppStrList, &httpResp, httpBuf, (int)sizeof(httpBuf),
DYNAMIC_TYPE_OCSP, NULL), 3);
ExpectNotNull(httpResp);
if (httpResp != NULL) {
ExpectBufEQ(httpResp, "abc", 3);
XFREE(httpResp, NULL, DYNAMIC_TYPE_OCSP);
httpResp = NULL;
}
XMEMSET(&ioCtx, 0, sizeof(ioCtx));
ioCtx.finalRet = WC_NO_ERR_TRACE(WOLFSSL_CBIO_ERR_WANT_READ);
ExpectIntEQ(wolfIO_HttpProcessResponseGenericIO(wolfio_http_test_io_cb,
&ioCtx, ocspAppStrList, &httpResp, httpBuf, (int)sizeof(httpBuf),
DYNAMIC_TYPE_OCSP, NULL), OCSP_WANT_READ);
XMEMSET(&ioCtx, 0, sizeof(ioCtx));
ioCtx.data = headerEarlyEndResp;
ioCtx.dataSz = (int)sizeof(headerEarlyEndResp) - 1;
ioCtx.maxChunk = 9;
ioCtx.finalRet = WOLFSSL_FATAL_ERROR;
ExpectIntEQ(wolfIO_HttpProcessResponseGenericIO(wolfio_http_test_io_cb,
&ioCtx, ocspAppStrList, &httpResp, httpBuf, (int)sizeof(httpBuf),
DYNAMIC_TYPE_OCSP, NULL), HTTP_HEADER_ERR);
return EXPECT_SUCCESS();
}
#else /* HAVE_OCSP && !NO_SHA */
tests/api/test_ossl_x509.c
+32 -5
View File
@@ -1050,10 +1050,6 @@ int test_wolfSSL_X509_check_ip_asc(void)
WOLFSSL_FILETYPE_PEM));
ExpectNotNull(empty = wolfSSL_X509_new());
#if 0
/* TODO: add cert gen for testing positive case */
ExpectIntEQ(wolfSSL_X509_check_ip_asc(x509, "127.0.0.1", 0), 1);
#endif
ExpectIntEQ(wolfSSL_X509_check_ip_asc(x509, "0.0.0.0", 0), 0);
ExpectIntEQ(wolfSSL_X509_check_ip_asc(x509, NULL, 0), 0);
ExpectIntEQ(wolfSSL_X509_check_ip_asc(NULL, NULL, 0), 0);
@@ -1179,6 +1175,7 @@ int test_wolfSSL_X509_bad_altname(void)
int certSize = (int)sizeof(malformed_alt_name_cert) / sizeof(unsigned char);
const char *name = "aaaaa";
int nameLen = (int)XSTRLEN(name);
const char badName[] = { 'a', 'a', '\0', 'a', 'a', 'a' };
ExpectNotNull(x509 = wolfSSL_X509_load_certificate_buffer(
malformed_alt_name_cert, certSize, SSL_FILETYPE_ASN1));
@@ -1191,6 +1188,14 @@ int test_wolfSSL_X509_bad_altname(void)
ExpectIntNE(wolfSSL_X509_check_host(x509, name, nameLen,
WOLFSSL_ALWAYS_CHECK_SUBJECT | WOLFSSL_LEFT_MOST_WILDCARD_ONLY,
NULL), 1);
/* Len handling must not rescue a malformed SAN. */
ExpectIntNE(wolfSSL_X509_check_host(x509, name, 0,
WOLFSSL_ALWAYS_CHECK_SUBJECT, NULL), 1);
ExpectIntNE(wolfSSL_X509_check_host(x509, name, nameLen + 1,
WOLFSSL_ALWAYS_CHECK_SUBJECT, NULL), 1);
/* Embedded NUL in the compared host name must also be rejected. */
ExpectIntNE(wolfSSL_X509_check_host(x509, badName, 6,
WOLFSSL_ALWAYS_CHECK_SUBJECT, NULL), 1);
X509_free(x509);
@@ -1295,6 +1300,9 @@ int test_wolfSSL_X509_name_match1(void)
int nameLen3 = (int)(XSTRLEN(name3));
const char *name4 = "bbb";
int nameLen4 = (int)(XSTRLEN(name4));
const char *name5 = "aaaaa";
int nameLen5 = 6;
const char badName[] = { 'a', 'a', '\0', 'a', 'a', 'a' };
ExpectNotNull(x509 = wolfSSL_X509_load_certificate_buffer(
cert_der, certSize, WOLFSSL_FILETYPE_ASN1));
@@ -1311,6 +1319,14 @@ int test_wolfSSL_X509_name_match1(void)
/* Ensure that "a*" does not match "bbb" */
ExpectIntNE(wolfSSL_X509_check_host(x509, name4, nameLen4,
WOLFSSL_ALWAYS_CHECK_SUBJECT, NULL), 1);
/* OpenSSL-compatible len handling should still accept the positive case. */
ExpectIntEQ(wolfSSL_X509_check_host(x509, name5, 0,
WOLFSSL_ALWAYS_CHECK_SUBJECT, NULL), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_X509_check_host(x509, name5, nameLen5,
WOLFSSL_ALWAYS_CHECK_SUBJECT, NULL), WOLFSSL_SUCCESS);
/* Embedded NUL in the compared host name must be rejected. */
ExpectIntNE(wolfSSL_X509_check_host(x509, badName, 6,
WOLFSSL_ALWAYS_CHECK_SUBJECT, NULL), WOLFSSL_SUCCESS);
/* WOLFSSL_LEFT_MOST_WILDCARD_ONLY flag should fail on all cases, since
* 'a*' alt name does not have wildcard left-most */
@@ -1584,6 +1600,10 @@ int test_wolfSSL_X509_name_match3(void)
int nameLen2 = (int)(XSTRLEN(name2));
const char *name3 = "example.com";
int nameLen3 = (int)(XSTRLEN(name3));
const char *name4 = "foo.example.com";
int nameLen4 = (int)(XSTRLEN(name4)) + 1;
const char badName[] = { 'f', 'o', 'o', '.', 'e', 'x', '\0', 'a', 'm',
'p', 'l', 'e', '.', 'c', 'o', 'm' };
ExpectNotNull(x509 = wolfSSL_X509_load_certificate_buffer(
cert_der, certSize, WOLFSSL_FILETYPE_ASN1));
@@ -1591,12 +1611,20 @@ int test_wolfSSL_X509_name_match3(void)
/* Ensure that "*.example.com" matches "foo.example.com" */
ExpectIntEQ(wolfSSL_X509_check_host(x509, name1, nameLen1,
WOLFSSL_ALWAYS_CHECK_SUBJECT, NULL), WOLFSSL_SUCCESS);
/* strlen()-driven and NUL-inclusive lengths should both preserve match. */
ExpectIntEQ(wolfSSL_X509_check_host(x509, name1, 0,
WOLFSSL_ALWAYS_CHECK_SUBJECT, NULL), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_X509_check_host(x509, name4, nameLen4,
WOLFSSL_ALWAYS_CHECK_SUBJECT, NULL), WOLFSSL_SUCCESS);
/* Ensure that "*.example.com" does NOT match "x.y.example.com" */
ExpectIntNE(wolfSSL_X509_check_host(x509, name2, nameLen2,
WOLFSSL_ALWAYS_CHECK_SUBJECT, NULL), WOLFSSL_SUCCESS);
/* Ensure that "*.example.com" does NOT match "example.com" */
ExpectIntNE(wolfSSL_X509_check_host(x509, name3, nameLen3,
WOLFSSL_ALWAYS_CHECK_SUBJECT, NULL), WOLFSSL_SUCCESS);
/* Embedded NUL must remain rejected. */
ExpectIntNE(wolfSSL_X509_check_host(x509, badName, (int)sizeof(badName),
WOLFSSL_ALWAYS_CHECK_SUBJECT, NULL), WOLFSSL_SUCCESS);
/* WOLFSSL_LEFT_MOST_WILDCARD_ONLY, should match "foo.example.com" */
ExpectIntEQ(wolfSSL_X509_check_host(x509, name1, nameLen1,
@@ -2081,4 +2109,3 @@ int test_wolfSSL_X509_cmp(void)
#endif
return EXPECT_RESULT();
}
tests/api/test_ossl_x509_ext.c
+157 -25
View File
@@ -41,7 +41,7 @@
int test_wolfSSL_X509_get_extension_flags(void)
{
EXPECT_DECLS;
#if defined(OPENSSL_ALL) && !defined(NO_RSA)
#if (defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA)
XFILE f = XBADFILE;
X509* x509 = NULL;
unsigned int extFlags;
@@ -94,14 +94,15 @@ int test_wolfSSL_X509_get_extension_flags(void)
ExpectIntEQ(X509_get_extension_flags(x509), extFlags);
ExpectIntEQ(X509_get_key_usage(x509), keyUsageFlags);
X509_free(x509);
#endif /* OPENSSL_ALL */
#endif
return EXPECT_RESULT();
}
int test_wolfSSL_X509_get_ext(void)
{
EXPECT_DECLS;
#if !defined(NO_FILESYSTEM) && defined(OPENSSL_ALL) && !defined(NO_RSA)
#if !defined(NO_FILESYSTEM) && \
(defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA)
int ret = 0;
XFILE f = XBADFILE;
WOLFSSL_X509* x509 = NULL;
@@ -137,7 +138,7 @@ int test_wolfSSL_X509_get_ext(void)
int test_wolfSSL_X509_get_ext_by_NID(void)
{
EXPECT_DECLS;
#if defined(OPENSSL_ALL) && !defined(NO_RSA)
#if (defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA)
int rc = 0;
XFILE f = XBADFILE;
WOLFSSL_X509* x509 = NULL;
@@ -187,7 +188,7 @@ int test_wolfSSL_X509_get_ext_by_NID(void)
int test_wolfSSL_X509_get_ext_subj_alt_name(void)
{
EXPECT_DECLS;
#if defined(OPENSSL_ALL) && !defined(NO_RSA)
#if (defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA)
int rc = 0;
XFILE f = XBADFILE;
WOLFSSL_X509* x509 = NULL;
@@ -219,7 +220,7 @@ int test_wolfSSL_X509_get_ext_subj_alt_name(void)
int test_wolfSSL_X509_set_ext(void)
{
EXPECT_DECLS;
#if defined(OPENSSL_ALL) && !defined(NO_RSA)
#if (defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA)
WOLFSSL_X509* x509 = NULL;
XFILE f = XBADFILE;
int loc;
@@ -250,7 +251,7 @@ int test_wolfSSL_X509_set_ext(void)
return EXPECT_RESULT();
}
#if defined(OPENSSL_ALL)
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)
static int test_X509_add_basic_constraints(WOLFSSL_X509* x509)
{
EXPECT_DECLS;
@@ -524,7 +525,7 @@ static int test_x509_add_subj_key_id(WOLFSSL_X509* x509)
int test_wolfSSL_X509_add_ext(void)
{
EXPECT_DECLS;
#if defined(OPENSSL_ALL)
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)
WOLFSSL_X509* x509 = NULL;
WOLFSSL_X509_EXTENSION* ext_empty = NULL;
WOLFSSL_X509_EXTENSION* ext = NULL;
@@ -662,8 +663,8 @@ int test_wolfSSL_X509_add_ext_dirname_san_rejected(void)
int test_wolfSSL_X509_get_ext_count(void)
{
EXPECT_DECLS;
#if defined(OPENSSL_ALL) && !defined(NO_CERTS) && !defined(NO_FILESYSTEM) && \
!defined(NO_RSA)
#if (defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && \
!defined(NO_CERTS) && !defined(NO_FILESYSTEM) && !defined(NO_RSA)
int ret = 0;
WOLFSSL_X509* x509 = NULL;
const char ocspRootCaFile[] = "./certs/ocsp/root-ca-cert.pem";
@@ -752,7 +753,7 @@ int test_wolfSSL_X509_stack_extensions(void)
int test_wolfSSL_X509_EXTENSION_new(void)
{
EXPECT_DECLS;
#if defined (OPENSSL_ALL)
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)
WOLFSSL_X509_EXTENSION* ext = NULL;
ExpectNotNull(ext = wolfSSL_X509_EXTENSION_new());
@@ -767,7 +768,7 @@ int test_wolfSSL_X509_EXTENSION_new(void)
int test_wolfSSL_X509_EXTENSION_dup(void)
{
EXPECT_DECLS;
#if defined (OPENSSL_ALL)
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)
WOLFSSL_X509_EXTENSION* ext = NULL;
WOLFSSL_X509_EXTENSION* dup = NULL;
@@ -784,7 +785,8 @@ int test_wolfSSL_X509_EXTENSION_dup(void)
int test_wolfSSL_X509_EXTENSION_get_object(void)
{
EXPECT_DECLS;
#if !defined(NO_FILESYSTEM) && defined(OPENSSL_ALL) && !defined(NO_RSA)
#if !defined(NO_FILESYSTEM) && \
(defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA)
WOLFSSL_X509* x509 = NULL;
WOLFSSL_X509_EXTENSION* ext = NULL;
WOLFSSL_X509_EXTENSION* dup = NULL;
@@ -815,7 +817,8 @@ int test_wolfSSL_X509_EXTENSION_get_object(void)
int test_wolfSSL_X509_EXTENSION_get_data(void)
{
EXPECT_DECLS;
#if !defined(NO_FILESYSTEM) && defined(OPENSSL_ALL) && !defined(NO_RSA)
#if !defined(NO_FILESYSTEM) && \
(defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA)
WOLFSSL_X509* x509 = NULL;
WOLFSSL_X509_EXTENSION* ext = NULL;
WOLFSSL_ASN1_STRING* str = NULL;
@@ -850,7 +853,8 @@ int test_wolfSSL_X509_EXTENSION_get_data(void)
int test_wolfSSL_X509_EXTENSION_get_critical(void)
{
EXPECT_DECLS;
#if !defined(NO_FILESYSTEM) && defined(OPENSSL_ALL) && !defined(NO_RSA)
#if !defined(NO_FILESYSTEM) && \
(defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA)
WOLFSSL_X509* x509 = NULL;
WOLFSSL_X509_EXTENSION* ext = NULL;
XFILE file = XBADFILE;
@@ -874,13 +878,15 @@ int test_wolfSSL_X509_EXTENSION_get_critical(void)
int test_wolfSSL_X509_EXTENSION_create_by_OBJ(void)
{
EXPECT_DECLS;
#if !defined(NO_FILESYSTEM) && defined(OPENSSL_ALL) && !defined(NO_RSA)
#if !defined(NO_FILESYSTEM) && \
(defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA)
XFILE file = XBADFILE;
WOLFSSL_X509* x509 = NULL;
WOLFSSL_X509* empty = NULL;
WOLFSSL_X509_EXTENSION* ext = NULL;
WOLFSSL_X509_EXTENSION* ext2 = NULL;
WOLFSSL_X509_EXTENSION* ext3 = NULL;
WOLFSSL_X509_EXTENSION* found = NULL;
WOLFSSL_ASN1_OBJECT* o = NULL;
int crit = 0;
WOLFSSL_ASN1_STRING* str = NULL;
@@ -893,6 +899,11 @@ int test_wolfSSL_X509_EXTENSION_create_by_OBJ(void)
ExpectNotNull(o = wolfSSL_X509_EXTENSION_get_object(ext));
ExpectIntEQ(crit = wolfSSL_X509_EXTENSION_get_critical(ext), 0);
ExpectIntEQ(wolfSSL_X509_EXTENSION_set_critical(NULL, 1), WOLFSSL_FAILURE);
ExpectIntEQ(wolfSSL_X509_EXTENSION_set_critical(ext, 1), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_X509_EXTENSION_get_critical(ext), 1);
ExpectIntEQ(wolfSSL_X509_EXTENSION_set_critical(ext, 0), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_X509_EXTENSION_get_critical(ext), 0);
ExpectNotNull(str = wolfSSL_X509_EXTENSION_get_data(ext));
ExpectNull(wolfSSL_X509_EXTENSION_create_by_OBJ(NULL, NULL, 0, NULL));
@@ -929,6 +940,9 @@ int test_wolfSSL_X509_EXTENSION_create_by_OBJ(void)
ExpectIntEQ(wolfSSL_X509_get_ext_by_OBJ(x509, o, -2), 0);
ExpectIntEQ(wolfSSL_X509_get_ext_by_OBJ(x509, o, 0),
WC_NO_ERR_TRACE(WOLFSSL_FATAL_ERROR));
ExpectNotNull(found = wolfSSL_X509_get_ext(x509, 0));
ExpectNotNull(found->obj);
ExpectIntEQ(wolfSSL_X509_get_ext_by_OBJ(x509, found->obj, -1), 0);
wolfSSL_X509_free(x509);
#endif
@@ -984,7 +998,8 @@ int test_wolfSSL_X509V3_set_ctx(void)
int test_wolfSSL_X509V3_EXT_get(void)
{
EXPECT_DECLS;
#if !defined(NO_FILESYSTEM) && defined(OPENSSL_ALL) && !defined(NO_RSA)
#if !defined(NO_FILESYSTEM) && \
(defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA)
XFILE f = XBADFILE;
int numOfExt =0;
int extNid = 0;
@@ -1053,7 +1068,7 @@ int test_wolfSSL_X509V3_EXT_get(void)
int test_wolfSSL_X509V3_EXT_nconf(void)
{
EXPECT_DECLS;
#ifdef OPENSSL_ALL
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)
const char *ext_names[] = {
"subjectKeyIdentifier",
"authorityKeyIdentifier",
@@ -1164,7 +1179,8 @@ int test_wolfSSL_X509V3_EXT_nconf(void)
int test_wolfSSL_X509V3_EXT_bc(void)
{
EXPECT_DECLS;
#if !defined(NO_FILESYSTEM) && defined(OPENSSL_ALL) && !defined(NO_RSA)
#if !defined(NO_FILESYSTEM) && \
(defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA)
WOLFSSL_X509_EXTENSION* ext = NULL;
WOLFSSL_ASN1_OBJECT* obj = NULL;
WOLFSSL_BASIC_CONSTRAINTS* bc = NULL;
@@ -1298,7 +1314,8 @@ int test_wolfSSL_X509_get_ext_d2i_basic_constraints(void)
int test_wolfSSL_X509V3_EXT_san(void)
{
EXPECT_DECLS;
#if !defined(NO_FILESYSTEM) && defined(OPENSSL_ALL) && !defined(NO_RSA)
#if !defined(NO_FILESYSTEM) && \
(defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA)
WOLFSSL_X509_EXTENSION* ext = NULL;
WOLFSSL_ASN1_OBJECT* obj = NULL;
WOLFSSL_STACK* sk = NULL;
@@ -1333,7 +1350,8 @@ int test_wolfSSL_X509V3_EXT_san(void)
int test_wolfSSL_X509V3_EXT_aia(void)
{
EXPECT_DECLS;
#if !defined(NO_FILESYSTEM) && defined(OPENSSL_ALL) && !defined(NO_RSA)
#if !defined(NO_FILESYSTEM) && \
(defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && !defined(NO_RSA)
WOLFSSL_X509_EXTENSION* ext = NULL;
WOLFSSL_ASN1_OBJECT* obj = NULL;
WOLFSSL_STACK* sk = NULL;
@@ -1397,6 +1415,13 @@ int test_wolfSSL_X509V3_EXT_aia(void)
int test_wolfSSL_X509V3_EXT(void)
{
EXPECT_DECLS;
/* This test walks the OCSP root CA's extensions by hardcoded index (i=0 basic
* constraints, i=1 subject key id, i=2 authority key id, ...) and asserts fixed
* values. That ordering/index assumption only holds for OPENSSL_ALL builds; in
* OPENSSL_EXTRA-only configs the stored-extension order can differ, so the SKID
* i2s check reads the AKID instead and fails. Keep this test OPENSSL_ALL-only
* (its state on master); the by-NID AIA test above is the one that needed
* widening to OPENSSL_EXTRA. */
#if !defined(NO_FILESYSTEM) && defined(OPENSSL_ALL) && !defined(NO_RSA)
XFILE f = XBADFILE;
int numOfExt = 0, nid = 0, i = 0, expected, actual = 0;
@@ -1414,6 +1439,7 @@ int test_wolfSSL_X509V3_EXT(void)
WOLFSSL_BASIC_CONSTRAINTS* bc = NULL;
WOLFSSL_ACCESS_DESCRIPTION* ad = NULL;
WOLFSSL_GENERAL_NAME* gn = NULL;
int critical = -1;
/* Check NULL argument */
ExpectNull(wolfSSL_X509V3_EXT_d2i(NULL));
@@ -1459,6 +1485,16 @@ int test_wolfSSL_X509V3_EXT(void)
ExpectNotNull(obj = wolfSSL_X509_EXTENSION_get_object(ext));
ExpectIntEQ((nid = wolfSSL_OBJ_obj2nid(obj)), NID_basic_constraints);
ExpectNotNull(bc = (WOLFSSL_BASIC_CONSTRAINTS*)wolfSSL_X509V3_EXT_d2i(ext));
critical = -1;
ExpectNotNull(ext2 = (WOLFSSL_X509_EXTENSION*)X509_get_ext_d2i(x509, NID_basic_constraints,
&critical, NULL));
ExpectIntNE(critical, -1);
/* X509_get_ext_d2i() returns a newly-allocated object; free before reuse. */
wolfSSL_BASIC_CONSTRAINTS_free((WOLFSSL_BASIC_CONSTRAINTS*)ext2);
ext2 = NULL;
ExpectNotNull(ext2 = wolfSSL_X509V3_EXT_i2d(NID_basic_constraints, 1, bc));
X509_EXTENSION_free(ext2);
ext2 = NULL;
ExpectIntEQ(bc->ca, 1);
ExpectNull(bc->pathlen);
@@ -1472,6 +1508,15 @@ int test_wolfSSL_X509V3_EXT(void)
ExpectIntEQ((nid = wolfSSL_OBJ_obj2nid(obj)), NID_subject_key_identifier);
ExpectNotNull(asn1str = (WOLFSSL_ASN1_STRING*)wolfSSL_X509V3_EXT_d2i(ext));
critical = -1;
ExpectNotNull(ext2 = (WOLFSSL_X509_EXTENSION*)X509_get_ext_d2i(x509, NID_subject_key_identifier,
&critical, NULL));
ExpectIntNE(critical, -1);
/* get_ext_d2i(subject_key_identifier) wraps the value in a
* STACK_OF(ASN1_OBJECT) (see wolfSSL_X509_get_ext_d2i). */
wolfSSL_sk_ASN1_OBJECT_pop_free((WOLF_STACK_OF(WOLFSSL_ASN1_OBJECT)*)ext2,
NULL);
ext2 = NULL;
ExpectNotNull(ext2 = wolfSSL_X509V3_EXT_i2d(NID_subject_key_identifier, 0,
asn1str));
X509_EXTENSION_free(ext2);
@@ -1497,6 +1542,16 @@ int test_wolfSSL_X509V3_EXT(void)
ExpectNotNull(aKeyId = (WOLFSSL_AUTHORITY_KEYID*)wolfSSL_X509V3_EXT_d2i(
ext));
critical = -1;
ExpectNotNull(ext2 = (WOLFSSL_X509_EXTENSION*)X509_get_ext_d2i(x509, NID_authority_key_identifier,
&critical, NULL));
ExpectIntNE(critical, -1);
wolfSSL_AUTHORITY_KEYID_free((WOLFSSL_AUTHORITY_KEYID*)ext2);
ext2 = NULL;
ExpectNotNull(ext2 = wolfSSL_X509V3_EXT_i2d(NID_authority_key_identifier,
0, aKeyId));
X509_EXTENSION_free(ext2);
ext2 = NULL;
ExpectNotNull(method = wolfSSL_X509V3_EXT_get(ext));
ExpectNotNull(asn1str = aKeyId->keyid);
ExpectNotNull(str = wolfSSL_i2s_ASN1_STRING((WOLFSSL_v3_ext_method*)method,
@@ -1519,6 +1574,15 @@ int test_wolfSSL_X509V3_EXT(void)
ExpectIntEQ((nid = wolfSSL_OBJ_obj2nid(obj)), NID_key_usage);
ExpectNotNull(asn1str = (WOLFSSL_ASN1_STRING*)wolfSSL_X509V3_EXT_d2i(ext));
critical = -1;
ExpectNotNull(ext2 = (WOLFSSL_X509_EXTENSION*)X509_get_ext_d2i(x509, NID_key_usage, &critical,
NULL));
ExpectIntNE(critical, -1);
wolfSSL_ASN1_STRING_free((WOLFSSL_ASN1_STRING*)ext2);
ext2 = NULL;
ExpectNotNull(ext2 = wolfSSL_X509V3_EXT_i2d(NID_key_usage, 0, asn1str));
X509_EXTENSION_free(ext2);
ext2 = NULL;
#if defined(WOLFSSL_QT)
ExpectNotNull(data = (unsigned char*)ASN1_STRING_get0_data(asn1str));
#else
@@ -1545,6 +1609,13 @@ int test_wolfSSL_X509V3_EXT(void)
ExpectIntEQ((nid = wolfSSL_OBJ_obj2nid(obj)), NID_info_access);
ExpectNotNull(aia = (WOLFSSL_AUTHORITY_INFO_ACCESS*)wolfSSL_X509V3_EXT_d2i(
ext));
critical = -1;
ExpectNotNull(ext2 = (WOLFSSL_X509_EXTENSION*)X509_get_ext_d2i(x509, NID_info_access, &critical,
NULL));
ExpectIntNE(critical, -1);
wolfSSL_sk_ACCESS_DESCRIPTION_pop_free(
(WOLFSSL_AUTHORITY_INFO_ACCESS*)ext2, NULL);
ext2 = NULL;
#if defined(WOLFSSL_QT)
ExpectIntEQ(OPENSSL_sk_num(aia), 1); /* Only one URI entry for this cert */
#else
@@ -1580,7 +1651,11 @@ int test_wolfSSL_X509V3_EXT(void)
ExpectNull(wolfSSL_sk_ACCESS_DESCRIPTION_value(NULL, 0));
ExpectNull(wolfSSL_sk_ACCESS_DESCRIPTION_value(aia, 1));
ExpectNotNull(wolfSSL_sk_ACCESS_DESCRIPTION_value(aia, 0));
wolfSSL_sk_ACCESS_DESCRIPTION_pop_free(aia, NULL);
/* Pass the element free explicitly: the stack's default (type-based) element
* free for ACCESS_DESCRIPTION is only wired up under OPENSSL_ALL, so with a
* NULL callback an OPENSSL_EXTRA-only build (this block now compiles there)
* frees the stack nodes but leaks each ACCESS_DESCRIPTION. */
wolfSSL_sk_ACCESS_DESCRIPTION_pop_free(aia, wolfSSL_ACCESS_DESCRIPTION_free);
aia = NULL;
#ifndef NO_WOLFSSL_STUB
@@ -1595,8 +1670,9 @@ int test_wolfSSL_X509V3_EXT(void)
int test_wolfSSL_X509V3_EXT_print(void)
{
EXPECT_DECLS;
#if !defined(NO_FILESYSTEM) && defined(OPENSSL_ALL) && !defined(NO_BIO) && \
!defined(NO_RSA)
#if !defined(NO_FILESYSTEM) && \
(defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)) && \
!defined(NO_BIO) && !defined(NO_RSA)
{
XFILE f = XBADFILE;
@@ -2365,6 +2441,63 @@ int test_wolfSSL_NAME_CONSTRAINTS_check_name(void)
return EXPECT_RESULT();
}
int test_wolfSSL_NAME_CONSTRAINTS_manual_paths(void)
{
EXPECT_DECLS;
#if defined(OPENSSL_EXTRA) && !defined(IGNORE_NAME_CONSTRAINTS)
NAME_CONSTRAINTS* nc = NULL;
GENERAL_SUBTREE* subtree = NULL;
GENERAL_NAME* gn = NULL;
const char dnsName[] = ".wolfssl.com";
ExpectNotNull(nc = NAME_CONSTRAINTS_new());
if (EXPECT_SUCCESS()) {
ExpectNotNull(nc->permittedSubtrees = wolfSSL_sk_new_null());
}
if (EXPECT_SUCCESS()) {
nc->permittedSubtrees->type = STACK_TYPE_GENERAL_SUBTREE;
ExpectNotNull(subtree = GENERAL_SUBTREE_new());
}
if (EXPECT_SUCCESS()) {
ExpectIntEQ(wolfSSL_sk_push(nc->permittedSubtrees, subtree), 1);
subtree = NULL;
}
/* base == NULL should be skipped, leaving the name permitted. */
if (EXPECT_SUCCESS()) {
ExpectIntEQ(wolfSSL_NAME_CONSTRAINTS_check_name(nc, GEN_DNS,
"www.example.com", 15), 1);
}
if (EXPECT_SUCCESS()) {
ExpectNotNull(subtree = sk_GENERAL_SUBTREE_value(nc->permittedSubtrees,
0));
ExpectNotNull(gn = GENERAL_NAME_new());
}
if (EXPECT_SUCCESS()) {
subtree->base = gn;
gn = NULL;
subtree->base->type = GEN_EMAIL;
ExpectIntEQ(wolfSSL_NAME_CONSTRAINTS_check_name(nc, GEN_DNS,
"www.example.com", 15), 1);
}
/* Same-type permitted constraint with no match should now reject. */
if (EXPECT_SUCCESS()) {
subtree->base->type = GEN_DNS;
ExpectIntEQ(ASN1_STRING_set(subtree->base->d.dNSName, dnsName,
(int)XSTRLEN(dnsName)), WOLFSSL_SUCCESS);
ExpectIntEQ(wolfSSL_NAME_CONSTRAINTS_check_name(nc, GEN_DNS,
"www.example.com", 15), 0);
ExpectIntEQ(wolfSSL_NAME_CONSTRAINTS_check_name(nc, GEN_DNS,
"www.sub.wolfssl.com", 19), 1);
}
NAME_CONSTRAINTS_free(nc);
#endif /* OPENSSL_EXTRA && !IGNORE_NAME_CONSTRAINTS */
return EXPECT_RESULT();
}
/*
* Test DNS type name constraint checking with leading dot (subdomain matching).
* Uses cert-ext-nc-combined.pem which has permitted;DNS:.wolfssl.com
@@ -2506,4 +2639,3 @@ int test_wolfSSL_NAME_CONSTRAINTS_excluded(void)
* !IGNORE_NAME_CONSTRAINTS */
return EXPECT_RESULT();
}
tests/api/test_ossl_x509_ext.h
+2
View File
@@ -54,6 +54,7 @@ int test_wolfSSL_NAME_CONSTRAINTS_types(void);
int test_wolfSSL_NAME_CONSTRAINTS_uri(void);
int test_wolfSSL_NAME_CONSTRAINTS_ipaddr(void);
int test_wolfSSL_NAME_CONSTRAINTS_check_name(void);
int test_wolfSSL_NAME_CONSTRAINTS_manual_paths(void);
int test_wolfSSL_NAME_CONSTRAINTS_dns(void);
int test_wolfSSL_NAME_CONSTRAINTS_excluded(void);
@@ -93,6 +94,7 @@ int test_wolfSSL_NAME_CONSTRAINTS_excluded(void);
TEST_DECL_GROUP("ossl_x509_ext", test_wolfSSL_NAME_CONSTRAINTS_uri), \
TEST_DECL_GROUP("ossl_x509_ext", test_wolfSSL_NAME_CONSTRAINTS_ipaddr), \
TEST_DECL_GROUP("ossl_x509_ext", test_wolfSSL_NAME_CONSTRAINTS_check_name),\
TEST_DECL_GROUP("ossl_x509_ext", test_wolfSSL_NAME_CONSTRAINTS_manual_paths),\
TEST_DECL_GROUP("ossl_x509_ext", test_wolfSSL_NAME_CONSTRAINTS_dns), \
TEST_DECL_GROUP("ossl_x509_ext", test_wolfSSL_NAME_CONSTRAINTS_excluded)
tests/api/test_ossl_x509_vp.c
+47 -1
View File
@@ -38,10 +38,12 @@ int test_wolfSSL_X509_VERIFY_PARAM(void)
#if defined(OPENSSL_EXTRA)
X509_VERIFY_PARAM *paramTo = NULL;
X509_VERIFY_PARAM *paramFrom = NULL;
char longHost[WOLFSSL_HOST_NAME_MAX + 8];
char testIPv4[] = "127.0.0.1";
char testIPv6[] = "0001:0000:0000:0000:0000:0000:0000:0000/32";
char testhostName1[] = "foo.hoge.com";
char testhostName2[] = "foobar.hoge.com";
size_t i;
ExpectNotNull(paramTo = X509_VERIFY_PARAM_new());
ExpectNotNull(XMEMSET(paramTo, 0, sizeof(X509_VERIFY_PARAM)));
@@ -53,6 +55,23 @@ int test_wolfSSL_X509_VERIFY_PARAM(void)
(int)XSTRLEN(testhostName1)), 1);
ExpectIntEQ(0, XSTRNCMP(paramFrom->hostName, testhostName1,
(int)XSTRLEN(testhostName1)));
ExpectIntEQ(X509_VERIFY_PARAM_set1_host(paramFrom, testhostName1, 0), 1);
ExpectIntEQ(0, XSTRNCMP(paramFrom->hostName, testhostName1,
(int)XSTRLEN(testhostName1)));
ExpectIntEQ(X509_VERIFY_PARAM_set1_host(paramFrom, NULL, 0), 1);
ExpectIntEQ(paramFrom->hostName[0], '\0');
XMEMSET(longHost, 'a', sizeof(longHost));
longHost[sizeof(longHost) - 1] = '\0';
ExpectIntEQ(X509_VERIFY_PARAM_set1_host(paramFrom, longHost,
(int)sizeof(longHost)), 1);
for (i = 0; i < WOLFSSL_HOST_NAME_MAX - 1; i++) {
ExpectIntEQ(paramFrom->hostName[i], 'a');
}
ExpectIntEQ(paramFrom->hostName[WOLFSSL_HOST_NAME_MAX - 1], '\0');
ExpectIntEQ(X509_VERIFY_PARAM_set1_host(paramFrom, testhostName1,
(int)XSTRLEN(testhostName1)), 1);
X509_VERIFY_PARAM_set_hostflags(NULL, 0x00);
@@ -132,6 +151,34 @@ int test_wolfSSL_X509_VERIFY_PARAM(void)
ExpectIntEQ(0x00, paramTo->hostFlags);
ExpectIntEQ(0, XSTRNCMP(paramTo->ipasc, testIPv4, WOLFSSL_MAX_IPSTR));
/* inherit flags test : VPARAM_ONCE */
ExpectIntEQ(X509_VERIFY_PARAM_set1_host(paramTo, testhostName2,
(int)XSTRLEN(testhostName2)), 1);
ExpectIntEQ(X509_VERIFY_PARAM_set1_ip_asc(paramTo, testIPv4), 1);
paramTo->inherit_flags = X509_VP_FLAG_ONCE;
paramFrom->inherit_flags = 0;
ExpectIntEQ(X509_VERIFY_PARAM_inherit(paramTo, paramFrom), 1);
ExpectIntEQ(paramTo->inherit_flags, 0);
ExpectIntEQ(0, XSTRNCMP(paramTo->hostName, testhostName2,
(int)XSTRLEN(testhostName2)));
ExpectIntEQ(0, XSTRNCMP(paramTo->ipasc, testIPv4, WOLFSSL_MAX_IPSTR));
/* check_time should not be copied when already set unless overwrite */
XMEMSET(paramTo, 0, sizeof(X509_VERIFY_PARAM));
XMEMSET(paramFrom, 0, sizeof(X509_VERIFY_PARAM));
paramTo->check_time = 11;
paramTo->flags = WOLFSSL_USE_CHECK_TIME;
paramFrom->check_time = 22;
ExpectIntEQ(X509_VERIFY_PARAM_inherit(paramTo, paramFrom), 1);
ExpectIntEQ(paramTo->check_time, 11);
ExpectIntEQ(paramTo->flags & WOLFSSL_USE_CHECK_TIME,
WOLFSSL_USE_CHECK_TIME);
paramTo->inherit_flags = X509_VP_FLAG_OVERWRITE;
ExpectIntEQ(X509_VERIFY_PARAM_inherit(paramTo, paramFrom), 1);
ExpectIntEQ(paramTo->check_time, 22);
ExpectIntEQ(paramTo->flags & WOLFSSL_USE_CHECK_TIME, 0);
/* test for incorrect parameters */
ExpectIntEQ(X509_VERIFY_PARAM_set_flags(NULL, X509_V_FLAG_CRL_CHECK_ALL),
0);
@@ -273,4 +320,3 @@ int test_wolfSSL_X509_VERIFY_PARAM_set1_host(void)
#endif /* OPENSSL_EXTRA */
return EXPECT_RESULT();
}
tests/api/test_pkcs12.c
+66
View File
@@ -199,6 +199,72 @@ int test_wc_PKCS12_create(void)
return EXPECT_RESULT();
}
int test_wc_PKCS12_create_guardrails(void)
{
EXPECT_DECLS;
#if !defined(NO_ASN) && defined(HAVE_PKCS12) && !defined(NO_PWDBASED) && \
!defined(NO_RSA) && !defined(NO_ASN_CRYPT) && \
!defined(NO_HMAC) && !defined(NO_CERTS) && defined(USE_CERT_BUFFERS_2048)
byte* inKey = (byte*)server_key_der_2048;
const word32 inKeySz = sizeof_server_key_der_2048;
byte* inCert = (byte*)server_cert_der_2048;
const word32 inCertSz = sizeof_server_cert_der_2048;
WC_DerCertList inCa = {
(byte*)ca_cert_der_2048, sizeof_ca_cert_der_2048, NULL
};
char pkcs12Passwd[] = "test_wc_PKCS12_create_guardrails";
ExpectNull(wc_PKCS12_create(pkcs12Passwd, sizeof(pkcs12Passwd) - 1,
(char*)"friendlyName", inKey, inKeySz, inCert, inCertSz, &inCa, 9999,
-1, 0, 0, 0, NULL));
ExpectNull(wc_PKCS12_create(pkcs12Passwd, sizeof(pkcs12Passwd) - 1,
(char*)"friendlyName", inKey, inKeySz, inCert, inCertSz, &inCa, -1,
9999, 0, 0, 0, NULL));
#endif
return EXPECT_RESULT();
}
int test_wc_PKCS12_parse_guardrails(void)
{
EXPECT_DECLS;
#if !defined(NO_ASN) && !defined(NO_PWDBASED) && defined(HAVE_PKCS12)
WC_PKCS12* pkcs12 = NULL;
byte* outKey = NULL;
byte* outCert = NULL;
WC_DerCertList* outCa = (WC_DerCertList*)1;
word32 outKeySz = 0;
word32 outCertSz = 0;
ExpectIntEQ(wc_PKCS12_parse(NULL, "", &outKey, &outKeySz, &outCert,
&outCertSz, &outCa), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectNotNull(pkcs12 = wc_PKCS12_new());
ExpectIntEQ(wc_PKCS12_parse(pkcs12, NULL, &outKey, &outKeySz, &outCert,
&outCertSz, &outCa), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_PKCS12_parse(pkcs12, "", NULL, &outKeySz, &outCert,
&outCertSz, &outCa), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_PKCS12_parse(pkcs12, "", &outKey, NULL, &outCert,
&outCertSz, &outCa), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_PKCS12_parse(pkcs12, "", &outKey, &outKeySz, NULL,
&outCertSz, &outCa), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_PKCS12_parse(pkcs12, "", &outKey, &outKeySz, &outCert,
NULL, &outCa), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
outKey = (byte*)1;
outCert = (byte*)1;
outKeySz = 17;
outCertSz = 19;
ExpectIntEQ(wc_PKCS12_parse(pkcs12, "", &outKey, &outKeySz, &outCert,
&outCertSz, &outCa), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectNull(outKey);
ExpectNull(outCert);
ExpectNull(outCa);
wc_PKCS12_free(pkcs12);
#endif
return EXPECT_RESULT();
}
int test_wc_d2i_PKCS12_bad_mac_salt(void)
{
EXPECT_DECLS;
tests/api/test_pkcs12.h
+4
View File
@@ -26,6 +26,8 @@
int test_wc_i2d_PKCS12(void);
int test_wc_PKCS12_create(void);
int test_wc_PKCS12_create_guardrails(void);
int test_wc_PKCS12_parse_guardrails(void);
int test_wc_d2i_PKCS12_bad_mac_salt(void);
int test_wc_d2i_PKCS12_oid_underflow(void);
int test_wc_PKCS12_encrypted_content_bounds(void);
@@ -42,6 +44,8 @@ int test_wc_PKCS12_PBKDF_ex_sha512_256(void);
#define TEST_PKCS12_DECLS \
TEST_DECL_GROUP("pkcs12", test_wc_i2d_PKCS12), \
TEST_DECL_GROUP("pkcs12", test_wc_PKCS12_create), \
TEST_DECL_GROUP("pkcs12", test_wc_PKCS12_create_guardrails), \
TEST_DECL_GROUP("pkcs12", test_wc_PKCS12_parse_guardrails), \
TEST_DECL_GROUP("pkcs12", test_wc_d2i_PKCS12_bad_mac_salt), \
TEST_DECL_GROUP("pkcs12", test_wc_d2i_PKCS12_oid_underflow), \
TEST_DECL_GROUP("pkcs12", test_wc_PKCS12_encrypted_content_bounds), \
tests/api/test_pkcs7.c
+66
View File
@@ -268,6 +268,72 @@ int test_wc_PKCS7_InitWithCert(void)
return EXPECT_RESULT();
} /* END test_wc_PKCS7_InitWithCert */
int test_wc_PKCS7_InitWithCert_guardrails(void)
{
EXPECT_DECLS;
#if defined(HAVE_PKCS7)
PKCS7* pkcs7 = NULL;
static byte malformedCert[] = { 0x30, 0x03, 0x02, 0x01, 0x00 };
#ifndef NO_RSA
#if defined(USE_CERT_BUFFERS_2048)
byte cert[sizeof(client_cert_der_2048)];
word32 certSz = sizeof(cert);
XMEMSET(cert, 0, sizeof(cert));
XMEMCPY(cert, client_cert_der_2048, sizeof(client_cert_der_2048));
#elif defined(USE_CERT_BUFFERS_1024)
byte cert[sizeof_client_cert_der_1024];
word32 certSz = sizeof(cert);
XMEMSET(cert, 0, sizeof(cert));
XMEMCPY(cert, client_cert_der_1024, sizeof_client_cert_der_1024);
#else
byte cert[ONEK_BUF];
XFILE fp = XBADFILE;
int tmpCertSz;
word32 certSz = 0;
ExpectTrue((fp = XFOPEN("./certs/1024/client-cert.der", "rb")) !=
XBADFILE);
ExpectIntGT(tmpCertSz = (int)XFREAD(cert, 1,
sizeof_client_cert_der_1024, fp), 0);
certSz = (word32)tmpCertSz;
if (fp != XBADFILE)
XFCLOSE(fp);
#endif
#elif defined(HAVE_ECC)
#if defined(USE_CERT_BUFFERS_256)
byte cert[sizeof(cliecc_cert_der_256)];
word32 certSz = sizeof(cert);
XMEMSET(cert, 0, sizeof(cert));
XMEMCPY(cert, cliecc_cert_der_256, sizeof_cliecc_cert_der_256);
#else
byte cert[ONEK_BUF];
XFILE fp = XBADFILE;
int tmpCertSz;
word32 certSz = 0;
ExpectTrue((fp = XFOPEN("./certs/client-ecc-cert.der", "rb")) !=
XBADFILE);
ExpectIntGT(tmpCertSz = (int)XFREAD(cert, 1,
sizeof_cliecc_cert_der_256, fp), 0);
certSz = (word32)tmpCertSz;
if (fp != XBADFILE)
XFCLOSE(fp);
#endif
#endif
ExpectNotNull(pkcs7 = wc_PKCS7_New(HEAP_HINT, testDevId));
ExpectIntEQ(wc_PKCS7_InitWithCert(pkcs7, (byte*)cert, 0), 0);
ExpectIntLT(wc_PKCS7_InitWithCert(pkcs7, malformedCert,
(word32)sizeof(malformedCert)), 0);
ExpectIntEQ(wc_PKCS7_InitWithCert(pkcs7, (byte*)cert, certSz), 0);
wc_PKCS7_Free(pkcs7);
#endif
return EXPECT_RESULT();
}
/*
* Testing wc_PKCS7_EncodeData()
tests/api/test_pkcs7.h
+2
View File
@@ -27,6 +27,7 @@
int test_wc_PKCS7_New(void);
int test_wc_PKCS7_Init(void);
int test_wc_PKCS7_InitWithCert(void);
int test_wc_PKCS7_InitWithCert_guardrails(void);
int test_wc_PKCS7_EncodeData(void);
int test_wc_PKCS7_EncodeSignedData(void);
int test_wc_PKCS7_EncodeSignedData_AttribOverflow(void);
@@ -113,6 +114,7 @@ int test_wc_PKCS7_VerifySignedData_TruncCertSetTag(void);
#define TEST_PKCS7_SIGNED_DATA_DECLS \
TEST_DECL_GROUP("pkcs7_sd", test_wc_PKCS7_InitWithCert), \
TEST_DECL_GROUP("pkcs7_sd", test_wc_PKCS7_InitWithCert_guardrails), \
TEST_DECL_GROUP("pkcs7_sd", test_wc_PKCS7_EncodeData), \
TEST_DECL_GROUP("pkcs7_sd", test_wc_PKCS7_EncodeSignedData), \
TEST_DECL_GROUP("pkcs7_sd", test_wc_PKCS7_EncodeSignedData_AttribOverflow), \
tests/api/test_rsa.c
+386
View File
@@ -30,6 +30,12 @@
#include <wolfssl/wolfcrypt/rsa.h>
#include <wolfssl/wolfcrypt/types.h>
#ifndef NO_SHA256
#include <wolfssl/wolfcrypt/sha256.h>
#endif
#ifdef WOLFSSL_SHA384
#include <wolfssl/wolfcrypt/sha512.h>
#endif
#include <tests/api/api.h>
#include <tests/api/test_rsa.h>
@@ -1400,3 +1406,383 @@ int test_wc_RsaKeyToDer_SizeOverflow(void)
return EXPECT_RESULT();
} /* END test_wc_RsaKeyToDer_SizeOverflow */
/*
* MC/DC wave 2 - decision-targeted negative paths for the high-level RSA
* encrypt/decrypt/sign surfaces. The existing tests above deliberately leave
* bad-arg coverage "tested in another testing function" for
* wc_RsaPublicEncrypt{,_ex}, wc_RsaPrivateDecrypt{,Inline}{,_ex}, and
* wc_RsaSetRNG. This function closes that gap by hitting the argument-check,
* short-buffer, and invalid-mode branches in wolfcrypt/src/rsa.c without
* changing any library source.
*/
int test_wc_RsaDecisionCoverage(void)
{
EXPECT_DECLS;
/* This function asserts wolfcrypt/src/rsa.c *internal* decision outcomes
* (short-buffer RSA_BUFFER_E, invalid pad-type, OAEP-vs-PKCSv15 padding
* mismatch) whose whole value is MC/DC of the open wolfCrypt rsa.c. Under the
* frozen self-test module that rsa.c is not the code being exercised, so these
* error-code decisions are not part of its contract and can legitimately
* differ. The sibling key-gen/decision tests in this file (e.g.
* test_wc_CheckProbablePrime, the RsaKeyGeneration group) exclude HAVE_SELFTEST
* for the same reason; do so here too. HAVE_FIPS is intentionally left running:
* that (newer) module honours these decisions and the campaign gains coverage
* from it. */
#if !defined(NO_RSA) && defined(WOLFSSL_KEY_GEN) && \
!defined(WOLFSSL_RSA_PUBLIC_ONLY) && !defined(HAVE_SELFTEST)
RsaKey key;
WC_RNG rng;
const char inStr[] = TEST_STRING;
const word32 inLen = (word32)TEST_STRING_SZ;
int bits = TEST_RSA_BITS;
const word32 cipherLen = TEST_RSA_BYTES;
int cipherOutLen = 0;
WC_DECLARE_VAR(in, byte, TEST_STRING_SZ, NULL);
WC_DECLARE_VAR(cipher, byte, TEST_RSA_BYTES, NULL);
WC_DECLARE_VAR(plain, byte, TEST_RSA_BYTES, NULL);
WC_ALLOC_VAR(in, byte, TEST_STRING_SZ, NULL);
WC_ALLOC_VAR(cipher, byte, TEST_RSA_BYTES, NULL);
WC_ALLOC_VAR(plain, byte, TEST_RSA_BYTES, NULL);
#ifdef WC_DECLARE_VAR_IS_HEAP_ALLOC
ExpectNotNull(in);
ExpectNotNull(cipher);
ExpectNotNull(plain);
#endif
ExpectNotNull(XMEMCPY(in, inStr, inLen));
XMEMSET(&key, 0, sizeof(RsaKey));
XMEMSET(&rng, 0, sizeof(WC_RNG));
ExpectIntEQ(wc_InitRsaKey(&key, HEAP_HINT), 0);
ExpectIntEQ(wc_InitRng(&rng), 0);
ExpectIntEQ(MAKE_RSA_KEY(&key, bits, WC_RSA_EXPONENT, &rng), 0);
/* ---- wc_RsaPublicEncrypt: argument-check decision branches ---- */
ExpectIntEQ(wc_RsaPublicEncrypt(NULL, inLen, cipher, cipherLen, &key, &rng),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RsaPublicEncrypt(in, inLen, NULL, cipherLen, &key, &rng),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RsaPublicEncrypt(in, inLen, cipher, cipherLen, NULL, &rng),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Short output buffer: cipher buffer smaller than modulus byte length
* must return RSA_BUFFER_E (short-buffer decision branch). */
ExpectIntEQ(wc_RsaPublicEncrypt(in, inLen, cipher, cipherLen - 1, &key,
&rng), WC_NO_ERR_TRACE(RSA_BUFFER_E));
/* One real encrypt so the decrypt-side negative cases have a valid
* cipher text to work with. */
ExpectIntGT(cipherOutLen = wc_RsaPublicEncrypt(in, inLen, cipher, cipherLen,
&key, &rng), 0);
/* ---- wc_RsaPrivateDecrypt: argument-check + short-buffer branches ---- */
#if defined(WC_RSA_BLINDING) && !defined(HAVE_FIPS)
ExpectIntEQ(wc_RsaSetRNG(&key, &rng), 0);
/* wc_RsaSetRNG NULL arg decision branches. */
ExpectIntEQ(wc_RsaSetRNG(NULL, &rng), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RsaSetRNG(&key, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
#endif
ExpectIntEQ(wc_RsaPrivateDecrypt(NULL, (word32)cipherOutLen, plain,
cipherLen, &key), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RsaPrivateDecrypt(cipher, (word32)cipherOutLen, NULL,
cipherLen, &key), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RsaPrivateDecrypt(cipher, (word32)cipherOutLen, plain,
cipherLen, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* ---- wc_RsaPrivateDecryptInline: argument-check decision branches ---- */
{
byte* outPtr = NULL;
ExpectIntEQ(wc_RsaPrivateDecryptInline(NULL, (word32)cipherOutLen,
&outPtr, &key), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
{
int ret = wc_RsaPrivateDecryptInline(cipher, (word32)cipherOutLen,
NULL, &key);
ExpectTrue(ret == WC_NO_ERR_TRACE(BAD_FUNC_ARG) || ret > 0);
}
ExpectIntEQ(wc_RsaPrivateDecryptInline(cipher, (word32)cipherOutLen,
&outPtr, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
}
#if !defined(HAVE_FIPS) && !defined(WC_NO_RSA_OAEP) && !defined(NO_SHA256)
/* ---- wc_RsaPublicEncrypt_ex: argument-check + invalid-mode branches --- */
ExpectIntEQ(wc_RsaPublicEncrypt_ex(NULL, inLen, cipher, cipherLen, &key,
&rng, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256, WC_MGF1SHA256, NULL, 0),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RsaPublicEncrypt_ex(in, inLen, NULL, cipherLen, &key, &rng,
WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256, WC_MGF1SHA256, NULL, 0),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RsaPublicEncrypt_ex(in, inLen, cipher, cipherLen, NULL, &rng,
WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256, WC_MGF1SHA256, NULL, 0),
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Invalid padding type selector: should not dispatch to any valid path. */
ExpectIntLT(wc_RsaPublicEncrypt_ex(in, inLen, cipher, cipherLen, &key,
&rng, /* bogus pad type */ 99, WC_HASH_TYPE_SHA256, WC_MGF1SHA256,
NULL, 0), 0);
/* Produce a valid OAEP-SHA256 cipher text for the decrypt negative path. */
cipherOutLen = wc_RsaPublicEncrypt_ex(in, inLen, cipher, cipherLen, &key,
&rng, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256, WC_MGF1SHA256, NULL, 0);
ExpectIntGT(cipherOutLen, 0);
/* ---- wc_RsaPrivateDecrypt_ex: argument-check + padding-mismatch ---- */
ExpectIntEQ(wc_RsaPrivateDecrypt_ex(NULL, (word32)cipherOutLen, plain,
cipherLen, &key, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256, WC_MGF1SHA256,
NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RsaPrivateDecrypt_ex(cipher, (word32)cipherOutLen, NULL,
cipherLen, &key, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256, WC_MGF1SHA256,
NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
ExpectIntEQ(wc_RsaPrivateDecrypt_ex(cipher, (word32)cipherOutLen, plain,
cipherLen, NULL, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256, WC_MGF1SHA256,
NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
/* Cipher text is OAEP-SHA256 with no label. Decrypting it as OAEP with a
* non-empty label makes the recovered lHash mismatch, so OAEP's integrity
* check fails *deterministically* and exercises the padding-mismatch
* decision branch in rsa.c. (Decoding it as PKCS#1 v1.5 was flaky: v1.5
* unpadding of the random OAEP plaintext spuriously "succeeds" a few
* percent of the time when byte[1] lands on 0x02 with a valid separator.) */
{
byte wrongLabel[5] = { 'w', 'r', 'o', 'n', 'g' };
ExpectIntLT(wc_RsaPrivateDecrypt_ex(cipher, (word32)cipherOutLen, plain,
cipherLen, &key, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256,
WC_MGF1SHA256, wrongLabel, sizeof(wrongLabel)), 0);
}
/* ---- wc_RsaPrivateDecryptInline_ex argument-check branches ---- */
{
byte* outPtr = NULL;
ExpectIntEQ(wc_RsaPrivateDecryptInline_ex(NULL, (word32)cipherOutLen,
&outPtr, &key, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256, WC_MGF1SHA256,
NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
{
int ret = wc_RsaPrivateDecryptInline_ex(cipher,
(word32)cipherOutLen, NULL, &key, WC_RSA_OAEP_PAD,
WC_HASH_TYPE_SHA256, WC_MGF1SHA256, NULL, 0);
ExpectTrue(ret == WC_NO_ERR_TRACE(BAD_FUNC_ARG) || ret > 0);
}
ExpectIntEQ(wc_RsaPrivateDecryptInline_ex(cipher, (word32)cipherOutLen,
&outPtr, NULL, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256, WC_MGF1SHA256,
NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
}
#endif /* !HAVE_FIPS && !WC_NO_RSA_OAEP && !NO_SHA256 */
WC_FREE_VAR(in, NULL);
WC_FREE_VAR(cipher, NULL);
WC_FREE_VAR(plain, NULL);
DoExpectIntEQ(wc_FreeRsaKey(&key), 0);
DoExpectIntEQ(wc_FreeRng(&rng), 0);
#endif
return EXPECT_RESULT();
} /* END test_wc_RsaDecisionCoverage */
/*
* MC/DC wave 2 - feature-oriented positive paths to lift rsa.c MC/DC by
* exercising OAEP, PSS, and PKCS#1 v1.5 sign/verify across multiple hash
* algorithms and label/salt configurations using the static client key DER
* (no runtime key generation).
*/
int test_wc_RsaFeatureCoverage(void)
{
EXPECT_DECLS;
#if !defined(NO_RSA) && !defined(WOLFSSL_RSA_PUBLIC_ONLY) && \
defined(USE_CERT_BUFFERS_2048) && !defined(HAVE_FIPS)
RsaKey key;
WC_RNG rng;
word32 idx = 0;
byte cipher[256];
byte plain[256];
byte sig[256];
int cipherLen;
int sigLen;
int initKey = 0;
int initRng = 0;
static const byte msg[16] = {
0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f
};
static const byte label[4] = { 0xde, 0xad, 0xbe, 0xef };
XMEMSET(&key, 0, sizeof(key));
XMEMSET(&rng, 0, sizeof(rng));
ExpectIntEQ(wc_InitRsaKey(&key, HEAP_HINT), 0);
if (EXPECT_SUCCESS()) initKey = 1;
ExpectIntEQ(wc_InitRng(&rng), 0);
if (EXPECT_SUCCESS()) initRng = 1;
ExpectIntEQ(wc_RsaPrivateKeyDecode(client_key_der_2048, &idx, &key,
sizeof_client_key_der_2048), 0);
#ifdef WC_RSA_BLINDING
ExpectIntEQ(wc_RsaSetRNG(&key, &rng), 0);
#endif
#if !defined(WC_NO_RSA_OAEP) && !defined(NO_SHA256)
/* ---- OAEP-SHA256 round trip with empty label ---- */
cipherLen = wc_RsaPublicEncrypt_ex(msg, sizeof(msg), cipher,
sizeof(cipher), &key, &rng, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256,
WC_MGF1SHA256, NULL, 0);
ExpectIntGT(cipherLen, 0);
if (cipherLen > 0) {
int n = wc_RsaPrivateDecrypt_ex(cipher, (word32)cipherLen, plain,
sizeof(plain), &key, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256,
WC_MGF1SHA256, NULL, 0);
ExpectIntEQ(n, (int)sizeof(msg));
if (n == (int)sizeof(msg))
ExpectBufEQ(plain, msg, sizeof(msg));
}
/* ---- OAEP-SHA256 round trip with non-empty label ---- */
cipherLen = wc_RsaPublicEncrypt_ex(msg, sizeof(msg), cipher,
sizeof(cipher), &key, &rng, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256,
WC_MGF1SHA256, (byte*)label, sizeof(label));
ExpectIntGT(cipherLen, 0);
if (cipherLen > 0) {
int n = wc_RsaPrivateDecrypt_ex(cipher, (word32)cipherLen, plain,
sizeof(plain), &key, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256,
WC_MGF1SHA256, (byte*)label, sizeof(label));
ExpectIntEQ(n, (int)sizeof(msg));
/* Wrong label must reject. */
n = wc_RsaPrivateDecrypt_ex(cipher, (word32)cipherLen, plain,
sizeof(plain), &key, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA256,
WC_MGF1SHA256, NULL, 0);
ExpectIntLT(n, 0);
}
#endif /* !WC_NO_RSA_OAEP && !NO_SHA256 */
#if !defined(WC_NO_RSA_OAEP) && defined(WOLFSSL_SHA384)
/* ---- OAEP-SHA384 round trip ---- */
cipherLen = wc_RsaPublicEncrypt_ex(msg, sizeof(msg), cipher,
sizeof(cipher), &key, &rng, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA384,
WC_MGF1SHA384, NULL, 0);
ExpectIntGT(cipherLen, 0);
if (cipherLen > 0) {
int n = wc_RsaPrivateDecrypt_ex(cipher, (word32)cipherLen, plain,
sizeof(plain), &key, WC_RSA_OAEP_PAD, WC_HASH_TYPE_SHA384,
WC_MGF1SHA384, NULL, 0);
ExpectIntEQ(n, (int)sizeof(msg));
}
#endif /* !WC_NO_RSA_OAEP && WOLFSSL_SHA384 */
/* ---- PKCS#1 v1.5 raw encrypt/decrypt round trip ---- */
cipherLen = wc_RsaPublicEncrypt(msg, sizeof(msg), cipher, sizeof(cipher),
&key, &rng);
ExpectIntGT(cipherLen, 0);
if (cipherLen > 0) {
int n = wc_RsaPrivateDecrypt(cipher, (word32)cipherLen, plain,
sizeof(plain), &key);
ExpectIntEQ(n, (int)sizeof(msg));
if (n == (int)sizeof(msg))
ExpectBufEQ(plain, msg, sizeof(msg));
}
/* ---- PKCS#1 v1.5 sign / verify ---- */
sigLen = wc_RsaSSL_Sign(msg, sizeof(msg), sig, sizeof(sig), &key, &rng);
ExpectIntGT(sigLen, 0);
if (sigLen > 0) {
int n = wc_RsaSSL_Verify(sig, (word32)sigLen, plain, sizeof(plain),
&key);
ExpectIntEQ(n, (int)sizeof(msg));
if (n == (int)sizeof(msg))
ExpectBufEQ(plain, msg, sizeof(msg));
}
/* Tampered signature must be rejected. */
if (sigLen > 0) {
sig[0] ^= 0x01;
ExpectIntLT(wc_RsaSSL_Verify(sig, (word32)sigLen, plain, sizeof(plain),
&key), 0);
sig[0] ^= 0x01;
}
#if defined(WC_RSA_PSS) && !defined(NO_SHA256)
/* ---- PSS-SHA256 sign / verify with default salt length ----
* PSS expects a hash-sized input, not arbitrary plaintext. */
{
byte hash256[WC_SHA256_DIGEST_SIZE];
ExpectIntEQ(wc_Sha256Hash(msg, sizeof(msg), hash256), 0);
sigLen = wc_RsaPSS_Sign(hash256, sizeof(hash256), sig, sizeof(sig),
WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key, &rng);
ExpectIntGT(sigLen, 0);
if (sigLen > 0) {
ExpectIntGT(wc_RsaPSS_Verify(sig, (word32)sigLen, plain,
sizeof(plain), WC_HASH_TYPE_SHA256, WC_MGF1SHA256, &key), 0);
}
/* ---- PSS-SHA256 sign / verify with explicit salt length ---- */
sigLen = wc_RsaPSS_Sign_ex(hash256, sizeof(hash256), sig, sizeof(sig),
WC_HASH_TYPE_SHA256, WC_MGF1SHA256, /* saltLen */ 16, &key, &rng);
ExpectIntGT(sigLen, 0);
if (sigLen > 0) {
ExpectIntGT(wc_RsaPSS_Verify_ex(sig, (word32)sigLen, plain,
sizeof(plain), WC_HASH_TYPE_SHA256, WC_MGF1SHA256, 16, &key),
0);
}
}
#endif /* WC_RSA_PSS && !NO_SHA256 */
#if defined(WC_RSA_PSS) && defined(WOLFSSL_SHA384)
/* ---- PSS-SHA384 sign / verify ---- */
{
byte hash384[WC_SHA384_DIGEST_SIZE];
ExpectIntEQ(wc_Sha384Hash(msg, sizeof(msg), hash384), 0);
sigLen = wc_RsaPSS_Sign(hash384, sizeof(hash384), sig, sizeof(sig),
WC_HASH_TYPE_SHA384, WC_MGF1SHA384, &key, &rng);
ExpectIntGT(sigLen, 0);
if (sigLen > 0) {
ExpectIntGT(wc_RsaPSS_Verify(sig, (word32)sigLen, plain,
sizeof(plain), WC_HASH_TYPE_SHA384, WC_MGF1SHA384, &key), 0);
}
}
#endif /* WC_RSA_PSS && WOLFSSL_SHA384 */
/* ---- wc_CheckRsaKey: exercise consistency checks on a good key ---- */
#ifdef WOLFSSL_RSA_KEY_CHECK
ExpectIntEQ(wc_CheckRsaKey(&key), 0);
#endif
/* ---- wc_InitRsaKey_Id / wc_InitRsaKey_Label: positive path ---- */
#ifdef WOLF_PRIVATE_KEY_ID
{
RsaKey tmpKey;
static const byte idBuf[4] = { 0x01, 0x02, 0x03, 0x04 };
XMEMSET(&tmpKey, 0, sizeof(tmpKey));
ExpectIntEQ(wc_InitRsaKey_Id(&tmpKey, (byte*)idBuf, sizeof(idBuf),
HEAP_HINT, INVALID_DEVID), 0);
DoExpectIntEQ(wc_FreeRsaKey(&tmpKey), 0);
}
{
RsaKey tmpKey;
XMEMSET(&tmpKey, 0, sizeof(tmpKey));
ExpectIntEQ(wc_InitRsaKey_Label(&tmpKey, "test-label", HEAP_HINT,
INVALID_DEVID), 0);
DoExpectIntEQ(wc_FreeRsaKey(&tmpKey), 0);
}
#endif /* WOLF_PRIVATE_KEY_ID */
/* ---- wc_RsaKeyToPublicDer_ex: with and without algorithm header ---- */
#ifdef WOLFSSL_KEY_GEN
{
byte pubDer[512];
ExpectIntGT(wc_RsaKeyToPublicDer_ex(&key, pubDer, sizeof(pubDer), 1),
0);
ExpectIntGT(wc_RsaKeyToPublicDer_ex(&key, pubDer, sizeof(pubDer), 0),
0);
}
#endif
/* ---- wc_RsaEncryptSize / wc_RsaFlattenPublicKey positive path ---- */
ExpectIntGT(wc_RsaEncryptSize(&key), 0);
{
byte n[256];
byte e[8];
word32 nSz = sizeof(n);
word32 eSz = sizeof(e);
ExpectIntEQ(wc_RsaFlattenPublicKey(&key, e, &eSz, n, &nSz), 0);
ExpectIntGT(nSz, 0);
ExpectIntGT(eSz, 0);
}
if (initKey) DoExpectIntEQ(wc_FreeRsaKey(&key), 0);
if (initRng) DoExpectIntEQ(wc_FreeRng(&rng), 0);
#endif
return EXPECT_RESULT();
} /* END test_wc_RsaFeatureCoverage */
tests/api/test_rsa.h
+5 -1
View File
@@ -45,6 +45,8 @@ int test_wc_RsaFlattenPublicKey(void);
int test_wc_RsaDecrypt_BoundsCheck(void);
int test_wc_RsaFunctionCheckIn_OversizedModulus(void);
int test_wc_RsaKeyToDer_SizeOverflow(void);
int test_wc_RsaDecisionCoverage(void);
int test_wc_RsaFeatureCoverage(void);
#define TEST_RSA_DECLS \
TEST_DECL_GROUP("rsa", test_wc_InitRsaKey), \
@@ -67,6 +69,8 @@ int test_wc_RsaKeyToDer_SizeOverflow(void);
TEST_DECL_GROUP("rsa", test_wc_RsaFlattenPublicKey), \
TEST_DECL_GROUP("rsa", test_wc_RsaDecrypt_BoundsCheck), \
TEST_DECL_GROUP("rsa", test_wc_RsaFunctionCheckIn_OversizedModulus), \
TEST_DECL_GROUP("rsa", test_wc_RsaKeyToDer_SizeOverflow)
TEST_DECL_GROUP("rsa", test_wc_RsaKeyToDer_SizeOverflow), \
TEST_DECL_GROUP("rsa", test_wc_RsaDecisionCoverage), \
TEST_DECL_GROUP("rsa", test_wc_RsaFeatureCoverage)
#endif /* WOLFCRYPT_TEST_RSA_H */
tests/api/test_signature.c
+47
View File
@@ -31,7 +31,11 @@
#include <wolfssl/wolfcrypt/signature.h>
#include <wolfssl/wolfcrypt/rsa.h>
#include <wolfssl/wolfcrypt/ecc.h>
#include <wolfssl/wolfcrypt/random.h>
#include <wolfssl/wolfcrypt/types.h>
#ifdef HAVE_FALCON
#include <wolfssl/wolfcrypt/falcon.h>
#endif
#include <tests/api/api.h>
#include <tests/api/test_signature.h>
@@ -161,3 +165,46 @@ int test_wc_SignatureGetSize_rsa(void)
return EXPECT_RESULT();
} /* END test_wc_SignatureGetSize_rsa(void) */
int test_wc_falcon_sign_verify(void)
{
EXPECT_DECLS;
#if defined(HAVE_FALCON) && defined(HAVE_LIBOQS)
falcon_key key;
WC_RNG rng;
byte sig[FALCON_LEVEL1_SIG_SIZE];
word32 sigLen = (word32)sizeof(sig);
word32 idx = 0;
int verified = 0;
static const byte msg[] = "wolfssl falcon coverage";
XMEMSET(&key, 0, sizeof(key));
ExpectIntEQ(wc_falcon_init(&key), 0);
ExpectIntEQ(wc_falcon_set_level(&key, 1), 0);
ExpectIntEQ(wc_InitRng(&rng), 0);
/* Use the embedded benchmark key rather than generating one with a
* direct OQS_SIG_keypair() call: that call draws from liboqs'
* randombytes callback, which wolfSSL points at its default liboqs RNG.
* Any earlier wolfCrypt_Init/Cleanup cycle in this suite leaves that RNG
* freed (wolfSSL_liboqsClose() does not reset liboqs_init, so re-Init
* never re-creates it) and the callback then abort()s. The wolfSSL API
* paths below hand OUR rng to liboqs instead, so they do not depend on
* that state. */
ExpectIntEQ(wc_Falcon_PrivateKeyDecode(bench_falcon_level1_key, &idx,
&key, (word32)sizeof_bench_falcon_level1_key), 0);
ExpectIntGT(wc_falcon_size(&key), 0);
ExpectIntGT(wc_falcon_pub_size(&key), 0);
ExpectIntGT(wc_falcon_priv_size(&key), 0);
ExpectIntGT(wc_falcon_sig_size(&key), 0);
ExpectIntEQ(wc_falcon_sign_msg(msg, (word32)sizeof(msg), sig, &sigLen,
&key, &rng), 0);
ExpectIntEQ(wc_falcon_verify_msg(sig, sigLen, msg, (word32)sizeof(msg),
&verified, &key), 0);
ExpectIntEQ(verified, 1);
DoExpectIntEQ(wc_FreeRng(&rng), 0);
wc_falcon_free(&key);
#endif
return EXPECT_RESULT();
}
tests/api/test_signature.h
+3 -1
View File
@@ -26,9 +26,11 @@
int test_wc_SignatureGetSize_ecc(void);
int test_wc_SignatureGetSize_rsa(void);
int test_wc_falcon_sign_verify(void);
#define TEST_SIGNATURE_DECLS \
TEST_DECL_GROUP("signature", test_wc_SignatureGetSize_ecc), \
TEST_DECL_GROUP("signature", test_wc_SignatureGetSize_rsa)
TEST_DECL_GROUP("signature", test_wc_SignatureGetSize_rsa), \
TEST_DECL_GROUP("signature", test_wc_falcon_sign_verify)
#endif /* WOLFCRYPT_TEST_SIGNATURE_H */
tests/unit-mcdc/README.md
+75
View File
@@ -0,0 +1,75 @@
# tests/unit-mcdc - white-box MC/DC supplements
This directory holds small, standalone white-box programs that raise **MC/DC**
(Modified Condition/Decision Coverage) on wolfcrypt/wolfssl source files by
reaching decisions that are **structurally unreachable from the public API**.
These are **not** part of the wolfSSL build and are **not** registered in
`tests/api`. They exist for the external ISO 26262 per-module coverage campaign
in `iso26262/mcdc-per-module/`. Nothing here changes library behaviour.
## Why a separate module
The `tests/api` suite drives each source file through its *public* API. A handful
of decision conditions live in `WOLFSSL_LOCAL` (link-local) or file-`static`
helpers whose "impossible" operand combinations every public caller rejects
*before* the helper runs (e.g. a `size != 0` argument paired with a `NULL`
pointer, which every `wc_*` entry point turns into `BAD_FUNC_ARG`). Such a
condition's MC/DC independence pair can never be demonstrated from the API
without editing library source.
A white-box program compiles the `.c` file in directly (`#include`), so the
static/local helpers are in scope, and calls them with **both halves of each
MC/DC independence pair** in the same binary.
## How coverage is combined
llvm-cov computes MC/DC independence **per binary**. The campaign's
`aggregate.sh` unions the "independence shown" bit **across binaries by source
`line:col`**. So each pair must be completed *within the white-box binary
itself* - it does not lean on the API tests to supply the other half. The
white-box result is unioned in as an extra `"<variant>_wb"` ledger row, one per
build variant, exactly like any other variant.
## Build contract (driven by `run-mcdc.sh`)
The campaign's `run-mcdc.sh` builds each file via `#include` with the **exact**
compile flags the instrumented library used for that translation unit (captured
from the real `libtool` command - struct layout and backend selection depend on
`-DHAVE___UINT128_T`, `user_settings.h`, `-DWOLFSSL_TEST_STATIC_BUILD`, ...), then
links against that variant's `libwolfssl.a` **with the file's own object
removed** (the white-box TU supplies the single, instrumented definition). The
binary is run, exported with `llvm-cov export`, and its `aes.c` MC/DC is unioned
by `line:col`. Any failure in this path is best-effort: it logs a skip and never
affects the API variant's own coverage row.
## Files
| file | target source | reaches |
|---|---|---|
| `test_aes_whitebox.c` | `wolfcrypt/src/aes.c` | `GHASH` / `GHASH_UPDATE` internal `ptr != NULL` guards (Class 1, 13 conds) and `_AesNew_common` cross-argument `BAD_FUNC_ARG` checks (Class 2, 6 conds) |
### `test_aes_whitebox.c` - what it deliberately does **not** cover
Four aes.c union residuals remain structurally uncoverable even here and stay
justified in `iso26262/mcdc-per-module/reports/aes/RESIDUALS.md`:
- **13386:5**, **13836:5** - the two operands are exact logical **complements**
of one parameter (`ivSz==0`/`ivSz>0`, `ivFixed==NULL`/`!=NULL`); unique-cause
MC/DC is unsatisfiable by construction.
- **14268:0** - `roll_auth`'s `ret==0` needs an internal AES op to fail
mid-operation, not selectable without corrupting library state.
- **15833:0** - a dead defensive branch on a loop index provably bounded to
`[0,7)`.
## Adding a new white-box module
1. Create `test_<file>_whitebox.c` that `#include`s the target `.c` and, in
`main()`, calls each unreachable helper with both halves of every targeted
MC/DC pair. Keep every call memory-safe (short-circuits protect NULL derefs);
surface setup failures as printed skips and **return 0** (a nonzero exit
makes the campaign discard the variant).
2. Point the campaign at it (a per-module white-box source path in
`db/modules.json`); `run-mcdc.sh`'s white-box step handles build/link/export.
3. Re-run `run-mcdc.sh <module>` then `aggregate.sh <module>`; confirm the
targeted `line:col` keys leave `GAPS.md`.
tests/unit-mcdc/test_aes_whitebox.c
+344
View File
@@ -0,0 +1,344 @@
/* test_aes_whitebox.c
*
* White-box MC/DC supplement for wolfcrypt/src/aes.c.
*
* The tests/api AES suite drives aes.c through its *public* API. A handful of
* decision conditions live in link-local (WOLFSSL_LOCAL) or file-static helpers
* whose "impossible" operand combinations are rejected by every public caller
* *before* the helper runs, so they can never be exercised from the API without
* modifying library source. This translation unit reaches them by compiling
* aes.c directly (#include) and calling the helpers with both halves of each
* MC/DC independence pair.
*
* Coverage from this binary is unioned with the tests/api variant coverage by
* source line:col in the per-module campaign (iso26262/mcdc-per-module):
* llvm-cov computes MC/DC independence PER BINARY, and the campaign's
* aggregate.sh ORs the "independence shown" bit across binaries by key. That is
* why every pair below is completed *within this file* rather than relying on
* the API tests to supply the other half.
*
* Build: compiled by run-mcdc.sh's white-box step with the SAME MC/DC CFLAGS,
* -DHAVE_CONFIG_H and -I<workspace> as the instrumented library, then linked
* against that variant's libwolfssl.a with its aes.o removed (this TU supplies
* the instrumented aes.c). NOT part of the wolfSSL build; not registered in
* tests/api. See tests/unit-mcdc/README.md.
*
* Targeted residuals (aes.c), by class:
* Class 1 GHASH / GHASH_UPDATE internal ptr!=NULL guards ...... 13 conditions
* Class 2 _AesNew_common cross-argument BAD_FUNC_ARG checks .... 6 conditions
* The remaining 4 union residuals are structurally uncoverable even here
* (2 complementary-operand decisions where unique-cause MC/DC is unsatisfiable,
* 1 needs an internal AES failure not selectable without corrupting state,
* 1 dead defensive branch on a provably-bounded loop index) and stay justified
* in reports/aes/RESIDUALS.md.
*/
/* Pull aes.c in verbatim so the file-static and WOLFSSL_LOCAL helpers below are
* in scope and instrumented in THIS binary. aes.c includes settings.h (which
* picks up user_settings.h via -DWOLFSSL_USER_SETTINGS) and aes.h itself. */
#include <wolfcrypt/src/aes.c>
#include <stdio.h>
#ifndef INVALID_DEVID
#define INVALID_DEVID (-2)
#endif
static int wb_fail = 0;
#define WB_NOTE(msg) do { printf(" [wb] %s\n", (msg)); } while (0)
/* ------------------------------------------------------------------------- *
* Class 1a: classic GHASH() internal guards.
*
* if (aSz != 0 && a != NULL) -> cond idx1 (a != NULL)
* if (cSz != 0 && c != NULL) -> cond idx1 (c != NULL)
*
* Every public wc_AesGcm* entry point returns BAD_FUNC_ARG for
* "size != 0 with pointer == NULL", so GHASH never sees a!=NULL / c!=NULL
* false. Only ONE GHASH backend compiles per build (GCM_SMALL / GCM_TABLE /
* GCM_TABLE_4BIT / WORD64-default / GCM_WORD32); calling GHASH here covers
* whichever line:col this build compiled. When a==NULL / c==NULL the guard
* short-circuits before dereferencing, so the NULL calls are safe.
* ------------------------------------------------------------------------- */
#ifdef HAVE_AESGCM
static void wb_ghash_classic(void)
{
Aes aes;
byte key[16];
byte buf[32];
byte s[16];
XMEMSET(key, 0, sizeof(key));
XMEMSET(buf, 0, sizeof(buf));
if (wc_AesInit(&aes, NULL, INVALID_DEVID) != 0) {
WB_NOTE("wc_AesInit failed (classic GHASH skipped)");
wb_fail = 1;
return;
}
if (wc_AesGcmSetKey(&aes, key, sizeof(key)) != 0) {
WB_NOTE("wc_AesGcmSetKey failed (classic GHASH skipped)");
wc_AesFree(&aes);
wb_fail = 1;
return;
}
/* TRUE half: aSz!=0 && a!=NULL, cSz!=0 && c!=NULL -> decisions true */
GHASH(&aes.gcm, buf, (word32)sizeof(buf), buf, (word32)sizeof(buf),
s, (word32)sizeof(s));
/* FALSE half: aSz!=0 && a==NULL, cSz!=0 && c==NULL -> decisions false,
* flipping the a!=NULL / c!=NULL operand while size!=0 is held true. */
GHASH(&aes.gcm, NULL, (word32)sizeof(buf), NULL, (word32)sizeof(buf),
s, (word32)sizeof(s));
WB_NOTE("classic GHASH ptr-guard pairs exercised");
wc_AesFree(&aes);
}
#else
static void wb_ghash_classic(void) { WB_NOTE("HAVE_AESGCM off; classic GHASH skipped"); }
#endif
/* ------------------------------------------------------------------------- *
* Class 1b: streaming GHASH_UPDATE() internal guards (WOLFSSL_AESGCM_STREAM).
*
* if (aSz != 0 && a != NULL) -> cond idx1 (a != NULL)
* if (aes->aOver > 0 && cSz > 0 && c != NULL) -> cond idx2 (c != NULL)
* if (cSz != 0 && c != NULL) -> cond idx1 (c != NULL)
*
* GHASH_UPDATE is a single static helper (one line:col set regardless of GHASH
* backend); one streaming build covers it. We set gcm->H via wc_AesGcmSetKey
* and drive aes->aOver directly to reach the partial-AAD branch. Bodies use
* AES_LASTGBLOCK(aes) and gcm->H (both valid) and never dereference a NULL a/c
* because of the short-circuit, so every call is memory-safe.
* ------------------------------------------------------------------------- */
#if defined(HAVE_AESGCM) && defined(WOLFSSL_AESGCM_STREAM)
static void wb_ghash_update(void)
{
Aes aes;
byte key[16];
byte iv[12];
byte buf[32];
XMEMSET(key, 0, sizeof(key));
XMEMSET(iv, 0, sizeof(iv));
XMEMSET(buf, 0, sizeof(buf));
if (wc_AesInit(&aes, NULL, INVALID_DEVID) != 0) {
WB_NOTE("wc_AesInit failed (GHASH_UPDATE skipped)");
wb_fail = 1;
return;
}
/* Public streaming init sets gcm->H, runs GHASH_INIT and (under
* WOLFSSL_SMALL_STACK) heap-allocates aes->streamData that AES_LASTGBLOCK
* indexes into -- avoids a NULL scratch deref in the manual path below. */
if (wc_AesGcmInit(&aes, key, sizeof(key), iv, sizeof(iv)) != 0) {
WB_NOTE("wc_AesGcmInit failed (GHASH_UPDATE skipped)");
wc_AesFree(&aes);
wb_fail = 1;
return;
}
aes.aOver = 0;
aes.cOver = 0;
/* line 10130: if (aSz != 0 && a != NULL) -- flip a!=NULL, hold aSz!=0 */
aes.aOver = 0;
GHASH_UPDATE(&aes, buf, (word32)WC_AES_BLOCK_SIZE, NULL, 0); /* a!=NULL T */
aes.aOver = 0;
GHASH_UPDATE(&aes, NULL, (word32)WC_AES_BLOCK_SIZE, NULL, 0);/* a!=NULL F */
/* line 10168: if (aes->aOver > 0 && cSz > 0 && c != NULL)
* hold aOver>0 and cSz>0, flip c!=NULL. The body zero-fills LASTGBLOCK and
* does not read c, so c==NULL is safe. The TRUE path resets aOver to 0, so
* re-arm aOver before each call. */
aes.aOver = 4;
GHASH_UPDATE(&aes, NULL, 0, NULL, (word32)WC_AES_BLOCK_SIZE); /* c!=NULL F */
aes.aOver = 4;
GHASH_UPDATE(&aes, NULL, 0, buf, (word32)WC_AES_BLOCK_SIZE); /* c!=NULL T */
/* line 10180: if (cSz != 0 && c != NULL) -- aOver==0 so the block above is
* skipped; hold cSz!=0, flip c!=NULL. */
aes.aOver = 0;
GHASH_UPDATE(&aes, NULL, 0, buf, (word32)WC_AES_BLOCK_SIZE); /* c!=NULL T */
aes.aOver = 0;
GHASH_UPDATE(&aes, NULL, 0, NULL, (word32)WC_AES_BLOCK_SIZE); /* c!=NULL F */
WB_NOTE("streaming GHASH_UPDATE ptr-guard pairs exercised");
wc_AesFree(&aes);
}
#else
static void wb_ghash_update(void) { WB_NOTE("AESGCM stream off; GHASH_UPDATE skipped"); }
#endif
/* ------------------------------------------------------------------------- *
* Class 2: _AesNew_common() cross-argument BAD_FUNC_ARG checks.
*
* _AesNew_common(heap, devId, result_code, aesInitType, id, idLen, label)
* validates that the id/idLen/label triple matches the init type. Each public
* wrapper (wc_AesNew / wc_AesNew_Id / wc_AesNew_Label) hard-codes the arguments
* it does not use, so the "wrong" combinations are unreachable through the API.
* We call the static directly with each combination.
*
* AES_NEW_INIT_ID line 14766: if (id==NULL || idLen==0 || label!=NULL)
* -> idx2 (label != NULL)
* AES_NEW_INIT_LABEL line 14774: if (label==NULL || id!=NULL || idLen!=0)
* -> idx1 (id != NULL), idx2 (idLen != 0)
* default line 14783: if (id!=NULL || idLen!=0 || label!=NULL)
* -> idx0 (id!=NULL), idx1 (idLen!=0), idx2 (label!=NULL)
*
* The BAD_FUNC_ARG branch frees nothing extra (no Aes init ran); the "all
* false" branch runs a normal wc_AesInit* which we release with wc_AesDelete.
* ------------------------------------------------------------------------- */
static void wb_release(Aes* aes)
{
if (aes != NULL) {
wc_AesFree(aes);
XFREE(aes, NULL, DYNAMIC_TYPE_AES);
}
}
static void wb_aesnew_common(void)
{
unsigned char id[4];
const char* label = "wb-label";
int rc = 0;
Aes* aes;
XMEMSET(id, 0x5A, sizeof(id));
#ifdef WOLF_PRIVATE_KEY_ID
/* line 14766, idx2 (label != NULL): id!=NULL,idLen!=0 held false-contrib,
* flip label. TRUE -> BAD_FUNC_ARG (no init); FALSE -> real ID init. */
aes = _AesNew_common(NULL, INVALID_DEVID, &rc, AES_NEW_INIT_ID,
id, (int)sizeof(id), label); /* label!=NULL -> true */
wb_release(aes);
aes = _AesNew_common(NULL, INVALID_DEVID, &rc, AES_NEW_INIT_ID,
id, (int)sizeof(id), NULL); /* label==NULL -> false */
wb_release(aes);
/* line 14774, idx1 (id!=NULL) and idx2 (idLen!=0): hold label!=NULL false,
* flip id then idLen. */
aes = _AesNew_common(NULL, INVALID_DEVID, &rc, AES_NEW_INIT_LABEL,
id, 0, label); /* id!=NULL -> true */
wb_release(aes);
aes = _AesNew_common(NULL, INVALID_DEVID, &rc, AES_NEW_INIT_LABEL,
NULL, 4, label); /* idLen!=0 -> true */
wb_release(aes);
aes = _AesNew_common(NULL, INVALID_DEVID, &rc, AES_NEW_INIT_LABEL,
NULL, 0, label); /* both false -> real */
wb_release(aes);
WB_NOTE("_AesNew_common ID/LABEL cross-arg pairs exercised");
#else
(void)id; (void)label;
WB_NOTE("WOLF_PRIVATE_KEY_ID off; ID/LABEL cases skipped");
#endif
/* line 14783 default case (always compiled), idx0/idx1/idx2: flip each of
* id / idLen / label with the others held false. */
aes = _AesNew_common(NULL, INVALID_DEVID, &rc, 0 /*plain*/,
id, 0, NULL); /* id!=NULL -> true */
wb_release(aes);
aes = _AesNew_common(NULL, INVALID_DEVID, &rc, 0 /*plain*/,
NULL, 4, NULL); /* idLen!=0 -> true */
wb_release(aes);
aes = _AesNew_common(NULL, INVALID_DEVID, &rc, 0 /*plain*/,
NULL, 0, label); /* label!=NULL -> true */
wb_release(aes);
aes = _AesNew_common(NULL, INVALID_DEVID, &rc, 0 /*plain*/,
NULL, 0, NULL); /* all false -> real */
wb_release(aes);
WB_NOTE("_AesNew_common default cross-arg pairs exercised");
}
/* ------------------------------------------------------------------------- *
* Class 3: AES-NI internal pointer guards (WOLFSSL_AESNI).
*
* When aes.c is compiled with AES-NI (the campaign's "aesni" variant), the
* AES-NI code paths add file-static helpers whose NULL/size guards every public
* caller pre-rejects, exactly like the classic GHASH guards:
*
* AES_set_encrypt_key_AESNI / AES_set_decrypt_key_AESNI
* line 1068 / 1099: if (!userKey || !aes) -> idx0 !userKey, idx1 !aes
* AesGcmAadUpdate_aesni
* line 12136: if (aSz != 0 && a != NULL) -> idx1 (a != NULL)
* AesGcmEncryptUpdate_aesni
* line 12305: AesGcmAadUpdate_aesni(..., (cSz > 0) && (c != NULL))
* -> idx1 (c != NULL)
* line 12310: if (cSz != 0 && c != NULL) -> idx1 (c != NULL)
* AesGcmDecryptUpdate_aesni
* line 12635: if (cSz != 0 && p != NULL) -> idx1 (p != NULL)
*
* The key setters return BAD_FUNC_ARG before any AES-NI work. For the GCM
* updaters, a data pointer == NULL with size != 0 short-circuits its guarded
* block before dereferencing, so the NULL calls are memory-safe. A valid GCM
* streaming state (wc_AesGcmInit) supplies gcm->H; on an AES-NI host use_aesni
* is set, so calling the *_aesni updaters directly is state-consistent.
* ASSERT_SAVED_VECTOR_REGISTERS is a no-op unless WOLFSSL_CHECK_VECTOR_REGISTERS.
* ------------------------------------------------------------------------- */
#ifdef WOLFSSL_AESNI
static void wb_aesni(void)
{
{ /* key-expansion !userKey / !aes halves */
Aes aes;
byte key[16];
XMEMSET(key, 0, sizeof(key));
XMEMSET(&aes, 0, sizeof(aes));
(void)AES_set_encrypt_key_AESNI(NULL, 128, &aes); /* !userKey -> true */
(void)AES_set_encrypt_key_AESNI(key, 128, NULL); /* !userKey F, !aes T */
(void)AES_set_decrypt_key_AESNI(NULL, 128, &aes); /* !userKey -> true */
(void)AES_set_decrypt_key_AESNI(key, 128, NULL); /* !userKey F, !aes T */
}
#if defined(HAVE_AESGCM) && defined(WOLFSSL_AESGCM_STREAM)
{ /* AES-NI GCM streaming ptr guards; both halves within this binary */
Aes aes;
byte key[16], iv[12], in[16], out[16];
XMEMSET(key, 0, sizeof(key)); XMEMSET(iv, 0, sizeof(iv));
XMEMSET(in, 0, sizeof(in)); XMEMSET(out, 0, sizeof(out));
if (wc_AesInit(&aes, NULL, INVALID_DEVID) == 0 &&
wc_AesGcmInit(&aes, key, sizeof(key), iv, sizeof(iv)) == 0) {
/* 12136: if (aSz != 0 && a != NULL) -- hold aSz!=0, flip a!=NULL */
aes.aOver = 0;
(void)AesGcmAadUpdate_aesni(&aes, in, 16, 0); /* a!=NULL T */
aes.aOver = 0;
(void)AesGcmAadUpdate_aesni(&aes, NULL, 16, 0); /* a!=NULL F */
/* 12305 + 12310: c!=NULL -- hold cSz!=0, flip c (out) */
aes.aOver = 0; aes.cOver = 0;
(void)AesGcmEncryptUpdate_aesni(&aes, out, in, 16, in, 16); /* c T */
aes.aOver = 0; aes.cOver = 0;
(void)AesGcmEncryptUpdate_aesni(&aes, NULL, in, 16, in, 16); /* c F */
/* 12635: p!=NULL -- hold cSz!=0, flip p (out) */
aes.aOver = 0; aes.cOver = 0;
(void)AesGcmDecryptUpdate_aesni(&aes, out, in, 16, in, 16); /* p T */
aes.aOver = 0; aes.cOver = 0;
(void)AesGcmDecryptUpdate_aesni(&aes, NULL, in, 16, in, 16); /* p F */
wc_AesFree(&aes);
}
else {
WB_NOTE("AES-NI GCM streaming init failed; GCM guards skipped");
}
}
#endif /* HAVE_AESGCM && WOLFSSL_AESGCM_STREAM */
WB_NOTE("AES-NI internal ptr-guard pairs exercised");
}
#else
static void wb_aesni(void) { WB_NOTE("WOLFSSL_AESNI off; AES-NI internals skipped"); }
#endif
int main(void)
{
printf("aes.c white-box MC/DC supplement\n");
#ifdef NO_AES
printf(" NO_AES defined; nothing to exercise\n");
return 0;
#else
wb_ghash_classic();
wb_ghash_update();
wb_aesnew_common();
wb_aesni();
printf("done (%s)\n", wb_fail ? "with skips" : "ok");
/* Setup failures are surfaced as skips, not test failures: the campaign
* treats a nonzero exit as a failed variant and discards its coverage. */
return 0;
#endif
}