lib/mbedtls
1
0
Fork 0
mirror of https://github.com/Mbed-TLS/mbedtls.git synced 2025-07-30 22:43:08 +03:00
Code Activity

For tests, rename TEST_CALLOC_OR_FAIL() to just TEST_CALLOC()

Browse Source 
Signed-off-by: Tom Cosgrove <tom.cosgrove@arm.com>
This commit is contained in:
Tom Cosgrove
2023-09-04 11:20:19 +01:00
parent 20e27de0bb
commit 30ceb23f3e
27 changed files with 150 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
tests/include/test/macros.h
View File

@ -143,7 +143,7 @@
* This expression may be evaluated multiple times.
*
*/
#define TEST_CALLOC_OR_FAIL(pointer, length) \
#define TEST_CALLOC(pointer, length) \
do { \
TEST_ASSERT((pointer) == NULL); \
if ((length) != 0) { \
@ -154,11 +154,11 @@
} while (0)
/* For backwards compatibility */
#define ASSERT_ALLOC(pointer, length) TEST_CALLOC_OR_FAIL(pointer, length)
#define ASSERT_ALLOC(pointer, length) TEST_CALLOC(pointer, length)
/** Allocate memory dynamically. If the allocation fails, skip the test case.
*
* This macro behaves like #TEST_CALLOC_OR_FAIL, except that if the allocation
* This macro behaves like #TEST_CALLOC, except that if the allocation
* fails, it marks the test as skipped rather than failed.
*/
#define TEST_CALLOC_OR_SKIP(pointer, length) \

10
tests/src/psa_exercise_key.c
View File

@ -505,7 +505,7 @@ psa_status_t mbedtls_test_psa_key_agreement_with_self(
key_bits = psa_get_key_bits(&attributes);
public_key_type = PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(private_key_type);
public_key_length = PSA_EXPORT_PUBLIC_KEY_OUTPUT_SIZE(public_key_type, key_bits);
TEST_CALLOC_OR_FAIL(public_key, public_key_length);
TEST_CALLOC(public_key, public_key_length);
PSA_ASSERT(psa_export_public_key(key, public_key, public_key_length,
&public_key_length));
@ -547,7 +547,7 @@ psa_status_t mbedtls_test_psa_raw_key_agreement_with_self(
key_bits = psa_get_key_bits(&attributes);
public_key_type = PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(private_key_type);
public_key_length = PSA_EXPORT_PUBLIC_KEY_OUTPUT_SIZE(public_key_type, key_bits);
TEST_CALLOC_OR_FAIL(public_key, public_key_length);
TEST_CALLOC(public_key, public_key_length);
PSA_ASSERT(psa_export_public_key(key,
public_key, public_key_length,
&public_key_length));
@ -807,7 +807,7 @@ static int exercise_export_key(mbedtls_svc_key_id_t key,
exported_size = PSA_EXPORT_KEY_OUTPUT_SIZE(
psa_get_key_type(&attributes),
psa_get_key_bits(&attributes));
TEST_CALLOC_OR_FAIL(exported, exported_size);
TEST_CALLOC(exported, exported_size);
if ((usage & PSA_KEY_USAGE_EXPORT) == 0 &&
!PSA_KEY_TYPE_IS_PUBLIC_KEY(psa_get_key_type(&attributes))) {
@ -850,7 +850,7 @@ static int exercise_export_public_key(mbedtls_svc_key_id_t key)
exported_size = PSA_EXPORT_KEY_OUTPUT_SIZE(
psa_get_key_type(&attributes),
psa_get_key_bits(&attributes));
TEST_CALLOC_OR_FAIL(exported, exported_size);
TEST_CALLOC(exported, exported_size);
TEST_EQUAL(psa_export_public_key(key, exported,
exported_size, &exported_length),
@ -863,7 +863,7 @@ static int exercise_export_public_key(mbedtls_svc_key_id_t key)
psa_get_key_type(&attributes));
exported_size = PSA_EXPORT_PUBLIC_KEY_OUTPUT_SIZE(public_type,
psa_get_key_bits(&attributes));
TEST_CALLOC_OR_FAIL(exported, exported_size);
TEST_CALLOC(exported, exported_size);
PSA_ASSERT(psa_export_public_key(key,
exported, exported_size,

6
tests/src/test_helpers/ssl_helpers.c
View File

@ -566,9 +566,9 @@ int mbedtls_test_ssl_endpoint_certificate_init(mbedtls_test_ssl_endpoint *ep,
}
cert = &(ep->cert);
TEST_CALLOC_OR_FAIL(cert->ca_cert, 1);
TEST_CALLOC_OR_FAIL(cert->cert, 1);
TEST_CALLOC_OR_FAIL(cert->pkey, 1);
TEST_CALLOC(cert->ca_cert, 1);
TEST_CALLOC(cert->cert, 1);
TEST_CALLOC(cert->pkey, 1);
mbedtls_x509_crt_init(cert->ca_cert);
mbedtls_x509_crt_init(cert->cert);

16
tests/suites/test_suite_aes.function
View File

@ -688,8 +688,8 @@ void aes_ecb_context_alignment(data_t *key)
struct align1 *dec1 = NULL;
/* All peak alignment */
TEST_CALLOC_OR_FAIL(enc0, 1);
TEST_CALLOC_OR_FAIL(dec0, 1);
TEST_CALLOC(enc0, 1);
TEST_CALLOC(dec0, 1);
if (!test_ctx_alignment(key, &enc0->ctx, &dec0->ctx)) {
goto exit;
}
@ -699,8 +699,8 @@ void aes_ecb_context_alignment(data_t *key)
dec0 = NULL;
/* Enc aligned, dec not */
TEST_CALLOC_OR_FAIL(enc0, 1);
TEST_CALLOC_OR_FAIL(dec1, 1);
TEST_CALLOC(enc0, 1);
TEST_CALLOC(dec1, 1);
if (!test_ctx_alignment(key, &enc0->ctx, &dec1->ctx)) {
goto exit;
}
@ -710,8 +710,8 @@ void aes_ecb_context_alignment(data_t *key)
dec1 = NULL;
/* Dec aligned, enc not */
TEST_CALLOC_OR_FAIL(enc1, 1);
TEST_CALLOC_OR_FAIL(dec0, 1);
TEST_CALLOC(enc1, 1);
TEST_CALLOC(dec0, 1);
if (!test_ctx_alignment(key, &enc1->ctx, &dec0->ctx)) {
goto exit;
}
@ -721,8 +721,8 @@ void aes_ecb_context_alignment(data_t *key)
dec0 = NULL;
/* Both shifted */
TEST_CALLOC_OR_FAIL(enc1, 1);
TEST_CALLOC_OR_FAIL(dec1, 1);
TEST_CALLOC(enc1, 1);
TEST_CALLOC(dec1, 1);
if (!test_ctx_alignment(key, &enc1->ctx, &dec1->ctx)) {
goto exit;
}

12
tests/suites/test_suite_asn1parse.function
View File

@ -135,7 +135,7 @@ int get_len_step(const data_t *input, size_t buffer_size,
/* Allocate a new buffer of exactly the length to parse each time.
* This gives memory sanitizers a chance to catch buffer overreads. */
if (buffer_size == 0) {
TEST_CALLOC_OR_FAIL(buf, 1);
TEST_CALLOC(buf, 1);
end = buf + 1;
p = end;
} else {
@ -247,7 +247,7 @@ void parse_prefixes(const data_t *input,
mbedtls_test_set_step(buffer_size);
/* Allocate a new buffer of exactly the length to parse each time.
* This gives memory sanitizers a chance to catch buffer overreads. */
TEST_CALLOC_OR_FAIL(buf, buffer_size);
TEST_CALLOC(buf, buffer_size);
memcpy(buf, input->x, buffer_size);
p = buf;
ret = nested_parse(&p, buf + buffer_size);
@ -506,7 +506,7 @@ void get_mpi_too_large()
mbedtls_mpi_init(&actual_mpi);
TEST_CALLOC_OR_FAIL(buf, size);
TEST_CALLOC(buf, size);
buf[0] = 0x02; /* tag: INTEGER */
buf[1] = 0x84; /* 4-octet length */
buf[2] = (too_many_octets >> 24) & 0xff;
@ -729,10 +729,10 @@ void free_named_data(int with_oid, int with_val, int with_next)
{ { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 };
if (with_oid) {
TEST_CALLOC_OR_FAIL(head.oid.p, 1);
TEST_CALLOC(head.oid.p, 1);
}
if (with_val) {
TEST_CALLOC_OR_FAIL(head.val.p, 1);
TEST_CALLOC(head.val.p, 1);
}
if (with_next) {
head.next = &next;
@ -758,7 +758,7 @@ void free_named_data_list(int length)
for (i = 0; i < length; i++) {
mbedtls_asn1_named_data *new = NULL;
TEST_CALLOC_OR_FAIL(new, 1);
TEST_CALLOC(new, 1);
new->next = head;
head = new;
}

10
tests/suites/test_suite_asn1write.function
View File

@ -17,7 +17,7 @@ int generic_write_start_step(generic_write_data_t *data)
mbedtls_test_set_step(data->size);
mbedtls_free(data->output);
data->output = NULL;
TEST_CALLOC_OR_FAIL(data->output, data->size == 0 ? 1 : data->size);
TEST_CALLOC(data->output, data->size == 0 ? 1 : data->size);
data->end = data->output + data->size;
data->p = data->end;
data->start = data->end - data->size;
@ -296,7 +296,7 @@ void mbedtls_asn1_write_algorithm_identifier(data_t *oid,
size_t len_complete = data_len + par_len;
unsigned char expected_params_tag;
size_t expected_params_len;
TEST_CALLOC_OR_FAIL(buf_complete, len_complete);
TEST_CALLOC(buf_complete, len_complete);
unsigned char *end_complete = buf_complete + len_complete;
memcpy(buf_complete, data.p, data_len);
if (par_len == 0) {
@ -404,7 +404,7 @@ void test_asn1_write_bitstrings(data_t *bitstring, int bits,
TEST_ASSERT(bitstring->len >= byte_length);
#if defined(MBEDTLS_ASN1_PARSE_C)
TEST_CALLOC_OR_FAIL(masked_bitstring, byte_length);
TEST_CALLOC(masked_bitstring, byte_length);
if (byte_length != 0) {
memcpy(masked_bitstring, bitstring->x, byte_length);
if (bits % 8 != 0) {
@ -477,7 +477,7 @@ void store_named_data_find(data_t *oid0, data_t *oid1,
}
pointers[ARRAY_LENGTH(nd)] = NULL;
for (i = 0; i < ARRAY_LENGTH(nd); i++) {
TEST_CALLOC_OR_FAIL(nd[i].oid.p, oid[i]->len);
TEST_CALLOC(nd[i].oid.p, oid[i]->len);
memcpy(nd[i].oid.p, oid[i]->x, oid[i]->len);
nd[i].oid.len = oid[i]->len;
nd[i].next = pointers[i+1];
@ -529,7 +529,7 @@ void store_named_data_val_found(int old_len, int new_len)
unsigned char *new_val = (unsigned char *) "new value";
if (old_len != 0) {
TEST_CALLOC_OR_FAIL(nd.val.p, (size_t) old_len);
TEST_CALLOC(nd.val.p, (size_t) old_len);
old_val = nd.val.p;
nd.val.len = old_len;
memset(old_val, 'x', old_len);

2
tests/suites/test_suite_bignum.function
View File

@ -1507,7 +1507,7 @@ void mpi_random_many(int min, data_t *bound_bytes, int iterations)
full_stats = 0;
stats_len = n_bits;
}
TEST_CALLOC_OR_FAIL(stats, stats_len);
TEST_CALLOC(stats, stats_len);
for (i = 0; i < (size_t) iterations; i++) {
mbedtls_test_set_step(i);

18
tests/suites/test_suite_cipher.function
View File

@ -1229,7 +1229,7 @@ void auth_crypt_tv(int cipher_id, data_t *key, data_t *iv,
* (we need the tag appended to the ciphertext)
*/
cipher_plus_tag_len = cipher->len + tag->len;
TEST_CALLOC_OR_FAIL(cipher_plus_tag, cipher_plus_tag_len);
TEST_CALLOC(cipher_plus_tag, cipher_plus_tag_len);
memcpy(cipher_plus_tag, cipher->x, cipher->len);
memcpy(cipher_plus_tag + cipher->len, tag->x, tag->len);
@ -1247,7 +1247,7 @@ void auth_crypt_tv(int cipher_id, data_t *key, data_t *iv,
* Try decrypting to a buffer that's 1B too small
*/
if (decrypt_buf_len != 0) {
TEST_CALLOC_OR_FAIL(decrypt_buf, decrypt_buf_len - 1);
TEST_CALLOC(decrypt_buf, decrypt_buf_len - 1);
outlen = 0;
ret = mbedtls_cipher_auth_decrypt_ext(&ctx, iv->x, iv->len,
@ -1262,7 +1262,7 @@ void auth_crypt_tv(int cipher_id, data_t *key, data_t *iv,
/*
* Authenticate and decrypt, and check result
*/
TEST_CALLOC_OR_FAIL(decrypt_buf, decrypt_buf_len);
TEST_CALLOC(decrypt_buf, decrypt_buf_len);
outlen = 0;
ret = mbedtls_cipher_auth_decrypt_ext(&ctx, iv->x, iv->len,
@ -1306,7 +1306,7 @@ void auth_crypt_tv(int cipher_id, data_t *key, data_t *iv,
/*
* Try encrypting with an output buffer that's 1B too small
*/
TEST_CALLOC_OR_FAIL(encrypt_buf, encrypt_buf_len - 1);
TEST_CALLOC(encrypt_buf, encrypt_buf_len - 1);
outlen = 0;
ret = mbedtls_cipher_auth_encrypt_ext(&ctx, iv->x, iv->len,
@ -1320,7 +1320,7 @@ void auth_crypt_tv(int cipher_id, data_t *key, data_t *iv,
/*
* Encrypt and check the result
*/
TEST_CALLOC_OR_FAIL(encrypt_buf, encrypt_buf_len);
TEST_CALLOC(encrypt_buf, encrypt_buf_len);
outlen = 0;
ret = mbedtls_cipher_auth_encrypt_ext(&ctx, iv->x, iv->len,
@ -1374,7 +1374,7 @@ void auth_crypt_tv(int cipher_id, data_t *key, data_t *iv,
* Authenticate and decrypt, and check result
*/
TEST_CALLOC_OR_FAIL(decrypt_buf, cipher->len);
TEST_CALLOC(decrypt_buf, cipher->len);
outlen = 0;
ret = mbedtls_cipher_auth_decrypt(&ctx, iv->x, iv->len, ad->x, ad->len,
tmp_cipher, cipher->len, decrypt_buf, &outlen,
@ -1411,14 +1411,14 @@ void auth_crypt_tv(int cipher_id, data_t *key, data_t *iv,
/* prepare buffers for encryption */
#if defined(MBEDTLS_USE_PSA_CRYPTO)
if (use_psa) {
TEST_CALLOC_OR_FAIL(cipher_plus_tag, cipher->len + tag->len);
TEST_CALLOC(cipher_plus_tag, cipher->len + tag->len);
tmp_cipher = cipher_plus_tag;
tmp_tag = cipher_plus_tag + cipher->len;
} else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
{
TEST_CALLOC_OR_FAIL(encrypt_buf, cipher->len);
TEST_CALLOC_OR_FAIL(tag_buf, tag->len);
TEST_CALLOC(encrypt_buf, cipher->len);
TEST_CALLOC(tag_buf, tag->len);
tmp_cipher = encrypt_buf;
tmp_tag = tag_buf;
}

4
tests/suites/test_suite_constant_time.function
View File

@ -23,8 +23,8 @@ void ssl_cf_memcpy_offset(int offset_min, int offset_max, int len)
size_t src_len = offset_max + len;
size_t secret;
TEST_CALLOC_OR_FAIL(dst, len);
TEST_CALLOC_OR_FAIL(src, src_len);
TEST_CALLOC(dst, len);
TEST_CALLOC(src, src_len);
/* Fill src in a way that we can detect if we copied the right bytes */
mbedtls_test_rnd_std_rand(NULL, src, src_len);

4
tests/suites/test_suite_constant_time_hmac.function
View File

@ -35,7 +35,7 @@ void ssl_cf_hmac(int hash)
block_size = hash == MBEDTLS_MD_SHA384 ? 128 : 64;
/* Use allocated out buffer to catch overwrites */
TEST_CALLOC_OR_FAIL(out, out_len);
TEST_CALLOC(out, out_len);
/* Set up contexts with the given hash and a dummy key */
TEST_EQUAL(0, mbedtls_md_setup(&ctx, md_info, 1));
@ -54,7 +54,7 @@ void ssl_cf_hmac(int hash)
mbedtls_test_set_step(max_in_len * 10000);
/* Use allocated in buffer to catch overreads */
TEST_CALLOC_OR_FAIL(data, max_in_len);
TEST_CALLOC(data, max_in_len);
min_in_len = max_in_len > 255 ? max_in_len - 255 : 0;
for (in_len = min_in_len; in_len <= max_in_len; in_len++) {

2
tests/suites/test_suite_ecp.function
View File

@ -1426,7 +1426,7 @@ void genkey_mx_known_answer(int bits, data_t *seed, data_t *expected)
rnd_info.fallback_f_rng = NULL;
rnd_info.fallback_p_rng = NULL;
TEST_CALLOC_OR_FAIL(actual, expected->len);
TEST_CALLOC(actual, expected->len);
ret = mbedtls_ecp_gen_privkey_mx(bits, &d,
mbedtls_test_rnd_buffer_rand, &rnd_info);

8
tests/suites/test_suite_mps.function
View File

@ -844,15 +844,15 @@ void mbedtls_mps_reader_random_usage(int num_out_chunks,
mbedtls_mps_reader rd;
if (acc_size > 0) {
TEST_CALLOC_OR_FAIL(acc, acc_size);
TEST_CALLOC(acc, acc_size);
}
/* This probably needs to be changed because we want
* our tests to be deterministic. */
// srand( time( NULL ) );
TEST_CALLOC_OR_FAIL(outgoing, num_out_chunks * max_chunk_size);
TEST_CALLOC_OR_FAIL(incoming, num_out_chunks * max_chunk_size);
TEST_CALLOC(outgoing, num_out_chunks * max_chunk_size);
TEST_CALLOC(incoming, num_out_chunks * max_chunk_size);
mbedtls_mps_reader_init(&rd, acc, acc_size);
@ -884,7 +884,7 @@ void mbedtls_mps_reader_random_usage(int num_out_chunks,
}
tmp_size = (rand() % max_chunk_size) + 1;
TEST_CALLOC_OR_FAIL(tmp, tmp_size);
TEST_CALLOC(tmp, tmp_size);
TEST_ASSERT(mbedtls_test_rnd_std_rand(NULL, tmp, tmp_size) == 0);
ret = mbedtls_mps_reader_feed(&rd, tmp, tmp_size);

2
tests/suites/test_suite_pk.function
View File

@ -915,7 +915,7 @@ void pk_sign_verify(int type, int parameter, int sign_ret, int verify_ret)
#endif
hash_len = mbedtls_md_get_size(mbedtls_md_info_from_type(md));
TEST_CALLOC_OR_FAIL(hash, hash_len);
TEST_CALLOC(hash, hash_len);
mbedtls_pk_init(&pk);
USE_PSA_INIT();

2
tests/suites/test_suite_pkcs12.function
View File

@ -42,7 +42,7 @@ void pkcs12_derive_key(int md_type, int key_size_arg,
salt_len = salt_arg->len;
TEST_CALLOC_OR_FAIL(output_data, key_size);
TEST_CALLOC(output_data, key_size);
int ret = mbedtls_pkcs12_derivation(output_data,
key_size,

4
tests/suites/test_suite_pkwrite.function
View File

@ -58,7 +58,7 @@ static void pk_write_check_common(char *key_file, int is_public_key, int is_der)
}
TEST_ASSERT(check_buf_len > 0);
TEST_CALLOC_OR_FAIL(buf, check_buf_len);
TEST_CALLOC(buf, check_buf_len);
if (is_public_key) {
TEST_EQUAL(mbedtls_pk_parse_public_keyfile(&key, key_file), 0);
@ -145,7 +145,7 @@ void pk_write_public_from_private(char *priv_key_file, char *pub_key_file)
&pub_key_len), 0);
derived_key_len = pub_key_len;
TEST_CALLOC_OR_FAIL(derived_key_raw, derived_key_len);
TEST_CALLOC(derived_key_raw, derived_key_len);
TEST_EQUAL(mbedtls_pk_write_pubkey_der(&priv_key, derived_key_raw,
derived_key_len), pub_key_len);

8
tests/suites/test_suite_platform_printf.function
View File

@ -32,7 +32,7 @@ void printf_int(char *format, /* any format expecting one int argument, e.g. "%d
const size_t n = strlen(result);
/* Nominal case: buffer just large enough */
TEST_CALLOC_OR_FAIL(output, n + 1);
TEST_CALLOC(output, n + 1);
TEST_EQUAL(n, mbedtls_snprintf(output, n + 1, format, x));
TEST_BUFFERS_EQUAL(result, n + 1, output, n + 1);
mbedtls_free(output);
@ -53,11 +53,11 @@ void printf_long_max(const char *format, /* "%lx" or longer type */
const size_t n = sizeof(value) * 2;
/* We assume that long has no padding bits! */
TEST_CALLOC_OR_FAIL(expected, n + 1);
TEST_CALLOC(expected, n + 1);
expected[0] = '7';
memset(expected + 1, 'f', sizeof(value) * 2 - 1);
TEST_CALLOC_OR_FAIL(output, n + 1);
TEST_CALLOC(output, n + 1);
TEST_EQUAL(n, mbedtls_snprintf(output, n + 1, format, value));
TEST_BUFFERS_EQUAL(expected, n + 1, output, n + 1);
mbedtls_free(output);
@ -77,7 +77,7 @@ void printf_char2(char *format, /* "%c%c" */
const size_t n = strlen(result);
/* Nominal case: buffer just large enough */
TEST_CALLOC_OR_FAIL(output, n + 1);
TEST_CALLOC(output, n + 1);
TEST_EQUAL(n, mbedtls_snprintf(output, n + 1, format, arg1, arg2));
TEST_BUFFERS_EQUAL(result, n + 1, output, n + 1);
mbedtls_free(output);

102
tests/suites/test_suite_psa_crypto.function
View File

@ -533,7 +533,7 @@ void import_rsa_made_up(int bits_arg, int keypair, int expected_status_arg)
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
PSA_ASSERT(psa_crypto_init());
TEST_CALLOC_OR_FAIL(buffer, buffer_size);
TEST_CALLOC(buffer, buffer_size);
TEST_ASSERT((ret = construct_fake_rsa_key(buffer, buffer_size, &p,
bits, keypair)) >= 0);
@ -578,9 +578,9 @@ void import_export(data_t *data,
psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
export_size = (ptrdiff_t) data->len + export_size_delta;
TEST_CALLOC_OR_FAIL(exported, export_size);
TEST_CALLOC(exported, export_size);
if (!canonical_input) {
TEST_CALLOC_OR_FAIL(reexported, export_size);
TEST_CALLOC(reexported, export_size);
}
PSA_ASSERT(psa_crypto_init());
@ -687,7 +687,7 @@ void import_export_public_key(data_t *data,
PSA_ASSERT(psa_import_key(&attributes, data->x, data->len, &key));
/* Export the public key */
TEST_CALLOC_OR_FAIL(exported, export_size);
TEST_CALLOC(exported, export_size);
status = psa_export_public_key(key,
exported, export_size,
&exported_length);
@ -1081,7 +1081,7 @@ void asymmetric_encryption_key_policy(int policy_usage_arg,
key_bits = psa_get_key_bits(&attributes);
buffer_length = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE(key_type, key_bits,
exercise_alg);
TEST_CALLOC_OR_FAIL(buffer, buffer_length);
TEST_CALLOC(buffer, buffer_length);
status = psa_asymmetric_encrypt(key, exercise_alg,
NULL, 0,
@ -1446,7 +1446,7 @@ void copy_success(int source_usage_arg,
psa_get_key_enrollment_algorithm(&target_attributes));
if (expected_usage & PSA_KEY_USAGE_EXPORT) {
size_t length;
TEST_CALLOC_OR_FAIL(export_buffer, material->len);
TEST_CALLOC(export_buffer, material->len);
PSA_ASSERT(psa_export_key(target_key, export_buffer,
material->len, &length));
TEST_BUFFERS_EQUAL(material->x, material->len,
@ -1599,7 +1599,7 @@ void hash_compute_fail(int alg_arg, data_t *input,
psa_status_t expected_status = expected_status_arg;
psa_status_t status;
TEST_CALLOC_OR_FAIL(output, output_size);
TEST_CALLOC(output, output_size);
PSA_ASSERT(psa_crypto_init());
@ -2187,7 +2187,7 @@ void mac_sign(int key_type_arg,
PSA_ERROR_BUFFER_TOO_SMALL);
mbedtls_test_set_step(output_size);
TEST_CALLOC_OR_FAIL(actual_mac, output_size);
TEST_CALLOC(actual_mac, output_size);
/* Calculate the MAC, one-shot case. */
TEST_EQUAL(psa_mac_compute(key, alg,
@ -2283,7 +2283,7 @@ void mac_verify(int key_type_arg,
PSA_ERROR_INVALID_SIGNATURE);
/* Test a MAC that's too long, one-shot case. */
TEST_CALLOC_OR_FAIL(perturbed_mac, expected_mac->len + 1);
TEST_CALLOC(perturbed_mac, expected_mac->len + 1);
memcpy(perturbed_mac, expected_mac->x, expected_mac->len);
TEST_EQUAL(psa_mac_verify(key, alg,
input->x, input->len,
@ -2608,7 +2608,7 @@ void cipher_encrypt_fail(int alg_arg,
output_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE(key_type, alg,
input->len);
TEST_CALLOC_OR_FAIL(output, output_buffer_size);
TEST_CALLOC(output, output_buffer_size);
PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
&key));
@ -2662,7 +2662,7 @@ void cipher_alg_without_iv(int alg_arg, int key_type_arg, data_t *key_data,
&key));
output_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE(key_type, alg,
plaintext->len);
TEST_CALLOC_OR_FAIL(output, output_buffer_size);
TEST_CALLOC(output, output_buffer_size);
/* set_iv() is not allowed */
PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
@ -2811,8 +2811,8 @@ void cipher_encrypt_validation(int alg_arg,
output1_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE(key_type, alg, input->len);
output2_buffer_size = PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type, alg, input->len) +
PSA_CIPHER_FINISH_OUTPUT_SIZE(key_type, alg);
TEST_CALLOC_OR_FAIL(output1, output1_buffer_size);
TEST_CALLOC_OR_FAIL(output2, output2_buffer_size);
TEST_CALLOC(output1, output1_buffer_size);
TEST_CALLOC(output2, output2_buffer_size);
PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
&key));
@ -2903,7 +2903,7 @@ void cipher_encrypt_multipart(int alg_arg, int key_type_arg,
output_buffer_size = PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type, alg, input->len) +
PSA_CIPHER_FINISH_OUTPUT_SIZE(key_type, alg);
TEST_CALLOC_OR_FAIL(output, output_buffer_size);
TEST_CALLOC(output, output_buffer_size);
TEST_LE_U(first_part_size, input->len);
PSA_ASSERT(psa_cipher_update(&operation, input->x, first_part_size,
@ -3002,7 +3002,7 @@ void cipher_decrypt_multipart(int alg_arg, int key_type_arg,
output_buffer_size = PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type, alg, input->len) +
PSA_CIPHER_FINISH_OUTPUT_SIZE(key_type, alg);
TEST_CALLOC_OR_FAIL(output, output_buffer_size);
TEST_CALLOC(output, output_buffer_size);
TEST_LE_U(first_part_size, input->len);
PSA_ASSERT(psa_cipher_update(&operation,
@ -3095,13 +3095,13 @@ void cipher_decrypt_fail(int alg_arg,
/* Allocate input buffer and copy the iv and the plaintext */
input_buffer_size = ((size_t) input_arg->len + (size_t) iv->len);
if (input_buffer_size > 0) {
TEST_CALLOC_OR_FAIL(input, input_buffer_size);
TEST_CALLOC(input, input_buffer_size);
memcpy(input, iv->x, iv->len);
memcpy(input + iv->len, input_arg->x, input_arg->len);
}
output_buffer_size = PSA_CIPHER_DECRYPT_OUTPUT_SIZE(key_type, alg, input_buffer_size);
TEST_CALLOC_OR_FAIL(output, output_buffer_size);
TEST_CALLOC(output, output_buffer_size);
status = psa_cipher_decrypt(key, alg, input, input_buffer_size, output,
output_buffer_size, &output_length);
@ -3142,13 +3142,13 @@ void cipher_decrypt(int alg_arg,
/* Allocate input buffer and copy the iv and the plaintext */
input_buffer_size = ((size_t) input_arg->len + (size_t) iv->len);
if (input_buffer_size > 0) {
TEST_CALLOC_OR_FAIL(input, input_buffer_size);
TEST_CALLOC(input, input_buffer_size);
memcpy(input, iv->x, iv->len);
memcpy(input + iv->len, input_arg->x, input_arg->len);
}
output_buffer_size = PSA_CIPHER_DECRYPT_OUTPUT_SIZE(key_type, alg, input_buffer_size);
TEST_CALLOC_OR_FAIL(output, output_buffer_size);
TEST_CALLOC(output, output_buffer_size);
PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
&key));
@ -3196,7 +3196,7 @@ void cipher_verify_output(int alg_arg,
PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
&key));
output1_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE(key_type, alg, input->len);
TEST_CALLOC_OR_FAIL(output1, output1_size);
TEST_CALLOC(output1, output1_size);
PSA_ASSERT(psa_cipher_encrypt(key, alg, input->x, input->len,
output1, output1_size,
@ -3207,7 +3207,7 @@ void cipher_verify_output(int alg_arg,
PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE(input->len));
output2_size = output1_length;
TEST_CALLOC_OR_FAIL(output2, output2_size);
TEST_CALLOC(output2, output2_size);
PSA_ASSERT(psa_cipher_decrypt(key, alg, output1, output1_length,
output2, output2_size,
@ -3273,7 +3273,7 @@ void cipher_verify_output_multipart(int alg_arg,
output1_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE(key_type, alg, input->len);
TEST_LE_U(output1_buffer_size,
PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE(input->len));
TEST_CALLOC_OR_FAIL(output1, output1_buffer_size);
TEST_CALLOC(output1, output1_buffer_size);
TEST_LE_U(first_part_size, input->len);
@ -3316,7 +3316,7 @@ void cipher_verify_output_multipart(int alg_arg,
PSA_CIPHER_DECRYPT_OUTPUT_SIZE(key_type, alg, output1_length));
TEST_LE_U(output2_buffer_size,
PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE(output1_length));
TEST_CALLOC_OR_FAIL(output2, output2_buffer_size);
TEST_CALLOC(output2, output2_buffer_size);
if (iv_length > 0) {
PSA_ASSERT(psa_cipher_set_iv(&operation2,
@ -3412,7 +3412,7 @@ void aead_encrypt_decrypt(int key_type_arg, data_t *key_data,
TEST_ASSERT(output_size <=
PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE(input_data->len));
}
TEST_CALLOC_OR_FAIL(output_data, output_size);
TEST_CALLOC(output_data, output_size);
status = psa_aead_encrypt(key, alg,
nonce->x, nonce->len,
@ -3433,7 +3433,7 @@ void aead_encrypt_decrypt(int key_type_arg, data_t *key_data,
TEST_EQUAL(status, expected_result);
if (PSA_SUCCESS == expected_result) {
TEST_CALLOC_OR_FAIL(output_data2, output_length);
TEST_CALLOC(output_data2, output_length);
/* For all currently defined algorithms, PSA_AEAD_DECRYPT_OUTPUT_SIZE
* should be exact. */
@ -3501,7 +3501,7 @@ void aead_encrypt(int key_type_arg, data_t *key_data,
PSA_AEAD_ENCRYPT_OUTPUT_SIZE(key_type, alg, input_data->len));
TEST_ASSERT(output_size <=
PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE(input_data->len));
TEST_CALLOC_OR_FAIL(output_data, output_size);
TEST_CALLOC(output_data, output_size);
status = psa_aead_encrypt(key, alg,
nonce->x, nonce->len,
@ -3571,7 +3571,7 @@ void aead_decrypt(int key_type_arg, data_t *key_data,
TEST_ASSERT(output_size <=
PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE(input_data->len));
}
TEST_CALLOC_OR_FAIL(output_data, output_size);
TEST_CALLOC(output_data, output_size);
status = psa_aead_decrypt(key, alg,
nonce->x, nonce->len,
@ -3655,7 +3655,7 @@ void sign_hash_deterministic(int key_type_arg, data_t *key_data,
key_bits, alg);
TEST_ASSERT(signature_size != 0);
TEST_LE_U(signature_size, PSA_SIGNATURE_MAX_SIZE);
TEST_CALLOC_OR_FAIL(signature, signature_size);
TEST_CALLOC(signature, signature_size);
/* Perform the signature. */
PSA_ASSERT(psa_sign_hash(key, alg,
@ -3705,7 +3705,7 @@ void sign_hash_fail(int key_type_arg, data_t *key_data,
size_t signature_length = 0xdeadbeef;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
TEST_CALLOC_OR_FAIL(signature, signature_size);
TEST_CALLOC(signature, signature_size);
PSA_ASSERT(psa_crypto_init());
@ -3775,7 +3775,7 @@ void sign_verify_hash(int key_type_arg, data_t *key_data,
key_bits, alg);
TEST_ASSERT(signature_size != 0);
TEST_LE_U(signature_size, PSA_SIGNATURE_MAX_SIZE);
TEST_CALLOC_OR_FAIL(signature, signature_size);
TEST_CALLOC(signature, signature_size);
/* Perform the signature. */
PSA_ASSERT(psa_sign_hash(key, alg,
@ -3926,7 +3926,7 @@ void sign_message_deterministic(int key_type_arg,
signature_size = PSA_SIGN_OUTPUT_SIZE(key_type, key_bits, alg);
TEST_ASSERT(signature_size != 0);
TEST_LE_U(signature_size, PSA_SIGNATURE_MAX_SIZE);
TEST_CALLOC_OR_FAIL(signature, signature_size);
TEST_CALLOC(signature, signature_size);
PSA_ASSERT(psa_sign_message(key, alg,
input_data->x, input_data->len,
@ -3964,7 +3964,7 @@ void sign_message_fail(int key_type_arg,
size_t signature_length = 0xdeadbeef;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
TEST_CALLOC_OR_FAIL(signature, signature_size);
TEST_CALLOC(signature, signature_size);
PSA_ASSERT(psa_crypto_init());
@ -4024,7 +4024,7 @@ void sign_verify_message(int key_type_arg,
signature_size = PSA_SIGN_OUTPUT_SIZE(key_type, key_bits, alg);
TEST_ASSERT(signature_size != 0);
TEST_LE_U(signature_size, PSA_SIGNATURE_MAX_SIZE);
TEST_CALLOC_OR_FAIL(signature, signature_size);
TEST_CALLOC(signature, signature_size);
PSA_ASSERT(psa_sign_message(key, alg,
input_data->x, input_data->len,
@ -4164,7 +4164,7 @@ void asymmetric_encrypt(int key_type_arg,
output_size = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE(key_type, key_bits, alg);
TEST_LE_U(output_size, PSA_ASYMMETRIC_ENCRYPT_OUTPUT_MAX_SIZE);
TEST_CALLOC_OR_FAIL(output, output_size);
TEST_CALLOC(output, output_size);
/* Encrypt the input */
actual_status = psa_asymmetric_encrypt(key, alg,
@ -4246,13 +4246,13 @@ void asymmetric_encrypt_decrypt(int key_type_arg,
output_size = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE(key_type, key_bits, alg);
TEST_LE_U(output_size, PSA_ASYMMETRIC_ENCRYPT_OUTPUT_MAX_SIZE);
TEST_CALLOC_OR_FAIL(output, output_size);
TEST_CALLOC(output, output_size);
output2_size = input_data->len;
TEST_LE_U(output2_size,
PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE(key_type, key_bits, alg));
TEST_LE_U(output2_size, PSA_ASYMMETRIC_DECRYPT_OUTPUT_MAX_SIZE);
TEST_CALLOC_OR_FAIL(output2, output2_size);
TEST_CALLOC(output2, output2_size);
/* We test encryption by checking that encrypt-then-decrypt gives back
* the original plaintext because of the non-optional random
@ -4320,7 +4320,7 @@ void asymmetric_decrypt(int key_type_arg,
/* Determine the maximum ciphertext length */
output_size = PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE(key_type, key_bits, alg);
TEST_LE_U(output_size, PSA_ASYMMETRIC_DECRYPT_OUTPUT_MAX_SIZE);
TEST_CALLOC_OR_FAIL(output, output_size);
TEST_CALLOC(output, output_size);
PSA_ASSERT(psa_asymmetric_decrypt(key, alg,
input_data->x, input_data->len,
@ -4375,7 +4375,7 @@ void asymmetric_decrypt_fail(int key_type_arg,
psa_status_t expected_status = expected_status_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
TEST_CALLOC_OR_FAIL(output, output_size);
TEST_CALLOC(output, output_size);
PSA_ASSERT(psa_crypto_init());
@ -4694,7 +4694,7 @@ void derive_output(int alg_arg,
expected_outputs[i] = NULL;
}
}
TEST_CALLOC_OR_FAIL(output_buffer, output_buffer_size);
TEST_CALLOC(output_buffer, output_buffer_size);
PSA_ASSERT(psa_crypto_init());
psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DERIVE);
@ -4931,8 +4931,8 @@ void derive_key_export(int alg_arg,
psa_key_attributes_t derived_attributes = PSA_KEY_ATTRIBUTES_INIT;
size_t length;
TEST_CALLOC_OR_FAIL(output_buffer, capacity);
TEST_CALLOC_OR_FAIL(export_buffer, capacity);
TEST_CALLOC(output_buffer, capacity);
TEST_CALLOC(export_buffer, capacity);
PSA_ASSERT(psa_crypto_init());
psa_set_key_usage_flags(&base_attributes, PSA_KEY_USAGE_DERIVE);
@ -5128,7 +5128,7 @@ void raw_key_agreement(int alg_arg,
PSA_RAW_KEY_AGREEMENT_OUTPUT_MAX_SIZE);
/* Good case with exact output size */
TEST_CALLOC_OR_FAIL(output, expected_output->len);
TEST_CALLOC(output, expected_output->len);
PSA_ASSERT(psa_raw_key_agreement(alg, our_key,
peer_key_data->x, peer_key_data->len,
output, expected_output->len,
@ -5140,7 +5140,7 @@ void raw_key_agreement(int alg_arg,
output_length = ~0;
/* Larger buffer */
TEST_CALLOC_OR_FAIL(output, expected_output->len + 1);
TEST_CALLOC(output, expected_output->len + 1);
PSA_ASSERT(psa_raw_key_agreement(alg, our_key,
peer_key_data->x, peer_key_data->len,
output, expected_output->len + 1,
@ -5152,7 +5152,7 @@ void raw_key_agreement(int alg_arg,
output_length = ~0;
/* Buffer too small */
TEST_CALLOC_OR_FAIL(output, expected_output->len - 1);
TEST_CALLOC(output, expected_output->len - 1);
TEST_EQUAL(psa_raw_key_agreement(alg, our_key,
peer_key_data->x, peer_key_data->len,
output, expected_output->len - 1,
@ -5241,7 +5241,7 @@ void key_agreement_output(int alg_arg,
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
uint8_t *actual_output = NULL;
TEST_CALLOC_OR_FAIL(actual_output, MAX(expected_output1->len,
TEST_CALLOC(actual_output, MAX(expected_output1->len,
expected_output2->len));
PSA_ASSERT(psa_crypto_init());
@ -5297,8 +5297,8 @@ void generate_random(int bytes_arg)
TEST_ASSERT(bytes_arg >= 0);
TEST_CALLOC_OR_FAIL(output, bytes);
TEST_CALLOC_OR_FAIL(changed, bytes);
TEST_CALLOC(output, bytes);
TEST_CALLOC(changed, bytes);
PSA_ASSERT(psa_crypto_init());
@ -5416,8 +5416,8 @@ void generate_key_rsa(int bits_arg,
is_default_public_exponent = 1;
e_read_size = 0;
}
TEST_CALLOC_OR_FAIL(e_read_buffer, e_read_size);
TEST_CALLOC_OR_FAIL(exported, exported_size);
TEST_CALLOC(e_read_buffer, e_read_size);
TEST_CALLOC(exported, exported_size);
PSA_ASSERT(psa_crypto_init());
@ -5519,8 +5519,8 @@ void persistent_key_load_key_from_storage(data_t *data,
size_t second_exported_length;
if (usage_flags & PSA_KEY_USAGE_EXPORT) {
TEST_CALLOC_OR_FAIL(first_export, export_size);
TEST_CALLOC_OR_FAIL(second_export, export_size);
TEST_CALLOC(first_export, export_size);
TEST_CALLOC(second_export, export_size);
}
PSA_ASSERT(psa_crypto_init());

38
tests/suites/test_suite_psa_crypto_driver_wrappers.function
View File

@ -56,7 +56,7 @@ void sign_hash(int key_type_arg,
TEST_ASSERT(signature_size != 0);
TEST_ASSERT(signature_size <= PSA_SIGNATURE_MAX_SIZE);
TEST_CALLOC_OR_FAIL(signature, signature_size);
TEST_CALLOC(signature, signature_size);
actual_status = psa_sign_hash(key, alg,
data_input->x, data_input->len,
@ -183,7 +183,7 @@ void sign_message(int key_type_arg,
TEST_ASSERT(signature_size != 0);
TEST_ASSERT(signature_size <= PSA_SIGNATURE_MAX_SIZE);
TEST_CALLOC_OR_FAIL(signature, signature_size);
TEST_CALLOC(signature, signature_size);
actual_status = psa_sign_message(key, alg,
data_input->x, data_input->len,
@ -487,8 +487,8 @@ void cipher_encrypt_validation(int alg_arg,
output1_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE(key_type, alg, input->len);
output2_buffer_size = PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type, alg, input->len) +
PSA_CIPHER_FINISH_OUTPUT_SIZE(key_type, alg);
TEST_CALLOC_OR_FAIL(output1, output1_buffer_size);
TEST_CALLOC_OR_FAIL(output2, output2_buffer_size);
TEST_CALLOC(output1, output1_buffer_size);
TEST_CALLOC(output2, output2_buffer_size);
PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
&key));
@ -605,7 +605,7 @@ void cipher_encrypt_multipart(int alg_arg,
output_buffer_size = ((size_t) input->len +
PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type));
TEST_CALLOC_OR_FAIL(output, output_buffer_size);
TEST_CALLOC(output, output_buffer_size);
if (mock_output_arg) {
mbedtls_test_driver_cipher_hooks.forced_output = expected_output->x;
@ -733,7 +733,7 @@ void cipher_decrypt_multipart(int alg_arg,
output_buffer_size = ((size_t) input->len +
PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type));
TEST_CALLOC_OR_FAIL(output, output_buffer_size);
TEST_CALLOC(output, output_buffer_size);
if (mock_output_arg) {
mbedtls_test_driver_cipher_hooks.forced_output = expected_output->x;
@ -832,13 +832,13 @@ void cipher_decrypt(int alg_arg,
/* Allocate input buffer and copy the iv and the plaintext */
input_buffer_size = ((size_t) input_arg->len + (size_t) iv->len);
if (input_buffer_size > 0) {
TEST_CALLOC_OR_FAIL(input, input_buffer_size);
TEST_CALLOC(input, input_buffer_size);
memcpy(input, iv->x, iv->len);
memcpy(input + iv->len, input_arg->x, input_arg->len);
}
output_buffer_size = PSA_CIPHER_DECRYPT_OUTPUT_SIZE(key_type, alg, input_buffer_size);
TEST_CALLOC_OR_FAIL(output, output_buffer_size);
TEST_CALLOC(output, output_buffer_size);
PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
&key));
@ -885,7 +885,7 @@ void cipher_entry_points(int alg_arg, int key_type_arg,
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
TEST_CALLOC_OR_FAIL(output, input->len + 16);
TEST_CALLOC(output, input->len + 16);
output_buffer_size = input->len + 16;
PSA_ASSERT(psa_crypto_init());
@ -1125,7 +1125,7 @@ void aead_encrypt(int key_type_arg, data_t *key_data,
PSA_AEAD_ENCRYPT_OUTPUT_SIZE(key_type, alg, input_data->len));
TEST_ASSERT(output_size <=
PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE(input_data->len));
TEST_CALLOC_OR_FAIL(output_data, output_size);
TEST_CALLOC(output_data, output_size);
mbedtls_test_driver_aead_hooks.forced_status = forced_status;
status = psa_aead_encrypt(key, alg,
@ -1187,7 +1187,7 @@ void aead_decrypt(int key_type_arg, data_t *key_data,
output_size = input_data->len - PSA_AEAD_TAG_LENGTH(key_type, key_bits,
alg);
TEST_CALLOC_OR_FAIL(output_data, output_size);
TEST_CALLOC(output_data, output_size);
mbedtls_test_driver_aead_hooks.forced_status = forced_status;
status = psa_aead_decrypt(key, alg,
@ -1250,7 +1250,7 @@ void mac_sign(int key_type_arg,
PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
&key));
TEST_CALLOC_OR_FAIL(actual_mac, mac_buffer_size);
TEST_CALLOC(actual_mac, mac_buffer_size);
mbedtls_test_driver_mac_hooks.forced_status = forced_status;
/*
@ -1470,7 +1470,7 @@ void builtin_key_export(int builtin_key_id_arg,
psa_status_t actual_status;
PSA_ASSERT(psa_crypto_init());
TEST_CALLOC_OR_FAIL(output_buffer, expected_output->len);
TEST_CALLOC(output_buffer, expected_output->len);
actual_status = psa_export_key(key, output_buffer, expected_output->len, &output_size);
@ -1521,7 +1521,7 @@ void builtin_pubkey_export(int builtin_key_id_arg,
psa_status_t actual_status;
PSA_ASSERT(psa_crypto_init());
TEST_CALLOC_OR_FAIL(output_buffer, expected_output->len);
TEST_CALLOC(output_buffer, expected_output->len);
actual_status = psa_export_public_key(key, output_buffer, expected_output->len, &output_size);
@ -1564,7 +1564,7 @@ void hash_compute(int alg_arg,
mbedtls_test_driver_hash_hooks.forced_status = forced_status;
PSA_ASSERT(psa_crypto_init());
TEST_CALLOC_OR_FAIL(output, PSA_HASH_LENGTH(alg));
TEST_CALLOC(output, PSA_HASH_LENGTH(alg));
TEST_EQUAL(psa_hash_compute(alg, input->x, input->len,
output, PSA_HASH_LENGTH(alg),
@ -1597,7 +1597,7 @@ void hash_multipart_setup(int alg_arg,
size_t output_length;
mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
TEST_CALLOC_OR_FAIL(output, PSA_HASH_LENGTH(alg));
TEST_CALLOC(output, PSA_HASH_LENGTH(alg));
PSA_ASSERT(psa_crypto_init());
@ -1642,7 +1642,7 @@ void hash_multipart_update(int alg_arg,
size_t output_length;
mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
TEST_CALLOC_OR_FAIL(output, PSA_HASH_LENGTH(alg));
TEST_CALLOC(output, PSA_HASH_LENGTH(alg));
PSA_ASSERT(psa_crypto_init());
@ -1697,7 +1697,7 @@ void hash_multipart_finish(int alg_arg,
size_t output_length;
mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
TEST_CALLOC_OR_FAIL(output, PSA_HASH_LENGTH(alg));
TEST_CALLOC(output, PSA_HASH_LENGTH(alg));
PSA_ASSERT(psa_crypto_init());
@ -1751,7 +1751,7 @@ void hash_clone(int alg_arg,
size_t output_length;
mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
TEST_CALLOC_OR_FAIL(output, PSA_HASH_LENGTH(alg));
TEST_CALLOC(output, PSA_HASH_LENGTH(alg));
PSA_ASSERT(psa_crypto_init());

6
tests/suites/test_suite_psa_crypto_entropy.function
View File

@ -114,8 +114,8 @@ void external_rng_failure_sign(int key_type, data_t *key_data, int alg,
size_t signature_size = PSA_SIGNATURE_MAX_SIZE;
size_t signature_length;
TEST_CALLOC_OR_FAIL(input, input_size);
TEST_CALLOC_OR_FAIL(signature, signature_size);
TEST_CALLOC(input, input_size);
TEST_CALLOC(signature, signature_size);
PSA_ASSERT(psa_crypto_init());
PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
@ -163,7 +163,7 @@ void validate_entropy_seed_injection(int seed_length_a,
} else {
seed_size = seed_length_b;
}
TEST_CALLOC_OR_FAIL(seed, seed_size);
TEST_CALLOC(seed, seed_size);
/* fill seed with some data */
for (i = 0; i < seed_size; ++i) {
seed[i] = i;

2
tests/suites/test_suite_psa_crypto_init.function
View File

@ -289,7 +289,7 @@ void entropy_from_nv_seed(int seed_size_arg,
uint8_t *seed = NULL;
size_t seed_size = seed_size_arg;
TEST_CALLOC_OR_FAIL(seed, seed_size);
TEST_CALLOC(seed, seed_size);
TEST_ASSERT(mbedtls_nv_seed_write(seed, seed_size) >= 0);
custom_entropy_sources_mask = ENTROPY_SOURCE_NV_SEED;

6
tests/suites/test_suite_psa_crypto_persistent_key.function
View File

@ -61,7 +61,7 @@ void format_storage_data_check(data_t *key_data,
psa_set_key_algorithm(&attributes, key_alg);
psa_set_key_enrollment_algorithm(&attributes, key_alg2);
TEST_CALLOC_OR_FAIL(file_data, file_data_length);
TEST_CALLOC(file_data, file_data_length);
psa_format_key_data_for_storage(key_data->x, key_data->len,
&attributes.core,
file_data);
@ -127,7 +127,7 @@ void save_large_persistent_key(int data_length_arg, int expected_status)
size_t data_length = data_length_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
TEST_CALLOC_OR_FAIL(data, data_length);
TEST_CALLOC(data, data_length);
PSA_ASSERT(psa_crypto_init());
@ -267,7 +267,7 @@ void import_export_persistent_key(data_t *data, int type_arg,
size_t exported_length;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
TEST_CALLOC_OR_FAIL(exported, export_size);
TEST_CALLOC(exported, export_size);
PSA_ASSERT(psa_crypto_init());

2
tests/suites/test_suite_psa_crypto_se_driver_hal.function
View File

@ -601,7 +601,7 @@ static int check_persistent_data(psa_key_location_t location,
int ok = 0;
PSA_ASSERT(psa_its_get_info(uid, &info));
TEST_CALLOC_OR_FAIL(loaded, info.size);
TEST_CALLOC(loaded, info.size);
PSA_ASSERT(psa_its_get(uid, 0, info.size, loaded, NULL));
TEST_BUFFERS_EQUAL(expected_data, size, loaded, info.size);
ok = 1;

10
tests/suites/test_suite_psa_crypto_slot_management.function
View File

@ -303,7 +303,7 @@ void persistent_slot_lifecycle(int lifetime_arg, int owner_id_arg, int id_arg,
psa_get_key_type(&read_attributes));
TEST_EQUAL(psa_get_key_bits(&attributes),
psa_get_key_bits(&read_attributes));
TEST_CALLOC_OR_FAIL(reexported, key_data->len);
TEST_CALLOC(reexported, key_data->len);
if (usage_flags & PSA_KEY_USAGE_EXPORT) {
PSA_ASSERT(psa_export_key(id, reexported, key_data->len,
&reexported_length));
@ -575,7 +575,7 @@ void copy_across_lifetimes(int source_lifetime_arg, int source_owner_id_arg,
psa_get_key_enrollment_algorithm(&target_attributes));
if (expected_usage & PSA_KEY_USAGE_EXPORT) {
size_t length;
TEST_CALLOC_OR_FAIL(export_buffer, material->len);
TEST_CALLOC(export_buffer, material->len);
PSA_ASSERT(psa_export_key(returned_target_id, export_buffer,
material->len, &length));
TEST_BUFFERS_EQUAL(material->x, material->len,
@ -689,7 +689,7 @@ void copy_to_occupied(int source_lifetime_arg, int source_id_arg,
psa_get_key_algorithm(&attributes2));
if (target_usage & PSA_KEY_USAGE_EXPORT) {
size_t length;
TEST_CALLOC_OR_FAIL(export_buffer, target_material->len);
TEST_CALLOC(export_buffer, target_material->len);
PSA_ASSERT(psa_export_key(returned_target_id, export_buffer,
target_material->len, &length));
TEST_BUFFERS_EQUAL(target_material->x, target_material->len,
@ -813,7 +813,7 @@ void many_transient_keys(int max_keys_arg)
uint8_t exported[sizeof(size_t)];
size_t exported_length;
TEST_CALLOC_OR_FAIL(keys, max_keys);
TEST_CALLOC(keys, max_keys);
PSA_ASSERT(psa_crypto_init());
psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
@ -942,7 +942,7 @@ void non_reusable_key_slots_integrity_in_case_of_key_slot_starvation()
TEST_ASSERT(MBEDTLS_PSA_KEY_SLOT_COUNT >= 1);
TEST_CALLOC_OR_FAIL(keys, MBEDTLS_PSA_KEY_SLOT_COUNT);
TEST_CALLOC(keys, MBEDTLS_PSA_KEY_SLOT_COUNT);
PSA_ASSERT(psa_crypto_init());
psa_set_key_usage_flags(&attributes,

4
tests/suites/test_suite_psa_crypto_storage_format.function
View File

@ -36,7 +36,7 @@ static int test_written_key(const psa_key_attributes_t *attributes,
/* Check that the key is represented as expected. */
PSA_ASSERT(psa_its_get_info(uid, &storage_info));
TEST_EQUAL(storage_info.size, expected_representation->len);
TEST_CALLOC_OR_FAIL(actual_representation, storage_info.size);
TEST_CALLOC(actual_representation, storage_info.size);
PSA_ASSERT(psa_its_get(uid, 0, storage_info.size,
actual_representation, &length));
TEST_BUFFERS_EQUAL(expected_representation->x, expected_representation->len,
@ -268,7 +268,7 @@ static int test_read_key(const psa_key_attributes_t *expected_attributes,
TEST_EQUAL(psa_get_key_enrollment_algorithm(expected_attributes),
psa_get_key_enrollment_algorithm(&actual_attributes));
if (can_export(expected_attributes)) {
TEST_CALLOC_OR_FAIL(exported_material, expected_material->len);
TEST_CALLOC(exported_material, expected_material->len);
PSA_ASSERT(psa_export_key(key_id,
exported_material, expected_material->len,
&length));

6
tests/suites/test_suite_psa_its.function
View File

@ -92,7 +92,7 @@ void set_get_remove(int uid_arg, int flags_arg, data_t *data)
unsigned char *buffer = NULL;
size_t ret_len = 0;
TEST_CALLOC_OR_FAIL(buffer, data->len);
TEST_CALLOC(buffer, data->len);
PSA_ASSERT(psa_its_set_wrap(uid, data->len, data->x, flags));
@ -122,7 +122,7 @@ void set_overwrite(int uid_arg,
unsigned char *buffer = NULL;
size_t ret_len = 0;
TEST_CALLOC_OR_FAIL(buffer, MAX(data1->len, data2->len));
TEST_CALLOC(buffer, MAX(data1->len, data2->len));
PSA_ASSERT(psa_its_set_wrap(uid, data1->len, data1->x, flags1));
PSA_ASSERT(psa_its_get_info(uid, &info));
@ -214,7 +214,7 @@ void get_at(int uid_arg, data_t *data,
size_t i;
size_t ret_len = 0;
TEST_CALLOC_OR_FAIL(buffer, length + 16);
TEST_CALLOC(buffer, length + 16);
trailer = buffer + length;
memset(trailer, '-', 16);

2
tests/suites/test_suite_random.function
View File

@ -163,7 +163,7 @@ void mbedtls_psa_get_random_length(int n)
unsigned char *output = NULL;
PSA_ASSERT(psa_crypto_init());
TEST_CALLOC_OR_FAIL(output, n);
TEST_CALLOC(output, n);
TEST_EQUAL(0, mbedtls_psa_get_random(MBEDTLS_PSA_RANDOM_STATE,
output, n));

8
tests/suites/test_suite_ssl.function
View File

@ -147,7 +147,7 @@ void test_callback_buffer(int size, int put1, int put1_ret,
if (input_len == 0) {
input_len = 1;
}
TEST_CALLOC_OR_FAIL(input, input_len);
TEST_CALLOC(input, input_len);
output_len = 0;
for (j = 0; j < ROUNDS; j++) {
@ -161,7 +161,7 @@ void test_callback_buffer(int size, int put1, int put1_ret,
if (output_len == 0) {
output_len = 1;
}
TEST_CALLOC_OR_FAIL(output, output_len);
TEST_CALLOC(output, output_len);
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
@ -1516,8 +1516,8 @@ void ssl_decrypt_non_etm_cbc(int cipher_type, int hash_id, int trunc_hmac,
+ plaintext_len
+ t0.maclen
+ padlen + 1;
TEST_CALLOC_OR_FAIL(buf, buflen);
TEST_CALLOC_OR_FAIL(buf_save, buflen);
TEST_CALLOC(buf, buflen);
TEST_CALLOC(buf_save, buflen);
/* Prepare a dummy record header */
memset(rec.ctr, 0, sizeof(rec.ctr));