mirror/mbedtls
1
0
Fork 0
mirror of https://github.com/Mbed-TLS/mbedtls.git synced 2025-03-28 19:21:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

test: proper positioning of USE_PSA_INIT + added missing exit labels

Browse Source 
Signed-off-by: valerio <valerio.setti@nordicsemi.no>
This commit is contained in:
valerio 2023-04-20 11:59:52 +02:00 committed by Valerio Setti
parent cf35d774fe
commit 32f2ac9a18
4 changed files with 122 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
tests/suites/test_suite_pk.function
View File

@ -216,10 +216,9 @@ void pk_psa_utils(int key_is_rsa)
size_t len; size_t len;
mbedtls_pk_debug_item dbg; mbedtls_pk_debug_item dbg;
USE_PSA_INIT();
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
mbedtls_pk_init(&pk2); mbedtls_pk_init(&pk2);
USE_PSA_INIT();
TEST_ASSERT(psa_crypto_init() == PSA_SUCCESS); TEST_ASSERT(psa_crypto_init() == PSA_SUCCESS);
@ -314,9 +313,8 @@ void pk_can_do_ext(int opaque_key, int key_type, int key_usage, int key_alg,
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT; mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
USE_PSA_INIT();
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
USE_PSA_INIT();
if (opaque_key == 1) { if (opaque_key == 1) {
psa_set_key_usage_flags(&attributes, key_usage); psa_set_key_usage_flags(&attributes, key_usage);
@ -361,9 +359,8 @@ void pk_invalid_param()
unsigned char buf[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }; unsigned char buf[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
size_t buf_size = sizeof(buf); size_t buf_size = sizeof(buf);
USE_PSA_INIT();
mbedtls_pk_init(&ctx); mbedtls_pk_init(&ctx);
USE_PSA_INIT();
TEST_EQUAL(MBEDTLS_ERR_PK_BAD_INPUT_DATA, TEST_EQUAL(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
mbedtls_pk_verify_restartable(&ctx, MBEDTLS_MD_NONE, mbedtls_pk_verify_restartable(&ctx, MBEDTLS_MD_NONE,
@ -411,8 +408,8 @@ void valid_parameters()
size_t len; size_t len;
void *options = NULL; void *options = NULL;
USE_PSA_INIT();
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_pk_setup(&pk, NULL) == TEST_ASSERT(mbedtls_pk_setup(&pk, NULL) ==
MBEDTLS_ERR_PK_BAD_INPUT_DATA); MBEDTLS_ERR_PK_BAD_INPUT_DATA);
@ -497,9 +494,10 @@ void valid_parameters_pkwrite(data_t *key_data)
{ {
mbedtls_pk_context pk; mbedtls_pk_context pk;
USE_PSA_INIT();
/* For the write tests to be effective, we need a valid key pair. */ /* For the write tests to be effective, we need a valid key pair. */
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_pk_parse_key(&pk, TEST_ASSERT(mbedtls_pk_parse_key(&pk,
key_data->x, key_data->len, NULL, 0, key_data->x, key_data->len, NULL, 0,
mbedtls_test_rnd_std_rand, NULL) == 0); mbedtls_test_rnd_std_rand, NULL) == 0);
@ -529,8 +527,8 @@ void pk_utils(int type, int parameter, int bitlen, int len, char *name)
{ {
mbedtls_pk_context pk; mbedtls_pk_context pk;
USE_PSA_INIT();
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(type)) == 0); TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(type)) == 0);
TEST_ASSERT(pk_genkey(&pk, parameter) == 0); TEST_ASSERT(pk_genkey(&pk, parameter) == 0);
@ -552,11 +550,10 @@ void mbedtls_pk_check_pair(char *pub_file, char *prv_file, int ret)
{ {
mbedtls_pk_context pub, prv, alt; mbedtls_pk_context pub, prv, alt;
USE_PSA_INIT();
mbedtls_pk_init(&pub); mbedtls_pk_init(&pub);
mbedtls_pk_init(&prv); mbedtls_pk_init(&prv);
mbedtls_pk_init(&alt); mbedtls_pk_init(&alt);
USE_PSA_INIT();
#if defined(MBEDTLS_USE_PSA_CRYPTO) #if defined(MBEDTLS_USE_PSA_CRYPTO)
/* mbedtls_pk_check_pair() returns either PK or ECP error codes depending /* mbedtls_pk_check_pair() returns either PK or ECP error codes depending
@ -611,10 +608,8 @@ void pk_rsa_verify_test_vec(data_t *message_str, int digest, int mod,
mbedtls_ecp_set_max_ops(1); mbedtls_ecp_set_max_ops(1);
#endif #endif
USE_PSA_INIT();
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0); TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
rsa = mbedtls_pk_rsa(pk); rsa = mbedtls_pk_rsa(pk);
@ -653,8 +648,8 @@ void pk_rsa_verify_ext_test_vec(data_t *message_str, int digest,
void *options; void *options;
int ret; int ret;
MD_OR_USE_PSA_INIT();
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
MD_OR_USE_PSA_INIT();
TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0); TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
rsa = mbedtls_pk_rsa(pk); rsa = mbedtls_pk_rsa(pk);
@ -708,8 +703,8 @@ void pk_ec_test_vec(int type, int id, data_t *key, data_t *hash,
mbedtls_pk_context pk; mbedtls_pk_context pk;
mbedtls_ecp_keypair *eckey; mbedtls_ecp_keypair *eckey;
USE_PSA_INIT();
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(type)) == 0); TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(type)) == 0);
@ -742,11 +737,11 @@ void pk_sign_verify_restart(int pk_type, int grp_id, char *d_str,
unsigned char sig[MBEDTLS_ECDSA_MAX_LEN]; unsigned char sig[MBEDTLS_ECDSA_MAX_LEN];
size_t slen; size_t slen;
USE_PSA_INIT();
mbedtls_pk_restart_init(&rs_ctx); mbedtls_pk_restart_init(&rs_ctx);
mbedtls_pk_init(&prv); mbedtls_pk_init(&prv);
mbedtls_pk_init(&pub); mbedtls_pk_init(&pub);
USE_PSA_INIT();
memset(sig, 0, sizeof(sig)); memset(sig, 0, sizeof(sig));
TEST_ASSERT(mbedtls_pk_setup(&prv, mbedtls_pk_info_from_type(pk_type)) == 0); TEST_ASSERT(mbedtls_pk_setup(&prv, mbedtls_pk_info_from_type(pk_type)) == 0);
@ -837,8 +832,8 @@ void pk_sign_verify(int type, int parameter, int sign_ret, int verify_ret)
mbedtls_ecp_set_max_ops(42000); mbedtls_ecp_set_max_ops(42000);
#endif #endif
MD_OR_USE_PSA_INIT();
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
MD_OR_USE_PSA_INIT();
memset(hash, 0x2a, sizeof(hash)); memset(hash, 0x2a, sizeof(hash));
memset(sig, 0, sizeof(sig)); memset(sig, 0, sizeof(sig));
@ -919,11 +914,10 @@ void pk_rsa_encrypt_decrypt_test(data_t *message, int mod,
mbedtls_pk_context pk; mbedtls_pk_context pk;
size_t olen, rlen; size_t olen, rlen;
USE_PSA_INIT();
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
mbedtls_mpi_init(&N); mbedtls_mpi_init(&P); mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E); mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
USE_PSA_INIT();
memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info)); memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
memset(output, 0, sizeof(output)); memset(output, 0, sizeof(output));
@ -995,15 +989,13 @@ void pk_rsa_decrypt_test_vec(data_t *cipher, int mod,
mbedtls_pk_context pk; mbedtls_pk_context pk;
size_t olen; size_t olen;
USE_PSA_INIT();
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
mbedtls_mpi_init(&N); mbedtls_mpi_init(&P); mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E); mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
USE_PSA_INIT();
memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info)); memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
/* init pk-rsa context */ /* init pk-rsa context */
TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0); TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
rsa = mbedtls_pk_rsa(pk); rsa = mbedtls_pk_rsa(pk);
@ -1052,11 +1044,10 @@ void pk_wrap_rsa_decrypt_test_vec(data_t *cipher, int mod,
mbedtls_svc_key_id_t key_id; mbedtls_svc_key_id_t key_id;
size_t olen; size_t olen;
USE_PSA_INIT();
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
mbedtls_mpi_init(&N); mbedtls_mpi_init(&P); mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E); mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
USE_PSA_INIT();
memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info)); memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
@ -1113,8 +1104,8 @@ void pk_ec_nocrypt(int type)
size_t olen = 0; size_t olen = 0;
int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH; int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
USE_PSA_INIT();
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
USE_PSA_INIT();
memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info)); memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
memset(output, 0, sizeof(output)); memset(output, 0, sizeof(output));
@ -1143,12 +1134,12 @@ void pk_rsa_overflow()
size_t hash_len = SIZE_MAX, sig_len = SIZE_MAX; size_t hash_len = SIZE_MAX, sig_len = SIZE_MAX;
unsigned char hash[50], sig[100]; unsigned char hash[50], sig[100];
mbedtls_pk_init(&pk);
USE_PSA_INIT(); USE_PSA_INIT();
memset(hash, 0x2a, sizeof(hash)); memset(hash, 0x2a, sizeof(hash));
memset(sig, 0, sizeof(sig)); memset(sig, 0, sizeof(sig));
mbedtls_pk_init(&pk);
TEST_ASSERT(mbedtls_pk_setup(&pk, TEST_ASSERT(mbedtls_pk_setup(&pk,
mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0); mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
@ -1188,10 +1179,10 @@ void pk_rsa_alt()
size_t sig_len, ciph_len, test_len; size_t sig_len, ciph_len, test_len;
int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH; int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
USE_PSA_INIT();
mbedtls_rsa_init(&raw); mbedtls_rsa_init(&raw);
mbedtls_pk_init(&rsa); mbedtls_pk_init(&alt); mbedtls_pk_init(&rsa);
mbedtls_pk_init(&alt);
USE_PSA_INIT();
memset(hash, 0x2a, sizeof(hash)); memset(hash, 0x2a, sizeof(hash));
memset(sig, 0, sizeof(sig)); memset(sig, 0, sizeof(sig));
@ -1285,12 +1276,12 @@ void pk_psa_sign(int parameter_arg,
* - parse it to a PK context and verify the signature this way * - parse it to a PK context and verify the signature this way
*/ */
mbedtls_pk_init(&pk);
USE_PSA_INIT(); USE_PSA_INIT();
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME) #if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME)
if (PSA_KEY_TYPE_IS_RSA(psa_type_arg)) { if (PSA_KEY_TYPE_IS_RSA(psa_type_arg)) {
/* Create legacy RSA public/private key in PK context. */ /* Create legacy RSA public/private key in PK context. */
mbedtls_pk_init(&pk);
TEST_ASSERT(mbedtls_pk_setup(&pk, TEST_ASSERT(mbedtls_pk_setup(&pk,
mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0); mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
TEST_ASSERT(mbedtls_rsa_gen_key(mbedtls_pk_rsa(pk), TEST_ASSERT(mbedtls_rsa_gen_key(mbedtls_pk_rsa(pk),
@ -1304,7 +1295,6 @@ void pk_psa_sign(int parameter_arg,
mbedtls_ecp_group_id grpid = parameter_arg; mbedtls_ecp_group_id grpid = parameter_arg;
/* Create legacy EC public/private key in PK context. */ /* Create legacy EC public/private key in PK context. */
mbedtls_pk_init(&pk);
TEST_ASSERT(mbedtls_pk_setup(&pk, TEST_ASSERT(mbedtls_pk_setup(&pk,
mbedtls_pk_info_from_type(MBEDTLS_PK_ECKEY)) == 0); mbedtls_pk_info_from_type(MBEDTLS_PK_ECKEY)) == 0);
TEST_ASSERT(pk_genkey(&pk, grpid) == 0); TEST_ASSERT(pk_genkey(&pk, grpid) == 0);
@ -1424,8 +1414,8 @@ void pk_psa_sign_ext(int pk_type, int parameter, int key_pk_type, int md_alg)
memset(hash, 0x2a, sizeof(hash)); memset(hash, 0x2a, sizeof(hash));
memset(sig, 0, sizeof(sig)); memset(sig, 0, sizeof(sig));
PSA_INIT();
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
PSA_INIT();
TEST_ASSERT(mbedtls_pk_setup(&pk, TEST_ASSERT(mbedtls_pk_setup(&pk,
mbedtls_pk_info_from_type(pk_type)) == 0); mbedtls_pk_info_from_type(pk_type)) == 0);
@ -1468,8 +1458,8 @@ void pk_psa_wrap_sign_ext(int pk_type, int parameter, int key_pk_type, int md_al
mbedtls_pk_rsassa_pss_options rsassa_pss_options; mbedtls_pk_rsassa_pss_options rsassa_pss_options;
int ret; int ret;
PSA_INIT();
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);
PSA_INIT();
/* Create legacy RSA public/private key in PK context. */ /* Create legacy RSA public/private key in PK context. */
mbedtls_pk_init(&pk); mbedtls_pk_init(&pk);

85
tests/suites/test_suite_ssl.function
View File

@ -1118,10 +1118,9 @@ void ssl_dtls_replay(data_t *prevs, data_t *new, int ret)
mbedtls_ssl_context ssl; mbedtls_ssl_context ssl;
mbedtls_ssl_config conf; mbedtls_ssl_config conf;
MD_OR_USE_PSA_INIT();
mbedtls_ssl_init(&ssl); mbedtls_ssl_init(&ssl);
mbedtls_ssl_config_init(&conf); mbedtls_ssl_config_init(&conf);
MD_OR_USE_PSA_INIT();
TEST_ASSERT(mbedtls_ssl_config_defaults(&conf, TEST_ASSERT(mbedtls_ssl_config_defaults(&conf,
MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_IS_CLIENT,
@ -1151,12 +1150,13 @@ void ssl_set_hostname_twice(char *hostname0, char *hostname1)
{ {
mbedtls_ssl_context ssl; mbedtls_ssl_context ssl;
USE_PSA_INIT();
mbedtls_ssl_init(&ssl); mbedtls_ssl_init(&ssl);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_ssl_set_hostname(&ssl, hostname0) == 0); TEST_ASSERT(mbedtls_ssl_set_hostname(&ssl, hostname0) == 0);
TEST_ASSERT(mbedtls_ssl_set_hostname(&ssl, hostname1) == 0); TEST_ASSERT(mbedtls_ssl_set_hostname(&ssl, hostname1) == 0);
exit:
mbedtls_ssl_free(&ssl); mbedtls_ssl_free(&ssl);
USE_PSA_DONE(); USE_PSA_DONE();
} }
@ -1182,11 +1182,11 @@ void ssl_crypt_record(int cipher_type, int hash_id,
size_t const buflen = 512; size_t const buflen = 512;
mbedtls_record rec, rec_backup; mbedtls_record rec, rec_backup;
MD_OR_USE_PSA_INIT();
mbedtls_ssl_init(&ssl); mbedtls_ssl_init(&ssl);
mbedtls_ssl_transform_init(&t0); mbedtls_ssl_transform_init(&t0);
mbedtls_ssl_transform_init(&t1); mbedtls_ssl_transform_init(&t1);
MD_OR_USE_PSA_INIT();
ret = mbedtls_test_ssl_build_transforms(&t0, &t1, cipher_type, hash_id, ret = mbedtls_test_ssl_build_transforms(&t0, &t1, cipher_type, hash_id,
etm, tag_mode, ver, etm, tag_mode, ver,
(size_t) cid0_len, (size_t) cid0_len,
@ -1336,11 +1336,11 @@ void ssl_crypt_record_small(int cipher_type, int hash_id,
int seen_success; /* Indicates if in the current mode we've int seen_success; /* Indicates if in the current mode we've
* already seen a successful test. */ * already seen a successful test. */
MD_OR_USE_PSA_INIT();
mbedtls_ssl_init(&ssl); mbedtls_ssl_init(&ssl);
mbedtls_ssl_transform_init(&t0); mbedtls_ssl_transform_init(&t0);
mbedtls_ssl_transform_init(&t1); mbedtls_ssl_transform_init(&t1);
MD_OR_USE_PSA_INIT();
ret = mbedtls_test_ssl_build_transforms(&t0, &t1, cipher_type, hash_id, ret = mbedtls_test_ssl_build_transforms(&t0, &t1, cipher_type, hash_id,
etm, tag_mode, ver, etm, tag_mode, ver,
(size_t) cid0_len, (size_t) cid0_len,
@ -1497,11 +1497,10 @@ void ssl_decrypt_non_etm_cbc(int cipher_type, int hash_id, int trunc_hmac,
int ret; int ret;
const unsigned char pad_max_len = 255; /* Per the standard */ const unsigned char pad_max_len = 255; /* Per the standard */
MD_OR_USE_PSA_INIT();
mbedtls_ssl_init(&ssl); mbedtls_ssl_init(&ssl);
mbedtls_ssl_transform_init(&t0); mbedtls_ssl_transform_init(&t0);
mbedtls_ssl_transform_init(&t1); mbedtls_ssl_transform_init(&t1);
MD_OR_USE_PSA_INIT();
/* Set up transforms with dummy keys */ /* Set up transforms with dummy keys */
ret = mbedtls_test_ssl_build_transforms(&t0, &t1, cipher_type, hash_id, ret = mbedtls_test_ssl_build_transforms(&t0, &t1, cipher_type, hash_id,
@ -1726,6 +1725,7 @@ void ssl_tls13_hkdf_expand_label(int hash_alg,
ASSERT_COMPARE(dst, (size_t) desired_length, ASSERT_COMPARE(dst, (size_t) desired_length,
expected->x, (size_t) expected->len); expected->x, (size_t) expected->len);
exit:
PSA_DONE(); PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -1779,6 +1779,7 @@ void ssl_tls13_traffic_key_generation(int hash_alg,
expected_server_write_iv->x, expected_server_write_iv->x,
(size_t) desired_iv_len); (size_t) desired_iv_len);
exit:
PSA_DONE(); PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -1823,6 +1824,7 @@ void ssl_tls13_derive_secret(int hash_alg,
ASSERT_COMPARE(dst, desired_length, ASSERT_COMPARE(dst, desired_length,
expected->x, desired_length); expected->x, desired_length);
exit:
PSA_DONE(); PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -1856,6 +1858,7 @@ void ssl_tls13_derive_early_secrets(int hash_alg,
ASSERT_COMPARE(secrets.early_exporter_master_secret, hash_len, ASSERT_COMPARE(secrets.early_exporter_master_secret, hash_len,
exporter_expected->x, exporter_expected->len); exporter_expected->x, exporter_expected->len);
exit:
PSA_DONE(); PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -1889,6 +1892,7 @@ void ssl_tls13_derive_handshake_secrets(int hash_alg,
ASSERT_COMPARE(secrets.server_handshake_traffic_secret, hash_len, ASSERT_COMPARE(secrets.server_handshake_traffic_secret, hash_len,
server_expected->x, server_expected->len); server_expected->x, server_expected->len);
exit:
PSA_DONE(); PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -1926,6 +1930,7 @@ void ssl_tls13_derive_application_secrets(int hash_alg,
ASSERT_COMPARE(secrets.exporter_master_secret, hash_len, ASSERT_COMPARE(secrets.exporter_master_secret, hash_len,
exporter_expected->x, exporter_expected->len); exporter_expected->x, exporter_expected->len);
exit:
PSA_DONE(); PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -1955,6 +1960,7 @@ void ssl_tls13_derive_resumption_secrets(int hash_alg,
ASSERT_COMPARE(secrets.resumption_master_secret, hash_len, ASSERT_COMPARE(secrets.resumption_master_secret, hash_len,
resumption_expected->x, resumption_expected->len); resumption_expected->x, resumption_expected->len);
exit:
PSA_DONE(); PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -1988,6 +1994,7 @@ void ssl_tls13_create_psk_binder(int hash_alg,
ASSERT_COMPARE(binder, hash_len, ASSERT_COMPARE(binder, hash_len,
binder_expected->x, binder_expected->len); binder_expected->x, binder_expected->len);
exit:
PSA_DONE(); PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -2086,6 +2093,7 @@ void ssl_tls13_record_protection(int ciphersuite,
ASSERT_COMPARE(rec.buf + rec.data_offset, rec.data_len, ASSERT_COMPARE(rec.buf + rec.data_offset, rec.data_len,
plaintext->x, plaintext->len); plaintext->x, plaintext->len);
exit:
mbedtls_free(buf); mbedtls_free(buf);
mbedtls_ssl_transform_free(&transform_send); mbedtls_ssl_transform_free(&transform_send);
mbedtls_ssl_transform_free(&transform_recv); mbedtls_ssl_transform_free(&transform_recv);
@ -2112,6 +2120,7 @@ void ssl_tls13_key_evolution(int hash_alg,
ASSERT_COMPARE(secret_new, (size_t) expected->len, ASSERT_COMPARE(secret_new, (size_t) expected->len,
expected->x, (size_t) expected->len); expected->x, (size_t) expected->len);
exit:
PSA_DONE(); PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -2155,9 +2164,9 @@ void ssl_serialize_session_save_load(int ticket_len, char *crt_file,
/* /*
* Test that a save-load pair is the identity * Test that a save-load pair is the identity
*/ */
USE_PSA_INIT();
mbedtls_ssl_session_init(&original); mbedtls_ssl_session_init(&original);
mbedtls_ssl_session_init(&restored); mbedtls_ssl_session_init(&restored);
USE_PSA_INIT();
/* Prepare a dummy session to work on */ /* Prepare a dummy session to work on */
((void) endpoint_type); ((void) endpoint_type);
@ -2304,8 +2313,8 @@ void ssl_serialize_session_load_save(int ticket_len, char *crt_file,
/* /*
* Test that a load-save pair is the identity * Test that a load-save pair is the identity
*/ */
USE_PSA_INIT();
mbedtls_ssl_session_init(&session); mbedtls_ssl_session_init(&session);
USE_PSA_INIT();
/* Prepare a dummy session to work on */ /* Prepare a dummy session to work on */
((void) endpoint_type); ((void) endpoint_type);
@ -2367,8 +2376,8 @@ void ssl_serialize_session_save_buf_size(int ticket_len, char *crt_file,
/* /*
* Test that session_save() fails cleanly on small buffers * Test that session_save() fails cleanly on small buffers
*/ */
USE_PSA_INIT();
mbedtls_ssl_session_init(&session); mbedtls_ssl_session_init(&session);
USE_PSA_INIT();
/* Prepare dummy session and get serialized size */ /* Prepare dummy session and get serialized size */
((void) endpoint_type); ((void) endpoint_type);
@ -2415,8 +2424,8 @@ void ssl_serialize_session_load_buf_size(int ticket_len, char *crt_file,
/* /*
* Test that session_load() fails cleanly on small buffers * Test that session_load() fails cleanly on small buffers
*/ */
USE_PSA_INIT();
mbedtls_ssl_session_init(&session); mbedtls_ssl_session_init(&session);
USE_PSA_INIT();
/* Prepare serialized session data */ /* Prepare serialized session data */
((void) endpoint_type); ((void) endpoint_type);
@ -2476,8 +2485,8 @@ void ssl_session_serialize_version_check(int corrupt_major,
corrupt_config == 1, corrupt_config == 1,
corrupt_config == 1 }; corrupt_config == 1 };
USE_PSA_INIT();
mbedtls_ssl_session_init(&session); mbedtls_ssl_session_init(&session);
USE_PSA_INIT();
((void) endpoint_type); ((void) endpoint_type);
((void) tls_version); ((void) tls_version);
#if defined(MBEDTLS_SSL_PROTO_TLS1_3) #if defined(MBEDTLS_SSL_PROTO_TLS1_3)
@ -2530,6 +2539,7 @@ void ssl_session_serialize_version_check(int corrupt_major,
*byte ^= corrupted_bit; *byte ^= corrupted_bit;
} }
} }
exit:
USE_PSA_DONE(); USE_PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -2697,6 +2707,8 @@ void handshake_cipher(char *cipher, int pk_alg, int dtls)
/* The goto below is used to avoid an "unused label" warning.*/ /* The goto below is used to avoid an "unused label" warning.*/
goto exit; goto exit;
exit:
MD_OR_USE_PSA_DONE(); MD_OR_USE_PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -2906,9 +2918,11 @@ void resize_buffers_serialize_mfl(int mfl)
USE_PSA_INIT(); USE_PSA_INIT();
test_resize_buffers(mfl, 0, MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION, 1, 1, test_resize_buffers(mfl, 0, MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION, 1, 1,
(char *) ""); (char *) "");
USE_PSA_DONE();
/* The goto below is used to avoid an "unused label" warning.*/ /* The goto below is used to avoid an "unused label" warning.*/
goto exit; goto exit;
exit:
USE_PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -2918,9 +2932,11 @@ void resize_buffers_renegotiate_mfl(int mfl, int legacy_renegotiation,
{ {
USE_PSA_INIT(); USE_PSA_INIT();
test_resize_buffers(mfl, 1, legacy_renegotiation, 0, 1, cipher); test_resize_buffers(mfl, 1, legacy_renegotiation, 0, 1, cipher);
USE_PSA_DONE();
/* The goto below is used to avoid an "unused label" warning.*/ /* The goto below is used to avoid an "unused label" warning.*/
goto exit; goto exit;
exit:
USE_PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -2935,8 +2951,8 @@ void test_multiple_psks()
mbedtls_ssl_config conf; mbedtls_ssl_config conf;
MD_OR_USE_PSA_INIT();
mbedtls_ssl_config_init(&conf); mbedtls_ssl_config_init(&conf);
MD_OR_USE_PSA_INIT();
TEST_ASSERT(mbedtls_ssl_conf_psk(&conf, TEST_ASSERT(mbedtls_ssl_conf_psk(&conf,
psk0, sizeof(psk0), psk0, sizeof(psk0),
@ -2947,9 +2963,7 @@ void test_multiple_psks()
MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE); MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE);
exit: exit:
mbedtls_ssl_config_free(&conf); mbedtls_ssl_config_free(&conf);
MD_OR_USE_PSA_DONE(); MD_OR_USE_PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -2979,8 +2993,8 @@ void test_multiple_psks_opaque(int mode)
mbedtls_ssl_config conf; mbedtls_ssl_config conf;
MD_OR_USE_PSA_INIT();
mbedtls_ssl_config_init(&conf); mbedtls_ssl_config_init(&conf);
MD_OR_USE_PSA_INIT();
switch (mode) { switch (mode) {
case 0: case 0:
@ -3031,7 +3045,6 @@ void test_multiple_psks_opaque(int mode)
} }
exit: exit:
mbedtls_ssl_config_free(&conf); mbedtls_ssl_config_free(&conf);
MD_OR_USE_PSA_DONE(); MD_OR_USE_PSA_DONE();
@ -3046,10 +3059,9 @@ void conf_version(int endpoint, int transport,
mbedtls_ssl_config conf; mbedtls_ssl_config conf;
mbedtls_ssl_context ssl; mbedtls_ssl_context ssl;
MD_OR_USE_PSA_INIT();
mbedtls_ssl_config_init(&conf); mbedtls_ssl_config_init(&conf);
mbedtls_ssl_init(&ssl); mbedtls_ssl_init(&ssl);
MD_OR_USE_PSA_INIT();
mbedtls_ssl_conf_endpoint(&conf, endpoint); mbedtls_ssl_conf_endpoint(&conf, endpoint);
mbedtls_ssl_conf_transport(&conf, transport); mbedtls_ssl_conf_transport(&conf, transport);
@ -3090,10 +3102,10 @@ void conf_curve()
#endif #endif
mbedtls_ssl_conf_curves(&conf, curve_list); mbedtls_ssl_conf_curves(&conf, curve_list);
MD_OR_USE_PSA_INIT();
mbedtls_ssl_context ssl; mbedtls_ssl_context ssl;
mbedtls_ssl_init(&ssl); mbedtls_ssl_init(&ssl);
MD_OR_USE_PSA_INIT();
TEST_ASSERT(mbedtls_ssl_setup(&ssl, &conf) == 0); TEST_ASSERT(mbedtls_ssl_setup(&ssl, &conf) == 0);
TEST_ASSERT(ssl.handshake != NULL && ssl.handshake->group_list != NULL); TEST_ASSERT(ssl.handshake != NULL && ssl.handshake->group_list != NULL);
@ -3107,7 +3119,6 @@ void conf_curve()
TEST_EQUAL(iana_tls_group_list[i], ssl.handshake->group_list[i]); TEST_EQUAL(iana_tls_group_list[i], ssl.handshake->group_list[i]);
} }
exit: exit:
mbedtls_ssl_free(&ssl); mbedtls_ssl_free(&ssl);
mbedtls_ssl_config_free(&conf); mbedtls_ssl_config_free(&conf);
@ -3131,10 +3142,10 @@ void conf_group()
mbedtls_ssl_conf_groups(&conf, iana_tls_group_list); mbedtls_ssl_conf_groups(&conf, iana_tls_group_list);
MD_OR_USE_PSA_INIT();
mbedtls_ssl_context ssl; mbedtls_ssl_context ssl;
mbedtls_ssl_init(&ssl); mbedtls_ssl_init(&ssl);
MD_OR_USE_PSA_INIT();
TEST_ASSERT(mbedtls_ssl_setup(&ssl, &conf) == 0); TEST_ASSERT(mbedtls_ssl_setup(&ssl, &conf) == 0);
TEST_ASSERT(ssl.conf != NULL && ssl.conf->group_list != NULL); TEST_ASSERT(ssl.conf != NULL && ssl.conf->group_list != NULL);
@ -3227,9 +3238,10 @@ void cookie_parsing(data_t *cookie, int exp_ret)
mbedtls_ssl_config conf; mbedtls_ssl_config conf;
size_t len; size_t len;
USE_PSA_INIT();
mbedtls_ssl_init(&ssl); mbedtls_ssl_init(&ssl);
mbedtls_ssl_config_init(&conf); mbedtls_ssl_config_init(&conf);
USE_PSA_INIT();
TEST_EQUAL(mbedtls_ssl_config_defaults(&conf, MBEDTLS_SSL_IS_SERVER, TEST_EQUAL(mbedtls_ssl_config_defaults(&conf, MBEDTLS_SSL_IS_SERVER,
MBEDTLS_SSL_TRANSPORT_DATAGRAM, MBEDTLS_SSL_TRANSPORT_DATAGRAM,
MBEDTLS_SSL_PRESET_DEFAULT), MBEDTLS_SSL_PRESET_DEFAULT),
@ -3244,6 +3256,7 @@ void cookie_parsing(data_t *cookie, int exp_ret)
&len), &len),
exp_ret); exp_ret);
exit:
mbedtls_ssl_free(&ssl); mbedtls_ssl_free(&ssl);
mbedtls_ssl_config_free(&conf); mbedtls_ssl_config_free(&conf);
USE_PSA_DONE(); USE_PSA_DONE();
@ -3259,6 +3272,8 @@ void timing_final_delay_accessor()
mbedtls_timing_set_delay(&delay_context, 50, 100); mbedtls_timing_set_delay(&delay_context, 50, 100);
TEST_ASSERT(mbedtls_timing_get_final_delay(&delay_context) == 100); TEST_ASSERT(mbedtls_timing_get_final_delay(&delay_context) == 100);
exit:
USE_PSA_DONE(); USE_PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -3276,10 +3291,9 @@ void cid_sanity()
mbedtls_test_rnd_std_rand(NULL, own_cid, sizeof(own_cid)); mbedtls_test_rnd_std_rand(NULL, own_cid, sizeof(own_cid));
MD_OR_USE_PSA_INIT();
mbedtls_ssl_init(&ssl); mbedtls_ssl_init(&ssl);
mbedtls_ssl_config_init(&conf); mbedtls_ssl_config_init(&conf);
MD_OR_USE_PSA_INIT();
TEST_ASSERT(mbedtls_ssl_config_defaults(&conf, TEST_ASSERT(mbedtls_ssl_config_defaults(&conf,
MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_IS_CLIENT,
@ -3435,11 +3449,12 @@ void tls13_server_certificate_msg_invalid_vector_len()
/* /*
* Test set-up * Test set-up
*/ */
MD_OR_USE_PSA_INIT();
mbedtls_platform_zeroize(&client_ep, sizeof(client_ep)); mbedtls_platform_zeroize(&client_ep, sizeof(client_ep));
mbedtls_platform_zeroize(&server_ep, sizeof(server_ep)); mbedtls_platform_zeroize(&server_ep, sizeof(server_ep));
mbedtls_test_init_handshake_options(&client_options); mbedtls_test_init_handshake_options(&client_options);
MD_OR_USE_PSA_INIT();
client_options.pk_alg = MBEDTLS_PK_ECDSA; client_options.pk_alg = MBEDTLS_PK_ECDSA;
ret = mbedtls_test_ssl_endpoint_init(&client_ep, MBEDTLS_SSL_IS_CLIENT, ret = mbedtls_test_ssl_endpoint_init(&client_ep, MBEDTLS_SSL_IS_CLIENT,
&client_options, NULL, NULL, NULL, &client_options, NULL, NULL, NULL,
@ -3530,9 +3545,8 @@ void ssl_ecjpake_set_password(int use_opaque_arg)
size_t pwd_len = 0; size_t pwd_len = 0;
int ret; int ret;
MD_OR_USE_PSA_INIT();
mbedtls_ssl_init(&ssl); mbedtls_ssl_init(&ssl);
MD_OR_USE_PSA_INIT();
/* test with uninitalized SSL context */ /* test with uninitalized SSL context */
ECJPAKE_TEST_SET_PASSWORD(MBEDTLS_ERR_SSL_BAD_INPUT_DATA); ECJPAKE_TEST_SET_PASSWORD(MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
@ -3669,7 +3683,8 @@ void elliptic_curve_get_properties()
#else #else
TEST_UNAVAILABLE_ECC(30, MBEDTLS_ECP_DP_CURVE448, PSA_ECC_FAMILY_MONTGOMERY, 448); TEST_UNAVAILABLE_ECC(30, MBEDTLS_ECP_DP_CURVE448, PSA_ECC_FAMILY_MONTGOMERY, 448);
#endif #endif
goto exit;
exit:
MD_OR_USE_PSA_DONE(); MD_OR_USE_PSA_DONE();
} }
/* END_CASE */ /* END_CASE */

68
tests/suites/test_suite_x509parse.function
View File

@ -428,13 +428,14 @@ void x509_accessor_ext_types(int ext_type, int has_ext_type)
mbedtls_x509_crt crt; mbedtls_x509_crt crt;
int expected_result = ext_type & has_ext_type; int expected_result = ext_type & has_ext_type;
USE_PSA_INIT();
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
USE_PSA_INIT();
crt.ext_types = ext_type; crt.ext_types = ext_type;
TEST_ASSERT(mbedtls_x509_crt_has_ext_type(&crt, has_ext_type) == expected_result); TEST_ASSERT(mbedtls_x509_crt_has_ext_type(&crt, has_ext_type) == expected_result);
exit:
mbedtls_x509_crt_free(&crt); mbedtls_x509_crt_free(&crt);
USE_PSA_DONE(); USE_PSA_DONE();
} }
@ -464,8 +465,8 @@ void x509_parse_san(char *crt_file, char *result_str, int parse_result)
char *p = buf; char *p = buf;
size_t n = sizeof(buf); size_t n = sizeof(buf);
USE_PSA_INIT();
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
USE_PSA_INIT();
memset(buf, 0, 2000); memset(buf, 0, 2000);
TEST_EQUAL(mbedtls_x509_crt_parse_file(&crt, crt_file), parse_result); TEST_EQUAL(mbedtls_x509_crt_parse_file(&crt, crt_file), parse_result);
@ -493,7 +494,6 @@ void x509_parse_san(char *crt_file, char *result_str, int parse_result)
TEST_ASSERT(strcmp(buf, result_str) == 0); TEST_ASSERT(strcmp(buf, result_str) == 0);
exit: exit:
mbedtls_x509_crt_free(&crt); mbedtls_x509_crt_free(&crt);
USE_PSA_DONE(); USE_PSA_DONE();
} }
@ -506,8 +506,8 @@ void x509_cert_info(char *crt_file, char *result_str)
char buf[2000]; char buf[2000];
int res; int res;
USE_PSA_INIT();
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
USE_PSA_INIT();
memset(buf, 0, 2000); memset(buf, 0, 2000);
TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0); TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
@ -531,8 +531,8 @@ void mbedtls_x509_crl_info(char *crl_file, char *result_str)
char buf[2000]; char buf[2000];
int res; int res;
USE_PSA_INIT();
mbedtls_x509_crl_init(&crl); mbedtls_x509_crl_init(&crl);
USE_PSA_INIT();
memset(buf, 0, 2000); memset(buf, 0, 2000);
TEST_ASSERT(mbedtls_x509_crl_parse_file(&crl, crl_file) == 0); TEST_ASSERT(mbedtls_x509_crl_parse_file(&crl, crl_file) == 0);
@ -555,8 +555,8 @@ void mbedtls_x509_crl_parse(char *crl_file, int result)
mbedtls_x509_crl crl; mbedtls_x509_crl crl;
char buf[2000]; char buf[2000];
USE_PSA_INIT();
mbedtls_x509_crl_init(&crl); mbedtls_x509_crl_init(&crl);
USE_PSA_INIT();
memset(buf, 0, 2000); memset(buf, 0, 2000);
TEST_ASSERT(mbedtls_x509_crl_parse_file(&crl, crl_file) == result); TEST_ASSERT(mbedtls_x509_crl_parse_file(&crl, crl_file) == result);
@ -574,8 +574,8 @@ void mbedtls_x509_csr_info(char *csr_file, char *result_str)
char buf[2000]; char buf[2000];
int res; int res;
USE_PSA_INIT();
mbedtls_x509_csr_init(&csr); mbedtls_x509_csr_init(&csr);
USE_PSA_INIT();
memset(buf, 0, 2000); memset(buf, 0, 2000);
TEST_ASSERT(mbedtls_x509_csr_parse_file(&csr, csr_file) == 0); TEST_ASSERT(mbedtls_x509_csr_parse_file(&csr, csr_file) == 0);
@ -606,6 +606,8 @@ void x509_verify_info(int flags, char *prefix, char *result_str)
TEST_ASSERT(res >= 0); TEST_ASSERT(res >= 0);
TEST_ASSERT(strcmp(buf, result_str) == 0); TEST_ASSERT(strcmp(buf, result_str) == 0);
exit:
USE_PSA_DONE(); USE_PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -630,10 +632,10 @@ void x509_verify_restart(char *crt_file, char *ca_file,
* - x509_verify() for server5 -> test-ca2: ~ 18800 * - x509_verify() for server5 -> test-ca2: ~ 18800
* - x509_verify() for server10 -> int-ca3 -> int-ca2: ~ 25500 * - x509_verify() for server10 -> int-ca3 -> int-ca2: ~ 25500
*/ */
MD_OR_USE_PSA_INIT();
mbedtls_x509_crt_restart_init(&rs_ctx); mbedtls_x509_crt_restart_init(&rs_ctx);
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
mbedtls_x509_crt_init(&ca); mbedtls_x509_crt_init(&ca);
MD_OR_USE_PSA_INIT();
TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0); TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
TEST_ASSERT(mbedtls_x509_crt_parse_file(&ca, ca_file) == 0); TEST_ASSERT(mbedtls_x509_crt_parse_file(&ca, ca_file) == 0);
@ -682,10 +684,10 @@ void x509_verify(char *crt_file, char *ca_file, char *crl_file,
char *cn_name = NULL; char *cn_name = NULL;
const mbedtls_x509_crt_profile *profile; const mbedtls_x509_crt_profile *profile;
MD_OR_USE_PSA_INIT();
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
mbedtls_x509_crt_init(&ca); mbedtls_x509_crt_init(&ca);
mbedtls_x509_crl_init(&crl); mbedtls_x509_crl_init(&crl);
MD_OR_USE_PSA_INIT();
if (strcmp(cn_name_str, "NULL") != 0) { if (strcmp(cn_name_str, "NULL") != 0) {
cn_name = cn_name_str; cn_name = cn_name_str;
@ -767,9 +769,9 @@ void x509_verify_ca_cb_failure(char *crt_file, char *ca_file, char *name,
mbedtls_x509_crt ca; mbedtls_x509_crt ca;
uint32_t flags = 0; uint32_t flags = 0;
USE_PSA_INIT();
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
mbedtls_x509_crt_init(&ca); mbedtls_x509_crt_init(&ca);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0); TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
TEST_ASSERT(mbedtls_x509_crt_parse_file(&ca, ca_file) == 0); TEST_ASSERT(mbedtls_x509_crt_parse_file(&ca, ca_file) == 0);
@ -801,9 +803,10 @@ void x509_verify_callback(char *crt_file, char *ca_file, char *name,
uint32_t flags = 0; uint32_t flags = 0;
verify_print_context vrfy_ctx; verify_print_context vrfy_ctx;
MD_OR_USE_PSA_INIT();
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
mbedtls_x509_crt_init(&ca); mbedtls_x509_crt_init(&ca);
MD_OR_USE_PSA_INIT();
verify_print_init(&vrfy_ctx); verify_print_init(&vrfy_ctx);
TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0); TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
@ -838,8 +841,9 @@ void mbedtls_x509_dn_gets_subject_replace(char *crt_file,
char buf[2000]; char buf[2000];
int res = 0; int res = 0;
USE_PSA_INIT();
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
USE_PSA_INIT();
memset(buf, 0, 2000); memset(buf, 0, 2000);
TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0); TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
@ -868,8 +872,9 @@ void mbedtls_x509_dn_gets(char *crt_file, char *entity, char *result_str)
char buf[2000]; char buf[2000];
int res = 0; int res = 0;
USE_PSA_INIT();
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
USE_PSA_INIT();
memset(buf, 0, 2000); memset(buf, 0, 2000);
TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0); TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
@ -914,6 +919,7 @@ void mbedtls_x509_get_name(char *rdn_sequence, int exp_ret)
TEST_EQUAL(ret, exp_ret); TEST_EQUAL(ret, exp_ret);
exit:
mbedtls_free(name); mbedtls_free(name);
USE_PSA_DONE(); USE_PSA_DONE();
} }
@ -992,8 +998,8 @@ void mbedtls_x509_time_is_past(char *crt_file, char *entity, int result)
{ {
mbedtls_x509_crt crt; mbedtls_x509_crt crt;
USE_PSA_INIT();
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0); TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
@ -1016,8 +1022,8 @@ void mbedtls_x509_time_is_future(char *crt_file, char *entity, int result)
{ {
mbedtls_x509_crt crt; mbedtls_x509_crt crt;
USE_PSA_INIT();
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0); TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
@ -1040,8 +1046,8 @@ void x509parse_crt_file(char *crt_file, int result)
{ {
mbedtls_x509_crt crt; mbedtls_x509_crt crt;
USE_PSA_INIT();
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == result); TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == result);
@ -1062,8 +1068,8 @@ void x509parse_crt(data_t *buf, char *result_str, int result)
((void) result_str); ((void) result_str);
#endif #endif
USE_PSA_INIT();
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_x509_crt_parse_der(&crt, buf->x, buf->len) == (result)); TEST_ASSERT(mbedtls_x509_crt_parse_der(&crt, buf->x, buf->len) == (result));
#if !defined(MBEDTLS_X509_REMOVE_INFO) #if !defined(MBEDTLS_X509_REMOVE_INFO)
@ -1147,12 +1153,12 @@ void x509parse_crt_cb(data_t *buf, char *result_str, int result)
((void) result_str); ((void) result_str);
#endif #endif
USE_PSA_INIT();
oid.tag = MBEDTLS_ASN1_OID; oid.tag = MBEDTLS_ASN1_OID;
oid.len = MBEDTLS_OID_SIZE(MBEDTLS_OID_PKIX "\x01\x1F"); oid.len = MBEDTLS_OID_SIZE(MBEDTLS_OID_PKIX "\x01\x1F");
oid.p = (unsigned char *) MBEDTLS_OID_PKIX "\x01\x1F"; oid.p = (unsigned char *) MBEDTLS_OID_PKIX "\x01\x1F";
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_x509_crt_parse_der_with_ext_cb(&crt, buf->x, buf->len, 0, parse_crt_ext_cb, TEST_ASSERT(mbedtls_x509_crt_parse_der_with_ext_cb(&crt, buf->x, buf->len, 0, parse_crt_ext_cb,
&oid) == (result)); &oid) == (result));
@ -1197,8 +1203,9 @@ void x509parse_crl(data_t *buf, char *result_str, int result)
unsigned char output[2000]; unsigned char output[2000];
int res; int res;
USE_PSA_INIT();
mbedtls_x509_crl_init(&crl); mbedtls_x509_crl_init(&crl);
USE_PSA_INIT();
memset(output, 0, 2000); memset(output, 0, 2000);
@ -1225,8 +1232,9 @@ void mbedtls_x509_csr_parse(data_t *csr_der, char *ref_out, int ref_ret)
char my_out[1000]; char my_out[1000];
int my_ret; int my_ret;
USE_PSA_INIT();
mbedtls_x509_csr_init(&csr); mbedtls_x509_csr_init(&csr);
USE_PSA_INIT();
memset(my_out, 0, sizeof(my_out)); memset(my_out, 0, sizeof(my_out));
my_ret = mbedtls_x509_csr_parse_der(&csr, csr_der->x, csr_der->len); my_ret = mbedtls_x509_csr_parse_der(&csr, csr_der->x, csr_der->len);
@ -1251,8 +1259,9 @@ void mbedtls_x509_csr_parse_file(char *csr_file, char *ref_out, int ref_ret)
char my_out[1000]; char my_out[1000];
int my_ret; int my_ret;
USE_PSA_INIT();
mbedtls_x509_csr_init(&csr); mbedtls_x509_csr_init(&csr);
USE_PSA_INIT();
memset(my_out, 0, sizeof(my_out)); memset(my_out, 0, sizeof(my_out));
my_ret = mbedtls_x509_csr_parse_file(&csr, csr_file); my_ret = mbedtls_x509_csr_parse_file(&csr, csr_file);
@ -1276,8 +1285,8 @@ void mbedtls_x509_crt_parse_path(char *crt_path, int ret, int nb_crt)
mbedtls_x509_crt chain, *cur; mbedtls_x509_crt chain, *cur;
int i; int i;
USE_PSA_INIT();
mbedtls_x509_crt_init(&chain); mbedtls_x509_crt_init(&chain);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_x509_crt_parse_path(&chain, crt_path) == ret); TEST_ASSERT(mbedtls_x509_crt_parse_path(&chain, crt_path) == ret);
@ -1309,9 +1318,9 @@ void mbedtls_x509_crt_verify_max(char *ca_file, char *chain_dir, int nb_int,
* We expect chain_dir to contain certificates 00.crt, 01.crt, etc. * We expect chain_dir to contain certificates 00.crt, 01.crt, etc.
* with NN.crt signed by NN-1.crt * with NN.crt signed by NN-1.crt
*/ */
MD_OR_USE_PSA_INIT();
mbedtls_x509_crt_init(&trusted); mbedtls_x509_crt_init(&trusted);
mbedtls_x509_crt_init(&chain); mbedtls_x509_crt_init(&chain);
MD_OR_USE_PSA_INIT();
/* Load trusted root */ /* Load trusted root */
TEST_ASSERT(mbedtls_x509_crt_parse_file(&trusted, ca_file) == 0); TEST_ASSERT(mbedtls_x509_crt_parse_file(&trusted, ca_file) == 0);
@ -1347,9 +1356,9 @@ void mbedtls_x509_crt_verify_chain(char *chain_paths, char *trusted_ca,
mbedtls_x509_crt trusted, chain; mbedtls_x509_crt trusted, chain;
const mbedtls_x509_crt_profile *profile = NULL; const mbedtls_x509_crt_profile *profile = NULL;
MD_OR_USE_PSA_INIT();
mbedtls_x509_crt_init(&chain); mbedtls_x509_crt_init(&chain);
mbedtls_x509_crt_init(&trusted); mbedtls_x509_crt_init(&trusted);
MD_OR_USE_PSA_INIT();
while ((act = mystrsep(&chain_paths, " ")) != NULL) { while ((act = mystrsep(&chain_paths, " ")) != NULL) {
TEST_ASSERT(mbedtls_x509_crt_parse_file(&chain, act) == 0); TEST_ASSERT(mbedtls_x509_crt_parse_file(&chain, act) == 0);
@ -1389,6 +1398,7 @@ void x509_oid_desc(data_t *buf, char *ref_desc)
int ret; int ret;
USE_PSA_INIT(); USE_PSA_INIT();
oid.tag = MBEDTLS_ASN1_OID; oid.tag = MBEDTLS_ASN1_OID;
oid.p = buf->x; oid.p = buf->x;
oid.len = buf->len; oid.len = buf->len;
@ -1403,6 +1413,8 @@ void x509_oid_desc(data_t *buf, char *ref_desc)
TEST_ASSERT(desc != NULL); TEST_ASSERT(desc != NULL);
TEST_ASSERT(strcmp(desc, ref_desc) == 0); TEST_ASSERT(strcmp(desc, ref_desc) == 0);
} }
exit:
USE_PSA_DONE(); USE_PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -1414,6 +1426,7 @@ void x509_oid_numstr(data_t *oid_buf, char *numstr, int blen, int ret)
char num_buf[100]; char num_buf[100];
USE_PSA_INIT(); USE_PSA_INIT();
memset(num_buf, 0x2a, sizeof(num_buf)); memset(num_buf, 0x2a, sizeof(num_buf));
oid.tag = MBEDTLS_ASN1_OID; oid.tag = MBEDTLS_ASN1_OID;
@ -1428,6 +1441,8 @@ void x509_oid_numstr(data_t *oid_buf, char *numstr, int blen, int ret)
TEST_ASSERT(num_buf[ret] == 0); TEST_ASSERT(num_buf[ret] == 0);
TEST_ASSERT(strcmp(num_buf, numstr) == 0); TEST_ASSERT(strcmp(num_buf, numstr) == 0);
} }
exit:
USE_PSA_DONE(); USE_PSA_DONE();
} }
/* END_CASE */ /* END_CASE */
@ -1437,8 +1452,8 @@ void x509_check_key_usage(char *crt_file, int usage, int ret)
{ {
mbedtls_x509_crt crt; mbedtls_x509_crt crt;
USE_PSA_INIT();
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0); TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
@ -1456,8 +1471,8 @@ void x509_check_extended_key_usage(char *crt_file, data_t *oid, int ret
{ {
mbedtls_x509_crt crt; mbedtls_x509_crt crt;
USE_PSA_INIT();
mbedtls_x509_crt_init(&crt); mbedtls_x509_crt_init(&crt);
USE_PSA_INIT();
TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0); TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
@ -1497,6 +1512,7 @@ void x509_get_time(int tag, char *time_str, int ret, int year, int mon,
TEST_ASSERT(min == time.min); TEST_ASSERT(min == time.min);
TEST_ASSERT(sec == time.sec); TEST_ASSERT(sec == time.sec);
} }
exit:
USE_PSA_DONE(); USE_PSA_DONE();
} }
/* END_CASE */ /* END_CASE */

12
tests/suites/test_suite_x509write.function
View File

@ -159,8 +159,6 @@ void x509_csr_check(char *key_file, char *cert_req_check_file, int md_type,
const char *san_dns_name = "example.com"; const char *san_dns_name = "example.com";
const char *san_uri_name = "http://pki.example.com/"; const char *san_uri_name = "http://pki.example.com/";
MD_OR_USE_PSA_INIT();
san_uri.node.type = MBEDTLS_X509_SAN_UNIFORM_RESOURCE_IDENTIFIER; san_uri.node.type = MBEDTLS_X509_SAN_UNIFORM_RESOURCE_IDENTIFIER;
san_uri.node.san.unstructured_name.p = (unsigned char *) san_uri_name; san_uri.node.san.unstructured_name.p = (unsigned char *) san_uri_name;
san_uri.node.san.unstructured_name.len = strlen(san_uri_name); san_uri.node.san.unstructured_name.len = strlen(san_uri_name);
@ -178,8 +176,9 @@ void x509_csr_check(char *key_file, char *cert_req_check_file, int md_type,
memset(&rnd_info, 0x2a, sizeof(mbedtls_test_rnd_pseudo_info)); memset(&rnd_info, 0x2a, sizeof(mbedtls_test_rnd_pseudo_info));
mbedtls_x509write_csr_init(&req); mbedtls_x509write_csr_init(&req);
mbedtls_pk_init(&key); mbedtls_pk_init(&key);
MD_OR_USE_PSA_INIT();
TEST_ASSERT(mbedtls_pk_parse_keyfile(&key, key_file, NULL, TEST_ASSERT(mbedtls_pk_parse_keyfile(&key, key_file, NULL,
mbedtls_test_rnd_std_rand, NULL) == 0); mbedtls_test_rnd_std_rand, NULL) == 0);
@ -266,12 +265,11 @@ void x509_csr_check_opaque(char *key_file, int md_type, int key_usage,
const char *subject_name = "C=NL,O=PolarSSL,CN=PolarSSL Server 1"; const char *subject_name = "C=NL,O=PolarSSL,CN=PolarSSL Server 1";
mbedtls_test_rnd_pseudo_info rnd_info; mbedtls_test_rnd_pseudo_info rnd_info;
mbedtls_x509write_csr_init(&req);
MD_OR_USE_PSA_INIT(); MD_OR_USE_PSA_INIT();
memset(&rnd_info, 0x2a, sizeof(mbedtls_test_rnd_pseudo_info)); memset(&rnd_info, 0x2a, sizeof(mbedtls_test_rnd_pseudo_info));
mbedtls_x509write_csr_init(&req);
md_alg_psa = mbedtls_hash_info_psa_from_md((mbedtls_md_type_t) md_type); md_alg_psa = mbedtls_hash_info_psa_from_md((mbedtls_md_type_t) md_type);
TEST_ASSERT(md_alg_psa != MBEDTLS_MD_NONE); TEST_ASSERT(md_alg_psa != MBEDTLS_MD_NONE);
@ -351,8 +349,6 @@ void x509_crt_check(char *subject_key_file, char *subject_pwd,
#endif #endif
mbedtls_pk_type_t issuer_key_type; mbedtls_pk_type_t issuer_key_type;
MD_OR_USE_PSA_INIT();
memset(&rnd_info, 0x2a, sizeof(mbedtls_test_rnd_pseudo_info)); memset(&rnd_info, 0x2a, sizeof(mbedtls_test_rnd_pseudo_info));
#if defined(MBEDTLS_TEST_DEPRECATED) && defined(MBEDTLS_BIGNUM_C) #if defined(MBEDTLS_TEST_DEPRECATED) && defined(MBEDTLS_BIGNUM_C)
mbedtls_mpi_init(&serial_mpi); mbedtls_mpi_init(&serial_mpi);
@ -361,8 +357,8 @@ void x509_crt_check(char *subject_key_file, char *subject_pwd,
mbedtls_pk_init(&subject_key); mbedtls_pk_init(&subject_key);
mbedtls_pk_init(&issuer_key); mbedtls_pk_init(&issuer_key);
mbedtls_pk_init(&issuer_key_alt); mbedtls_pk_init(&issuer_key_alt);
mbedtls_x509write_crt_init(&crt); mbedtls_x509write_crt_init(&crt);
MD_OR_USE_PSA_INIT();
TEST_ASSERT(mbedtls_pk_parse_keyfile(&subject_key, subject_key_file, TEST_ASSERT(mbedtls_pk_parse_keyfile(&subject_key, subject_key_file,
subject_pwd, mbedtls_test_rnd_std_rand, NULL) == 0); subject_pwd, mbedtls_test_rnd_std_rand, NULL) == 0);