cuberite/polarssl
1
0
Fork 0
mirror of https://github.com/cuberite/polarssl.git synced 2025-09-08 14:49:59 -04:00
Code Issues Packages Projects Releases Wiki Activity

Fix code style

Browse Source 
Signed-off-by: Tom Cosgrove <tom.cosgrove@arm.com>
This commit is contained in:
Tom Cosgrove 2023-09-04 11:29:39 +01:00
parent ba3b14dad9
commit a240fe3c19
18 changed files with 108 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
tests/suites/test_suite_aria.function
View File

@ -225,7 +225,7 @@ void aria_encrypt_ecb(data_t *key_str, data_t *src_str,
} }
TEST_MEMORY_COMPARE(output, expected_output->len, TEST_MEMORY_COMPARE(output, expected_output->len,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
} }
exit: exit:
@ -253,7 +253,7 @@ void aria_decrypt_ecb(data_t *key_str, data_t *src_str,
} }
TEST_MEMORY_COMPARE(output, expected_output->len, TEST_MEMORY_COMPARE(output, expected_output->len,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
} }
exit: exit:
@ -278,7 +278,7 @@ void aria_encrypt_cbc(data_t *key_str, data_t *iv_str,
output) == cbc_result); output) == cbc_result);
if (cbc_result == 0) { if (cbc_result == 0) {
TEST_MEMORY_COMPARE(output, expected_output->len, TEST_MEMORY_COMPARE(output, expected_output->len,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
} }
exit: exit:
@ -303,7 +303,7 @@ void aria_decrypt_cbc(data_t *key_str, data_t *iv_str,
output) == cbc_result); output) == cbc_result);
if (cbc_result == 0) { if (cbc_result == 0) {
TEST_MEMORY_COMPARE(output, expected_output->len, TEST_MEMORY_COMPARE(output, expected_output->len,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
} }
exit: exit:
@ -330,7 +330,7 @@ void aria_encrypt_cfb128(data_t *key_str, data_t *iv_str,
== result); == result);
TEST_MEMORY_COMPARE(output, expected_output->len, TEST_MEMORY_COMPARE(output, expected_output->len,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
exit: exit:
mbedtls_aria_free(&ctx); mbedtls_aria_free(&ctx);
@ -356,7 +356,7 @@ void aria_decrypt_cfb128(data_t *key_str, data_t *iv_str,
== result); == result);
TEST_MEMORY_COMPARE(output, expected_output->len, TEST_MEMORY_COMPARE(output, expected_output->len,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
exit: exit:
mbedtls_aria_free(&ctx); mbedtls_aria_free(&ctx);
@ -382,7 +382,7 @@ void aria_encrypt_ctr(data_t *key_str, data_t *iv_str,
== result); == result);
TEST_MEMORY_COMPARE(output, expected_output->len, TEST_MEMORY_COMPARE(output, expected_output->len,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
exit: exit:
mbedtls_aria_free(&ctx); mbedtls_aria_free(&ctx);
@ -408,7 +408,7 @@ void aria_decrypt_ctr(data_t *key_str, data_t *iv_str,
== result); == result);
TEST_MEMORY_COMPARE(output, expected_output->len, TEST_MEMORY_COMPARE(output, expected_output->len,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
exit: exit:
mbedtls_aria_free(&ctx); mbedtls_aria_free(&ctx);

8
tests/suites/test_suite_asn1write.function
View File

@ -38,7 +38,7 @@ int generic_write_finish_step(generic_write_data_t *data,
TEST_ASSERT(data->p >= data->start); TEST_ASSERT(data->p >= data->start);
TEST_ASSERT(data->p <= data->end); TEST_ASSERT(data->p <= data->end);
TEST_MEMORY_COMPARE(data->p, (size_t) (data->end - data->p), TEST_MEMORY_COMPARE(data->p, (size_t) (data->end - data->p),
expected->x, expected->len); expected->x, expected->len);
} }
ok = 1; ok = 1;
@ -441,7 +441,7 @@ void test_asn1_write_bitstrings(data_t *bitstring, int bits,
TEST_EQUAL(mbedtls_asn1_get_bitstring(&data.p, data.end, TEST_EQUAL(mbedtls_asn1_get_bitstring(&data.p, data.end,
&read), 0); &read), 0);
TEST_MEMORY_COMPARE(read.p, read.len, TEST_MEMORY_COMPARE(read.p, read.len,
masked_bitstring, byte_length); masked_bitstring, byte_length);
TEST_EQUAL(read.unused_bits, 8 * byte_length - value_bits); TEST_EQUAL(read.unused_bits, 8 * byte_length - value_bits);
} }
#endif /* MBEDTLS_ASN1_PARSE_C */ #endif /* MBEDTLS_ASN1_PARSE_C */
@ -546,7 +546,7 @@ void store_named_data_val_found(int old_len, int new_len)
if (new_val != NULL) { if (new_val != NULL) {
TEST_MEMORY_COMPARE(found->val.p, found->val.len, TEST_MEMORY_COMPARE(found->val.p, found->val.len,
new_val, (size_t) new_len); new_val, (size_t) new_len);
} }
if (new_len == 0) { if (new_len == 0) {
TEST_ASSERT(found->val.p == NULL); TEST_ASSERT(found->val.p == NULL);
@ -588,7 +588,7 @@ void store_named_data_val_new(int new_len, int set_new_val)
} else { } else {
TEST_ASSERT(found->val.p != new_val); TEST_ASSERT(found->val.p != new_val);
TEST_MEMORY_COMPARE(found->val.p, found->val.len, TEST_MEMORY_COMPARE(found->val.p, found->val.len,
new_val, (size_t) new_len); new_val, (size_t) new_len);
} }
exit: exit:

6
tests/suites/test_suite_chacha20.function
View File

@ -30,7 +30,7 @@ void chacha20_crypt(data_t *key_str,
output) == 0); output) == 0);
TEST_MEMORY_COMPARE(output, expected_output_str->len, TEST_MEMORY_COMPARE(output, expected_output_str->len,
expected_output_str->x, expected_output_str->len); expected_output_str->x, expected_output_str->len);
/* /*
* Test the streaming API * Test the streaming API
@ -45,7 +45,7 @@ void chacha20_crypt(data_t *key_str,
TEST_ASSERT(mbedtls_chacha20_update(&ctx, src_str->len, src_str->x, output) == 0); TEST_ASSERT(mbedtls_chacha20_update(&ctx, src_str->len, src_str->x, output) == 0);
TEST_MEMORY_COMPARE(output, expected_output_str->len, TEST_MEMORY_COMPARE(output, expected_output_str->len,
expected_output_str->x, expected_output_str->len); expected_output_str->x, expected_output_str->len);
/* /*
* Test the streaming API again, piecewise * Test the streaming API again, piecewise
@ -61,7 +61,7 @@ void chacha20_crypt(data_t *key_str,
src_str->x + 1, output + 1) == 0); src_str->x + 1, output + 1) == 0);
TEST_MEMORY_COMPARE(output, expected_output_str->len, TEST_MEMORY_COMPARE(output, expected_output_str->len,
expected_output_str->x, expected_output_str->len); expected_output_str->x, expected_output_str->len);
mbedtls_chacha20_free(&ctx); mbedtls_chacha20_free(&ctx);
} }

8
tests/suites/test_suite_ecp.function
View File

@ -853,7 +853,7 @@ void ecp_muladd(int id,
TEST_ASSERT(len <= MBEDTLS_ECP_MAX_PT_LEN); TEST_ASSERT(len <= MBEDTLS_ECP_MAX_PT_LEN);
TEST_MEMORY_COMPARE(expected_result->x, expected_result->len, TEST_MEMORY_COMPARE(expected_result->x, expected_result->len,
actual_result, len); actual_result, len);
exit: exit:
mbedtls_ecp_group_free(&grp); mbedtls_ecp_group_free(&grp);
@ -1357,7 +1357,7 @@ void mbedtls_ecp_read_key(int grp_id, data_t *in_key, int expected, int canonica
TEST_ASSERT(ret == 0); TEST_ASSERT(ret == 0);
TEST_MEMORY_COMPARE(in_key->x, in_key->len, TEST_MEMORY_COMPARE(in_key->x, in_key->len,
buf, in_key->len); buf, in_key->len);
} else { } else {
unsigned char export1[MBEDTLS_ECP_MAX_BYTES]; unsigned char export1[MBEDTLS_ECP_MAX_BYTES];
unsigned char export2[MBEDTLS_ECP_MAX_BYTES]; unsigned char export2[MBEDTLS_ECP_MAX_BYTES];
@ -1372,7 +1372,7 @@ void mbedtls_ecp_read_key(int grp_id, data_t *in_key, int expected, int canonica
TEST_ASSERT(ret == 0); TEST_ASSERT(ret == 0);
TEST_MEMORY_COMPARE(export1, in_key->len, TEST_MEMORY_COMPARE(export1, in_key->len,
export2, in_key->len); export2, in_key->len);
} }
} }
@ -1449,7 +1449,7 @@ void genkey_mx_known_answer(int bits, data_t *seed, data_t *expected)
* - Other bits must be random (by testing with different RNG outputs, * - Other bits must be random (by testing with different RNG outputs,
* we validate that those bits are indeed influenced by the RNG). */ * we validate that those bits are indeed influenced by the RNG). */
TEST_MEMORY_COMPARE(expected->x, expected->len, TEST_MEMORY_COMPARE(expected->x, expected->len,
actual, expected->len); actual, expected->len);
} }
exit: exit:

