Convert more tests (adcd8e37) · Commits · CYBER - Cyber Security / TS 103 523 MSP / TLMSP / TLMSP OpenSSL

test/build.info

+2 −2

Original line number	Diff line number	Diff line
		@@ -151,7 +151,7 @@ IF[{- !$disabled{tests} -}]
		INCLUDE[evp_test]=../include
		DEPEND[evp_test]=../libcrypto

		SOURCE[evp_extra_test]=evp_extra_test.c
		SOURCE[evp_extra_test]=evp_extra_test.c testutil.c test_main.c
		INCLUDE[evp_extra_test]=../include
		DEPEND[evp_extra_test]=../libcrypto

		@@ -191,7 +191,7 @@ IF[{- !$disabled{tests} -}]
		INCLUDE[bad_dtls_test]=../include
		DEPEND[bad_dtls_test]=../libcrypto ../libssl

		SOURCE[packettest]=packettest.c
		SOURCE[packettest]=packettest.c testutil.c test_main.c
		INCLUDE[packettest]=../include
		DEPEND[packettest]=../libcrypto

test/ct_test.c

+75 −155

Original line number	Diff line number	Diff line
		@@ -60,29 +60,21 @@ typedef struct ct_test_fixture {
		static CT_TEST_FIXTURE set_up(const char *const test_case_name)
		{
		CT_TEST_FIXTURE fixture;
		int setup_ok = 1;
		int ok = 0;

		memset(&fixture, 0, sizeof(fixture));

		fixture.test_case_name = test_case_name;
		fixture.epoch_time_in_ms = 1473269626000; /* Sep 7 17:33:46 2016 GMT */
		fixture.ctlog_store = CTLOG_STORE_new();

		if (fixture.ctlog_store == NULL) {
		setup_ok = 0;
		fprintf(stderr, "Failed to create a new CT log store\n");
		if (!TEST_ptr(fixture.ctlog_store = CTLOG_STORE_new())
		\|\| !TEST_int_eq(
		CTLOG_STORE_load_default_file(fixture.ctlog_store), 1))
		goto end;
		}

		if (CTLOG_STORE_load_default_file(fixture.ctlog_store) != 1) {
		setup_ok = 0;
		fprintf(stderr, "Failed to load CT log list\n");
		goto end;
		}
		ok = 1;

		end:
		if (!setup_ok) {
		if (!ok) {
		CTLOG_STORE_free(fixture.ctlog_store);
		TEST_error("Failed to setup");
		exit(EXIT_FAILURE);
		}
		return fixture;
		@@ -96,19 +88,18 @@ static void tear_down(CT_TEST_FIXTURE fixture)

		static char mk_file_path(const char dir, const char *file)
		{
		char *full_file = NULL;
		size_t full_file_l = 0;
		const char *sep = "";
		#ifndef OPENSSL_SYS_VMS
		sep = "/";
		const char *sep = "/";
		#else
		const char *sep = "";
		#endif
		size_t len = strlen(dir) + strlen(sep) + strlen(file) + 1;
		char *full_file = OPENSSL_zalloc(len);

		full_file_l = strlen(dir) + strlen(sep) + strlen(file) + 1;
		full_file = OPENSSL_zalloc(full_file_l);
		if (full_file != NULL) {
		OPENSSL_strlcpy(full_file, dir, full_file_l);
		OPENSSL_strlcat(full_file, sep, full_file_l);
		OPENSSL_strlcat(full_file, file, full_file_l);
		OPENSSL_strlcpy(full_file, dir, len);
		OPENSSL_strlcat(full_file, sep, len);
		OPENSSL_strlcat(full_file, file, len);
		}

		return full_file;
		@@ -121,33 +112,32 @@ static X509 load_pem_cert(const char dir, const char *file)

		if (file_path != NULL) {
		BIO *cert_io = BIO_new_file(file_path, "r");
		OPENSSL_free(file_path);

		if (cert_io != NULL)
		cert = PEM_read_bio_X509(cert_io, NULL, NULL, NULL);

		BIO_free(cert_io);
		}

		OPENSSL_free(file_path);
		return cert;
		}

		static int read_text_file(const char dir, const char file,
		char *buffer, int buffer_length)
		{
		int result = -1;
		int len = -1;
		char *file_path = mk_file_path(dir, file);

		if (file_path != NULL) {
		BIO *file_io = BIO_new_file(file_path, "r");
		OPENSSL_free(file_path);

		if (file_io != NULL) {
		result = BIO_read(file_io, buffer, buffer_length);
		if (file_io != NULL)
		len = BIO_read(file_io, buffer, buffer_length);
		BIO_free(file_io);
		}
		}

		return result;
		OPENSSL_free(file_path);
		return len;
		}

		static int compare_sct_list_printout(STACK_OF(SCT) *sct,
		@@ -155,31 +145,21 @@ static int compare_sct_list_printout(STACK_OF(SCT) *sct,
		{
		BIO *text_buffer = NULL;
		char *actual_output = NULL;
		int result = 1;
		int result = 0;

		text_buffer = BIO_new(BIO_s_mem());
		if (text_buffer == NULL) {
		fprintf(stderr, "Unable to allocate buffer\n");
		if (!TEST_ptr(text_buffer = BIO_new(BIO_s_mem())))
		goto end;
		}

		SCT_LIST_print(sct, text_buffer, 0, "\n", NULL);

		/* Append null terminator because we're about to use the buffer contents
		* as a string. */
		if (BIO_write(text_buffer, "\0", 1) != 1) {
		fprintf(stderr, "Failed to append null terminator to SCT text\n");
		/* Append \0 because we're about to use the buffer contents as a string. */
		if (!TEST_true(BIO_write(text_buffer, "\0", 1)))
		goto end;
		}

		BIO_get_mem_data(text_buffer, &actual_output);
		result = strcmp(actual_output, expected_output);

		if (result != 0) {
		fprintf(stderr,
		"Expected SCT printout:\n%s\nActual SCT printout:\n%s\n",
		expected_output, actual_output);
		}
		if (!TEST_str_eq(actual_output, expected_output))
		goto end;
		result = 1;

		end:
		BIO_free(text_buffer);
		@@ -191,55 +171,41 @@ static int compare_extension_printout(X509_EXTENSION *extension,
		{
		BIO *text_buffer = NULL;
		char *actual_output = NULL;
		int result = 1;
		int result = 0;

		text_buffer = BIO_new(BIO_s_mem());
		if (text_buffer == NULL) {
		fprintf(stderr, "Unable to allocate buffer\n");
		if (!TEST_ptr(text_buffer = BIO_new(BIO_s_mem()))
		\|\| !TEST_true(X509V3_EXT_print(text_buffer, extension,
		X509V3_EXT_DEFAULT, 0)))
		goto end;
		}

		if (!X509V3_EXT_print(text_buffer, extension, X509V3_EXT_DEFAULT, 0)) {
		fprintf(stderr, "Failed to print extension\n");
		/* Append \0 because we're about to use the buffer contents as a string. */
		if (!TEST_true(BIO_write(text_buffer, "\0", 1)))
		goto end;
		}

		/* Append null terminator because we're about to use the buffer contents
		* as a string. */
		if (BIO_write(text_buffer, "\0", 1) != 1) {
		fprintf(stderr,
		"Failed to append null terminator to extension text\n");
		goto end;
		}

		BIO_get_mem_data(text_buffer, &actual_output);
		result = strcmp(actual_output, expected_output);
		if (!TEST_str_eq(actual_output, expected_output))
		goto end;

		if (result != 0) {
		fprintf(stderr,
		"Expected SCT printout:\n%s\nActual SCT printout:\n%s\n",
		expected_output, actual_output);
		}
		result = 1;

		end:
		BIO_free(text_buffer);
		return result;
		}

		static int assert_validity(CT_TEST_FIXTURE fixture,
		STACK_OF(SCT) *scts,
		CT_POLICY_EVAL_CTX *policy_ctx) {
		static int assert_validity(CT_TEST_FIXTURE fixture, STACK_OF(SCT) *scts,
		CT_POLICY_EVAL_CTX *policy_ctx)
		{
		int invalid_sct_count = 0;
		int valid_sct_count = 0;
		int i;

		if (SCT_LIST_validate(scts, policy_ctx) < 0) {
		fprintf(stderr, "Error verifying SCTs\n");
		if (!TEST_int_ge(SCT_LIST_validate(scts, policy_ctx), 0))
		return 0;
		}

		for (i = 0; i < sk_SCT_num(scts); ++i) {
		SCT *sct_i = sk_SCT_value(scts, i);

		switch (SCT_get_validation_status(sct_i)) {
		case SCT_VALIDATION_STATUS_VALID:
		++valid_sct_count;
		@@ -256,18 +222,12 @@ static int assert_validity(CT_TEST_FIXTURE fixture,
		}
		}

		if (valid_sct_count != fixture.expected_valid_sct_count) {
		if (!TEST_int_eq(valid_sct_count, fixture.expected_valid_sct_count)) {
		int unverified_sct_count = sk_SCT_num(scts) -
		invalid_sct_count - valid_sct_count;

		fprintf(stderr,
		"%d SCTs failed verification\n"
		"%d SCTs passed verification (%d expected)\n"
		"%d SCTs were unverified\n",
		invalid_sct_count,
		valid_sct_count,
		fixture.expected_valid_sct_count,
		unverified_sct_count);
		TEST_info("%d SCTs failed, %d SCTs unverified",
		invalid_sct_count, unverified_sct_count);
		return 0;
		}

		@@ -291,12 +251,8 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
		expected_sct_text,
		CT_TEST_MAX_FILE_SIZE - 1);

		if (sct_text_len < 0) {
		fprintf(stderr, "Test data file not found: %s\n",
		fixture.sct_text_file);
		if (!TEST_int_ge(sct_text_len, 0))
		goto end;
		}

		expected_sct_text[sct_text_len] = '\0';
		}

		@@ -308,25 +264,17 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
		if (fixture.certificate_file != NULL) {
		int sct_extension_index;
		X509_EXTENSION *sct_extension = NULL;
		cert = load_pem_cert(fixture.certs_dir, fixture.certificate_file);

		if (cert == NULL) {
		fprintf(stderr, "Unable to load certificate: %s\n",
		fixture.certificate_file);
		if (!TEST_ptr(cert = load_pem_cert(fixture.certs_dir,
		fixture.certificate_file)))
		goto end;
		}

		CT_POLICY_EVAL_CTX_set1_cert(ct_policy_ctx, cert);

		if (fixture.issuer_file != NULL) {
		issuer = load_pem_cert(fixture.certs_dir, fixture.issuer_file);

		if (issuer == NULL) {
		fprintf(stderr, "Unable to load issuer certificate: %s\n",
		fixture.issuer_file);
		if (!TEST_ptr(issuer = load_pem_cert(fixture.certs_dir,
		fixture.issuer_file)))
		goto end;
		}

		CT_POLICY_EVAL_CTX_set1_issuer(ct_policy_ctx, issuer);
		}

		@@ -334,17 +282,13 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
		X509_get_ext_by_NID(cert, NID_ct_precert_scts, -1);
		sct_extension = X509_get_ext(cert, sct_extension_index);
		if (fixture.expected_sct_count > 0) {
		if (sct_extension == NULL) {
		fprintf(stderr, "SCT extension not found in: %s\n",
		fixture.certificate_file);
		if (!TEST_ptr(sct_extension))
		goto end;
		}

		if (fixture.sct_text_file
		&& compare_extension_printout(sct_extension,
		expected_sct_text)) {
		&& !compare_extension_printout(sct_extension,
		expected_sct_text))
		goto end;
		}

		if (fixture.test_validity) {
		int i;
		@@ -353,30 +297,24 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
		for (i = 0; i < sk_SCT_num(scts); ++i) {
		SCT *sct_i = sk_SCT_value(scts, i);

		if (!SCT_set_source(sct_i, SCT_SOURCE_X509V3_EXTENSION)) {
		fprintf(stderr,
		"Error setting SCT source to X509v3 extension\n");
		if (!TEST_true(SCT_set_source(sct_i,
		SCT_SOURCE_X509V3_EXTENSION)))
		goto end;
		}
		}

		if (!assert_validity(fixture, scts, ct_policy_ctx))
		goto end;
		}
		} else if (sct_extension != NULL) {
		fprintf(stderr,
		"Expected no SCTs, but found SCT extension in: %s\n",
		fixture.certificate_file);
		} else if (!TEST_ptr_null(sct_extension)) {
		goto end;
		}
		}

		if (fixture.tls_sct_list != NULL) {
		const unsigned char *p = fixture.tls_sct_list;
		if (o2i_SCT_LIST(&scts, &p, fixture.tls_sct_list_len) == NULL) {
		fprintf(stderr, "Failed to decode SCTs from TLS format\n");

		if (!TEST_ptr(o2i_SCT_LIST(&scts, &p, fixture.tls_sct_list_len)))
		goto end;
		}

		if (fixture.test_validity && cert != NULL) {
		if (!assert_validity(fixture, scts, ct_policy_ctx))
		@@ -384,18 +322,15 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
		}

		if (fixture.sct_text_file
		&& compare_sct_list_printout(scts, expected_sct_text)) {
		&& !compare_sct_list_printout(scts, expected_sct_text)) {
		goto end;
		}

		tls_sct_list_len = i2o_SCT_LIST(scts, &tls_sct_list);
		if (tls_sct_list_len != fixture.tls_sct_list_len \|\|
		memcmp(fixture.tls_sct_list, tls_sct_list, tls_sct_list_len) != 0) {
		fprintf(stderr,
		"Failed to encode SCTs into TLS format correctly\n");
		if (!TEST_mem_eq(fixture.tls_sct_list, fixture.tls_sct_list_len,
		tls_sct_list, tls_sct_list_len))
		goto end;
		}
		}
		success = 1;

		end:
		@@ -520,15 +455,11 @@ static int test_encode_tls_sct()
		SETUP_CT_TEST_FIXTURE();

		fixture.sct_list = sk_SCT_new_null();
		sct = SCT_new_from_base64(SCT_VERSION_V1, log_id,
		if (!TEST_ptr(sct = SCT_new_from_base64(SCT_VERSION_V1, log_id,
		CT_LOG_ENTRY_TYPE_X509, timestamp,
		extensions, signature);
		extensions, signature)))

		if (sct == NULL) {
		tear_down(fixture);
		fprintf(stderr, "Failed to create SCT from base64-encoded test data\n");
		return 0;
		}

		sk_SCT_push(fixture.sct_list, sct);
		fixture.sct_dir = ct_dir;
		@@ -548,11 +479,8 @@ static int test_default_ct_policy_eval_ctx_time_is_now()
		1000;
		const time_t time_tolerance = 600; /* 10 minutes */

		if (fabs(difftime(time(NULL), default_time)) > time_tolerance) {
		fprintf(stderr,
		"Default CT_POLICY_EVAL_CTX time is not approximately now.\n");
		if (!TEST_uint_le(fabs(difftime(time(NULL), default_time)), time_tolerance))
		goto end;
		}

		success = 1;
		end:
		@@ -562,13 +490,10 @@ end:

		int test_main(int argc, char *argv[])
		{
		int result = 0;
		char *tmp_env;

		tmp_env = getenv("CT_DIR");
		ct_dir = OPENSSL_strdup(tmp_env != NULL ? tmp_env : "ct");
		tmp_env = getenv("CERTS_DIR");
		certs_dir = OPENSSL_strdup(tmp_env != NULL ? tmp_env : "certs");
		if ((ct_dir = getenv("CT_DIR")) == NULL)
		ct_dir = "ct";
		if ((certs_dir = getenv("CERTS_DIR")) == NULL)
		certs_dir = "certs";

		ADD_TEST(test_no_scts_in_certificate);
		ADD_TEST(test_one_sct_in_certificate);
		@@ -580,12 +505,7 @@ int test_main(int argc, char *argv[])
		ADD_TEST(test_encode_tls_sct);
		ADD_TEST(test_default_ct_policy_eval_ctx_time_is_now);

		result = run_tests(argv[0]);

		OPENSSL_free(ct_dir);
		OPENSSL_free(certs_dir);

		return result;
		return run_tests(argv[0]);
		}
		#else
		int test_main(int argc, char *argv[])

test/evp_extra_test.c

+63 −115

Original line number	Diff line number	Diff line
		@@ -15,6 +15,8 @@
		#include <openssl/evp.h>
		#include <openssl/rsa.h>
		#include <openssl/x509.h>
		#include "testutil.h"
		#include "test_main.h"

		/*
		* kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
		@@ -186,6 +188,18 @@ static const unsigned char kExampleBadECKeyDER[] = {
		};
		#endif

		typedef struct APK_DATA_st {
		const unsigned char *kder;
		size_t size;
		int evptype;
		} APK_DATA;

		static APK_DATA keydata[] = {
		{kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA},
		{kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA},
		{kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC}
		};

		static EVP_PKEY *load_example_rsa_key(void)
		{
		EVP_PKEY *ret = NULL;
		@@ -193,19 +207,17 @@ static EVP_PKEY *load_example_rsa_key(void)
		EVP_PKEY *pkey = NULL;
		RSA *rsa = NULL;

		if (!d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))) {
		if (!TEST_true(d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))))
		return NULL;
		}

		pkey = EVP_PKEY_new();
		if (pkey == NULL \|\| !EVP_PKEY_set1_RSA(pkey, rsa)) {
		goto out;
		}
		if (!TEST_ptr(pkey = EVP_PKEY_new())
		\|\| !TEST_true(EVP_PKEY_set1_RSA(pkey, rsa)))
		goto end;

		ret = pkey;
		pkey = NULL;

		out:
		end:
		EVP_PKEY_free(pkey);
		RSA_free(rsa);

		@@ -218,48 +230,37 @@ static int test_EVP_DigestSignInit(void)
		EVP_PKEY *pkey = NULL;
		unsigned char *sig = NULL;
		size_t sig_len = 0;
		EVP_MD_CTX md_ctx, md_ctx_verify;
		EVP_MD_CTX md_ctx, md_ctx_verify = NULL;

		md_ctx = EVP_MD_CTX_new();
		md_ctx_verify = EVP_MD_CTX_new();
		if (md_ctx == NULL \|\| md_ctx_verify == NULL)
		if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
		\|\| !TEST_ptr(md_ctx_verify = EVP_MD_CTX_new())
		\|\| !TEST_ptr(pkey = load_example_rsa_key()))
		goto out;

		pkey = load_example_rsa_key();
		if (pkey == NULL \|\|
		!EVP_DigestSignInit(md_ctx, NULL, EVP_sha256(), NULL, pkey) \|\|
		!EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))) {
		if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
		\|\| !TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
		goto out;
		}

		/* Determine the size of the signature. */
		if (!EVP_DigestSignFinal(md_ctx, NULL, &sig_len)) {
		if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len))
		\|\| !TEST_size_t_eq(sig_len, (size_t)EVP_PKEY_size(pkey)))
		goto out;
		}
		/* Sanity check for testing. */
		if (sig_len != (size_t)EVP_PKEY_size(pkey)) {
		fprintf(stderr, "sig_len mismatch\n");
		goto out;
		}

		sig = OPENSSL_malloc(sig_len);
		if (sig == NULL \|\| !EVP_DigestSignFinal(md_ctx, sig, &sig_len)) {
		if (!TEST_ptr(sig = OPENSSL_malloc(sig_len))
		\|\| !TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
		goto out;
		}

		/* Ensure that the signature round-trips. */
		if (!EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sha256(), NULL, pkey)
		\|\| !EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))
		\|\| !EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)) {
		if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sha256(),
		NULL, pkey))
		\|\| !TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify,
		kMsg, sizeof(kMsg)))
		\|\| !TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
		goto out;
		}

		ret = 1;

		out:
		if (!ret) {
		ERR_print_errors_fp(stderr);
		}

		EVP_MD_CTX_free(md_ctx);
		EVP_MD_CTX_free(md_ctx_verify);
		EVP_PKEY_free(pkey);
		@@ -272,56 +273,44 @@ static int test_EVP_DigestVerifyInit(void)
		{
		int ret = 0;
		EVP_PKEY *pkey = NULL;
		EVP_MD_CTX *md_ctx;
		EVP_MD_CTX *md_ctx = NULL;

		md_ctx = EVP_MD_CTX_new();
		if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
		\|\| !TEST_ptr(pkey = load_example_rsa_key()))
		goto out;

		pkey = load_example_rsa_key();
		if (pkey == NULL \|\|
		!EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey) \|\|
		!EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)) \|\|
		!EVP_DigestVerifyFinal(md_ctx, kSignature, sizeof(kSignature))) {
		if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
		\|\| !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
		\|\| !TEST_true(EVP_DigestVerifyFinal(md_ctx, kSignature,
		sizeof(kSignature))))
		goto out;
		}
		ret = 1;

		out:
		if (!ret) {
		ERR_print_errors_fp(stderr);
		}

		EVP_MD_CTX_free(md_ctx);
		EVP_PKEY_free(pkey);

		return ret;
		}

		static int test_d2i_AutoPrivateKey(const unsigned char *input,
		size_t input_len, int expected_id)
		static int test_d2i_AutoPrivateKey(int i)
		{
		int ret = 0;
		const unsigned char *p;
		EVP_PKEY *pkey = NULL;
		const APK_DATA *ak = &keydata[i];
		const unsigned char *input = ak->kder;
		size_t input_len = ak->size;
		int expected_id = ak->evptype;

		p = input;
		pkey = d2i_AutoPrivateKey(NULL, &p, input_len);
		if (pkey == NULL \|\| p != input + input_len) {
		fprintf(stderr, "d2i_AutoPrivateKey failed\n");
		goto done;
		}

		if (EVP_PKEY_id(pkey) != expected_id) {
		fprintf(stderr, "Did not decode expected type\n");
		if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
		\|\| !TEST_ptr_eq(p, input + input_len)
		\|\| !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
		goto done;
		}

		ret = 1;

		done:
		if (!ret) {
		ERR_print_errors_fp(stderr);
		}

		EVP_PKEY_free(pkey);
		return ret;
		}
		@@ -335,18 +324,16 @@ static int test_EVP_PKCS82PKEY(void)
		PKCS8_PRIV_KEY_INFO *p8inf = NULL;
		EVP_PKEY *pkey = NULL;

		p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp, sizeof(kExampleBadECKeyDER));
		if (!TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp,
		sizeof(kExampleBadECKeyDER))))
		goto done;

		if (!p8inf \|\| derp != kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)) {
		fprintf(stderr, "Failed to parse key\n");
		if (!TEST_ptr_eq(derp,
		kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)))
		goto done;
		}

		pkey = EVP_PKCS82PKEY(p8inf);
		if (pkey) {
		fprintf(stderr, "Imported invalid EC key\n");
		if (!TEST_ptr_null(pkey = EVP_PKCS82PKEY(p8inf)))
		goto done;
		}

		ret = 1;

		@@ -358,52 +345,13 @@ static int test_EVP_PKCS82PKEY(void)
		}
		#endif

		int main(void)
		void register_tests(void)
		{
		CRYPTO_set_mem_debug(1);
		CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);


		if (!test_EVP_DigestSignInit()) {
		fprintf(stderr, "EVP_DigestSignInit failed\n");
		return 1;
		}

		if (!test_EVP_DigestVerifyInit()) {
		fprintf(stderr, "EVP_DigestVerifyInit failed\n");
		return 1;
		}

		if (!test_d2i_AutoPrivateKey(kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER),
		EVP_PKEY_RSA)) {
		fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyDER) failed\n");
		return 1;
		}

		if (!test_d2i_AutoPrivateKey
		(kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA)) {
		fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyPKCS8) failed\n");
		return 1;
		}

		ADD_TEST(test_EVP_DigestSignInit);
		ADD_TEST(test_EVP_DigestVerifyInit);
		ADD_ALL_TESTS(test_d2i_AutoPrivateKey,
		sizeof(keydata) / sizeof(keydata[0]));
		#ifndef OPENSSL_NO_EC
		if (!test_d2i_AutoPrivateKey(kExampleECKeyDER, sizeof(kExampleECKeyDER),
		EVP_PKEY_EC)) {
		fprintf(stderr, "d2i_AutoPrivateKey(kExampleECKeyDER) failed\n");
		return 1;
		}

		if (!test_EVP_PKCS82PKEY()) {
		fprintf(stderr, "test_EVP_PKCS82PKEY failed\n");
		return 1;
		}
		ADD_TEST(test_EVP_PKCS82PKEY);
		#endif

		#ifndef OPENSSL_NO_CRYPTO_MDEBUG
		if (CRYPTO_mem_leaks_fp(stderr) <= 0)
		return 1;
		#endif

		printf("PASS\n");
		return 0;
		}