2
tests/suites/test_suite_hkdf.function
View File

@ -25,7 +25,7 @@ void test_hkdf(int md_alg, data_t *ikm, data_t *salt, data_t *info,
TEST_ASSERT(ret == 0); TEST_ASSERT(ret == 0);
TEST_MEMORY_COMPARE(okm, expected_okm->len, TEST_MEMORY_COMPARE(okm, expected_okm->len,
expected_okm->x, expected_okm->len); expected_okm->x, expected_okm->len);
} }
/* END_CASE */ /* END_CASE */

4
tests/suites/test_suite_mps.function
View File

@ -611,8 +611,8 @@ void mbedtls_mps_reader_reclaim_data_left(int option)
TEST_ASSERT(mbedtls_mps_reader_get(&rd, sizeof(buf) / 2, TEST_ASSERT(mbedtls_mps_reader_get(&rd, sizeof(buf) / 2,
&tmp, NULL) == 0); &tmp, NULL) == 0);
TEST_MEMORY_COMPARE(tmp, sizeof(buf) / 2, TEST_MEMORY_COMPARE(tmp, sizeof(buf) / 2,
buf + sizeof(buf) / 2, buf + sizeof(buf) / 2,
sizeof(buf) / 2); sizeof(buf) / 2);
break; break;
default: default:

2
tests/suites/test_suite_pkcs12.function
View File

@ -58,7 +58,7 @@ void pkcs12_derive_key(int md_type, int key_size_arg,
if (expected_status == 0) { if (expected_status == 0) {
TEST_MEMORY_COMPARE(expected_output->x, expected_output->len, TEST_MEMORY_COMPARE(expected_output->x, expected_output->len,
output_data, key_size); output_data, key_size);
} }
exit: exit:

4
tests/suites/test_suite_pkwrite.function
View File

@ -151,7 +151,7 @@ void pk_write_public_from_private(char *priv_key_file, char *pub_key_file)
derived_key_len), pub_key_len); derived_key_len), pub_key_len);
TEST_MEMORY_COMPARE(derived_key_raw, derived_key_len, TEST_MEMORY_COMPARE(derived_key_raw, derived_key_len,
pub_key_raw, pub_key_len); pub_key_raw, pub_key_len);
#if defined(MBEDTLS_USE_PSA_CRYPTO) #if defined(MBEDTLS_USE_PSA_CRYPTO)
mbedtls_platform_zeroize(derived_key_raw, derived_key_len); mbedtls_platform_zeroize(derived_key_raw, derived_key_len);
@ -163,7 +163,7 @@ void pk_write_public_from_private(char *priv_key_file, char *pub_key_file)
derived_key_len), pub_key_len); derived_key_len), pub_key_len);
TEST_MEMORY_COMPARE(derived_key_raw, derived_key_len, TEST_MEMORY_COMPARE(derived_key_raw, derived_key_len,
pub_key_raw, pub_key_len); pub_key_raw, pub_key_len);
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */
exit: exit:

8
tests/suites/test_suite_poly1305.function
View File

@ -23,7 +23,7 @@ void mbedtls_poly1305(data_t *key, data_t *expected_mac, data_t *src_str)
src_str->len, mac) == 0); src_str->len, mac) == 0);
TEST_MEMORY_COMPARE(mac, expected_mac->len, TEST_MEMORY_COMPARE(mac, expected_mac->len,
expected_mac->x, expected_mac->len); expected_mac->x, expected_mac->len);
/* /*
* Test the streaming API * Test the streaming API
@ -37,7 +37,7 @@ void mbedtls_poly1305(data_t *key, data_t *expected_mac, data_t *src_str)
TEST_ASSERT(mbedtls_poly1305_finish(&ctx, mac) == 0); TEST_ASSERT(mbedtls_poly1305_finish(&ctx, mac) == 0);
TEST_MEMORY_COMPARE(mac, expected_mac->len, TEST_MEMORY_COMPARE(mac, expected_mac->len,
expected_mac->x, expected_mac->len); expected_mac->x, expected_mac->len);
/* /*
* Test the streaming API again, piecewise * Test the streaming API again, piecewise
@ -54,7 +54,7 @@ void mbedtls_poly1305(data_t *key, data_t *expected_mac, data_t *src_str)
TEST_ASSERT(mbedtls_poly1305_finish(&ctx, mac) == 0); TEST_ASSERT(mbedtls_poly1305_finish(&ctx, mac) == 0);
TEST_MEMORY_COMPARE(mac, expected_mac->len, TEST_MEMORY_COMPARE(mac, expected_mac->len,
expected_mac->x, expected_mac->len); expected_mac->x, expected_mac->len);
} }
/* /*
@ -70,7 +70,7 @@ void mbedtls_poly1305(data_t *key, data_t *expected_mac, data_t *src_str)
TEST_ASSERT(mbedtls_poly1305_finish(&ctx, mac) == 0); TEST_ASSERT(mbedtls_poly1305_finish(&ctx, mac) == 0);
TEST_MEMORY_COMPARE(mac, expected_mac->len, TEST_MEMORY_COMPARE(mac, expected_mac->len,
expected_mac->x, expected_mac->len); expected_mac->x, expected_mac->len);
} }
mbedtls_poly1305_free(&ctx); mbedtls_poly1305_free(&ctx);

66
tests/suites/test_suite_psa_crypto.function
View File

@ -633,7 +633,7 @@ void import_export(data_t *data,
export_size, export_size,
&reexported_length)); &reexported_length));
TEST_MEMORY_COMPARE(exported, exported_length, TEST_MEMORY_COMPARE(exported, exported_length,
reexported, reexported_length); reexported, reexported_length);
PSA_ASSERT(psa_destroy_key(key2)); PSA_ASSERT(psa_destroy_key(key2));
} }
TEST_ASSERT(exported_length <= TEST_ASSERT(exported_length <=
@ -704,7 +704,7 @@ void import_export_public_key(data_t *data,
TEST_LE_U(expected_public_key->len, TEST_LE_U(expected_public_key->len,
PSA_EXPORT_PUBLIC_KEY_MAX_SIZE); PSA_EXPORT_PUBLIC_KEY_MAX_SIZE);
TEST_MEMORY_COMPARE(expected_public_key->x, expected_public_key->len, TEST_MEMORY_COMPARE(expected_public_key->x, expected_public_key->len,
exported, exported_length); exported, exported_length);
} }
exit: exit:
@ -1450,7 +1450,7 @@ void copy_success(int source_usage_arg,
PSA_ASSERT(psa_export_key(target_key, export_buffer, PSA_ASSERT(psa_export_key(target_key, export_buffer,
material->len, &length)); material->len, &length));
TEST_MEMORY_COMPARE(material->x, material->len, TEST_MEMORY_COMPARE(material->x, material->len,
export_buffer, length); export_buffer, length);
} }
if (!mbedtls_test_psa_exercise_key(target_key, expected_usage, expected_alg)) { if (!mbedtls_test_psa_exercise_key(target_key, expected_usage, expected_alg)) {
@ -1651,7 +1651,7 @@ void hash_compute_compare(int alg_arg, data_t *input,
&output_length)); &output_length));
TEST_EQUAL(output_length, PSA_HASH_LENGTH(alg)); TEST_EQUAL(output_length, PSA_HASH_LENGTH(alg));
TEST_MEMORY_COMPARE(output, output_length, TEST_MEMORY_COMPARE(output, output_length,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
/* Compute with larger buffer */ /* Compute with larger buffer */
PSA_ASSERT(psa_hash_compute(alg, input->x, input->len, PSA_ASSERT(psa_hash_compute(alg, input->x, input->len,
@ -1659,7 +1659,7 @@ void hash_compute_compare(int alg_arg, data_t *input,
&output_length)); &output_length));
TEST_EQUAL(output_length, PSA_HASH_LENGTH(alg)); TEST_EQUAL(output_length, PSA_HASH_LENGTH(alg));
TEST_MEMORY_COMPARE(output, output_length, TEST_MEMORY_COMPARE(output, output_length,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
/* Compare with correct hash */ /* Compare with correct hash */
PSA_ASSERT(psa_hash_compare(alg, input->x, input->len, PSA_ASSERT(psa_hash_compare(alg, input->x, input->len,
@ -2196,7 +2196,7 @@ void mac_sign(int key_type_arg,
expected_status); expected_status);
if (expected_status == PSA_SUCCESS) { if (expected_status == PSA_SUCCESS) {
TEST_MEMORY_COMPARE(expected_mac->x, expected_mac->len, TEST_MEMORY_COMPARE(expected_mac->x, expected_mac->len,
actual_mac, mac_length); actual_mac, mac_length);
} }
if (output_size > 0) { if (output_size > 0) {
@ -2215,7 +2215,7 @@ void mac_sign(int key_type_arg,
if (expected_status == PSA_SUCCESS) { if (expected_status == PSA_SUCCESS) {
TEST_MEMORY_COMPARE(expected_mac->x, expected_mac->len, TEST_MEMORY_COMPARE(expected_mac->x, expected_mac->len,
actual_mac, mac_length); actual_mac, mac_length);
} }
mbedtls_free(actual_mac); mbedtls_free(actual_mac);
actual_mac = NULL; actual_mac = NULL;
@ -2698,7 +2698,7 @@ void cipher_alg_without_iv(int alg_arg, int key_type_arg, data_t *key_data,
&length)); &length));
output_length += length; output_length += length;
TEST_MEMORY_COMPARE(ciphertext->x, ciphertext->len, TEST_MEMORY_COMPARE(ciphertext->x, ciphertext->len,
output, output_length); output, output_length);
/* Multipart encryption */ /* Multipart encryption */
PSA_ASSERT(psa_cipher_decrypt_setup(&operation, key, alg)); PSA_ASSERT(psa_cipher_decrypt_setup(&operation, key, alg));
@ -2716,7 +2716,7 @@ void cipher_alg_without_iv(int alg_arg, int key_type_arg, data_t *key_data,
&length)); &length));
output_length += length; output_length += length;
TEST_MEMORY_COMPARE(plaintext->x, plaintext->len, TEST_MEMORY_COMPARE(plaintext->x, plaintext->len,
output, output_length); output, output_length);
/* One-shot encryption */ /* One-shot encryption */
output_length = ~0; output_length = ~0;
@ -2724,7 +2724,7 @@ void cipher_alg_without_iv(int alg_arg, int key_type_arg, data_t *key_data,
output, output_buffer_size, output, output_buffer_size,
&output_length)); &output_length));
TEST_MEMORY_COMPARE(ciphertext->x, ciphertext->len, TEST_MEMORY_COMPARE(ciphertext->x, ciphertext->len,
output, output_length); output, output_length);
/* One-shot decryption */ /* One-shot decryption */
output_length = ~0; output_length = ~0;
@ -2732,7 +2732,7 @@ void cipher_alg_without_iv(int alg_arg, int key_type_arg, data_t *key_data,
output, output_buffer_size, output, output_buffer_size,
&output_length)); &output_length));
TEST_MEMORY_COMPARE(plaintext->x, plaintext->len, TEST_MEMORY_COMPARE(plaintext->x, plaintext->len,
output, output_length); output, output_length);
exit: exit:
mbedtls_free(output); mbedtls_free(output);
@ -2851,7 +2851,7 @@ void cipher_encrypt_validation(int alg_arg,
PSA_ASSERT(psa_cipher_abort(&operation)); PSA_ASSERT(psa_cipher_abort(&operation));
TEST_MEMORY_COMPARE(output1 + iv_size, output1_length - iv_size, TEST_MEMORY_COMPARE(output1 + iv_size, output1_length - iv_size,
output2, output2_length); output2, output2_length);
exit: exit:
psa_cipher_abort(&operation); psa_cipher_abort(&operation);
@ -2950,7 +2950,7 @@ void cipher_encrypt_multipart(int alg_arg, int key_type_arg,
PSA_ASSERT(psa_cipher_abort(&operation)); PSA_ASSERT(psa_cipher_abort(&operation));
TEST_MEMORY_COMPARE(expected_output->x, expected_output->len, TEST_MEMORY_COMPARE(expected_output->x, expected_output->len,
output, total_output_length); output, total_output_length);
} }
exit: exit:
@ -3050,7 +3050,7 @@ void cipher_decrypt_multipart(int alg_arg, int key_type_arg,
PSA_ASSERT(psa_cipher_abort(&operation)); PSA_ASSERT(psa_cipher_abort(&operation));
TEST_MEMORY_COMPARE(expected_output->x, expected_output->len, TEST_MEMORY_COMPARE(expected_output->x, expected_output->len,
output, total_output_length); output, total_output_length);
} }
exit: exit:
@ -3161,7 +3161,7 @@ void cipher_decrypt(int alg_arg,
PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE(input_buffer_size)); PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE(input_buffer_size));
TEST_MEMORY_COMPARE(expected_output->x, expected_output->len, TEST_MEMORY_COMPARE(expected_output->x, expected_output->len,
output, output_length); output, output_length);
exit: exit:
mbedtls_free(input); mbedtls_free(input);
mbedtls_free(output); mbedtls_free(output);
@ -3453,7 +3453,7 @@ void aead_encrypt_decrypt(int key_type_arg, data_t *key_data,
expected_result); expected_result);
TEST_MEMORY_COMPARE(input_data->x, input_data->len, TEST_MEMORY_COMPARE(input_data->x, input_data->len,
output_data2, output_length2); output_data2, output_length2);
} }
exit: exit:
@ -3520,7 +3520,7 @@ void aead_encrypt(int key_type_arg, data_t *key_data,
PSA_ASSERT(status); PSA_ASSERT(status);
TEST_MEMORY_COMPARE(expected_result->x, expected_result->len, TEST_MEMORY_COMPARE(expected_result->x, expected_result->len,
output_data, output_length); output_data, output_length);
exit: exit:
psa_destroy_key(key); psa_destroy_key(key);
@ -3593,7 +3593,7 @@ void aead_decrypt(int key_type_arg, data_t *key_data,
if (expected_result == PSA_SUCCESS) { if (expected_result == PSA_SUCCESS) {
TEST_MEMORY_COMPARE(expected_data->x, expected_data->len, TEST_MEMORY_COMPARE(expected_data->x, expected_data->len,
output_data, output_length); output_data, output_length);
} }
exit: exit:
@ -3664,7 +3664,7 @@ void sign_hash_deterministic(int key_type_arg, data_t *key_data,
&signature_length)); &signature_length));
/* Verify that the signature is what is expected. */ /* Verify that the signature is what is expected. */
TEST_MEMORY_COMPARE(output_data->x, output_data->len, TEST_MEMORY_COMPARE(output_data->x, output_data->len,
signature, signature_length); signature, signature_length);
#if defined(MBEDTLS_TEST_DEPRECATED) #if defined(MBEDTLS_TEST_DEPRECATED)
memset(signature, 0, signature_size); memset(signature, 0, signature_size);
@ -3674,7 +3674,7 @@ void sign_hash_deterministic(int key_type_arg, data_t *key_data,
signature, signature_size, signature, signature_size,
&signature_length)); &signature_length));
TEST_MEMORY_COMPARE(output_data->x, output_data->len, TEST_MEMORY_COMPARE(output_data->x, output_data->len,
signature, signature_length); signature, signature_length);
#endif /* MBEDTLS_TEST_DEPRECATED */ #endif /* MBEDTLS_TEST_DEPRECATED */
exit: exit:
@ -3934,7 +3934,7 @@ void sign_message_deterministic(int key_type_arg,
&signature_length)); &signature_length));
TEST_MEMORY_COMPARE(output_data->x, output_data->len, TEST_MEMORY_COMPARE(output_data->x, output_data->len,
signature, signature_length); signature, signature_length);
exit: exit:
psa_reset_key_attributes(&attributes); psa_reset_key_attributes(&attributes);
@ -4272,7 +4272,7 @@ void asymmetric_encrypt_decrypt(int key_type_arg,
output2, output2_size, output2, output2_size,
&output2_length)); &output2_length));
TEST_MEMORY_COMPARE(input_data->x, input_data->len, TEST_MEMORY_COMPARE(input_data->x, input_data->len,
output2, output2_length); output2, output2_length);
exit: exit:
/* /*
@ -4329,7 +4329,7 @@ void asymmetric_decrypt(int key_type_arg,
output_size, output_size,
&output_length)); &output_length));
TEST_MEMORY_COMPARE(expected_data->x, expected_data->len, TEST_MEMORY_COMPARE(expected_data->x, expected_data->len,
output, output_length); output, output_length);
/* If the label is empty, the test framework puts a non-null pointer /* If the label is empty, the test framework puts a non-null pointer
* in label->x. Test that a null pointer works as well. */ * in label->x. Test that a null pointer works as well. */
@ -4345,7 +4345,7 @@ void asymmetric_decrypt(int key_type_arg,
output_size, output_size,
&output_length)); &output_length));
TEST_MEMORY_COMPARE(expected_data->x, expected_data->len, TEST_MEMORY_COMPARE(expected_data->x, expected_data->len,
output, output_length); output, output_length);
} }
exit: exit:
@ -4757,7 +4757,7 @@ void derive_output(int alg_arg,
PSA_ASSERT(status); PSA_ASSERT(status);
if (output_sizes[i] != 0) { if (output_sizes[i] != 0) {
TEST_MEMORY_COMPARE(output_buffer, output_sizes[i], TEST_MEMORY_COMPARE(output_buffer, output_sizes[i],
expected_outputs[i], output_sizes[i]); expected_outputs[i], output_sizes[i]);
} }
/* Check the operation status. */ /* Check the operation status. */
expected_capacity -= output_sizes[i]; expected_capacity -= output_sizes[i];
@ -4983,7 +4983,7 @@ void derive_key_export(int alg_arg,
/* Compare the outputs from the two runs. */ /* Compare the outputs from the two runs. */
TEST_MEMORY_COMPARE(output_buffer, bytes1 + bytes2, TEST_MEMORY_COMPARE(output_buffer, bytes1 + bytes2,
export_buffer, capacity); export_buffer, capacity);
exit: exit:
mbedtls_free(output_buffer); mbedtls_free(output_buffer);
@ -5134,7 +5134,7 @@ void raw_key_agreement(int alg_arg,
output, expected_output->len, output, expected_output->len,
&output_length)); &output_length));
TEST_MEMORY_COMPARE(output, output_length, TEST_MEMORY_COMPARE(output, output_length,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
mbedtls_free(output); mbedtls_free(output);
output = NULL; output = NULL;
output_length = ~0; output_length = ~0;
@ -5146,7 +5146,7 @@ void raw_key_agreement(int alg_arg,
output, expected_output->len + 1, output, expected_output->len + 1,
&output_length)); &output_length));
TEST_MEMORY_COMPARE(output, output_length, TEST_MEMORY_COMPARE(output, output_length,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
mbedtls_free(output); mbedtls_free(output);
output = NULL; output = NULL;
output_length = ~0; output_length = ~0;
@ -5242,7 +5242,7 @@ void key_agreement_output(int alg_arg,
uint8_t *actual_output = NULL; uint8_t *actual_output = NULL;
TEST_CALLOC(actual_output, MAX(expected_output1->len, TEST_CALLOC(actual_output, MAX(expected_output1->len,
expected_output2->len)); expected_output2->len));
PSA_ASSERT(psa_crypto_init()); PSA_ASSERT(psa_crypto_init());
@ -5269,13 +5269,13 @@ void key_agreement_output(int alg_arg,
actual_output, actual_output,
expected_output1->len)); expected_output1->len));
TEST_MEMORY_COMPARE(actual_output, expected_output1->len, TEST_MEMORY_COMPARE(actual_output, expected_output1->len,
expected_output1->x, expected_output1->len); expected_output1->x, expected_output1->len);
if (expected_output2->len != 0) { if (expected_output2->len != 0) {
PSA_ASSERT(psa_key_derivation_output_bytes(&operation, PSA_ASSERT(psa_key_derivation_output_bytes(&operation,
actual_output, actual_output,
expected_output2->len)); expected_output2->len));
TEST_MEMORY_COMPARE(actual_output, expected_output2->len, TEST_MEMORY_COMPARE(actual_output, expected_output2->len,
expected_output2->x, expected_output2->len); expected_output2->x, expected_output2->len);
} }
exit: exit:
@ -5589,7 +5589,7 @@ void persistent_key_load_key_from_storage(data_t *data,
&first_exported_length)); &first_exported_length));
if (generation_method == IMPORT_KEY) { if (generation_method == IMPORT_KEY) {
TEST_MEMORY_COMPARE(data->x, data->len, TEST_MEMORY_COMPARE(data->x, data->len,
first_export, first_exported_length); first_export, first_exported_length);
} }
} }
@ -5616,7 +5616,7 @@ void persistent_key_load_key_from_storage(data_t *data,
second_export, export_size, second_export, export_size,
&second_exported_length)); &second_exported_length));
TEST_MEMORY_COMPARE(first_export, first_exported_length, TEST_MEMORY_COMPARE(first_export, first_exported_length,
second_export, second_exported_length); second_export, second_exported_length);
} }
/* Do something with the key according to its type and permitted usage. */ /* Do something with the key according to its type and permitted usage. */