test/packettest.c

+261 −304

File changed.

Preview size limit exceeded, changes collapsed.

test/testutil.c

+32 −0

Original line number	Diff line number	Diff line
		@@ -363,6 +363,38 @@ int test_str_ne(const char file, int line, const char st1, const char *st2,
		return 1;
		}

		int test_strn_eq(const char file, int line, const char st1, const char *st2,
		const char s1, const char s2, size_t len)
		{
		int prec = (int)len;

		if (s1 == NULL && s2 == NULL)
		return 1;
		if (s1 == NULL \|\| s2 == NULL \|\| strncmp(s1, s2, len) != 0) {
		test_fail_message(NULL, file, line, "string", "%.s [%.s] == %s [%.s]",
		st1, prec, print_string_maybe_null(s1),
		st2, prec, print_string_maybe_null(s2));
		return 0;
		}
		return 1;
		}

		int test_strn_ne(const char file, int line, const char st1, const char *st2,
		const char s1, const char s2, size_t len)
		{
		int prec = (int)len;

		if ((s1 == NULL) ^ (s2 == NULL))
		return 1;
		if (s1 == NULL \|\| strncmp(s1, s2, len) == 0) {
		test_fail_message(NULL, file, line, "string", "%s [%.s] != %s [%.s]",
		st1, prec, print_string_maybe_null(s1),
		st2, prec, print_string_maybe_null(s2));
		return 0;
		}
		return 1;
		}

		/*
		* We could use OPENSSL_buf2hexstr() to do this but trying to allocate memory
		* in a failure state isn't generally a great idea.