26
tests/suites/test_suite_psa_crypto_driver_wrappers.function
View File

@ -65,7 +65,7 @@ void sign_hash(int key_type_arg,
TEST_EQUAL(actual_status, expected_status); TEST_EQUAL(actual_status, expected_status);
if (expected_status == PSA_SUCCESS) { if (expected_status == PSA_SUCCESS) {
TEST_MEMORY_COMPARE(signature, signature_length, TEST_MEMORY_COMPARE(signature, signature_length,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
} }
TEST_EQUAL(mbedtls_test_driver_signature_sign_hooks.hits, 1); TEST_EQUAL(mbedtls_test_driver_signature_sign_hooks.hits, 1);
@ -192,7 +192,7 @@ void sign_message(int key_type_arg,
TEST_EQUAL(actual_status, expected_status); TEST_EQUAL(actual_status, expected_status);
if (expected_status == PSA_SUCCESS) { if (expected_status == PSA_SUCCESS) {
TEST_MEMORY_COMPARE(signature, signature_length, TEST_MEMORY_COMPARE(signature, signature_length,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
} }
/* In the builtin algorithm the driver is called twice. */ /* In the builtin algorithm the driver is called twice. */
TEST_EQUAL(mbedtls_test_driver_signature_sign_hooks.hits, TEST_EQUAL(mbedtls_test_driver_signature_sign_hooks.hits,
@ -314,7 +314,7 @@ void generate_key(int force_status_arg,
if (fake_output->len > 0) { if (fake_output->len > 0) {
TEST_MEMORY_COMPARE(actual_output, actual_output_length, TEST_MEMORY_COMPARE(actual_output, actual_output_length,
expected_output, expected_output_length); expected_output, expected_output_length);
} else { } else {
size_t zeroes = 0; size_t zeroes = 0;
for (size_t i = 0; i < sizeof(actual_output); i++) { for (size_t i = 0; i < sizeof(actual_output); i++) {
@ -446,7 +446,7 @@ void export_key(int force_status_arg,
if (actual_status == PSA_SUCCESS) { if (actual_status == PSA_SUCCESS) {
TEST_MEMORY_COMPARE(actual_output, actual_output_length, TEST_MEMORY_COMPARE(actual_output, actual_output_length,
expected_output_ptr, expected_output_length); expected_output_ptr, expected_output_length);
} }
exit: exit:
psa_reset_key_attributes(&attributes); psa_reset_key_attributes(&attributes);
@ -528,7 +528,7 @@ void cipher_encrypt_validation(int alg_arg,
// driver function should've been called as part of the finish() core routine // driver function should've been called as part of the finish() core routine
TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0); TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0);
TEST_MEMORY_COMPARE(output1 + iv_size, output1_length - iv_size, TEST_MEMORY_COMPARE(output1 + iv_size, output1_length - iv_size,
output2, output2_length); output2, output2_length);
exit: exit:
psa_cipher_abort(&operation); psa_cipher_abort(&operation);
@ -656,7 +656,7 @@ void cipher_encrypt_multipart(int alg_arg,
TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0); TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0);
TEST_MEMORY_COMPARE(expected_output->x, expected_output->len, TEST_MEMORY_COMPARE(expected_output->x, expected_output->len,
output, total_output_length); output, total_output_length);
} }
exit: exit:
@ -785,7 +785,7 @@ void cipher_decrypt_multipart(int alg_arg,
TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0); TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0);
TEST_MEMORY_COMPARE(expected_output->x, expected_output->len, TEST_MEMORY_COMPARE(expected_output->x, expected_output->len,
output, total_output_length); output, total_output_length);
} }
exit: exit:
@ -857,7 +857,7 @@ void cipher_decrypt(int alg_arg,
if (expected_status == PSA_SUCCESS) { if (expected_status == PSA_SUCCESS) {
TEST_MEMORY_COMPARE(expected_output->x, expected_output->len, TEST_MEMORY_COMPARE(expected_output->x, expected_output->len,
output, output_length); output, output_length);
} }
exit: exit:
@ -1142,7 +1142,7 @@ void aead_encrypt(int key_type_arg, data_t *key_data,
if (status == PSA_SUCCESS) { if (status == PSA_SUCCESS) {
TEST_MEMORY_COMPARE(expected_result->x, expected_result->len, TEST_MEMORY_COMPARE(expected_result->x, expected_result->len,
output_data, output_length); output_data, output_length);
} }
exit: exit:
@ -1205,7 +1205,7 @@ void aead_decrypt(int key_type_arg, data_t *key_data,
if (status == PSA_SUCCESS) { if (status == PSA_SUCCESS) {
TEST_MEMORY_COMPARE(expected_data->x, expected_data->len, TEST_MEMORY_COMPARE(expected_data->x, expected_data->len,
output_data, output_length); output_data, output_length);
} }
exit: exit:
@ -1327,7 +1327,7 @@ void mac_sign(int key_type_arg,
if (forced_status == PSA_SUCCESS) { if (forced_status == PSA_SUCCESS) {
TEST_MEMORY_COMPARE(expected_mac->x, expected_mac->len, TEST_MEMORY_COMPARE(expected_mac->x, expected_mac->len,
actual_mac, mac_length); actual_mac, mac_length);
} }
mbedtls_free(actual_mac); mbedtls_free(actual_mac);
@ -1478,7 +1478,7 @@ void builtin_key_export(int builtin_key_id_arg,
PSA_ASSERT(actual_status); PSA_ASSERT(actual_status);
TEST_EQUAL(output_size, expected_output->len); TEST_EQUAL(output_size, expected_output->len);
TEST_MEMORY_COMPARE(output_buffer, output_size, TEST_MEMORY_COMPARE(output_buffer, output_size,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
PSA_ASSERT(psa_get_key_attributes(key, &attributes)); PSA_ASSERT(psa_get_key_attributes(key, &attributes));
TEST_EQUAL(psa_get_key_bits(&attributes), builtin_key_bits); TEST_EQUAL(psa_get_key_bits(&attributes), builtin_key_bits);
@ -1529,7 +1529,7 @@ void builtin_pubkey_export(int builtin_key_id_arg,
PSA_ASSERT(actual_status); PSA_ASSERT(actual_status);
TEST_EQUAL(output_size, expected_output->len); TEST_EQUAL(output_size, expected_output->len);
TEST_MEMORY_COMPARE(output_buffer, output_size, TEST_MEMORY_COMPARE(output_buffer, output_size,
expected_output->x, expected_output->len); expected_output->x, expected_output->len);
PSA_ASSERT(psa_get_key_attributes(key, &attributes)); PSA_ASSERT(psa_get_key_attributes(key, &attributes));
TEST_EQUAL(psa_get_key_bits(&attributes), builtin_key_bits); TEST_EQUAL(psa_get_key_bits(&attributes), builtin_key_bits);

6
tests/suites/test_suite_psa_crypto_hash.function
View File

@ -26,7 +26,7 @@ void hash_finish(int alg_arg, data_t *input, data_t *expected_hash)
actual_hash, sizeof(actual_hash), actual_hash, sizeof(actual_hash),
&actual_hash_length)); &actual_hash_length));
TEST_MEMORY_COMPARE(expected_hash->x, expected_hash->len, TEST_MEMORY_COMPARE(expected_hash->x, expected_hash->len,
actual_hash, actual_hash_length); actual_hash, actual_hash_length);
exit: exit:
psa_hash_abort(&operation); psa_hash_abort(&operation);
@ -84,13 +84,13 @@ void hash_multi_part(int alg_arg, data_t *input, data_t *expected_hash)
actual_hash, sizeof(actual_hash), actual_hash, sizeof(actual_hash),
&actual_hash_length)); &actual_hash_length));
TEST_MEMORY_COMPARE(expected_hash->x, expected_hash->len, TEST_MEMORY_COMPARE(expected_hash->x, expected_hash->len,
actual_hash, actual_hash_length); actual_hash, actual_hash_length);
PSA_ASSERT(psa_hash_finish(&operation2, PSA_ASSERT(psa_hash_finish(&operation2,
actual_hash, sizeof(actual_hash), actual_hash, sizeof(actual_hash),
&actual_hash_length)); &actual_hash_length));
TEST_MEMORY_COMPARE(expected_hash->x, expected_hash->len, TEST_MEMORY_COMPARE(expected_hash->x, expected_hash->len,
actual_hash, actual_hash_length); actual_hash, actual_hash_length);
} while (len++ != input->len); } while (len++ != input->len);
exit: exit:

4
tests/suites/test_suite_psa_crypto_persistent_key.function
View File

@ -67,7 +67,7 @@ void format_storage_data_check(data_t *key_data,
file_data); file_data);
TEST_MEMORY_COMPARE(expected_file_data->x, expected_file_data->len, TEST_MEMORY_COMPARE(expected_file_data->x, expected_file_data->len,
file_data, file_data_length); file_data, file_data_length);
exit: exit:
mbedtls_free(file_data); mbedtls_free(file_data);
@ -112,7 +112,7 @@ void parse_storage_data_check(data_t *file_data,
TEST_EQUAL(psa_get_key_enrollment_algorithm(&attributes), TEST_EQUAL(psa_get_key_enrollment_algorithm(&attributes),
(uint32_t) expected_key_alg2); (uint32_t) expected_key_alg2);
TEST_MEMORY_COMPARE(expected_key_data->x, expected_key_data->len, TEST_MEMORY_COMPARE(expected_key_data->x, expected_key_data->len,
key_data, key_data_length); key_data, key_data_length);
exit: exit:
mbedtls_free(key_data); mbedtls_free(key_data);

2
tests/suites/test_suite_psa_crypto_se_driver_hal.function
View File

@ -959,7 +959,7 @@ void key_creation_import_export(int lifetime_arg, int min_slot, int restart)
exported, sizeof(exported), exported, sizeof(exported),
&exported_length)); &exported_length));
TEST_MEMORY_COMPARE(key_material, sizeof(key_material), TEST_MEMORY_COMPARE(key_material, sizeof(key_material),
exported, exported_length); exported, exported_length);
PSA_ASSERT(psa_destroy_key(returned_id)); PSA_ASSERT(psa_destroy_key(returned_id));
if (!check_persistent_data(location, if (!check_persistent_data(location,

16
tests/suites/test_suite_psa_crypto_slot_management.function
View File

@ -308,7 +308,7 @@ void persistent_slot_lifecycle(int lifetime_arg, int owner_id_arg, int id_arg,
PSA_ASSERT(psa_export_key(id, reexported, key_data->len, PSA_ASSERT(psa_export_key(id, reexported, key_data->len,
&reexported_length)); &reexported_length));
TEST_MEMORY_COMPARE(key_data->x, key_data->len, TEST_MEMORY_COMPARE(key_data->x, key_data->len,
reexported, reexported_length); reexported, reexported_length);
} else { } else {
TEST_EQUAL(psa_export_key(id, reexported, TEST_EQUAL(psa_export_key(id, reexported,
key_data->len, &reexported_length), key_data->len, &reexported_length),
@ -403,7 +403,7 @@ void create_existent(int lifetime_arg, int owner_id_arg, int id_arg,
reexported, sizeof(reexported), reexported, sizeof(reexported),
&reexported_length)); &reexported_length));
TEST_MEMORY_COMPARE(material1, sizeof(material1), TEST_MEMORY_COMPARE(material1, sizeof(material1),
reexported, reexported_length); reexported, reexported_length);
PSA_ASSERT(psa_close_key(id)); PSA_ASSERT(psa_close_key(id));
@ -579,7 +579,7 @@ void copy_across_lifetimes(int source_lifetime_arg, int source_owner_id_arg,
PSA_ASSERT(psa_export_key(returned_target_id, export_buffer, PSA_ASSERT(psa_export_key(returned_target_id, export_buffer,
material->len, &length)); material->len, &length));
TEST_MEMORY_COMPARE(material->x, material->len, TEST_MEMORY_COMPARE(material->x, material->len,
export_buffer, length); export_buffer, length);
} else { } else {
size_t length; size_t length;
/* Check that the key is actually non-exportable. */ /* Check that the key is actually non-exportable. */
@ -693,7 +693,7 @@ void copy_to_occupied(int source_lifetime_arg, int source_id_arg,
PSA_ASSERT(psa_export_key(returned_target_id, export_buffer, PSA_ASSERT(psa_export_key(returned_target_id, export_buffer,
target_material->len, &length)); target_material->len, &length));
TEST_MEMORY_COMPARE(target_material->x, target_material->len, TEST_MEMORY_COMPARE(target_material->x, target_material->len,
export_buffer, length); export_buffer, length);
} }
PSA_ASSERT(psa_destroy_key(returned_source_id)); PSA_ASSERT(psa_destroy_key(returned_source_id));
@ -841,7 +841,7 @@ void many_transient_keys(int max_keys_arg)
exported, sizeof(exported), exported, sizeof(exported),
&exported_length)); &exported_length));
TEST_MEMORY_COMPARE(exported, exported_length, TEST_MEMORY_COMPARE(exported, exported_length,
(uint8_t *) &i, sizeof(i)); (uint8_t *) &i, sizeof(i));
} }
PSA_ASSERT(psa_close_key(keys[i - 1])); PSA_ASSERT(psa_close_key(keys[i - 1]));
@ -918,7 +918,7 @@ void key_slot_eviction_to_import_new_key(int lifetime_arg)
exported, sizeof(exported), exported, sizeof(exported),
&exported_length)); &exported_length));
TEST_MEMORY_COMPARE(exported, exported_length, TEST_MEMORY_COMPARE(exported, exported_length,
(uint8_t *) &i, sizeof(i)); (uint8_t *) &i, sizeof(i));
PSA_ASSERT(psa_destroy_key(key)); PSA_ASSERT(psa_destroy_key(key));
} }
@ -1017,7 +1017,7 @@ void non_reusable_key_slots_integrity_in_case_of_key_slot_starvation()
exported, sizeof(exported), exported, sizeof(exported),
&exported_length)); &exported_length));
TEST_MEMORY_COMPARE(exported, exported_length, TEST_MEMORY_COMPARE(exported, exported_length,
(uint8_t *) &i, sizeof(i)); (uint8_t *) &i, sizeof(i));
PSA_ASSERT(psa_destroy_key(keys[i])); PSA_ASSERT(psa_destroy_key(keys[i]));
} }
@ -1029,7 +1029,7 @@ void non_reusable_key_slots_integrity_in_case_of_key_slot_starvation()
PSA_ASSERT(psa_export_key(persistent_key, exported, sizeof(exported), PSA_ASSERT(psa_export_key(persistent_key, exported, sizeof(exported),
&exported_length)); &exported_length));
TEST_MEMORY_COMPARE(exported, exported_length, TEST_MEMORY_COMPARE(exported, exported_length,
(uint8_t *) &persistent_key, sizeof(persistent_key)); (uint8_t *) &persistent_key, sizeof(persistent_key));
exit: exit:
/* /*
* Key attributes may have been returned by psa_get_key_attributes() * Key attributes may have been returned by psa_get_key_attributes()

4
tests/suites/test_suite_psa_crypto_storage_format.function
View File

@ -40,7 +40,7 @@ static int test_written_key(const psa_key_attributes_t *attributes,
PSA_ASSERT(psa_its_get(uid, 0, storage_info.size, PSA_ASSERT(psa_its_get(uid, 0, storage_info.size,
actual_representation, &length)); actual_representation, &length));
TEST_MEMORY_COMPARE(expected_representation->x, expected_representation->len, TEST_MEMORY_COMPARE(expected_representation->x, expected_representation->len,
actual_representation, length); actual_representation, length);
ok = 1; ok = 1;
@ -273,7 +273,7 @@ static int test_read_key(const psa_key_attributes_t *expected_attributes,
exported_material, expected_material->len, exported_material, expected_material->len,
&length)); &length));
TEST_MEMORY_COMPARE(expected_material->x, expected_material->len, TEST_MEMORY_COMPARE(expected_material->x, expected_material->len,
exported_material, length); exported_material, length);
} }
if ((flags & TEST_FLAG_EXERCISE) && can_exercise(&actual_attributes)) { if ((flags & TEST_FLAG_EXERCISE) && can_exercise(&actual_attributes)) {

4
tests/suites/test_suite_psa_its.function
View File

@ -168,7 +168,7 @@ void set_multiple(int first_id, int count)
"Content of file 0x%08lx", (unsigned long) uid); "Content of file 0x%08lx", (unsigned long) uid);
PSA_ASSERT(psa_its_get(uid, 0, sizeof(stored), retrieved, &ret_len)); PSA_ASSERT(psa_its_get(uid, 0, sizeof(stored), retrieved, &ret_len));
TEST_MEMORY_COMPARE(retrieved, ret_len, TEST_MEMORY_COMPARE(retrieved, ret_len,
stored, sizeof(stored)); stored, sizeof(stored));
PSA_ASSERT(psa_its_remove(uid)); PSA_ASSERT(psa_its_remove(uid));
TEST_ASSERT(psa_its_get(uid, 0, 0, NULL, NULL) == TEST_ASSERT(psa_its_get(uid, 0, 0, NULL, NULL) ==
PSA_ERROR_DOES_NOT_EXIST); PSA_ERROR_DOES_NOT_EXIST);
@ -224,7 +224,7 @@ void get_at(int uid_arg, data_t *data,
TEST_ASSERT(status == (psa_status_t) expected_status); TEST_ASSERT(status == (psa_status_t) expected_status);
if (status == PSA_SUCCESS) { if (status == PSA_SUCCESS) {
TEST_MEMORY_COMPARE(data->x + offset, (size_t) length_arg, TEST_MEMORY_COMPARE(data->x + offset, (size_t) length_arg,
buffer, ret_len); buffer, ret_len);
} }
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
TEST_ASSERT(trailer[i] == '-'); TEST_ASSERT(trailer[i] == '-');

30
tests/suites/test_suite_ssl.function
View File

@ -1690,7 +1690,7 @@ void ssl_tls1_3_hkdf_expand_label(int hash_alg,
dst, desired_length) == 0); dst, desired_length) == 0);
TEST_MEMORY_COMPARE(dst, (size_t) desired_length, TEST_MEMORY_COMPARE(dst, (size_t) desired_length,
expected->x, (size_t) expected->len); expected->x, (size_t) expected->len);
} }
/* END_CASE */ /* END_CASE */
@ -1725,21 +1725,21 @@ void ssl_tls1_3_traffic_key_generation(int hash_alg,
&keys) == 0); &keys) == 0);
TEST_MEMORY_COMPARE(keys.client_write_key, TEST_MEMORY_COMPARE(keys.client_write_key,
keys.key_len, keys.key_len,
expected_client_write_key->x, expected_client_write_key->x,
(size_t) desired_key_len); (size_t) desired_key_len);
TEST_MEMORY_COMPARE(keys.server_write_key, TEST_MEMORY_COMPARE(keys.server_write_key,
keys.key_len, keys.key_len,
expected_server_write_key->x, expected_server_write_key->x,
(size_t) desired_key_len); (size_t) desired_key_len);
TEST_MEMORY_COMPARE(keys.client_write_iv, TEST_MEMORY_COMPARE(keys.client_write_iv,
keys.iv_len, keys.iv_len,
expected_client_write_iv->x, expected_client_write_iv->x,
(size_t) desired_iv_len); (size_t) desired_iv_len);
TEST_MEMORY_COMPARE(keys.server_write_iv, TEST_MEMORY_COMPARE(keys.server_write_iv,
keys.iv_len, keys.iv_len,
expected_server_write_iv->x, expected_server_write_iv->x,
(size_t) desired_iv_len); (size_t) desired_iv_len);
} }
/* END_CASE */ /* END_CASE */
@ -1779,7 +1779,7 @@ void ssl_tls1_3_derive_secret(int hash_alg,
dst, desired_length) == 0); dst, desired_length) == 0);
TEST_MEMORY_COMPARE(dst, desired_length, TEST_MEMORY_COMPARE(dst, desired_length,
expected->x, desired_length); expected->x, desired_length);
} }
/* END_CASE */ /* END_CASE */
@ -1798,7 +1798,7 @@ void ssl_tls1_3_key_evolution(int hash_alg,
secret_new) == 0); secret_new) == 0);
TEST_MEMORY_COMPARE(secret_new, (size_t) expected->len, TEST_MEMORY_COMPARE(secret_new, (size_t) expected->len,
expected->x, (size_t) expected->len); expected->x, (size_t) expected->len);
} }
/* END_CASE */ /* END_CASE */