Switch to the new code style
Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
diff --git a/tests/configs/config-wrapper-malloc-0-null.h b/tests/configs/config-wrapper-malloc-0-null.h
index add1a78..622ac57 100644
--- a/tests/configs/config-wrapper-malloc-0-null.h
+++ b/tests/configs/config-wrapper-malloc-0-null.h
@@ -26,11 +26,12 @@
#include <stdlib.h>
#ifndef MBEDTLS_PLATFORM_STD_CALLOC
-static inline void *custom_calloc( size_t nmemb, size_t size )
+static inline void *custom_calloc(size_t nmemb, size_t size)
{
- if( nmemb == 0 || size == 0 )
- return( NULL );
- return( calloc( nmemb, size ) );
+ if (nmemb == 0 || size == 0) {
+ return NULL;
+ }
+ return calloc(nmemb, size);
}
#define MBEDTLS_PLATFORM_MEMORY
diff --git a/tests/include/spe/crypto_spe.h b/tests/include/spe/crypto_spe.h
index 1aee8a5..a79ce17 100644
--- a/tests/include/spe/crypto_spe.h
+++ b/tests/include/spe/crypto_spe.h
@@ -34,110 +34,110 @@
#define PSA_FUNCTION_NAME(x) mbedcrypto__ ## x
#define psa_crypto_init \
- PSA_FUNCTION_NAME(psa_crypto_init)
+ PSA_FUNCTION_NAME(psa_crypto_init)
#define psa_key_derivation_get_capacity \
- PSA_FUNCTION_NAME(psa_key_derivation_get_capacity)
+ PSA_FUNCTION_NAME(psa_key_derivation_get_capacity)
#define psa_key_derivation_set_capacity \
- PSA_FUNCTION_NAME(psa_key_derivation_set_capacity)
+ PSA_FUNCTION_NAME(psa_key_derivation_set_capacity)
#define psa_key_derivation_input_bytes \
- PSA_FUNCTION_NAME(psa_key_derivation_input_bytes)
+ PSA_FUNCTION_NAME(psa_key_derivation_input_bytes)
#define psa_key_derivation_output_bytes \
- PSA_FUNCTION_NAME(psa_key_derivation_output_bytes)
+ PSA_FUNCTION_NAME(psa_key_derivation_output_bytes)
#define psa_key_derivation_input_key \
- PSA_FUNCTION_NAME(psa_key_derivation_input_key)
+ PSA_FUNCTION_NAME(psa_key_derivation_input_key)
#define psa_key_derivation_output_key \
- PSA_FUNCTION_NAME(psa_key_derivation_output_key)
+ PSA_FUNCTION_NAME(psa_key_derivation_output_key)
#define psa_key_derivation_setup \
- PSA_FUNCTION_NAME(psa_key_derivation_setup)
+ PSA_FUNCTION_NAME(psa_key_derivation_setup)
#define psa_key_derivation_abort \
- PSA_FUNCTION_NAME(psa_key_derivation_abort)
+ PSA_FUNCTION_NAME(psa_key_derivation_abort)
#define psa_key_derivation_key_agreement \
- PSA_FUNCTION_NAME(psa_key_derivation_key_agreement)
+ PSA_FUNCTION_NAME(psa_key_derivation_key_agreement)
#define psa_raw_key_agreement \
- PSA_FUNCTION_NAME(psa_raw_key_agreement)
+ PSA_FUNCTION_NAME(psa_raw_key_agreement)
#define psa_generate_random \
- PSA_FUNCTION_NAME(psa_generate_random)
+ PSA_FUNCTION_NAME(psa_generate_random)
#define psa_aead_encrypt \
- PSA_FUNCTION_NAME(psa_aead_encrypt)
+ PSA_FUNCTION_NAME(psa_aead_encrypt)
#define psa_aead_decrypt \
- PSA_FUNCTION_NAME(psa_aead_decrypt)
+ PSA_FUNCTION_NAME(psa_aead_decrypt)
#define psa_open_key \
- PSA_FUNCTION_NAME(psa_open_key)
+ PSA_FUNCTION_NAME(psa_open_key)
#define psa_close_key \
- PSA_FUNCTION_NAME(psa_close_key)
+ PSA_FUNCTION_NAME(psa_close_key)
#define psa_import_key \
- PSA_FUNCTION_NAME(psa_import_key)
+ PSA_FUNCTION_NAME(psa_import_key)
#define psa_destroy_key \
- PSA_FUNCTION_NAME(psa_destroy_key)
+ PSA_FUNCTION_NAME(psa_destroy_key)
#define psa_get_key_attributes \
- PSA_FUNCTION_NAME(psa_get_key_attributes)
+ PSA_FUNCTION_NAME(psa_get_key_attributes)
#define psa_reset_key_attributes \
- PSA_FUNCTION_NAME(psa_reset_key_attributes)
+ PSA_FUNCTION_NAME(psa_reset_key_attributes)
#define psa_export_key \
- PSA_FUNCTION_NAME(psa_export_key)
+ PSA_FUNCTION_NAME(psa_export_key)
#define psa_export_public_key \
- PSA_FUNCTION_NAME(psa_export_public_key)
+ PSA_FUNCTION_NAME(psa_export_public_key)
#define psa_purge_key \
- PSA_FUNCTION_NAME(psa_purge_key)
+ PSA_FUNCTION_NAME(psa_purge_key)
#define psa_copy_key \
- PSA_FUNCTION_NAME(psa_copy_key)
+ PSA_FUNCTION_NAME(psa_copy_key)
#define psa_cipher_operation_init \
- PSA_FUNCTION_NAME(psa_cipher_operation_init)
+ PSA_FUNCTION_NAME(psa_cipher_operation_init)
#define psa_cipher_generate_iv \
- PSA_FUNCTION_NAME(psa_cipher_generate_iv)
+ PSA_FUNCTION_NAME(psa_cipher_generate_iv)
#define psa_cipher_set_iv \
- PSA_FUNCTION_NAME(psa_cipher_set_iv)
+ PSA_FUNCTION_NAME(psa_cipher_set_iv)
#define psa_cipher_encrypt_setup \
- PSA_FUNCTION_NAME(psa_cipher_encrypt_setup)
+ PSA_FUNCTION_NAME(psa_cipher_encrypt_setup)
#define psa_cipher_decrypt_setup \
- PSA_FUNCTION_NAME(psa_cipher_decrypt_setup)
+ PSA_FUNCTION_NAME(psa_cipher_decrypt_setup)
#define psa_cipher_update \
- PSA_FUNCTION_NAME(psa_cipher_update)
+ PSA_FUNCTION_NAME(psa_cipher_update)
#define psa_cipher_finish \
- PSA_FUNCTION_NAME(psa_cipher_finish)
+ PSA_FUNCTION_NAME(psa_cipher_finish)
#define psa_cipher_abort \
- PSA_FUNCTION_NAME(psa_cipher_abort)
+ PSA_FUNCTION_NAME(psa_cipher_abort)
#define psa_hash_operation_init \
- PSA_FUNCTION_NAME(psa_hash_operation_init)
+ PSA_FUNCTION_NAME(psa_hash_operation_init)
#define psa_hash_setup \
- PSA_FUNCTION_NAME(psa_hash_setup)
+ PSA_FUNCTION_NAME(psa_hash_setup)
#define psa_hash_update \
- PSA_FUNCTION_NAME(psa_hash_update)
+ PSA_FUNCTION_NAME(psa_hash_update)
#define psa_hash_finish \
- PSA_FUNCTION_NAME(psa_hash_finish)
+ PSA_FUNCTION_NAME(psa_hash_finish)
#define psa_hash_verify \
- PSA_FUNCTION_NAME(psa_hash_verify)
+ PSA_FUNCTION_NAME(psa_hash_verify)
#define psa_hash_abort \
- PSA_FUNCTION_NAME(psa_hash_abort)
+ PSA_FUNCTION_NAME(psa_hash_abort)
#define psa_hash_clone \
- PSA_FUNCTION_NAME(psa_hash_clone)
+ PSA_FUNCTION_NAME(psa_hash_clone)
#define psa_hash_compute \
- PSA_FUNCTION_NAME(psa_hash_compute)
+ PSA_FUNCTION_NAME(psa_hash_compute)
#define psa_hash_compare \
- PSA_FUNCTION_NAME(psa_hash_compare)
+ PSA_FUNCTION_NAME(psa_hash_compare)
#define psa_mac_operation_init \
- PSA_FUNCTION_NAME(psa_mac_operation_init)
+ PSA_FUNCTION_NAME(psa_mac_operation_init)
#define psa_mac_sign_setup \
- PSA_FUNCTION_NAME(psa_mac_sign_setup)
+ PSA_FUNCTION_NAME(psa_mac_sign_setup)
#define psa_mac_verify_setup \
- PSA_FUNCTION_NAME(psa_mac_verify_setup)
+ PSA_FUNCTION_NAME(psa_mac_verify_setup)
#define psa_mac_update \
- PSA_FUNCTION_NAME(psa_mac_update)
+ PSA_FUNCTION_NAME(psa_mac_update)
#define psa_mac_sign_finish \
- PSA_FUNCTION_NAME(psa_mac_sign_finish)
+ PSA_FUNCTION_NAME(psa_mac_sign_finish)
#define psa_mac_verify_finish \
- PSA_FUNCTION_NAME(psa_mac_verify_finish)
+ PSA_FUNCTION_NAME(psa_mac_verify_finish)
#define psa_mac_abort \
- PSA_FUNCTION_NAME(psa_mac_abort)
+ PSA_FUNCTION_NAME(psa_mac_abort)
#define psa_sign_hash \
- PSA_FUNCTION_NAME(psa_sign_hash)
+ PSA_FUNCTION_NAME(psa_sign_hash)
#define psa_verify_hash \
- PSA_FUNCTION_NAME(psa_verify_hash)
+ PSA_FUNCTION_NAME(psa_verify_hash)
#define psa_asymmetric_encrypt \
- PSA_FUNCTION_NAME(psa_asymmetric_encrypt)
+ PSA_FUNCTION_NAME(psa_asymmetric_encrypt)
#define psa_asymmetric_decrypt \
- PSA_FUNCTION_NAME(psa_asymmetric_decrypt)
+ PSA_FUNCTION_NAME(psa_asymmetric_decrypt)
#define psa_generate_key \
- PSA_FUNCTION_NAME(psa_generate_key)
+ PSA_FUNCTION_NAME(psa_generate_key)
#endif /* CRYPTO_SPE_H */
diff --git a/tests/include/test/asn1_helpers.h b/tests/include/test/asn1_helpers.h
index 91ae260..dee3cbd 100644
--- a/tests/include/test/asn1_helpers.h
+++ b/tests/include/test/asn1_helpers.h
@@ -43,8 +43,8 @@
*
* \return \c 0 if the test failed, otherwise 1.
*/
-int mbedtls_test_asn1_skip_integer( unsigned char **p, const unsigned char *end,
- size_t min_bits, size_t max_bits,
- int must_be_odd );
+int mbedtls_test_asn1_skip_integer(unsigned char **p, const unsigned char *end,
+ size_t min_bits, size_t max_bits,
+ int must_be_odd);
#endif /* ASN1_HELPERS_H */
diff --git a/tests/include/test/drivers/aead.h b/tests/include/test/drivers/aead.h
index 2207cb3..182bed2 100644
--- a/tests/include/test/drivers/aead.h
+++ b/tests/include/test/drivers/aead.h
@@ -41,10 +41,10 @@
#define MBEDTLS_TEST_DRIVER_AEAD_INIT { 0, 0, 0 }
static inline mbedtls_test_driver_aead_hooks_t
- mbedtls_test_driver_aead_hooks_init( void )
+mbedtls_test_driver_aead_hooks_init(void)
{
const mbedtls_test_driver_aead_hooks_t v = MBEDTLS_TEST_DRIVER_AEAD_INIT;
- return( v );
+ return v;
}
extern mbedtls_test_driver_aead_hooks_t mbedtls_test_driver_aead_hooks;
@@ -56,7 +56,7 @@
const uint8_t *nonce, size_t nonce_length,
const uint8_t *additional_data, size_t additional_data_length,
const uint8_t *plaintext, size_t plaintext_length,
- uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length );
+ uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length);
psa_status_t mbedtls_test_transparent_aead_decrypt(
const psa_key_attributes_t *attributes,
@@ -65,7 +65,7 @@
const uint8_t *nonce, size_t nonce_length,
const uint8_t *additional_data, size_t additional_data_length,
const uint8_t *ciphertext, size_t ciphertext_length,
- uint8_t *plaintext, size_t plaintext_size, size_t *plaintext_length );
+ uint8_t *plaintext, size_t plaintext_size, size_t *plaintext_length);
#endif /* PSA_CRYPTO_DRIVER_TEST */
#endif /* PSA_CRYPTO_TEST_DRIVERS_AEAD_H */
diff --git a/tests/include/test/drivers/cipher.h b/tests/include/test/drivers/cipher.h
index c1aa616..2bd7b62 100644
--- a/tests/include/test/drivers/cipher.h
+++ b/tests/include/test/drivers/cipher.h
@@ -45,10 +45,10 @@
#define MBEDTLS_TEST_DRIVER_CIPHER_INIT { NULL, 0, PSA_SUCCESS, 0 }
static inline mbedtls_test_driver_cipher_hooks_t
- mbedtls_test_driver_cipher_hooks_init( void )
+mbedtls_test_driver_cipher_hooks_init(void)
{
const mbedtls_test_driver_cipher_hooks_t v = MBEDTLS_TEST_DRIVER_CIPHER_INIT;
- return( v );
+ return v;
}
extern mbedtls_test_driver_cipher_hooks_t mbedtls_test_driver_cipher_hooks;
@@ -81,7 +81,7 @@
psa_algorithm_t alg);
psa_status_t mbedtls_test_transparent_cipher_abort(
- mbedtls_transparent_test_driver_cipher_operation_t *operation );
+ mbedtls_transparent_test_driver_cipher_operation_t *operation);
psa_status_t mbedtls_test_transparent_cipher_set_iv(
mbedtls_transparent_test_driver_cipher_operation_t *operation,
diff --git a/tests/include/test/drivers/hash.h b/tests/include/test/drivers/hash.h
index 865cd74..de7ebc5 100644
--- a/tests/include/test/drivers/hash.h
+++ b/tests/include/test/drivers/hash.h
@@ -41,10 +41,10 @@
#define MBEDTLS_TEST_DRIVER_HASH_INIT { 0, 0, 0 }
static inline mbedtls_test_driver_hash_hooks_t
- mbedtls_test_driver_hash_hooks_init( void )
+mbedtls_test_driver_hash_hooks_init(void)
{
const mbedtls_test_driver_hash_hooks_t v = MBEDTLS_TEST_DRIVER_HASH_INIT;
- return( v );
+ return v;
}
extern mbedtls_test_driver_hash_hooks_t mbedtls_test_driver_hash_hooks;
@@ -52,29 +52,29 @@
psa_status_t mbedtls_test_transparent_hash_compute(
psa_algorithm_t alg,
const uint8_t *input, size_t input_length,
- uint8_t *hash, size_t hash_size, size_t *hash_length );
+ uint8_t *hash, size_t hash_size, size_t *hash_length);
psa_status_t mbedtls_test_transparent_hash_setup(
mbedtls_transparent_test_driver_hash_operation_t *operation,
- psa_algorithm_t alg );
+ psa_algorithm_t alg);
psa_status_t mbedtls_test_transparent_hash_clone(
const mbedtls_transparent_test_driver_hash_operation_t *source_operation,
- mbedtls_transparent_test_driver_hash_operation_t *target_operation );
+ mbedtls_transparent_test_driver_hash_operation_t *target_operation);
psa_status_t mbedtls_test_transparent_hash_update(
mbedtls_transparent_test_driver_hash_operation_t *operation,
const uint8_t *input,
- size_t input_length );
+ size_t input_length);
psa_status_t mbedtls_test_transparent_hash_finish(
mbedtls_transparent_test_driver_hash_operation_t *operation,
uint8_t *hash,
size_t hash_size,
- size_t *hash_length );
+ size_t *hash_length);
psa_status_t mbedtls_test_transparent_hash_abort(
- mbedtls_transparent_test_driver_hash_operation_t *operation );
+ mbedtls_transparent_test_driver_hash_operation_t *operation);
#endif /* PSA_CRYPTO_DRIVER_TEST */
#endif /* PSA_CRYPTO_TEST_DRIVERS_HASH_H */
diff --git a/tests/include/test/drivers/key_management.h b/tests/include/test/drivers/key_management.h
index c8dfbb3..d10ba4b 100644
--- a/tests/include/test/drivers/key_management.h
+++ b/tests/include/test/drivers/key_management.h
@@ -52,43 +52,43 @@
* used as a location of an opaque test drivers. */
#define MBEDTLS_TEST_DRIVER_KEY_MANAGEMENT_INIT { NULL, 0, PSA_SUCCESS, 0, 0x800000 }
static inline mbedtls_test_driver_key_management_hooks_t
- mbedtls_test_driver_key_management_hooks_init( void )
+mbedtls_test_driver_key_management_hooks_init(void)
{
const mbedtls_test_driver_key_management_hooks_t
v = MBEDTLS_TEST_DRIVER_KEY_MANAGEMENT_INIT;
- return( v );
+ return v;
}
extern mbedtls_test_driver_key_management_hooks_t
mbedtls_test_driver_key_management_hooks;
-psa_status_t mbedtls_test_transparent_init( void );
-void mbedtls_test_transparent_free( void );
-psa_status_t mbedtls_test_opaque_init( void );
-void mbedtls_test_opaque_free( void );
+psa_status_t mbedtls_test_transparent_init(void);
+void mbedtls_test_transparent_free(void);
+psa_status_t mbedtls_test_opaque_init(void);
+void mbedtls_test_opaque_free(void);
psa_status_t mbedtls_test_transparent_generate_key(
const psa_key_attributes_t *attributes,
- uint8_t *key, size_t key_size, size_t *key_length );
+ uint8_t *key, size_t key_size, size_t *key_length);
psa_status_t mbedtls_test_opaque_generate_key(
const psa_key_attributes_t *attributes,
- uint8_t *key, size_t key_size, size_t *key_length );
+ uint8_t *key, size_t key_size, size_t *key_length);
psa_status_t mbedtls_test_opaque_export_key(
const psa_key_attributes_t *attributes,
const uint8_t *key, size_t key_length,
- uint8_t *data, size_t data_size, size_t *data_length );
+ uint8_t *data, size_t data_size, size_t *data_length);
psa_status_t mbedtls_test_transparent_export_public_key(
const psa_key_attributes_t *attributes,
const uint8_t *key, size_t key_length,
- uint8_t *data, size_t data_size, size_t *data_length );
+ uint8_t *data, size_t data_size, size_t *data_length);
psa_status_t mbedtls_test_opaque_export_public_key(
const psa_key_attributes_t *attributes,
const uint8_t *key, size_t key_length,
- uint8_t *data, size_t data_size, size_t *data_length );
+ uint8_t *data, size_t data_size, size_t *data_length);
psa_status_t mbedtls_test_transparent_import_key(
const psa_key_attributes_t *attributes,
@@ -102,7 +102,7 @@
psa_status_t mbedtls_test_opaque_get_builtin_key(
psa_drv_slot_number_t slot_number,
psa_key_attributes_t *attributes,
- uint8_t *key_buffer, size_t key_buffer_size, size_t *key_buffer_length );
+ uint8_t *key_buffer, size_t key_buffer_size, size_t *key_buffer_length);
#endif /* PSA_CRYPTO_DRIVER_TEST */
#endif /* PSA_CRYPTO_TEST_DRIVERS_KEY_MANAGEMENT_H */
diff --git a/tests/include/test/drivers/mac.h b/tests/include/test/drivers/mac.h
index 7733dd3..8af1335 100644
--- a/tests/include/test/drivers/mac.h
+++ b/tests/include/test/drivers/mac.h
@@ -41,10 +41,10 @@
#define MBEDTLS_TEST_DRIVER_MAC_INIT { 0, 0, 0 }
static inline mbedtls_test_driver_mac_hooks_t
- mbedtls_test_driver_mac_hooks_init( void )
+mbedtls_test_driver_mac_hooks_init(void)
{
const mbedtls_test_driver_mac_hooks_t v = MBEDTLS_TEST_DRIVER_MAC_INIT;
- return( v );
+ return v;
}
extern mbedtls_test_driver_mac_hooks_t mbedtls_test_driver_mac_hooks;
@@ -58,40 +58,40 @@
size_t input_length,
uint8_t *mac,
size_t mac_size,
- size_t *mac_length );
+ size_t *mac_length);
psa_status_t mbedtls_test_transparent_mac_sign_setup(
mbedtls_transparent_test_driver_mac_operation_t *operation,
const psa_key_attributes_t *attributes,
const uint8_t *key_buffer,
size_t key_buffer_size,
- psa_algorithm_t alg );
+ psa_algorithm_t alg);
psa_status_t mbedtls_test_transparent_mac_verify_setup(
mbedtls_transparent_test_driver_mac_operation_t *operation,
const psa_key_attributes_t *attributes,
const uint8_t *key_buffer,
size_t key_buffer_size,
- psa_algorithm_t alg );
+ psa_algorithm_t alg);
psa_status_t mbedtls_test_transparent_mac_update(
mbedtls_transparent_test_driver_mac_operation_t *operation,
const uint8_t *input,
- size_t input_length );
+ size_t input_length);
psa_status_t mbedtls_test_transparent_mac_sign_finish(
mbedtls_transparent_test_driver_mac_operation_t *operation,
uint8_t *mac,
size_t mac_size,
- size_t *mac_length );
+ size_t *mac_length);
psa_status_t mbedtls_test_transparent_mac_verify_finish(
mbedtls_transparent_test_driver_mac_operation_t *operation,
const uint8_t *mac,
- size_t mac_length );
+ size_t mac_length);
psa_status_t mbedtls_test_transparent_mac_abort(
- mbedtls_transparent_test_driver_mac_operation_t *operation );
+ mbedtls_transparent_test_driver_mac_operation_t *operation);
psa_status_t mbedtls_test_opaque_mac_compute(
const psa_key_attributes_t *attributes,
@@ -102,40 +102,40 @@
size_t input_length,
uint8_t *mac,
size_t mac_size,
- size_t *mac_length );
+ size_t *mac_length);
psa_status_t mbedtls_test_opaque_mac_sign_setup(
mbedtls_opaque_test_driver_mac_operation_t *operation,
const psa_key_attributes_t *attributes,
const uint8_t *key_buffer,
size_t key_buffer_size,
- psa_algorithm_t alg );
+ psa_algorithm_t alg);
psa_status_t mbedtls_test_opaque_mac_verify_setup(
mbedtls_opaque_test_driver_mac_operation_t *operation,
const psa_key_attributes_t *attributes,
const uint8_t *key_buffer,
size_t key_buffer_size,
- psa_algorithm_t alg );
+ psa_algorithm_t alg);
psa_status_t mbedtls_test_opaque_mac_update(
mbedtls_opaque_test_driver_mac_operation_t *operation,
const uint8_t *input,
- size_t input_length );
+ size_t input_length);
psa_status_t mbedtls_test_opaque_mac_sign_finish(
mbedtls_opaque_test_driver_mac_operation_t *operation,
uint8_t *mac,
size_t mac_size,
- size_t *mac_length );
+ size_t *mac_length);
psa_status_t mbedtls_test_opaque_mac_verify_finish(
mbedtls_opaque_test_driver_mac_operation_t *operation,
const uint8_t *mac,
- size_t mac_length );
+ size_t mac_length);
psa_status_t mbedtls_test_opaque_mac_abort(
- mbedtls_opaque_test_driver_mac_operation_t *operation );
+ mbedtls_opaque_test_driver_mac_operation_t *operation);
#endif /* PSA_CRYPTO_DRIVER_TEST */
#endif /* PSA_CRYPTO_TEST_DRIVERS_MAC_H */
diff --git a/tests/include/test/drivers/signature.h b/tests/include/test/drivers/signature.h
index 5e64edc..4a2465b 100644
--- a/tests/include/test/drivers/signature.h
+++ b/tests/include/test/drivers/signature.h
@@ -42,11 +42,11 @@
#define MBEDTLS_TEST_DRIVER_SIGNATURE_INIT { NULL, 0, PSA_SUCCESS, 0 }
static inline mbedtls_test_driver_signature_hooks_t
- mbedtls_test_driver_signature_hooks_init( void )
+mbedtls_test_driver_signature_hooks_init(void)
{
const mbedtls_test_driver_signature_hooks_t
v = MBEDTLS_TEST_DRIVER_SIGNATURE_INIT;
- return( v );
+ return v;
}
extern mbedtls_test_driver_signature_hooks_t
@@ -63,7 +63,7 @@
size_t input_length,
uint8_t *signature,
size_t signature_size,
- size_t *signature_length );
+ size_t *signature_length);
psa_status_t mbedtls_test_opaque_signature_sign_message(
const psa_key_attributes_t *attributes,
@@ -74,7 +74,7 @@
size_t input_length,
uint8_t *signature,
size_t signature_size,
- size_t *signature_length );
+ size_t *signature_length);
psa_status_t mbedtls_test_transparent_signature_verify_message(
const psa_key_attributes_t *attributes,
@@ -84,7 +84,7 @@
const uint8_t *input,
size_t input_length,
const uint8_t *signature,
- size_t signature_length );
+ size_t signature_length);
psa_status_t mbedtls_test_opaque_signature_verify_message(
const psa_key_attributes_t *attributes,
@@ -94,35 +94,35 @@
const uint8_t *input,
size_t input_length,
const uint8_t *signature,
- size_t signature_length );
+ size_t signature_length);
psa_status_t mbedtls_test_transparent_signature_sign_hash(
const psa_key_attributes_t *attributes,
const uint8_t *key, size_t key_length,
psa_algorithm_t alg,
const uint8_t *hash, size_t hash_length,
- uint8_t *signature, size_t signature_size, size_t *signature_length );
+ uint8_t *signature, size_t signature_size, size_t *signature_length);
psa_status_t mbedtls_test_opaque_signature_sign_hash(
const psa_key_attributes_t *attributes,
const uint8_t *key, size_t key_length,
psa_algorithm_t alg,
const uint8_t *hash, size_t hash_length,
- uint8_t *signature, size_t signature_size, size_t *signature_length );
+ uint8_t *signature, size_t signature_size, size_t *signature_length);
psa_status_t mbedtls_test_transparent_signature_verify_hash(
const psa_key_attributes_t *attributes,
const uint8_t *key, size_t key_length,
psa_algorithm_t alg,
const uint8_t *hash, size_t hash_length,
- const uint8_t *signature, size_t signature_length );
+ const uint8_t *signature, size_t signature_length);
psa_status_t mbedtls_test_opaque_signature_verify_hash(
const psa_key_attributes_t *attributes,
const uint8_t *key, size_t key_length,
psa_algorithm_t alg,
const uint8_t *hash, size_t hash_length,
- const uint8_t *signature, size_t signature_length );
+ const uint8_t *signature, size_t signature_length);
#endif /* PSA_CRYPTO_DRIVER_TEST */
#endif /* PSA_CRYPTO_TEST_DRIVERS_SIGNATURE_H */
diff --git a/tests/include/test/drivers/size.h b/tests/include/test/drivers/size.h
index b2665bd..9d0adcf 100644
--- a/tests/include/test/drivers/size.h
+++ b/tests/include/test/drivers/size.h
@@ -31,7 +31,7 @@
size_t mbedtls_test_size_function(
const psa_key_type_t key_type,
- const size_t key_bits );
+ const size_t key_bits);
#endif /* PSA_CRYPTO_DRIVER_TEST */
#endif /* PSA_CRYPTO_TEST_DRIVERS_SIZE_H */
diff --git a/tests/include/test/fake_external_rng_for_test.h b/tests/include/test/fake_external_rng_for_test.h
index faeef22..ad8e1c6 100644
--- a/tests/include/test/fake_external_rng_for_test.h
+++ b/tests/include/test/fake_external_rng_for_test.h
@@ -44,13 +44,13 @@
* of the PSA subsystem. You may disable it temporarily to simulate a
* depleted entropy source.
*/
-void mbedtls_test_enable_insecure_external_rng( void );
+void mbedtls_test_enable_insecure_external_rng(void);
/** Disable the insecure implementation of mbedtls_psa_external_get_random().
*
* See mbedtls_test_enable_insecure_external_rng().
*/
-void mbedtls_test_disable_insecure_external_rng( void );
+void mbedtls_test_disable_insecure_external_rng(void);
#endif /* MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */
#endif /* FAKE_EXTERNAL_RNG_FOR_TEST_H */
diff --git a/tests/include/test/helpers.h b/tests/include/test/helpers.h
index 7a87c5b..9d60c20 100644
--- a/tests/include/test/helpers.h
+++ b/tests/include/test/helpers.h
@@ -46,21 +46,18 @@
#endif
/** The type of test case arguments that contain binary data. */
-typedef struct data_tag
-{
- uint8_t * x;
+typedef struct data_tag {
+ uint8_t *x;
uint32_t len;
} data_t;
-typedef enum
-{
+typedef enum {
MBEDTLS_TEST_RESULT_SUCCESS = 0,
MBEDTLS_TEST_RESULT_FAILED,
MBEDTLS_TEST_RESULT_SKIPPED
} mbedtls_test_result_t;
-typedef struct
-{
+typedef struct {
mbedtls_test_result_t result;
const char *test;
const char *filename;
@@ -75,8 +72,8 @@
mbedtls_test_info_t;
extern mbedtls_test_info_t mbedtls_test_info;
-int mbedtls_test_platform_setup( void );
-void mbedtls_test_platform_teardown( void );
+int mbedtls_test_platform_setup(void);
+void mbedtls_test_platform_teardown(void);
/**
* \brief Record the current test case as a failure.
@@ -94,7 +91,7 @@
* \param line_no Line number where the failure originated.
* \param filename Filename where the failure originated.
*/
-void mbedtls_test_fail( const char *test, int line_no, const char* filename );
+void mbedtls_test_fail(const char *test, int line_no, const char *filename);
/**
* \brief Record the current test case as skipped.
@@ -107,7 +104,7 @@
* \param line_no Line number where the test case was skipped.
* \param filename Filename where the test case was skipped.
*/
-void mbedtls_test_skip( const char *test, int line_no, const char* filename );
+void mbedtls_test_skip(const char *test, int line_no, const char *filename);
/**
* \brief Set the test step number for failure reports.
@@ -119,12 +116,12 @@
*
* \param step The step number to report.
*/
-void mbedtls_test_set_step( unsigned long step );
+void mbedtls_test_set_step(unsigned long step);
/**
* \brief Reset mbedtls_test_info to a ready/starting state.
*/
-void mbedtls_test_info_reset( void );
+void mbedtls_test_info_reset(void);
/**
* \brief Record the current test case as a failure if two integers
@@ -144,8 +141,8 @@
*
* \return \c 1 if the values are equal, otherwise \c 0.
*/
-int mbedtls_test_equal( const char *test, int line_no, const char* filename,
- unsigned long long value1, unsigned long long value2 );
+int mbedtls_test_equal(const char *test, int line_no, const char *filename,
+ unsigned long long value1, unsigned long long value2);
/**
* \brief Record the current test case as a failure based
@@ -165,8 +162,8 @@
*
* \return \c 1 if \p value1 <= \p value2, otherwise \c 0.
*/
-int mbedtls_test_le_u( const char *test, int line_no, const char* filename,
- unsigned long long value1, unsigned long long value2 );
+int mbedtls_test_le_u(const char *test, int line_no, const char *filename,
+ unsigned long long value1, unsigned long long value2);
/**
* \brief Record the current test case as a failure based
@@ -186,8 +183,8 @@
*
* \return \c 1 if \p value1 <= \p value2, otherwise \c 0.
*/
-int mbedtls_test_le_s( const char *test, int line_no, const char* filename,
- long long value1, long long value2 );
+int mbedtls_test_le_s(const char *test, int line_no, const char *filename,
+ long long value1, long long value2);
/**
* \brief This function decodes the hexadecimal representation of
@@ -207,12 +204,12 @@
* \return \c -1 if the output buffer is too small or the input string
* is not a valid hexadecimal representation.
*/
-int mbedtls_test_unhexify( unsigned char *obuf, size_t obufmax,
- const char *ibuf, size_t *len );
+int mbedtls_test_unhexify(unsigned char *obuf, size_t obufmax,
+ const char *ibuf, size_t *len);
-void mbedtls_test_hexify( unsigned char *obuf,
- const unsigned char *ibuf,
- int len );
+void mbedtls_test_hexify(unsigned char *obuf,
+ const unsigned char *ibuf,
+ int len);
/**
* Allocate and zeroize a buffer.
@@ -221,7 +218,7 @@
*
* For convenience, dies if allocation fails.
*/
-unsigned char *mbedtls_test_zero_alloc( size_t len );
+unsigned char *mbedtls_test_zero_alloc(size_t len);
/**
* Allocate and fill a buffer from hex data.
@@ -233,15 +230,14 @@
*
* For convenience, dies if allocation fails.
*/
-unsigned char *mbedtls_test_unhexify_alloc( const char *ibuf, size_t *olen );
+unsigned char *mbedtls_test_unhexify_alloc(const char *ibuf, size_t *olen);
-int mbedtls_test_hexcmp( uint8_t * a, uint8_t * b,
- uint32_t a_len, uint32_t b_len );
+int mbedtls_test_hexcmp(uint8_t *a, uint8_t *b,
+ uint32_t a_len, uint32_t b_len);
#if defined(MBEDTLS_CHECK_PARAMS)
-typedef struct
-{
+typedef struct {
const char *failure_condition;
const char *file;
int line;
@@ -257,7 +253,7 @@
* mbedtls_param_failed() that cancels it.
*/
void mbedtls_test_param_failed_get_location_record(
- mbedtls_test_param_failed_location_record_t *location_record );
+ mbedtls_test_param_failed_location_record_t *location_record);
/**
* \brief State that a call to mbedtls_param_failed() is expected.
@@ -266,7 +262,7 @@
* mbedtls_test_param_failed_check_expected_call() or
* mbedtls_param_failed that cancel it.
*/
-void mbedtls_test_param_failed_expect_call( void );
+void mbedtls_test_param_failed_expect_call(void);
/**
* \brief Check whether mbedtls_param_failed() has been called as expected.
@@ -279,7 +275,7 @@
* mbedtls_param_failed() has been called.
* \c -1 Otherwise.
*/
-int mbedtls_test_param_failed_check_expected_call( void );
+int mbedtls_test_param_failed_check_expected_call(void);
/**
* \brief Get the address of the object of type jmp_buf holding the execution
@@ -308,7 +304,7 @@
* \return Address of the object of type jmp_buf holding the execution state
* information used by mbedtls_param_failed() to do a long jump.
*/
-void* mbedtls_test_param_failed_get_state_buf( void );
+void *mbedtls_test_param_failed_get_state_buf(void);
/**
* \brief Reset the execution state used by mbedtls_param_failed() to do a
@@ -324,7 +320,7 @@
* mbedtls_param_failed() will not trigger a long jump with
* undefined behavior but rather a long jump that will rather fault.
*/
-void mbedtls_test_param_failed_reset_state( void );
+void mbedtls_test_param_failed_reset_state(void);
#endif /* MBEDTLS_CHECK_PARAMS */
#if defined(MBEDTLS_PSA_CRYPTO_C) && defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
@@ -334,11 +330,11 @@
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
/** Permanently activate the mutex usage verification framework. See
* threading_helpers.c for information. */
-void mbedtls_test_mutex_usage_init( void );
+void mbedtls_test_mutex_usage_init(void);
/** Call this function after executing a test case to check for mutex usage
* errors. */
-void mbedtls_test_mutex_usage_check( void );
+void mbedtls_test_mutex_usage_check(void);
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
#if defined(MBEDTLS_TEST_HOOKS)
@@ -353,8 +349,8 @@
*
* \note If the check fails, fail the test currently being run.
*/
-void mbedtls_test_err_add_check( int high, int low,
- const char *file, int line);
+void mbedtls_test_err_add_check(int high, int low,
+ const char *file, int line);
#endif
#if defined(MBEDTLS_BIGNUM_C)
@@ -379,7 +375,7 @@
*
* \return \c 0 on success, an \c MBEDTLS_ERR_MPI_xxx error code otherwise.
*/
-int mbedtls_test_read_mpi( mbedtls_mpi *X, const char *s );
+int mbedtls_test_read_mpi(mbedtls_mpi *X, const char *s);
/** Nonzero if the current test case had an input parsed with
* mbedtls_test_read_mpi() that is a negative 0 (`"-"`, `"-0"`, `"-00"`, etc.,
diff --git a/tests/include/test/macros.h b/tests/include/test/macros.h
index f9de646..2354205 100644
--- a/tests/include/test/macros.h
+++ b/tests/include/test/macros.h
@@ -62,14 +62,14 @@
*
* \param TEST The test expression to be tested.
*/
-#define TEST_ASSERT( TEST ) \
+#define TEST_ASSERT(TEST) \
do { \
- if( ! (TEST) ) \
- { \
- mbedtls_test_fail( #TEST, __LINE__, __FILE__ ); \
- goto exit; \
- } \
- } while( 0 )
+ if (!(TEST)) \
+ { \
+ mbedtls_test_fail( #TEST, __LINE__, __FILE__); \
+ goto exit; \
+ } \
+ } while (0)
/** Evaluate two integer expressions and fail the test case if they have
* different values.
@@ -80,12 +80,12 @@
* \param expr1 An integral-typed expression to evaluate.
* \param expr2 Another integral-typed expression to evaluate.
*/
-#define TEST_EQUAL( expr1, expr2 ) \
+#define TEST_EQUAL(expr1, expr2) \
do { \
- if( ! mbedtls_test_equal( #expr1 " == " #expr2, __LINE__, __FILE__, \
- expr1, expr2 ) ) \
- goto exit; \
- } while( 0 )
+ if (!mbedtls_test_equal( #expr1 " == " #expr2, __LINE__, __FILE__, \
+ expr1, expr2)) \
+ goto exit; \
+ } while (0)
/** Evaluate two unsigned integer expressions and fail the test case
* if they are not in increasing order (left <= right).
@@ -93,12 +93,12 @@
* \param expr1 An integral-typed expression to evaluate.
* \param expr2 Another integral-typed expression to evaluate.
*/
-#define TEST_LE_U( expr1, expr2 ) \
+#define TEST_LE_U(expr1, expr2) \
do { \
- if( ! mbedtls_test_le_u( #expr1 " <= " #expr2, __LINE__, __FILE__, \
- expr1, expr2 ) ) \
- goto exit; \
- } while( 0 )
+ if (!mbedtls_test_le_u( #expr1 " <= " #expr2, __LINE__, __FILE__, \
+ expr1, expr2)) \
+ goto exit; \
+ } while (0)
/** Evaluate two signed integer expressions and fail the test case
* if they are not in increasing order (left <= right).
@@ -106,12 +106,12 @@
* \param expr1 An integral-typed expression to evaluate.
* \param expr2 Another integral-typed expression to evaluate.
*/
-#define TEST_LE_S( expr1, expr2 ) \
+#define TEST_LE_S(expr1, expr2) \
do { \
- if( ! mbedtls_test_le_s( #expr1 " <= " #expr2, __LINE__, __FILE__, \
- expr1, expr2 ) ) \
- goto exit; \
- } while( 0 )
+ if (!mbedtls_test_le_s( #expr1 " <= " #expr2, __LINE__, __FILE__, \
+ expr1, expr2)) \
+ goto exit; \
+ } while (0)
/** Allocate memory dynamically and fail the test case if this fails.
* The allocated memory will be filled with zeros.
@@ -133,36 +133,36 @@
* This expression may be evaluated multiple times.
*
*/
-#define ASSERT_ALLOC( pointer, length ) \
+#define ASSERT_ALLOC(pointer, length) \
do \
{ \
- TEST_ASSERT( ( pointer ) == NULL ); \
- if( ( length ) != 0 ) \
+ TEST_ASSERT((pointer) == NULL); \
+ if ((length) != 0) \
{ \
- ( pointer ) = mbedtls_calloc( sizeof( *( pointer ) ), \
- ( length ) ); \
- TEST_ASSERT( ( pointer ) != NULL ); \
+ (pointer) = mbedtls_calloc(sizeof(*(pointer)), \
+ (length)); \
+ TEST_ASSERT((pointer) != NULL); \
} \
} \
- while( 0 )
+ while (0)
/** Allocate memory dynamically. If the allocation fails, skip the test case.
*
* This macro behaves like #ASSERT_ALLOC, except that if the allocation
* fails, it marks the test as skipped rather than failed.
*/
-#define ASSERT_ALLOC_WEAK( pointer, length ) \
+#define ASSERT_ALLOC_WEAK(pointer, length) \
do \
{ \
- TEST_ASSERT( ( pointer ) == NULL ); \
- if( ( length ) != 0 ) \
+ TEST_ASSERT((pointer) == NULL); \
+ if ((length) != 0) \
{ \
- ( pointer ) = mbedtls_calloc( sizeof( *( pointer ) ), \
- ( length ) ); \
- TEST_ASSUME( ( pointer ) != NULL ); \
+ (pointer) = mbedtls_calloc(sizeof(*(pointer)), \
+ (length)); \
+ TEST_ASSUME((pointer) != NULL); \
} \
} \
- while( 0 )
+ while (0)
/** Compare two buffers and fail the test case if they differ.
*
@@ -176,14 +176,14 @@
* \param size2 Size of the second buffer in bytes.
* This expression may be evaluated multiple times.
*/
-#define ASSERT_COMPARE( p1, size1, p2, size2 ) \
+#define ASSERT_COMPARE(p1, size1, p2, size2) \
do \
{ \
- TEST_ASSERT( ( size1 ) == ( size2 ) ); \
- if( ( size1 ) != 0 ) \
- TEST_ASSERT( memcmp( ( p1 ), ( p2 ), ( size1 ) ) == 0 ); \
+ TEST_ASSERT((size1) == (size2)); \
+ if ((size1) != 0) \
+ TEST_ASSERT(memcmp((p1), (p2), (size1)) == 0); \
} \
- while( 0 )
+ while (0)
/**
* \brief This macro tests the expression passed to it and skips the
@@ -191,14 +191,14 @@
*
* \param TEST The test expression to be tested.
*/
-#define TEST_ASSUME( TEST ) \
+#define TEST_ASSUME(TEST) \
do { \
- if( ! (TEST) ) \
+ if (!(TEST)) \
{ \
- mbedtls_test_skip( #TEST, __LINE__, __FILE__ ); \
+ mbedtls_test_skip( #TEST, __LINE__, __FILE__); \
goto exit; \
} \
- } while( 0 )
+ } while (0)
#if defined(MBEDTLS_CHECK_PARAMS) && !defined(MBEDTLS_PARAM_FAILED_ALT)
/**
@@ -221,17 +221,17 @@
*
* \param TEST The test expression to be tested.
*/
-#define TEST_INVALID_PARAM_RET( PARAM_ERR_VALUE, TEST ) \
+#define TEST_INVALID_PARAM_RET(PARAM_ERR_VALUE, TEST) \
do { \
- mbedtls_test_param_failed_expect_call( ); \
- if( ( ( TEST ) != ( PARAM_ERR_VALUE ) ) || \
- ( mbedtls_test_param_failed_check_expected_call( ) != 0 ) ) \
+ mbedtls_test_param_failed_expect_call(); \
+ if (((TEST) != (PARAM_ERR_VALUE)) || \
+ (mbedtls_test_param_failed_check_expected_call() != 0)) \
{ \
- mbedtls_test_fail( #TEST, __LINE__, __FILE__ ); \
+ mbedtls_test_fail( #TEST, __LINE__, __FILE__); \
goto exit; \
} \
- mbedtls_test_param_failed_check_expected_call( ); \
- } while( 0 )
+ mbedtls_test_param_failed_check_expected_call(); \
+ } while (0)
/**
* \brief This macro tests the statement passed to it as a test step or
@@ -253,18 +253,18 @@
*
* \param TEST The test expression to be tested.
*/
-#define TEST_INVALID_PARAM( TEST ) \
+#define TEST_INVALID_PARAM(TEST) \
do { \
- memcpy( jmp_tmp, mbedtls_test_param_failed_get_state_buf( ), \
- sizeof( jmp_tmp ) ); \
- if( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 ) \
+ memcpy(jmp_tmp, mbedtls_test_param_failed_get_state_buf(), \
+ sizeof(jmp_tmp)); \
+ if (setjmp(mbedtls_test_param_failed_get_state_buf()) == 0) \
{ \
TEST; \
- mbedtls_test_fail( #TEST, __LINE__, __FILE__ ); \
+ mbedtls_test_fail( #TEST, __LINE__, __FILE__); \
goto exit; \
} \
- mbedtls_test_param_failed_reset_state( ); \
- } while( 0 )
+ mbedtls_test_param_failed_reset_state(); \
+ } while (0)
#endif /* MBEDTLS_CHECK_PARAMS && !MBEDTLS_PARAM_FAILED_ALT */
/**
@@ -298,15 +298,15 @@
*
* \param TEST The test expression to be tested.
*/
-#define TEST_VALID_PARAM( TEST ) \
- TEST_ASSERT( ( TEST, 1 ) );
+#define TEST_VALID_PARAM(TEST) \
+ TEST_ASSERT((TEST, 1));
-#define TEST_HELPER_ASSERT(a) if( !( a ) ) \
-{ \
- mbedtls_fprintf( stderr, "Assertion Failed at %s:%d - %s\n", \
- __FILE__, __LINE__, #a ); \
- mbedtls_exit( 1 ); \
-}
+#define TEST_HELPER_ASSERT(a) if (!(a)) \
+ { \
+ mbedtls_fprintf(stderr, "Assertion Failed at %s:%d - %s\n", \
+ __FILE__, __LINE__, #a); \
+ mbedtls_exit(1); \
+ }
/** \def ARRAY_LENGTH
* Return the number of elements of a static or stack array.
@@ -317,34 +317,34 @@
*/
/* A correct implementation of ARRAY_LENGTH, but which silently gives
* a nonsensical result if called with a pointer rather than an array. */
-#define ARRAY_LENGTH_UNSAFE( array ) \
- ( sizeof( array ) / sizeof( *( array ) ) )
+#define ARRAY_LENGTH_UNSAFE(array) \
+ (sizeof(array) / sizeof(*(array)))
#if defined(__GNUC__)
/* Test if arg and &(arg)[0] have the same type. This is true if arg is
* an array but not if it's a pointer. */
-#define IS_ARRAY_NOT_POINTER( arg ) \
- ( ! __builtin_types_compatible_p( __typeof__( arg ), \
- __typeof__( &( arg )[0] ) ) )
+#define IS_ARRAY_NOT_POINTER(arg) \
+ (!__builtin_types_compatible_p(__typeof__(arg), \
+ __typeof__(&(arg)[0])))
/* A compile-time constant with the value 0. If `const_expr` is not a
* compile-time constant with a nonzero value, cause a compile-time error. */
-#define STATIC_ASSERT_EXPR( const_expr ) \
- ( 0 && sizeof( struct { unsigned int STATIC_ASSERT : 1 - 2 * ! ( const_expr ); } ) )
+#define STATIC_ASSERT_EXPR(const_expr) \
+ (0 && sizeof(struct { unsigned int STATIC_ASSERT : 1 - 2 * !(const_expr); }))
/* Return the scalar value `value` (possibly promoted). This is a compile-time
* constant if `value` is. `condition` must be a compile-time constant.
* If `condition` is false, arrange to cause a compile-time error. */
-#define STATIC_ASSERT_THEN_RETURN( condition, value ) \
- ( STATIC_ASSERT_EXPR( condition ) ? 0 : ( value ) )
+#define STATIC_ASSERT_THEN_RETURN(condition, value) \
+ (STATIC_ASSERT_EXPR(condition) ? 0 : (value))
-#define ARRAY_LENGTH( array ) \
- ( STATIC_ASSERT_THEN_RETURN( IS_ARRAY_NOT_POINTER( array ), \
- ARRAY_LENGTH_UNSAFE( array ) ) )
+#define ARRAY_LENGTH(array) \
+ (STATIC_ASSERT_THEN_RETURN(IS_ARRAY_NOT_POINTER(array), \
+ ARRAY_LENGTH_UNSAFE(array)))
#else
/* If we aren't sure the compiler supports our non-standard tricks,
* fall back to the unsafe implementation. */
-#define ARRAY_LENGTH( array ) ARRAY_LENGTH_UNSAFE( array )
+#define ARRAY_LENGTH(array) ARRAY_LENGTH_UNSAFE(array)
#endif
/** Return the smaller of two values.
@@ -354,7 +354,7 @@
*
* \return The smaller of \p x and \p y.
*/
-#define MIN( x, y ) ( ( x ) < ( y ) ? ( x ) : ( y ) )
+#define MIN(x, y) ((x) < (y) ? (x) : (y))
/** Return the larger of two values.
*
@@ -363,29 +363,29 @@
*
* \return The larger of \p x and \p y.
*/
-#define MAX( x, y ) ( ( x ) > ( y ) ? ( x ) : ( y ) )
+#define MAX(x, y) ((x) > (y) ? (x) : (y))
/*
* 32-bit integer manipulation macros (big endian)
*/
#ifndef GET_UINT32_BE
-#define GET_UINT32_BE(n,b,i) \
-{ \
- (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
- | ( (uint32_t) (b)[(i) + 1] << 16 ) \
- | ( (uint32_t) (b)[(i) + 2] << 8 ) \
- | ( (uint32_t) (b)[(i) + 3] ); \
-}
+#define GET_UINT32_BE(n, b, i) \
+ { \
+ (n) = ((uint32_t) (b)[(i)] << 24) \
+ | ((uint32_t) (b)[(i) + 1] << 16) \
+ | ((uint32_t) (b)[(i) + 2] << 8) \
+ | ((uint32_t) (b)[(i) + 3]); \
+ }
#endif
#ifndef PUT_UINT32_BE
-#define PUT_UINT32_BE(n,b,i) \
-{ \
- (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
- (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
- (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
- (b)[(i) + 3] = (unsigned char) ( (n) ); \
-}
+#define PUT_UINT32_BE(n, b, i) \
+ { \
+ (b)[(i)] = (unsigned char) ((n) >> 24); \
+ (b)[(i) + 1] = (unsigned char) ((n) >> 16); \
+ (b)[(i) + 2] = (unsigned char) ((n) >> 8); \
+ (b)[(i) + 3] = (unsigned char) ((n)); \
+ }
#endif
#endif /* TEST_MACROS_H */
diff --git a/tests/include/test/psa_crypto_helpers.h b/tests/include/test/psa_crypto_helpers.h
index 7dc829b..08179e2 100644
--- a/tests/include/test/psa_crypto_helpers.h
+++ b/tests/include/test/psa_crypto_helpers.h
@@ -36,11 +36,11 @@
#if defined(MBEDTLS_PSA_CRYPTO_STORAGE_C)
/* Internal function for #TEST_USES_KEY_ID. Return 1 on success, 0 on failure. */
-int mbedtls_test_uses_key_id( mbedtls_svc_key_id_t key_id );
+int mbedtls_test_uses_key_id(mbedtls_svc_key_id_t key_id);
/** Destroy persistent keys recorded with #TEST_USES_KEY_ID.
*/
-void mbedtls_test_psa_purge_key_storage( void );
+void mbedtls_test_psa_purge_key_storage(void);
/** Purge the in-memory cache of persistent keys recorded with
* #TEST_USES_KEY_ID.
@@ -48,7 +48,7 @@
* Call this function before calling PSA_DONE() if it's ok for
* persistent keys to still exist at this point.
*/
-void mbedtls_test_psa_purge_key_cache( void );
+void mbedtls_test_psa_purge_key_cache(void);
/** \def TEST_USES_KEY_ID
*
@@ -75,18 +75,18 @@
*
* \param key_id The PSA key identifier to record.
*/
-#define TEST_USES_KEY_ID( key_id ) \
- TEST_ASSERT( mbedtls_test_uses_key_id( key_id ) )
+#define TEST_USES_KEY_ID(key_id) \
+ TEST_ASSERT(mbedtls_test_uses_key_id(key_id))
#else /* MBEDTLS_PSA_CRYPTO_STORAGE_C */
-#define TEST_USES_KEY_ID( key_id ) ( (void) ( key_id ) )
-#define mbedtls_test_psa_purge_key_storage( ) ( (void) 0 )
-#define mbedtls_test_psa_purge_key_cache( ) ( (void) 0 )
+#define TEST_USES_KEY_ID(key_id) ((void) (key_id))
+#define mbedtls_test_psa_purge_key_storage() ((void) 0)
+#define mbedtls_test_psa_purge_key_cache() ((void) 0)
#endif /* MBEDTLS_PSA_CRYPTO_STORAGE_C */
-#define PSA_INIT( ) PSA_ASSERT( psa_crypto_init( ) )
+#define PSA_INIT() PSA_ASSERT(psa_crypto_init())
/** Check for things that have not been cleaned up properly in the
* PSA subsystem.
@@ -95,7 +95,7 @@
* \return A string literal explaining what has not been cleaned up
* if applicable.
*/
-const char *mbedtls_test_helper_is_psa_leaking( void );
+const char *mbedtls_test_helper_is_psa_leaking(void);
/** Check that no PSA Crypto key slots are in use.
*
@@ -104,13 +104,13 @@
* `TEST_ASSERT( ! mbedtls_test_helper_is_psa_leaking( ) )`
* but with a more informative message.
*/
-#define ASSERT_PSA_PRISTINE( ) \
+#define ASSERT_PSA_PRISTINE() \
do \
{ \
- if( test_fail_if_psa_leaking( __LINE__, __FILE__ ) ) \
- goto exit; \
+ if (test_fail_if_psa_leaking(__LINE__, __FILE__)) \
+ goto exit; \
} \
- while( 0 )
+ while (0)
/** Shut down the PSA Crypto subsystem and destroy persistent keys.
* Expect a clean shutdown, with no slots in use.
@@ -122,14 +122,14 @@
* \note Persistent keys must be recorded with #TEST_USES_KEY_ID before
* creating them.
*/
-#define PSA_DONE( ) \
+#define PSA_DONE() \
do \
{ \
- test_fail_if_psa_leaking( __LINE__, __FILE__ ); \
- mbedtls_test_psa_purge_key_storage( ); \
- mbedtls_psa_crypto_free( ); \
+ test_fail_if_psa_leaking(__LINE__, __FILE__); \
+ mbedtls_test_psa_purge_key_storage(); \
+ mbedtls_psa_crypto_free(); \
} \
- while( 0 )
+ while (0)
/** Shut down the PSA Crypto subsystem, allowing persistent keys to survive.
* Expect a clean shutdown, with no slots in use.
@@ -137,22 +137,22 @@
* If some key slots are still in use, record the test case as failed and
* jump to the `exit` label.
*/
-#define PSA_SESSION_DONE( ) \
+#define PSA_SESSION_DONE() \
do \
{ \
- mbedtls_test_psa_purge_key_cache( ); \
- ASSERT_PSA_PRISTINE( ); \
- mbedtls_psa_crypto_free( ); \
+ mbedtls_test_psa_purge_key_cache(); \
+ ASSERT_PSA_PRISTINE(); \
+ mbedtls_psa_crypto_free(); \
} \
- while( 0 )
+ while (0)
#if defined(RECORD_PSA_STATUS_COVERAGE_LOG)
-psa_status_t mbedtls_test_record_status( psa_status_t status,
- const char *func,
- const char *file, int line,
- const char *expr );
+psa_status_t mbedtls_test_record_status(psa_status_t status,
+ const char *func,
+ const char *file, int line,
+ const char *expr);
/** Return value logging wrapper macro.
*
@@ -178,8 +178,8 @@
* a value of type #psa_status_t.
* \return The value of \p expr.
*/
-#define RECORD_STATUS( string, expr ) \
- mbedtls_test_record_status( ( expr ), string, __FILE__, __LINE__, #expr )
+#define RECORD_STATUS(string, expr) \
+ mbedtls_test_record_status((expr), string, __FILE__, __LINE__, #expr)
#include "instrument_record_status.h"
@@ -191,7 +191,7 @@
* permissions of other usage policies
* (like PSA_KEY_USAGE_SIGN_HASH involves PSA_KEY_USAGE_SIGN_MESSAGE).
*/
-psa_key_usage_t mbedtls_test_update_key_usage_flags( psa_key_usage_t usage_flags );
+psa_key_usage_t mbedtls_test_update_key_usage_flags(psa_key_usage_t usage_flags);
/** Skip a test case if the given key is a 192 bits AES key and the AES
* implementation is at least partially provided by an accelerator or
@@ -220,18 +220,18 @@
#define MBEDTLS_TEST_HAVE_ALT_AES 0
#endif
-#define MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_bits ) \
+#define MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192(key_type, key_bits) \
do \
{ \
- if( ( MBEDTLS_TEST_HAVE_ALT_AES ) && \
- ( ( key_type ) == PSA_KEY_TYPE_AES ) && \
- ( key_bits == 192 ) ) \
+ if ((MBEDTLS_TEST_HAVE_ALT_AES) && \
+ ((key_type) == PSA_KEY_TYPE_AES) && \
+ (key_bits == 192)) \
{ \
- mbedtls_test_skip( "AES-192 not supported", __LINE__, __FILE__ ); \
+ mbedtls_test_skip("AES-192 not supported", __LINE__, __FILE__); \
goto exit; \
} \
} \
- while( 0 )
+ while (0)
/** Skip a test case if a GCM operation with a nonce length different from
* 12 bytes fails and was performed by an accelerator or alternative
@@ -262,20 +262,20 @@
#define MBEDTLS_TEST_HAVE_ALT_GCM 0
#endif
-#define MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, \
- nonce_length ) \
+#define MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE(alg, \
+ nonce_length) \
do \
{ \
- if( ( MBEDTLS_TEST_HAVE_ALT_GCM ) && \
- ( PSA_ALG_AEAD_WITH_SHORTENED_TAG( ( alg ) , 0 ) == \
- PSA_ALG_AEAD_WITH_SHORTENED_TAG( PSA_ALG_GCM, 0 ) ) && \
- ( ( nonce_length ) != 12 ) ) \
+ if ((MBEDTLS_TEST_HAVE_ALT_GCM) && \
+ (PSA_ALG_AEAD_WITH_SHORTENED_TAG((alg), 0) == \
+ PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_GCM, 0)) && \
+ ((nonce_length) != 12)) \
{ \
- mbedtls_test_skip( "GCM with non-12-byte IV is not supported", __LINE__, __FILE__ ); \
+ mbedtls_test_skip("GCM with non-12-byte IV is not supported", __LINE__, __FILE__); \
goto exit; \
} \
} \
- while( 0 )
+ while (0)
#endif /* MBEDTLS_PSA_CRYPTO_C */
@@ -292,14 +292,14 @@
* #MBEDTLS_USE_PSA_CRYPTO is disabled.
*/
#if defined(MBEDTLS_USE_PSA_CRYPTO)
-#define USE_PSA_INIT( ) PSA_INIT( )
-#define USE_PSA_DONE( ) PSA_DONE( )
+#define USE_PSA_INIT() PSA_INIT()
+#define USE_PSA_DONE() PSA_DONE()
#else /* MBEDTLS_USE_PSA_CRYPTO */
/* Define empty macros so that we can use them in the preamble and teardown
* of every test function that uses PSA conditionally based on
* MBEDTLS_USE_PSA_CRYPTO. */
-#define USE_PSA_INIT( ) ( (void) 0 )
-#define USE_PSA_DONE( ) ( (void) 0 )
+#define USE_PSA_INIT() ((void) 0)
+#define USE_PSA_DONE() ((void) 0)
#endif /* !MBEDTLS_USE_PSA_CRYPTO */
#endif /* PSA_CRYPTO_HELPERS_H */
diff --git a/tests/include/test/psa_exercise_key.h b/tests/include/test/psa_exercise_key.h
index 4306c1a..179df18 100644
--- a/tests/include/test/psa_exercise_key.h
+++ b/tests/include/test/psa_exercise_key.h
@@ -109,7 +109,7 @@
* This is used in some smoke tests.
*/
#if defined(KNOWN_SUPPORTED_HASH_ALG) && defined(PSA_WANT_ALG_HMAC)
-#define KNOWN_SUPPORTED_MAC_ALG ( PSA_ALG_HMAC( KNOWN_SUPPORTED_HASH_ALG ) )
+#define KNOWN_SUPPORTED_MAC_ALG (PSA_ALG_HMAC(KNOWN_SUPPORTED_HASH_ALG))
#define KNOWN_SUPPORTED_MAC_KEY_TYPE PSA_KEY_TYPE_HMAC
#elif defined(KNOWN_SUPPORTED_BLOCK_CIPHER) && defined(MBEDTLS_CMAC_C)
#define KNOWN_SUPPORTED_MAC_ALG PSA_ALG_CMAC
@@ -168,12 +168,12 @@
* \return \c 1 on success, \c 0 on failure.
*/
int mbedtls_test_psa_setup_key_derivation_wrap(
- psa_key_derivation_operation_t* operation,
+ psa_key_derivation_operation_t *operation,
mbedtls_svc_key_id_t key,
psa_algorithm_t alg,
- const unsigned char* input1, size_t input1_length,
- const unsigned char* input2, size_t input2_length,
- size_t capacity );
+ const unsigned char *input1, size_t input1_length,
+ const unsigned char *input2, size_t input2_length,
+ size_t capacity);
/** Perform a key agreement using the given key pair against its public key
* using psa_raw_key_agreement().
@@ -189,7 +189,7 @@
*/
psa_status_t mbedtls_test_psa_raw_key_agreement_with_self(
psa_algorithm_t alg,
- mbedtls_svc_key_id_t key );
+ mbedtls_svc_key_id_t key);
/** Perform a key agreement using the given key pair against its public key
* using psa_key_derivation_raw_key().
@@ -208,7 +208,7 @@
*/
psa_status_t mbedtls_test_psa_key_agreement_with_self(
psa_key_derivation_operation_t *operation,
- mbedtls_svc_key_id_t key );
+ mbedtls_svc_key_id_t key);
/** Perform sanity checks on the given key representation.
*
@@ -230,7 +230,7 @@
*/
int mbedtls_test_psa_exported_key_sanity_check(
psa_key_type_t type, size_t bits,
- const uint8_t *exported, size_t exported_length );
+ const uint8_t *exported, size_t exported_length);
/** Do smoke tests on a key.
*
@@ -259,11 +259,11 @@
* \retval 0 The key failed the smoke tests.
* \retval 1 The key passed the smoke tests.
*/
-int mbedtls_test_psa_exercise_key( mbedtls_svc_key_id_t key,
- psa_key_usage_t usage,
- psa_algorithm_t alg );
+int mbedtls_test_psa_exercise_key(mbedtls_svc_key_id_t key,
+ psa_key_usage_t usage,
+ psa_algorithm_t alg);
-psa_key_usage_t mbedtls_test_psa_usage_to_exercise( psa_key_type_t type,
- psa_algorithm_t alg );
+psa_key_usage_t mbedtls_test_psa_usage_to_exercise(psa_key_type_t type,
+ psa_algorithm_t alg);
#endif /* PSA_EXERCISE_KEY_H */
diff --git a/tests/include/test/psa_helpers.h b/tests/include/test/psa_helpers.h
index f438a71..2665fac 100644
--- a/tests/include/test/psa_helpers.h
+++ b/tests/include/test/psa_helpers.h
@@ -31,6 +31,6 @@
* to a \c psa_xxx function that returns a value of type
* #psa_status_t.
*/
-#define PSA_ASSERT( expr ) TEST_EQUAL( ( expr ), PSA_SUCCESS )
+#define PSA_ASSERT(expr) TEST_EQUAL((expr), PSA_SUCCESS)
#endif /* PSA_HELPERS_H */
diff --git a/tests/include/test/random.h b/tests/include/test/random.h
index 6428280..4f7b55c 100644
--- a/tests/include/test/random.h
+++ b/tests/include/test/random.h
@@ -34,12 +34,11 @@
#include <stddef.h>
#include <stdint.h>
-typedef struct
-{
+typedef struct {
unsigned char *buf; /* Pointer to a buffer of length bytes. */
size_t length;
/* If fallback_f_rng is NULL, fail after delivering length bytes. */
- int ( *fallback_f_rng )( void*, unsigned char *, size_t );
+ int (*fallback_f_rng)(void *, unsigned char *, size_t);
void *fallback_p_rng;
} mbedtls_test_rnd_buf_info;
@@ -50,8 +49,7 @@
* Do not forget endianness!
* State( v0, v1 ) should be set to zero.
*/
-typedef struct
-{
+typedef struct {
uint32_t key[16];
uint32_t v0, v1;
} mbedtls_test_rnd_pseudo_info;
@@ -65,18 +63,18 @@
*
* rng_state shall be NULL.
*/
-int mbedtls_test_rnd_std_rand( void *rng_state,
- unsigned char *output,
- size_t len );
+int mbedtls_test_rnd_std_rand(void *rng_state,
+ unsigned char *output,
+ size_t len);
/**
* This function only returns zeros.
*
* \p rng_state shall be \c NULL.
*/
-int mbedtls_test_rnd_zero_rand( void *rng_state,
- unsigned char *output,
- size_t len );
+int mbedtls_test_rnd_zero_rand(void *rng_state,
+ unsigned char *output,
+ size_t len);
/**
* This function returns random data based on a buffer it receives.
@@ -90,9 +88,9 @@
* #mbedtls_test_rnd_buf_info structure if there is one, and
* will return #MBEDTLS_ERR_ENTROPY_SOURCE_FAILED otherwise.
*/
-int mbedtls_test_rnd_buffer_rand( void *rng_state,
- unsigned char *output,
- size_t len );
+int mbedtls_test_rnd_buffer_rand(void *rng_state,
+ unsigned char *output,
+ size_t len);
/**
* This function returns random based on a pseudo random function.
@@ -102,8 +100,8 @@
*
* \p rng_state shall be a pointer to a #mbedtls_test_rnd_pseudo_info structure.
*/
-int mbedtls_test_rnd_pseudo_rand( void *rng_state,
- unsigned char *output,
- size_t len );
+int mbedtls_test_rnd_pseudo_rand(void *rng_state,
+ unsigned char *output,
+ size_t len);
#endif /* TEST_RANDOM_H */
diff --git a/tests/src/asn1_helpers.c b/tests/src/asn1_helpers.c
index 79aa166..aaf7587 100644
--- a/tests/src/asn1_helpers.c
+++ b/tests/src/asn1_helpers.c
@@ -27,48 +27,48 @@
#include <mbedtls/asn1.h>
-int mbedtls_test_asn1_skip_integer( unsigned char **p, const unsigned char *end,
- size_t min_bits, size_t max_bits,
- int must_be_odd )
+int mbedtls_test_asn1_skip_integer(unsigned char **p, const unsigned char *end,
+ size_t min_bits, size_t max_bits,
+ int must_be_odd)
{
size_t len;
size_t actual_bits;
unsigned char msb;
- TEST_EQUAL( mbedtls_asn1_get_tag( p, end, &len,
- MBEDTLS_ASN1_INTEGER ),
- 0 );
+ TEST_EQUAL(mbedtls_asn1_get_tag(p, end, &len,
+ MBEDTLS_ASN1_INTEGER),
+ 0);
/* Check if the retrieved length doesn't extend the actual buffer's size.
* It is assumed here, that end >= p, which validates casting to size_t. */
- TEST_ASSERT( len <= (size_t)( end - *p) );
+ TEST_ASSERT(len <= (size_t) (end - *p));
/* Tolerate a slight departure from DER encoding:
* - 0 may be represented by an empty string or a 1-byte string.
* - The sign bit may be used as a value bit. */
- if( ( len == 1 && ( *p )[0] == 0 ) ||
- ( len > 1 && ( *p )[0] == 0 && ( ( *p )[1] & 0x80 ) != 0 ) )
- {
- ++( *p );
+ if ((len == 1 && (*p)[0] == 0) ||
+ (len > 1 && (*p)[0] == 0 && ((*p)[1] & 0x80) != 0)) {
+ ++(*p);
--len;
}
- if( min_bits == 0 && len == 0 )
- return( 1 );
- msb = ( *p )[0];
- TEST_ASSERT( msb != 0 );
- actual_bits = 8 * ( len - 1 );
- while( msb != 0 )
- {
+ if (min_bits == 0 && len == 0) {
+ return 1;
+ }
+ msb = (*p)[0];
+ TEST_ASSERT(msb != 0);
+ actual_bits = 8 * (len - 1);
+ while (msb != 0) {
msb >>= 1;
++actual_bits;
}
- TEST_ASSERT( actual_bits >= min_bits );
- TEST_ASSERT( actual_bits <= max_bits );
- if( must_be_odd )
- TEST_ASSERT( ( ( *p )[len-1] & 1 ) != 0 );
+ TEST_ASSERT(actual_bits >= min_bits);
+ TEST_ASSERT(actual_bits <= max_bits);
+ if (must_be_odd) {
+ TEST_ASSERT(((*p)[len-1] & 1) != 0);
+ }
*p += len;
- return( 1 );
+ return 1;
exit:
- return( 0 );
+ return 0;
}
#endif /* MBEDTLS_ASN1_PARSE_C */
diff --git a/tests/src/drivers/hash.c b/tests/src/drivers/hash.c
index 0d59bee..9cfb707 100644
--- a/tests/src/drivers/hash.c
+++ b/tests/src/drivers/hash.c
@@ -38,28 +38,25 @@
psa_status_t mbedtls_test_transparent_hash_compute(
psa_algorithm_t alg,
const uint8_t *input, size_t input_length,
- uint8_t *hash, size_t hash_size, size_t *hash_length )
+ uint8_t *hash, size_t hash_size, size_t *hash_length)
{
mbedtls_test_driver_hash_hooks.hits++;
- if( mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_hash_hooks.driver_status =
- mbedtls_test_driver_hash_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_hash_hooks.driver_status =
+ mbedtls_test_driver_hash_hooks.forced_status;
+ } else {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH)
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH)
mbedtls_test_driver_hash_hooks.driver_status =
libtestdriver1_mbedtls_psa_hash_compute(
alg, input, input_length,
- hash, hash_size, hash_length );
+ hash, hash_size, hash_length);
#elif defined(MBEDTLS_PSA_BUILTIN_HASH)
mbedtls_test_driver_hash_hooks.driver_status =
mbedtls_psa_hash_compute(
alg, input, input_length,
- hash, hash_size, hash_length );
+ hash, hash_size, hash_length);
#else
(void) alg;
(void) input;
@@ -71,29 +68,26 @@
#endif
}
- return( mbedtls_test_driver_hash_hooks.driver_status );
+ return mbedtls_test_driver_hash_hooks.driver_status;
}
psa_status_t mbedtls_test_transparent_hash_setup(
mbedtls_transparent_test_driver_hash_operation_t *operation,
- psa_algorithm_t alg )
+ psa_algorithm_t alg)
{
mbedtls_test_driver_hash_hooks.hits++;
- if( mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_hash_hooks.driver_status =
- mbedtls_test_driver_hash_hooks.forced_status;
- }
- else
- {
-#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH)
+ if (mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS) {
mbedtls_test_driver_hash_hooks.driver_status =
- libtestdriver1_mbedtls_psa_hash_setup( operation, alg );
+ mbedtls_test_driver_hash_hooks.forced_status;
+ } else {
+#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH)
+ mbedtls_test_driver_hash_hooks.driver_status =
+ libtestdriver1_mbedtls_psa_hash_setup(operation, alg);
#elif defined(MBEDTLS_PSA_BUILTIN_HASH)
mbedtls_test_driver_hash_hooks.driver_status =
- mbedtls_psa_hash_setup( operation, alg );
+ mbedtls_psa_hash_setup(operation, alg);
#else
(void) operation;
(void) alg;
@@ -101,30 +95,27 @@
#endif
}
- return( mbedtls_test_driver_hash_hooks.driver_status );
+ return mbedtls_test_driver_hash_hooks.driver_status;
}
psa_status_t mbedtls_test_transparent_hash_clone(
const mbedtls_transparent_test_driver_hash_operation_t *source_operation,
- mbedtls_transparent_test_driver_hash_operation_t *target_operation )
+ mbedtls_transparent_test_driver_hash_operation_t *target_operation)
{
mbedtls_test_driver_hash_hooks.hits++;
- if( mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_hash_hooks.driver_status =
- mbedtls_test_driver_hash_hooks.forced_status;
- }
- else
- {
-#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH)
+ if (mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS) {
mbedtls_test_driver_hash_hooks.driver_status =
- libtestdriver1_mbedtls_psa_hash_clone( source_operation,
- target_operation );
+ mbedtls_test_driver_hash_hooks.forced_status;
+ } else {
+#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH)
+ mbedtls_test_driver_hash_hooks.driver_status =
+ libtestdriver1_mbedtls_psa_hash_clone(source_operation,
+ target_operation);
#elif defined(MBEDTLS_PSA_BUILTIN_HASH)
mbedtls_test_driver_hash_hooks.driver_status =
- mbedtls_psa_hash_clone( source_operation, target_operation );
+ mbedtls_psa_hash_clone(source_operation, target_operation);
#else
(void) source_operation;
(void) target_operation;
@@ -132,31 +123,28 @@
#endif
}
- return( mbedtls_test_driver_hash_hooks.driver_status );
+ return mbedtls_test_driver_hash_hooks.driver_status;
}
psa_status_t mbedtls_test_transparent_hash_update(
mbedtls_transparent_test_driver_hash_operation_t *operation,
const uint8_t *input,
- size_t input_length )
+ size_t input_length)
{
mbedtls_test_driver_hash_hooks.hits++;
- if( mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_hash_hooks.driver_status =
- mbedtls_test_driver_hash_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_hash_hooks.driver_status =
+ mbedtls_test_driver_hash_hooks.forced_status;
+ } else {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH)
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH)
mbedtls_test_driver_hash_hooks.driver_status =
libtestdriver1_mbedtls_psa_hash_update(
- operation, input, input_length );
+ operation, input, input_length);
#elif defined(MBEDTLS_PSA_BUILTIN_HASH)
mbedtls_test_driver_hash_hooks.driver_status =
- mbedtls_psa_hash_update( operation, input, input_length );
+ mbedtls_psa_hash_update(operation, input, input_length);
#else
(void) operation;
(void) input;
@@ -165,32 +153,29 @@
#endif
}
- return( mbedtls_test_driver_hash_hooks.driver_status );
+ return mbedtls_test_driver_hash_hooks.driver_status;
}
psa_status_t mbedtls_test_transparent_hash_finish(
mbedtls_transparent_test_driver_hash_operation_t *operation,
uint8_t *hash,
size_t hash_size,
- size_t *hash_length )
+ size_t *hash_length)
{
mbedtls_test_driver_hash_hooks.hits++;
- if( mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_hash_hooks.driver_status =
- mbedtls_test_driver_hash_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_hash_hooks.driver_status =
+ mbedtls_test_driver_hash_hooks.forced_status;
+ } else {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH)
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH)
mbedtls_test_driver_hash_hooks.driver_status =
libtestdriver1_mbedtls_psa_hash_finish(
- operation, hash, hash_size, hash_length );
+ operation, hash, hash_size, hash_length);
#elif defined(MBEDTLS_PSA_BUILTIN_HASH)
mbedtls_test_driver_hash_hooks.driver_status =
- mbedtls_psa_hash_finish( operation, hash, hash_size, hash_length );
+ mbedtls_psa_hash_finish(operation, hash, hash_size, hash_length);
#else
(void) operation;
(void) hash;
@@ -200,34 +185,31 @@
#endif
}
- return( mbedtls_test_driver_hash_hooks.driver_status );
+ return mbedtls_test_driver_hash_hooks.driver_status;
}
psa_status_t mbedtls_test_transparent_hash_abort(
- mbedtls_transparent_test_driver_hash_operation_t *operation )
+ mbedtls_transparent_test_driver_hash_operation_t *operation)
{
mbedtls_test_driver_hash_hooks.hits++;
- if( mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_hash_hooks.driver_status =
- mbedtls_test_driver_hash_hooks.forced_status;
- }
- else
- {
-#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH)
+ if (mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS) {
mbedtls_test_driver_hash_hooks.driver_status =
- libtestdriver1_mbedtls_psa_hash_abort( operation );
+ mbedtls_test_driver_hash_hooks.forced_status;
+ } else {
+#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH)
+ mbedtls_test_driver_hash_hooks.driver_status =
+ libtestdriver1_mbedtls_psa_hash_abort(operation);
#elif defined(MBEDTLS_PSA_BUILTIN_HASH)
mbedtls_test_driver_hash_hooks.driver_status =
- mbedtls_psa_hash_abort( operation );
+ mbedtls_psa_hash_abort(operation);
#else
(void) operation;
mbedtls_test_driver_hash_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
#endif
}
- return( mbedtls_test_driver_hash_hooks.driver_status );
+ return mbedtls_test_driver_hash_hooks.driver_status;
}
#endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */
diff --git a/tests/src/drivers/platform_builtin_keys.c b/tests/src/drivers/platform_builtin_keys.c
index 759fa78..f073410 100644
--- a/tests/src/drivers/platform_builtin_keys.c
+++ b/tests/src/drivers/platform_builtin_keys.c
@@ -27,8 +27,7 @@
#include <test/drivers/test_driver.h>
#endif
-typedef struct
-{
+typedef struct {
psa_key_id_t builtin_key_id;
psa_key_lifetime_t lifetime;
psa_drv_slot_number_t slot_number;
@@ -40,52 +39,50 @@
* ECDSA can be exercised on key ID MBEDTLS_PSA_KEY_ID_BUILTIN_MIN + 1. */
{ MBEDTLS_PSA_KEY_ID_BUILTIN_MIN - 1,
PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION(
- PSA_KEY_PERSISTENCE_READ_ONLY, PSA_CRYPTO_TEST_DRIVER_LOCATION ),
+ PSA_KEY_PERSISTENCE_READ_ONLY, PSA_CRYPTO_TEST_DRIVER_LOCATION),
PSA_CRYPTO_TEST_DRIVER_BUILTIN_AES_KEY_SLOT },
{ MBEDTLS_PSA_KEY_ID_BUILTIN_MIN,
PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION(
- PSA_KEY_PERSISTENCE_READ_ONLY, PSA_CRYPTO_TEST_DRIVER_LOCATION ),
+ PSA_KEY_PERSISTENCE_READ_ONLY, PSA_CRYPTO_TEST_DRIVER_LOCATION),
PSA_CRYPTO_TEST_DRIVER_BUILTIN_AES_KEY_SLOT },
{ MBEDTLS_PSA_KEY_ID_BUILTIN_MIN + 1,
PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION(
- PSA_KEY_PERSISTENCE_READ_ONLY, PSA_CRYPTO_TEST_DRIVER_LOCATION ),
- PSA_CRYPTO_TEST_DRIVER_BUILTIN_ECDSA_KEY_SLOT},
+ PSA_KEY_PERSISTENCE_READ_ONLY, PSA_CRYPTO_TEST_DRIVER_LOCATION),
+ PSA_CRYPTO_TEST_DRIVER_BUILTIN_ECDSA_KEY_SLOT },
{ MBEDTLS_PSA_KEY_ID_BUILTIN_MAX - 1,
PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION(
- PSA_KEY_PERSISTENCE_READ_ONLY, PSA_CRYPTO_TEST_DRIVER_LOCATION ),
- PSA_CRYPTO_TEST_DRIVER_BUILTIN_AES_KEY_SLOT},
+ PSA_KEY_PERSISTENCE_READ_ONLY, PSA_CRYPTO_TEST_DRIVER_LOCATION),
+ PSA_CRYPTO_TEST_DRIVER_BUILTIN_AES_KEY_SLOT },
{ MBEDTLS_PSA_KEY_ID_BUILTIN_MAX,
PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION(
- PSA_KEY_PERSISTENCE_READ_ONLY, PSA_CRYPTO_TEST_DRIVER_LOCATION ),
- PSA_CRYPTO_TEST_DRIVER_BUILTIN_AES_KEY_SLOT},
+ PSA_KEY_PERSISTENCE_READ_ONLY, PSA_CRYPTO_TEST_DRIVER_LOCATION),
+ PSA_CRYPTO_TEST_DRIVER_BUILTIN_AES_KEY_SLOT },
{ MBEDTLS_PSA_KEY_ID_BUILTIN_MAX + 1,
PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION(
- PSA_KEY_PERSISTENCE_READ_ONLY, PSA_CRYPTO_TEST_DRIVER_LOCATION ),
- PSA_CRYPTO_TEST_DRIVER_BUILTIN_AES_KEY_SLOT},
+ PSA_KEY_PERSISTENCE_READ_ONLY, PSA_CRYPTO_TEST_DRIVER_LOCATION),
+ PSA_CRYPTO_TEST_DRIVER_BUILTIN_AES_KEY_SLOT },
#else
- {0, 0, 0}
+ { 0, 0, 0 }
#endif
};
psa_status_t mbedtls_psa_platform_get_builtin_key(
mbedtls_svc_key_id_t key_id,
psa_key_lifetime_t *lifetime,
- psa_drv_slot_number_t *slot_number )
+ psa_drv_slot_number_t *slot_number)
{
- psa_key_id_t app_key_id = MBEDTLS_SVC_KEY_ID_GET_KEY_ID( key_id );
+ psa_key_id_t app_key_id = MBEDTLS_SVC_KEY_ID_GET_KEY_ID(key_id);
const mbedtls_psa_builtin_key_description_t *builtin_key;
- for( size_t i = 0;
- i < ( sizeof( builtin_keys ) / sizeof( builtin_keys[0] ) ); i++ )
- {
+ for (size_t i = 0;
+ i < (sizeof(builtin_keys) / sizeof(builtin_keys[0])); i++) {
builtin_key = &builtin_keys[i];
- if( builtin_key->builtin_key_id == app_key_id )
- {
+ if (builtin_key->builtin_key_id == app_key_id) {
*lifetime = builtin_key->lifetime;
*slot_number = builtin_key->slot_number;
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
}
- return( PSA_ERROR_DOES_NOT_EXIST );
+ return PSA_ERROR_DOES_NOT_EXIST;
}
diff --git a/tests/src/drivers/test_driver_aead.c b/tests/src/drivers/test_driver_aead.c
index e249ec3..ebee4f8 100644
--- a/tests/src/drivers/test_driver_aead.c
+++ b/tests/src/drivers/test_driver_aead.c
@@ -42,28 +42,25 @@
const uint8_t *nonce, size_t nonce_length,
const uint8_t *additional_data, size_t additional_data_length,
const uint8_t *plaintext, size_t plaintext_length,
- uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length )
+ uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length)
{
mbedtls_test_driver_aead_hooks.hits++;
- if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_aead_hooks.driver_status =
- mbedtls_test_driver_aead_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_aead_hooks.driver_status =
+ mbedtls_test_driver_aead_hooks.forced_status;
+ } else {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
mbedtls_test_driver_aead_hooks.driver_status =
libtestdriver1_mbedtls_psa_aead_encrypt(
- (const libtestdriver1_psa_key_attributes_t *)attributes,
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
key_buffer, key_buffer_size,
alg,
nonce, nonce_length,
additional_data, additional_data_length,
plaintext, plaintext_length,
- ciphertext, ciphertext_size, ciphertext_length );
+ ciphertext, ciphertext_size, ciphertext_length);
#elif defined(MBEDTLS_PSA_BUILTIN_AEAD)
mbedtls_test_driver_aead_hooks.driver_status =
mbedtls_psa_aead_encrypt(
@@ -72,7 +69,7 @@
nonce, nonce_length,
additional_data, additional_data_length,
plaintext, plaintext_length,
- ciphertext, ciphertext_size, ciphertext_length );
+ ciphertext, ciphertext_size, ciphertext_length);
#else
(void) attributes;
(void) key_buffer;
@@ -90,7 +87,7 @@
mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
#endif
}
- return( mbedtls_test_driver_aead_hooks.driver_status );
+ return mbedtls_test_driver_aead_hooks.driver_status;
}
psa_status_t mbedtls_test_transparent_aead_decrypt(
@@ -100,28 +97,25 @@
const uint8_t *nonce, size_t nonce_length,
const uint8_t *additional_data, size_t additional_data_length,
const uint8_t *ciphertext, size_t ciphertext_length,
- uint8_t *plaintext, size_t plaintext_size, size_t *plaintext_length )
+ uint8_t *plaintext, size_t plaintext_size, size_t *plaintext_length)
{
mbedtls_test_driver_aead_hooks.hits++;
- if( mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_aead_hooks.driver_status =
- mbedtls_test_driver_aead_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_aead_hooks.driver_status =
+ mbedtls_test_driver_aead_hooks.forced_status;
+ } else {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD)
mbedtls_test_driver_aead_hooks.driver_status =
libtestdriver1_mbedtls_psa_aead_decrypt(
- (const libtestdriver1_psa_key_attributes_t *)attributes,
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
key_buffer, key_buffer_size,
alg,
nonce, nonce_length,
additional_data, additional_data_length,
ciphertext, ciphertext_length,
- plaintext, plaintext_size, plaintext_length );
+ plaintext, plaintext_size, plaintext_length);
#elif defined(MBEDTLS_PSA_BUILTIN_AEAD)
mbedtls_test_driver_aead_hooks.driver_status =
mbedtls_psa_aead_decrypt(
@@ -130,7 +124,7 @@
nonce, nonce_length,
additional_data, additional_data_length,
ciphertext, ciphertext_length,
- plaintext, plaintext_size, plaintext_length );
+ plaintext, plaintext_size, plaintext_length);
#else
(void) attributes;
(void) key_buffer;
@@ -148,7 +142,7 @@
mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
#endif
}
- return( mbedtls_test_driver_aead_hooks.driver_status );
+ return mbedtls_test_driver_aead_hooks.driver_status;
}
#endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */
diff --git a/tests/src/drivers/test_driver_cipher.c b/tests/src/drivers/test_driver_cipher.c
index 30a8119..42eb74d 100644
--- a/tests/src/drivers/test_driver_cipher.c
+++ b/tests/src/drivers/test_driver_cipher.c
@@ -54,41 +54,42 @@
size_t input_length,
uint8_t *output,
size_t output_size,
- size_t *output_length )
+ size_t *output_length)
{
mbedtls_test_driver_cipher_hooks.hits++;
- if( mbedtls_test_driver_cipher_hooks.forced_output != NULL )
- {
- if( output_size < mbedtls_test_driver_cipher_hooks.forced_output_length )
- return( PSA_ERROR_BUFFER_TOO_SMALL );
+ if (mbedtls_test_driver_cipher_hooks.forced_output != NULL) {
+ if (output_size < mbedtls_test_driver_cipher_hooks.forced_output_length) {
+ return PSA_ERROR_BUFFER_TOO_SMALL;
+ }
- memcpy( output,
- mbedtls_test_driver_cipher_hooks.forced_output,
- mbedtls_test_driver_cipher_hooks.forced_output_length );
+ memcpy(output,
+ mbedtls_test_driver_cipher_hooks.forced_output,
+ mbedtls_test_driver_cipher_hooks.forced_output_length);
*output_length = mbedtls_test_driver_cipher_hooks.forced_output_length;
- return( mbedtls_test_driver_cipher_hooks.forced_status );
+ return mbedtls_test_driver_cipher_hooks.forced_status;
}
- if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
- return( mbedtls_test_driver_cipher_hooks.forced_status );
+ if (mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS) {
+ return mbedtls_test_driver_cipher_hooks.forced_status;
+ }
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
- return( libtestdriver1_mbedtls_psa_cipher_encrypt(
- (const libtestdriver1_psa_key_attributes_t *)attributes,
- key_buffer, key_buffer_size,
- alg, iv, iv_length, input, input_length,
- output, output_size, output_length ) );
+ return libtestdriver1_mbedtls_psa_cipher_encrypt(
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ key_buffer, key_buffer_size,
+ alg, iv, iv_length, input, input_length,
+ output, output_size, output_length);
#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
- return( mbedtls_psa_cipher_encrypt(
- attributes, key_buffer, key_buffer_size,
- alg, iv, iv_length, input, input_length,
- output, output_size, output_length ) );
+ return mbedtls_psa_cipher_encrypt(
+ attributes, key_buffer, key_buffer_size,
+ alg, iv, iv_length, input, input_length,
+ output, output_size, output_length);
#endif
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_transparent_cipher_decrypt(
@@ -100,41 +101,42 @@
size_t input_length,
uint8_t *output,
size_t output_size,
- size_t *output_length )
+ size_t *output_length)
{
- mbedtls_test_driver_cipher_hooks.hits++;
+ mbedtls_test_driver_cipher_hooks.hits++;
- if( mbedtls_test_driver_cipher_hooks.forced_output != NULL )
- {
- if( output_size < mbedtls_test_driver_cipher_hooks.forced_output_length )
- return( PSA_ERROR_BUFFER_TOO_SMALL );
+ if (mbedtls_test_driver_cipher_hooks.forced_output != NULL) {
+ if (output_size < mbedtls_test_driver_cipher_hooks.forced_output_length) {
+ return PSA_ERROR_BUFFER_TOO_SMALL;
+ }
- memcpy( output,
- mbedtls_test_driver_cipher_hooks.forced_output,
- mbedtls_test_driver_cipher_hooks.forced_output_length );
+ memcpy(output,
+ mbedtls_test_driver_cipher_hooks.forced_output,
+ mbedtls_test_driver_cipher_hooks.forced_output_length);
*output_length = mbedtls_test_driver_cipher_hooks.forced_output_length;
- return( mbedtls_test_driver_cipher_hooks.forced_status );
+ return mbedtls_test_driver_cipher_hooks.forced_status;
}
- if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
- return( mbedtls_test_driver_cipher_hooks.forced_status );
+ if (mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS) {
+ return mbedtls_test_driver_cipher_hooks.forced_status;
+ }
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
- return( libtestdriver1_mbedtls_psa_cipher_decrypt(
- (const libtestdriver1_psa_key_attributes_t *)attributes,
- key_buffer, key_buffer_size,
- alg, input, input_length,
- output, output_size, output_length ) );
+ return libtestdriver1_mbedtls_psa_cipher_decrypt(
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ key_buffer, key_buffer_size,
+ alg, input, input_length,
+ output, output_size, output_length);
#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
- return( mbedtls_psa_cipher_decrypt(
- attributes, key_buffer, key_buffer_size,
- alg, input, input_length,
- output, output_size, output_length ) );
+ return mbedtls_psa_cipher_decrypt(
+ attributes, key_buffer, key_buffer_size,
+ alg, input, input_length,
+ output, output_size, output_length);
#endif
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_transparent_cipher_encrypt_setup(
@@ -149,23 +151,24 @@
* useful for the test suite, since it gives a chance of catching memory
* corruption errors should the core not have allocated (enough) memory for
* our context struct. */
- memset( operation, 0, sizeof( *operation ) );
+ memset(operation, 0, sizeof(*operation));
- if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
- return( mbedtls_test_driver_cipher_hooks.forced_status );
+ if (mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS) {
+ return mbedtls_test_driver_cipher_hooks.forced_status;
+ }
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
- return( libtestdriver1_mbedtls_psa_cipher_encrypt_setup(
- operation,
- (const libtestdriver1_psa_key_attributes_t *)attributes,
- key, key_length, alg ) );
+ return libtestdriver1_mbedtls_psa_cipher_encrypt_setup(
+ operation,
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ key, key_length, alg);
#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
- return( mbedtls_psa_cipher_encrypt_setup(
- operation, attributes, key, key_length, alg ) );
+ return mbedtls_psa_cipher_encrypt_setup(
+ operation, attributes, key, key_length, alg);
#endif
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_transparent_cipher_decrypt_setup(
@@ -176,21 +179,22 @@
{
mbedtls_test_driver_cipher_hooks.hits++;
- if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
- return( mbedtls_test_driver_cipher_hooks.forced_status );
+ if (mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS) {
+ return mbedtls_test_driver_cipher_hooks.forced_status;
+ }
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
- return( libtestdriver1_mbedtls_psa_cipher_decrypt_setup(
- operation,
- (const libtestdriver1_psa_key_attributes_t *)attributes,
- key, key_length, alg ) );
+ return libtestdriver1_mbedtls_psa_cipher_decrypt_setup(
+ operation,
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ key, key_length, alg);
#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
- return( mbedtls_psa_cipher_decrypt_setup(
- operation, attributes, key, key_length, alg ) );
+ return mbedtls_psa_cipher_decrypt_setup(
+ operation, attributes, key, key_length, alg);
#endif
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_transparent_cipher_abort(
@@ -198,23 +202,24 @@
{
mbedtls_test_driver_cipher_hooks.hits++;
- if( operation->alg == 0 )
- return( PSA_SUCCESS );
+ if (operation->alg == 0) {
+ return PSA_SUCCESS;
+ }
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
- libtestdriver1_mbedtls_psa_cipher_abort( operation );
+ libtestdriver1_mbedtls_psa_cipher_abort(operation);
#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
- mbedtls_psa_cipher_abort( operation );
+ mbedtls_psa_cipher_abort(operation);
#endif
/* Wiping the entire struct here, instead of member-by-member. This is
* useful for the test suite, since it gives a chance of catching memory
* corruption errors should the core not have allocated (enough) memory for
* our context struct. */
- memset( operation, 0, sizeof( *operation ) );
+ memset(operation, 0, sizeof(*operation));
- return( mbedtls_test_driver_cipher_hooks.forced_status );
+ return mbedtls_test_driver_cipher_hooks.forced_status;
}
psa_status_t mbedtls_test_transparent_cipher_set_iv(
@@ -224,18 +229,19 @@
{
mbedtls_test_driver_cipher_hooks.hits++;
- if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
- return( mbedtls_test_driver_cipher_hooks.forced_status );
+ if (mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS) {
+ return mbedtls_test_driver_cipher_hooks.forced_status;
+ }
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
- return( libtestdriver1_mbedtls_psa_cipher_set_iv(
- operation, iv, iv_length ) );
+ return libtestdriver1_mbedtls_psa_cipher_set_iv(
+ operation, iv, iv_length);
#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
- return( mbedtls_psa_cipher_set_iv( operation, iv, iv_length ) );
+ return mbedtls_psa_cipher_set_iv(operation, iv, iv_length);
#endif
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_transparent_cipher_update(
@@ -248,34 +254,35 @@
{
mbedtls_test_driver_cipher_hooks.hits++;
- if( mbedtls_test_driver_cipher_hooks.forced_output != NULL )
- {
- if( output_size < mbedtls_test_driver_cipher_hooks.forced_output_length )
+ if (mbedtls_test_driver_cipher_hooks.forced_output != NULL) {
+ if (output_size < mbedtls_test_driver_cipher_hooks.forced_output_length) {
return PSA_ERROR_BUFFER_TOO_SMALL;
+ }
- memcpy( output,
- mbedtls_test_driver_cipher_hooks.forced_output,
- mbedtls_test_driver_cipher_hooks.forced_output_length );
+ memcpy(output,
+ mbedtls_test_driver_cipher_hooks.forced_output,
+ mbedtls_test_driver_cipher_hooks.forced_output_length);
*output_length = mbedtls_test_driver_cipher_hooks.forced_output_length;
- return( mbedtls_test_driver_cipher_hooks.forced_status );
+ return mbedtls_test_driver_cipher_hooks.forced_status;
}
- if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
- return( mbedtls_test_driver_cipher_hooks.forced_status );
+ if (mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS) {
+ return mbedtls_test_driver_cipher_hooks.forced_status;
+ }
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
- return( libtestdriver1_mbedtls_psa_cipher_update(
- operation, input, input_length,
- output, output_size, output_length ) );
+ return libtestdriver1_mbedtls_psa_cipher_update(
+ operation, input, input_length,
+ output, output_size, output_length);
#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
- return( mbedtls_psa_cipher_update(
- operation, input, input_length,
- output, output_size, output_length ) );
+ return mbedtls_psa_cipher_update(
+ operation, input, input_length,
+ output, output_size, output_length);
#endif
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_transparent_cipher_finish(
@@ -286,32 +293,33 @@
{
mbedtls_test_driver_cipher_hooks.hits++;
- if( mbedtls_test_driver_cipher_hooks.forced_output != NULL )
- {
- if( output_size < mbedtls_test_driver_cipher_hooks.forced_output_length )
+ if (mbedtls_test_driver_cipher_hooks.forced_output != NULL) {
+ if (output_size < mbedtls_test_driver_cipher_hooks.forced_output_length) {
return PSA_ERROR_BUFFER_TOO_SMALL;
+ }
- memcpy( output,
- mbedtls_test_driver_cipher_hooks.forced_output,
- mbedtls_test_driver_cipher_hooks.forced_output_length );
+ memcpy(output,
+ mbedtls_test_driver_cipher_hooks.forced_output,
+ mbedtls_test_driver_cipher_hooks.forced_output_length);
*output_length = mbedtls_test_driver_cipher_hooks.forced_output_length;
- return( mbedtls_test_driver_cipher_hooks.forced_status );
+ return mbedtls_test_driver_cipher_hooks.forced_status;
}
- if( mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS )
- return( mbedtls_test_driver_cipher_hooks.forced_status );
+ if (mbedtls_test_driver_cipher_hooks.forced_status != PSA_SUCCESS) {
+ return mbedtls_test_driver_cipher_hooks.forced_status;
+ }
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_CIPHER)
- return( libtestdriver1_mbedtls_psa_cipher_finish(
- operation, output, output_size, output_length ) );
+ return libtestdriver1_mbedtls_psa_cipher_finish(
+ operation, output, output_size, output_length);
#elif defined(MBEDTLS_PSA_BUILTIN_CIPHER)
- return( mbedtls_psa_cipher_finish(
- operation, output, output_size, output_length ) );
+ return mbedtls_psa_cipher_finish(
+ operation, output, output_size, output_length);
#endif
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
/*
@@ -336,7 +344,7 @@
(void) output;
(void) output_size;
(void) output_length;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_cipher_decrypt(
@@ -355,7 +363,7 @@
(void) output;
(void) output_size;
(void) output_length;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_cipher_encrypt_setup(
@@ -369,7 +377,7 @@
(void) key;
(void) key_length;
(void) alg;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_cipher_decrypt_setup(
@@ -383,14 +391,14 @@
(void) key;
(void) key_length;
(void) alg;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_cipher_abort(
- mbedtls_opaque_test_driver_cipher_operation_t *operation )
+ mbedtls_opaque_test_driver_cipher_operation_t *operation)
{
(void) operation;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_cipher_set_iv(
@@ -401,7 +409,7 @@
(void) operation;
(void) iv;
(void) iv_length;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_cipher_update(
@@ -418,7 +426,7 @@
(void) output;
(void) output_size;
(void) output_length;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_cipher_finish(
@@ -431,6 +439,6 @@
(void) output;
(void) output_size;
(void) output_length;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
#endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */
diff --git a/tests/src/drivers/test_driver_key_management.c b/tests/src/drivers/test_driver_key_management.c
index 89cb8b9..f337e42 100644
--- a/tests/src/drivers/test_driver_key_management.c
+++ b/tests/src/drivers/test_driver_key_management.c
@@ -48,116 +48,115 @@
mbedtls_test_driver_key_management_hooks = MBEDTLS_TEST_DRIVER_KEY_MANAGEMENT_INIT;
const uint8_t mbedtls_test_driver_aes_key[16] =
- { 0x36, 0x77, 0x39, 0x7A, 0x24, 0x43, 0x26, 0x46,
- 0x29, 0x4A, 0x40, 0x4E, 0x63, 0x52, 0x66, 0x55 };
+{ 0x36, 0x77, 0x39, 0x7A, 0x24, 0x43, 0x26, 0x46,
+ 0x29, 0x4A, 0x40, 0x4E, 0x63, 0x52, 0x66, 0x55 };
const uint8_t mbedtls_test_driver_ecdsa_key[32] =
- { 0xdc, 0x7d, 0x9d, 0x26, 0xd6, 0x7a, 0x4f, 0x63,
- 0x2c, 0x34, 0xc2, 0xdc, 0x0b, 0x69, 0x86, 0x18,
- 0x38, 0x82, 0xc2, 0x06, 0xdf, 0x04, 0xcd, 0xb7,
- 0xd6, 0x9a, 0xab, 0xe2, 0x8b, 0xe4, 0xf8, 0x1a };
+{ 0xdc, 0x7d, 0x9d, 0x26, 0xd6, 0x7a, 0x4f, 0x63,
+ 0x2c, 0x34, 0xc2, 0xdc, 0x0b, 0x69, 0x86, 0x18,
+ 0x38, 0x82, 0xc2, 0x06, 0xdf, 0x04, 0xcd, 0xb7,
+ 0xd6, 0x9a, 0xab, 0xe2, 0x8b, 0xe4, 0xf8, 0x1a };
const uint8_t mbedtls_test_driver_ecdsa_pubkey[65] =
- { 0x04,
- 0x85, 0xf6, 0x4d, 0x89, 0xf0, 0x0b, 0xe6, 0x6c,
- 0x88, 0xdd, 0x93, 0x7e, 0xfd, 0x6d, 0x7c, 0x44,
- 0x56, 0x48, 0xdc, 0xb7, 0x01, 0x15, 0x0b, 0x8a,
- 0x95, 0x09, 0x29, 0x58, 0x50, 0xf4, 0x1c, 0x19,
- 0x31, 0xe5, 0x71, 0xfb, 0x8f, 0x8c, 0x78, 0x31,
- 0x7a, 0x20, 0xb3, 0x80, 0xe8, 0x66, 0x58, 0x4b,
- 0xbc, 0x25, 0x16, 0xc3, 0xd2, 0x70, 0x2d, 0x79,
- 0x2f, 0x13, 0x1a, 0x92, 0x20, 0x95, 0xfd, 0x6c };
+{ 0x04,
+ 0x85, 0xf6, 0x4d, 0x89, 0xf0, 0x0b, 0xe6, 0x6c,
+ 0x88, 0xdd, 0x93, 0x7e, 0xfd, 0x6d, 0x7c, 0x44,
+ 0x56, 0x48, 0xdc, 0xb7, 0x01, 0x15, 0x0b, 0x8a,
+ 0x95, 0x09, 0x29, 0x58, 0x50, 0xf4, 0x1c, 0x19,
+ 0x31, 0xe5, 0x71, 0xfb, 0x8f, 0x8c, 0x78, 0x31,
+ 0x7a, 0x20, 0xb3, 0x80, 0xe8, 0x66, 0x58, 0x4b,
+ 0xbc, 0x25, 0x16, 0xc3, 0xd2, 0x70, 0x2d, 0x79,
+ 0x2f, 0x13, 0x1a, 0x92, 0x20, 0x95, 0xfd, 0x6c };
-psa_status_t mbedtls_test_transparent_init( void )
+psa_status_t mbedtls_test_transparent_init(void)
{
-psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
+ psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1)
- status = libtestdriver1_psa_crypto_init( );
- if( status != PSA_SUCCESS )
- return( status );
+ status = libtestdriver1_psa_crypto_init();
+ if (status != PSA_SUCCESS) {
+ return status;
+ }
#endif
- (void)status;
- return( PSA_SUCCESS );
+ (void) status;
+ return PSA_SUCCESS;
}
-void mbedtls_test_transparent_free( void )
+void mbedtls_test_transparent_free(void)
{
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1)
- libtestdriver1_mbedtls_psa_crypto_free( );
+ libtestdriver1_mbedtls_psa_crypto_free();
#endif
return;
}
-psa_status_t mbedtls_test_opaque_init( void )
+psa_status_t mbedtls_test_opaque_init(void)
{
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
-void mbedtls_test_opaque_free( void )
+void mbedtls_test_opaque_free(void)
{
return;
}
psa_status_t mbedtls_test_transparent_generate_key(
const psa_key_attributes_t *attributes,
- uint8_t *key, size_t key_size, size_t *key_length )
+ uint8_t *key, size_t key_size, size_t *key_length)
{
++mbedtls_test_driver_key_management_hooks.hits;
- if( mbedtls_test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
- return( mbedtls_test_driver_key_management_hooks.forced_status );
+ if (mbedtls_test_driver_key_management_hooks.forced_status != PSA_SUCCESS) {
+ return mbedtls_test_driver_key_management_hooks.forced_status;
+ }
- if( mbedtls_test_driver_key_management_hooks.forced_output != NULL )
- {
- if( mbedtls_test_driver_key_management_hooks.forced_output_length >
- key_size )
- return( PSA_ERROR_BUFFER_TOO_SMALL );
- memcpy( key, mbedtls_test_driver_key_management_hooks.forced_output,
- mbedtls_test_driver_key_management_hooks.forced_output_length );
+ if (mbedtls_test_driver_key_management_hooks.forced_output != NULL) {
+ if (mbedtls_test_driver_key_management_hooks.forced_output_length >
+ key_size) {
+ return PSA_ERROR_BUFFER_TOO_SMALL;
+ }
+ memcpy(key, mbedtls_test_driver_key_management_hooks.forced_output,
+ mbedtls_test_driver_key_management_hooks.forced_output_length);
*key_length = mbedtls_test_driver_key_management_hooks.forced_output_length;
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
- if( PSA_KEY_TYPE_IS_ECC( psa_get_key_type( attributes ) )
- && PSA_KEY_TYPE_IS_KEY_PAIR( psa_get_key_type( attributes ) ) )
- {
+ if (PSA_KEY_TYPE_IS_ECC(psa_get_key_type(attributes))
+ && PSA_KEY_TYPE_IS_KEY_PAIR(psa_get_key_type(attributes))) {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_KEY_PAIR)
- return( libtestdriver1_mbedtls_psa_ecp_generate_key(
- (const libtestdriver1_psa_key_attributes_t *)attributes,
- key, key_size, key_length ) );
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_KEY_PAIR)
+ return libtestdriver1_mbedtls_psa_ecp_generate_key(
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ key, key_size, key_length);
#elif defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_KEY_PAIR)
- return( mbedtls_psa_ecp_generate_key(
- attributes, key, key_size, key_length ) );
+ return mbedtls_psa_ecp_generate_key(
+ attributes, key, key_size, key_length);
#endif
- }
- else if( psa_get_key_type( attributes ) == PSA_KEY_TYPE_RSA_KEY_PAIR )
- {
+ } else if (psa_get_key_type(attributes) == PSA_KEY_TYPE_RSA_KEY_PAIR) {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_KEY_PAIR)
- return( libtestdriver1_mbedtls_psa_rsa_generate_key(
- (const libtestdriver1_psa_key_attributes_t *)attributes,
- key, key_size, key_length ) );
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_KEY_PAIR)
+ return libtestdriver1_mbedtls_psa_rsa_generate_key(
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ key, key_size, key_length);
#elif defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_KEY_PAIR)
- return( mbedtls_psa_rsa_generate_key(
- attributes, key, key_size, key_length ) );
+ return mbedtls_psa_rsa_generate_key(
+ attributes, key, key_size, key_length);
#endif
}
- (void)attributes;
- return( PSA_ERROR_NOT_SUPPORTED );
+ (void) attributes;
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_generate_key(
const psa_key_attributes_t *attributes,
- uint8_t *key, size_t key_size, size_t *key_length )
+ uint8_t *key, size_t key_size, size_t *key_length)
{
(void) attributes;
(void) key;
(void) key_size;
(void) key_length;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_transparent_import_key(
@@ -169,231 +168,237 @@
size_t *key_buffer_length,
size_t *bits)
{
- psa_key_type_t type = psa_get_key_type( attributes );
+ psa_key_type_t type = psa_get_key_type(attributes);
++mbedtls_test_driver_key_management_hooks.hits;
mbedtls_test_driver_key_management_hooks.location = PSA_KEY_LOCATION_LOCAL_STORAGE;
- if( mbedtls_test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
- return( mbedtls_test_driver_key_management_hooks.forced_status );
+ if (mbedtls_test_driver_key_management_hooks.forced_status != PSA_SUCCESS) {
+ return mbedtls_test_driver_key_management_hooks.forced_status;
+ }
- if( PSA_KEY_TYPE_IS_ECC( type ) )
- {
+ if (PSA_KEY_TYPE_IS_ECC(type)) {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- ( defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_KEY_PAIR) || \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_PUBLIC_KEY) )
- return( libtestdriver1_mbedtls_psa_ecp_import_key(
- (const libtestdriver1_psa_key_attributes_t *)attributes,
- data, data_length,
- key_buffer, key_buffer_size,
- key_buffer_length, bits ) );
+ (defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_KEY_PAIR) || \
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_PUBLIC_KEY))
+ return libtestdriver1_mbedtls_psa_ecp_import_key(
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ data, data_length,
+ key_buffer, key_buffer_size,
+ key_buffer_length, bits);
#elif defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_KEY_PAIR) || \
- defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_PUBLIC_KEY)
- return( mbedtls_psa_ecp_import_key(
- attributes,
- data, data_length,
- key_buffer, key_buffer_size,
- key_buffer_length, bits ) );
+ defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_PUBLIC_KEY)
+ return mbedtls_psa_ecp_import_key(
+ attributes,
+ data, data_length,
+ key_buffer, key_buffer_size,
+ key_buffer_length, bits);
#endif
- }
- else if( PSA_KEY_TYPE_IS_RSA( type ) )
- {
+ } else if (PSA_KEY_TYPE_IS_RSA(type)) {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- ( defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_KEY_PAIR) || \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_PUBLIC_KEY) )
- return( libtestdriver1_mbedtls_psa_rsa_import_key(
- (const libtestdriver1_psa_key_attributes_t *)attributes,
- data, data_length,
- key_buffer, key_buffer_size,
- key_buffer_length, bits ) );
+ (defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_KEY_PAIR) || \
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_PUBLIC_KEY))
+ return libtestdriver1_mbedtls_psa_rsa_import_key(
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ data, data_length,
+ key_buffer, key_buffer_size,
+ key_buffer_length, bits);
#elif defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_KEY_PAIR) || \
- defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_PUBLIC_KEY)
- return( mbedtls_psa_rsa_import_key(
- attributes,
- data, data_length,
- key_buffer, key_buffer_size,
- key_buffer_length, bits ) );
+ defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_PUBLIC_KEY)
+ return mbedtls_psa_rsa_import_key(
+ attributes,
+ data, data_length,
+ key_buffer, key_buffer_size,
+ key_buffer_length, bits);
#endif
}
- (void)data;
- (void)data_length;
- (void)key_buffer;
- (void)key_buffer_size;
- (void)key_buffer_length;
- (void)bits;
- (void)type;
+ (void) data;
+ (void) data_length;
+ (void) key_buffer;
+ (void) key_buffer_size;
+ (void) key_buffer_length;
+ (void) bits;
+ (void) type;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_export_key(
const psa_key_attributes_t *attributes,
const uint8_t *key, size_t key_length,
- uint8_t *data, size_t data_size, size_t *data_length )
+ uint8_t *data, size_t data_size, size_t *data_length)
{
/* Assume this is a builtin key based on the key material length. */
- psa_drv_slot_number_t slot_number = *( ( psa_drv_slot_number_t* ) key );
+ psa_drv_slot_number_t slot_number = *((psa_drv_slot_number_t *) key);
- if( key_length != sizeof( psa_drv_slot_number_t ) )
- {
+ if (key_length != sizeof(psa_drv_slot_number_t)) {
/* Test driver does not support generic opaque key handling yet. */
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
- switch( slot_number )
- {
+ switch (slot_number) {
case PSA_CRYPTO_TEST_DRIVER_BUILTIN_ECDSA_KEY_SLOT:
/* This is the ECDSA slot. Verify the key's attributes before
* returning the private key. */
- if( psa_get_key_type( attributes ) !=
- PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_FAMILY_SECP_R1 ) )
- return( PSA_ERROR_CORRUPTION_DETECTED );
- if( psa_get_key_bits( attributes ) != 256 )
- return( PSA_ERROR_CORRUPTION_DETECTED );
- if( psa_get_key_algorithm( attributes ) !=
- PSA_ALG_ECDSA( PSA_ALG_ANY_HASH ) )
- return( PSA_ERROR_CORRUPTION_DETECTED );
- if( ( psa_get_key_usage_flags( attributes ) &
- PSA_KEY_USAGE_EXPORT ) == 0 )
- return( PSA_ERROR_CORRUPTION_DETECTED );
+ if (psa_get_key_type(attributes) !=
+ PSA_KEY_TYPE_ECC_KEY_PAIR(PSA_ECC_FAMILY_SECP_R1)) {
+ return PSA_ERROR_CORRUPTION_DETECTED;
+ }
+ if (psa_get_key_bits(attributes) != 256) {
+ return PSA_ERROR_CORRUPTION_DETECTED;
+ }
+ if (psa_get_key_algorithm(attributes) !=
+ PSA_ALG_ECDSA(PSA_ALG_ANY_HASH)) {
+ return PSA_ERROR_CORRUPTION_DETECTED;
+ }
+ if ((psa_get_key_usage_flags(attributes) &
+ PSA_KEY_USAGE_EXPORT) == 0) {
+ return PSA_ERROR_CORRUPTION_DETECTED;
+ }
- if( data_size < sizeof( mbedtls_test_driver_ecdsa_key ) )
- return( PSA_ERROR_BUFFER_TOO_SMALL );
+ if (data_size < sizeof(mbedtls_test_driver_ecdsa_key)) {
+ return PSA_ERROR_BUFFER_TOO_SMALL;
+ }
- memcpy( data, mbedtls_test_driver_ecdsa_key,
- sizeof( mbedtls_test_driver_ecdsa_key ) );
- *data_length = sizeof( mbedtls_test_driver_ecdsa_key );
- return( PSA_SUCCESS );
+ memcpy(data, mbedtls_test_driver_ecdsa_key,
+ sizeof(mbedtls_test_driver_ecdsa_key));
+ *data_length = sizeof(mbedtls_test_driver_ecdsa_key);
+ return PSA_SUCCESS;
case PSA_CRYPTO_TEST_DRIVER_BUILTIN_AES_KEY_SLOT:
/* This is the AES slot. Verify the key's attributes before
* returning the key. */
- if( psa_get_key_type( attributes ) != PSA_KEY_TYPE_AES )
- return( PSA_ERROR_CORRUPTION_DETECTED );
- if( psa_get_key_bits( attributes ) != 128 )
- return( PSA_ERROR_CORRUPTION_DETECTED );
- if( psa_get_key_algorithm( attributes ) != PSA_ALG_CTR )
- return( PSA_ERROR_CORRUPTION_DETECTED );
- if( ( psa_get_key_usage_flags( attributes ) &
- PSA_KEY_USAGE_EXPORT ) == 0 )
- return( PSA_ERROR_CORRUPTION_DETECTED );
+ if (psa_get_key_type(attributes) != PSA_KEY_TYPE_AES) {
+ return PSA_ERROR_CORRUPTION_DETECTED;
+ }
+ if (psa_get_key_bits(attributes) != 128) {
+ return PSA_ERROR_CORRUPTION_DETECTED;
+ }
+ if (psa_get_key_algorithm(attributes) != PSA_ALG_CTR) {
+ return PSA_ERROR_CORRUPTION_DETECTED;
+ }
+ if ((psa_get_key_usage_flags(attributes) &
+ PSA_KEY_USAGE_EXPORT) == 0) {
+ return PSA_ERROR_CORRUPTION_DETECTED;
+ }
- if( data_size < sizeof( mbedtls_test_driver_aes_key ) )
- return( PSA_ERROR_BUFFER_TOO_SMALL );
+ if (data_size < sizeof(mbedtls_test_driver_aes_key)) {
+ return PSA_ERROR_BUFFER_TOO_SMALL;
+ }
- memcpy( data, mbedtls_test_driver_aes_key,
- sizeof( mbedtls_test_driver_aes_key ) );
- *data_length = sizeof( mbedtls_test_driver_aes_key );
- return( PSA_SUCCESS );
+ memcpy(data, mbedtls_test_driver_aes_key,
+ sizeof(mbedtls_test_driver_aes_key));
+ *data_length = sizeof(mbedtls_test_driver_aes_key);
+ return PSA_SUCCESS;
default:
- return( PSA_ERROR_DOES_NOT_EXIST );
+ return PSA_ERROR_DOES_NOT_EXIST;
}
}
psa_status_t mbedtls_test_transparent_export_public_key(
const psa_key_attributes_t *attributes,
const uint8_t *key_buffer, size_t key_buffer_size,
- uint8_t *data, size_t data_size, size_t *data_length )
+ uint8_t *data, size_t data_size, size_t *data_length)
{
++mbedtls_test_driver_key_management_hooks.hits;
- if( mbedtls_test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
- return( mbedtls_test_driver_key_management_hooks.forced_status );
+ if (mbedtls_test_driver_key_management_hooks.forced_status != PSA_SUCCESS) {
+ return mbedtls_test_driver_key_management_hooks.forced_status;
+ }
- if( mbedtls_test_driver_key_management_hooks.forced_output != NULL )
- {
- if( mbedtls_test_driver_key_management_hooks.forced_output_length >
- data_size )
- return( PSA_ERROR_BUFFER_TOO_SMALL );
- memcpy( data, mbedtls_test_driver_key_management_hooks.forced_output,
- mbedtls_test_driver_key_management_hooks.forced_output_length );
+ if (mbedtls_test_driver_key_management_hooks.forced_output != NULL) {
+ if (mbedtls_test_driver_key_management_hooks.forced_output_length >
+ data_size) {
+ return PSA_ERROR_BUFFER_TOO_SMALL;
+ }
+ memcpy(data, mbedtls_test_driver_key_management_hooks.forced_output,
+ mbedtls_test_driver_key_management_hooks.forced_output_length);
*data_length = mbedtls_test_driver_key_management_hooks.forced_output_length;
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
- psa_key_type_t key_type = psa_get_key_type( attributes );
+ psa_key_type_t key_type = psa_get_key_type(attributes);
- if( PSA_KEY_TYPE_IS_ECC( key_type ) )
- {
+ if (PSA_KEY_TYPE_IS_ECC(key_type)) {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- ( defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_KEY_PAIR) || \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_PUBLIC_KEY) )
- return( libtestdriver1_mbedtls_psa_ecp_export_public_key(
- (const libtestdriver1_psa_key_attributes_t *)attributes,
- key_buffer, key_buffer_size,
- data, data_size, data_length ) );
+ (defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_KEY_PAIR) || \
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_PUBLIC_KEY))
+ return libtestdriver1_mbedtls_psa_ecp_export_public_key(
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ key_buffer, key_buffer_size,
+ data, data_size, data_length);
#elif defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_KEY_PAIR) || \
- defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_PUBLIC_KEY)
- return( mbedtls_psa_ecp_export_public_key(
- attributes,
- key_buffer, key_buffer_size,
- data, data_size, data_length ) );
+ defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_ECC_PUBLIC_KEY)
+ return mbedtls_psa_ecp_export_public_key(
+ attributes,
+ key_buffer, key_buffer_size,
+ data, data_size, data_length);
#endif
- }
- else if( PSA_KEY_TYPE_IS_RSA( key_type ) )
- {
+ } else if (PSA_KEY_TYPE_IS_RSA(key_type)) {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- ( defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_KEY_PAIR) || \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_PUBLIC_KEY) )
- return( libtestdriver1_mbedtls_psa_rsa_export_public_key(
- (const libtestdriver1_psa_key_attributes_t *)attributes,
- key_buffer, key_buffer_size,
- data, data_size, data_length ) );
+ (defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_KEY_PAIR) || \
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_PUBLIC_KEY))
+ return libtestdriver1_mbedtls_psa_rsa_export_public_key(
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ key_buffer, key_buffer_size,
+ data, data_size, data_length);
#elif defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_KEY_PAIR) || \
- defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_PUBLIC_KEY)
- return( mbedtls_psa_rsa_export_public_key(
- attributes,
- key_buffer, key_buffer_size,
- data, data_size, data_length ) );
+ defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_RSA_PUBLIC_KEY)
+ return mbedtls_psa_rsa_export_public_key(
+ attributes,
+ key_buffer, key_buffer_size,
+ data, data_size, data_length);
#endif
}
- (void)key_buffer;
- (void)key_buffer_size;
- (void)key_type;
+ (void) key_buffer;
+ (void) key_buffer_size;
+ (void) key_type;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_export_public_key(
const psa_key_attributes_t *attributes,
const uint8_t *key, size_t key_length,
- uint8_t *data, size_t data_size, size_t *data_length )
+ uint8_t *data, size_t data_size, size_t *data_length)
{
- if( key_length != sizeof( psa_drv_slot_number_t ) )
- {
+ if (key_length != sizeof(psa_drv_slot_number_t)) {
/* Test driver does not support generic opaque key handling yet. */
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
/* Assume this is a builtin key based on the key material length. */
- psa_drv_slot_number_t slot_number = *( ( psa_drv_slot_number_t* ) key );
- switch( slot_number )
- {
+ psa_drv_slot_number_t slot_number = *((psa_drv_slot_number_t *) key);
+ switch (slot_number) {
case PSA_CRYPTO_TEST_DRIVER_BUILTIN_ECDSA_KEY_SLOT:
/* This is the ECDSA slot. Verify the key's attributes before
* returning the public key. */
- if( psa_get_key_type( attributes ) !=
- PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_FAMILY_SECP_R1 ) )
- return( PSA_ERROR_CORRUPTION_DETECTED );
- if( psa_get_key_bits( attributes ) != 256 )
- return( PSA_ERROR_CORRUPTION_DETECTED );
- if( psa_get_key_algorithm( attributes ) !=
- PSA_ALG_ECDSA( PSA_ALG_ANY_HASH ) )
- return( PSA_ERROR_CORRUPTION_DETECTED );
+ if (psa_get_key_type(attributes) !=
+ PSA_KEY_TYPE_ECC_KEY_PAIR(PSA_ECC_FAMILY_SECP_R1)) {
+ return PSA_ERROR_CORRUPTION_DETECTED;
+ }
+ if (psa_get_key_bits(attributes) != 256) {
+ return PSA_ERROR_CORRUPTION_DETECTED;
+ }
+ if (psa_get_key_algorithm(attributes) !=
+ PSA_ALG_ECDSA(PSA_ALG_ANY_HASH)) {
+ return PSA_ERROR_CORRUPTION_DETECTED;
+ }
- if( data_size < sizeof( mbedtls_test_driver_ecdsa_pubkey ) )
- return( PSA_ERROR_BUFFER_TOO_SMALL );
+ if (data_size < sizeof(mbedtls_test_driver_ecdsa_pubkey)) {
+ return PSA_ERROR_BUFFER_TOO_SMALL;
+ }
- memcpy( data, mbedtls_test_driver_ecdsa_pubkey,
- sizeof( mbedtls_test_driver_ecdsa_pubkey ) );
- *data_length = sizeof( mbedtls_test_driver_ecdsa_pubkey );
- return( PSA_SUCCESS );
+ memcpy(data, mbedtls_test_driver_ecdsa_pubkey,
+ sizeof(mbedtls_test_driver_ecdsa_pubkey));
+ *data_length = sizeof(mbedtls_test_driver_ecdsa_pubkey);
+ return PSA_SUCCESS;
default:
- return( PSA_ERROR_DOES_NOT_EXIST );
+ return PSA_ERROR_DOES_NOT_EXIST;
}
}
@@ -410,49 +415,50 @@
psa_status_t mbedtls_test_opaque_get_builtin_key(
psa_drv_slot_number_t slot_number,
psa_key_attributes_t *attributes,
- uint8_t *key_buffer, size_t key_buffer_size, size_t *key_buffer_length )
+ uint8_t *key_buffer, size_t key_buffer_size, size_t *key_buffer_length)
{
- switch( slot_number )
- {
+ switch (slot_number) {
case PSA_CRYPTO_TEST_DRIVER_BUILTIN_AES_KEY_SLOT:
- psa_set_key_type( attributes, PSA_KEY_TYPE_AES );
- psa_set_key_bits( attributes, 128 );
+ psa_set_key_type(attributes, PSA_KEY_TYPE_AES);
+ psa_set_key_bits(attributes, 128);
psa_set_key_usage_flags(
attributes,
PSA_KEY_USAGE_ENCRYPT |
PSA_KEY_USAGE_DECRYPT |
- PSA_KEY_USAGE_EXPORT );
- psa_set_key_algorithm( attributes, PSA_ALG_CTR );
+ PSA_KEY_USAGE_EXPORT);
+ psa_set_key_algorithm(attributes, PSA_ALG_CTR);
- if( key_buffer_size < sizeof( psa_drv_slot_number_t ) )
- return( PSA_ERROR_BUFFER_TOO_SMALL );
+ if (key_buffer_size < sizeof(psa_drv_slot_number_t)) {
+ return PSA_ERROR_BUFFER_TOO_SMALL;
+ }
- *( (psa_drv_slot_number_t*) key_buffer ) =
+ *((psa_drv_slot_number_t *) key_buffer) =
PSA_CRYPTO_TEST_DRIVER_BUILTIN_AES_KEY_SLOT;
- *key_buffer_length = sizeof( psa_drv_slot_number_t );
- return( PSA_SUCCESS );
+ *key_buffer_length = sizeof(psa_drv_slot_number_t);
+ return PSA_SUCCESS;
case PSA_CRYPTO_TEST_DRIVER_BUILTIN_ECDSA_KEY_SLOT:
psa_set_key_type(
attributes,
- PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_FAMILY_SECP_R1 ) );
- psa_set_key_bits( attributes, 256 );
+ PSA_KEY_TYPE_ECC_KEY_PAIR(PSA_ECC_FAMILY_SECP_R1));
+ psa_set_key_bits(attributes, 256);
psa_set_key_usage_flags(
attributes,
PSA_KEY_USAGE_SIGN_HASH |
PSA_KEY_USAGE_VERIFY_HASH |
- PSA_KEY_USAGE_EXPORT );
+ PSA_KEY_USAGE_EXPORT);
psa_set_key_algorithm(
- attributes, PSA_ALG_ECDSA( PSA_ALG_ANY_HASH ) );
+ attributes, PSA_ALG_ECDSA(PSA_ALG_ANY_HASH));
- if( key_buffer_size < sizeof( psa_drv_slot_number_t ) )
- return( PSA_ERROR_BUFFER_TOO_SMALL );
+ if (key_buffer_size < sizeof(psa_drv_slot_number_t)) {
+ return PSA_ERROR_BUFFER_TOO_SMALL;
+ }
- *( (psa_drv_slot_number_t*) key_buffer ) =
+ *((psa_drv_slot_number_t *) key_buffer) =
PSA_CRYPTO_TEST_DRIVER_BUILTIN_ECDSA_KEY_SLOT;
- *key_buffer_length = sizeof( psa_drv_slot_number_t );
- return( PSA_SUCCESS );
+ *key_buffer_length = sizeof(psa_drv_slot_number_t);
+ return PSA_SUCCESS;
default:
- return( PSA_ERROR_DOES_NOT_EXIST );
+ return PSA_ERROR_DOES_NOT_EXIST;
}
}
diff --git a/tests/src/drivers/test_driver_mac.c b/tests/src/drivers/test_driver_mac.c
index 06b6eb7..362cc43 100644
--- a/tests/src/drivers/test_driver_mac.c
+++ b/tests/src/drivers/test_driver_mac.c
@@ -44,31 +44,28 @@
size_t input_length,
uint8_t *mac,
size_t mac_size,
- size_t *mac_length )
+ size_t *mac_length)
{
mbedtls_test_driver_mac_hooks.hits++;
- if( mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_test_driver_mac_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_MAC)
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_MAC)
mbedtls_test_driver_mac_hooks.driver_status =
libtestdriver1_mbedtls_psa_mac_compute(
- (const libtestdriver1_psa_key_attributes_t *)attributes,
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
key_buffer, key_buffer_size, alg,
input, input_length,
- mac, mac_size, mac_length );
+ mac, mac_size, mac_length);
#elif defined(MBEDTLS_PSA_BUILTIN_MAC)
mbedtls_test_driver_mac_hooks.driver_status =
mbedtls_psa_mac_compute(
attributes, key_buffer, key_buffer_size, alg,
input, input_length,
- mac, mac_size, mac_length );
+ mac, mac_size, mac_length);
#else
(void) attributes;
(void) key_buffer;
@@ -83,7 +80,7 @@
#endif
}
- return( mbedtls_test_driver_mac_hooks.driver_status );
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
psa_status_t mbedtls_test_transparent_mac_sign_setup(
@@ -91,28 +88,25 @@
const psa_key_attributes_t *attributes,
const uint8_t *key_buffer,
size_t key_buffer_size,
- psa_algorithm_t alg )
+ psa_algorithm_t alg)
{
mbedtls_test_driver_mac_hooks.hits++;
- if( mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_test_driver_mac_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_MAC)
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_MAC)
mbedtls_test_driver_mac_hooks.driver_status =
libtestdriver1_mbedtls_psa_mac_sign_setup(
operation,
- (const libtestdriver1_psa_key_attributes_t *)attributes,
- key_buffer, key_buffer_size, alg );
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ key_buffer, key_buffer_size, alg);
#elif defined(MBEDTLS_PSA_BUILTIN_MAC)
mbedtls_test_driver_mac_hooks.driver_status =
mbedtls_psa_mac_sign_setup(
- operation, attributes, key_buffer, key_buffer_size, alg );
+ operation, attributes, key_buffer, key_buffer_size, alg);
#else
(void) operation;
(void) attributes;
@@ -123,7 +117,7 @@
#endif
}
- return( mbedtls_test_driver_mac_hooks.driver_status );
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
psa_status_t mbedtls_test_transparent_mac_verify_setup(
@@ -131,28 +125,25 @@
const psa_key_attributes_t *attributes,
const uint8_t *key_buffer,
size_t key_buffer_size,
- psa_algorithm_t alg )
+ psa_algorithm_t alg)
{
mbedtls_test_driver_mac_hooks.hits++;
- if( mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_test_driver_mac_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_MAC)
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_MAC)
mbedtls_test_driver_mac_hooks.driver_status =
libtestdriver1_mbedtls_psa_mac_verify_setup(
operation,
- (const libtestdriver1_psa_key_attributes_t *)attributes,
- key_buffer, key_buffer_size, alg );
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ key_buffer, key_buffer_size, alg);
#elif defined(MBEDTLS_PSA_BUILTIN_MAC)
mbedtls_test_driver_mac_hooks.driver_status =
mbedtls_psa_mac_verify_setup(
- operation, attributes, key_buffer, key_buffer_size, alg );
+ operation, attributes, key_buffer, key_buffer_size, alg);
#else
(void) operation;
(void) attributes;
@@ -163,32 +154,29 @@
#endif
}
- return( mbedtls_test_driver_mac_hooks.driver_status );
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
psa_status_t mbedtls_test_transparent_mac_update(
mbedtls_transparent_test_driver_mac_operation_t *operation,
const uint8_t *input,
- size_t input_length )
+ size_t input_length)
{
mbedtls_test_driver_mac_hooks.hits++;
- if( mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_test_driver_mac_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_MAC)
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_MAC)
mbedtls_test_driver_mac_hooks.driver_status =
libtestdriver1_mbedtls_psa_mac_update(
- operation, input, input_length );
+ operation, input, input_length);
#elif defined(MBEDTLS_PSA_BUILTIN_MAC)
mbedtls_test_driver_mac_hooks.driver_status =
mbedtls_psa_mac_update(
- operation, input, input_length );
+ operation, input, input_length);
#else
(void) operation;
(void) input;
@@ -197,33 +185,30 @@
#endif
}
- return( mbedtls_test_driver_mac_hooks.driver_status );
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
psa_status_t mbedtls_test_transparent_mac_sign_finish(
mbedtls_transparent_test_driver_mac_operation_t *operation,
uint8_t *mac,
size_t mac_size,
- size_t *mac_length )
+ size_t *mac_length)
{
mbedtls_test_driver_mac_hooks.hits++;
- if( mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_test_driver_mac_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_MAC)
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_MAC)
mbedtls_test_driver_mac_hooks.driver_status =
libtestdriver1_mbedtls_psa_mac_sign_finish(
- operation, mac, mac_size, mac_length );
+ operation, mac, mac_size, mac_length);
#elif defined(MBEDTLS_PSA_BUILTIN_MAC)
mbedtls_test_driver_mac_hooks.driver_status =
mbedtls_psa_mac_sign_finish(
- operation, mac, mac_size, mac_length );
+ operation, mac, mac_size, mac_length);
#else
(void) operation;
(void) mac;
@@ -233,32 +218,29 @@
#endif
}
- return( mbedtls_test_driver_mac_hooks.driver_status );
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
psa_status_t mbedtls_test_transparent_mac_verify_finish(
mbedtls_transparent_test_driver_mac_operation_t *operation,
const uint8_t *mac,
- size_t mac_length )
+ size_t mac_length)
{
mbedtls_test_driver_mac_hooks.hits++;
- if( mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_test_driver_mac_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_MAC)
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_MAC)
mbedtls_test_driver_mac_hooks.driver_status =
libtestdriver1_mbedtls_psa_mac_verify_finish(
- operation, mac, mac_length );
+ operation, mac, mac_length);
#elif defined(MBEDTLS_PSA_BUILTIN_MAC)
mbedtls_test_driver_mac_hooks.driver_status =
mbedtls_psa_mac_verify_finish(
- operation, mac, mac_length );
+ operation, mac, mac_length);
#else
(void) operation;
(void) mac;
@@ -267,35 +249,32 @@
#endif
}
- return( mbedtls_test_driver_mac_hooks.driver_status );
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
psa_status_t mbedtls_test_transparent_mac_abort(
- mbedtls_transparent_test_driver_mac_operation_t *operation )
+ mbedtls_transparent_test_driver_mac_operation_t *operation)
{
mbedtls_test_driver_mac_hooks.hits++;
- if( mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_test_driver_mac_hooks.forced_status;
- }
- else
- {
-#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_MAC)
+ if (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
mbedtls_test_driver_mac_hooks.driver_status =
- libtestdriver1_mbedtls_psa_mac_abort( operation );
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
+#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_MAC)
+ mbedtls_test_driver_mac_hooks.driver_status =
+ libtestdriver1_mbedtls_psa_mac_abort(operation);
#elif defined(MBEDTLS_PSA_BUILTIN_MAC)
mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_psa_mac_abort( operation );
+ mbedtls_psa_mac_abort(operation);
#else
(void) operation;
mbedtls_test_driver_mac_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
#endif
}
- return( mbedtls_test_driver_mac_hooks.driver_status );
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
psa_status_t mbedtls_test_opaque_mac_compute(
@@ -307,17 +286,14 @@
size_t input_length,
uint8_t *mac,
size_t mac_size,
- size_t *mac_length )
+ size_t *mac_length)
{
mbedtls_test_driver_mac_hooks.hits++;
- if( mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_test_driver_mac_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
(void) attributes;
(void) key_buffer;
(void) key_buffer_size;
@@ -330,7 +306,7 @@
mbedtls_test_driver_mac_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
}
- return( mbedtls_test_driver_mac_hooks.driver_status );
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
psa_status_t mbedtls_test_opaque_mac_sign_setup(
@@ -338,17 +314,14 @@
const psa_key_attributes_t *attributes,
const uint8_t *key_buffer,
size_t key_buffer_size,
- psa_algorithm_t alg )
+ psa_algorithm_t alg)
{
mbedtls_test_driver_mac_hooks.hits++;
- if( mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_test_driver_mac_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
(void) operation;
(void) attributes;
(void) key_buffer;
@@ -357,7 +330,7 @@
mbedtls_test_driver_mac_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
}
- return( mbedtls_test_driver_mac_hooks.driver_status );
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
psa_status_t mbedtls_test_opaque_mac_verify_setup(
@@ -365,17 +338,14 @@
const psa_key_attributes_t *attributes,
const uint8_t *key_buffer,
size_t key_buffer_size,
- psa_algorithm_t alg )
+ psa_algorithm_t alg)
{
mbedtls_test_driver_mac_hooks.hits++;
- if( mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_test_driver_mac_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
(void) operation;
(void) attributes;
(void) key_buffer;
@@ -384,47 +354,41 @@
mbedtls_test_driver_mac_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
}
- return( mbedtls_test_driver_mac_hooks.driver_status );
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
psa_status_t mbedtls_test_opaque_mac_update(
mbedtls_opaque_test_driver_mac_operation_t *operation,
const uint8_t *input,
- size_t input_length )
+ size_t input_length)
{
mbedtls_test_driver_mac_hooks.hits++;
- if( mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_test_driver_mac_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
(void) operation;
(void) input;
(void) input_length;
mbedtls_test_driver_mac_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
}
- return( mbedtls_test_driver_mac_hooks.driver_status );
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
psa_status_t mbedtls_test_opaque_mac_sign_finish(
mbedtls_opaque_test_driver_mac_operation_t *operation,
uint8_t *mac,
size_t mac_size,
- size_t *mac_length )
+ size_t *mac_length)
{
mbedtls_test_driver_mac_hooks.hits++;
- if( mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_test_driver_mac_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
(void) operation;
(void) mac;
(void) mac_size;
@@ -432,49 +396,43 @@
mbedtls_test_driver_mac_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
}
- return( mbedtls_test_driver_mac_hooks.driver_status );
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
psa_status_t mbedtls_test_opaque_mac_verify_finish(
mbedtls_opaque_test_driver_mac_operation_t *operation,
const uint8_t *mac,
- size_t mac_length )
+ size_t mac_length)
{
mbedtls_test_driver_mac_hooks.hits++;
- if( mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_test_driver_mac_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
(void) operation;
(void) mac;
(void) mac_length;
mbedtls_test_driver_mac_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
}
- return( mbedtls_test_driver_mac_hooks.driver_status );
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
psa_status_t mbedtls_test_opaque_mac_abort(
- mbedtls_opaque_test_driver_mac_operation_t *operation )
+ mbedtls_opaque_test_driver_mac_operation_t *operation)
{
mbedtls_test_driver_mac_hooks.hits++;
- if( mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS )
- {
- mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_test_driver_mac_hooks.forced_status;
- }
- else
- {
+ if (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
(void) operation;
mbedtls_test_driver_mac_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED;
}
- return( mbedtls_test_driver_mac_hooks.driver_status );
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
#endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */
diff --git a/tests/src/drivers/test_driver_signature.c b/tests/src/drivers/test_driver_signature.c
index 3de43a8..75d7703 100644
--- a/tests/src/drivers/test_driver_signature.c
+++ b/tests/src/drivers/test_driver_signature.c
@@ -64,72 +64,63 @@
size_t hash_length,
uint8_t *signature,
size_t signature_size,
- size_t *signature_length )
+ size_t *signature_length)
{
- if( attributes->core.type == PSA_KEY_TYPE_RSA_KEY_PAIR )
- {
- if( PSA_ALG_IS_RSA_PKCS1V15_SIGN( alg ) ||
- PSA_ALG_IS_RSA_PSS( alg) )
- {
+ if (attributes->core.type == PSA_KEY_TYPE_RSA_KEY_PAIR) {
+ if (PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) ||
+ PSA_ALG_IS_RSA_PSS(alg)) {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- ( defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_RSA_PKCS1V15_SIGN) || \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS) )
- return( libtestdriver1_mbedtls_psa_rsa_sign_hash(
- (const libtestdriver1_psa_key_attributes_t *) attributes,
- key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_size, signature_length ) );
+ (defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_RSA_PKCS1V15_SIGN) || \
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS))
+ return libtestdriver1_mbedtls_psa_rsa_sign_hash(
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ key_buffer, key_buffer_size,
+ alg, hash, hash_length,
+ signature, signature_size, signature_length);
#elif defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PKCS1V15_SIGN) || \
- defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS)
- return( mbedtls_psa_rsa_sign_hash(
- attributes,
- key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_size, signature_length ) );
+ defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS)
+ return mbedtls_psa_rsa_sign_hash(
+ attributes,
+ key_buffer, key_buffer_size,
+ alg, hash, hash_length,
+ signature, signature_size, signature_length);
#endif
+ } else {
+ return PSA_ERROR_INVALID_ARGUMENT;
}
- else
- {
- return( PSA_ERROR_INVALID_ARGUMENT );
- }
- }
- else if( PSA_KEY_TYPE_IS_ECC( attributes->core.type ) )
- {
- if( PSA_ALG_IS_ECDSA( alg ) )
- {
+ } else if (PSA_KEY_TYPE_IS_ECC(attributes->core.type)) {
+ if (PSA_ALG_IS_ECDSA(alg)) {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- ( defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_ECDSA) || \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA) )
- return( libtestdriver1_mbedtls_psa_ecdsa_sign_hash(
- (const libtestdriver1_psa_key_attributes_t *) attributes,
- key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_size, signature_length ) );
+ (defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_ECDSA) || \
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA))
+ return libtestdriver1_mbedtls_psa_ecdsa_sign_hash(
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ key_buffer, key_buffer_size,
+ alg, hash, hash_length,
+ signature, signature_size, signature_length);
#elif defined(MBEDTLS_PSA_BUILTIN_ALG_ECDSA) || \
- defined(MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA)
- return( mbedtls_psa_ecdsa_sign_hash(
- attributes,
- key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_size, signature_length ) );
+ defined(MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA)
+ return mbedtls_psa_ecdsa_sign_hash(
+ attributes,
+ key_buffer, key_buffer_size,
+ alg, hash, hash_length,
+ signature, signature_size, signature_length);
#endif
- }
- else
- {
- return( PSA_ERROR_INVALID_ARGUMENT );
+ } else {
+ return PSA_ERROR_INVALID_ARGUMENT;
}
}
- (void)attributes;
- (void)key_buffer;
- (void)key_buffer_size;
- (void)alg;
- (void)hash;
- (void)hash_length;
- (void)signature;
- (void)signature_size;
- (void)signature_length;
- return( PSA_ERROR_NOT_SUPPORTED );
+ (void) attributes;
+ (void) key_buffer;
+ (void) key_buffer_size;
+ (void) alg;
+ (void) hash;
+ (void) hash_length;
+ (void) signature;
+ (void) signature_size;
+ (void) signature_length;
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t verify_hash(
@@ -140,71 +131,62 @@
const uint8_t *hash,
size_t hash_length,
const uint8_t *signature,
- size_t signature_length )
+ size_t signature_length)
{
- if( PSA_KEY_TYPE_IS_RSA( attributes->core.type ) )
- {
- if( PSA_ALG_IS_RSA_PKCS1V15_SIGN( alg ) ||
- PSA_ALG_IS_RSA_PSS( alg) )
- {
+ if (PSA_KEY_TYPE_IS_RSA(attributes->core.type)) {
+ if (PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) ||
+ PSA_ALG_IS_RSA_PSS(alg)) {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- ( defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_RSA_PKCS1V15_SIGN) || \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS) )
- return( libtestdriver1_mbedtls_psa_rsa_verify_hash(
- (const libtestdriver1_psa_key_attributes_t *) attributes,
- key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_length ) );
+ (defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_RSA_PKCS1V15_SIGN) || \
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS))
+ return libtestdriver1_mbedtls_psa_rsa_verify_hash(
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ key_buffer, key_buffer_size,
+ alg, hash, hash_length,
+ signature, signature_length);
#elif defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PKCS1V15_SIGN) || \
- defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS)
- return( mbedtls_psa_rsa_verify_hash(
- attributes,
- key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_length ) );
+ defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS)
+ return mbedtls_psa_rsa_verify_hash(
+ attributes,
+ key_buffer, key_buffer_size,
+ alg, hash, hash_length,
+ signature, signature_length);
#endif
+ } else {
+ return PSA_ERROR_INVALID_ARGUMENT;
}
- else
- {
- return( PSA_ERROR_INVALID_ARGUMENT );
- }
- }
- else if( PSA_KEY_TYPE_IS_ECC( attributes->core.type ) )
- {
- if( PSA_ALG_IS_ECDSA( alg ) )
- {
+ } else if (PSA_KEY_TYPE_IS_ECC(attributes->core.type)) {
+ if (PSA_ALG_IS_ECDSA(alg)) {
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
- ( defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_ECDSA) || \
- defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA) )
- return( libtestdriver1_mbedtls_psa_ecdsa_verify_hash(
- (const libtestdriver1_psa_key_attributes_t *) attributes,
- key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_length ) );
+ (defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_ECDSA) || \
+ defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA))
+ return libtestdriver1_mbedtls_psa_ecdsa_verify_hash(
+ (const libtestdriver1_psa_key_attributes_t *) attributes,
+ key_buffer, key_buffer_size,
+ alg, hash, hash_length,
+ signature, signature_length);
#elif defined(MBEDTLS_PSA_BUILTIN_ALG_ECDSA) || \
- defined(MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA)
- return( mbedtls_psa_ecdsa_verify_hash(
- attributes,
- key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_length ) );
+ defined(MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA)
+ return mbedtls_psa_ecdsa_verify_hash(
+ attributes,
+ key_buffer, key_buffer_size,
+ alg, hash, hash_length,
+ signature, signature_length);
#endif
- }
- else
- {
- return( PSA_ERROR_INVALID_ARGUMENT );
+ } else {
+ return PSA_ERROR_INVALID_ARGUMENT;
}
}
- (void)attributes;
- (void)key_buffer;
- (void)key_buffer_size;
- (void)alg;
- (void)hash;
- (void)hash_length;
- (void)signature;
- (void)signature_length;
- return( PSA_ERROR_NOT_SUPPORTED );
+ (void) attributes;
+ (void) key_buffer;
+ (void) key_buffer_size;
+ (void) alg;
+ (void) hash;
+ (void) hash_length;
+ (void) signature;
+ (void) signature_length;
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_transparent_signature_sign_message(
@@ -216,7 +198,7 @@
size_t input_length,
uint8_t *signature,
size_t signature_size,
- size_t *signature_length )
+ size_t *signature_length)
{
psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
size_t hash_length;
@@ -224,41 +206,43 @@
++mbedtls_test_driver_signature_sign_hooks.hits;
- if( mbedtls_test_driver_signature_sign_hooks.forced_status != PSA_SUCCESS )
- return( mbedtls_test_driver_signature_sign_hooks.forced_status );
+ if (mbedtls_test_driver_signature_sign_hooks.forced_status != PSA_SUCCESS) {
+ return mbedtls_test_driver_signature_sign_hooks.forced_status;
+ }
- if( mbedtls_test_driver_signature_sign_hooks.forced_output != NULL )
- {
- if( mbedtls_test_driver_signature_sign_hooks.forced_output_length > signature_size )
- return( PSA_ERROR_BUFFER_TOO_SMALL );
+ if (mbedtls_test_driver_signature_sign_hooks.forced_output != NULL) {
+ if (mbedtls_test_driver_signature_sign_hooks.forced_output_length > signature_size) {
+ return PSA_ERROR_BUFFER_TOO_SMALL;
+ }
- memcpy( signature, mbedtls_test_driver_signature_sign_hooks.forced_output,
- mbedtls_test_driver_signature_sign_hooks.forced_output_length );
+ memcpy(signature, mbedtls_test_driver_signature_sign_hooks.forced_output,
+ mbedtls_test_driver_signature_sign_hooks.forced_output_length);
*signature_length = mbedtls_test_driver_signature_sign_hooks.forced_output_length;
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH)
status = libtestdriver1_mbedtls_psa_hash_compute(
- PSA_ALG_SIGN_GET_HASH( alg ), input, input_length,
- hash, sizeof( hash ), &hash_length );
+ PSA_ALG_SIGN_GET_HASH(alg), input, input_length,
+ hash, sizeof(hash), &hash_length);
#elif defined(MBEDTLS_PSA_BUILTIN_HASH)
status = mbedtls_psa_hash_compute(
- PSA_ALG_SIGN_GET_HASH( alg ), input, input_length,
- hash, sizeof( hash ), &hash_length );
+ PSA_ALG_SIGN_GET_HASH(alg), input, input_length,
+ hash, sizeof(hash), &hash_length);
#else
(void) input;
(void) input_length;
status = PSA_ERROR_NOT_SUPPORTED;
#endif
- if( status != PSA_SUCCESS )
+ if (status != PSA_SUCCESS) {
return status;
+ }
- return( sign_hash( attributes, key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_size, signature_length ) );
+ return sign_hash(attributes, key_buffer, key_buffer_size,
+ alg, hash, hash_length,
+ signature, signature_size, signature_length);
}
psa_status_t mbedtls_test_opaque_signature_sign_message(
@@ -270,7 +254,7 @@
size_t input_length,
uint8_t *signature,
size_t signature_size,
- size_t *signature_length )
+ size_t *signature_length)
{
(void) attributes;
(void) key;
@@ -282,7 +266,7 @@
(void) signature_size;
(void) signature_length;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_transparent_signature_verify_message(
@@ -293,7 +277,7 @@
const uint8_t *input,
size_t input_length,
const uint8_t *signature,
- size_t signature_length )
+ size_t signature_length)
{
psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
size_t hash_length;
@@ -301,29 +285,31 @@
++mbedtls_test_driver_signature_verify_hooks.hits;
- if( mbedtls_test_driver_signature_verify_hooks.forced_status != PSA_SUCCESS )
- return( mbedtls_test_driver_signature_verify_hooks.forced_status );
+ if (mbedtls_test_driver_signature_verify_hooks.forced_status != PSA_SUCCESS) {
+ return mbedtls_test_driver_signature_verify_hooks.forced_status;
+ }
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \
defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH)
status = libtestdriver1_mbedtls_psa_hash_compute(
- PSA_ALG_SIGN_GET_HASH( alg ), input, input_length,
- hash, sizeof( hash ), &hash_length );
+ PSA_ALG_SIGN_GET_HASH(alg), input, input_length,
+ hash, sizeof(hash), &hash_length);
#elif defined(MBEDTLS_PSA_BUILTIN_HASH)
status = mbedtls_psa_hash_compute(
- PSA_ALG_SIGN_GET_HASH( alg ), input, input_length,
- hash, sizeof( hash ), &hash_length );
+ PSA_ALG_SIGN_GET_HASH(alg), input, input_length,
+ hash, sizeof(hash), &hash_length);
#else
(void) input;
(void) input_length;
status = PSA_ERROR_NOT_SUPPORTED;
#endif
- if( status != PSA_SUCCESS )
+ if (status != PSA_SUCCESS) {
return status;
+ }
- return( verify_hash( attributes, key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_length ) );
+ return verify_hash(attributes, key_buffer, key_buffer_size,
+ alg, hash, hash_length,
+ signature, signature_length);
}
psa_status_t mbedtls_test_opaque_signature_verify_message(
@@ -334,7 +320,7 @@
const uint8_t *input,
size_t input_length,
const uint8_t *signature,
- size_t signature_length )
+ size_t signature_length)
{
(void) attributes;
(void) key;
@@ -345,7 +331,7 @@
(void) signature;
(void) signature_length;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_transparent_signature_sign_hash(
@@ -353,26 +339,27 @@
const uint8_t *key_buffer, size_t key_buffer_size,
psa_algorithm_t alg,
const uint8_t *hash, size_t hash_length,
- uint8_t *signature, size_t signature_size, size_t *signature_length )
+ uint8_t *signature, size_t signature_size, size_t *signature_length)
{
++mbedtls_test_driver_signature_sign_hooks.hits;
- if( mbedtls_test_driver_signature_sign_hooks.forced_status != PSA_SUCCESS )
- return( mbedtls_test_driver_signature_sign_hooks.forced_status );
-
- if( mbedtls_test_driver_signature_sign_hooks.forced_output != NULL )
- {
- if( mbedtls_test_driver_signature_sign_hooks.forced_output_length > signature_size )
- return( PSA_ERROR_BUFFER_TOO_SMALL );
- memcpy( signature, mbedtls_test_driver_signature_sign_hooks.forced_output,
- mbedtls_test_driver_signature_sign_hooks.forced_output_length );
- *signature_length = mbedtls_test_driver_signature_sign_hooks.forced_output_length;
- return( PSA_SUCCESS );
+ if (mbedtls_test_driver_signature_sign_hooks.forced_status != PSA_SUCCESS) {
+ return mbedtls_test_driver_signature_sign_hooks.forced_status;
}
- return( sign_hash( attributes, key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_size, signature_length ) );
+ if (mbedtls_test_driver_signature_sign_hooks.forced_output != NULL) {
+ if (mbedtls_test_driver_signature_sign_hooks.forced_output_length > signature_size) {
+ return PSA_ERROR_BUFFER_TOO_SMALL;
+ }
+ memcpy(signature, mbedtls_test_driver_signature_sign_hooks.forced_output,
+ mbedtls_test_driver_signature_sign_hooks.forced_output_length);
+ *signature_length = mbedtls_test_driver_signature_sign_hooks.forced_output_length;
+ return PSA_SUCCESS;
+ }
+
+ return sign_hash(attributes, key_buffer, key_buffer_size,
+ alg, hash, hash_length,
+ signature, signature_size, signature_length);
}
psa_status_t mbedtls_test_opaque_signature_sign_hash(
@@ -380,7 +367,7 @@
const uint8_t *key, size_t key_length,
psa_algorithm_t alg,
const uint8_t *hash, size_t hash_length,
- uint8_t *signature, size_t signature_size, size_t *signature_length )
+ uint8_t *signature, size_t signature_size, size_t *signature_length)
{
(void) attributes;
(void) key;
@@ -392,7 +379,7 @@
(void) signature_size;
(void) signature_length;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_transparent_signature_verify_hash(
@@ -400,16 +387,17 @@
const uint8_t *key_buffer, size_t key_buffer_size,
psa_algorithm_t alg,
const uint8_t *hash, size_t hash_length,
- const uint8_t *signature, size_t signature_length )
+ const uint8_t *signature, size_t signature_length)
{
++mbedtls_test_driver_signature_verify_hooks.hits;
- if( mbedtls_test_driver_signature_verify_hooks.forced_status != PSA_SUCCESS )
- return( mbedtls_test_driver_signature_verify_hooks.forced_status );
+ if (mbedtls_test_driver_signature_verify_hooks.forced_status != PSA_SUCCESS) {
+ return mbedtls_test_driver_signature_verify_hooks.forced_status;
+ }
- return verify_hash( attributes, key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_length );
+ return verify_hash(attributes, key_buffer, key_buffer_size,
+ alg, hash, hash_length,
+ signature, signature_length);
}
psa_status_t mbedtls_test_opaque_signature_verify_hash(
@@ -417,7 +405,7 @@
const uint8_t *key, size_t key_length,
psa_algorithm_t alg,
const uint8_t *hash, size_t hash_length,
- const uint8_t *signature, size_t signature_length )
+ const uint8_t *signature, size_t signature_length)
{
(void) attributes;
(void) key;
@@ -427,7 +415,7 @@
(void) hash_length;
(void) signature;
(void) signature_length;
- return( PSA_ERROR_NOT_SUPPORTED );
+ return PSA_ERROR_NOT_SUPPORTED;
}
#endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */
diff --git a/tests/src/drivers/test_driver_size.c b/tests/src/drivers/test_driver_size.c
index d8bcaee..e0226dd 100644
--- a/tests/src/drivers/test_driver_size.c
+++ b/tests/src/drivers/test_driver_size.c
@@ -37,7 +37,7 @@
* This macro returns the base size for the key context. It is the size of the
* driver specific information stored in each key context.
*/
-#define TEST_DRIVER_KEY_CONTEXT_BASE_SIZE sizeof( test_driver_key_context_t )
+#define TEST_DRIVER_KEY_CONTEXT_BASE_SIZE sizeof(test_driver_key_context_t)
/*
* Number of bytes included in every key context for a key pair.
@@ -70,32 +70,27 @@
size_t mbedtls_test_size_function(
const psa_key_type_t key_type,
- const size_t key_bits )
+ const size_t key_bits)
{
size_t key_buffer_size = 0;
- if( PSA_KEY_TYPE_IS_KEY_PAIR( key_type ) )
- {
+ if (PSA_KEY_TYPE_IS_KEY_PAIR(key_type)) {
int public_key_overhead =
- ( ( TEST_DRIVER_KEY_CONTEXT_STORE_PUBLIC_KEY == 1 )
- ? PSA_EXPORT_KEY_OUTPUT_SIZE( key_type, key_bits ) : 0 );
+ ((TEST_DRIVER_KEY_CONTEXT_STORE_PUBLIC_KEY == 1)
+ ? PSA_EXPORT_KEY_OUTPUT_SIZE(key_type, key_bits) : 0);
key_buffer_size = TEST_DRIVER_KEY_CONTEXT_BASE_SIZE +
TEST_DRIVER_KEY_CONTEXT_PUBLIC_KEY_SIZE +
public_key_overhead;
- }
- else if( PSA_KEY_TYPE_IS_PUBLIC_KEY( key_type ) )
- {
+ } else if (PSA_KEY_TYPE_IS_PUBLIC_KEY(key_type)) {
key_buffer_size = TEST_DRIVER_KEY_CONTEXT_BASE_SIZE +
TEST_DRIVER_KEY_CONTEXT_PUBLIC_KEY_SIZE;
- }
- else if ( !PSA_KEY_TYPE_IS_KEY_PAIR( key_type ) &&
- !PSA_KEY_TYPE_IS_PUBLIC_KEY ( key_type ) )
- {
+ } else if (!PSA_KEY_TYPE_IS_KEY_PAIR(key_type) &&
+ !PSA_KEY_TYPE_IS_PUBLIC_KEY(key_type)) {
key_buffer_size = TEST_DRIVER_KEY_CONTEXT_BASE_SIZE +
- ( TEST_DRIVER_KEY_CONTEXT_SYMMETRIC_FACTOR *
- ( ( key_bits + 7 ) / 8 ) );
+ (TEST_DRIVER_KEY_CONTEXT_SYMMETRIC_FACTOR *
+ ((key_bits + 7) / 8));
}
- return( key_buffer_size );
+ return key_buffer_size;
}
#endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */
diff --git a/tests/src/fake_external_rng_for_test.c b/tests/src/fake_external_rng_for_test.c
index 9c2195b..89af7d3 100644
--- a/tests/src/fake_external_rng_for_test.c
+++ b/tests/src/fake_external_rng_for_test.c
@@ -28,29 +28,30 @@
static int test_insecure_external_rng_enabled = 0;
-void mbedtls_test_enable_insecure_external_rng( void )
+void mbedtls_test_enable_insecure_external_rng(void)
{
test_insecure_external_rng_enabled = 1;
}
-void mbedtls_test_disable_insecure_external_rng( void )
+void mbedtls_test_disable_insecure_external_rng(void)
{
test_insecure_external_rng_enabled = 0;
}
psa_status_t mbedtls_psa_external_get_random(
mbedtls_psa_external_random_context_t *context,
- uint8_t *output, size_t output_size, size_t *output_length )
+ uint8_t *output, size_t output_size, size_t *output_length)
{
(void) context;
- if( !test_insecure_external_rng_enabled )
- return( PSA_ERROR_INSUFFICIENT_ENTROPY );
+ if (!test_insecure_external_rng_enabled) {
+ return PSA_ERROR_INSUFFICIENT_ENTROPY;
+ }
/* This implementation is for test purposes only!
* Use the libc non-cryptographic random generator. */
- mbedtls_test_rnd_std_rand( NULL, output, output_size );
+ mbedtls_test_rnd_std_rand(NULL, output, output_size);
*output_length = output_size;
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
#endif /* MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */
diff --git a/tests/src/helpers.c b/tests/src/helpers.c
index 77b4d94..6c215d1 100644
--- a/tests/src/helpers.c
+++ b/tests/src/helpers.c
@@ -28,8 +28,7 @@
/* Static global variables */
#if defined(MBEDTLS_CHECK_PARAMS)
-typedef struct
-{
+typedef struct {
uint8_t expected_call;
uint8_t expected_call_happened;
@@ -50,40 +49,40 @@
/*----------------------------------------------------------------------------*/
/* Helper Functions */
-int mbedtls_test_platform_setup( void )
+int mbedtls_test_platform_setup(void)
{
int ret = 0;
#if defined(MBEDTLS_PLATFORM_C)
- ret = mbedtls_platform_setup( &platform_ctx );
+ ret = mbedtls_platform_setup(&platform_ctx);
#endif /* MBEDTLS_PLATFORM_C */
- return( ret );
+ return ret;
}
-void mbedtls_test_platform_teardown( void )
+void mbedtls_test_platform_teardown(void)
{
#if defined(MBEDTLS_PLATFORM_C)
- mbedtls_platform_teardown( &platform_ctx );
+ mbedtls_platform_teardown(&platform_ctx);
#endif /* MBEDTLS_PLATFORM_C */
}
static int ascii2uc(const char c, unsigned char *uc)
{
- if( ( c >= '0' ) && ( c <= '9' ) )
+ if ((c >= '0') && (c <= '9')) {
*uc = c - '0';
- else if( ( c >= 'a' ) && ( c <= 'f' ) )
+ } else if ((c >= 'a') && (c <= 'f')) {
*uc = c - 'a' + 10;
- else if( ( c >= 'A' ) && ( c <= 'F' ) )
+ } else if ((c >= 'A') && (c <= 'F')) {
*uc = c - 'A' + 10;
- else
- return( -1 );
+ } else {
+ return -1;
+ }
- return( 0 );
+ return 0;
}
-void mbedtls_test_fail( const char *test, int line_no, const char* filename )
+void mbedtls_test_fail(const char *test, int line_no, const char *filename)
{
- if( mbedtls_test_info.result == MBEDTLS_TEST_RESULT_FAILED )
- {
+ if (mbedtls_test_info.result == MBEDTLS_TEST_RESULT_FAILED) {
/* We've already recorded the test as having failed. Don't
* overwrite any previous information about the failure. */
return;
@@ -94,7 +93,7 @@
mbedtls_test_info.filename = filename;
}
-void mbedtls_test_skip( const char *test, int line_no, const char* filename )
+void mbedtls_test_skip(const char *test, int line_no, const char *filename)
{
mbedtls_test_info.result = MBEDTLS_TEST_RESULT_SKIPPED;
mbedtls_test_info.test = test;
@@ -102,7 +101,7 @@
mbedtls_test_info.filename = filename;
}
-void mbedtls_test_set_step( unsigned long step )
+void mbedtls_test_set_step(unsigned long step)
{
mbedtls_test_info.step = step;
}
@@ -111,201 +110,205 @@
unsigned mbedtls_test_case_uses_negative_0 = 0;
#endif
-void mbedtls_test_info_reset( void )
+void mbedtls_test_info_reset(void)
{
mbedtls_test_info.result = MBEDTLS_TEST_RESULT_SUCCESS;
- mbedtls_test_info.step = (unsigned long)( -1 );
+ mbedtls_test_info.step = (unsigned long) (-1);
mbedtls_test_info.test = 0;
mbedtls_test_info.line_no = 0;
mbedtls_test_info.filename = 0;
- memset( mbedtls_test_info.line1, 0, sizeof( mbedtls_test_info.line1 ) );
- memset( mbedtls_test_info.line2, 0, sizeof( mbedtls_test_info.line2 ) );
+ memset(mbedtls_test_info.line1, 0, sizeof(mbedtls_test_info.line1));
+ memset(mbedtls_test_info.line2, 0, sizeof(mbedtls_test_info.line2));
#if defined(MBEDTLS_BIGNUM_C)
mbedtls_test_case_uses_negative_0 = 0;
#endif
}
-int mbedtls_test_equal( const char *test, int line_no, const char* filename,
- unsigned long long value1, unsigned long long value2 )
+int mbedtls_test_equal(const char *test, int line_no, const char *filename,
+ unsigned long long value1, unsigned long long value2)
{
- TEST_CF_PUBLIC( &value1, sizeof( value1 ) );
- TEST_CF_PUBLIC( &value2, sizeof( value2 ) );
+ TEST_CF_PUBLIC(&value1, sizeof(value1));
+ TEST_CF_PUBLIC(&value2, sizeof(value2));
- if( value1 == value2 )
- return( 1 );
+ if (value1 == value2) {
+ return 1;
+ }
- if( mbedtls_test_info.result == MBEDTLS_TEST_RESULT_FAILED )
- {
+ if (mbedtls_test_info.result == MBEDTLS_TEST_RESULT_FAILED) {
/* We've already recorded the test as having failed. Don't
* overwrite any previous information about the failure. */
- return( 0 );
+ return 0;
}
- mbedtls_test_fail( test, line_no, filename );
- (void) mbedtls_snprintf( mbedtls_test_info.line1,
- sizeof( mbedtls_test_info.line1 ),
- "lhs = 0x%016llx = %lld",
- value1, (long long) value1 );
- (void) mbedtls_snprintf( mbedtls_test_info.line2,
- sizeof( mbedtls_test_info.line2 ),
- "rhs = 0x%016llx = %lld",
- value2, (long long) value2 );
- return( 0 );
+ mbedtls_test_fail(test, line_no, filename);
+ (void) mbedtls_snprintf(mbedtls_test_info.line1,
+ sizeof(mbedtls_test_info.line1),
+ "lhs = 0x%016llx = %lld",
+ value1, (long long) value1);
+ (void) mbedtls_snprintf(mbedtls_test_info.line2,
+ sizeof(mbedtls_test_info.line2),
+ "rhs = 0x%016llx = %lld",
+ value2, (long long) value2);
+ return 0;
}
-int mbedtls_test_le_u( const char *test, int line_no, const char* filename,
- unsigned long long value1, unsigned long long value2 )
+int mbedtls_test_le_u(const char *test, int line_no, const char *filename,
+ unsigned long long value1, unsigned long long value2)
{
- TEST_CF_PUBLIC( &value1, sizeof( value1 ) );
- TEST_CF_PUBLIC( &value2, sizeof( value2 ) );
+ TEST_CF_PUBLIC(&value1, sizeof(value1));
+ TEST_CF_PUBLIC(&value2, sizeof(value2));
- if( value1 <= value2 )
- return( 1 );
+ if (value1 <= value2) {
+ return 1;
+ }
- if( mbedtls_test_info.result == MBEDTLS_TEST_RESULT_FAILED )
- {
+ if (mbedtls_test_info.result == MBEDTLS_TEST_RESULT_FAILED) {
/* We've already recorded the test as having failed. Don't
* overwrite any previous information about the failure. */
- return( 0 );
+ return 0;
}
- mbedtls_test_fail( test, line_no, filename );
- (void) mbedtls_snprintf( mbedtls_test_info.line1,
- sizeof( mbedtls_test_info.line1 ),
- "lhs = 0x%016llx = %llu",
- value1, value1 );
- (void) mbedtls_snprintf( mbedtls_test_info.line2,
- sizeof( mbedtls_test_info.line2 ),
- "rhs = 0x%016llx = %llu",
- value2, value2 );
- return( 0 );
+ mbedtls_test_fail(test, line_no, filename);
+ (void) mbedtls_snprintf(mbedtls_test_info.line1,
+ sizeof(mbedtls_test_info.line1),
+ "lhs = 0x%016llx = %llu",
+ value1, value1);
+ (void) mbedtls_snprintf(mbedtls_test_info.line2,
+ sizeof(mbedtls_test_info.line2),
+ "rhs = 0x%016llx = %llu",
+ value2, value2);
+ return 0;
}
-int mbedtls_test_le_s( const char *test, int line_no, const char* filename,
- long long value1, long long value2 )
+int mbedtls_test_le_s(const char *test, int line_no, const char *filename,
+ long long value1, long long value2)
{
- TEST_CF_PUBLIC( &value1, sizeof( value1 ) );
- TEST_CF_PUBLIC( &value2, sizeof( value2 ) );
+ TEST_CF_PUBLIC(&value1, sizeof(value1));
+ TEST_CF_PUBLIC(&value2, sizeof(value2));
- if( value1 <= value2 )
- return( 1 );
+ if (value1 <= value2) {
+ return 1;
+ }
- if( mbedtls_test_info.result == MBEDTLS_TEST_RESULT_FAILED )
- {
+ if (mbedtls_test_info.result == MBEDTLS_TEST_RESULT_FAILED) {
/* We've already recorded the test as having failed. Don't
* overwrite any previous information about the failure. */
- return( 0 );
+ return 0;
}
- mbedtls_test_fail( test, line_no, filename );
- (void) mbedtls_snprintf( mbedtls_test_info.line1,
- sizeof( mbedtls_test_info.line1 ),
- "lhs = 0x%016llx = %lld",
- (unsigned long long) value1, value1 );
- (void) mbedtls_snprintf( mbedtls_test_info.line2,
- sizeof( mbedtls_test_info.line2 ),
- "rhs = 0x%016llx = %lld",
- (unsigned long long) value2, value2 );
- return( 0 );
+ mbedtls_test_fail(test, line_no, filename);
+ (void) mbedtls_snprintf(mbedtls_test_info.line1,
+ sizeof(mbedtls_test_info.line1),
+ "lhs = 0x%016llx = %lld",
+ (unsigned long long) value1, value1);
+ (void) mbedtls_snprintf(mbedtls_test_info.line2,
+ sizeof(mbedtls_test_info.line2),
+ "rhs = 0x%016llx = %lld",
+ (unsigned long long) value2, value2);
+ return 0;
}
-int mbedtls_test_unhexify( unsigned char *obuf,
- size_t obufmax,
- const char *ibuf,
- size_t *len )
+int mbedtls_test_unhexify(unsigned char *obuf,
+ size_t obufmax,
+ const char *ibuf,
+ size_t *len)
{
unsigned char uc, uc2;
- *len = strlen( ibuf );
+ *len = strlen(ibuf);
/* Must be even number of bytes. */
- if ( ( *len ) & 1 )
- return( -1 );
+ if ((*len) & 1) {
+ return -1;
+ }
*len /= 2;
- if ( (*len) > obufmax )
- return( -1 );
-
- while( *ibuf != 0 )
- {
- if ( ascii2uc( *(ibuf++), &uc ) != 0 )
- return( -1 );
-
- if ( ascii2uc( *(ibuf++), &uc2 ) != 0 )
- return( -1 );
-
- *(obuf++) = ( uc << 4 ) | uc2;
+ if ((*len) > obufmax) {
+ return -1;
}
- return( 0 );
+ while (*ibuf != 0) {
+ if (ascii2uc(*(ibuf++), &uc) != 0) {
+ return -1;
+ }
+
+ if (ascii2uc(*(ibuf++), &uc2) != 0) {
+ return -1;
+ }
+
+ *(obuf++) = (uc << 4) | uc2;
+ }
+
+ return 0;
}
-void mbedtls_test_hexify( unsigned char *obuf,
- const unsigned char *ibuf,
- int len )
+void mbedtls_test_hexify(unsigned char *obuf,
+ const unsigned char *ibuf,
+ int len)
{
unsigned char l, h;
- while( len != 0 )
- {
+ while (len != 0) {
h = *ibuf / 16;
l = *ibuf % 16;
- if( h < 10 )
+ if (h < 10) {
*obuf++ = '0' + h;
- else
+ } else {
*obuf++ = 'a' + h - 10;
+ }
- if( l < 10 )
+ if (l < 10) {
*obuf++ = '0' + l;
- else
+ } else {
*obuf++ = 'a' + l - 10;
+ }
++ibuf;
len--;
}
}
-unsigned char *mbedtls_test_zero_alloc( size_t len )
+unsigned char *mbedtls_test_zero_alloc(size_t len)
{
void *p;
- size_t actual_len = ( len != 0 ) ? len : 1;
+ size_t actual_len = (len != 0) ? len : 1;
- p = mbedtls_calloc( 1, actual_len );
- TEST_HELPER_ASSERT( p != NULL );
+ p = mbedtls_calloc(1, actual_len);
+ TEST_HELPER_ASSERT(p != NULL);
- memset( p, 0x00, actual_len );
+ memset(p, 0x00, actual_len);
- return( p );
+ return p;
}
-unsigned char *mbedtls_test_unhexify_alloc( const char *ibuf, size_t *olen )
+unsigned char *mbedtls_test_unhexify_alloc(const char *ibuf, size_t *olen)
{
unsigned char *obuf;
size_t len;
- *olen = strlen( ibuf ) / 2;
+ *olen = strlen(ibuf) / 2;
- if( *olen == 0 )
- return( mbedtls_test_zero_alloc( *olen ) );
+ if (*olen == 0) {
+ return mbedtls_test_zero_alloc(*olen);
+ }
- obuf = mbedtls_calloc( 1, *olen );
- TEST_HELPER_ASSERT( obuf != NULL );
- TEST_HELPER_ASSERT( mbedtls_test_unhexify( obuf, *olen, ibuf, &len ) == 0 );
+ obuf = mbedtls_calloc(1, *olen);
+ TEST_HELPER_ASSERT(obuf != NULL);
+ TEST_HELPER_ASSERT(mbedtls_test_unhexify(obuf, *olen, ibuf, &len) == 0);
- return( obuf );
+ return obuf;
}
-int mbedtls_test_hexcmp( uint8_t * a, uint8_t * b,
- uint32_t a_len, uint32_t b_len )
+int mbedtls_test_hexcmp(uint8_t *a, uint8_t *b,
+ uint32_t a_len, uint32_t b_len)
{
int ret = 0;
uint32_t i = 0;
- if( a_len != b_len )
- return( -1 );
+ if (a_len != b_len) {
+ return -1;
+ }
- for( i = 0; i < a_len; i++ )
- {
- if( a[i] != b[i] )
- {
+ for (i = 0; i < a_len; i++) {
+ if (a[i] != b[i]) {
ret = -1;
break;
}
@@ -315,40 +318,41 @@
#if defined(MBEDTLS_CHECK_PARAMS)
void mbedtls_test_param_failed_get_location_record(
- mbedtls_test_param_failed_location_record_t *location_record )
+ mbedtls_test_param_failed_location_record_t *location_record)
{
*location_record = param_failed_ctx.location_record;
}
-void mbedtls_test_param_failed_expect_call( void )
+void mbedtls_test_param_failed_expect_call(void)
{
param_failed_ctx.expected_call_happened = 0;
param_failed_ctx.expected_call = 1;
}
-int mbedtls_test_param_failed_check_expected_call( void )
+int mbedtls_test_param_failed_check_expected_call(void)
{
param_failed_ctx.expected_call = 0;
- if( param_failed_ctx.expected_call_happened != 0 )
- return( 0 );
+ if (param_failed_ctx.expected_call_happened != 0) {
+ return 0;
+ }
- return( -1 );
+ return -1;
}
-void* mbedtls_test_param_failed_get_state_buf( void )
+void *mbedtls_test_param_failed_get_state_buf(void)
{
return ¶m_failed_ctx.state;
}
-void mbedtls_test_param_failed_reset_state( void )
+void mbedtls_test_param_failed_reset_state(void)
{
- memset( param_failed_ctx.state, 0, sizeof( param_failed_ctx.state ) );
+ memset(param_failed_ctx.state, 0, sizeof(param_failed_ctx.state));
}
-void mbedtls_param_failed( const char *failure_condition,
- const char *file,
- int line )
+void mbedtls_param_failed(const char *failure_condition,
+ const char *file,
+ int line)
{
/* Record the location of the failure */
param_failed_ctx.location_record.failure_condition = failure_condition;
@@ -356,27 +360,24 @@
param_failed_ctx.location_record.line = line;
/* If we are testing the callback function... */
- if( param_failed_ctx.expected_call != 0 )
- {
+ if (param_failed_ctx.expected_call != 0) {
param_failed_ctx.expected_call = 0;
param_failed_ctx.expected_call_happened = 1;
- }
- else
- {
+ } else {
/* ...else try a long jump. If the execution state has not been set-up
* or reset then the long jump buffer is all zero's and the call will
* with high probability fault, emphasizing there is something to look
* at.
*/
- longjmp( param_failed_ctx.state, 1 );
+ longjmp(param_failed_ctx.state, 1);
}
}
#endif /* MBEDTLS_CHECK_PARAMS */
#if defined(MBEDTLS_TEST_HOOKS)
-void mbedtls_test_err_add_check( int high, int low,
- const char *file, int line )
+void mbedtls_test_err_add_check(int high, int low,
+ const char *file, int line)
{
/* Error codes are always negative (a value of zero is a success) however
* their positive opposites can be easier to understand. The following
@@ -390,74 +391,64 @@
* and module-dependent error code (bits 7..11)).
* l = low level error code.
*/
- if ( high > -0x1000 && high != 0 )
- /* high < 0001000000000000
- * No high level module ID bits are set.
- */
- {
- mbedtls_test_fail( "'high' is not a high-level error code",
- line, file );
- }
- else if ( high < -0x7F80 )
- /* high > 0111111110000000
- * Error code is greater than the largest allowed high level module ID.
- */
- {
- mbedtls_test_fail( "'high' error code is greater than 15 bits",
- line, file );
- }
- else if ( ( high & 0x7F ) != 0 )
- /* high & 0000000001111111
- * Error code contains low level error code bits.
- */
- {
- mbedtls_test_fail( "'high' contains a low-level error code",
- line, file );
- }
- else if ( low < -0x007F )
- /* low > 0000000001111111
- * Error code contains high or module level error code bits.
- */
- {
- mbedtls_test_fail( "'low' error code is greater than 7 bits",
- line, file );
- }
- else if ( low > 0 )
- {
- mbedtls_test_fail( "'low' error code is greater than zero",
- line, file );
+ if (high > -0x1000 && high != 0) {
+ /* high < 0001000000000000
+ * No high level module ID bits are set.
+ */
+ mbedtls_test_fail("'high' is not a high-level error code",
+ line, file);
+ } else if (high < -0x7F80) {
+ /* high > 0111111110000000
+ * Error code is greater than the largest allowed high level module ID.
+ */
+ mbedtls_test_fail("'high' error code is greater than 15 bits",
+ line, file);
+ } else if ((high & 0x7F) != 0) {
+ /* high & 0000000001111111
+ * Error code contains low level error code bits.
+ */
+ mbedtls_test_fail("'high' contains a low-level error code",
+ line, file);
+ } else if (low < -0x007F) {
+ /* low > 0000000001111111
+ * Error code contains high or module level error code bits.
+ */
+ mbedtls_test_fail("'low' error code is greater than 7 bits",
+ line, file);
+ } else if (low > 0) {
+ mbedtls_test_fail("'low' error code is greater than zero",
+ line, file);
}
}
#endif /* MBEDTLS_TEST_HOOKS */
#if defined(MBEDTLS_BIGNUM_C)
-int mbedtls_test_read_mpi( mbedtls_mpi *X, const char *s )
+int mbedtls_test_read_mpi(mbedtls_mpi *X, const char *s)
{
int negative = 0;
/* Always set the sign bit to -1 if the input has a minus sign, even for 0.
* This creates an invalid representation, which mbedtls_mpi_read_string()
* avoids but we want to be able to create that in test data. */
- if( s[0] == '-' )
- {
+ if (s[0] == '-') {
++s;
negative = 1;
}
/* mbedtls_mpi_read_string() currently retains leading zeros.
* It always allocates at least one limb for the value 0. */
- if( s[0] == 0 )
- {
- mbedtls_mpi_free( X );
- return( 0 );
+ if (s[0] == 0) {
+ mbedtls_mpi_free(X);
+ return 0;
}
- int ret = mbedtls_mpi_read_string( X, 16, s );
- if( ret != 0 )
- return( ret );
- if( negative )
- {
- if( mbedtls_mpi_cmp_int( X, 0 ) == 0 )
+ int ret = mbedtls_mpi_read_string(X, 16, s);
+ if (ret != 0) {
+ return ret;
+ }
+ if (negative) {
+ if (mbedtls_mpi_cmp_int(X, 0) == 0) {
++mbedtls_test_case_uses_negative_0;
+ }
X->s = -1;
}
- return( 0 );
+ return 0;
}
#endif
diff --git a/tests/src/psa_crypto_helpers.c b/tests/src/psa_crypto_helpers.c
index 299b6d1..06274d3 100644
--- a/tests/src/psa_crypto_helpers.c
+++ b/tests/src/psa_crypto_helpers.c
@@ -36,96 +36,106 @@
static mbedtls_svc_key_id_t key_ids_used_in_test[9];
static size_t num_key_ids_used;
-int mbedtls_test_uses_key_id( mbedtls_svc_key_id_t key_id )
+int mbedtls_test_uses_key_id(mbedtls_svc_key_id_t key_id)
{
size_t i;
- if( MBEDTLS_SVC_KEY_ID_GET_KEY_ID( key_id ) >
- PSA_MAX_PERSISTENT_KEY_IDENTIFIER )
- {
+ if (MBEDTLS_SVC_KEY_ID_GET_KEY_ID(key_id) >
+ PSA_MAX_PERSISTENT_KEY_IDENTIFIER) {
/* Don't touch key id values that designate non-key files. */
- return( 1 );
+ return 1;
}
- for( i = 0; i < num_key_ids_used ; i++ )
- {
- if( mbedtls_svc_key_id_equal( key_id, key_ids_used_in_test[i] ) )
- return( 1 );
+ for (i = 0; i < num_key_ids_used; i++) {
+ if (mbedtls_svc_key_id_equal(key_id, key_ids_used_in_test[i])) {
+ return 1;
+ }
}
- if( num_key_ids_used == ARRAY_LENGTH( key_ids_used_in_test ) )
- return( 0 );
+ if (num_key_ids_used == ARRAY_LENGTH(key_ids_used_in_test)) {
+ return 0;
+ }
key_ids_used_in_test[num_key_ids_used] = key_id;
++num_key_ids_used;
- return( 1 );
+ return 1;
}
-void mbedtls_test_psa_purge_key_storage( void )
+void mbedtls_test_psa_purge_key_storage(void)
{
size_t i;
- for( i = 0; i < num_key_ids_used; i++ )
- psa_destroy_persistent_key( key_ids_used_in_test[i] );
+ for (i = 0; i < num_key_ids_used; i++) {
+ psa_destroy_persistent_key(key_ids_used_in_test[i]);
+ }
num_key_ids_used = 0;
}
-void mbedtls_test_psa_purge_key_cache( void )
+void mbedtls_test_psa_purge_key_cache(void)
{
size_t i;
- for( i = 0; i < num_key_ids_used; i++ )
- psa_purge_key( key_ids_used_in_test[i] );
+ for (i = 0; i < num_key_ids_used; i++) {
+ psa_purge_key(key_ids_used_in_test[i]);
+ }
}
#endif /* MBEDTLS_PSA_CRYPTO_STORAGE_C */
-const char *mbedtls_test_helper_is_psa_leaking( void )
+const char *mbedtls_test_helper_is_psa_leaking(void)
{
mbedtls_psa_stats_t stats;
- mbedtls_psa_get_stats( &stats );
+ mbedtls_psa_get_stats(&stats);
- if( stats.volatile_slots != 0 )
- return( "A volatile slot has not been closed properly." );
- if( stats.persistent_slots != 0 )
- return( "A persistent slot has not been closed properly." );
- if( stats.external_slots != 0 )
- return( "An external slot has not been closed properly." );
- if( stats.half_filled_slots != 0 )
- return( "A half-filled slot has not been cleared properly." );
- if( stats.locked_slots != 0 )
- return( "Some slots are still marked as locked." );
+ if (stats.volatile_slots != 0) {
+ return "A volatile slot has not been closed properly.";
+ }
+ if (stats.persistent_slots != 0) {
+ return "A persistent slot has not been closed properly.";
+ }
+ if (stats.external_slots != 0) {
+ return "An external slot has not been closed properly.";
+ }
+ if (stats.half_filled_slots != 0) {
+ return "A half-filled slot has not been cleared properly.";
+ }
+ if (stats.locked_slots != 0) {
+ return "Some slots are still marked as locked.";
+ }
- return( NULL );
+ return NULL;
}
#if defined(RECORD_PSA_STATUS_COVERAGE_LOG)
/** Name of the file where return statuses are logged by #RECORD_STATUS. */
#define STATUS_LOG_FILE_NAME "statuses.log"
-psa_status_t mbedtls_test_record_status( psa_status_t status,
- const char *func,
- const char *file, int line,
- const char *expr )
+psa_status_t mbedtls_test_record_status(psa_status_t status,
+ const char *func,
+ const char *file, int line,
+ const char *expr)
{
/* We open the log file on first use.
* We never close the log file, so the record_status feature is not
* compatible with resource leak detectors such as Asan.
*/
static FILE *log;
- if( log == NULL )
- log = fopen( STATUS_LOG_FILE_NAME, "a" );
- fprintf( log, "%d:%s:%s:%d:%s\n", (int) status, func, file, line, expr );
- return( status );
+ if (log == NULL) {
+ log = fopen(STATUS_LOG_FILE_NAME, "a");
+ }
+ fprintf(log, "%d:%s:%s:%d:%s\n", (int) status, func, file, line, expr);
+ return status;
}
#endif /* defined(RECORD_PSA_STATUS_COVERAGE_LOG) */
-psa_key_usage_t mbedtls_test_update_key_usage_flags( psa_key_usage_t usage_flags )
+psa_key_usage_t mbedtls_test_update_key_usage_flags(psa_key_usage_t usage_flags)
{
psa_key_usage_t updated_usage = usage_flags;
- if( usage_flags & PSA_KEY_USAGE_SIGN_HASH )
+ if (usage_flags & PSA_KEY_USAGE_SIGN_HASH) {
updated_usage |= PSA_KEY_USAGE_SIGN_MESSAGE;
+ }
- if( usage_flags & PSA_KEY_USAGE_VERIFY_HASH )
+ if (usage_flags & PSA_KEY_USAGE_VERIFY_HASH) {
updated_usage |= PSA_KEY_USAGE_VERIFY_MESSAGE;
+ }
- return( updated_usage );
+ return updated_usage;
}
#endif /* MBEDTLS_PSA_CRYPTO_C */
diff --git a/tests/src/psa_exercise_key.c b/tests/src/psa_exercise_key.c
index d1650f1..0843e24 100644
--- a/tests/src/psa_exercise_key.c
+++ b/tests/src/psa_exercise_key.c
@@ -33,14 +33,14 @@
#include <test/psa_crypto_helpers.h>
#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
-static int lifetime_is_dynamic_secure_element( psa_key_lifetime_t lifetime )
+static int lifetime_is_dynamic_secure_element(psa_key_lifetime_t lifetime)
{
- return( PSA_KEY_LIFETIME_GET_LOCATION( lifetime ) !=
- PSA_KEY_LOCATION_LOCAL_STORAGE );
+ return PSA_KEY_LIFETIME_GET_LOCATION(lifetime) !=
+ PSA_KEY_LOCATION_LOCAL_STORAGE;
}
#endif
-static int check_key_attributes_sanity( mbedtls_svc_key_id_t key )
+static int check_key_attributes_sanity(mbedtls_svc_key_id_t key)
{
int ok = 0;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -49,58 +49,54 @@
psa_key_type_t type;
size_t bits;
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- lifetime = psa_get_key_lifetime( &attributes );
- id = psa_get_key_id( &attributes );
- type = psa_get_key_type( &attributes );
- bits = psa_get_key_bits( &attributes );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ lifetime = psa_get_key_lifetime(&attributes);
+ id = psa_get_key_id(&attributes);
+ type = psa_get_key_type(&attributes);
+ bits = psa_get_key_bits(&attributes);
/* Persistence */
- if( PSA_KEY_LIFETIME_IS_VOLATILE( lifetime ) )
- {
+ if (PSA_KEY_LIFETIME_IS_VOLATILE(lifetime)) {
TEST_ASSERT(
- ( PSA_KEY_ID_VOLATILE_MIN <=
- MBEDTLS_SVC_KEY_ID_GET_KEY_ID( id ) ) &&
- ( MBEDTLS_SVC_KEY_ID_GET_KEY_ID( id ) <=
- PSA_KEY_ID_VOLATILE_MAX ) );
- }
- else
- {
+ (PSA_KEY_ID_VOLATILE_MIN <=
+ MBEDTLS_SVC_KEY_ID_GET_KEY_ID(id)) &&
+ (MBEDTLS_SVC_KEY_ID_GET_KEY_ID(id) <=
+ PSA_KEY_ID_VOLATILE_MAX));
+ } else {
TEST_ASSERT(
- ( PSA_KEY_ID_USER_MIN <= MBEDTLS_SVC_KEY_ID_GET_KEY_ID( id ) ) &&
- ( MBEDTLS_SVC_KEY_ID_GET_KEY_ID( id ) <= PSA_KEY_ID_USER_MAX ) );
+ (PSA_KEY_ID_USER_MIN <= MBEDTLS_SVC_KEY_ID_GET_KEY_ID(id)) &&
+ (MBEDTLS_SVC_KEY_ID_GET_KEY_ID(id) <= PSA_KEY_ID_USER_MAX));
}
#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
/* randomly-generated 64-bit constant, should never appear in test data */
psa_key_slot_number_t slot_number = 0xec94d4a5058a1a21;
- psa_status_t status = psa_get_key_slot_number( &attributes, &slot_number );
- if( lifetime_is_dynamic_secure_element( lifetime ) )
- {
+ psa_status_t status = psa_get_key_slot_number(&attributes, &slot_number);
+ if (lifetime_is_dynamic_secure_element(lifetime)) {
/* Mbed Crypto currently always exposes the slot number to
* applications. This is not mandated by the PSA specification
* and may change in future versions. */
- TEST_EQUAL( status, 0 );
- TEST_ASSERT( slot_number != 0xec94d4a5058a1a21 );
- }
- else
- {
- TEST_EQUAL( status, PSA_ERROR_INVALID_ARGUMENT );
+ TEST_EQUAL(status, 0);
+ TEST_ASSERT(slot_number != 0xec94d4a5058a1a21);
+ } else {
+ TEST_EQUAL(status, PSA_ERROR_INVALID_ARGUMENT);
}
#endif
/* Type and size */
- TEST_ASSERT( type != 0 );
- TEST_ASSERT( bits != 0 );
- TEST_ASSERT( bits <= PSA_MAX_KEY_BITS );
- if( PSA_KEY_TYPE_IS_UNSTRUCTURED( type ) )
- TEST_ASSERT( bits % 8 == 0 );
+ TEST_ASSERT(type != 0);
+ TEST_ASSERT(bits != 0);
+ TEST_ASSERT(bits <= PSA_MAX_KEY_BITS);
+ if (PSA_KEY_TYPE_IS_UNSTRUCTURED(type)) {
+ TEST_ASSERT(bits % 8 == 0);
+ }
/* MAX macros concerning specific key types */
- if( PSA_KEY_TYPE_IS_ECC( type ) )
- TEST_ASSERT( bits <= PSA_VENDOR_ECC_MAX_CURVE_BITS );
- else if( PSA_KEY_TYPE_IS_RSA( type ) )
- TEST_ASSERT( bits <= PSA_VENDOR_RSA_MAX_KEY_BITS );
- TEST_ASSERT( PSA_BLOCK_CIPHER_BLOCK_LENGTH( type ) <= PSA_BLOCK_CIPHER_BLOCK_MAX_SIZE );
+ if (PSA_KEY_TYPE_IS_ECC(type)) {
+ TEST_ASSERT(bits <= PSA_VENDOR_ECC_MAX_CURVE_BITS);
+ } else if (PSA_KEY_TYPE_IS_RSA(type)) {
+ TEST_ASSERT(bits <= PSA_VENDOR_RSA_MAX_KEY_BITS);
+ }
+ TEST_ASSERT(PSA_BLOCK_CIPHER_BLOCK_LENGTH(type) <= PSA_BLOCK_CIPHER_BLOCK_MAX_SIZE);
ok = 1;
@@ -109,410 +105,389 @@
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- return( ok );
+ return ok;
}
-static int exercise_mac_key( mbedtls_svc_key_id_t key,
- psa_key_usage_t usage,
- psa_algorithm_t alg )
+static int exercise_mac_key(mbedtls_svc_key_id_t key,
+ psa_key_usage_t usage,
+ psa_algorithm_t alg)
{
psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
const unsigned char input[] = "foo";
- unsigned char mac[PSA_MAC_MAX_SIZE] = {0};
- size_t mac_length = sizeof( mac );
+ unsigned char mac[PSA_MAC_MAX_SIZE] = { 0 };
+ size_t mac_length = sizeof(mac);
/* Convert wildcard algorithm to exercisable algorithm */
- if( alg & PSA_ALG_MAC_AT_LEAST_THIS_LENGTH_FLAG )
- {
- alg = PSA_ALG_TRUNCATED_MAC( alg, PSA_MAC_TRUNCATED_LENGTH( alg ) );
+ if (alg & PSA_ALG_MAC_AT_LEAST_THIS_LENGTH_FLAG) {
+ alg = PSA_ALG_TRUNCATED_MAC(alg, PSA_MAC_TRUNCATED_LENGTH(alg));
}
- if( usage & PSA_KEY_USAGE_SIGN_HASH )
- {
- PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_mac_update( &operation,
- input, sizeof( input ) ) );
- PSA_ASSERT( psa_mac_sign_finish( &operation,
- mac, sizeof( mac ),
- &mac_length ) );
+ if (usage & PSA_KEY_USAGE_SIGN_HASH) {
+ PSA_ASSERT(psa_mac_sign_setup(&operation, key, alg));
+ PSA_ASSERT(psa_mac_update(&operation,
+ input, sizeof(input)));
+ PSA_ASSERT(psa_mac_sign_finish(&operation,
+ mac, sizeof(mac),
+ &mac_length));
}
- if( usage & PSA_KEY_USAGE_VERIFY_HASH )
- {
+ if (usage & PSA_KEY_USAGE_VERIFY_HASH) {
psa_status_t verify_status =
- ( usage & PSA_KEY_USAGE_SIGN_HASH ?
- PSA_SUCCESS :
- PSA_ERROR_INVALID_SIGNATURE );
- PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_mac_update( &operation,
- input, sizeof( input ) ) );
- TEST_EQUAL( psa_mac_verify_finish( &operation, mac, mac_length ),
- verify_status );
+ (usage & PSA_KEY_USAGE_SIGN_HASH ?
+ PSA_SUCCESS :
+ PSA_ERROR_INVALID_SIGNATURE);
+ PSA_ASSERT(psa_mac_verify_setup(&operation, key, alg));
+ PSA_ASSERT(psa_mac_update(&operation,
+ input, sizeof(input)));
+ TEST_EQUAL(psa_mac_verify_finish(&operation, mac, mac_length),
+ verify_status);
}
- return( 1 );
+ return 1;
exit:
- psa_mac_abort( &operation );
- return( 0 );
+ psa_mac_abort(&operation);
+ return 0;
}
-static int exercise_cipher_key( mbedtls_svc_key_id_t key,
- psa_key_usage_t usage,
- psa_algorithm_t alg )
+static int exercise_cipher_key(mbedtls_svc_key_id_t key,
+ psa_key_usage_t usage,
+ psa_algorithm_t alg)
{
psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
- unsigned char iv[PSA_CIPHER_IV_MAX_SIZE] = {0};
+ unsigned char iv[PSA_CIPHER_IV_MAX_SIZE] = { 0 };
size_t iv_length;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_type_t key_type;
const unsigned char plaintext[16] = "Hello, world...";
unsigned char ciphertext[32] = "(wabblewebblewibblewobblewubble)";
- size_t ciphertext_length = sizeof( ciphertext );
- unsigned char decrypted[sizeof( ciphertext )];
+ size_t ciphertext_length = sizeof(ciphertext);
+ unsigned char decrypted[sizeof(ciphertext)];
size_t part_length;
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_type = psa_get_key_type( &attributes );
- iv_length = PSA_CIPHER_IV_LENGTH( key_type, alg );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_type = psa_get_key_type(&attributes);
+ iv_length = PSA_CIPHER_IV_LENGTH(key_type, alg);
- if( usage & PSA_KEY_USAGE_ENCRYPT )
- {
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
- if( iv_length != 0 )
- {
- PSA_ASSERT( psa_cipher_generate_iv( &operation,
- iv, sizeof( iv ),
- &iv_length ) );
+ if (usage & PSA_KEY_USAGE_ENCRYPT) {
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
+ if (iv_length != 0) {
+ PSA_ASSERT(psa_cipher_generate_iv(&operation,
+ iv, sizeof(iv),
+ &iv_length));
}
- PSA_ASSERT( psa_cipher_update( &operation,
- plaintext, sizeof( plaintext ),
- ciphertext, sizeof( ciphertext ),
- &ciphertext_length ) );
- PSA_ASSERT( psa_cipher_finish( &operation,
- ciphertext + ciphertext_length,
- sizeof( ciphertext ) - ciphertext_length,
- &part_length ) );
+ PSA_ASSERT(psa_cipher_update(&operation,
+ plaintext, sizeof(plaintext),
+ ciphertext, sizeof(ciphertext),
+ &ciphertext_length));
+ PSA_ASSERT(psa_cipher_finish(&operation,
+ ciphertext + ciphertext_length,
+ sizeof(ciphertext) - ciphertext_length,
+ &part_length));
ciphertext_length += part_length;
}
- if( usage & PSA_KEY_USAGE_DECRYPT )
- {
+ if (usage & PSA_KEY_USAGE_DECRYPT) {
psa_status_t status;
int maybe_invalid_padding = 0;
- if( ! ( usage & PSA_KEY_USAGE_ENCRYPT ) )
- {
- maybe_invalid_padding = ! PSA_ALG_IS_STREAM_CIPHER( alg );
+ if (!(usage & PSA_KEY_USAGE_ENCRYPT)) {
+ maybe_invalid_padding = !PSA_ALG_IS_STREAM_CIPHER(alg);
}
- PSA_ASSERT( psa_cipher_decrypt_setup( &operation, key, alg ) );
- if( iv_length != 0 )
- {
- PSA_ASSERT( psa_cipher_set_iv( &operation,
- iv, iv_length ) );
+ PSA_ASSERT(psa_cipher_decrypt_setup(&operation, key, alg));
+ if (iv_length != 0) {
+ PSA_ASSERT(psa_cipher_set_iv(&operation,
+ iv, iv_length));
}
- PSA_ASSERT( psa_cipher_update( &operation,
- ciphertext, ciphertext_length,
- decrypted, sizeof( decrypted ),
- &part_length ) );
- status = psa_cipher_finish( &operation,
- decrypted + part_length,
- sizeof( decrypted ) - part_length,
- &part_length );
+ PSA_ASSERT(psa_cipher_update(&operation,
+ ciphertext, ciphertext_length,
+ decrypted, sizeof(decrypted),
+ &part_length));
+ status = psa_cipher_finish(&operation,
+ decrypted + part_length,
+ sizeof(decrypted) - part_length,
+ &part_length);
/* For a stream cipher, all inputs are valid. For a block cipher,
* if the input is some arbitrary data rather than an actual
- ciphertext, a padding error is likely. */
- if( maybe_invalid_padding )
- TEST_ASSERT( status == PSA_SUCCESS ||
- status == PSA_ERROR_INVALID_PADDING );
- else
- PSA_ASSERT( status );
+ ciphertext, a padding error is likely. */
+ if (maybe_invalid_padding) {
+ TEST_ASSERT(status == PSA_SUCCESS ||
+ status == PSA_ERROR_INVALID_PADDING);
+ } else {
+ PSA_ASSERT(status);
+ }
}
- return( 1 );
+ return 1;
exit:
- psa_cipher_abort( &operation );
- psa_reset_key_attributes( &attributes );
- return( 0 );
+ psa_cipher_abort(&operation);
+ psa_reset_key_attributes(&attributes);
+ return 0;
}
-static int exercise_aead_key( mbedtls_svc_key_id_t key,
- psa_key_usage_t usage,
- psa_algorithm_t alg )
+static int exercise_aead_key(mbedtls_svc_key_id_t key,
+ psa_key_usage_t usage,
+ psa_algorithm_t alg)
{
- unsigned char nonce[PSA_AEAD_NONCE_MAX_SIZE] = {0};
+ unsigned char nonce[PSA_AEAD_NONCE_MAX_SIZE] = { 0 };
size_t nonce_length;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_type_t key_type;
unsigned char plaintext[16] = "Hello, world...";
unsigned char ciphertext[48] = "(wabblewebblewibblewobblewubble)";
- size_t ciphertext_length = sizeof( ciphertext );
- size_t plaintext_length = sizeof( ciphertext );
+ size_t ciphertext_length = sizeof(ciphertext);
+ size_t plaintext_length = sizeof(ciphertext);
/* Convert wildcard algorithm to exercisable algorithm */
- if( alg & PSA_ALG_AEAD_AT_LEAST_THIS_LENGTH_FLAG )
- {
- alg = PSA_ALG_AEAD_WITH_SHORTENED_TAG( alg, PSA_ALG_AEAD_GET_TAG_LENGTH( alg ) );
+ if (alg & PSA_ALG_AEAD_AT_LEAST_THIS_LENGTH_FLAG) {
+ alg = PSA_ALG_AEAD_WITH_SHORTENED_TAG(alg, PSA_ALG_AEAD_GET_TAG_LENGTH(alg));
}
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_type = psa_get_key_type( &attributes );
- nonce_length = PSA_AEAD_NONCE_LENGTH( key_type, alg );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_type = psa_get_key_type(&attributes);
+ nonce_length = PSA_AEAD_NONCE_LENGTH(key_type, alg);
- if( usage & PSA_KEY_USAGE_ENCRYPT )
- {
- PSA_ASSERT( psa_aead_encrypt( key, alg,
- nonce, nonce_length,
- NULL, 0,
- plaintext, sizeof( plaintext ),
- ciphertext, sizeof( ciphertext ),
- &ciphertext_length ) );
+ if (usage & PSA_KEY_USAGE_ENCRYPT) {
+ PSA_ASSERT(psa_aead_encrypt(key, alg,
+ nonce, nonce_length,
+ NULL, 0,
+ plaintext, sizeof(plaintext),
+ ciphertext, sizeof(ciphertext),
+ &ciphertext_length));
}
- if( usage & PSA_KEY_USAGE_DECRYPT )
- {
+ if (usage & PSA_KEY_USAGE_DECRYPT) {
psa_status_t verify_status =
- ( usage & PSA_KEY_USAGE_ENCRYPT ?
- PSA_SUCCESS :
- PSA_ERROR_INVALID_SIGNATURE );
- TEST_EQUAL( psa_aead_decrypt( key, alg,
- nonce, nonce_length,
- NULL, 0,
- ciphertext, ciphertext_length,
- plaintext, sizeof( plaintext ),
- &plaintext_length ),
- verify_status );
+ (usage & PSA_KEY_USAGE_ENCRYPT ?
+ PSA_SUCCESS :
+ PSA_ERROR_INVALID_SIGNATURE);
+ TEST_EQUAL(psa_aead_decrypt(key, alg,
+ nonce, nonce_length,
+ NULL, 0,
+ ciphertext, ciphertext_length,
+ plaintext, sizeof(plaintext),
+ &plaintext_length),
+ verify_status);
}
- return( 1 );
+ return 1;
exit:
- psa_reset_key_attributes( &attributes );
- return( 0 );
+ psa_reset_key_attributes(&attributes);
+ return 0;
}
-static int can_sign_or_verify_message( psa_key_usage_t usage,
- psa_algorithm_t alg )
+static int can_sign_or_verify_message(psa_key_usage_t usage,
+ psa_algorithm_t alg)
{
/* Sign-the-unspecified-hash algorithms can only be used with
* {sign,verify}_hash, not with {sign,verify}_message. */
- if( alg == PSA_ALG_ECDSA_ANY || alg == PSA_ALG_RSA_PKCS1V15_SIGN_RAW )
- return( 0 );
- return( usage & ( PSA_KEY_USAGE_SIGN_MESSAGE |
- PSA_KEY_USAGE_VERIFY_MESSAGE ) );
+ if (alg == PSA_ALG_ECDSA_ANY || alg == PSA_ALG_RSA_PKCS1V15_SIGN_RAW) {
+ return 0;
+ }
+ return usage & (PSA_KEY_USAGE_SIGN_MESSAGE |
+ PSA_KEY_USAGE_VERIFY_MESSAGE);
}
-static int exercise_signature_key( mbedtls_svc_key_id_t key,
- psa_key_usage_t usage,
- psa_algorithm_t alg )
+static int exercise_signature_key(mbedtls_svc_key_id_t key,
+ psa_key_usage_t usage,
+ psa_algorithm_t alg)
{
- if( usage & ( PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH ) )
- {
- unsigned char payload[PSA_HASH_MAX_SIZE] = {1};
+ if (usage & (PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH)) {
+ unsigned char payload[PSA_HASH_MAX_SIZE] = { 1 };
size_t payload_length = 16;
- unsigned char signature[PSA_SIGNATURE_MAX_SIZE] = {0};
- size_t signature_length = sizeof( signature );
- psa_algorithm_t hash_alg = PSA_ALG_SIGN_GET_HASH( alg );
+ unsigned char signature[PSA_SIGNATURE_MAX_SIZE] = { 0 };
+ size_t signature_length = sizeof(signature);
+ psa_algorithm_t hash_alg = PSA_ALG_SIGN_GET_HASH(alg);
/* If the policy allows signing with any hash, just pick one. */
- if( PSA_ALG_IS_SIGN_HASH( alg ) && hash_alg == PSA_ALG_ANY_HASH )
- {
+ if (PSA_ALG_IS_SIGN_HASH(alg) && hash_alg == PSA_ALG_ANY_HASH) {
#if defined(KNOWN_MBEDTLS_SUPPORTED_HASH_ALG)
hash_alg = KNOWN_MBEDTLS_SUPPORTED_HASH_ALG;
alg ^= PSA_ALG_ANY_HASH ^ hash_alg;
#else
- TEST_ASSERT( ! "No hash algorithm for hash-and-sign testing" );
+ TEST_ASSERT(!"No hash algorithm for hash-and-sign testing");
#endif
}
/* Some algorithms require the payload to have the size of
* the hash encoded in the algorithm. Use this input size
* even for algorithms that allow other input sizes. */
- if( hash_alg != 0 )
- payload_length = PSA_HASH_LENGTH( hash_alg );
+ if (hash_alg != 0) {
+ payload_length = PSA_HASH_LENGTH(hash_alg);
+ }
- if( usage & PSA_KEY_USAGE_SIGN_HASH )
- {
- PSA_ASSERT( psa_sign_hash( key, alg,
+ if (usage & PSA_KEY_USAGE_SIGN_HASH) {
+ PSA_ASSERT(psa_sign_hash(key, alg,
+ payload, payload_length,
+ signature, sizeof(signature),
+ &signature_length));
+ }
+
+ if (usage & PSA_KEY_USAGE_VERIFY_HASH) {
+ psa_status_t verify_status =
+ (usage & PSA_KEY_USAGE_SIGN_HASH ?
+ PSA_SUCCESS :
+ PSA_ERROR_INVALID_SIGNATURE);
+ TEST_EQUAL(psa_verify_hash(key, alg,
payload, payload_length,
- signature, sizeof( signature ),
- &signature_length ) );
- }
-
- if( usage & PSA_KEY_USAGE_VERIFY_HASH )
- {
- psa_status_t verify_status =
- ( usage & PSA_KEY_USAGE_SIGN_HASH ?
- PSA_SUCCESS :
- PSA_ERROR_INVALID_SIGNATURE );
- TEST_EQUAL( psa_verify_hash( key, alg,
- payload, payload_length,
- signature, signature_length ),
- verify_status );
+ signature, signature_length),
+ verify_status);
}
}
- if( can_sign_or_verify_message( usage, alg ) )
- {
+ if (can_sign_or_verify_message(usage, alg)) {
unsigned char message[256] = "Hello, world...";
- unsigned char signature[PSA_SIGNATURE_MAX_SIZE] = {0};
+ unsigned char signature[PSA_SIGNATURE_MAX_SIZE] = { 0 };
size_t message_length = 16;
- size_t signature_length = sizeof( signature );
+ size_t signature_length = sizeof(signature);
- if( usage & PSA_KEY_USAGE_SIGN_MESSAGE )
- {
- PSA_ASSERT( psa_sign_message( key, alg,
- message, message_length,
- signature, sizeof( signature ),
- &signature_length ) );
+ if (usage & PSA_KEY_USAGE_SIGN_MESSAGE) {
+ PSA_ASSERT(psa_sign_message(key, alg,
+ message, message_length,
+ signature, sizeof(signature),
+ &signature_length));
}
- if( usage & PSA_KEY_USAGE_VERIFY_MESSAGE )
- {
+ if (usage & PSA_KEY_USAGE_VERIFY_MESSAGE) {
psa_status_t verify_status =
- ( usage & PSA_KEY_USAGE_SIGN_MESSAGE ?
- PSA_SUCCESS :
- PSA_ERROR_INVALID_SIGNATURE );
- TEST_EQUAL( psa_verify_message( key, alg,
- message, message_length,
- signature, signature_length ),
- verify_status );
+ (usage & PSA_KEY_USAGE_SIGN_MESSAGE ?
+ PSA_SUCCESS :
+ PSA_ERROR_INVALID_SIGNATURE);
+ TEST_EQUAL(psa_verify_message(key, alg,
+ message, message_length,
+ signature, signature_length),
+ verify_status);
}
}
- return( 1 );
+ return 1;
exit:
- return( 0 );
+ return 0;
}
-static int exercise_asymmetric_encryption_key( mbedtls_svc_key_id_t key,
- psa_key_usage_t usage,
- psa_algorithm_t alg )
+static int exercise_asymmetric_encryption_key(mbedtls_svc_key_id_t key,
+ psa_key_usage_t usage,
+ psa_algorithm_t alg)
{
unsigned char plaintext[256] = "Hello, world...";
unsigned char ciphertext[256] = "(wabblewebblewibblewobblewubble)";
- size_t ciphertext_length = sizeof( ciphertext );
+ size_t ciphertext_length = sizeof(ciphertext);
size_t plaintext_length = 16;
- if( usage & PSA_KEY_USAGE_ENCRYPT )
- {
- PSA_ASSERT( psa_asymmetric_encrypt( key, alg,
- plaintext, plaintext_length,
- NULL, 0,
- ciphertext, sizeof( ciphertext ),
- &ciphertext_length ) );
+ if (usage & PSA_KEY_USAGE_ENCRYPT) {
+ PSA_ASSERT(psa_asymmetric_encrypt(key, alg,
+ plaintext, plaintext_length,
+ NULL, 0,
+ ciphertext, sizeof(ciphertext),
+ &ciphertext_length));
}
- if( usage & PSA_KEY_USAGE_DECRYPT )
- {
+ if (usage & PSA_KEY_USAGE_DECRYPT) {
psa_status_t status =
- psa_asymmetric_decrypt( key, alg,
- ciphertext, ciphertext_length,
- NULL, 0,
- plaintext, sizeof( plaintext ),
- &plaintext_length );
- TEST_ASSERT( status == PSA_SUCCESS ||
- ( ( usage & PSA_KEY_USAGE_ENCRYPT ) == 0 &&
- ( status == PSA_ERROR_INVALID_ARGUMENT ||
- status == PSA_ERROR_INVALID_PADDING ) ) );
+ psa_asymmetric_decrypt(key, alg,
+ ciphertext, ciphertext_length,
+ NULL, 0,
+ plaintext, sizeof(plaintext),
+ &plaintext_length);
+ TEST_ASSERT(status == PSA_SUCCESS ||
+ ((usage & PSA_KEY_USAGE_ENCRYPT) == 0 &&
+ (status == PSA_ERROR_INVALID_ARGUMENT ||
+ status == PSA_ERROR_INVALID_PADDING)));
}
- return( 1 );
+ return 1;
exit:
- return( 0 );
+ return 0;
}
int mbedtls_test_psa_setup_key_derivation_wrap(
- psa_key_derivation_operation_t* operation,
+ psa_key_derivation_operation_t *operation,
mbedtls_svc_key_id_t key,
psa_algorithm_t alg,
- const unsigned char* input1, size_t input1_length,
- const unsigned char* input2, size_t input2_length,
- size_t capacity )
+ const unsigned char *input1, size_t input1_length,
+ const unsigned char *input2, size_t input2_length,
+ size_t capacity)
{
- PSA_ASSERT( psa_key_derivation_setup( operation, alg ) );
- if( PSA_ALG_IS_HKDF( alg ) )
- {
- PSA_ASSERT( psa_key_derivation_input_bytes( operation,
- PSA_KEY_DERIVATION_INPUT_SALT,
- input1, input1_length ) );
- PSA_ASSERT( psa_key_derivation_input_key( operation,
- PSA_KEY_DERIVATION_INPUT_SECRET,
- key ) );
- PSA_ASSERT( psa_key_derivation_input_bytes( operation,
- PSA_KEY_DERIVATION_INPUT_INFO,
- input2,
- input2_length ) );
- }
- else if( PSA_ALG_IS_TLS12_PRF( alg ) ||
- PSA_ALG_IS_TLS12_PSK_TO_MS( alg ) )
- {
- PSA_ASSERT( psa_key_derivation_input_bytes( operation,
- PSA_KEY_DERIVATION_INPUT_SEED,
- input1, input1_length ) );
- PSA_ASSERT( psa_key_derivation_input_key( operation,
- PSA_KEY_DERIVATION_INPUT_SECRET,
- key ) );
- PSA_ASSERT( psa_key_derivation_input_bytes( operation,
- PSA_KEY_DERIVATION_INPUT_LABEL,
- input2, input2_length ) );
- }
- else
- {
- TEST_ASSERT( ! "Key derivation algorithm not supported" );
+ PSA_ASSERT(psa_key_derivation_setup(operation, alg));
+ if (PSA_ALG_IS_HKDF(alg)) {
+ PSA_ASSERT(psa_key_derivation_input_bytes(operation,
+ PSA_KEY_DERIVATION_INPUT_SALT,
+ input1, input1_length));
+ PSA_ASSERT(psa_key_derivation_input_key(operation,
+ PSA_KEY_DERIVATION_INPUT_SECRET,
+ key));
+ PSA_ASSERT(psa_key_derivation_input_bytes(operation,
+ PSA_KEY_DERIVATION_INPUT_INFO,
+ input2,
+ input2_length));
+ } else if (PSA_ALG_IS_TLS12_PRF(alg) ||
+ PSA_ALG_IS_TLS12_PSK_TO_MS(alg)) {
+ PSA_ASSERT(psa_key_derivation_input_bytes(operation,
+ PSA_KEY_DERIVATION_INPUT_SEED,
+ input1, input1_length));
+ PSA_ASSERT(psa_key_derivation_input_key(operation,
+ PSA_KEY_DERIVATION_INPUT_SECRET,
+ key));
+ PSA_ASSERT(psa_key_derivation_input_bytes(operation,
+ PSA_KEY_DERIVATION_INPUT_LABEL,
+ input2, input2_length));
+ } else {
+ TEST_ASSERT(!"Key derivation algorithm not supported");
}
- if( capacity != SIZE_MAX )
- PSA_ASSERT( psa_key_derivation_set_capacity( operation, capacity ) );
+ if (capacity != SIZE_MAX) {
+ PSA_ASSERT(psa_key_derivation_set_capacity(operation, capacity));
+ }
- return( 1 );
+ return 1;
exit:
- return( 0 );
+ return 0;
}
-static int exercise_key_derivation_key( mbedtls_svc_key_id_t key,
- psa_key_usage_t usage,
- psa_algorithm_t alg )
+static int exercise_key_derivation_key(mbedtls_svc_key_id_t key,
+ psa_key_usage_t usage,
+ psa_algorithm_t alg)
{
psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
unsigned char input1[] = "Input 1";
- size_t input1_length = sizeof( input1 );
+ size_t input1_length = sizeof(input1);
unsigned char input2[] = "Input 2";
- size_t input2_length = sizeof( input2 );
+ size_t input2_length = sizeof(input2);
unsigned char output[1];
- size_t capacity = sizeof( output );
+ size_t capacity = sizeof(output);
- if( usage & PSA_KEY_USAGE_DERIVE )
- {
- if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, key, alg,
- input1, input1_length,
- input2, input2_length,
- capacity ) )
+ if (usage & PSA_KEY_USAGE_DERIVE) {
+ if (!mbedtls_test_psa_setup_key_derivation_wrap(&operation, key, alg,
+ input1, input1_length,
+ input2, input2_length,
+ capacity)) {
goto exit;
+ }
- PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
- output,
- capacity ) );
- PSA_ASSERT( psa_key_derivation_abort( &operation ) );
+ PSA_ASSERT(psa_key_derivation_output_bytes(&operation,
+ output,
+ capacity));
+ PSA_ASSERT(psa_key_derivation_abort(&operation));
}
- return( 1 );
+ return 1;
exit:
- return( 0 );
+ return 0;
}
/* We need two keys to exercise key agreement. Exercise the
* private key against its own public key. */
psa_status_t mbedtls_test_psa_key_agreement_with_self(
psa_key_derivation_operation_t *operation,
- mbedtls_svc_key_id_t key )
+ mbedtls_svc_key_id_t key)
{
psa_key_type_t private_key_type;
psa_key_type_t public_key_type;
@@ -525,34 +500,34 @@
psa_status_t status = PSA_ERROR_GENERIC_ERROR;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- private_key_type = psa_get_key_type( &attributes );
- 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 );
- ASSERT_ALLOC( public_key, public_key_length );
- PSA_ASSERT( psa_export_public_key( key, public_key, public_key_length,
- &public_key_length ) );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ private_key_type = psa_get_key_type(&attributes);
+ 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);
+ ASSERT_ALLOC(public_key, public_key_length);
+ PSA_ASSERT(psa_export_public_key(key, public_key, public_key_length,
+ &public_key_length));
status = psa_key_derivation_key_agreement(
operation, PSA_KEY_DERIVATION_INPUT_SECRET, key,
- public_key, public_key_length );
+ public_key, public_key_length);
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- mbedtls_free( public_key );
- return( status );
+ mbedtls_free(public_key);
+ return status;
}
/* We need two keys to exercise key agreement. Exercise the
* private key against its own public key. */
psa_status_t mbedtls_test_psa_raw_key_agreement_with_self(
psa_algorithm_t alg,
- mbedtls_svc_key_id_t key )
+ mbedtls_svc_key_id_t key)
{
psa_key_type_t private_key_type;
psa_key_type_t public_key_type;
@@ -567,26 +542,25 @@
psa_status_t status = PSA_ERROR_GENERIC_ERROR;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- private_key_type = psa_get_key_type( &attributes );
- 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 );
- ASSERT_ALLOC( public_key, public_key_length );
- PSA_ASSERT( psa_export_public_key( key,
- public_key, public_key_length,
- &public_key_length ) );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ private_key_type = psa_get_key_type(&attributes);
+ 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);
+ ASSERT_ALLOC(public_key, public_key_length);
+ PSA_ASSERT(psa_export_public_key(key,
+ public_key, public_key_length,
+ &public_key_length));
- status = psa_raw_key_agreement( alg, key,
- public_key, public_key_length,
- output, sizeof( output ), &output_length );
- if ( status == PSA_SUCCESS )
- {
- TEST_ASSERT( output_length <=
- PSA_RAW_KEY_AGREEMENT_OUTPUT_SIZE( private_key_type,
- key_bits ) );
- TEST_ASSERT( output_length <=
- PSA_RAW_KEY_AGREEMENT_OUTPUT_MAX_SIZE );
+ status = psa_raw_key_agreement(alg, key,
+ public_key, public_key_length,
+ output, sizeof(output), &output_length);
+ if (status == PSA_SUCCESS) {
+ TEST_ASSERT(output_length <=
+ PSA_RAW_KEY_AGREEMENT_OUTPUT_SIZE(private_key_type,
+ key_bits));
+ TEST_ASSERT(output_length <=
+ PSA_RAW_KEY_AGREEMENT_OUTPUT_MAX_SIZE);
}
exit:
@@ -594,93 +568,86 @@
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- mbedtls_free( public_key );
- return( status );
+ mbedtls_free(public_key);
+ return status;
}
-static int exercise_raw_key_agreement_key( mbedtls_svc_key_id_t key,
- psa_key_usage_t usage,
- psa_algorithm_t alg )
+static int exercise_raw_key_agreement_key(mbedtls_svc_key_id_t key,
+ psa_key_usage_t usage,
+ psa_algorithm_t alg)
{
int ok = 0;
- if( usage & PSA_KEY_USAGE_DERIVE )
- {
+ if (usage & PSA_KEY_USAGE_DERIVE) {
/* We need two keys to exercise key agreement. Exercise the
* private key against its own public key. */
- PSA_ASSERT( mbedtls_test_psa_raw_key_agreement_with_self( alg, key ) );
+ PSA_ASSERT(mbedtls_test_psa_raw_key_agreement_with_self(alg, key));
}
ok = 1;
exit:
- return( ok );
+ return ok;
}
-static int exercise_key_agreement_key( mbedtls_svc_key_id_t key,
- psa_key_usage_t usage,
- psa_algorithm_t alg )
+static int exercise_key_agreement_key(mbedtls_svc_key_id_t key,
+ psa_key_usage_t usage,
+ psa_algorithm_t alg)
{
psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
unsigned char input[1];
unsigned char output[1];
int ok = 0;
- psa_algorithm_t kdf_alg = PSA_ALG_KEY_AGREEMENT_GET_KDF( alg );
+ psa_algorithm_t kdf_alg = PSA_ALG_KEY_AGREEMENT_GET_KDF(alg);
- if( usage & PSA_KEY_USAGE_DERIVE )
- {
+ if (usage & PSA_KEY_USAGE_DERIVE) {
/* We need two keys to exercise key agreement. Exercise the
* private key against its own public key. */
- PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
- if( PSA_ALG_IS_TLS12_PRF( kdf_alg ) ||
- PSA_ALG_IS_TLS12_PSK_TO_MS( kdf_alg ) )
- {
- PSA_ASSERT( psa_key_derivation_input_bytes(
- &operation, PSA_KEY_DERIVATION_INPUT_SEED,
- input, sizeof( input ) ) );
+ PSA_ASSERT(psa_key_derivation_setup(&operation, alg));
+ if (PSA_ALG_IS_TLS12_PRF(kdf_alg) ||
+ PSA_ALG_IS_TLS12_PSK_TO_MS(kdf_alg)) {
+ PSA_ASSERT(psa_key_derivation_input_bytes(
+ &operation, PSA_KEY_DERIVATION_INPUT_SEED,
+ input, sizeof(input)));
}
- PSA_ASSERT( mbedtls_test_psa_key_agreement_with_self( &operation, key ) );
+ PSA_ASSERT(mbedtls_test_psa_key_agreement_with_self(&operation, key));
- if( PSA_ALG_IS_TLS12_PRF( kdf_alg ) ||
- PSA_ALG_IS_TLS12_PSK_TO_MS( kdf_alg ) )
- {
- PSA_ASSERT( psa_key_derivation_input_bytes(
- &operation, PSA_KEY_DERIVATION_INPUT_LABEL,
- input, sizeof( input ) ) );
+ if (PSA_ALG_IS_TLS12_PRF(kdf_alg) ||
+ PSA_ALG_IS_TLS12_PSK_TO_MS(kdf_alg)) {
+ PSA_ASSERT(psa_key_derivation_input_bytes(
+ &operation, PSA_KEY_DERIVATION_INPUT_LABEL,
+ input, sizeof(input)));
+ } else if (PSA_ALG_IS_HKDF(kdf_alg)) {
+ PSA_ASSERT(psa_key_derivation_input_bytes(
+ &operation, PSA_KEY_DERIVATION_INPUT_INFO,
+ input, sizeof(input)));
}
- else if( PSA_ALG_IS_HKDF( kdf_alg ) )
- {
- PSA_ASSERT( psa_key_derivation_input_bytes(
- &operation, PSA_KEY_DERIVATION_INPUT_INFO,
- input, sizeof( input ) ) );
- }
- PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
- output,
- sizeof( output ) ) );
- PSA_ASSERT( psa_key_derivation_abort( &operation ) );
+ PSA_ASSERT(psa_key_derivation_output_bytes(&operation,
+ output,
+ sizeof(output)));
+ PSA_ASSERT(psa_key_derivation_abort(&operation));
}
ok = 1;
exit:
- return( ok );
+ return ok;
}
int mbedtls_test_psa_exported_key_sanity_check(
psa_key_type_t type, size_t bits,
- const uint8_t *exported, size_t exported_length )
+ const uint8_t *exported, size_t exported_length)
{
- TEST_ASSERT( exported_length <= PSA_EXPORT_KEY_OUTPUT_SIZE( type, bits ) );
+ TEST_ASSERT(exported_length <= PSA_EXPORT_KEY_OUTPUT_SIZE(type, bits));
- if( PSA_KEY_TYPE_IS_UNSTRUCTURED( type ) )
- TEST_EQUAL( exported_length, PSA_BITS_TO_BYTES( bits ) );
- else
+ if (PSA_KEY_TYPE_IS_UNSTRUCTURED(type)) {
+ TEST_EQUAL(exported_length, PSA_BITS_TO_BYTES(bits));
+ } else
#if defined(MBEDTLS_ASN1_PARSE_C)
- if( type == PSA_KEY_TYPE_RSA_KEY_PAIR )
- {
- uint8_t *p = (uint8_t*) exported;
+ if (type == PSA_KEY_TYPE_RSA_KEY_PAIR) {
+ uint8_t *p = (uint8_t *) exported;
const uint8_t *end = exported + exported_length;
size_t len;
/* RSAPrivateKey ::= SEQUENCE {
@@ -695,140 +662,139 @@
* coefficient INTEGER, -- (inverse of q) mod p
* }
*/
- TEST_EQUAL( mbedtls_asn1_get_tag( &p, end, &len,
- MBEDTLS_ASN1_SEQUENCE |
- MBEDTLS_ASN1_CONSTRUCTED ), 0 );
- TEST_EQUAL( len, end - p );
- if( ! mbedtls_test_asn1_skip_integer( &p, end, 0, 0, 0 ) )
+ TEST_EQUAL(mbedtls_asn1_get_tag(&p, end, &len,
+ MBEDTLS_ASN1_SEQUENCE |
+ MBEDTLS_ASN1_CONSTRUCTED), 0);
+ TEST_EQUAL(len, end - p);
+ if (!mbedtls_test_asn1_skip_integer(&p, end, 0, 0, 0)) {
goto exit;
- if( ! mbedtls_test_asn1_skip_integer( &p, end, bits, bits, 1 ) )
+ }
+ if (!mbedtls_test_asn1_skip_integer(&p, end, bits, bits, 1)) {
goto exit;
- if( ! mbedtls_test_asn1_skip_integer( &p, end, 2, bits, 1 ) )
+ }
+ if (!mbedtls_test_asn1_skip_integer(&p, end, 2, bits, 1)) {
goto exit;
+ }
/* Require d to be at least half the size of n. */
- if( ! mbedtls_test_asn1_skip_integer( &p, end, bits / 2, bits, 1 ) )
+ if (!mbedtls_test_asn1_skip_integer(&p, end, bits / 2, bits, 1)) {
goto exit;
+ }
/* Require p and q to be at most half the size of n, rounded up. */
- if( ! mbedtls_test_asn1_skip_integer( &p, end, bits / 2, bits / 2 + 1, 1 ) )
+ if (!mbedtls_test_asn1_skip_integer(&p, end, bits / 2, bits / 2 + 1, 1)) {
goto exit;
- if( ! mbedtls_test_asn1_skip_integer( &p, end, bits / 2, bits / 2 + 1, 1 ) )
+ }
+ if (!mbedtls_test_asn1_skip_integer(&p, end, bits / 2, bits / 2 + 1, 1)) {
goto exit;
- if( ! mbedtls_test_asn1_skip_integer( &p, end, 1, bits / 2 + 1, 0 ) )
+ }
+ if (!mbedtls_test_asn1_skip_integer(&p, end, 1, bits / 2 + 1, 0)) {
goto exit;
- if( ! mbedtls_test_asn1_skip_integer( &p, end, 1, bits / 2 + 1, 0 ) )
+ }
+ if (!mbedtls_test_asn1_skip_integer(&p, end, 1, bits / 2 + 1, 0)) {
goto exit;
- if( ! mbedtls_test_asn1_skip_integer( &p, end, 1, bits / 2 + 1, 0 ) )
+ }
+ if (!mbedtls_test_asn1_skip_integer(&p, end, 1, bits / 2 + 1, 0)) {
goto exit;
- TEST_EQUAL( p - end, 0 );
+ }
+ TEST_EQUAL(p - end, 0);
- TEST_ASSERT( exported_length <= PSA_EXPORT_KEY_PAIR_MAX_SIZE );
- }
- else
+ TEST_ASSERT(exported_length <= PSA_EXPORT_KEY_PAIR_MAX_SIZE);
+ } else
#endif /* MBEDTLS_ASN1_PARSE_C */
#if defined(MBEDTLS_ECP_C)
- if( PSA_KEY_TYPE_IS_ECC_KEY_PAIR( type ) )
- {
+ if (PSA_KEY_TYPE_IS_ECC_KEY_PAIR(type)) {
/* Just the secret value */
- TEST_EQUAL( exported_length, PSA_BITS_TO_BYTES( bits ) );
+ TEST_EQUAL(exported_length, PSA_BITS_TO_BYTES(bits));
- TEST_ASSERT( exported_length <= PSA_EXPORT_KEY_PAIR_MAX_SIZE );
- }
- else
+ TEST_ASSERT(exported_length <= PSA_EXPORT_KEY_PAIR_MAX_SIZE);
+ } else
#endif /* MBEDTLS_ECP_C */
#if defined(MBEDTLS_ASN1_PARSE_C)
- if( type == PSA_KEY_TYPE_RSA_PUBLIC_KEY )
- {
- uint8_t *p = (uint8_t*) exported;
+ if (type == PSA_KEY_TYPE_RSA_PUBLIC_KEY) {
+ uint8_t *p = (uint8_t *) exported;
const uint8_t *end = exported + exported_length;
size_t len;
/* RSAPublicKey ::= SEQUENCE {
* modulus INTEGER, -- n
* publicExponent INTEGER } -- e
*/
- TEST_EQUAL( mbedtls_asn1_get_tag( &p, end, &len,
- MBEDTLS_ASN1_SEQUENCE |
- MBEDTLS_ASN1_CONSTRUCTED ),
- 0 );
- TEST_EQUAL( len, end - p );
- if( ! mbedtls_test_asn1_skip_integer( &p, end, bits, bits, 1 ) )
+ TEST_EQUAL(mbedtls_asn1_get_tag(&p, end, &len,
+ MBEDTLS_ASN1_SEQUENCE |
+ MBEDTLS_ASN1_CONSTRUCTED),
+ 0);
+ TEST_EQUAL(len, end - p);
+ if (!mbedtls_test_asn1_skip_integer(&p, end, bits, bits, 1)) {
goto exit;
- if( ! mbedtls_test_asn1_skip_integer( &p, end, 2, bits, 1 ) )
+ }
+ if (!mbedtls_test_asn1_skip_integer(&p, end, 2, bits, 1)) {
goto exit;
- TEST_EQUAL( p - end, 0 );
+ }
+ TEST_EQUAL(p - end, 0);
- TEST_ASSERT( exported_length <=
- PSA_EXPORT_PUBLIC_KEY_OUTPUT_SIZE( type, bits ) );
- TEST_ASSERT( exported_length <=
- PSA_EXPORT_PUBLIC_KEY_MAX_SIZE );
- }
- else
+ TEST_ASSERT(exported_length <=
+ PSA_EXPORT_PUBLIC_KEY_OUTPUT_SIZE(type, bits));
+ TEST_ASSERT(exported_length <=
+ PSA_EXPORT_PUBLIC_KEY_MAX_SIZE);
+ } else
#endif /* MBEDTLS_ASN1_PARSE_C */
#if defined(MBEDTLS_ECP_C)
- if( PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY( type ) )
- {
+ if (PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(type)) {
- TEST_ASSERT( exported_length <=
- PSA_EXPORT_PUBLIC_KEY_OUTPUT_SIZE( type, bits ) );
- TEST_ASSERT( exported_length <=
- PSA_EXPORT_PUBLIC_KEY_MAX_SIZE );
+ TEST_ASSERT(exported_length <=
+ PSA_EXPORT_PUBLIC_KEY_OUTPUT_SIZE(type, bits));
+ TEST_ASSERT(exported_length <=
+ PSA_EXPORT_PUBLIC_KEY_MAX_SIZE);
- if( PSA_KEY_TYPE_ECC_GET_FAMILY( type ) == PSA_ECC_FAMILY_MONTGOMERY )
- {
+ if (PSA_KEY_TYPE_ECC_GET_FAMILY(type) == PSA_ECC_FAMILY_MONTGOMERY) {
/* The representation of an ECC Montgomery public key is
* the raw compressed point */
- TEST_EQUAL( PSA_BITS_TO_BYTES( bits ), exported_length );
- }
- else
- {
+ TEST_EQUAL(PSA_BITS_TO_BYTES(bits), exported_length);
+ } else {
/* The representation of an ECC Weierstrass public key is:
* - The byte 0x04;
* - `x_P` as a `ceiling(m/8)`-byte string, big-endian;
* - `y_P` as a `ceiling(m/8)`-byte string, big-endian;
* - where m is the bit size associated with the curve.
*/
- TEST_EQUAL( 1 + 2 * PSA_BITS_TO_BYTES( bits ), exported_length );
- TEST_EQUAL( exported[0], 4 );
+ TEST_EQUAL(1 + 2 * PSA_BITS_TO_BYTES(bits), exported_length);
+ TEST_EQUAL(exported[0], 4);
}
- }
- else
+ } else
#endif /* MBEDTLS_ECP_C */
{
(void) exported;
- TEST_ASSERT( ! "Sanity check not implemented for this key type" );
+ TEST_ASSERT(!"Sanity check not implemented for this key type");
}
#if defined(MBEDTLS_DES_C)
- if( type == PSA_KEY_TYPE_DES )
- {
+ if (type == PSA_KEY_TYPE_DES) {
/* Check the parity bits. */
unsigned i;
- for( i = 0; i < bits / 8; i++ )
- {
+ for (i = 0; i < bits / 8; i++) {
unsigned bit_count = 0;
unsigned m;
- for( m = 1; m <= 0x100; m <<= 1 )
- {
- if( exported[i] & m )
+ for (m = 1; m <= 0x100; m <<= 1) {
+ if (exported[i] & m) {
++bit_count;
+ }
}
- TEST_ASSERT( bit_count % 2 != 0 );
+ TEST_ASSERT(bit_count % 2 != 0);
}
}
#endif
- return( 1 );
+ return 1;
exit:
- return( 0 );
+ return 0;
}
-static int exercise_export_key( mbedtls_svc_key_id_t key,
- psa_key_usage_t usage )
+static int exercise_export_key(mbedtls_svc_key_id_t key,
+ psa_key_usage_t usage)
{
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
uint8_t *exported = NULL;
@@ -836,42 +802,41 @@
size_t exported_length = 0;
int ok = 0;
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
exported_size = PSA_EXPORT_KEY_OUTPUT_SIZE(
- psa_get_key_type( &attributes ),
- psa_get_key_bits( &attributes ) );
- ASSERT_ALLOC( exported, exported_size );
+ psa_get_key_type(&attributes),
+ psa_get_key_bits(&attributes));
+ ASSERT_ALLOC(exported, exported_size);
- if( ( usage & PSA_KEY_USAGE_EXPORT ) == 0 &&
- ! PSA_KEY_TYPE_IS_PUBLIC_KEY( psa_get_key_type( &attributes ) ) )
- {
- TEST_EQUAL( psa_export_key( key, exported,
- exported_size, &exported_length ),
- PSA_ERROR_NOT_PERMITTED );
+ if ((usage & PSA_KEY_USAGE_EXPORT) == 0 &&
+ !PSA_KEY_TYPE_IS_PUBLIC_KEY(psa_get_key_type(&attributes))) {
+ TEST_EQUAL(psa_export_key(key, exported,
+ exported_size, &exported_length),
+ PSA_ERROR_NOT_PERMITTED);
ok = 1;
goto exit;
}
- PSA_ASSERT( psa_export_key( key,
- exported, exported_size,
- &exported_length ) );
+ PSA_ASSERT(psa_export_key(key,
+ exported, exported_size,
+ &exported_length));
ok = mbedtls_test_psa_exported_key_sanity_check(
- psa_get_key_type( &attributes ), psa_get_key_bits( &attributes ),
- exported, exported_length );
+ psa_get_key_type(&attributes), psa_get_key_bits(&attributes),
+ exported, exported_length);
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- mbedtls_free( exported );
- return( ok );
+ mbedtls_free(exported);
+ return ok;
}
-static int exercise_export_public_key( mbedtls_svc_key_id_t key )
+static int exercise_export_public_key(mbedtls_svc_key_id_t key)
{
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_type_t public_type;
@@ -880,119 +845,113 @@
size_t exported_length = 0;
int ok = 0;
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- if( ! PSA_KEY_TYPE_IS_ASYMMETRIC( psa_get_key_type( &attributes ) ) )
- {
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ if (!PSA_KEY_TYPE_IS_ASYMMETRIC(psa_get_key_type(&attributes))) {
exported_size = PSA_EXPORT_KEY_OUTPUT_SIZE(
- psa_get_key_type( &attributes ),
- psa_get_key_bits( &attributes ) );
- ASSERT_ALLOC( exported, exported_size );
+ psa_get_key_type(&attributes),
+ psa_get_key_bits(&attributes));
+ ASSERT_ALLOC(exported, exported_size);
- TEST_EQUAL( psa_export_public_key( key, exported,
- exported_size, &exported_length ),
- PSA_ERROR_INVALID_ARGUMENT );
+ TEST_EQUAL(psa_export_public_key(key, exported,
+ exported_size, &exported_length),
+ PSA_ERROR_INVALID_ARGUMENT);
ok = 1;
goto exit;
}
public_type = PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(
- psa_get_key_type( &attributes ) );
- exported_size = PSA_EXPORT_PUBLIC_KEY_OUTPUT_SIZE( public_type,
- psa_get_key_bits( &attributes ) );
- ASSERT_ALLOC( exported, exported_size );
+ psa_get_key_type(&attributes));
+ exported_size = PSA_EXPORT_PUBLIC_KEY_OUTPUT_SIZE(public_type,
+ psa_get_key_bits(&attributes));
+ ASSERT_ALLOC(exported, exported_size);
- PSA_ASSERT( psa_export_public_key( key,
- exported, exported_size,
- &exported_length ) );
+ PSA_ASSERT(psa_export_public_key(key,
+ exported, exported_size,
+ &exported_length));
ok = mbedtls_test_psa_exported_key_sanity_check(
- public_type, psa_get_key_bits( &attributes ),
- exported, exported_length );
+ public_type, psa_get_key_bits(&attributes),
+ exported, exported_length);
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- mbedtls_free( exported );
- return( ok );
+ mbedtls_free(exported);
+ return ok;
}
-int mbedtls_test_psa_exercise_key( mbedtls_svc_key_id_t key,
- psa_key_usage_t usage,
- psa_algorithm_t alg )
+int mbedtls_test_psa_exercise_key(mbedtls_svc_key_id_t key,
+ psa_key_usage_t usage,
+ psa_algorithm_t alg)
{
int ok = 0;
- if( ! check_key_attributes_sanity( key ) )
- return( 0 );
+ if (!check_key_attributes_sanity(key)) {
+ return 0;
+ }
- if( alg == 0 )
+ if (alg == 0) {
ok = 1; /* If no algorithm, do nothing (used for raw data "keys"). */
- else if( PSA_ALG_IS_MAC( alg ) )
- ok = exercise_mac_key( key, usage, alg );
- else if( PSA_ALG_IS_CIPHER( alg ) )
- ok = exercise_cipher_key( key, usage, alg );
- else if( PSA_ALG_IS_AEAD( alg ) )
- ok = exercise_aead_key( key, usage, alg );
- else if( PSA_ALG_IS_SIGN( alg ) )
- ok = exercise_signature_key( key, usage, alg );
- else if( PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) )
- ok = exercise_asymmetric_encryption_key( key, usage, alg );
- else if( PSA_ALG_IS_KEY_DERIVATION( alg ) )
- ok = exercise_key_derivation_key( key, usage, alg );
- else if( PSA_ALG_IS_RAW_KEY_AGREEMENT( alg ) )
- ok = exercise_raw_key_agreement_key( key, usage, alg );
- else if( PSA_ALG_IS_KEY_AGREEMENT( alg ) )
- ok = exercise_key_agreement_key( key, usage, alg );
- else
- TEST_ASSERT( ! "No code to exercise this category of algorithm" );
+ } else if (PSA_ALG_IS_MAC(alg)) {
+ ok = exercise_mac_key(key, usage, alg);
+ } else if (PSA_ALG_IS_CIPHER(alg)) {
+ ok = exercise_cipher_key(key, usage, alg);
+ } else if (PSA_ALG_IS_AEAD(alg)) {
+ ok = exercise_aead_key(key, usage, alg);
+ } else if (PSA_ALG_IS_SIGN(alg)) {
+ ok = exercise_signature_key(key, usage, alg);
+ } else if (PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg)) {
+ ok = exercise_asymmetric_encryption_key(key, usage, alg);
+ } else if (PSA_ALG_IS_KEY_DERIVATION(alg)) {
+ ok = exercise_key_derivation_key(key, usage, alg);
+ } else if (PSA_ALG_IS_RAW_KEY_AGREEMENT(alg)) {
+ ok = exercise_raw_key_agreement_key(key, usage, alg);
+ } else if (PSA_ALG_IS_KEY_AGREEMENT(alg)) {
+ ok = exercise_key_agreement_key(key, usage, alg);
+ } else {
+ TEST_ASSERT(!"No code to exercise this category of algorithm");
+ }
- ok = ok && exercise_export_key( key, usage );
- ok = ok && exercise_export_public_key( key );
+ ok = ok && exercise_export_key(key, usage);
+ ok = ok && exercise_export_public_key(key);
exit:
- return( ok );
+ return ok;
}
-psa_key_usage_t mbedtls_test_psa_usage_to_exercise( psa_key_type_t type,
- psa_algorithm_t alg )
+psa_key_usage_t mbedtls_test_psa_usage_to_exercise(psa_key_type_t type,
+ psa_algorithm_t alg)
{
- if( PSA_ALG_IS_MAC( alg ) || PSA_ALG_IS_SIGN( alg ) )
- {
- if( PSA_ALG_IS_SIGN_HASH( alg ) )
- {
- if( PSA_ALG_SIGN_GET_HASH( alg ) )
- return( PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ?
- PSA_KEY_USAGE_VERIFY_HASH | PSA_KEY_USAGE_VERIFY_MESSAGE:
- PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH |
- PSA_KEY_USAGE_SIGN_MESSAGE | PSA_KEY_USAGE_VERIFY_MESSAGE );
+ if (PSA_ALG_IS_MAC(alg) || PSA_ALG_IS_SIGN(alg)) {
+ if (PSA_ALG_IS_SIGN_HASH(alg)) {
+ if (PSA_ALG_SIGN_GET_HASH(alg)) {
+ return PSA_KEY_TYPE_IS_PUBLIC_KEY(type) ?
+ PSA_KEY_USAGE_VERIFY_HASH | PSA_KEY_USAGE_VERIFY_MESSAGE :
+ PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH |
+ PSA_KEY_USAGE_SIGN_MESSAGE | PSA_KEY_USAGE_VERIFY_MESSAGE;
+ }
+ } else if (PSA_ALG_IS_SIGN_MESSAGE(alg)) {
+ return PSA_KEY_TYPE_IS_PUBLIC_KEY(type) ?
+ PSA_KEY_USAGE_VERIFY_MESSAGE :
+ PSA_KEY_USAGE_SIGN_MESSAGE | PSA_KEY_USAGE_VERIFY_MESSAGE;
}
- else if( PSA_ALG_IS_SIGN_MESSAGE( alg) )
- return( PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ?
- PSA_KEY_USAGE_VERIFY_MESSAGE :
- PSA_KEY_USAGE_SIGN_MESSAGE | PSA_KEY_USAGE_VERIFY_MESSAGE );
- return( PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ?
- PSA_KEY_USAGE_VERIFY_HASH :
- PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH );
- }
- else if( PSA_ALG_IS_CIPHER( alg ) || PSA_ALG_IS_AEAD( alg ) ||
- PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) )
- {
- return( PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ?
- PSA_KEY_USAGE_ENCRYPT :
- PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
- }
- else if( PSA_ALG_IS_KEY_DERIVATION( alg ) ||
- PSA_ALG_IS_KEY_AGREEMENT( alg ) )
- {
- return( PSA_KEY_USAGE_DERIVE );
- }
- else
- {
- return( 0 );
+ return PSA_KEY_TYPE_IS_PUBLIC_KEY(type) ?
+ PSA_KEY_USAGE_VERIFY_HASH :
+ PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH;
+ } else if (PSA_ALG_IS_CIPHER(alg) || PSA_ALG_IS_AEAD(alg) ||
+ PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg)) {
+ return PSA_KEY_TYPE_IS_PUBLIC_KEY(type) ?
+ PSA_KEY_USAGE_ENCRYPT :
+ PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT;
+ } else if (PSA_ALG_IS_KEY_DERIVATION(alg) ||
+ PSA_ALG_IS_KEY_AGREEMENT(alg)) {
+ return PSA_KEY_USAGE_DERIVE;
+ } else {
+ return 0;
}
}
diff --git a/tests/src/random.c b/tests/src/random.c
index 7f3f401..e74e689 100644
--- a/tests/src/random.c
+++ b/tests/src/random.c
@@ -37,109 +37,111 @@
#include <mbedtls/entropy.h>
-int mbedtls_test_rnd_std_rand( void *rng_state,
- unsigned char *output,
- size_t len )
+int mbedtls_test_rnd_std_rand(void *rng_state,
+ unsigned char *output,
+ size_t len)
{
#if !defined(__OpenBSD__) && !defined(__NetBSD__)
size_t i;
- if( rng_state != NULL )
+ if (rng_state != NULL) {
rng_state = NULL;
+ }
- for( i = 0; i < len; ++i )
+ for (i = 0; i < len; ++i) {
output[i] = rand();
+ }
#else
- if( rng_state != NULL )
+ if (rng_state != NULL) {
rng_state = NULL;
+ }
- arc4random_buf( output, len );
+ arc4random_buf(output, len);
#endif /* !OpenBSD && !NetBSD */
- return( 0 );
+ return 0;
}
-int mbedtls_test_rnd_zero_rand( void *rng_state,
- unsigned char *output,
- size_t len )
+int mbedtls_test_rnd_zero_rand(void *rng_state,
+ unsigned char *output,
+ size_t len)
{
- if( rng_state != NULL )
+ if (rng_state != NULL) {
rng_state = NULL;
+ }
- memset( output, 0, len );
+ memset(output, 0, len);
- return( 0 );
+ return 0;
}
-int mbedtls_test_rnd_buffer_rand( void *rng_state,
- unsigned char *output,
- size_t len )
+int mbedtls_test_rnd_buffer_rand(void *rng_state,
+ unsigned char *output,
+ size_t len)
{
mbedtls_test_rnd_buf_info *info = (mbedtls_test_rnd_buf_info *) rng_state;
size_t use_len;
- if( rng_state == NULL )
- return( mbedtls_test_rnd_std_rand( NULL, output, len ) );
+ if (rng_state == NULL) {
+ return mbedtls_test_rnd_std_rand(NULL, output, len);
+ }
use_len = len;
- if( len > info->length )
+ if (len > info->length) {
use_len = info->length;
+ }
- if( use_len )
- {
- memcpy( output, info->buf, use_len );
+ if (use_len) {
+ memcpy(output, info->buf, use_len);
info->buf += use_len;
info->length -= use_len;
}
- if( len - use_len > 0 )
- {
- if( info->fallback_f_rng != NULL )
- {
- return( info->fallback_f_rng( info->fallback_p_rng,
- output + use_len,
- len - use_len ) );
+ if (len - use_len > 0) {
+ if (info->fallback_f_rng != NULL) {
+ return info->fallback_f_rng(info->fallback_p_rng,
+ output + use_len,
+ len - use_len);
+ } else {
+ return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
}
- else
- return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
}
- return( 0 );
+ return 0;
}
-int mbedtls_test_rnd_pseudo_rand( void *rng_state,
- unsigned char *output,
- size_t len )
+int mbedtls_test_rnd_pseudo_rand(void *rng_state,
+ unsigned char *output,
+ size_t len)
{
mbedtls_test_rnd_pseudo_info *info =
(mbedtls_test_rnd_pseudo_info *) rng_state;
- uint32_t i, *k, sum, delta=0x9E3779B9;
+ uint32_t i, *k, sum, delta = 0x9E3779B9;
unsigned char result[4], *out = output;
- if( rng_state == NULL )
- return( mbedtls_test_rnd_std_rand( NULL, output, len ) );
+ if (rng_state == NULL) {
+ return mbedtls_test_rnd_std_rand(NULL, output, len);
+ }
k = info->key;
- while( len > 0 )
- {
- size_t use_len = ( len > 4 ) ? 4 : len;
+ while (len > 0) {
+ size_t use_len = (len > 4) ? 4 : len;
sum = 0;
- for( i = 0; i < 32; i++ )
- {
- info->v0 += ( ( ( info->v1 << 4 ) ^ ( info->v1 >> 5 ) )
- + info->v1 ) ^ ( sum + k[sum & 3] );
+ for (i = 0; i < 32; i++) {
+ info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5))
+ + info->v1) ^ (sum + k[sum & 3]);
sum += delta;
- info->v1 += ( ( ( info->v0 << 4 ) ^ ( info->v0 >> 5 ) )
- + info->v0 ) ^ ( sum + k[( sum>>11 ) & 3] );
+ info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5))
+ + info->v0) ^ (sum + k[(sum>>11) & 3]);
}
- PUT_UINT32_BE( info->v0, result, 0 );
- memcpy( out, result, use_len );
+ PUT_UINT32_BE(info->v0, result, 0);
+ memcpy(out, result, use_len);
len -= use_len;
out += 4;
}
- return( 0 );
+ return 0;
}
diff --git a/tests/src/threading_helpers.c b/tests/src/threading_helpers.c
index ca91b79..ae6e590 100644
--- a/tests/src/threading_helpers.c
+++ b/tests/src/threading_helpers.c
@@ -70,8 +70,7 @@
* indicate the exact location of the problematic call. To locate the error,
* use a debugger and set a breakpoint on mbedtls_test_mutex_usage_error().
*/
-enum value_of_mutex_is_valid_field
-{
+enum value_of_mutex_is_valid_field {
/* Potential values for the is_valid field of mbedtls_threading_mutex_t.
* Note that MUTEX_FREED must be 0 and MUTEX_IDLE must be 1 for
* compatibility with threading_mutex_init_pthread() and
@@ -82,12 +81,11 @@
MUTEX_LOCKED = 2, //!< Set by our lock
};
-typedef struct
-{
- void (*init)( mbedtls_threading_mutex_t * );
- void (*free)( mbedtls_threading_mutex_t * );
- int (*lock)( mbedtls_threading_mutex_t * );
- int (*unlock)( mbedtls_threading_mutex_t * );
+typedef struct {
+ void (*init)(mbedtls_threading_mutex_t *);
+ void (*free)(mbedtls_threading_mutex_t *);
+ int (*lock)(mbedtls_threading_mutex_t *);
+ int (*unlock)(mbedtls_threading_mutex_t *);
} mutex_functions_t;
static mutex_functions_t mutex_functions;
@@ -98,94 +96,96 @@
*/
static int live_mutexes;
-static void mbedtls_test_mutex_usage_error( mbedtls_threading_mutex_t *mutex,
- const char *msg )
+static void mbedtls_test_mutex_usage_error(mbedtls_threading_mutex_t *mutex,
+ const char *msg)
{
(void) mutex;
- if( mbedtls_test_info.mutex_usage_error == NULL )
+ if (mbedtls_test_info.mutex_usage_error == NULL) {
mbedtls_test_info.mutex_usage_error = msg;
- mbedtls_fprintf( stdout, "[mutex: %s] ", msg );
+ }
+ mbedtls_fprintf(stdout, "[mutex: %s] ", msg);
/* Don't mark the test as failed yet. This way, if the test fails later
* for a functional reason, the test framework will report the message
* and location for this functional reason. If the test passes,
* mbedtls_test_mutex_usage_check() will mark it as failed. */
}
-static void mbedtls_test_wrap_mutex_init( mbedtls_threading_mutex_t *mutex )
+static void mbedtls_test_wrap_mutex_init(mbedtls_threading_mutex_t *mutex)
{
- mutex_functions.init( mutex );
- if( mutex->is_valid )
+ mutex_functions.init(mutex);
+ if (mutex->is_valid) {
++live_mutexes;
+ }
}
-static void mbedtls_test_wrap_mutex_free( mbedtls_threading_mutex_t *mutex )
+static void mbedtls_test_wrap_mutex_free(mbedtls_threading_mutex_t *mutex)
{
- switch( mutex->is_valid )
- {
+ switch (mutex->is_valid) {
case MUTEX_FREED:
- mbedtls_test_mutex_usage_error( mutex, "free without init or double free" );
+ mbedtls_test_mutex_usage_error(mutex, "free without init or double free");
break;
case MUTEX_IDLE:
/* Do nothing. The underlying free function will reset is_valid
* to 0. */
break;
case MUTEX_LOCKED:
- mbedtls_test_mutex_usage_error( mutex, "free without unlock" );
+ mbedtls_test_mutex_usage_error(mutex, "free without unlock");
break;
default:
- mbedtls_test_mutex_usage_error( mutex, "corrupted state" );
+ mbedtls_test_mutex_usage_error(mutex, "corrupted state");
break;
}
- if( mutex->is_valid )
+ if (mutex->is_valid) {
--live_mutexes;
- mutex_functions.free( mutex );
+ }
+ mutex_functions.free(mutex);
}
-static int mbedtls_test_wrap_mutex_lock( mbedtls_threading_mutex_t *mutex )
+static int mbedtls_test_wrap_mutex_lock(mbedtls_threading_mutex_t *mutex)
{
- int ret = mutex_functions.lock( mutex );
- switch( mutex->is_valid )
- {
+ int ret = mutex_functions.lock(mutex);
+ switch (mutex->is_valid) {
case MUTEX_FREED:
- mbedtls_test_mutex_usage_error( mutex, "lock without init" );
+ mbedtls_test_mutex_usage_error(mutex, "lock without init");
break;
case MUTEX_IDLE:
- if( ret == 0 )
+ if (ret == 0) {
mutex->is_valid = 2;
+ }
break;
case MUTEX_LOCKED:
- mbedtls_test_mutex_usage_error( mutex, "double lock" );
+ mbedtls_test_mutex_usage_error(mutex, "double lock");
break;
default:
- mbedtls_test_mutex_usage_error( mutex, "corrupted state" );
+ mbedtls_test_mutex_usage_error(mutex, "corrupted state");
break;
}
- return( ret );
+ return ret;
}
-static int mbedtls_test_wrap_mutex_unlock( mbedtls_threading_mutex_t *mutex )
+static int mbedtls_test_wrap_mutex_unlock(mbedtls_threading_mutex_t *mutex)
{
- int ret = mutex_functions.unlock( mutex );
- switch( mutex->is_valid )
- {
+ int ret = mutex_functions.unlock(mutex);
+ switch (mutex->is_valid) {
case MUTEX_FREED:
- mbedtls_test_mutex_usage_error( mutex, "unlock without init" );
+ mbedtls_test_mutex_usage_error(mutex, "unlock without init");
break;
case MUTEX_IDLE:
- mbedtls_test_mutex_usage_error( mutex, "unlock without lock" );
+ mbedtls_test_mutex_usage_error(mutex, "unlock without lock");
break;
case MUTEX_LOCKED:
- if( ret == 0 )
+ if (ret == 0) {
mutex->is_valid = MUTEX_IDLE;
+ }
break;
default:
- mbedtls_test_mutex_usage_error( mutex, "corrupted state" );
+ mbedtls_test_mutex_usage_error(mutex, "corrupted state");
break;
}
- return( ret );
+ return ret;
}
-void mbedtls_test_mutex_usage_init( void )
+void mbedtls_test_mutex_usage_init(void)
{
mutex_functions.init = mbedtls_mutex_init;
mutex_functions.free = mbedtls_mutex_free;
@@ -197,25 +197,24 @@
mbedtls_mutex_unlock = &mbedtls_test_wrap_mutex_unlock;
}
-void mbedtls_test_mutex_usage_check( void )
+void mbedtls_test_mutex_usage_check(void)
{
- if( live_mutexes != 0 )
- {
+ if (live_mutexes != 0) {
/* A positive number (more init than free) means that a mutex resource
* is leaking (on platforms where a mutex consumes more than the
* mbedtls_threading_mutex_t object itself). The rare case of a
* negative number means a missing init somewhere. */
- mbedtls_fprintf( stdout, "[mutex: %d leaked] ", live_mutexes );
+ mbedtls_fprintf(stdout, "[mutex: %d leaked] ", live_mutexes);
live_mutexes = 0;
- if( mbedtls_test_info.mutex_usage_error == NULL )
+ if (mbedtls_test_info.mutex_usage_error == NULL) {
mbedtls_test_info.mutex_usage_error = "missing free";
+ }
}
- if( mbedtls_test_info.mutex_usage_error != NULL &&
- mbedtls_test_info.result != MBEDTLS_TEST_RESULT_FAILED )
- {
+ if (mbedtls_test_info.mutex_usage_error != NULL &&
+ mbedtls_test_info.result != MBEDTLS_TEST_RESULT_FAILED) {
/* Functionally, the test passed. But there was a mutex usage error,
* so mark the test as failed after all. */
- mbedtls_test_fail( "Mutex usage error", __LINE__, __FILE__ );
+ mbedtls_test_fail("Mutex usage error", __LINE__, __FILE__);
}
mbedtls_test_info.mutex_usage_error = NULL;
}
diff --git a/tests/suites/helpers.function b/tests/suites/helpers.function
index c085b18..eb0dc03 100644
--- a/tests/suites/helpers.function
+++ b/tests/suites/helpers.function
@@ -68,11 +68,11 @@
/* Indicates whether we expect mbedtls_entropy_init
* to initialize some strong entropy source. */
#if defined(MBEDTLS_TEST_NULL_ENTROPY) || \
- ( !defined(MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES) && \
- ( !defined(MBEDTLS_NO_PLATFORM_ENTROPY) || \
- defined(MBEDTLS_HAVEGE_C) || \
- defined(MBEDTLS_ENTROPY_HARDWARE_ALT) || \
- defined(ENTROPY_NV_SEED) ) )
+ (!defined(MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES) && \
+ (!defined(MBEDTLS_NO_PLATFORM_ENTROPY) || \
+ defined(MBEDTLS_HAVEGE_C) || \
+ defined(MBEDTLS_ENTROPY_HARDWARE_ALT) || \
+ defined(ENTROPY_NV_SEED)))
#define ENTROPY_HAVE_STRONG
#endif
@@ -87,65 +87,60 @@
*
* \return 0 if the key store is empty, 1 otherwise.
*/
-int test_fail_if_psa_leaking( int line_no, const char *filename )
+int test_fail_if_psa_leaking(int line_no, const char *filename)
{
- const char *msg = mbedtls_test_helper_is_psa_leaking( );
- if( msg == NULL )
+ const char *msg = mbedtls_test_helper_is_psa_leaking();
+ if (msg == NULL) {
return 0;
- else
- {
- mbedtls_test_fail( msg, line_no, filename );
+ } else {
+ mbedtls_test_fail(msg, line_no, filename);
return 1;
}
}
#endif /* defined(MBEDTLS_PSA_CRYPTO_C) */
#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
-static int redirect_output( FILE* out_stream, const char* path )
+static int redirect_output(FILE *out_stream, const char *path)
{
int out_fd, dup_fd;
- FILE* path_stream;
+ FILE *path_stream;
- out_fd = fileno( out_stream );
- dup_fd = dup( out_fd );
+ out_fd = fileno(out_stream);
+ dup_fd = dup(out_fd);
- if( dup_fd == -1 )
- {
- return( -1 );
+ if (dup_fd == -1) {
+ return -1;
}
- path_stream = fopen( path, "w" );
- if( path_stream == NULL )
- {
- close( dup_fd );
- return( -1 );
+ path_stream = fopen(path, "w");
+ if (path_stream == NULL) {
+ close(dup_fd);
+ return -1;
}
- fflush( out_stream );
- if( dup2( fileno( path_stream ), out_fd ) == -1 )
- {
- close( dup_fd );
- fclose( path_stream );
- return( -1 );
+ fflush(out_stream);
+ if (dup2(fileno(path_stream), out_fd) == -1) {
+ close(dup_fd);
+ fclose(path_stream);
+ return -1;
}
- fclose( path_stream );
- return( dup_fd );
+ fclose(path_stream);
+ return dup_fd;
}
-static int restore_output( FILE* out_stream, int dup_fd )
+static int restore_output(FILE *out_stream, int dup_fd)
{
- int out_fd = fileno( out_stream );
+ int out_fd = fileno(out_stream);
- fflush( out_stream );
- if( dup2( dup_fd, out_fd ) == -1 )
- {
- close( out_fd );
- close( dup_fd );
- return( -1 );
+ fflush(out_stream);
+ if (dup2(dup_fd, out_fd) == -1) {
+ close(out_fd);
+ close(dup_fd);
+ return -1;
}
- close( dup_fd );
- return( 0 );
+ close(dup_fd);
+ return 0;
}
#endif /* __unix__ || __APPLE__ __MACH__ */
diff --git a/tests/suites/host_test.function b/tests/suites/host_test.function
index bb06822..475a9c8 100644
--- a/tests/suites/host_test.function
+++ b/tests/suites/host_test.function
@@ -8,20 +8,19 @@
*
* \return 0 if success else 1
*/
-int verify_string( char **str )
+int verify_string(char **str)
{
- if( ( *str )[0] != '"' ||
- ( *str )[strlen( *str ) - 1] != '"' )
- {
- mbedtls_fprintf( stderr,
- "Expected string (with \"\") for parameter and got: %s\n", *str );
- return( -1 );
+ if ((*str)[0] != '"' ||
+ (*str)[strlen(*str) - 1] != '"') {
+ mbedtls_fprintf(stderr,
+ "Expected string (with \"\") for parameter and got: %s\n", *str);
+ return -1;
}
- ( *str )++;
- ( *str )[strlen( *str ) - 1] = '\0';
+ (*str)++;
+ (*str)[strlen(*str) - 1] = '\0';
- return( 0 );
+ return 0;
}
/**
@@ -33,50 +32,46 @@
*
* \return 0 if success else 1
*/
-int verify_int( char *str, int32_t *value )
+int verify_int(char *str, int32_t *value)
{
size_t i;
int minus = 0;
int digits = 1;
int hex = 0;
- for( i = 0; i < strlen( str ); i++ )
- {
- if( i == 0 && str[i] == '-' )
- {
+ for (i = 0; i < strlen(str); i++) {
+ if (i == 0 && str[i] == '-') {
minus = 1;
continue;
}
- if( ( ( minus && i == 2 ) || ( !minus && i == 1 ) ) &&
- str[i - 1] == '0' && ( str[i] == 'x' || str[i] == 'X' ) )
- {
+ if (((minus && i == 2) || (!minus && i == 1)) &&
+ str[i - 1] == '0' && (str[i] == 'x' || str[i] == 'X')) {
hex = 1;
continue;
}
- if( ! ( ( str[i] >= '0' && str[i] <= '9' ) ||
- ( hex && ( ( str[i] >= 'a' && str[i] <= 'f' ) ||
- ( str[i] >= 'A' && str[i] <= 'F' ) ) ) ) )
- {
+ if (!((str[i] >= '0' && str[i] <= '9') ||
+ (hex && ((str[i] >= 'a' && str[i] <= 'f') ||
+ (str[i] >= 'A' && str[i] <= 'F'))))) {
digits = 0;
break;
}
}
- if( digits )
- {
- if( hex )
- *value = strtol( str, NULL, 16 );
- else
- *value = strtol( str, NULL, 10 );
+ if (digits) {
+ if (hex) {
+ *value = strtol(str, NULL, 16);
+ } else {
+ *value = strtol(str, NULL, 10);
+ }
- return( 0 );
+ return 0;
}
- mbedtls_fprintf( stderr,
- "Expected integer for parameter and got: %s\n", str );
- return( KEY_VALUE_MAPPING_NOT_FOUND );
+ mbedtls_fprintf(stderr,
+ "Expected integer for parameter and got: %s\n", str);
+ return KEY_VALUE_MAPPING_NOT_FOUND;
}
@@ -107,44 +102,45 @@
*
* \return 0 if success else -1
*/
-int get_line( FILE *f, char *buf, size_t len )
+int get_line(FILE *f, char *buf, size_t len)
{
char *ret;
int i = 0, str_len = 0, has_string = 0;
/* Read until we get a valid line */
- do
- {
- ret = fgets( buf, len, f );
- if( ret == NULL )
- return( -1 );
+ do {
+ ret = fgets(buf, len, f);
+ if (ret == NULL) {
+ return -1;
+ }
- str_len = strlen( buf );
+ str_len = strlen(buf);
/* Skip empty line and comment */
- if ( str_len == 0 || buf[0] == '#' )
+ if (str_len == 0 || buf[0] == '#') {
continue;
+ }
has_string = 0;
- for ( i = 0; i < str_len; i++ )
- {
+ for (i = 0; i < str_len; i++) {
char c = buf[i];
- if ( c != ' ' && c != '\t' && c != '\n' &&
- c != '\v' && c != '\f' && c != '\r' )
- {
+ if (c != ' ' && c != '\t' && c != '\n' &&
+ c != '\v' && c != '\f' && c != '\r') {
has_string = 1;
break;
}
}
- } while( !has_string );
+ } while (!has_string);
/* Strip new line and carriage return */
- ret = buf + strlen( buf );
- if( ret-- > buf && *ret == '\n' )
+ ret = buf + strlen(buf);
+ if (ret-- > buf && *ret == '\n') {
*ret = '\0';
- if( ret-- > buf && *ret == '\r' )
+ }
+ if (ret-- > buf && *ret == '\r') {
*ret = '\0';
+ }
- return( 0 );
+ return 0;
}
/**
@@ -157,8 +153,8 @@
*
* \return Count of strings found.
*/
-static int parse_arguments( char *buf, size_t len, char **params,
- size_t params_len )
+static int parse_arguments(char *buf, size_t len, char **params,
+ size_t params_len)
{
size_t cnt = 0, i;
char *cur = buf;
@@ -166,20 +162,16 @@
params[cnt++] = cur;
- while( *p != '\0' && p < ( buf + len ) )
- {
- if( *p == '\\' )
- {
+ while (*p != '\0' && p < (buf + len)) {
+ if (*p == '\\') {
p++;
p++;
continue;
}
- if( *p == ':' )
- {
- if( p + 1 < buf + len )
- {
+ if (*p == ':') {
+ if (p + 1 < buf + len) {
cur = p + 1;
- TEST_HELPER_ASSERT( cnt < params_len );
+ TEST_HELPER_ASSERT(cnt < params_len);
params[cnt++] = cur;
}
*p = '\0';
@@ -189,35 +181,28 @@
}
/* Replace newlines, question marks and colons in strings */
- for( i = 0; i < cnt; i++ )
- {
+ for (i = 0; i < cnt; i++) {
p = params[i];
q = params[i];
- while( *p != '\0' )
- {
- if( *p == '\\' && *( p + 1 ) == 'n' )
- {
+ while (*p != '\0') {
+ if (*p == '\\' && *(p + 1) == 'n') {
p += 2;
- *( q++ ) = '\n';
- }
- else if( *p == '\\' && *( p + 1 ) == ':' )
- {
+ *(q++) = '\n';
+ } else if (*p == '\\' && *(p + 1) == ':') {
p += 2;
- *( q++ ) = ':';
- }
- else if( *p == '\\' && *( p + 1 ) == '?' )
- {
+ *(q++) = ':';
+ } else if (*p == '\\' && *(p + 1) == '?') {
p += 2;
- *( q++ ) = '?';
+ *(q++) = '?';
+ } else {
+ *(q++) = *(p++);
}
- else
- *( q++ ) = *( p++ );
}
*q = '\0';
}
- return( cnt );
+ return cnt;
}
/**
@@ -238,81 +223,59 @@
*
* \return 0 for success else 1
*/
-static int convert_params( size_t cnt , char ** params , int32_t * int_params_store )
+static int convert_params(size_t cnt, char **params, int32_t *int_params_store)
{
- char ** cur = params;
- char ** out = params;
+ char **cur = params;
+ char **out = params;
int ret = DISPATCH_TEST_SUCCESS;
- while ( cur < params + cnt )
- {
- char * type = *cur++;
- char * val = *cur++;
+ while (cur < params + cnt) {
+ char *type = *cur++;
+ char *val = *cur++;
- if ( strcmp( type, "char*" ) == 0 )
- {
- if ( verify_string( &val ) == 0 )
- {
- *out++ = val;
- }
- else
- {
- ret = ( DISPATCH_INVALID_TEST_DATA );
+ if (strcmp(type, "char*") == 0) {
+ if (verify_string(&val) == 0) {
+ *out++ = val;
+ } else {
+ ret = (DISPATCH_INVALID_TEST_DATA);
break;
}
- }
- else if ( strcmp( type, "int" ) == 0 )
- {
- if ( verify_int( val, int_params_store ) == 0 )
- {
- *out++ = (char *) int_params_store++;
- }
- else
- {
- ret = ( DISPATCH_INVALID_TEST_DATA );
+ } else if (strcmp(type, "int") == 0) {
+ if (verify_int(val, int_params_store) == 0) {
+ *out++ = (char *) int_params_store++;
+ } else {
+ ret = (DISPATCH_INVALID_TEST_DATA);
break;
}
- }
- else if ( strcmp( type, "hex" ) == 0 )
- {
- if ( verify_string( &val ) == 0 )
- {
+ } else if (strcmp(type, "hex") == 0) {
+ if (verify_string(&val) == 0) {
size_t len;
TEST_HELPER_ASSERT(
- mbedtls_test_unhexify( (unsigned char *) val, strlen( val ),
- val, &len ) == 0 );
+ mbedtls_test_unhexify((unsigned char *) val, strlen(val),
+ val, &len) == 0);
*int_params_store = len;
*out++ = val;
- *out++ = (char *)(int_params_store++);
- }
- else
- {
- ret = ( DISPATCH_INVALID_TEST_DATA );
+ *out++ = (char *) (int_params_store++);
+ } else {
+ ret = (DISPATCH_INVALID_TEST_DATA);
break;
}
- }
- else if ( strcmp( type, "exp" ) == 0 )
- {
- int exp_id = strtol( val, NULL, 10 );
- if ( get_expression ( exp_id, int_params_store ) == 0 )
- {
- *out++ = (char *)int_params_store++;
+ } else if (strcmp(type, "exp") == 0) {
+ int exp_id = strtol(val, NULL, 10);
+ if (get_expression(exp_id, int_params_store) == 0) {
+ *out++ = (char *) int_params_store++;
+ } else {
+ ret = (DISPATCH_INVALID_TEST_DATA);
+ break;
}
- else
- {
- ret = ( DISPATCH_INVALID_TEST_DATA );
- break;
- }
- }
- else
- {
- ret = ( DISPATCH_INVALID_TEST_DATA );
- break;
+ } else {
+ ret = (DISPATCH_INVALID_TEST_DATA);
+ break;
}
}
- return( ret );
+ return ret;
}
/**
@@ -335,26 +298,27 @@
#if defined(__GNUC__)
__attribute__((__noinline__))
#endif
-static int test_snprintf( size_t n, const char *ref_buf, int ref_ret )
+static int test_snprintf(size_t n, const char *ref_buf, int ref_ret)
{
int ret;
char buf[10] = "xxxxxxxxx";
const char ref[10] = "xxxxxxxxx";
- if( n >= sizeof( buf ) )
- return( -1 );
- ret = mbedtls_snprintf( buf, n, "%s", "123" );
- if( ret < 0 || (size_t) ret >= n )
+ if (n >= sizeof(buf)) {
+ return -1;
+ }
+ ret = mbedtls_snprintf(buf, n, "%s", "123");
+ if (ret < 0 || (size_t) ret >= n) {
ret = -1;
-
- if( strncmp( ref_buf, buf, sizeof( buf ) ) != 0 ||
- ref_ret != ret ||
- memcmp( buf + n, ref + n, sizeof( buf ) - n ) != 0 )
- {
- return( 1 );
}
- return( 0 );
+ if (strncmp(ref_buf, buf, sizeof(buf)) != 0 ||
+ ref_ret != ret ||
+ memcmp(buf + n, ref + n, sizeof(buf) - n) != 0) {
+ return 1;
+ }
+
+ return 0;
}
/**
@@ -362,14 +326,14 @@
*
* \return 0 for success else 1
*/
-static int run_test_snprintf( void )
+static int run_test_snprintf(void)
{
- return( test_snprintf( 0, "xxxxxxxxx", -1 ) != 0 ||
- test_snprintf( 1, "", -1 ) != 0 ||
- test_snprintf( 2, "1", -1 ) != 0 ||
- test_snprintf( 3, "12", -1 ) != 0 ||
- test_snprintf( 4, "123", 3 ) != 0 ||
- test_snprintf( 5, "123", 3 ) != 0 );
+ return test_snprintf(0, "xxxxxxxxx", -1) != 0 ||
+ test_snprintf(1, "", -1) != 0 ||
+ test_snprintf(2, "1", -1) != 0 ||
+ test_snprintf(3, "12", -1) != 0 ||
+ test_snprintf(4, "123", 3) != 0 ||
+ test_snprintf(5, "123", 3) != 0;
}
/** \brief Write the description of the test case to the outcome CSV file.
@@ -379,43 +343,44 @@
* \param argv0 The test suite name.
* \param test_case The test case description.
*/
-static void write_outcome_entry( FILE *outcome_file,
- const char *argv0,
- const char *test_case )
+static void write_outcome_entry(FILE *outcome_file,
+ const char *argv0,
+ const char *test_case)
{
/* The non-varying fields are initialized on first use. */
static const char *platform = NULL;
static const char *configuration = NULL;
static const char *test_suite = NULL;
- if( outcome_file == NULL )
+ if (outcome_file == NULL) {
return;
+ }
- if( platform == NULL )
- {
- platform = getenv( "MBEDTLS_TEST_PLATFORM" );
- if( platform == NULL )
+ if (platform == NULL) {
+ platform = getenv("MBEDTLS_TEST_PLATFORM");
+ if (platform == NULL) {
platform = "unknown";
+ }
}
- if( configuration == NULL )
- {
- configuration = getenv( "MBEDTLS_TEST_CONFIGURATION" );
- if( configuration == NULL )
+ if (configuration == NULL) {
+ configuration = getenv("MBEDTLS_TEST_CONFIGURATION");
+ if (configuration == NULL) {
configuration = "unknown";
+ }
}
- if( test_suite == NULL )
- {
- test_suite = strrchr( argv0, '/' );
- if( test_suite != NULL )
+ if (test_suite == NULL) {
+ test_suite = strrchr(argv0, '/');
+ if (test_suite != NULL) {
test_suite += 1; // skip the '/'
- else
+ } else {
test_suite = argv0;
+ }
}
/* Write the beginning of the outcome line.
* Ignore errors: writing the outcome file is on a best-effort basis. */
- mbedtls_fprintf( outcome_file, "%s;%s;%s;%s;",
- platform, configuration, test_suite, test_case );
+ mbedtls_fprintf(outcome_file, "%s;%s;%s;%s;",
+ platform, configuration, test_suite, test_case);
}
/** \brief Write the result of the test case to the outcome CSV file.
@@ -429,65 +394,63 @@
* \param ret The test dispatch status (DISPATCH_xxx).
* \param info A pointer to the test info structure.
*/
-static void write_outcome_result( FILE *outcome_file,
- size_t unmet_dep_count,
- int unmet_dependencies[],
- int missing_unmet_dependencies,
- int ret,
- const mbedtls_test_info_t *info )
+static void write_outcome_result(FILE *outcome_file,
+ size_t unmet_dep_count,
+ int unmet_dependencies[],
+ int missing_unmet_dependencies,
+ int ret,
+ const mbedtls_test_info_t *info)
{
- if( outcome_file == NULL )
+ if (outcome_file == NULL) {
return;
+ }
/* Write the end of the outcome line.
* Ignore errors: writing the outcome file is on a best-effort basis. */
- switch( ret )
- {
+ switch (ret) {
case DISPATCH_TEST_SUCCESS:
- if( unmet_dep_count > 0 )
- {
+ if (unmet_dep_count > 0) {
size_t i;
- mbedtls_fprintf( outcome_file, "SKIP" );
- for( i = 0; i < unmet_dep_count; i++ )
- {
- mbedtls_fprintf( outcome_file, "%c%d",
- i == 0 ? ';' : ':',
- unmet_dependencies[i] );
+ mbedtls_fprintf(outcome_file, "SKIP");
+ for (i = 0; i < unmet_dep_count; i++) {
+ mbedtls_fprintf(outcome_file, "%c%d",
+ i == 0 ? ';' : ':',
+ unmet_dependencies[i]);
}
- if( missing_unmet_dependencies )
- mbedtls_fprintf( outcome_file, ":..." );
+ if (missing_unmet_dependencies) {
+ mbedtls_fprintf(outcome_file, ":...");
+ }
break;
}
- switch( info->result )
- {
+ switch (info->result) {
case MBEDTLS_TEST_RESULT_SUCCESS:
- mbedtls_fprintf( outcome_file, "PASS;" );
+ mbedtls_fprintf(outcome_file, "PASS;");
break;
case MBEDTLS_TEST_RESULT_SKIPPED:
- mbedtls_fprintf( outcome_file, "SKIP;Runtime skip" );
+ mbedtls_fprintf(outcome_file, "SKIP;Runtime skip");
break;
default:
- mbedtls_fprintf( outcome_file, "FAIL;%s:%d:%s",
- info->filename, info->line_no,
- info->test );
+ mbedtls_fprintf(outcome_file, "FAIL;%s:%d:%s",
+ info->filename, info->line_no,
+ info->test);
break;
}
break;
case DISPATCH_TEST_FN_NOT_FOUND:
- mbedtls_fprintf( outcome_file, "FAIL;Test function not found" );
+ mbedtls_fprintf(outcome_file, "FAIL;Test function not found");
break;
case DISPATCH_INVALID_TEST_DATA:
- mbedtls_fprintf( outcome_file, "FAIL;Invalid test data" );
+ mbedtls_fprintf(outcome_file, "FAIL;Invalid test data");
break;
case DISPATCH_UNSUPPORTED_SUITE:
- mbedtls_fprintf( outcome_file, "SKIP;Unsupported suite" );
+ mbedtls_fprintf(outcome_file, "SKIP;Unsupported suite");
break;
default:
- mbedtls_fprintf( outcome_file, "FAIL;Unknown cause" );
+ mbedtls_fprintf(outcome_file, "FAIL;Unknown cause");
break;
}
- mbedtls_fprintf( outcome_file, "\n" );
- fflush( outcome_file );
+ mbedtls_fprintf(outcome_file, "\n");
+ fflush(outcome_file);
}
/**
@@ -500,7 +463,7 @@
*
* \return Program exit status.
*/
-int execute_tests( int argc , const char ** argv )
+int execute_tests(int argc, const char **argv)
{
/* Local Configurations and options */
const char *default_filename = "DATA_FILE";
@@ -525,17 +488,17 @@
#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
int stdout_fd = -1;
#endif /* __unix__ || __APPLE__ __MACH__ */
- const char *outcome_file_name = getenv( "MBEDTLS_TEST_OUTCOME_FILE" );
+ const char *outcome_file_name = getenv("MBEDTLS_TEST_OUTCOME_FILE");
FILE *outcome_file = NULL;
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && \
!defined(TEST_SUITE_MEMORY_BUFFER_ALLOC)
unsigned char alloc_buf[1000000];
- mbedtls_memory_buffer_alloc_init( alloc_buf, sizeof( alloc_buf ) );
+ mbedtls_memory_buffer_alloc_init(alloc_buf, sizeof(alloc_buf));
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
- mbedtls_test_mutex_usage_init( );
+ mbedtls_test_mutex_usage_init();
#endif
/*
@@ -543,52 +506,42 @@
* of a NULL pointer. We do however use that in our code for initializing
* structures, which should work on every modern platform. Let's be sure.
*/
- memset( &pointer, 0, sizeof( void * ) );
- if( pointer != NULL )
- {
- mbedtls_fprintf( stderr, "all-bits-zero is not a NULL pointer\n" );
- return( 1 );
+ memset(&pointer, 0, sizeof(void *));
+ if (pointer != NULL) {
+ mbedtls_fprintf(stderr, "all-bits-zero is not a NULL pointer\n");
+ return 1;
}
/*
* Make sure we have a snprintf that correctly zero-terminates
*/
- if( run_test_snprintf() != 0 )
- {
- mbedtls_fprintf( stderr, "the snprintf implementation is broken\n" );
- return( 1 );
+ if (run_test_snprintf() != 0) {
+ mbedtls_fprintf(stderr, "the snprintf implementation is broken\n");
+ return 1;
}
- if( outcome_file_name != NULL && *outcome_file_name != '\0' )
- {
- outcome_file = fopen( outcome_file_name, "a" );
- if( outcome_file == NULL )
- {
- mbedtls_fprintf( stderr, "Unable to open outcome file. Continuing anyway.\n" );
+ if (outcome_file_name != NULL && *outcome_file_name != '\0') {
+ outcome_file = fopen(outcome_file_name, "a");
+ if (outcome_file == NULL) {
+ mbedtls_fprintf(stderr, "Unable to open outcome file. Continuing anyway.\n");
}
}
- while( arg_index < argc )
- {
+ while (arg_index < argc) {
next_arg = argv[arg_index];
- if( strcmp( next_arg, "--verbose" ) == 0 ||
- strcmp( next_arg, "-v" ) == 0 )
- {
+ if (strcmp(next_arg, "--verbose") == 0 ||
+ strcmp(next_arg, "-v") == 0) {
option_verbose = 1;
- }
- else if( strcmp(next_arg, "--help" ) == 0 ||
- strcmp(next_arg, "-h" ) == 0 )
- {
- mbedtls_fprintf( stdout, USAGE );
- mbedtls_exit( EXIT_SUCCESS );
- }
- else
- {
+ } else if (strcmp(next_arg, "--help") == 0 ||
+ strcmp(next_arg, "-h") == 0) {
+ mbedtls_fprintf(stdout, USAGE);
+ mbedtls_exit(EXIT_SUCCESS);
+ } else {
/* Not an option, therefore treat all further arguments as the file
* list.
*/
- test_files = &argv[ arg_index ];
+ test_files = &argv[arg_index];
testfile_count = argc - arg_index;
break;
}
@@ -597,226 +550,204 @@
}
/* If no files were specified, assume a default */
- if ( test_files == NULL || testfile_count == 0 )
- {
+ if (test_files == NULL || testfile_count == 0) {
test_files = &default_filename;
testfile_count = 1;
}
/* Initialize the struct that holds information about the last test */
- mbedtls_test_info_reset( );
+ mbedtls_test_info_reset();
/* Now begin to execute the tests in the testfiles */
- for ( testfile_index = 0;
- testfile_index < testfile_count;
- testfile_index++ )
- {
+ for (testfile_index = 0;
+ testfile_index < testfile_count;
+ testfile_index++) {
size_t unmet_dep_count = 0;
int unmet_dependencies[20];
int missing_unmet_dependencies = 0;
- test_filename = test_files[ testfile_index ];
+ test_filename = test_files[testfile_index];
- file = fopen( test_filename, "r" );
- if( file == NULL )
- {
- mbedtls_fprintf( stderr, "Failed to open test file: %s\n",
- test_filename );
- if( outcome_file != NULL )
- fclose( outcome_file );
- return( 1 );
+ file = fopen(test_filename, "r");
+ if (file == NULL) {
+ mbedtls_fprintf(stderr, "Failed to open test file: %s\n",
+ test_filename);
+ if (outcome_file != NULL) {
+ fclose(outcome_file);
+ }
+ return 1;
}
- while( !feof( file ) )
- {
- if( unmet_dep_count > 0 )
- {
- mbedtls_fprintf( stderr,
- "FATAL: Dep count larger than zero at start of loop\n" );
- mbedtls_exit( MBEDTLS_EXIT_FAILURE );
+ while (!feof(file)) {
+ if (unmet_dep_count > 0) {
+ mbedtls_fprintf(stderr,
+ "FATAL: Dep count larger than zero at start of loop\n");
+ mbedtls_exit(MBEDTLS_EXIT_FAILURE);
}
unmet_dep_count = 0;
missing_unmet_dependencies = 0;
- if( ( ret = get_line( file, buf, sizeof(buf) ) ) != 0 )
+ if ((ret = get_line(file, buf, sizeof(buf))) != 0) {
break;
- mbedtls_fprintf( stdout, "%s%.66s",
- mbedtls_test_info.result == MBEDTLS_TEST_RESULT_FAILED ?
- "\n" : "", buf );
- mbedtls_fprintf( stdout, " " );
- for( i = strlen( buf ) + 1; i < 67; i++ )
- mbedtls_fprintf( stdout, "." );
- mbedtls_fprintf( stdout, " " );
- fflush( stdout );
- write_outcome_entry( outcome_file, argv[0], buf );
+ }
+ mbedtls_fprintf(stdout, "%s%.66s",
+ mbedtls_test_info.result == MBEDTLS_TEST_RESULT_FAILED ?
+ "\n" : "", buf);
+ mbedtls_fprintf(stdout, " ");
+ for (i = strlen(buf) + 1; i < 67; i++) {
+ mbedtls_fprintf(stdout, ".");
+ }
+ mbedtls_fprintf(stdout, " ");
+ fflush(stdout);
+ write_outcome_entry(outcome_file, argv[0], buf);
total_tests++;
- if( ( ret = get_line( file, buf, sizeof( buf ) ) ) != 0 )
+ if ((ret = get_line(file, buf, sizeof(buf))) != 0) {
break;
- cnt = parse_arguments( buf, strlen( buf ), params,
- sizeof( params ) / sizeof( params[0] ) );
+ }
+ cnt = parse_arguments(buf, strlen(buf), params,
+ sizeof(params) / sizeof(params[0]));
- if( strcmp( params[0], "depends_on" ) == 0 )
- {
- for( i = 1; i < cnt; i++ )
- {
- int dep_id = strtol( params[i], NULL, 10 );
- if( dep_check( dep_id ) != DEPENDENCY_SUPPORTED )
- {
- if( unmet_dep_count <
- ARRAY_LENGTH( unmet_dependencies ) )
- {
+ if (strcmp(params[0], "depends_on") == 0) {
+ for (i = 1; i < cnt; i++) {
+ int dep_id = strtol(params[i], NULL, 10);
+ if (dep_check(dep_id) != DEPENDENCY_SUPPORTED) {
+ if (unmet_dep_count <
+ ARRAY_LENGTH(unmet_dependencies)) {
unmet_dependencies[unmet_dep_count] = dep_id;
unmet_dep_count++;
- }
- else
- {
+ } else {
missing_unmet_dependencies = 1;
}
}
}
- if( ( ret = get_line( file, buf, sizeof( buf ) ) ) != 0 )
+ if ((ret = get_line(file, buf, sizeof(buf))) != 0) {
break;
- cnt = parse_arguments( buf, strlen( buf ), params,
- sizeof( params ) / sizeof( params[0] ) );
+ }
+ cnt = parse_arguments(buf, strlen(buf), params,
+ sizeof(params) / sizeof(params[0]));
}
// If there are no unmet dependencies execute the test
- if( unmet_dep_count == 0 )
- {
- mbedtls_test_info_reset( );
+ if (unmet_dep_count == 0) {
+ mbedtls_test_info_reset();
#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
/* Suppress all output from the library unless we're verbose
* mode
*/
- if( !option_verbose )
- {
- stdout_fd = redirect_output( stdout, "/dev/null" );
- if( stdout_fd == -1 )
- {
+ if (!option_verbose) {
+ stdout_fd = redirect_output(stdout, "/dev/null");
+ if (stdout_fd == -1) {
/* Redirection has failed with no stdout so exit */
- exit( 1 );
+ exit(1);
}
}
#endif /* __unix__ || __APPLE__ __MACH__ */
- function_id = strtoul( params[0], NULL, 10 );
- if ( (ret = check_test( function_id )) == DISPATCH_TEST_SUCCESS )
- {
- ret = convert_params( cnt - 1, params + 1, int_params );
- if ( DISPATCH_TEST_SUCCESS == ret )
- {
- ret = dispatch_test( function_id, (void **)( params + 1 ) );
+ function_id = strtoul(params[0], NULL, 10);
+ if ((ret = check_test(function_id)) == DISPATCH_TEST_SUCCESS) {
+ ret = convert_params(cnt - 1, params + 1, int_params);
+ if (DISPATCH_TEST_SUCCESS == ret) {
+ ret = dispatch_test(function_id, (void **) (params + 1));
}
}
#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
- if( !option_verbose && restore_output( stdout, stdout_fd ) )
- {
- /* Redirection has failed with no stdout so exit */
- exit( 1 );
+ if (!option_verbose && restore_output(stdout, stdout_fd)) {
+ /* Redirection has failed with no stdout so exit */
+ exit(1);
}
#endif /* __unix__ || __APPLE__ __MACH__ */
}
- write_outcome_result( outcome_file,
- unmet_dep_count, unmet_dependencies,
- missing_unmet_dependencies,
- ret, &mbedtls_test_info );
- if( unmet_dep_count > 0 || ret == DISPATCH_UNSUPPORTED_SUITE )
- {
+ write_outcome_result(outcome_file,
+ unmet_dep_count, unmet_dependencies,
+ missing_unmet_dependencies,
+ ret, &mbedtls_test_info);
+ if (unmet_dep_count > 0 || ret == DISPATCH_UNSUPPORTED_SUITE) {
total_skipped++;
- mbedtls_fprintf( stdout, "----" );
+ mbedtls_fprintf(stdout, "----");
- if( 1 == option_verbose && ret == DISPATCH_UNSUPPORTED_SUITE )
- {
- mbedtls_fprintf( stdout, "\n Test Suite not enabled" );
+ if (1 == option_verbose && ret == DISPATCH_UNSUPPORTED_SUITE) {
+ mbedtls_fprintf(stdout, "\n Test Suite not enabled");
}
- if( 1 == option_verbose && unmet_dep_count > 0 )
- {
- mbedtls_fprintf( stdout, "\n Unmet dependencies: " );
- for( i = 0; i < unmet_dep_count; i++ )
- {
- mbedtls_fprintf( stdout, "%d ",
- unmet_dependencies[i] );
+ if (1 == option_verbose && unmet_dep_count > 0) {
+ mbedtls_fprintf(stdout, "\n Unmet dependencies: ");
+ for (i = 0; i < unmet_dep_count; i++) {
+ mbedtls_fprintf(stdout, "%d ",
+ unmet_dependencies[i]);
}
- if( missing_unmet_dependencies )
- mbedtls_fprintf( stdout, "..." );
+ if (missing_unmet_dependencies) {
+ mbedtls_fprintf(stdout, "...");
+ }
}
- mbedtls_fprintf( stdout, "\n" );
- fflush( stdout );
+ mbedtls_fprintf(stdout, "\n");
+ fflush(stdout);
unmet_dep_count = 0;
missing_unmet_dependencies = 0;
- }
- else if( ret == DISPATCH_TEST_SUCCESS )
- {
- if( mbedtls_test_info.result == MBEDTLS_TEST_RESULT_SUCCESS )
- {
- mbedtls_fprintf( stdout, "PASS\n" );
- }
- else if( mbedtls_test_info.result == MBEDTLS_TEST_RESULT_SKIPPED )
- {
- mbedtls_fprintf( stdout, "----\n" );
+ } else if (ret == DISPATCH_TEST_SUCCESS) {
+ if (mbedtls_test_info.result == MBEDTLS_TEST_RESULT_SUCCESS) {
+ mbedtls_fprintf(stdout, "PASS\n");
+ } else if (mbedtls_test_info.result == MBEDTLS_TEST_RESULT_SKIPPED) {
+ mbedtls_fprintf(stdout, "----\n");
total_skipped++;
- }
- else
- {
+ } else {
total_errors++;
- mbedtls_fprintf( stdout, "FAILED\n" );
- mbedtls_fprintf( stdout, " %s\n at ",
- mbedtls_test_info.test );
- if( mbedtls_test_info.step != (unsigned long)( -1 ) )
- {
- mbedtls_fprintf( stdout, "step %lu, ",
- mbedtls_test_info.step );
+ mbedtls_fprintf(stdout, "FAILED\n");
+ mbedtls_fprintf(stdout, " %s\n at ",
+ mbedtls_test_info.test);
+ if (mbedtls_test_info.step != (unsigned long) (-1)) {
+ mbedtls_fprintf(stdout, "step %lu, ",
+ mbedtls_test_info.step);
}
- mbedtls_fprintf( stdout, "line %d, %s",
- mbedtls_test_info.line_no,
- mbedtls_test_info.filename );
- if( mbedtls_test_info.line1[0] != 0 )
- mbedtls_fprintf( stdout, "\n %s",
- mbedtls_test_info.line1 );
- if( mbedtls_test_info.line2[0] != 0 )
- mbedtls_fprintf( stdout, "\n %s",
- mbedtls_test_info.line2 );
+ mbedtls_fprintf(stdout, "line %d, %s",
+ mbedtls_test_info.line_no,
+ mbedtls_test_info.filename);
+ if (mbedtls_test_info.line1[0] != 0) {
+ mbedtls_fprintf(stdout, "\n %s",
+ mbedtls_test_info.line1);
+ }
+ if (mbedtls_test_info.line2[0] != 0) {
+ mbedtls_fprintf(stdout, "\n %s",
+ mbedtls_test_info.line2);
+ }
}
- fflush( stdout );
- }
- else if( ret == DISPATCH_INVALID_TEST_DATA )
- {
- mbedtls_fprintf( stderr, "FAILED: FATAL PARSE ERROR\n" );
- fclose( file );
- mbedtls_exit( 2 );
- }
- else if( ret == DISPATCH_TEST_FN_NOT_FOUND )
- {
- mbedtls_fprintf( stderr, "FAILED: FATAL TEST FUNCTION NOT FOUND\n" );
- fclose( file );
- mbedtls_exit( 2 );
- }
- else
+ fflush(stdout);
+ } else if (ret == DISPATCH_INVALID_TEST_DATA) {
+ mbedtls_fprintf(stderr, "FAILED: FATAL PARSE ERROR\n");
+ fclose(file);
+ mbedtls_exit(2);
+ } else if (ret == DISPATCH_TEST_FN_NOT_FOUND) {
+ mbedtls_fprintf(stderr, "FAILED: FATAL TEST FUNCTION NOT FOUND\n");
+ fclose(file);
+ mbedtls_exit(2);
+ } else {
total_errors++;
+ }
}
- fclose( file );
+ fclose(file);
}
- if( outcome_file != NULL )
- fclose( outcome_file );
+ if (outcome_file != NULL) {
+ fclose(outcome_file);
+ }
- mbedtls_fprintf( stdout, "\n----------------------------------------------------------------------------\n\n");
- if( total_errors == 0 )
- mbedtls_fprintf( stdout, "PASSED" );
- else
- mbedtls_fprintf( stdout, "FAILED" );
+ mbedtls_fprintf(stdout,
+ "\n----------------------------------------------------------------------------\n\n");
+ if (total_errors == 0) {
+ mbedtls_fprintf(stdout, "PASSED");
+ } else {
+ mbedtls_fprintf(stdout, "FAILED");
+ }
- mbedtls_fprintf( stdout, " (%u / %u tests (%u skipped))\n",
- total_tests - total_errors, total_tests, total_skipped );
+ mbedtls_fprintf(stdout, " (%u / %u tests (%u skipped))\n",
+ total_tests - total_errors, total_tests, total_skipped);
#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) && \
!defined(TEST_SUITE_MEMORY_BUFFER_ALLOC)
@@ -826,5 +757,5 @@
mbedtls_memory_buffer_alloc_free();
#endif
- return( total_errors != 0 );
+ return total_errors != 0;
}
diff --git a/tests/suites/main_test.function b/tests/suites/main_test.function
index 65c7083..1e5c666 100644
--- a/tests/suites/main_test.function
+++ b/tests/suites/main_test.function
@@ -81,24 +81,23 @@
*
* \return 0 if exp_id is found. 1 otherwise.
*/
-int get_expression( int32_t exp_id, int32_t * out_value )
+int get_expression(int32_t exp_id, int32_t *out_value)
{
int ret = KEY_VALUE_MAPPING_FOUND;
(void) exp_id;
(void) out_value;
- switch( exp_id )
- {
-__MBEDTLS_TEST_TEMPLATE__EXPRESSION_CODE
+ switch (exp_id) {
+ __MBEDTLS_TEST_TEMPLATE__EXPRESSION_CODE
#line __MBEDTLS_TEST_TEMPLATE__LINE_NO "suites/main_test.function"
default:
- {
- ret = KEY_VALUE_MAPPING_NOT_FOUND;
- }
- break;
+ {
+ ret = KEY_VALUE_MAPPING_NOT_FOUND;
+ }
+ break;
}
- return( ret );
+ return ret;
}
@@ -113,20 +112,19 @@
*
* \return DEPENDENCY_SUPPORTED if set else DEPENDENCY_NOT_SUPPORTED
*/
-int dep_check( int dep_id )
+int dep_check(int dep_id)
{
int ret = DEPENDENCY_NOT_SUPPORTED;
(void) dep_id;
- switch( dep_id )
- {
-__MBEDTLS_TEST_TEMPLATE__DEP_CHECK_CODE
+ switch (dep_id) {
+ __MBEDTLS_TEST_TEMPLATE__DEP_CHECK_CODE
#line __MBEDTLS_TEST_TEMPLATE__LINE_NO "suites/main_test.function"
default:
break;
}
- return( ret );
+ return ret;
}
@@ -143,7 +141,7 @@
* dereferences. Each wrapper function hard-codes the
* number and types of the parameters.
*/
-typedef void (*TestWrapper_t)( void **param_array );
+typedef void (*TestWrapper_t)(void **param_array);
/**
@@ -154,7 +152,7 @@
*/
TestWrapper_t test_funcs[] =
{
-__MBEDTLS_TEST_TEMPLATE__DISPATCH_CODE
+ __MBEDTLS_TEST_TEMPLATE__DISPATCH_CODE
#line __MBEDTLS_TEST_TEMPLATE__LINE_NO "suites/main_test.function"
};
@@ -173,32 +171,29 @@
void execute_function_ptr(TestWrapper_t fp, void **params)
{
#if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
- mbedtls_test_enable_insecure_external_rng( );
+ mbedtls_test_enable_insecure_external_rng();
#endif
#if defined(MBEDTLS_CHECK_PARAMS)
mbedtls_test_param_failed_location_record_t location_record;
- if ( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 )
- {
- fp( params );
- }
- else
- {
+ if (setjmp(mbedtls_test_param_failed_get_state_buf()) == 0) {
+ fp(params);
+ } else {
/* Unexpected parameter validation error */
- mbedtls_test_param_failed_get_location_record( &location_record );
- mbedtls_test_fail( location_record.failure_condition,
- location_record.line,
- location_record.file );
+ mbedtls_test_param_failed_get_location_record(&location_record);
+ mbedtls_test_fail(location_record.failure_condition,
+ location_record.line,
+ location_record.file);
}
- mbedtls_test_param_failed_reset_state( );
+ mbedtls_test_param_failed_reset_state();
#else
- fp( params );
+ fp(params);
#endif
#if defined(MBEDTLS_TEST_MUTEX_USAGE)
- mbedtls_test_mutex_usage_check( );
+ mbedtls_test_mutex_usage_check();
#endif /* MBEDTLS_TEST_MUTEX_USAGE */
}
@@ -213,25 +208,23 @@
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
-int dispatch_test( size_t func_idx, void ** params )
+int dispatch_test(size_t func_idx, void **params)
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
- if ( func_idx < (int)( sizeof( test_funcs ) / sizeof( TestWrapper_t ) ) )
- {
+ if (func_idx < (int) (sizeof(test_funcs) / sizeof(TestWrapper_t))) {
fp = test_funcs[func_idx];
- if ( fp )
+ if (fp) {
execute_function_ptr(fp, params);
- else
+ } else {
ret = DISPATCH_UNSUPPORTED_SUITE;
- }
- else
- {
+ }
+ } else {
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
- return( ret );
+ return ret;
}
@@ -245,23 +238,21 @@
* DISPATCH_TEST_FN_NOT_FOUND if not found
* DISPATCH_UNSUPPORTED_SUITE if not compile time enabled.
*/
-int check_test( size_t func_idx )
+int check_test(size_t func_idx)
{
int ret = DISPATCH_TEST_SUCCESS;
TestWrapper_t fp = NULL;
- if ( func_idx < (int)( sizeof(test_funcs)/sizeof( TestWrapper_t ) ) )
- {
+ if (func_idx < (int) (sizeof(test_funcs)/sizeof(TestWrapper_t))) {
fp = test_funcs[func_idx];
- if ( fp == NULL )
+ if (fp == NULL) {
ret = DISPATCH_UNSUPPORTED_SUITE;
- }
- else
- {
+ }
+ } else {
ret = DISPATCH_TEST_FN_NOT_FOUND;
}
- return( ret );
+ return ret;
}
@@ -281,22 +272,21 @@
*
* \return Exit code.
*/
-int main( int argc, const char *argv[] )
+int main(int argc, const char *argv[])
{
-#if defined(MBEDTLS_TEST_HOOKS) && defined (MBEDTLS_ERROR_C)
+#if defined(MBEDTLS_TEST_HOOKS) && defined(MBEDTLS_ERROR_C)
mbedtls_test_hook_error_add = &mbedtls_test_err_add_check;
#endif
int ret = mbedtls_test_platform_setup();
- if( ret != 0 )
- {
- mbedtls_fprintf( stderr,
- "FATAL: Failed to initialize platform - error %d\n",
- ret );
- return( -1 );
+ if (ret != 0) {
+ mbedtls_fprintf(stderr,
+ "FATAL: Failed to initialize platform - error %d\n",
+ ret);
+ return -1;
}
- ret = execute_tests( argc, argv );
+ ret = execute_tests(argc, argv);
mbedtls_test_platform_teardown();
- return( ret );
+ return ret;
}
diff --git a/tests/suites/test_suite_aes.function b/tests/suites/test_suite_aes.function
index 57b8b92..6b92b87 100644
--- a/tests/suites/test_suite_aes.function
+++ b/tests/suites/test_suite_aes.function
@@ -8,107 +8,105 @@
*/
/* BEGIN_CASE */
-void aes_encrypt_ecb( data_t * key_str, data_t * src_str,
- data_t * dst, int setkey_result )
+void aes_encrypt_ecb(data_t *key_str, data_t *src_str,
+ data_t *dst, int setkey_result)
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
- mbedtls_aes_init( &ctx );
+ mbedtls_aes_init(&ctx);
- TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == setkey_result );
- if( setkey_result == 0 )
- {
- TEST_ASSERT( mbedtls_aes_crypt_ecb( &ctx, MBEDTLS_AES_ENCRYPT, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == setkey_result);
+ if (setkey_result == 0) {
+ TEST_ASSERT(mbedtls_aes_crypt_ecb(&ctx, MBEDTLS_AES_ENCRYPT, src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);
}
exit:
- mbedtls_aes_free( &ctx );
+ mbedtls_aes_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void aes_decrypt_ecb( data_t * key_str, data_t * src_str,
- data_t * dst, int setkey_result )
+void aes_decrypt_ecb(data_t *key_str, data_t *src_str,
+ data_t *dst, int setkey_result)
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
- mbedtls_aes_init( &ctx );
+ mbedtls_aes_init(&ctx);
- TEST_ASSERT( mbedtls_aes_setkey_dec( &ctx, key_str->x, key_str->len * 8 ) == setkey_result );
- if( setkey_result == 0 )
- {
- TEST_ASSERT( mbedtls_aes_crypt_ecb( &ctx, MBEDTLS_AES_DECRYPT, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_aes_setkey_dec(&ctx, key_str->x, key_str->len * 8) == setkey_result);
+ if (setkey_result == 0) {
+ TEST_ASSERT(mbedtls_aes_crypt_ecb(&ctx, MBEDTLS_AES_DECRYPT, src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);
}
exit:
- mbedtls_aes_free( &ctx );
+ mbedtls_aes_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void aes_encrypt_cbc( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst,
- int cbc_result )
+void aes_encrypt_cbc(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst,
+ int cbc_result)
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
- mbedtls_aes_init( &ctx );
+ mbedtls_aes_init(&ctx);
- TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == 0 );
- TEST_ASSERT( mbedtls_aes_crypt_cbc( &ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
- if( cbc_result == 0 )
- {
+ TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
+ TEST_ASSERT(mbedtls_aes_crypt_cbc(&ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x,
+ src_str->x, output) == cbc_result);
+ if (cbc_result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
- src_str->len, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
+ src_str->len, dst->len) == 0);
}
exit:
- mbedtls_aes_free( &ctx );
+ mbedtls_aes_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void aes_decrypt_cbc( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst,
- int cbc_result )
+void aes_decrypt_cbc(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst,
+ int cbc_result)
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
- mbedtls_aes_init( &ctx );
+ mbedtls_aes_init(&ctx);
- TEST_ASSERT( mbedtls_aes_setkey_dec( &ctx, key_str->x, key_str->len * 8 ) == 0 );
- TEST_ASSERT( mbedtls_aes_crypt_cbc( &ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
- if( cbc_result == 0)
- {
+ TEST_ASSERT(mbedtls_aes_setkey_dec(&ctx, key_str->x, key_str->len * 8) == 0);
+ TEST_ASSERT(mbedtls_aes_crypt_cbc(&ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x,
+ src_str->x, output) == cbc_result);
+ if (cbc_result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
- src_str->len, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
+ src_str->len, dst->len) == 0);
}
exit:
- mbedtls_aes_free( &ctx );
+ mbedtls_aes_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
-void aes_encrypt_xts( char *hex_key_string, char *hex_data_unit_string,
- char *hex_src_string, char *hex_dst_string )
+void aes_encrypt_xts(char *hex_key_string, char *hex_data_unit_string,
+ char *hex_src_string, char *hex_dst_string)
{
enum { AES_BLOCK_SIZE = 16 };
unsigned char *data_unit = NULL;
@@ -119,40 +117,40 @@
mbedtls_aes_xts_context ctx;
size_t key_len, src_len, dst_len, data_unit_len;
- mbedtls_aes_xts_init( &ctx );
+ mbedtls_aes_xts_init(&ctx);
- data_unit = mbedtls_test_unhexify_alloc( hex_data_unit_string,
- &data_unit_len );
- TEST_ASSERT( data_unit_len == AES_BLOCK_SIZE );
+ data_unit = mbedtls_test_unhexify_alloc(hex_data_unit_string,
+ &data_unit_len);
+ TEST_ASSERT(data_unit_len == AES_BLOCK_SIZE);
- key = mbedtls_test_unhexify_alloc( hex_key_string, &key_len );
- TEST_ASSERT( key_len % 2 == 0 );
+ key = mbedtls_test_unhexify_alloc(hex_key_string, &key_len);
+ TEST_ASSERT(key_len % 2 == 0);
- src = mbedtls_test_unhexify_alloc( hex_src_string, &src_len );
- dst = mbedtls_test_unhexify_alloc( hex_dst_string, &dst_len );
- TEST_ASSERT( src_len == dst_len );
+ src = mbedtls_test_unhexify_alloc(hex_src_string, &src_len);
+ dst = mbedtls_test_unhexify_alloc(hex_dst_string, &dst_len);
+ TEST_ASSERT(src_len == dst_len);
- output = mbedtls_test_zero_alloc( dst_len );
+ output = mbedtls_test_zero_alloc(dst_len);
- TEST_ASSERT( mbedtls_aes_xts_setkey_enc( &ctx, key, key_len * 8 ) == 0 );
- TEST_ASSERT( mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_ENCRYPT, src_len,
- data_unit, src, output ) == 0 );
+ TEST_ASSERT(mbedtls_aes_xts_setkey_enc(&ctx, key, key_len * 8) == 0);
+ TEST_ASSERT(mbedtls_aes_crypt_xts(&ctx, MBEDTLS_AES_ENCRYPT, src_len,
+ data_unit, src, output) == 0);
- TEST_ASSERT( memcmp( output, dst, dst_len ) == 0 );
+ TEST_ASSERT(memcmp(output, dst, dst_len) == 0);
exit:
- mbedtls_aes_xts_free( &ctx );
- mbedtls_free( data_unit );
- mbedtls_free( key );
- mbedtls_free( src );
- mbedtls_free( dst );
- mbedtls_free( output );
+ mbedtls_aes_xts_free(&ctx);
+ mbedtls_free(data_unit);
+ mbedtls_free(key);
+ mbedtls_free(src);
+ mbedtls_free(dst);
+ mbedtls_free(output);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
-void aes_decrypt_xts( char *hex_key_string, char *hex_data_unit_string,
- char *hex_dst_string, char *hex_src_string )
+void aes_decrypt_xts(char *hex_key_string, char *hex_data_unit_string,
+ char *hex_dst_string, char *hex_src_string)
{
enum { AES_BLOCK_SIZE = 16 };
unsigned char *data_unit = NULL;
@@ -163,39 +161,39 @@
mbedtls_aes_xts_context ctx;
size_t key_len, src_len, dst_len, data_unit_len;
- mbedtls_aes_xts_init( &ctx );
+ mbedtls_aes_xts_init(&ctx);
- data_unit = mbedtls_test_unhexify_alloc( hex_data_unit_string,
- &data_unit_len );
- TEST_ASSERT( data_unit_len == AES_BLOCK_SIZE );
+ data_unit = mbedtls_test_unhexify_alloc(hex_data_unit_string,
+ &data_unit_len);
+ TEST_ASSERT(data_unit_len == AES_BLOCK_SIZE);
- key = mbedtls_test_unhexify_alloc( hex_key_string, &key_len );
- TEST_ASSERT( key_len % 2 == 0 );
+ key = mbedtls_test_unhexify_alloc(hex_key_string, &key_len);
+ TEST_ASSERT(key_len % 2 == 0);
- src = mbedtls_test_unhexify_alloc( hex_src_string, &src_len );
- dst = mbedtls_test_unhexify_alloc( hex_dst_string, &dst_len );
- TEST_ASSERT( src_len == dst_len );
+ src = mbedtls_test_unhexify_alloc(hex_src_string, &src_len);
+ dst = mbedtls_test_unhexify_alloc(hex_dst_string, &dst_len);
+ TEST_ASSERT(src_len == dst_len);
- output = mbedtls_test_zero_alloc( dst_len );
+ output = mbedtls_test_zero_alloc(dst_len);
- TEST_ASSERT( mbedtls_aes_xts_setkey_dec( &ctx, key, key_len * 8 ) == 0 );
- TEST_ASSERT( mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_DECRYPT, src_len,
- data_unit, src, output ) == 0 );
+ TEST_ASSERT(mbedtls_aes_xts_setkey_dec(&ctx, key, key_len * 8) == 0);
+ TEST_ASSERT(mbedtls_aes_crypt_xts(&ctx, MBEDTLS_AES_DECRYPT, src_len,
+ data_unit, src, output) == 0);
- TEST_ASSERT( memcmp( output, dst, dst_len ) == 0 );
+ TEST_ASSERT(memcmp(output, dst, dst_len) == 0);
exit:
- mbedtls_aes_xts_free( &ctx );
- mbedtls_free( data_unit );
- mbedtls_free( key );
- mbedtls_free( src );
- mbedtls_free( dst );
- mbedtls_free( output );
+ mbedtls_aes_xts_free(&ctx);
+ mbedtls_free(data_unit);
+ mbedtls_free(key);
+ mbedtls_free(src);
+ mbedtls_free(dst);
+ mbedtls_free(output);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
-void aes_crypt_xts_size( int size, int retval )
+void aes_crypt_xts_size(int size, int retval)
{
mbedtls_aes_xts_context ctx;
const unsigned char src[16] = { 0 };
@@ -203,166 +201,171 @@
unsigned char data_unit[16];
size_t length = size;
- mbedtls_aes_xts_init( &ctx );
- memset( data_unit, 0x00, sizeof( data_unit ) );
+ mbedtls_aes_xts_init(&ctx);
+ memset(data_unit, 0x00, sizeof(data_unit));
/* Valid pointers are passed for builds with MBEDTLS_CHECK_PARAMS, as
* otherwise we wouldn't get to the size check we're interested in. */
- TEST_ASSERT( mbedtls_aes_crypt_xts( &ctx, MBEDTLS_AES_ENCRYPT, length, data_unit, src, output ) == retval );
+ TEST_ASSERT(mbedtls_aes_crypt_xts(&ctx, MBEDTLS_AES_ENCRYPT, length, data_unit, src,
+ output) == retval);
exit:
- mbedtls_aes_xts_free( &ctx );
+ mbedtls_aes_xts_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_XTS */
-void aes_crypt_xts_keysize( int size, int retval )
+void aes_crypt_xts_keysize(int size, int retval)
{
mbedtls_aes_xts_context ctx;
const unsigned char key[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
size_t key_len = size;
- mbedtls_aes_xts_init( &ctx );
+ mbedtls_aes_xts_init(&ctx);
- TEST_ASSERT( mbedtls_aes_xts_setkey_enc( &ctx, key, key_len * 8 ) == retval );
- TEST_ASSERT( mbedtls_aes_xts_setkey_dec( &ctx, key, key_len * 8 ) == retval );
+ TEST_ASSERT(mbedtls_aes_xts_setkey_enc(&ctx, key, key_len * 8) == retval);
+ TEST_ASSERT(mbedtls_aes_xts_setkey_dec(&ctx, key, key_len * 8) == retval);
exit:
- mbedtls_aes_xts_free( &ctx );
+ mbedtls_aes_xts_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
-void aes_encrypt_cfb128( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst )
+void aes_encrypt_cfb128(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst)
{
unsigned char output[100];
mbedtls_aes_context ctx;
size_t iv_offset = 0;
memset(output, 0x00, 100);
- mbedtls_aes_init( &ctx );
+ mbedtls_aes_init(&ctx);
- TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == 0 );
- TEST_ASSERT( mbedtls_aes_crypt_cfb128( &ctx, MBEDTLS_AES_ENCRYPT, 16, &iv_offset, iv_str->x, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
+ TEST_ASSERT(mbedtls_aes_crypt_cfb128(&ctx, MBEDTLS_AES_ENCRYPT, 16, &iv_offset, iv_str->x,
+ src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);
exit:
- mbedtls_aes_free( &ctx );
+ mbedtls_aes_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
-void aes_decrypt_cfb128( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst )
+void aes_decrypt_cfb128(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst)
{
unsigned char output[100];
mbedtls_aes_context ctx;
size_t iv_offset = 0;
memset(output, 0x00, 100);
- mbedtls_aes_init( &ctx );
+ mbedtls_aes_init(&ctx);
- TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == 0 );
- TEST_ASSERT( mbedtls_aes_crypt_cfb128( &ctx, MBEDTLS_AES_DECRYPT, 16, &iv_offset, iv_str->x, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
+ TEST_ASSERT(mbedtls_aes_crypt_cfb128(&ctx, MBEDTLS_AES_DECRYPT, 16, &iv_offset, iv_str->x,
+ src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);
exit:
- mbedtls_aes_free( &ctx );
+ mbedtls_aes_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
-void aes_encrypt_cfb8( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst )
+void aes_encrypt_cfb8(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst)
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
- mbedtls_aes_init( &ctx );
+ mbedtls_aes_init(&ctx);
- TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == 0 );
- TEST_ASSERT( mbedtls_aes_crypt_cfb8( &ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
+ TEST_ASSERT(mbedtls_aes_crypt_cfb8(&ctx, MBEDTLS_AES_ENCRYPT, src_str->len, iv_str->x,
+ src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
- src_str->len, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
+ src_str->len, dst->len) == 0);
exit:
- mbedtls_aes_free( &ctx );
+ mbedtls_aes_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
-void aes_decrypt_cfb8( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst )
+void aes_decrypt_cfb8(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst)
{
unsigned char output[100];
mbedtls_aes_context ctx;
memset(output, 0x00, 100);
- mbedtls_aes_init( &ctx );
+ mbedtls_aes_init(&ctx);
- TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == 0 );
- TEST_ASSERT( mbedtls_aes_crypt_cfb8( &ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x, key_str->len * 8) == 0);
+ TEST_ASSERT(mbedtls_aes_crypt_cfb8(&ctx, MBEDTLS_AES_DECRYPT, src_str->len, iv_str->x,
+ src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
- src_str->len, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
+ src_str->len, dst->len) == 0);
exit:
- mbedtls_aes_free( &ctx );
+ mbedtls_aes_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_OFB */
-void aes_encrypt_ofb( int fragment_size, data_t *key_str,
- data_t *iv_str, data_t *src_str,
- data_t *expected_output )
+void aes_encrypt_ofb(int fragment_size, data_t *key_str,
+ data_t *iv_str, data_t *src_str,
+ data_t *expected_output)
{
unsigned char output[32];
mbedtls_aes_context ctx;
size_t iv_offset = 0;
int in_buffer_len;
- unsigned char* src_str_next;
+ unsigned char *src_str_next;
- memset( output, 0x00, sizeof( output ) );
- mbedtls_aes_init( &ctx );
+ memset(output, 0x00, sizeof(output));
+ mbedtls_aes_init(&ctx);
- TEST_ASSERT( (size_t)fragment_size < sizeof( output ) );
+ TEST_ASSERT((size_t) fragment_size < sizeof(output));
- TEST_ASSERT( mbedtls_aes_setkey_enc( &ctx, key_str->x,
- key_str->len * 8 ) == 0 );
+ TEST_ASSERT(mbedtls_aes_setkey_enc(&ctx, key_str->x,
+ key_str->len * 8) == 0);
in_buffer_len = src_str->len;
src_str_next = src_str->x;
- while( in_buffer_len > 0 )
- {
- TEST_ASSERT( mbedtls_aes_crypt_ofb( &ctx, fragment_size, &iv_offset,
- iv_str->x, src_str_next, output ) == 0 );
+ while (in_buffer_len > 0) {
+ TEST_ASSERT(mbedtls_aes_crypt_ofb(&ctx, fragment_size, &iv_offset,
+ iv_str->x, src_str_next, output) == 0);
- TEST_ASSERT( memcmp( output, expected_output->x, fragment_size ) == 0 );
+ TEST_ASSERT(memcmp(output, expected_output->x, fragment_size) == 0);
in_buffer_len -= fragment_size;
expected_output->x += fragment_size;
src_str_next += fragment_size;
- if( in_buffer_len < fragment_size )
+ if (in_buffer_len < fragment_size) {
fragment_size = in_buffer_len;
+ }
}
exit:
- mbedtls_aes_free( &ctx );
+ mbedtls_aes_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void aes_check_params( )
+void aes_check_params()
{
mbedtls_aes_context aes_ctx;
#if defined(MBEDTLS_CIPHER_MODE_XTS)
@@ -375,185 +378,185 @@
const int valid_mode = MBEDTLS_AES_ENCRYPT;
const int invalid_mode = 42;
- TEST_INVALID_PARAM( mbedtls_aes_init( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_aes_init(NULL));
#if defined(MBEDTLS_CIPHER_MODE_XTS)
- TEST_INVALID_PARAM( mbedtls_aes_xts_init( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_aes_xts_init(NULL));
#endif
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_setkey_enc( NULL, key, 128 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_setkey_enc( &aes_ctx, NULL, 128 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_setkey_enc(NULL, key, 128));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_setkey_enc(&aes_ctx, NULL, 128));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_setkey_dec( NULL, key, 128 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_setkey_dec( &aes_ctx, NULL, 128 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_setkey_dec(NULL, key, 128));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_setkey_dec(&aes_ctx, NULL, 128));
#if defined(MBEDTLS_CIPHER_MODE_XTS)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_xts_setkey_enc( NULL, key, 128 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_xts_setkey_enc( &xts_ctx, NULL, 128 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_xts_setkey_enc(NULL, key, 128));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_xts_setkey_enc(&xts_ctx, NULL, 128));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_xts_setkey_dec( NULL, key, 128 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_xts_setkey_dec( &xts_ctx, NULL, 128 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_xts_setkey_dec(NULL, key, 128));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_xts_setkey_dec(&xts_ctx, NULL, 128));
#endif
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ecb( NULL,
- valid_mode, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ecb( &aes_ctx,
- invalid_mode, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ecb( &aes_ctx,
- valid_mode, NULL, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ecb( &aes_ctx,
- valid_mode, in, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ecb(NULL,
+ valid_mode, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ecb(&aes_ctx,
+ invalid_mode, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ecb(&aes_ctx,
+ valid_mode, NULL, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ecb(&aes_ctx,
+ valid_mode, in, NULL));
#if defined(MBEDTLS_CIPHER_MODE_CBC)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cbc( NULL,
- valid_mode, 16,
- out, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cbc( &aes_ctx,
- invalid_mode, 16,
- out, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cbc( &aes_ctx,
- valid_mode, 16,
- NULL, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cbc( &aes_ctx,
- valid_mode, 16,
- out, NULL, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cbc( &aes_ctx,
- valid_mode, 16,
- out, in, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cbc(NULL,
+ valid_mode, 16,
+ out, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cbc(&aes_ctx,
+ invalid_mode, 16,
+ out, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cbc(&aes_ctx,
+ valid_mode, 16,
+ NULL, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cbc(&aes_ctx,
+ valid_mode, 16,
+ out, NULL, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cbc(&aes_ctx,
+ valid_mode, 16,
+ out, in, NULL));
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_xts( NULL,
- valid_mode, 16,
- in, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_xts( &xts_ctx,
- invalid_mode, 16,
- in, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_xts( &xts_ctx,
- valid_mode, 16,
- NULL, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_xts( &xts_ctx,
- valid_mode, 16,
- in, NULL, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_xts( &xts_ctx,
- valid_mode, 16,
- in, in, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_xts(NULL,
+ valid_mode, 16,
+ in, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_xts(&xts_ctx,
+ invalid_mode, 16,
+ in, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_xts(&xts_ctx,
+ valid_mode, 16,
+ NULL, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_xts(&xts_ctx,
+ valid_mode, 16,
+ in, NULL, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_xts(&xts_ctx,
+ valid_mode, 16,
+ in, in, NULL));
#endif /* MBEDTLS_CIPHER_MODE_XTS */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cfb128( NULL,
- valid_mode, 16,
- &size, out, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cfb128( &aes_ctx,
- invalid_mode, 16,
- &size, out, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cfb128( &aes_ctx,
- valid_mode, 16,
- NULL, out, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cfb128( &aes_ctx,
- valid_mode, 16,
- &size, NULL, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cfb128( &aes_ctx,
- valid_mode, 16,
- &size, out, NULL, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cfb128( &aes_ctx,
- valid_mode, 16,
- &size, out, in, NULL ) );
-
-
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cfb8( NULL,
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cfb128(NULL,
valid_mode, 16,
- out, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cfb8( &aes_ctx,
+ &size, out, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cfb128(&aes_ctx,
invalid_mode, 16,
- out, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cfb8( &aes_ctx,
+ &size, out, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cfb128(&aes_ctx,
valid_mode, 16,
- NULL, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cfb8( &aes_ctx,
+ NULL, out, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cfb128(&aes_ctx,
valid_mode, 16,
- out, NULL, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_cfb8( &aes_ctx,
+ &size, NULL, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cfb128(&aes_ctx,
valid_mode, 16,
- out, in, NULL ) );
+ &size, out, NULL, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cfb128(&aes_ctx,
+ valid_mode, 16,
+ &size, out, in, NULL));
+
+
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cfb8(NULL,
+ valid_mode, 16,
+ out, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cfb8(&aes_ctx,
+ invalid_mode, 16,
+ out, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cfb8(&aes_ctx,
+ valid_mode, 16,
+ NULL, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cfb8(&aes_ctx,
+ valid_mode, 16,
+ out, NULL, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_cfb8(&aes_ctx,
+ valid_mode, 16,
+ out, in, NULL));
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_OFB)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ofb( NULL, 16,
- &size, out, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ofb( &aes_ctx, 16,
- NULL, out, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ofb( &aes_ctx, 16,
- &size, NULL, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ofb( &aes_ctx, 16,
- &size, out, NULL, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ofb( &aes_ctx, 16,
- &size, out, in, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ofb(NULL, 16,
+ &size, out, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ofb(&aes_ctx, 16,
+ NULL, out, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ofb(&aes_ctx, 16,
+ &size, NULL, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ofb(&aes_ctx, 16,
+ &size, out, NULL, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ofb(&aes_ctx, 16,
+ &size, out, in, NULL));
#endif /* MBEDTLS_CIPHER_MODE_OFB */
#if defined(MBEDTLS_CIPHER_MODE_CTR)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ctr( NULL, 16, &size, out,
- out, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ctr( &aes_ctx, 16, NULL, out,
- out, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, NULL,
- out, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
- NULL, in, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
- out, NULL, out ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_AES_BAD_INPUT_DATA,
- mbedtls_aes_crypt_ctr( &aes_ctx, 16, &size, out,
- out, in, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ctr(NULL, 16, &size, out,
+ out, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ctr(&aes_ctx, 16, NULL, out,
+ out, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ctr(&aes_ctx, 16, &size, NULL,
+ out, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ctr(&aes_ctx, 16, &size, out,
+ NULL, in, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ctr(&aes_ctx, 16, &size, out,
+ out, NULL, out));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_AES_BAD_INPUT_DATA,
+ mbedtls_aes_crypt_ctr(&aes_ctx, 16, &size, out,
+ out, in, NULL));
#endif /* MBEDTLS_CIPHER_MODE_CTR */
}
/* END_CASE */
/* BEGIN_CASE */
-void aes_misc_params( )
+void aes_misc_params()
{
#if defined(MBEDTLS_CIPHER_MODE_CBC) || \
defined(MBEDTLS_CIPHER_MODE_XTS) || \
@@ -565,7 +568,7 @@
#if defined(MBEDTLS_CIPHER_MODE_CBC) || \
defined(MBEDTLS_CIPHER_MODE_CFB) || \
defined(MBEDTLS_CIPHER_MODE_OFB)
-mbedtls_aes_context aes_ctx;
+ mbedtls_aes_context aes_ctx;
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
mbedtls_aes_xts_context xts_ctx;
@@ -576,51 +579,51 @@
#endif
/* These calls accept NULL */
- TEST_VALID_PARAM( mbedtls_aes_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_aes_free(NULL));
#if defined(MBEDTLS_CIPHER_MODE_XTS)
- TEST_VALID_PARAM( mbedtls_aes_xts_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_aes_xts_free(NULL));
#endif
#if defined(MBEDTLS_CIPHER_MODE_CBC)
- TEST_ASSERT( mbedtls_aes_crypt_cbc( &aes_ctx, MBEDTLS_AES_ENCRYPT,
- 15,
- out, in, out )
- == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
- TEST_ASSERT( mbedtls_aes_crypt_cbc( &aes_ctx, MBEDTLS_AES_ENCRYPT,
- 17,
- out, in, out )
- == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
+ TEST_ASSERT(mbedtls_aes_crypt_cbc(&aes_ctx, MBEDTLS_AES_ENCRYPT,
+ 15,
+ out, in, out)
+ == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH);
+ TEST_ASSERT(mbedtls_aes_crypt_cbc(&aes_ctx, MBEDTLS_AES_ENCRYPT,
+ 17,
+ out, in, out)
+ == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH);
#endif
#if defined(MBEDTLS_CIPHER_MODE_XTS)
- TEST_ASSERT( mbedtls_aes_crypt_xts( &xts_ctx, MBEDTLS_AES_ENCRYPT,
- 15,
- in, in, out )
- == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
- TEST_ASSERT( mbedtls_aes_crypt_xts( &xts_ctx, MBEDTLS_AES_ENCRYPT,
- (1 << 24) + 1,
- in, in, out )
- == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH );
+ TEST_ASSERT(mbedtls_aes_crypt_xts(&xts_ctx, MBEDTLS_AES_ENCRYPT,
+ 15,
+ in, in, out)
+ == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH);
+ TEST_ASSERT(mbedtls_aes_crypt_xts(&xts_ctx, MBEDTLS_AES_ENCRYPT,
+ (1 << 24) + 1,
+ in, in, out)
+ == MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH);
#endif
#if defined(MBEDTLS_CIPHER_MODE_CFB)
size = 16;
- TEST_ASSERT( mbedtls_aes_crypt_cfb128( &aes_ctx, MBEDTLS_AES_ENCRYPT, 16,
- &size, out, in, out )
- == MBEDTLS_ERR_AES_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_aes_crypt_cfb128(&aes_ctx, MBEDTLS_AES_ENCRYPT, 16,
+ &size, out, in, out)
+ == MBEDTLS_ERR_AES_BAD_INPUT_DATA);
#endif
#if defined(MBEDTLS_CIPHER_MODE_OFB)
size = 16;
- TEST_ASSERT( mbedtls_aes_crypt_ofb( &aes_ctx, 16, &size, out, in, out )
- == MBEDTLS_ERR_AES_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_aes_crypt_ofb(&aes_ctx, 16, &size, out, in, out)
+ == MBEDTLS_ERR_AES_BAD_INPUT_DATA);
#endif
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void aes_selftest( )
+void aes_selftest()
{
- TEST_ASSERT( mbedtls_aes_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_aes_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_arc4.function b/tests/suites/test_suite_arc4.function
index c1e2386..c1b19d5 100644
--- a/tests/suites/test_suite_arc4.function
+++ b/tests/suites/test_suite_arc4.function
@@ -8,30 +8,30 @@
*/
/* BEGIN_CASE */
-void mbedtls_arc4_crypt( data_t * src_str, data_t * key_str, data_t * dst )
+void mbedtls_arc4_crypt(data_t *src_str, data_t *key_str, data_t *dst)
{
unsigned char dst_str[1000];
mbedtls_arc4_context ctx;
memset(dst_str, 0x00, 1000);
- mbedtls_arc4_init( &ctx );
+ mbedtls_arc4_init(&ctx);
mbedtls_arc4_setup(&ctx, key_str->x, key_str->len);
- TEST_ASSERT( mbedtls_arc4_crypt(&ctx, src_str->len,
- src_str->x, dst_str ) == 0 );
+ TEST_ASSERT(mbedtls_arc4_crypt(&ctx, src_str->len,
+ src_str->x, dst_str) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( dst_str, dst->x,
- src_str->len, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(dst_str, dst->x,
+ src_str->len, dst->len) == 0);
exit:
- mbedtls_arc4_free( &ctx );
+ mbedtls_arc4_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void arc4_selftest( )
+void arc4_selftest()
{
- TEST_ASSERT( mbedtls_arc4_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_arc4_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_aria.function b/tests/suites/test_suite_aria.function
index 11af9a3..ed33389 100644
--- a/tests/suites/test_suite_aria.function
+++ b/tests/suites/test_suite_aria.function
@@ -6,9 +6,9 @@
#define ARIA_MAX_DATASIZE 160
/* Maximum sizes of hexified things */
-#define ARIA_MAX_KEY_STR ( 2 * MBEDTLS_ARIA_MAX_KEYSIZE + 1 )
-#define ARIA_BLOCK_STR ( 2 * MBEDTLS_ARIA_BLOCKSIZE + 1 )
-#define ARIA_MAX_DATA_STR ( 2 * ARIA_MAX_DATASIZE + 1 )
+#define ARIA_MAX_KEY_STR (2 * MBEDTLS_ARIA_MAX_KEYSIZE + 1)
+#define ARIA_BLOCK_STR (2 * MBEDTLS_ARIA_BLOCKSIZE + 1)
+#define ARIA_MAX_DATA_STR (2 * ARIA_MAX_DATASIZE + 1)
/* END_HEADER */
/* BEGIN_DEPENDENCIES
@@ -17,14 +17,14 @@
*/
/* BEGIN_CASE */
-void aria_valid_param( )
+void aria_valid_param()
{
- TEST_VALID_PARAM( mbedtls_aria_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_aria_free(NULL));
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void aria_invalid_param( )
+void aria_invalid_param()
{
mbedtls_aria_context ctx;
unsigned char key[128 / 8] = { 0 };
@@ -36,167 +36,167 @@
((void) iv_off);
((void) iv);
- TEST_INVALID_PARAM( mbedtls_aria_init( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_aria_init(NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_setkey_enc( NULL, key,
- sizeof( key ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_setkey_enc( &ctx, NULL,
- sizeof( key ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_setkey_enc(NULL, key,
+ sizeof(key)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_setkey_enc(&ctx, NULL,
+ sizeof(key)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_setkey_dec( NULL, key,
- sizeof( key ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_setkey_dec( &ctx, NULL,
- sizeof( key ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_setkey_dec(NULL, key,
+ sizeof(key)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_setkey_dec(&ctx, NULL,
+ sizeof(key)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_ecb( NULL, input, output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_ecb( &ctx, NULL, output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_ecb( &ctx, input, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_ecb(NULL, input, output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_ecb(&ctx, NULL, output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_ecb(&ctx, input, NULL));
#if defined(MBEDTLS_CIPHER_MODE_CBC)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_cbc( NULL,
- MBEDTLS_ARIA_ENCRYPT,
- sizeof( input ),
- iv,
- input,
- output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_cbc( &ctx,
- 42 /* invalid mode */,
- sizeof( input ),
- iv,
- input,
- output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_cbc( &ctx,
- MBEDTLS_ARIA_ENCRYPT,
- sizeof( input ),
- NULL,
- input,
- output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_cbc( &ctx,
- MBEDTLS_ARIA_ENCRYPT,
- sizeof( input ),
- iv,
- NULL,
- output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_cbc( &ctx,
- MBEDTLS_ARIA_ENCRYPT,
- sizeof( input ),
- iv,
- input,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_cbc(NULL,
+ MBEDTLS_ARIA_ENCRYPT,
+ sizeof(input),
+ iv,
+ input,
+ output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_cbc(&ctx,
+ 42 /* invalid mode */,
+ sizeof(input),
+ iv,
+ input,
+ output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_cbc(&ctx,
+ MBEDTLS_ARIA_ENCRYPT,
+ sizeof(input),
+ NULL,
+ input,
+ output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_cbc(&ctx,
+ MBEDTLS_ARIA_ENCRYPT,
+ sizeof(input),
+ iv,
+ NULL,
+ output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_cbc(&ctx,
+ MBEDTLS_ARIA_ENCRYPT,
+ sizeof(input),
+ iv,
+ input,
+ NULL));
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_cfb128( NULL,
- MBEDTLS_ARIA_ENCRYPT,
- sizeof( input ),
- &iv_off,
- iv,
- input,
- output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_cfb128( &ctx,
- 42, /* invalid mode */
- sizeof( input ),
- &iv_off,
- iv,
- input,
- output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_cfb128( &ctx,
- MBEDTLS_ARIA_ENCRYPT,
- sizeof( input ),
- NULL,
- iv,
- input,
- output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_cfb128( &ctx,
- MBEDTLS_ARIA_ENCRYPT,
- sizeof( input ),
- &iv_off,
- NULL,
- input,
- output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_cfb128( &ctx,
- MBEDTLS_ARIA_ENCRYPT,
- sizeof( input ),
- &iv_off,
- iv,
- NULL,
- output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_cfb128( &ctx,
- MBEDTLS_ARIA_ENCRYPT,
- sizeof( input ),
- &iv_off,
- iv,
- input,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_cfb128(NULL,
+ MBEDTLS_ARIA_ENCRYPT,
+ sizeof(input),
+ &iv_off,
+ iv,
+ input,
+ output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_cfb128(&ctx,
+ 42, /* invalid mode */
+ sizeof(input),
+ &iv_off,
+ iv,
+ input,
+ output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_cfb128(&ctx,
+ MBEDTLS_ARIA_ENCRYPT,
+ sizeof(input),
+ NULL,
+ iv,
+ input,
+ output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_cfb128(&ctx,
+ MBEDTLS_ARIA_ENCRYPT,
+ sizeof(input),
+ &iv_off,
+ NULL,
+ input,
+ output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_cfb128(&ctx,
+ MBEDTLS_ARIA_ENCRYPT,
+ sizeof(input),
+ &iv_off,
+ iv,
+ NULL,
+ output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_cfb128(&ctx,
+ MBEDTLS_ARIA_ENCRYPT,
+ sizeof(input),
+ &iv_off,
+ iv,
+ input,
+ NULL));
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_CTR)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_ctr( NULL,
- sizeof( input ),
- &iv_off,
- iv,
- iv,
- input,
- output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_ctr( &ctx,
- sizeof( input ),
- NULL,
- iv,
- iv,
- input,
- output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_ctr( &ctx,
- sizeof( input ),
- &iv_off,
- NULL,
- iv,
- input,
- output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_ctr( &ctx,
- sizeof( input ),
- &iv_off,
- iv,
- NULL,
- input,
- output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_ctr( &ctx,
- sizeof( input ),
- &iv_off,
- iv,
- iv,
- NULL,
- output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
- mbedtls_aria_crypt_ctr( &ctx,
- sizeof( input ),
- &iv_off,
- iv,
- iv,
- input,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_ctr(NULL,
+ sizeof(input),
+ &iv_off,
+ iv,
+ iv,
+ input,
+ output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_ctr(&ctx,
+ sizeof(input),
+ NULL,
+ iv,
+ iv,
+ input,
+ output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_ctr(&ctx,
+ sizeof(input),
+ &iv_off,
+ NULL,
+ iv,
+ input,
+ output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_ctr(&ctx,
+ sizeof(input),
+ &iv_off,
+ iv,
+ NULL,
+ input,
+ output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_ctr(&ctx,
+ sizeof(input),
+ &iv_off,
+ iv,
+ iv,
+ NULL,
+ output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ARIA_BAD_INPUT_DATA,
+ mbedtls_aria_crypt_ctr(&ctx,
+ sizeof(input),
+ &iv_off,
+ iv,
+ iv,
+ input,
+ NULL));
#endif /* MBEDTLS_CIPHER_MODE_CTR */
exit:
@@ -206,224 +206,218 @@
/* END_CASE */
/* BEGIN_CASE */
-void aria_encrypt_ecb( data_t *key_str, data_t *src_str,
- data_t *expected_output, int setkey_result )
+void aria_encrypt_ecb(data_t *key_str, data_t *src_str,
+ data_t *expected_output, int setkey_result)
{
unsigned char output[ARIA_MAX_DATASIZE];
mbedtls_aria_context ctx;
size_t i;
- memset( output, 0x00, sizeof( output ) );
- mbedtls_aria_init( &ctx );
+ memset(output, 0x00, sizeof(output));
+ mbedtls_aria_init(&ctx);
- TEST_ASSERT( mbedtls_aria_setkey_enc( &ctx, key_str->x, key_str->len * 8 )
- == setkey_result );
- if( setkey_result == 0 )
- {
- for( i = 0; i < src_str->len; i += MBEDTLS_ARIA_BLOCKSIZE )
- {
- TEST_ASSERT( mbedtls_aria_crypt_ecb( &ctx, src_str->x + i,
- output + i ) == 0 );
+ TEST_ASSERT(mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8)
+ == setkey_result);
+ if (setkey_result == 0) {
+ for (i = 0; i < src_str->len; i += MBEDTLS_ARIA_BLOCKSIZE) {
+ TEST_ASSERT(mbedtls_aria_crypt_ecb(&ctx, src_str->x + i,
+ output + i) == 0);
}
- ASSERT_COMPARE( output, expected_output->len,
- expected_output->x, expected_output->len );
+ ASSERT_COMPARE(output, expected_output->len,
+ expected_output->x, expected_output->len);
}
exit:
- mbedtls_aria_free( &ctx );
+ mbedtls_aria_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void aria_decrypt_ecb( data_t *key_str, data_t *src_str,
- data_t *expected_output, int setkey_result )
+void aria_decrypt_ecb(data_t *key_str, data_t *src_str,
+ data_t *expected_output, int setkey_result)
{
unsigned char output[ARIA_MAX_DATASIZE];
mbedtls_aria_context ctx;
size_t i;
- memset( output, 0x00, sizeof( output ) );
- mbedtls_aria_init( &ctx );
+ memset(output, 0x00, sizeof(output));
+ mbedtls_aria_init(&ctx);
- TEST_ASSERT( mbedtls_aria_setkey_dec( &ctx, key_str->x, key_str->len * 8 )
- == setkey_result );
- if( setkey_result == 0 )
- {
- for( i = 0; i < src_str->len; i += MBEDTLS_ARIA_BLOCKSIZE )
- {
- TEST_ASSERT( mbedtls_aria_crypt_ecb( &ctx, src_str->x + i,
- output + i ) == 0 );
+ TEST_ASSERT(mbedtls_aria_setkey_dec(&ctx, key_str->x, key_str->len * 8)
+ == setkey_result);
+ if (setkey_result == 0) {
+ for (i = 0; i < src_str->len; i += MBEDTLS_ARIA_BLOCKSIZE) {
+ TEST_ASSERT(mbedtls_aria_crypt_ecb(&ctx, src_str->x + i,
+ output + i) == 0);
}
- ASSERT_COMPARE( output, expected_output->len,
- expected_output->x, expected_output->len );
+ ASSERT_COMPARE(output, expected_output->len,
+ expected_output->x, expected_output->len);
}
exit:
- mbedtls_aria_free( &ctx );
+ mbedtls_aria_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void aria_encrypt_cbc( data_t *key_str, data_t *iv_str,
- data_t *src_str, data_t *expected_output,
- int cbc_result )
+void aria_encrypt_cbc(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *expected_output,
+ int cbc_result)
{
unsigned char output[ARIA_MAX_DATASIZE];
mbedtls_aria_context ctx;
- memset( output, 0x00, sizeof( output ) );
- mbedtls_aria_init( &ctx );
+ memset(output, 0x00, sizeof(output));
+ mbedtls_aria_init(&ctx);
- mbedtls_aria_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
- TEST_ASSERT( mbedtls_aria_crypt_cbc( &ctx, MBEDTLS_ARIA_ENCRYPT,
- src_str->len, iv_str->x, src_str->x,
- output ) == cbc_result );
- if( cbc_result == 0 )
- {
- ASSERT_COMPARE( output, expected_output->len,
- expected_output->x, expected_output->len );
+ mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8);
+ TEST_ASSERT(mbedtls_aria_crypt_cbc(&ctx, MBEDTLS_ARIA_ENCRYPT,
+ src_str->len, iv_str->x, src_str->x,
+ output) == cbc_result);
+ if (cbc_result == 0) {
+ ASSERT_COMPARE(output, expected_output->len,
+ expected_output->x, expected_output->len);
}
exit:
- mbedtls_aria_free( &ctx );
+ mbedtls_aria_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void aria_decrypt_cbc( data_t *key_str, data_t *iv_str,
- data_t *src_str, data_t *expected_output,
- int cbc_result )
+void aria_decrypt_cbc(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *expected_output,
+ int cbc_result)
{
unsigned char output[ARIA_MAX_DATASIZE];
mbedtls_aria_context ctx;
- memset( output, 0x00, sizeof( output ) );
- mbedtls_aria_init( &ctx );
+ memset(output, 0x00, sizeof(output));
+ mbedtls_aria_init(&ctx);
- mbedtls_aria_setkey_dec( &ctx, key_str->x, key_str->len * 8 );
- TEST_ASSERT( mbedtls_aria_crypt_cbc( &ctx, MBEDTLS_ARIA_DECRYPT,
- src_str->len, iv_str->x, src_str->x,
- output ) == cbc_result );
- if( cbc_result == 0 )
- {
- ASSERT_COMPARE( output, expected_output->len,
- expected_output->x, expected_output->len );
+ mbedtls_aria_setkey_dec(&ctx, key_str->x, key_str->len * 8);
+ TEST_ASSERT(mbedtls_aria_crypt_cbc(&ctx, MBEDTLS_ARIA_DECRYPT,
+ src_str->len, iv_str->x, src_str->x,
+ output) == cbc_result);
+ if (cbc_result == 0) {
+ ASSERT_COMPARE(output, expected_output->len,
+ expected_output->x, expected_output->len);
}
exit:
- mbedtls_aria_free( &ctx );
+ mbedtls_aria_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
-void aria_encrypt_cfb128( data_t *key_str, data_t *iv_str,
- data_t *src_str, data_t *expected_output,
- int result )
+void aria_encrypt_cfb128(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *expected_output,
+ int result)
{
unsigned char output[ARIA_MAX_DATASIZE];
mbedtls_aria_context ctx;
size_t iv_offset = 0;
- memset( output, 0x00, sizeof( output ) );
- mbedtls_aria_init( &ctx );
+ memset(output, 0x00, sizeof(output));
+ mbedtls_aria_init(&ctx);
- mbedtls_aria_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
- TEST_ASSERT( mbedtls_aria_crypt_cfb128( &ctx, MBEDTLS_ARIA_ENCRYPT,
- src_str->len, &iv_offset,
- iv_str->x, src_str->x, output )
- == result );
+ mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8);
+ TEST_ASSERT(mbedtls_aria_crypt_cfb128(&ctx, MBEDTLS_ARIA_ENCRYPT,
+ src_str->len, &iv_offset,
+ iv_str->x, src_str->x, output)
+ == result);
- ASSERT_COMPARE( output, expected_output->len,
- expected_output->x, expected_output->len );
+ ASSERT_COMPARE(output, expected_output->len,
+ expected_output->x, expected_output->len);
exit:
- mbedtls_aria_free( &ctx );
+ mbedtls_aria_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
-void aria_decrypt_cfb128( data_t *key_str, data_t *iv_str,
- data_t *src_str, data_t *expected_output,
- int result )
+void aria_decrypt_cfb128(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *expected_output,
+ int result)
{
unsigned char output[ARIA_MAX_DATASIZE];
mbedtls_aria_context ctx;
size_t iv_offset = 0;
- memset( output, 0x00, sizeof( output ) );
- mbedtls_aria_init( &ctx );
+ memset(output, 0x00, sizeof(output));
+ mbedtls_aria_init(&ctx);
- mbedtls_aria_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
- TEST_ASSERT( mbedtls_aria_crypt_cfb128( &ctx, MBEDTLS_ARIA_DECRYPT,
- src_str->len, &iv_offset,
- iv_str->x, src_str->x, output )
- == result );
+ mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8);
+ TEST_ASSERT(mbedtls_aria_crypt_cfb128(&ctx, MBEDTLS_ARIA_DECRYPT,
+ src_str->len, &iv_offset,
+ iv_str->x, src_str->x, output)
+ == result);
- ASSERT_COMPARE( output, expected_output->len,
- expected_output->x, expected_output->len );
+ ASSERT_COMPARE(output, expected_output->len,
+ expected_output->x, expected_output->len);
exit:
- mbedtls_aria_free( &ctx );
+ mbedtls_aria_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CTR */
-void aria_encrypt_ctr( data_t *key_str, data_t *iv_str,
- data_t *src_str, data_t *expected_output,
- int result )
+void aria_encrypt_ctr(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *expected_output,
+ int result)
{
unsigned char output[ARIA_MAX_DATASIZE];
unsigned char blk[MBEDTLS_ARIA_BLOCKSIZE];
mbedtls_aria_context ctx;
size_t iv_offset = 0;
- memset( output, 0x00, sizeof( output ) );
- mbedtls_aria_init( &ctx );
+ memset(output, 0x00, sizeof(output));
+ mbedtls_aria_init(&ctx);
- mbedtls_aria_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
- TEST_ASSERT( mbedtls_aria_crypt_ctr( &ctx, src_str->len, &iv_offset,
- iv_str->x, blk, src_str->x, output )
- == result );
+ mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8);
+ TEST_ASSERT(mbedtls_aria_crypt_ctr(&ctx, src_str->len, &iv_offset,
+ iv_str->x, blk, src_str->x, output)
+ == result);
- ASSERT_COMPARE( output, expected_output->len,
- expected_output->x, expected_output->len );
+ ASSERT_COMPARE(output, expected_output->len,
+ expected_output->x, expected_output->len);
exit:
- mbedtls_aria_free( &ctx );
+ mbedtls_aria_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CTR */
-void aria_decrypt_ctr( data_t *key_str, data_t *iv_str,
- data_t *src_str, data_t *expected_output,
- int result )
+void aria_decrypt_ctr(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *expected_output,
+ int result)
{
unsigned char output[ARIA_MAX_DATASIZE];
unsigned char blk[MBEDTLS_ARIA_BLOCKSIZE];
mbedtls_aria_context ctx;
size_t iv_offset = 0;
- memset( output, 0x00, sizeof( output ) );
- mbedtls_aria_init( &ctx );
+ memset(output, 0x00, sizeof(output));
+ mbedtls_aria_init(&ctx);
- mbedtls_aria_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
- TEST_ASSERT( mbedtls_aria_crypt_ctr( &ctx, src_str->len, &iv_offset,
- iv_str->x, blk, src_str->x, output )
- == result );
+ mbedtls_aria_setkey_enc(&ctx, key_str->x, key_str->len * 8);
+ TEST_ASSERT(mbedtls_aria_crypt_ctr(&ctx, src_str->len, &iv_offset,
+ iv_str->x, blk, src_str->x, output)
+ == result);
- ASSERT_COMPARE( output, expected_output->len,
- expected_output->x, expected_output->len );
+ ASSERT_COMPARE(output, expected_output->len,
+ expected_output->x, expected_output->len);
exit:
- mbedtls_aria_free( &ctx );
+ mbedtls_aria_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
void aria_selftest()
{
- TEST_ASSERT( mbedtls_aria_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_aria_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_asn1parse.function b/tests/suites/test_suite_asn1parse.function
index 4cc0f17..7c546c1 100644
--- a/tests/suites/test_suite_asn1parse.function
+++ b/tests/suites/test_suite_asn1parse.function
@@ -16,8 +16,8 @@
* should not be checked. */
#define UNPREDICTABLE_RESULT 0x5552
-static int nested_parse( unsigned char **const p,
- const unsigned char *const end )
+static int nested_parse(unsigned char **const p,
+ const unsigned char *const end)
{
int ret;
size_t len = 0;
@@ -28,31 +28,32 @@
/* First get the length, skipping over the tag. */
content_start = start + 1;
- ret = mbedtls_asn1_get_len( &content_start, end, &len );
- TEST_ASSERT( content_start <= end );
- if( ret != 0 )
- return( ret );
+ ret = mbedtls_asn1_get_len(&content_start, end, &len);
+ TEST_ASSERT(content_start <= end);
+ if (ret != 0) {
+ return ret;
+ }
/* Since we have a valid element start (tag and length), retrieve and
* check the tag. */
tag = start[0];
- TEST_EQUAL( mbedtls_asn1_get_tag( p, end, &len2, tag ^ 1 ),
- MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
+ TEST_EQUAL(mbedtls_asn1_get_tag(p, end, &len2, tag ^ 1),
+ MBEDTLS_ERR_ASN1_UNEXPECTED_TAG);
*p = start;
- TEST_EQUAL( mbedtls_asn1_get_tag( p, end, &len2, tag ), 0 );
- TEST_EQUAL( len, len2 );
- TEST_ASSERT( *p == content_start );
+ TEST_EQUAL(mbedtls_asn1_get_tag(p, end, &len2, tag), 0);
+ TEST_EQUAL(len, len2);
+ TEST_ASSERT(*p == content_start);
*p = content_start;
- switch( tag & 0x1f )
- {
+ switch (tag & 0x1f) {
case MBEDTLS_ASN1_BOOLEAN:
{
int val = -257;
*p = start;
- ret = mbedtls_asn1_get_bool( p, end, &val );
- if( ret == 0 )
- TEST_ASSERT( val == 0 || val == 1 );
+ ret = mbedtls_asn1_get_bool(p, end, &val);
+ if (ret == 0) {
+ TEST_ASSERT(val == 0 || val == 1);
+ }
break;
}
@@ -60,23 +61,22 @@
{
#if defined(MBEDTLS_BIGNUM_C)
mbedtls_mpi mpi;
- mbedtls_mpi_init( &mpi );
+ mbedtls_mpi_init(&mpi);
*p = start;
- ret = mbedtls_asn1_get_mpi( p, end, &mpi );
- mbedtls_mpi_free( &mpi );
+ ret = mbedtls_asn1_get_mpi(p, end, &mpi);
+ mbedtls_mpi_free(&mpi);
#else
*p = start + 1;
- ret = mbedtls_asn1_get_len( p, end, &len );
+ ret = mbedtls_asn1_get_len(p, end, &len);
*p += len;
#endif
/* If we're sure that the number fits in an int, also
* call mbedtls_asn1_get_int(). */
- if( ret == 0 && len < sizeof( int ) )
- {
+ if (ret == 0 && len < sizeof(int)) {
int val = -257;
unsigned char *q = start;
- ret = mbedtls_asn1_get_int( &q, end, &val );
- TEST_ASSERT( *p == q );
+ ret = mbedtls_asn1_get_int(&q, end, &val);
+ TEST_ASSERT(*p == q);
}
break;
}
@@ -85,14 +85,15 @@
{
mbedtls_asn1_bitstring bs;
*p = start;
- ret = mbedtls_asn1_get_bitstring( p, end, &bs );
+ ret = mbedtls_asn1_get_bitstring(p, end, &bs);
break;
}
case MBEDTLS_ASN1_SEQUENCE:
{
- while( *p <= end && *p < content_start + len && ret == 0 )
- ret = nested_parse( p, content_start + len );
+ while (*p <= end && *p < content_start + len && ret == 0) {
+ ret = nested_parse(p, content_start + len);
+ }
break;
}
@@ -111,18 +112,18 @@
default:
/* No further testing implemented for this tag. */
*p += len;
- return( 0 );
+ return 0;
}
- TEST_ASSERT( *p <= end );
- return( ret );
+ TEST_ASSERT(*p <= end);
+ return ret;
exit:
- return( ERR_PARSE_INCONSISTENCY );
+ return ERR_PARSE_INCONSISTENCY;
}
-int get_len_step( const data_t *input, size_t buffer_size,
- size_t actual_length )
+int get_len_step(const data_t *input, size_t buffer_size,
+ size_t actual_length)
{
unsigned char *buf = NULL;
unsigned char *p = NULL;
@@ -130,53 +131,43 @@
size_t parsed_length;
int ret;
- mbedtls_test_set_step( buffer_size );
+ 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. */
- if( buffer_size == 0 )
- {
- ASSERT_ALLOC( buf, 1 );
+ if (buffer_size == 0) {
+ ASSERT_ALLOC(buf, 1);
end = buf + 1;
p = end;
- }
- else
- {
- ASSERT_ALLOC_WEAK( buf, buffer_size );
- if( buffer_size > input->len )
- {
- memcpy( buf, input->x, input->len );
- memset( buf + input->len, 'A', buffer_size - input->len );
- }
- else
- {
- memcpy( buf, input->x, buffer_size );
+ } else {
+ ASSERT_ALLOC_WEAK(buf, buffer_size);
+ if (buffer_size > input->len) {
+ memcpy(buf, input->x, input->len);
+ memset(buf + input->len, 'A', buffer_size - input->len);
+ } else {
+ memcpy(buf, input->x, buffer_size);
}
p = buf;
end = buf + buffer_size;
}
- ret = mbedtls_asn1_get_len( &p, end, &parsed_length );
+ ret = mbedtls_asn1_get_len(&p, end, &parsed_length);
- if( buffer_size >= input->len + actual_length )
- {
- TEST_EQUAL( ret, 0 );
- TEST_ASSERT( p == buf + input->len );
- TEST_EQUAL( parsed_length, actual_length );
+ if (buffer_size >= input->len + actual_length) {
+ TEST_EQUAL(ret, 0);
+ TEST_ASSERT(p == buf + input->len);
+ TEST_EQUAL(parsed_length, actual_length);
+ } else {
+ TEST_EQUAL(ret, MBEDTLS_ERR_ASN1_OUT_OF_DATA);
}
- else
- {
- TEST_EQUAL( ret, MBEDTLS_ERR_ASN1_OUT_OF_DATA );
- }
- mbedtls_free( buf );
- return( 1 );
+ mbedtls_free(buf);
+ return 1;
exit:
- mbedtls_free( buf );
- return( 0 );
+ mbedtls_free(buf);
+ return 0;
}
-typedef struct
-{
+typedef struct {
const unsigned char *input_start;
const char *description;
} traverse_state_t;
@@ -188,38 +179,40 @@
#define RET_TRAVERSE_ERROR 2
-static int traverse_callback( void *ctx, int tag,
- unsigned char *content, size_t len )
+static int traverse_callback(void *ctx, int tag,
+ unsigned char *content, size_t len)
{
traverse_state_t *state = ctx;
size_t offset;
const char *rest = state->description;
unsigned long n;
- TEST_ASSERT( content > state->input_start );
+ TEST_ASSERT(content > state->input_start);
offset = content - state->input_start;
- mbedtls_test_set_step( offset );
+ mbedtls_test_set_step(offset);
- if( *rest == 0 )
- return( RET_TRAVERSE_STOP );
- n = strtoul( rest, (char **) &rest, 0 );
- TEST_EQUAL( n, offset );
- TEST_EQUAL( *rest, ',' );
+ if (*rest == 0) {
+ return RET_TRAVERSE_STOP;
+ }
+ n = strtoul(rest, (char **) &rest, 0);
+ TEST_EQUAL(n, offset);
+ TEST_EQUAL(*rest, ',');
++rest;
- n = strtoul( rest, (char **) &rest, 0 );
- TEST_EQUAL( n, (unsigned) tag );
- TEST_EQUAL( *rest, ',' );
+ n = strtoul(rest, (char **) &rest, 0);
+ TEST_EQUAL(n, (unsigned) tag);
+ TEST_EQUAL(*rest, ',');
++rest;
- n = strtoul( rest, (char **) &rest, 0 );
- TEST_EQUAL( n, len );
- if( *rest == ',' )
+ n = strtoul(rest, (char **) &rest, 0);
+ TEST_EQUAL(n, len);
+ if (*rest == ',') {
++rest;
+ }
state->description = rest;
- return( 0 );
+ return 0;
exit:
- return( RET_TRAVERSE_ERROR );
+ return RET_TRAVERSE_ERROR;
}
/* END_HEADER */
@@ -230,9 +223,9 @@
*/
/* BEGIN_CASE */
-void parse_prefixes( const data_t *input,
- int full_result,
- int overfull_result )
+void parse_prefixes(const data_t *input,
+ int full_result,
+ int overfull_result)
{
/* full_result: expected result from parsing the given string. */
/* overfull_result: expected_result from parsing the given string plus
@@ -250,45 +243,42 @@
* we wouldn't know what to parse the input as.
* Also test the input followed by an extra byte.
*/
- for( buffer_size = 1; buffer_size <= input->len + 1; buffer_size++ )
- {
- mbedtls_test_set_step( buffer_size );
+ for (buffer_size = 1; buffer_size <= input->len + 1; buffer_size++) {
+ 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. */
- ASSERT_ALLOC( buf, buffer_size );
- memcpy( buf, input->x, buffer_size );
+ ASSERT_ALLOC(buf, buffer_size);
+ memcpy(buf, input->x, buffer_size);
p = buf;
- ret = nested_parse( &p, buf + buffer_size );
+ ret = nested_parse(&p, buf + buffer_size);
- if( ret == ERR_PARSE_INCONSISTENCY )
+ if (ret == ERR_PARSE_INCONSISTENCY) {
goto exit;
- if( buffer_size < input->len )
- {
- TEST_EQUAL( ret, MBEDTLS_ERR_ASN1_OUT_OF_DATA );
}
- else if( buffer_size == input->len )
- {
- TEST_EQUAL( ret, full_result );
+ if (buffer_size < input->len) {
+ TEST_EQUAL(ret, MBEDTLS_ERR_ASN1_OUT_OF_DATA);
+ } else if (buffer_size == input->len) {
+ TEST_EQUAL(ret, full_result);
+ } else { /* ( buffer_size > input->len ) */
+ if (overfull_result != UNPREDICTABLE_RESULT) {
+ TEST_EQUAL(ret, overfull_result);
+ }
}
- else /* ( buffer_size > input->len ) */
- {
- if( overfull_result != UNPREDICTABLE_RESULT )
- TEST_EQUAL( ret, overfull_result );
+ if (ret == 0) {
+ TEST_ASSERT(p == buf + input->len);
}
- if( ret == 0 )
- TEST_ASSERT( p == buf + input->len );
- mbedtls_free( buf );
+ mbedtls_free(buf);
buf = NULL;
}
exit:
- mbedtls_free( buf );
+ mbedtls_free(buf);
}
/* END_CASE */
/* BEGIN_CASE */
-void get_len( const data_t *input, int actual_length_arg )
+void get_len(const data_t *input, int actual_length_arg)
{
size_t actual_length = actual_length_arg;
size_t buffer_size;
@@ -299,37 +289,38 @@
* the payload is truncated more than one byte away from either end,
* and we only test the empty string on a 1-byte input.
*/
- for( buffer_size = 1; buffer_size <= input->len + 1; buffer_size++ )
- {
- if( ! get_len_step( input, buffer_size, actual_length ) )
+ for (buffer_size = 1; buffer_size <= input->len + 1; buffer_size++) {
+ if (!get_len_step(input, buffer_size, actual_length)) {
goto exit;
+ }
}
- if( ! get_len_step( input, input->len + actual_length - 1, actual_length ) )
+ if (!get_len_step(input, input->len + actual_length - 1, actual_length)) {
goto exit;
- if( ! get_len_step( input, input->len + actual_length, actual_length ) )
+ }
+ if (!get_len_step(input, input->len + actual_length, actual_length)) {
goto exit;
+ }
}
/* END_CASE */
/* BEGIN_CASE */
-void get_boolean( const data_t *input,
- int expected_value, int expected_result )
+void get_boolean(const data_t *input,
+ int expected_value, int expected_result)
{
unsigned char *p = input->x;
int val;
int ret;
- ret = mbedtls_asn1_get_bool( &p, input->x + input->len, &val );
- TEST_EQUAL( ret, expected_result );
- if( expected_result == 0 )
- {
- TEST_EQUAL( val, expected_value );
- TEST_ASSERT( p == input->x + input->len );
+ ret = mbedtls_asn1_get_bool(&p, input->x + input->len, &val);
+ TEST_EQUAL(ret, expected_result);
+ if (expected_result == 0) {
+ TEST_EQUAL(val, expected_value);
+ TEST_ASSERT(p == input->x + input->len);
}
}
/* END_CASE */
/* BEGIN_CASE */
-void empty_integer( const data_t *input )
+void empty_integer(const data_t *input)
{
unsigned char *p;
#if defined(MBEDTLS_BIGNUM_C)
@@ -338,34 +329,34 @@
int val;
#if defined(MBEDTLS_BIGNUM_C)
- mbedtls_mpi_init( & actual_mpi );
+ mbedtls_mpi_init(&actual_mpi);
#endif
/* An INTEGER with no content is not valid. */
p = input->x;
- TEST_EQUAL( mbedtls_asn1_get_int( &p, input->x + input->len, &val ),
- MBEDTLS_ERR_ASN1_INVALID_LENGTH );
+ TEST_EQUAL(mbedtls_asn1_get_int(&p, input->x + input->len, &val),
+ MBEDTLS_ERR_ASN1_INVALID_LENGTH);
#if defined(MBEDTLS_BIGNUM_C)
/* INTEGERs are sometimes abused as bitstrings, so the library accepts
* an INTEGER with empty content and gives it the value 0. */
p = input->x;
- TEST_EQUAL( mbedtls_asn1_get_mpi( &p, input->x + input->len, &actual_mpi ),
- 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &actual_mpi, 0 ), 0 );
+ TEST_EQUAL(mbedtls_asn1_get_mpi(&p, input->x + input->len, &actual_mpi),
+ 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&actual_mpi, 0), 0);
#endif
exit:
#if defined(MBEDTLS_BIGNUM_C)
- mbedtls_mpi_free( &actual_mpi );
+ mbedtls_mpi_free(&actual_mpi);
#endif
- /*empty cleanup in some configurations*/ ;
+ /*empty cleanup in some configurations*/;
}
/* END_CASE */
/* BEGIN_CASE */
-void get_integer( const data_t *input,
- const char *expected_hex, int expected_result )
+void get_integer(const data_t *input,
+ const char *expected_hex, int expected_result)
{
unsigned char *p;
#if defined(MBEDTLS_BIGNUM_C)
@@ -380,26 +371,24 @@
int ret;
#if defined(MBEDTLS_BIGNUM_C)
- mbedtls_mpi_init( &expected_mpi );
- mbedtls_mpi_init( &actual_mpi );
- mbedtls_mpi_init( &complement );
+ mbedtls_mpi_init(&expected_mpi);
+ mbedtls_mpi_init(&actual_mpi);
+ mbedtls_mpi_init(&complement);
#endif
errno = 0;
- expected_value = strtol( expected_hex, NULL, 16 );
- if( expected_result == 0 &&
- ( errno == ERANGE
+ expected_value = strtol(expected_hex, NULL, 16);
+ if (expected_result == 0 &&
+ (errno == ERANGE
#if LONG_MAX > INT_MAX
- || expected_value > INT_MAX || expected_value < INT_MIN
+ || expected_value > INT_MAX || expected_value < INT_MIN
#endif
- ) )
- {
+ )) {
/* The library returns the dubious error code INVALID_LENGTH
* for integers that are out of range. */
expected_result_for_int = MBEDTLS_ERR_ASN1_INVALID_LENGTH;
}
- if( expected_result == 0 && expected_value < 0 )
- {
+ if (expected_result == 0 && expected_value < 0) {
/* The library does not support negative INTEGERs and
* returns the dubious error code INVALID_LENGTH.
* Test that we preserve the historical behavior. If we
@@ -408,34 +397,28 @@
}
p = input->x;
- ret = mbedtls_asn1_get_int( &p, input->x + input->len, &val );
- TEST_EQUAL( ret, expected_result_for_int );
- if( ret == 0 )
- {
- TEST_EQUAL( val, expected_value );
- TEST_ASSERT( p == input->x + input->len );
+ ret = mbedtls_asn1_get_int(&p, input->x + input->len, &val);
+ TEST_EQUAL(ret, expected_result_for_int);
+ if (ret == 0) {
+ TEST_EQUAL(val, expected_value);
+ TEST_ASSERT(p == input->x + input->len);
}
#if defined(MBEDTLS_BIGNUM_C)
- ret = mbedtls_test_read_mpi( &expected_mpi, expected_hex );
- TEST_ASSERT( ret == 0 || ret == MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
- if( ret == MBEDTLS_ERR_MPI_BAD_INPUT_DATA )
- {
+ ret = mbedtls_test_read_mpi(&expected_mpi, expected_hex);
+ TEST_ASSERT(ret == 0 || ret == MBEDTLS_ERR_MPI_BAD_INPUT_DATA);
+ if (ret == MBEDTLS_ERR_MPI_BAD_INPUT_DATA) {
/* The data overflows the maximum MPI size. */
expected_result_for_mpi = MBEDTLS_ERR_MPI_BAD_INPUT_DATA;
}
p = input->x;
- ret = mbedtls_asn1_get_mpi( &p, input->x + input->len, &actual_mpi );
- TEST_EQUAL( ret, expected_result_for_mpi );
- if( ret == 0 )
- {
- if( expected_value >= 0 )
- {
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &actual_mpi,
- &expected_mpi ) == 0 );
- }
- else
- {
+ ret = mbedtls_asn1_get_mpi(&p, input->x + input->len, &actual_mpi);
+ TEST_EQUAL(ret, expected_result_for_mpi);
+ if (ret == 0) {
+ if (expected_value >= 0) {
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&actual_mpi,
+ &expected_mpi) == 0);
+ } else {
/* The library ignores the sign bit in ASN.1 INTEGERs
* (which makes sense insofar as INTEGERs are sometimes
* abused as bit strings), so the result of parsing them
@@ -448,32 +431,32 @@
* negative INTEGERs, we'll fix this test code. */
unsigned char *q = input->x + 1;
size_t len;
- TEST_ASSERT( mbedtls_asn1_get_len( &q, input->x + input->len,
- &len ) == 0 );
- TEST_ASSERT( mbedtls_mpi_lset( &complement, 1 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_shift_l( &complement, len * 8 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_add_mpi( &complement, &complement,
- &expected_mpi ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &complement,
- &actual_mpi ) == 0 );
+ TEST_ASSERT(mbedtls_asn1_get_len(&q, input->x + input->len,
+ &len) == 0);
+ TEST_ASSERT(mbedtls_mpi_lset(&complement, 1) == 0);
+ TEST_ASSERT(mbedtls_mpi_shift_l(&complement, len * 8) == 0);
+ TEST_ASSERT(mbedtls_mpi_add_mpi(&complement, &complement,
+ &expected_mpi) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&complement,
+ &actual_mpi) == 0);
}
- TEST_ASSERT( p == input->x + input->len );
+ TEST_ASSERT(p == input->x + input->len);
}
#endif
exit:
#if defined(MBEDTLS_BIGNUM_C)
- mbedtls_mpi_free( &expected_mpi );
- mbedtls_mpi_free( &actual_mpi );
- mbedtls_mpi_free( &complement );
+ mbedtls_mpi_free(&expected_mpi);
+ mbedtls_mpi_free(&actual_mpi);
+ mbedtls_mpi_free(&complement);
#endif
- /*empty cleanup in some configurations*/ ;
+ /*empty cleanup in some configurations*/;
}
/* END_CASE */
/* BEGIN_CASE */
-void get_enum( const data_t *input,
- const char *expected_hex, int expected_result )
+void get_enum(const data_t *input,
+ const char *expected_hex, int expected_result)
{
unsigned char *p;
long expected_value;
@@ -482,20 +465,18 @@
int ret;
errno = 0;
- expected_value = strtol( expected_hex, NULL, 16 );
- if( expected_result == 0 &&
- ( errno == ERANGE
+ expected_value = strtol(expected_hex, NULL, 16);
+ if (expected_result == 0 &&
+ (errno == ERANGE
#if LONG_MAX > INT_MAX
- || expected_value > INT_MAX || expected_value < INT_MIN
+ || expected_value > INT_MAX || expected_value < INT_MIN
#endif
- ) )
- {
+ )) {
/* The library returns the dubious error code INVALID_LENGTH
* for integers that are out of range. */
expected_result_for_enum = MBEDTLS_ERR_ASN1_INVALID_LENGTH;
}
- if( expected_result == 0 && expected_value < 0 )
- {
+ if (expected_result == 0 && expected_value < 0) {
/* The library does not support negative INTEGERs and
* returns the dubious error code INVALID_LENGTH.
* Test that we preserve the historical behavior. If we
@@ -504,18 +485,17 @@
}
p = input->x;
- ret = mbedtls_asn1_get_enum( &p, input->x + input->len, &val );
- TEST_EQUAL( ret, expected_result_for_enum );
- if( ret == 0 )
- {
- TEST_EQUAL( val, expected_value );
- TEST_ASSERT( p == input->x + input->len );
+ ret = mbedtls_asn1_get_enum(&p, input->x + input->len, &val);
+ TEST_EQUAL(ret, expected_result_for_enum);
+ if (ret == 0) {
+ TEST_EQUAL(val, expected_value);
+ TEST_ASSERT(p == input->x + input->len);
}
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_BIGNUM_C */
-void get_mpi_too_large( )
+void get_mpi_too_large()
{
unsigned char *buf = NULL;
unsigned char *p;
@@ -524,63 +504,62 @@
MBEDTLS_MPI_MAX_LIMBS * sizeof(mbedtls_mpi_uint) + 1;
size_t size = too_many_octets + 6;
- mbedtls_mpi_init( &actual_mpi );
+ mbedtls_mpi_init(&actual_mpi);
- ASSERT_ALLOC( buf, size );
+ ASSERT_ALLOC(buf, size);
buf[0] = 0x02; /* tag: INTEGER */
buf[1] = 0x84; /* 4-octet length */
- buf[2] = ( too_many_octets >> 24 ) & 0xff;
- buf[3] = ( too_many_octets >> 16 ) & 0xff;
- buf[4] = ( too_many_octets >> 8 ) & 0xff;
+ buf[2] = (too_many_octets >> 24) & 0xff;
+ buf[3] = (too_many_octets >> 16) & 0xff;
+ buf[4] = (too_many_octets >> 8) & 0xff;
buf[5] = too_many_octets & 0xff;
buf[6] = 0x01; /* most significant octet */
p = buf;
- TEST_EQUAL( mbedtls_asn1_get_mpi( &p, buf + size, &actual_mpi ),
- MBEDTLS_ERR_MPI_ALLOC_FAILED );
+ TEST_EQUAL(mbedtls_asn1_get_mpi(&p, buf + size, &actual_mpi),
+ MBEDTLS_ERR_MPI_ALLOC_FAILED);
exit:
- mbedtls_mpi_free( &actual_mpi );
- mbedtls_free( buf );
+ mbedtls_mpi_free(&actual_mpi);
+ mbedtls_free(buf);
}
/* END_CASE */
/* BEGIN_CASE */
-void get_bitstring( const data_t *input,
- int expected_length, int expected_unused_bits,
- int expected_result, int expected_result_null )
+void get_bitstring(const data_t *input,
+ int expected_length, int expected_unused_bits,
+ int expected_result, int expected_result_null)
{
mbedtls_asn1_bitstring bs = { 0xdead, 0x21, NULL };
unsigned char *p = input->x;
- TEST_EQUAL( mbedtls_asn1_get_bitstring( &p, input->x + input->len, &bs ),
- expected_result );
- if( expected_result == 0 )
- {
- TEST_EQUAL( bs.len, (size_t) expected_length );
- TEST_EQUAL( bs.unused_bits, expected_unused_bits );
- TEST_ASSERT( bs.p != NULL );
- TEST_EQUAL( bs.p - input->x + bs.len, input->len );
- TEST_ASSERT( p == input->x + input->len );
+ TEST_EQUAL(mbedtls_asn1_get_bitstring(&p, input->x + input->len, &bs),
+ expected_result);
+ if (expected_result == 0) {
+ TEST_EQUAL(bs.len, (size_t) expected_length);
+ TEST_EQUAL(bs.unused_bits, expected_unused_bits);
+ TEST_ASSERT(bs.p != NULL);
+ TEST_EQUAL(bs.p - input->x + bs.len, input->len);
+ TEST_ASSERT(p == input->x + input->len);
}
p = input->x;
- TEST_EQUAL( mbedtls_asn1_get_bitstring_null( &p, input->x + input->len,
- &bs.len ),
- expected_result_null );
- if( expected_result_null == 0 )
- {
- TEST_EQUAL( bs.len, (size_t) expected_length );
- if( expected_result == 0 )
- TEST_ASSERT( p == input->x + input->len - bs.len );
+ TEST_EQUAL(mbedtls_asn1_get_bitstring_null(&p, input->x + input->len,
+ &bs.len),
+ expected_result_null);
+ if (expected_result_null == 0) {
+ TEST_EQUAL(bs.len, (size_t) expected_length);
+ if (expected_result == 0) {
+ TEST_ASSERT(p == input->x + input->len - bs.len);
+ }
}
}
/* END_CASE */
/* BEGIN_CASE */
-void get_sequence_of( const data_t *input, int tag,
- const char *description,
- int expected_result )
+void get_sequence_of(const data_t *input, int tag,
+ const char *description,
+ int expected_result)
{
/* The description string is a comma-separated list of integers.
* For each element in the SEQUENCE in input, description contains
@@ -596,53 +575,49 @@
unsigned long n;
unsigned int step = 0;
- TEST_EQUAL( mbedtls_asn1_get_sequence_of( &p, input->x + input->len,
- &head, tag ),
- expected_result );
- if( expected_result == 0 )
- {
- TEST_ASSERT( p == input->x + input->len );
+ TEST_EQUAL(mbedtls_asn1_get_sequence_of(&p, input->x + input->len,
+ &head, tag),
+ expected_result);
+ if (expected_result == 0) {
+ TEST_ASSERT(p == input->x + input->len);
- if( ! *rest )
- {
- TEST_EQUAL( head.buf.tag, 0 );
- TEST_ASSERT( head.buf.p == NULL );
- TEST_EQUAL( head.buf.len, 0 );
- TEST_ASSERT( head.next == NULL );
- }
- else
- {
+ if (!*rest) {
+ TEST_EQUAL(head.buf.tag, 0);
+ TEST_ASSERT(head.buf.p == NULL);
+ TEST_EQUAL(head.buf.len, 0);
+ TEST_ASSERT(head.next == NULL);
+ } else {
cur = &head;
- while( *rest )
- {
- mbedtls_test_set_step( step );
- TEST_ASSERT( cur != NULL );
- TEST_EQUAL( cur->buf.tag, tag );
- n = strtoul( rest, (char **) &rest, 0 );
- TEST_EQUAL( n, (size_t)( cur->buf.p - input->x ) );
+ while (*rest) {
+ mbedtls_test_set_step(step);
+ TEST_ASSERT(cur != NULL);
+ TEST_EQUAL(cur->buf.tag, tag);
+ n = strtoul(rest, (char **) &rest, 0);
+ TEST_EQUAL(n, (size_t) (cur->buf.p - input->x));
++rest;
- n = strtoul( rest, (char **) &rest, 0 );
- TEST_EQUAL( n, cur->buf.len );
- if( *rest )
+ n = strtoul(rest, (char **) &rest, 0);
+ TEST_EQUAL(n, cur->buf.len);
+ if (*rest) {
++rest;
+ }
cur = cur->next;
++step;
}
- TEST_ASSERT( cur == NULL );
+ TEST_ASSERT(cur == NULL);
}
}
exit:
- mbedtls_asn1_sequence_free( head.next );
+ mbedtls_asn1_sequence_free(head.next);
}
/* END_CASE */
/* BEGIN_CASE */
-void traverse_sequence_of( const data_t *input,
- int tag_must_mask, int tag_must_val,
- int tag_may_mask, int tag_may_val,
- const char *description,
- int expected_result )
+void traverse_sequence_of(const data_t *input,
+ int tag_must_mask, int tag_must_val,
+ int tag_may_mask, int tag_may_val,
+ const char *description,
+ int expected_result)
{
/* The description string is a comma-separated list of integers.
* For each element in the SEQUENCE in input, description contains
@@ -652,144 +627,148 @@
* "offset1,tag1,length1,..." */
unsigned char *p = input->x;
- traverse_state_t traverse_state = {input->x, description};
+ traverse_state_t traverse_state = { input->x, description };
int ret;
- ret = mbedtls_asn1_traverse_sequence_of( &p, input->x + input->len,
- (uint8_t) tag_must_mask, (uint8_t) tag_must_val,
- (uint8_t) tag_may_mask, (uint8_t) tag_may_val,
- traverse_callback, &traverse_state );
- if( ret == RET_TRAVERSE_ERROR )
+ ret = mbedtls_asn1_traverse_sequence_of(&p, input->x + input->len,
+ (uint8_t) tag_must_mask, (uint8_t) tag_must_val,
+ (uint8_t) tag_may_mask, (uint8_t) tag_may_val,
+ traverse_callback, &traverse_state);
+ if (ret == RET_TRAVERSE_ERROR) {
goto exit;
- TEST_EQUAL( ret, expected_result );
- TEST_EQUAL( *traverse_state.description, 0 );
+ }
+ TEST_EQUAL(ret, expected_result);
+ TEST_EQUAL(*traverse_state.description, 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void get_alg( const data_t *input,
- int oid_offset, int oid_length,
- int params_tag, int params_offset, int params_length,
- int total_length,
- int expected_result )
+void get_alg(const data_t *input,
+ int oid_offset, int oid_length,
+ int params_tag, int params_offset, int params_length,
+ int total_length,
+ int expected_result)
{
mbedtls_asn1_buf oid = { -1, 0, NULL };
mbedtls_asn1_buf params = { -1, 0, NULL };
unsigned char *p = input->x;
int ret;
- TEST_EQUAL( mbedtls_asn1_get_alg( &p, input->x + input->len,
- &oid, ¶ms ),
- expected_result );
- if( expected_result == 0 )
- {
- TEST_EQUAL( oid.tag, MBEDTLS_ASN1_OID );
- TEST_EQUAL( oid.p - input->x, oid_offset );
- TEST_EQUAL( oid.len, (size_t) oid_length );
- TEST_EQUAL( params.tag, params_tag );
- if( params_offset != 0 )
- TEST_EQUAL( params.p - input->x, params_offset );
- else
- TEST_ASSERT( params.p == NULL );
- TEST_EQUAL( params.len, (size_t) params_length );
- TEST_EQUAL( p - input->x, total_length );
+ TEST_EQUAL(mbedtls_asn1_get_alg(&p, input->x + input->len,
+ &oid, ¶ms),
+ expected_result);
+ if (expected_result == 0) {
+ TEST_EQUAL(oid.tag, MBEDTLS_ASN1_OID);
+ TEST_EQUAL(oid.p - input->x, oid_offset);
+ TEST_EQUAL(oid.len, (size_t) oid_length);
+ TEST_EQUAL(params.tag, params_tag);
+ if (params_offset != 0) {
+ TEST_EQUAL(params.p - input->x, params_offset);
+ } else {
+ TEST_ASSERT(params.p == NULL);
+ }
+ TEST_EQUAL(params.len, (size_t) params_length);
+ TEST_EQUAL(p - input->x, total_length);
}
- ret = mbedtls_asn1_get_alg_null( &p, input->x + input->len, &oid );
- if( expected_result == 0 && params_offset == 0 )
- {
- TEST_EQUAL( oid.tag, MBEDTLS_ASN1_OID );
- TEST_EQUAL( oid.p - input->x, oid_offset );
- TEST_EQUAL( oid.len, (size_t) oid_length );
- TEST_EQUAL( p - input->x, total_length );
+ ret = mbedtls_asn1_get_alg_null(&p, input->x + input->len, &oid);
+ if (expected_result == 0 && params_offset == 0) {
+ TEST_EQUAL(oid.tag, MBEDTLS_ASN1_OID);
+ TEST_EQUAL(oid.p - input->x, oid_offset);
+ TEST_EQUAL(oid.len, (size_t) oid_length);
+ TEST_EQUAL(p - input->x, total_length);
+ } else {
+ TEST_ASSERT(ret != 0);
}
- else
- TEST_ASSERT( ret != 0 );
}
/* END_CASE */
/* BEGIN_CASE */
-void find_named_data( data_t *oid0, data_t *oid1, data_t *oid2, data_t *oid3,
- data_t *needle, int from, int position )
+void find_named_data(data_t *oid0, data_t *oid1, data_t *oid2, data_t *oid3,
+ data_t *needle, int from, int position)
{
- mbedtls_asn1_named_data nd[] ={
- { {0x06, oid0->len, oid0->x}, {0, 0, NULL}, NULL, 0 },
- { {0x06, oid1->len, oid1->x}, {0, 0, NULL}, NULL, 0 },
- { {0x06, oid2->len, oid2->x}, {0, 0, NULL}, NULL, 0 },
- { {0x06, oid3->len, oid3->x}, {0, 0, NULL}, NULL, 0 },
+ mbedtls_asn1_named_data nd[] = {
+ { { 0x06, oid0->len, oid0->x }, { 0, 0, NULL }, NULL, 0 },
+ { { 0x06, oid1->len, oid1->x }, { 0, 0, NULL }, NULL, 0 },
+ { { 0x06, oid2->len, oid2->x }, { 0, 0, NULL }, NULL, 0 },
+ { { 0x06, oid3->len, oid3->x }, { 0, 0, NULL }, NULL, 0 },
};
- mbedtls_asn1_named_data *pointers[ARRAY_LENGTH( nd ) + 1];
+ mbedtls_asn1_named_data *pointers[ARRAY_LENGTH(nd) + 1];
size_t i;
mbedtls_asn1_named_data *found;
- for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
+ for (i = 0; i < ARRAY_LENGTH(nd); i++) {
pointers[i] = &nd[i];
- pointers[ARRAY_LENGTH( nd )] = NULL;
- for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
+ }
+ pointers[ARRAY_LENGTH(nd)] = NULL;
+ for (i = 0; i < ARRAY_LENGTH(nd); i++) {
nd[i].next = pointers[i+1];
+ }
- found = mbedtls_asn1_find_named_data( pointers[from],
- (const char *) needle->x,
- needle->len );
- TEST_ASSERT( found == pointers[position] );
+ found = mbedtls_asn1_find_named_data(pointers[from],
+ (const char *) needle->x,
+ needle->len);
+ TEST_ASSERT(found == pointers[position]);
}
/* END_CASE */
/* BEGIN_CASE */
-void free_named_data_null( )
+void free_named_data_null()
{
- mbedtls_asn1_free_named_data( NULL );
+ mbedtls_asn1_free_named_data(NULL);
goto exit; /* Silence unused label warning */
}
/* END_CASE */
/* BEGIN_CASE */
-void free_named_data( int with_oid, int with_val, int with_next )
+void free_named_data(int with_oid, int with_val, int with_next)
{
mbedtls_asn1_named_data next =
- { {0x06, 0, NULL}, {0, 0xcafe, NULL}, NULL, 0 };
+ { { 0x06, 0, NULL }, { 0, 0xcafe, NULL }, NULL, 0 };
mbedtls_asn1_named_data head =
- { {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 };
+ { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 };
- if( with_oid )
- ASSERT_ALLOC( head.oid.p, 1 );
- if( with_val )
- ASSERT_ALLOC( head.val.p, 1 );
- if( with_next )
+ if (with_oid) {
+ ASSERT_ALLOC(head.oid.p, 1);
+ }
+ if (with_val) {
+ ASSERT_ALLOC(head.val.p, 1);
+ }
+ if (with_next) {
head.next = &next;
+ }
- mbedtls_asn1_free_named_data( &head );
- TEST_ASSERT( head.oid.p == NULL );
- TEST_ASSERT( head.val.p == NULL );
- TEST_ASSERT( head.next == NULL );
- TEST_ASSERT( next.val.len == 0xcafe );
+ mbedtls_asn1_free_named_data(&head);
+ TEST_ASSERT(head.oid.p == NULL);
+ TEST_ASSERT(head.val.p == NULL);
+ TEST_ASSERT(head.next == NULL);
+ TEST_ASSERT(next.val.len == 0xcafe);
exit:
- mbedtls_free( head.oid.p );
- mbedtls_free( head.val.p );
+ mbedtls_free(head.oid.p);
+ mbedtls_free(head.val.p);
}
/* END_CASE */
/* BEGIN_CASE */
-void free_named_data_list( int length )
+void free_named_data_list(int length)
{
mbedtls_asn1_named_data *head = NULL;
int i;
- for( i = 0; i < length; i++ )
- {
+ for (i = 0; i < length; i++) {
mbedtls_asn1_named_data *new = NULL;
- ASSERT_ALLOC( new, 1 );
+ ASSERT_ALLOC(new, 1);
new->next = head;
head = new;
}
- mbedtls_asn1_free_named_data_list( &head );
- TEST_ASSERT( head == NULL );
+ mbedtls_asn1_free_named_data_list(&head);
+ TEST_ASSERT(head == NULL);
/* Most of the point of the test is that it doesn't leak memory.
* So this test is only really useful under a memory leak detection
* framework. */
exit:
- mbedtls_asn1_free_named_data_list( &head );
+ mbedtls_asn1_free_named_data_list(&head);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_asn1write.function b/tests/suites/test_suite_asn1write.function
index 5aa4cbe..06b9edf 100644
--- a/tests/suites/test_suite_asn1write.function
+++ b/tests/suites/test_suite_asn1write.function
@@ -4,8 +4,7 @@
#define GUARD_LEN 4
#define GUARD_VAL 0x2a
-typedef struct
-{
+typedef struct {
unsigned char *output;
unsigned char *start;
unsigned char *end;
@@ -13,41 +12,38 @@
size_t size;
} generic_write_data_t;
-int generic_write_start_step( generic_write_data_t *data )
+int generic_write_start_step(generic_write_data_t *data)
{
- mbedtls_test_set_step( data->size );
- mbedtls_free( data->output );
+ mbedtls_test_set_step(data->size);
+ mbedtls_free(data->output);
data->output = NULL;
- ASSERT_ALLOC( data->output, data->size == 0 ? 1 : data->size );
+ ASSERT_ALLOC(data->output, data->size == 0 ? 1 : data->size);
data->end = data->output + data->size;
data->p = data->end;
data->start = data->end - data->size;
- return( 1 );
+ return 1;
exit:
- return( 0 );
+ return 0;
}
-int generic_write_finish_step( generic_write_data_t *data,
- const data_t *expected, int ret )
+int generic_write_finish_step(generic_write_data_t *data,
+ const data_t *expected, int ret)
{
int ok = 0;
- if( data->size < expected->len )
- {
- TEST_EQUAL( ret, MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
- }
- else
- {
- TEST_EQUAL( ret, data->end - data->p );
- TEST_ASSERT( data->p >= data->start );
- TEST_ASSERT( data->p <= data->end );
- ASSERT_COMPARE( data->p, (size_t)( data->end - data->p ),
- expected->x, expected->len );
+ if (data->size < expected->len) {
+ TEST_EQUAL(ret, MBEDTLS_ERR_ASN1_BUF_TOO_SMALL);
+ } else {
+ TEST_EQUAL(ret, data->end - data->p);
+ TEST_ASSERT(data->p >= data->start);
+ TEST_ASSERT(data->p <= data->end);
+ ASSERT_COMPARE(data->p, (size_t) (data->end - data->p),
+ expected->x, expected->len);
}
ok = 1;
exit:
- return( ok );
+ return ok;
}
/* END_HEADER */
@@ -58,206 +54,209 @@
*/
/* BEGIN_CASE */
-void mbedtls_asn1_write_null( data_t *expected )
+void mbedtls_asn1_write_null(data_t *expected)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
int ret;
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
- ret = mbedtls_asn1_write_null( &data.p, data.start );
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ }
+ ret = mbedtls_asn1_write_null(&data.p, data.start);
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
/* There's no parsing function for NULL. */
}
exit:
- mbedtls_free( data.output );
+ mbedtls_free(data.output);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_asn1_write_bool( int val, data_t *expected )
+void mbedtls_asn1_write_bool(int val, data_t *expected)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
int ret;
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
- ret = mbedtls_asn1_write_bool( &data.p, data.start, val );
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ }
+ ret = mbedtls_asn1_write_bool(&data.p, data.start, val);
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
#if defined(MBEDTLS_ASN1_PARSE_C)
- if( ret >= 0 )
- {
+ if (ret >= 0) {
int read = 0xdeadbeef;
- TEST_EQUAL( mbedtls_asn1_get_bool( &data.p, data.end, &read ), 0 );
- TEST_EQUAL( val, read );
+ TEST_EQUAL(mbedtls_asn1_get_bool(&data.p, data.end, &read), 0);
+ TEST_EQUAL(val, read);
}
#endif /* MBEDTLS_ASN1_PARSE_C */
}
exit:
- mbedtls_free( data.output );
+ mbedtls_free(data.output);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_asn1_write_int( int val, data_t *expected )
+void mbedtls_asn1_write_int(int val, data_t *expected)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
int ret;
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
- ret = mbedtls_asn1_write_int( &data.p, data.start, val );
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ }
+ ret = mbedtls_asn1_write_int(&data.p, data.start, val);
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
#if defined(MBEDTLS_ASN1_PARSE_C)
- if( ret >= 0 )
- {
+ if (ret >= 0) {
int read = 0xdeadbeef;
- TEST_EQUAL( mbedtls_asn1_get_int( &data.p, data.end, &read ), 0 );
- TEST_EQUAL( val, read );
+ TEST_EQUAL(mbedtls_asn1_get_int(&data.p, data.end, &read), 0);
+ TEST_EQUAL(val, read);
}
#endif /* MBEDTLS_ASN1_PARSE_C */
}
exit:
- mbedtls_free( data.output );
+ mbedtls_free(data.output);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_asn1_write_enum( int val, data_t *expected )
+void mbedtls_asn1_write_enum(int val, data_t *expected)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
int ret;
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
- ret = mbedtls_asn1_write_enum( &data.p, data.start, val );
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ }
+ ret = mbedtls_asn1_write_enum(&data.p, data.start, val);
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
#if defined(MBEDTLS_ASN1_PARSE_C)
- if( ret >= 0 )
- {
+ if (ret >= 0) {
int read = 0xdeadbeef;
- TEST_EQUAL( mbedtls_asn1_get_enum( &data.p, data.end, &read ), 0 );
- TEST_EQUAL( val, read );
+ TEST_EQUAL(mbedtls_asn1_get_enum(&data.p, data.end, &read), 0);
+ TEST_EQUAL(val, read);
}
#endif /* MBEDTLS_ASN1_PARSE_C */
}
exit:
- mbedtls_free( data.output );
+ mbedtls_free(data.output);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_BIGNUM_C */
-void mbedtls_asn1_write_mpi( data_t *val, data_t *expected )
+void mbedtls_asn1_write_mpi(data_t *val, data_t *expected)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
mbedtls_mpi mpi, read;
int ret;
- mbedtls_mpi_init( &mpi );
- mbedtls_mpi_init( &read );
- TEST_ASSERT( mbedtls_mpi_read_binary( &mpi, val->x, val->len ) == 0 );
+ mbedtls_mpi_init(&mpi);
+ mbedtls_mpi_init(&read);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&mpi, val->x, val->len) == 0);
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
- ret = mbedtls_asn1_write_mpi( &data.p, data.start, &mpi );
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ }
+ ret = mbedtls_asn1_write_mpi(&data.p, data.start, &mpi);
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
#if defined(MBEDTLS_ASN1_PARSE_C)
- if( ret >= 0 )
- {
- TEST_EQUAL( mbedtls_asn1_get_mpi( &data.p, data.end, &read ), 0 );
- TEST_EQUAL( 0, mbedtls_mpi_cmp_mpi( &mpi, &read ) );
+ if (ret >= 0) {
+ TEST_EQUAL(mbedtls_asn1_get_mpi(&data.p, data.end, &read), 0);
+ TEST_EQUAL(0, mbedtls_mpi_cmp_mpi(&mpi, &read));
}
#endif /* MBEDTLS_ASN1_PARSE_C */
/* Skip some intermediate lengths, they're boring. */
- if( expected->len > 10 && data.size == 8 )
+ if (expected->len > 10 && data.size == 8) {
data.size = expected->len - 2;
+ }
}
exit:
- mbedtls_mpi_free( &mpi );
- mbedtls_mpi_free( &read );
- mbedtls_free( data.output );
+ mbedtls_mpi_free(&mpi);
+ mbedtls_mpi_free(&read);
+ mbedtls_free(data.output);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_asn1_write_string( int tag, data_t *content, data_t *expected )
+void mbedtls_asn1_write_string(int tag, data_t *content, data_t *expected)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
int ret;
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
- switch( tag )
- {
+ }
+ switch (tag) {
case MBEDTLS_ASN1_OCTET_STRING:
ret = mbedtls_asn1_write_octet_string(
- &data.p, data.start, content->x, content->len );
+ &data.p, data.start, content->x, content->len);
break;
case MBEDTLS_ASN1_OID:
ret = mbedtls_asn1_write_oid(
&data.p, data.start,
- (const char *) content->x, content->len );
+ (const char *) content->x, content->len);
break;
case MBEDTLS_ASN1_UTF8_STRING:
ret = mbedtls_asn1_write_utf8_string(
&data.p, data.start,
- (const char *) content->x, content->len );
+ (const char *) content->x, content->len);
break;
case MBEDTLS_ASN1_PRINTABLE_STRING:
ret = mbedtls_asn1_write_printable_string(
&data.p, data.start,
- (const char *) content->x, content->len );
+ (const char *) content->x, content->len);
break;
case MBEDTLS_ASN1_IA5_STRING:
ret = mbedtls_asn1_write_ia5_string(
&data.p, data.start,
- (const char *) content->x, content->len );
+ (const char *) content->x, content->len);
break;
default:
ret = mbedtls_asn1_write_tagged_string(
&data.p, data.start, tag,
- (const char *) content->x, content->len );
+ (const char *) content->x, content->len);
}
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
/* There's no parsing function for octet or character strings. */
/* Skip some intermediate lengths, they're boring. */
- if( expected->len > 10 && data.size == 8 )
+ if (expected->len > 10 && data.size == 8) {
data.size = expected->len - 2;
+ }
}
exit:
- mbedtls_free( data.output );
+ mbedtls_free(data.output);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_asn1_write_algorithm_identifier( data_t *oid,
- int par_len,
- data_t *expected )
+void mbedtls_asn1_write_algorithm_identifier(data_t *oid,
+ int par_len,
+ data_t *expected)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
int ret;
@@ -265,29 +264,30 @@
unsigned char *buf_complete = NULL;
#endif /* MBEDTLS_ASN1_PARSE_C */
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
+ }
ret = mbedtls_asn1_write_algorithm_identifier(
&data.p, data.start,
- (const char *) oid->x, oid->len, par_len );
+ (const char *) oid->x, oid->len, par_len);
/* If params_len != 0, mbedtls_asn1_write_algorithm_identifier()
* assumes that the parameters are already present in the buffer
* and returns a length that accounts for this, but our test
* data omits the parameters. */
- if( ret >= 0 )
+ if (ret >= 0) {
ret -= par_len;
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ }
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
#if defined(MBEDTLS_ASN1_PARSE_C)
/* Only do a parse-back test if the parameters aren't too large for
* a small-heap environment. The boundary is somewhat arbitrary. */
- if( ret >= 0 && par_len <= 1234 )
- {
- mbedtls_asn1_buf alg = {0, 0, NULL};
- mbedtls_asn1_buf params = {0, 0, NULL};
+ if (ret >= 0 && par_len <= 1234) {
+ mbedtls_asn1_buf alg = { 0, 0, NULL };
+ mbedtls_asn1_buf params = { 0, 0, NULL };
/* The writing function doesn't write the parameters unless
* they're null: it only takes their length as input. But the
* parsing function requires the parameters to be present.
@@ -296,59 +296,52 @@
size_t len_complete = data_len + par_len;
unsigned char expected_params_tag;
size_t expected_params_len;
- ASSERT_ALLOC( buf_complete, len_complete );
+ ASSERT_ALLOC(buf_complete, len_complete);
unsigned char *end_complete = buf_complete + len_complete;
- memcpy( buf_complete, data.p, data_len );
- if( par_len == 0 )
- {
+ memcpy(buf_complete, data.p, data_len);
+ if (par_len == 0) {
/* mbedtls_asn1_write_algorithm_identifier() wrote a NULL */
expected_params_tag = 0x05;
expected_params_len = 0;
- }
- else if( par_len >= 2 && par_len < 2 + 128 )
- {
+ } else if (par_len >= 2 && par_len < 2 + 128) {
/* Write an OCTET STRING with a short length encoding */
expected_params_tag = buf_complete[data_len] = 0x04;
expected_params_len = par_len - 2;
buf_complete[data_len + 1] = (unsigned char) expected_params_len;
- }
- else if( par_len >= 4 + 128 && par_len < 3 + 256 * 256 )
- {
+ } else if (par_len >= 4 + 128 && par_len < 3 + 256 * 256) {
/* Write an OCTET STRING with a two-byte length encoding */
expected_params_tag = buf_complete[data_len] = 0x04;
expected_params_len = par_len - 4;
buf_complete[data_len + 1] = 0x82;
- buf_complete[data_len + 2] = (unsigned char) ( expected_params_len >> 8 );
- buf_complete[data_len + 3] = (unsigned char) ( expected_params_len );
- }
- else
- {
- TEST_ASSERT( ! "Bad test data: invalid length of ASN.1 element" );
+ buf_complete[data_len + 2] = (unsigned char) (expected_params_len >> 8);
+ buf_complete[data_len + 3] = (unsigned char) (expected_params_len);
+ } else {
+ TEST_ASSERT(!"Bad test data: invalid length of ASN.1 element");
}
unsigned char *p = buf_complete;
- TEST_EQUAL( mbedtls_asn1_get_alg( &p, end_complete,
- &alg, ¶ms ), 0 );
- TEST_EQUAL( alg.tag, MBEDTLS_ASN1_OID );
- ASSERT_COMPARE( alg.p, alg.len, oid->x, oid->len );
- TEST_EQUAL( params.tag, expected_params_tag );
- TEST_EQUAL( params.len, expected_params_len );
- mbedtls_free( buf_complete );
+ TEST_EQUAL(mbedtls_asn1_get_alg(&p, end_complete,
+ &alg, ¶ms), 0);
+ TEST_EQUAL(alg.tag, MBEDTLS_ASN1_OID);
+ ASSERT_COMPARE(alg.p, alg.len, oid->x, oid->len);
+ TEST_EQUAL(params.tag, expected_params_tag);
+ TEST_EQUAL(params.len, expected_params_len);
+ mbedtls_free(buf_complete);
buf_complete = NULL;
}
#endif /* MBEDTLS_ASN1_PARSE_C */
}
exit:
- mbedtls_free( data.output );
+ mbedtls_free(data.output);
#if defined(MBEDTLS_ASN1_PARSE_C)
- mbedtls_free( buf_complete );
+ mbedtls_free(buf_complete);
#endif /* MBEDTLS_ASN1_PARSE_C */
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ASN1_PARSE_C */
-void mbedtls_asn1_write_len( int len, data_t * asn1, int buf_len,
- int result )
+void mbedtls_asn1_write_len(int len, data_t *asn1, int buf_len,
+ int result)
{
int ret;
unsigned char buf[150];
@@ -356,260 +349,253 @@
size_t i;
size_t read_len;
- memset( buf, GUARD_VAL, sizeof( buf ) );
+ memset(buf, GUARD_VAL, sizeof(buf));
p = buf + GUARD_LEN + buf_len;
- ret = mbedtls_asn1_write_len( &p, buf + GUARD_LEN, (size_t) len );
+ ret = mbedtls_asn1_write_len(&p, buf + GUARD_LEN, (size_t) len);
- TEST_ASSERT( ret == result );
+ TEST_ASSERT(ret == result);
/* Check for buffer overwrite on both sides */
- for( i = 0; i < GUARD_LEN; i++ )
- {
- TEST_ASSERT( buf[i] == GUARD_VAL );
- TEST_ASSERT( buf[GUARD_LEN + buf_len + i] == GUARD_VAL );
+ for (i = 0; i < GUARD_LEN; i++) {
+ TEST_ASSERT(buf[i] == GUARD_VAL);
+ TEST_ASSERT(buf[GUARD_LEN + buf_len + i] == GUARD_VAL);
}
- if( result >= 0 )
- {
- TEST_ASSERT( p + asn1->len == buf + GUARD_LEN + buf_len );
+ if (result >= 0) {
+ TEST_ASSERT(p + asn1->len == buf + GUARD_LEN + buf_len);
- TEST_ASSERT( memcmp( p, asn1->x, asn1->len ) == 0 );
+ TEST_ASSERT(memcmp(p, asn1->x, asn1->len) == 0);
/* Read back with mbedtls_asn1_get_len() to check */
- ret = mbedtls_asn1_get_len( &p, buf + GUARD_LEN + buf_len, &read_len );
+ ret = mbedtls_asn1_get_len(&p, buf + GUARD_LEN + buf_len, &read_len);
- if( len == 0 )
- {
- TEST_ASSERT( ret == 0 );
- }
- else
- {
+ if (len == 0) {
+ TEST_ASSERT(ret == 0);
+ } else {
/* Return will be MBEDTLS_ERR_ASN1_OUT_OF_DATA because the rest of
* the buffer is missing
*/
- TEST_ASSERT( ret == MBEDTLS_ERR_ASN1_OUT_OF_DATA );
+ TEST_ASSERT(ret == MBEDTLS_ERR_ASN1_OUT_OF_DATA);
}
- TEST_ASSERT( read_len == (size_t) len );
- TEST_ASSERT( p == buf + GUARD_LEN + buf_len );
+ TEST_ASSERT(read_len == (size_t) len);
+ TEST_ASSERT(p == buf + GUARD_LEN + buf_len);
}
}
/* END_CASE */
/* BEGIN_CASE */
-void test_asn1_write_bitstrings( data_t *bitstring, int bits,
- data_t *expected, int is_named )
+void test_asn1_write_bitstrings(data_t *bitstring, int bits,
+ data_t *expected, int is_named)
{
generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 };
int ret;
- int ( *func )( unsigned char **p, unsigned char *start,
- const unsigned char *buf, size_t bits ) =
- ( is_named ? mbedtls_asn1_write_named_bitstring :
- mbedtls_asn1_write_bitstring );
+ int (*func)(unsigned char **p, unsigned char *start,
+ const unsigned char *buf, size_t bits) =
+ (is_named ? mbedtls_asn1_write_named_bitstring :
+ mbedtls_asn1_write_bitstring);
#if defined(MBEDTLS_ASN1_PARSE_C)
unsigned char *masked_bitstring = NULL;
#endif /* MBEDTLS_ASN1_PARSE_C */
/* The API expects `bitstring->x` to contain `bits` bits. */
- size_t byte_length = ( bits + 7 ) / 8;
- TEST_ASSERT( bitstring->len >= byte_length );
+ size_t byte_length = (bits + 7) / 8;
+ TEST_ASSERT(bitstring->len >= byte_length);
#if defined(MBEDTLS_ASN1_PARSE_C)
- ASSERT_ALLOC( masked_bitstring, byte_length );
- if( byte_length != 0 )
- {
- memcpy( masked_bitstring, bitstring->x, byte_length );
- if( bits % 8 != 0 )
- masked_bitstring[byte_length - 1] &= ~( 0xff >> ( bits % 8 ) );
+ ASSERT_ALLOC(masked_bitstring, byte_length);
+ if (byte_length != 0) {
+ memcpy(masked_bitstring, bitstring->x, byte_length);
+ if (bits % 8 != 0) {
+ masked_bitstring[byte_length - 1] &= ~(0xff >> (bits % 8));
+ }
}
size_t value_bits = bits;
- if( is_named )
- {
+ if (is_named) {
/* In a named bit string, all trailing 0 bits are removed. */
- while( byte_length > 0 && masked_bitstring[byte_length - 1] == 0 )
+ while (byte_length > 0 && masked_bitstring[byte_length - 1] == 0) {
--byte_length;
+ }
value_bits = 8 * byte_length;
- if( byte_length > 0 )
- {
+ if (byte_length > 0) {
unsigned char last_byte = masked_bitstring[byte_length - 1];
- for( unsigned b = 1; b < 0xff && ( last_byte & b ) == 0; b <<= 1 )
+ for (unsigned b = 1; b < 0xff && (last_byte & b) == 0; b <<= 1) {
--value_bits;
+ }
}
}
#endif /* MBEDTLS_ASN1_PARSE_C */
- for( data.size = 0; data.size <= expected->len + 1; data.size++ )
- {
- if( ! generic_write_start_step( &data ) )
+ for (data.size = 0; data.size <= expected->len + 1; data.size++) {
+ if (!generic_write_start_step(&data)) {
goto exit;
- ret = ( *func )( &data.p, data.start, bitstring->x, bits );
- if( ! generic_write_finish_step( &data, expected, ret ) )
+ }
+ ret = (*func)(&data.p, data.start, bitstring->x, bits);
+ if (!generic_write_finish_step(&data, expected, ret)) {
goto exit;
+ }
#if defined(MBEDTLS_ASN1_PARSE_C)
- if( ret >= 0 )
- {
- mbedtls_asn1_bitstring read = {0, 0, NULL};
- TEST_EQUAL( mbedtls_asn1_get_bitstring( &data.p, data.end,
- &read ), 0 );
- ASSERT_COMPARE( read.p, read.len,
- masked_bitstring, byte_length );
- TEST_EQUAL( read.unused_bits, 8 * byte_length - value_bits );
+ if (ret >= 0) {
+ mbedtls_asn1_bitstring read = { 0, 0, NULL };
+ TEST_EQUAL(mbedtls_asn1_get_bitstring(&data.p, data.end,
+ &read), 0);
+ ASSERT_COMPARE(read.p, read.len,
+ masked_bitstring, byte_length);
+ TEST_EQUAL(read.unused_bits, 8 * byte_length - value_bits);
}
#endif /* MBEDTLS_ASN1_PARSE_C */
}
exit:
- mbedtls_free( data.output );
+ mbedtls_free(data.output);
#if defined(MBEDTLS_ASN1_PARSE_C)
- mbedtls_free( masked_bitstring );
+ mbedtls_free(masked_bitstring);
#endif /* MBEDTLS_ASN1_PARSE_C */
}
/* END_CASE */
/* BEGIN_CASE */
-void store_named_data_find( data_t *oid0, data_t *oid1,
- data_t *oid2, data_t *oid3,
- data_t *needle, int from, int position )
+void store_named_data_find(data_t *oid0, data_t *oid1,
+ data_t *oid2, data_t *oid3,
+ data_t *needle, int from, int position)
{
- data_t *oid[4] = {oid0, oid1, oid2, oid3};
- mbedtls_asn1_named_data nd[] ={
- { {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
- { {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
- { {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
- { {0x06, 0, NULL}, {0, 0, NULL}, NULL, 0 },
+ data_t *oid[4] = { oid0, oid1, oid2, oid3 };
+ mbedtls_asn1_named_data nd[] = {
+ { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 },
+ { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 },
+ { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 },
+ { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 },
};
- mbedtls_asn1_named_data *pointers[ARRAY_LENGTH( nd ) + 1];
+ mbedtls_asn1_named_data *pointers[ARRAY_LENGTH(nd) + 1];
size_t i;
mbedtls_asn1_named_data *head = NULL;
mbedtls_asn1_named_data *found = NULL;
- for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
+ for (i = 0; i < ARRAY_LENGTH(nd); i++) {
pointers[i] = &nd[i];
- pointers[ARRAY_LENGTH( nd )] = NULL;
- for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
- {
- ASSERT_ALLOC( nd[i].oid.p, oid[i]->len );
- memcpy( nd[i].oid.p, oid[i]->x, oid[i]->len );
+ }
+ pointers[ARRAY_LENGTH(nd)] = NULL;
+ for (i = 0; i < ARRAY_LENGTH(nd); i++) {
+ ASSERT_ALLOC(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];
}
head = pointers[from];
- found = mbedtls_asn1_store_named_data( &head,
- (const char *) needle->x,
- needle->len,
- NULL, 0 );
+ found = mbedtls_asn1_store_named_data(&head,
+ (const char *) needle->x,
+ needle->len,
+ NULL, 0);
/* In any case, the existing list structure must be unchanged. */
- for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
- TEST_ASSERT( nd[i].next == pointers[i+1] );
-
- if( position >= 0 )
- {
- /* position should have been found and modified. */
- TEST_ASSERT( head == pointers[from] );
- TEST_ASSERT( found == pointers[position] );
+ for (i = 0; i < ARRAY_LENGTH(nd); i++) {
+ TEST_ASSERT(nd[i].next == pointers[i+1]);
}
- else
- {
+
+ if (position >= 0) {
+ /* position should have been found and modified. */
+ TEST_ASSERT(head == pointers[from]);
+ TEST_ASSERT(found == pointers[position]);
+ } else {
/* A new entry should have been created. */
- TEST_ASSERT( found == head );
- TEST_ASSERT( head->next == pointers[from] );
- for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
- TEST_ASSERT( found != &nd[i] );
+ TEST_ASSERT(found == head);
+ TEST_ASSERT(head->next == pointers[from]);
+ for (i = 0; i < ARRAY_LENGTH(nd); i++) {
+ TEST_ASSERT(found != &nd[i]);
+ }
}
exit:
- if( found != NULL && found == head && found != pointers[from] )
- {
- mbedtls_free( found->oid.p );
- mbedtls_free( found );
+ if (found != NULL && found == head && found != pointers[from]) {
+ mbedtls_free(found->oid.p);
+ mbedtls_free(found);
}
- for( i = 0; i < ARRAY_LENGTH( nd ); i++ )
- mbedtls_free( nd[i].oid.p );
+ for (i = 0; i < ARRAY_LENGTH(nd); i++) {
+ mbedtls_free(nd[i].oid.p);
+ }
}
/* END_CASE */
/* BEGIN_CASE */
-void store_named_data_val_found( int old_len, int new_len )
+void store_named_data_val_found(int old_len, int new_len)
{
mbedtls_asn1_named_data nd =
- { {0x06, 3, (unsigned char *) "OID"}, {0, 0, NULL}, NULL, 0 };
+ { { 0x06, 3, (unsigned char *) "OID" }, { 0, 0, NULL }, NULL, 0 };
mbedtls_asn1_named_data *head = &nd;
mbedtls_asn1_named_data *found = NULL;
unsigned char *old_val = NULL;
unsigned char *new_val = (unsigned char *) "new value";
- if( old_len != 0 )
- {
- ASSERT_ALLOC( nd.val.p, (size_t) old_len );
+ if (old_len != 0) {
+ ASSERT_ALLOC(nd.val.p, (size_t) old_len);
old_val = nd.val.p;
nd.val.len = old_len;
- memset( old_val, 'x', old_len );
+ memset(old_val, 'x', old_len);
}
- if( new_len <= 0 )
- {
- new_len = - new_len;
+ if (new_len <= 0) {
+ new_len = -new_len;
new_val = NULL;
}
- found = mbedtls_asn1_store_named_data( &head, "OID", 3,
- new_val, new_len );
- TEST_ASSERT( head == &nd );
- TEST_ASSERT( found == head );
+ found = mbedtls_asn1_store_named_data(&head, "OID", 3,
+ new_val, new_len);
+ TEST_ASSERT(head == &nd);
+ TEST_ASSERT(found == head);
- if( new_val != NULL)
- ASSERT_COMPARE( found->val.p, found->val.len,
- new_val, (size_t) new_len );
- if( new_len == 0)
- TEST_ASSERT( found->val.p == NULL );
- else if( new_len == old_len )
- TEST_ASSERT( found->val.p == old_val );
- else
- TEST_ASSERT( found->val.p != old_val );
+ if (new_val != NULL) {
+ ASSERT_COMPARE(found->val.p, found->val.len,
+ new_val, (size_t) new_len);
+ }
+ if (new_len == 0) {
+ TEST_ASSERT(found->val.p == NULL);
+ } else if (new_len == old_len) {
+ TEST_ASSERT(found->val.p == old_val);
+ } else {
+ TEST_ASSERT(found->val.p != old_val);
+ }
exit:
- mbedtls_free( nd.val.p );
+ mbedtls_free(nd.val.p);
}
/* END_CASE */
/* BEGIN_CASE */
-void store_named_data_val_new( int new_len, int set_new_val )
+void store_named_data_val_new(int new_len, int set_new_val)
{
mbedtls_asn1_named_data *head = NULL;
mbedtls_asn1_named_data *found = NULL;
const unsigned char *oid = (unsigned char *) "OID";
- size_t oid_len = strlen( (const char *) oid );
+ size_t oid_len = strlen((const char *) oid);
const unsigned char *new_val = (unsigned char *) "new value";
- if( set_new_val == 0 )
+ if (set_new_val == 0) {
new_val = NULL;
+ }
- found = mbedtls_asn1_store_named_data( &head,
- (const char *) oid, oid_len,
- new_val, (size_t) new_len );
- TEST_ASSERT( found != NULL );
- TEST_ASSERT( found == head );
- TEST_ASSERT( found->oid.p != oid );
- ASSERT_COMPARE( found->oid.p, found->oid.len, oid, oid_len );
- if( new_len == 0 )
- TEST_ASSERT( found->val.p == NULL );
- else if( new_val == NULL )
- TEST_ASSERT( found->val.p != NULL );
- else
- {
- TEST_ASSERT( found->val.p != new_val );
- ASSERT_COMPARE( found->val.p, found->val.len,
- new_val, (size_t) new_len );
+ found = mbedtls_asn1_store_named_data(&head,
+ (const char *) oid, oid_len,
+ new_val, (size_t) new_len);
+ TEST_ASSERT(found != NULL);
+ TEST_ASSERT(found == head);
+ TEST_ASSERT(found->oid.p != oid);
+ ASSERT_COMPARE(found->oid.p, found->oid.len, oid, oid_len);
+ if (new_len == 0) {
+ TEST_ASSERT(found->val.p == NULL);
+ } else if (new_val == NULL) {
+ TEST_ASSERT(found->val.p != NULL);
+ } else {
+ TEST_ASSERT(found->val.p != new_val);
+ ASSERT_COMPARE(found->val.p, found->val.len,
+ new_val, (size_t) new_len);
}
exit:
- if( found != NULL )
- {
- mbedtls_free( found->oid.p );
- mbedtls_free( found->val.p );
+ if (found != NULL) {
+ mbedtls_free(found->oid.p);
+ mbedtls_free(found->val.p);
}
- mbedtls_free( found );
+ mbedtls_free(found);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_base64.function b/tests/suites/test_suite_base64.function
index 7baa3d5..ce6bd42 100644
--- a/tests/suites/test_suite_base64.function
+++ b/tests/suites/test_suite_base64.function
@@ -17,67 +17,66 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS */
-void mask_of_range( int low_arg, int high_arg )
+void mask_of_range(int low_arg, int high_arg)
{
unsigned char low = low_arg, high = high_arg;
unsigned c;
- for( c = 0; c <= 0xff; c++ )
- {
- mbedtls_test_set_step( c );
- TEST_CF_SECRET( &c, sizeof( c ) );
- unsigned char m = mbedtls_ct_uchar_mask_of_range( low, high, c );
- TEST_CF_PUBLIC( &c, sizeof( c ) );
- TEST_CF_PUBLIC( &m, sizeof( m ) );
- if( low <= c && c <= high )
- TEST_EQUAL( m, 0xff );
- else
- TEST_EQUAL( m, 0 );
+ for (c = 0; c <= 0xff; c++) {
+ mbedtls_test_set_step(c);
+ TEST_CF_SECRET(&c, sizeof(c));
+ unsigned char m = mbedtls_ct_uchar_mask_of_range(low, high, c);
+ TEST_CF_PUBLIC(&c, sizeof(c));
+ TEST_CF_PUBLIC(&m, sizeof(m));
+ if (low <= c && c <= high) {
+ TEST_EQUAL(m, 0xff);
+ } else {
+ TEST_EQUAL(m, 0);
+ }
}
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS */
-void enc_chars( )
+void enc_chars()
{
- for( unsigned value = 0; value < 64; value++ )
- {
- mbedtls_test_set_step( value );
- TEST_CF_SECRET( &value, sizeof( value ) );
- unsigned char digit = mbedtls_ct_base64_enc_char( value );
- TEST_CF_PUBLIC( &value, sizeof( value ) );
- TEST_CF_PUBLIC( &digit, sizeof( digit ) );
- TEST_EQUAL( digit, base64_digits[value] );
+ for (unsigned value = 0; value < 64; value++) {
+ mbedtls_test_set_step(value);
+ TEST_CF_SECRET(&value, sizeof(value));
+ unsigned char digit = mbedtls_ct_base64_enc_char(value);
+ TEST_CF_PUBLIC(&value, sizeof(value));
+ TEST_CF_PUBLIC(&digit, sizeof(digit));
+ TEST_EQUAL(digit, base64_digits[value]);
}
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS */
-void dec_chars( )
+void dec_chars()
{
char *p;
signed char expected;
- for( unsigned c = 0; c <= 0xff; c++ )
- {
- mbedtls_test_set_step( c );
+ for (unsigned c = 0; c <= 0xff; c++) {
+ mbedtls_test_set_step(c);
/* base64_digits is 0-terminated. sizeof()-1 excludes the trailing 0. */
- p = memchr( base64_digits, c, sizeof( base64_digits ) - 1 );
- if( p == NULL )
+ p = memchr(base64_digits, c, sizeof(base64_digits) - 1);
+ if (p == NULL) {
expected = -1;
- else
+ } else {
expected = p - base64_digits;
- TEST_CF_SECRET( &c, sizeof( c ) );
- signed char actual = mbedtls_ct_base64_dec_value( c );
- TEST_CF_PUBLIC( &c, sizeof( c ) );
- TEST_CF_PUBLIC( &actual, sizeof( actual ) );
- TEST_EQUAL( actual, expected );
+ }
+ TEST_CF_SECRET(&c, sizeof(c));
+ signed char actual = mbedtls_ct_base64_dec_value(c);
+ TEST_CF_PUBLIC(&c, sizeof(c));
+ TEST_CF_PUBLIC(&actual, sizeof(actual));
+ TEST_EQUAL(actual, expected);
}
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_base64_encode( char * src_string, char * dst_string,
- int dst_buf_size, int result )
+void mbedtls_base64_encode(char *src_string, char *dst_string,
+ int dst_buf_size, int result)
{
unsigned char src_str[1000];
unsigned char dst_str[1000];
@@ -86,26 +85,25 @@
memset(src_str, 0x00, 1000);
memset(dst_str, 0x00, 1000);
- strncpy( (char *) src_str, src_string, sizeof(src_str) - 1 );
- src_len = strlen( (char *) src_str );
+ strncpy((char *) src_str, src_string, sizeof(src_str) - 1);
+ src_len = strlen((char *) src_str);
- TEST_CF_SECRET( src_str, sizeof( src_str ) );
- TEST_ASSERT( mbedtls_base64_encode( dst_str, dst_buf_size, &len, src_str, src_len) == result );
- TEST_CF_PUBLIC( src_str, sizeof( src_str ) );
+ TEST_CF_SECRET(src_str, sizeof(src_str));
+ TEST_ASSERT(mbedtls_base64_encode(dst_str, dst_buf_size, &len, src_str, src_len) == result);
+ TEST_CF_PUBLIC(src_str, sizeof(src_str));
/* dest_str will have had tainted data copied to it, prevent the TEST_ASSERT below from triggering
CF failures by unmarking it. */
- TEST_CF_PUBLIC( dst_str, len );
+ TEST_CF_PUBLIC(dst_str, len);
- if( result == 0 )
- {
- TEST_ASSERT( strcmp( (char *) dst_str, dst_string ) == 0 );
+ if (result == 0) {
+ TEST_ASSERT(strcmp((char *) dst_str, dst_string) == 0);
}
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_base64_decode( char * src_string, char * dst_string, int result )
+void mbedtls_base64_decode(char *src_string, char *dst_string, int result)
{
unsigned char src_str[1000];
unsigned char dst_str[1000];
@@ -115,77 +113,73 @@
memset(src_str, 0x00, 1000);
memset(dst_str, 0x00, 1000);
- strncpy( (char *) src_str, src_string, sizeof(src_str) - 1 );
- res = mbedtls_base64_decode( dst_str, sizeof( dst_str ), &len, src_str, strlen( (char *) src_str ) );
- TEST_ASSERT( res == result );
- if( result == 0 )
- {
- TEST_ASSERT( strcmp( (char *) dst_str, dst_string ) == 0 );
+ strncpy((char *) src_str, src_string, sizeof(src_str) - 1);
+ res = mbedtls_base64_decode(dst_str, sizeof(dst_str), &len, src_str, strlen((char *) src_str));
+ TEST_ASSERT(res == result);
+ if (result == 0) {
+ TEST_ASSERT(strcmp((char *) dst_str, dst_string) == 0);
}
}
/* END_CASE */
/* BEGIN_CASE */
-void base64_encode_hex( data_t * src, char * dst, int dst_buf_size,
- int result )
+void base64_encode_hex(data_t *src, char *dst, int dst_buf_size,
+ int result)
{
unsigned char *res = NULL;
size_t len;
- res = mbedtls_test_zero_alloc( dst_buf_size );
+ res = mbedtls_test_zero_alloc(dst_buf_size);
- TEST_CF_SECRET( src->x, src->len );
- TEST_ASSERT( mbedtls_base64_encode( res, dst_buf_size, &len, src->x, src->len ) == result );
- TEST_CF_PUBLIC( src->x, src->len );
+ TEST_CF_SECRET(src->x, src->len);
+ TEST_ASSERT(mbedtls_base64_encode(res, dst_buf_size, &len, src->x, src->len) == result);
+ TEST_CF_PUBLIC(src->x, src->len);
/* res will have had tainted data copied to it, prevent the TEST_ASSERT below from triggering
CF failures by unmarking it. */
- TEST_CF_PUBLIC( res, len );
+ TEST_CF_PUBLIC(res, len);
- if( result == 0 )
- {
- TEST_ASSERT( len == strlen( dst ) );
- TEST_ASSERT( memcmp( dst, res, len ) == 0 );
+ if (result == 0) {
+ TEST_ASSERT(len == strlen(dst));
+ TEST_ASSERT(memcmp(dst, res, len) == 0);
}
exit:
- mbedtls_free( res );
+ mbedtls_free(res);
}
/* END_CASE */
/* BEGIN_CASE */
-void base64_decode_hex( char * src, data_t * dst, int dst_buf_size,
- int result )
+void base64_decode_hex(char *src, data_t *dst, int dst_buf_size,
+ int result)
{
unsigned char *res = NULL;
size_t len;
- res = mbedtls_test_zero_alloc( dst_buf_size );
+ res = mbedtls_test_zero_alloc(dst_buf_size);
- TEST_ASSERT( mbedtls_base64_decode( res, dst_buf_size, &len, (unsigned char *) src,
- strlen( src ) ) == result );
- if( result == 0 )
- {
- TEST_ASSERT( len == dst->len );
- TEST_ASSERT( memcmp( dst->x, res, len ) == 0 );
+ TEST_ASSERT(mbedtls_base64_decode(res, dst_buf_size, &len, (unsigned char *) src,
+ strlen(src)) == result);
+ if (result == 0) {
+ TEST_ASSERT(len == dst->len);
+ TEST_ASSERT(memcmp(dst->x, res, len) == 0);
}
exit:
- mbedtls_free( res );
+ mbedtls_free(res);
}
/* END_CASE */
/* BEGIN_CASE */
-void base64_decode_hex_src( data_t * src, char * dst_ref, int result )
+void base64_decode_hex_src(data_t *src, char *dst_ref, int result)
{
unsigned char dst[1000] = { 0 };
size_t len;
- TEST_ASSERT( mbedtls_base64_decode( dst, sizeof( dst ), &len, src->x, src->len ) == result );
- if( result == 0 )
- {
- TEST_ASSERT( len == strlen( dst_ref ) );
- TEST_ASSERT( memcmp( dst, dst_ref, len ) == 0 );
+ TEST_ASSERT(mbedtls_base64_decode(dst, sizeof(dst), &len, src->x, src->len) == result);
+ if (result == 0) {
+ TEST_ASSERT(len == strlen(dst_ref));
+ TEST_ASSERT(memcmp(dst, dst_ref, len) == 0);
}
exit:
@@ -194,8 +188,8 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void base64_selftest( )
+void base64_selftest()
{
- TEST_ASSERT( mbedtls_base64_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_base64_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_bignum.function b/tests/suites/test_suite_bignum.function
index 35952f0..9afebba 100644
--- a/tests/suites/test_suite_bignum.function
+++ b/tests/suites/test_suite_bignum.function
@@ -9,28 +9,27 @@
/* Check the validity of the sign bit in an MPI object. Reject representations
* that are not supported by the rest of the library and indicate a bug when
* constructing the value. */
-static int sign_is_valid( const mbedtls_mpi *X )
+static int sign_is_valid(const mbedtls_mpi *X)
{
/* Only +1 and -1 are valid sign bits, not e.g. 0 */
- if( X->s != 1 && X->s != -1 )
- return( 0 );
+ if (X->s != 1 && X->s != -1) {
+ return 0;
+ }
/* The value 0 must be represented with the sign +1. A "negative zero"
* with s=-1 is an invalid representation. Forbid that. As an exception,
* we sometimes test the robustness of library functions when given
* a negative zero input. If a test case has a negative zero as input,
* we don't mind if the function has a negative zero output. */
- if( ! mbedtls_test_case_uses_negative_0 &&
- mbedtls_mpi_bitlen( X ) == 0 && X->s != 1 )
- {
- return( 0 );
+ if (!mbedtls_test_case_uses_negative_0 &&
+ mbedtls_mpi_bitlen(X) == 0 && X->s != 1) {
+ return 0;
}
- return( 1 );
+ return 1;
}
-typedef struct mbedtls_test_mpi_random
-{
+typedef struct mbedtls_test_mpi_random {
data_t *data;
size_t pos;
size_t chunk_len;
@@ -42,49 +41,49 @@
* test) are stored in the data member of the state structure. Each number is in
* the format that mbedtls_mpi_read_string understands and is chunk_len long.
*/
-int mbedtls_test_mpi_miller_rabin_determinizer( void* state,
- unsigned char* buf,
- size_t len )
+int mbedtls_test_mpi_miller_rabin_determinizer(void *state,
+ unsigned char *buf,
+ size_t len)
{
- mbedtls_test_mpi_random *random = (mbedtls_test_mpi_random*) state;
+ mbedtls_test_mpi_random *random = (mbedtls_test_mpi_random *) state;
- if( random == NULL || random->data->x == NULL || buf == NULL )
- return( -1 );
-
- if( random->pos + random->chunk_len > random->data->len
- || random->chunk_len > len )
- {
- return( -1 );
+ if (random == NULL || random->data->x == NULL || buf == NULL) {
+ return -1;
}
- memset( buf, 0, len );
+ if (random->pos + random->chunk_len > random->data->len
+ || random->chunk_len > len) {
+ return -1;
+ }
+
+ memset(buf, 0, len);
/* The witness is written to the end of the buffer, since the buffer is
* used as big endian, unsigned binary data in mbedtls_mpi_read_binary.
* Writing the witness to the start of the buffer would result in the
* buffer being 'witness 000...000', which would be treated as
* witness * 2^n for some n. */
- memcpy( buf + len - random->chunk_len, &random->data->x[random->pos],
- random->chunk_len );
+ memcpy(buf + len - random->chunk_len, &random->data->x[random->pos],
+ random->chunk_len);
random->pos += random->chunk_len;
- return( 0 );
+ return 0;
}
/* Random generator that is told how many bytes to return. */
-static int f_rng_bytes_left( void *state, unsigned char *buf, size_t len )
+static int f_rng_bytes_left(void *state, unsigned char *buf, size_t len)
{
size_t *bytes_left = state;
size_t i;
- for( i = 0; i < len; i++ )
- {
- if( *bytes_left == 0 )
- return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
+ for (i = 0; i < len; i++) {
+ if (*bytes_left == 0) {
+ return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
+ }
buf[i] = *bytes_left & 0xff;
- --( *bytes_left );
+ --(*bytes_left);
}
- return( 0 );
+ return 0;
}
/* Test whether bytes represents (in big-endian base 256) a number b that
@@ -98,37 +97,39 @@
* number is above some threshold A. The threshold value is heuristic and
* based on the needs of mpi_random_many().
*/
-static int is_significantly_above_a_power_of_2( data_t *bytes )
+static int is_significantly_above_a_power_of_2(data_t *bytes)
{
const uint8_t *p = bytes->x;
size_t len = bytes->len;
unsigned x;
/* Skip leading null bytes */
- while( len > 0 && p[0] == 0 )
- {
+ while (len > 0 && p[0] == 0) {
++p;
--len;
}
/* 0 is not significantly above a power of 2 */
- if( len == 0 )
- return( 0 );
+ if (len == 0) {
+ return 0;
+ }
/* Extract the (up to) 2 most significant bytes */
- if( len == 1 )
+ if (len == 1) {
x = p[0];
- else
- x = ( p[0] << 8 ) | p[1];
+ } else {
+ x = (p[0] << 8) | p[1];
+ }
/* Shift the most significant bit of x to position 8 and mask it out */
- while( ( x & 0xfe00 ) != 0 )
+ while ((x & 0xfe00) != 0) {
x >>= 1;
+ }
x &= 0x00ff;
/* At this point, x = floor((b - 2^n) / 2^(n-8)). b is significantly above
* a power of 2 iff x is significantly above 0 compared to 2^8.
* Testing x >= 2^4 amounts to picking A = 1/16 in the function
* description above. */
- return( x >= 0x10 );
+ return x >= 0x10;
}
/* END_HEADER */
@@ -139,14 +140,14 @@
*/
/* BEGIN_CASE */
-void mpi_valid_param( )
+void mpi_valid_param()
{
- TEST_VALID_PARAM( mbedtls_mpi_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_mpi_free(NULL));
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void mpi_invalid_param( )
+void mpi_invalid_param()
{
mbedtls_mpi X;
const char *s_in = "00101000101010";
@@ -156,197 +157,197 @@
size_t olen;
mbedtls_mpi_uint mpi_uint;
- TEST_INVALID_PARAM( mbedtls_mpi_init( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_mpi_init(NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_grow( NULL, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_copy( NULL, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_copy( &X, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_grow(NULL, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_copy(NULL, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_copy(&X, NULL));
- TEST_INVALID_PARAM( mbedtls_mpi_swap( NULL, &X ) );
- TEST_INVALID_PARAM( mbedtls_mpi_swap( &X, NULL ) );
+ TEST_INVALID_PARAM(mbedtls_mpi_swap(NULL, &X));
+ TEST_INVALID_PARAM(mbedtls_mpi_swap(&X, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_safe_cond_assign( NULL, &X, 0 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_safe_cond_assign( &X, NULL, 0 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_safe_cond_assign(NULL, &X, 0));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_safe_cond_assign(&X, NULL, 0));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_safe_cond_swap( NULL, &X, 0 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_safe_cond_swap( &X, NULL, 0 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_safe_cond_swap(NULL, &X, 0));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_safe_cond_swap(&X, NULL, 0));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_lset( NULL, 42 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_lset(NULL, 42));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_get_bit( NULL, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_set_bit( NULL, 42, 0 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_get_bit(NULL, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_set_bit(NULL, 42, 0));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_read_string( NULL, 2, s_in ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_read_string( &X, 2, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_read_string(NULL, 2, s_in));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_read_string(&X, 2, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_write_string( NULL, 2,
- s_out, sizeof( s_out ),
- &olen ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_write_string( &X, 2,
- NULL, sizeof( s_out ),
- &olen ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_write_string( &X, 2,
- s_out, sizeof( s_out ),
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_write_string(NULL, 2,
+ s_out, sizeof(s_out),
+ &olen));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_write_string(&X, 2,
+ NULL, sizeof(s_out),
+ &olen));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_write_string(&X, 2,
+ s_out, sizeof(s_out),
+ NULL));
#if defined(MBEDTLS_FS_IO)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_read_file( NULL, 2, stdin ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_read_file( &X, 2, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_read_file(NULL, 2, stdin));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_read_file(&X, 2, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_write_file( "", NULL, 2, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_write_file("", NULL, 2, NULL));
#endif /* MBEDTLS_FS_IO */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_read_binary( NULL, u_in,
- sizeof( u_in ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_read_binary( &X, NULL,
- sizeof( u_in ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_read_binary(NULL, u_in,
+ sizeof(u_in)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_read_binary(&X, NULL,
+ sizeof(u_in)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_write_binary( NULL, u_out,
- sizeof( u_out ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_write_binary( &X, NULL,
- sizeof( u_out ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_write_binary(NULL, u_out,
+ sizeof(u_out)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_write_binary(&X, NULL,
+ sizeof(u_out)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_shift_l( NULL, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_shift_r( NULL, 42 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_shift_l(NULL, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_shift_r(NULL, 42));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_cmp_abs( NULL, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_cmp_abs( &X, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_cmp_abs(NULL, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_cmp_abs(&X, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_cmp_mpi( NULL, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_cmp_mpi( &X, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_cmp_mpi(NULL, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_cmp_mpi(&X, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_cmp_int( NULL, 42 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_cmp_int(NULL, 42));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_add_abs( NULL, &X, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_add_abs( &X, NULL, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_add_abs( &X, &X, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_add_abs(NULL, &X, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_add_abs(&X, NULL, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_add_abs(&X, &X, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_sub_abs( NULL, &X, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_sub_abs( &X, NULL, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_sub_abs( &X, &X, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_sub_abs(NULL, &X, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_sub_abs(&X, NULL, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_sub_abs(&X, &X, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_add_mpi( NULL, &X, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_add_mpi( &X, NULL, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_add_mpi( &X, &X, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_add_mpi(NULL, &X, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_add_mpi(&X, NULL, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_add_mpi(&X, &X, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_sub_mpi( NULL, &X, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_sub_mpi( &X, NULL, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_sub_mpi( &X, &X, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_sub_mpi(NULL, &X, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_sub_mpi(&X, NULL, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_sub_mpi(&X, &X, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_add_int( NULL, &X, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_add_int( &X, NULL, 42 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_add_int(NULL, &X, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_add_int(&X, NULL, 42));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_sub_int( NULL, &X, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_sub_int( &X, NULL, 42 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_sub_int(NULL, &X, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_sub_int(&X, NULL, 42));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_mul_mpi( NULL, &X, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_mul_mpi( &X, NULL, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_mul_mpi( &X, &X, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_mul_mpi(NULL, &X, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_mul_mpi(&X, NULL, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_mul_mpi(&X, &X, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_mul_int( NULL, &X, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_mul_int( &X, NULL, 42 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_mul_int(NULL, &X, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_mul_int(&X, NULL, 42));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_div_mpi( &X, &X, NULL, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_div_mpi( &X, &X, &X, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_div_mpi(&X, &X, NULL, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_div_mpi(&X, &X, &X, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_div_int( &X, &X, NULL, 42 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_div_int(&X, &X, NULL, 42));
- TEST_INVALID_PARAM_RET( 0, mbedtls_mpi_lsb( NULL ) );
+ TEST_INVALID_PARAM_RET(0, mbedtls_mpi_lsb(NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_mod_mpi( NULL, &X, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_mod_mpi( &X, NULL, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_mod_mpi( &X, &X, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_mod_mpi(NULL, &X, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_mod_mpi(&X, NULL, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_mod_mpi(&X, &X, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_mod_int( NULL, &X, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_mod_int( &mpi_uint, NULL, 42 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_mod_int(NULL, &X, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_mod_int(&mpi_uint, NULL, 42));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_exp_mod( NULL, &X, &X, &X, NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_exp_mod( &X, NULL, &X, &X, NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_exp_mod( &X, &X, NULL, &X, NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_exp_mod( &X, &X, &X, NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_exp_mod(NULL, &X, &X, &X, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_exp_mod(&X, NULL, &X, &X, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_exp_mod(&X, &X, NULL, &X, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_exp_mod(&X, &X, &X, NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_fill_random( NULL, 42,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_fill_random( &X, 42, NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_fill_random(NULL, 42,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_fill_random(&X, 42, NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_gcd( NULL, &X, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_gcd( &X, NULL, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_gcd( &X, &X, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_gcd(NULL, &X, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_gcd(&X, NULL, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_gcd(&X, &X, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_inv_mod( NULL, &X, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_inv_mod( &X, NULL, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
- mbedtls_mpi_inv_mod( &X, &X, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_inv_mod(NULL, &X, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_inv_mod(&X, NULL, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_MPI_BAD_INPUT_DATA,
+ mbedtls_mpi_inv_mod(&X, &X, NULL));
exit:
return;
@@ -354,158 +355,156 @@
/* END_CASE */
/* BEGIN_CASE */
-void mpi_null( )
+void mpi_null()
{
mbedtls_mpi X, Y, Z;
- mbedtls_mpi_init( &X );
- mbedtls_mpi_init( &Y );
- mbedtls_mpi_init( &Z );
+ mbedtls_mpi_init(&X);
+ mbedtls_mpi_init(&Y);
+ mbedtls_mpi_init(&Z);
- TEST_ASSERT( mbedtls_mpi_get_bit( &X, 42 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_lsb( &X ) == 0 );
- TEST_ASSERT( mbedtls_mpi_bitlen( &X ) == 0 );
- TEST_ASSERT( mbedtls_mpi_size( &X ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_get_bit(&X, 42) == 0);
+ TEST_ASSERT(mbedtls_mpi_lsb(&X) == 0);
+ TEST_ASSERT(mbedtls_mpi_bitlen(&X) == 0);
+ TEST_ASSERT(mbedtls_mpi_size(&X) == 0);
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_read_write_string( int radix_X, char * input_X, int radix_A,
- char * input_A, int output_size, int result_read,
- int result_write )
+void mpi_read_write_string(int radix_X, char *input_X, int radix_A,
+ char *input_A, int output_size, int result_read,
+ int result_write)
{
mbedtls_mpi X;
char str[1000];
size_t len;
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&X);
- memset( str, '!', sizeof( str ) );
+ memset(str, '!', sizeof(str));
- TEST_ASSERT( mbedtls_mpi_read_string( &X, radix_X, input_X ) == result_read );
- if( result_read == 0 )
- {
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( mbedtls_mpi_write_string( &X, radix_A, str, output_size, &len ) == result_write );
- if( result_write == 0 )
- {
- TEST_ASSERT( strcasecmp( str, input_A ) == 0 );
- TEST_ASSERT( str[len] == '!' );
+ TEST_ASSERT(mbedtls_mpi_read_string(&X, radix_X, input_X) == result_read);
+ if (result_read == 0) {
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(mbedtls_mpi_write_string(&X, radix_A, str, output_size, &len) == result_write);
+ if (result_write == 0) {
+ TEST_ASSERT(strcasecmp(str, input_A) == 0);
+ TEST_ASSERT(str[len] == '!');
}
}
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_read_binary( data_t * buf, char * input_A )
+void mbedtls_mpi_read_binary(data_t *buf, char *input_A)
{
mbedtls_mpi X;
char str[1000];
size_t len;
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&X);
- TEST_ASSERT( mbedtls_mpi_read_binary( &X, buf->x, buf->len ) == 0 );
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( mbedtls_mpi_write_string( &X, 16, str, sizeof( str ), &len ) == 0 );
- TEST_ASSERT( strcmp( (char *) str, input_A ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_read_binary(&X, buf->x, buf->len) == 0);
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(mbedtls_mpi_write_string(&X, 16, str, sizeof(str), &len) == 0);
+ TEST_ASSERT(strcmp((char *) str, input_A) == 0);
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_read_binary_le( data_t * buf, char * input_A )
+void mbedtls_mpi_read_binary_le(data_t *buf, char *input_A)
{
mbedtls_mpi X;
char str[1000];
size_t len;
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&X);
- TEST_ASSERT( mbedtls_mpi_read_binary_le( &X, buf->x, buf->len ) == 0 );
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( mbedtls_mpi_write_string( &X, 16, str, sizeof( str ), &len ) == 0 );
- TEST_ASSERT( strcmp( (char *) str, input_A ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_read_binary_le(&X, buf->x, buf->len) == 0);
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(mbedtls_mpi_write_string(&X, 16, str, sizeof(str), &len) == 0);
+ TEST_ASSERT(strcmp((char *) str, input_A) == 0);
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_write_binary( char * input_X, data_t * input_A,
- int output_size, int result )
+void mbedtls_mpi_write_binary(char *input_X, data_t *input_A,
+ int output_size, int result)
{
mbedtls_mpi X;
unsigned char buf[1000];
size_t buflen;
- memset( buf, 0x00, 1000 );
+ memset(buf, 0x00, 1000);
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&X);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
- buflen = mbedtls_mpi_size( &X );
- if( buflen > (size_t) output_size )
+ buflen = mbedtls_mpi_size(&X);
+ if (buflen > (size_t) output_size) {
buflen = (size_t) output_size;
+ }
- TEST_ASSERT( mbedtls_mpi_write_binary( &X, buf, buflen ) == result );
- if( result == 0)
- {
+ TEST_ASSERT(mbedtls_mpi_write_binary(&X, buf, buflen) == result);
+ if (result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( buf, input_A->x,
- buflen, input_A->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(buf, input_A->x,
+ buflen, input_A->len) == 0);
}
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_write_binary_le( char * input_X, data_t * input_A,
- int output_size, int result )
+void mbedtls_mpi_write_binary_le(char *input_X, data_t *input_A,
+ int output_size, int result)
{
mbedtls_mpi X;
unsigned char buf[1000];
size_t buflen;
- memset( buf, 0x00, 1000 );
+ memset(buf, 0x00, 1000);
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&X);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
- buflen = mbedtls_mpi_size( &X );
- if( buflen > (size_t) output_size )
+ buflen = mbedtls_mpi_size(&X);
+ if (buflen > (size_t) output_size) {
buflen = (size_t) output_size;
+ }
- TEST_ASSERT( mbedtls_mpi_write_binary_le( &X, buf, buflen ) == result );
- if( result == 0)
- {
+ TEST_ASSERT(mbedtls_mpi_write_binary_le(&X, buf, buflen) == result);
+ if (result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( buf, input_A->x,
- buflen, input_A->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(buf, input_A->x,
+ buflen, input_A->len) == 0);
}
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO */
-void mbedtls_mpi_read_file( char * input_file, data_t * input_A, int result )
+void mbedtls_mpi_read_file(char *input_file, data_t *input_A, int result)
{
mbedtls_mpi X;
unsigned char buf[1000];
@@ -513,678 +512,677 @@
FILE *file;
int ret;
- memset( buf, 0x00, 1000 );
+ memset(buf, 0x00, 1000);
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&X);
- file = fopen( input_file, "r" );
- TEST_ASSERT( file != NULL );
- ret = mbedtls_mpi_read_file( &X, 16, file );
+ file = fopen(input_file, "r");
+ TEST_ASSERT(file != NULL);
+ ret = mbedtls_mpi_read_file(&X, 16, file);
fclose(file);
- TEST_ASSERT( ret == result );
+ TEST_ASSERT(ret == result);
- if( result == 0 )
- {
- TEST_ASSERT( sign_is_valid( &X ) );
- buflen = mbedtls_mpi_size( &X );
- TEST_ASSERT( mbedtls_mpi_write_binary( &X, buf, buflen ) == 0 );
+ if (result == 0) {
+ TEST_ASSERT(sign_is_valid(&X));
+ buflen = mbedtls_mpi_size(&X);
+ TEST_ASSERT(mbedtls_mpi_write_binary(&X, buf, buflen) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( buf, input_A->x,
- buflen, input_A->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(buf, input_A->x,
+ buflen, input_A->len) == 0);
}
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO */
-void mbedtls_mpi_write_file( char * input_X, char * output_file )
+void mbedtls_mpi_write_file(char *input_X, char *output_file)
{
mbedtls_mpi X, Y;
FILE *file_out, *file_in;
int ret;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
- file_out = fopen( output_file, "w" );
- TEST_ASSERT( file_out != NULL );
- ret = mbedtls_mpi_write_file( NULL, &X, 16, file_out );
+ file_out = fopen(output_file, "w");
+ TEST_ASSERT(file_out != NULL);
+ ret = mbedtls_mpi_write_file(NULL, &X, 16, file_out);
fclose(file_out);
- TEST_ASSERT( ret == 0 );
+ TEST_ASSERT(ret == 0);
- file_in = fopen( output_file, "r" );
- TEST_ASSERT( file_in != NULL );
- ret = mbedtls_mpi_read_file( &Y, 16, file_in );
+ file_in = fopen(output_file, "r");
+ TEST_ASSERT(file_in != NULL);
+ ret = mbedtls_mpi_read_file(&Y, 16, file_in);
fclose(file_in);
- TEST_ASSERT( ret == 0 );
+ TEST_ASSERT(ret == 0);
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &Y) == 0);
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_get_bit( char * input_X, int pos, int val )
+void mbedtls_mpi_get_bit(char *input_X, int pos, int val)
{
mbedtls_mpi X;
- mbedtls_mpi_init( &X );
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_mpi_get_bit( &X, pos ) == val );
+ mbedtls_mpi_init(&X);
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_mpi_get_bit(&X, pos) == val);
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_set_bit( char * input_X, int pos, int val,
- char * output_Y, int result )
+void mbedtls_mpi_set_bit(char *input_X, int pos, int val,
+ char *output_Y, int result)
{
mbedtls_mpi X, Y;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, output_Y ) == 0 );
- TEST_ASSERT( mbedtls_mpi_set_bit( &X, pos, val ) == result );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, output_Y) == 0);
+ TEST_ASSERT(mbedtls_mpi_set_bit(&X, pos, val) == result);
- if( result == 0 )
- {
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == 0 );
+ if (result == 0) {
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &Y) == 0);
}
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_lsb( char * input_X, int nr_bits )
+void mbedtls_mpi_lsb(char *input_X, int nr_bits)
{
mbedtls_mpi X;
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&X);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_mpi_lsb( &X ) == (size_t) nr_bits );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_mpi_lsb(&X) == (size_t) nr_bits);
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_bitlen( char * input_X, int nr_bits )
+void mbedtls_mpi_bitlen(char *input_X, int nr_bits)
{
mbedtls_mpi X;
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&X);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_mpi_bitlen( &X ) == (size_t) nr_bits );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_mpi_bitlen(&X) == (size_t) nr_bits);
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_gcd( char * input_X, char * input_Y,
- char * input_A )
+void mbedtls_mpi_gcd(char *input_X, char *input_Y,
+ char *input_A)
{
mbedtls_mpi A, X, Y, Z;
- mbedtls_mpi_init( &A ); mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z );
+ mbedtls_mpi_init(&A); mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y); mbedtls_mpi_init(&Z);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, input_Y ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- TEST_ASSERT( mbedtls_mpi_gcd( &Z, &X, &Y ) == 0 );
- TEST_ASSERT( sign_is_valid( &Z ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, input_Y) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ TEST_ASSERT(mbedtls_mpi_gcd(&Z, &X, &Y) == 0);
+ TEST_ASSERT(sign_is_valid(&Z));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Z, &A) == 0);
exit:
- mbedtls_mpi_free( &A ); mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z );
+ mbedtls_mpi_free(&A); mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y); mbedtls_mpi_free(&Z);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_cmp_int( int input_X, int input_A, int result_CMP )
+void mbedtls_mpi_cmp_int(int input_X, int input_A, int result_CMP)
{
mbedtls_mpi X;
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&X);
- TEST_ASSERT( mbedtls_mpi_lset( &X, input_X ) == 0);
- TEST_ASSERT( mbedtls_mpi_cmp_int( &X, input_A ) == result_CMP);
+ TEST_ASSERT(mbedtls_mpi_lset(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_int(&X, input_A) == result_CMP);
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_cmp_mpi( char * input_X, char * input_Y,
- int input_A )
+void mbedtls_mpi_cmp_mpi(char *input_X, char *input_Y,
+ int input_A)
{
mbedtls_mpi X, Y;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, input_Y ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y ) == input_A );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, input_Y) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &Y) == input_A);
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_lt_mpi_ct( int size_X, char * input_X,
- int size_Y, char * input_Y,
- int input_ret, int input_err )
+void mbedtls_mpi_lt_mpi_ct(int size_X, char *input_X,
+ int size_Y, char *input_Y,
+ int input_ret, int input_err)
{
unsigned ret = -1;
unsigned input_uret = input_ret;
mbedtls_mpi X, Y;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, input_Y ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, input_Y) == 0);
- TEST_ASSERT( mbedtls_mpi_grow( &X, size_X ) == 0 );
- TEST_ASSERT( mbedtls_mpi_grow( &Y, size_Y ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_grow(&X, size_X) == 0);
+ TEST_ASSERT(mbedtls_mpi_grow(&Y, size_Y) == 0);
- TEST_ASSERT( mbedtls_mpi_lt_mpi_ct( &X, &Y, &ret ) == input_err );
- if( input_err == 0 )
- TEST_ASSERT( ret == input_uret );
+ TEST_ASSERT(mbedtls_mpi_lt_mpi_ct(&X, &Y, &ret) == input_err);
+ if (input_err == 0) {
+ TEST_ASSERT(ret == input_uret);
+ }
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_cmp_abs( char * input_X, char * input_Y,
- int input_A )
+void mbedtls_mpi_cmp_abs(char *input_X, char *input_Y,
+ int input_A)
{
mbedtls_mpi X, Y;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, input_Y ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_abs( &X, &Y ) == input_A );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, input_Y) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_abs(&X, &Y) == input_A);
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_copy( char *src_hex, char *dst_hex )
+void mbedtls_mpi_copy(char *src_hex, char *dst_hex)
{
mbedtls_mpi src, dst, ref;
- mbedtls_mpi_init( &src );
- mbedtls_mpi_init( &dst );
- mbedtls_mpi_init( &ref );
+ mbedtls_mpi_init(&src);
+ mbedtls_mpi_init(&dst);
+ mbedtls_mpi_init(&ref);
- TEST_ASSERT( mbedtls_test_read_mpi( &src, src_hex ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &ref, dst_hex ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&src, src_hex) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&ref, dst_hex) == 0);
/* mbedtls_mpi_copy() */
- TEST_ASSERT( mbedtls_test_read_mpi( &dst, dst_hex ) == 0 );
- TEST_ASSERT( mbedtls_mpi_copy( &dst, &src ) == 0 );
- TEST_ASSERT( sign_is_valid( &dst ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &dst, &src ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&dst, dst_hex) == 0);
+ TEST_ASSERT(mbedtls_mpi_copy(&dst, &src) == 0);
+ TEST_ASSERT(sign_is_valid(&dst));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&dst, &src) == 0);
/* mbedtls_mpi_safe_cond_assign(), assignment done */
- mbedtls_mpi_free( &dst );
- TEST_ASSERT( mbedtls_test_read_mpi( &dst, dst_hex ) == 0 );
- TEST_ASSERT( mbedtls_mpi_safe_cond_assign( &dst, &src, 1 ) == 0 );
- TEST_ASSERT( sign_is_valid( &dst ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &dst, &src ) == 0 );
+ mbedtls_mpi_free(&dst);
+ TEST_ASSERT(mbedtls_test_read_mpi(&dst, dst_hex) == 0);
+ TEST_ASSERT(mbedtls_mpi_safe_cond_assign(&dst, &src, 1) == 0);
+ TEST_ASSERT(sign_is_valid(&dst));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&dst, &src) == 0);
/* mbedtls_mpi_safe_cond_assign(), assignment not done */
- mbedtls_mpi_free( &dst );
- TEST_ASSERT( mbedtls_test_read_mpi( &dst, dst_hex ) == 0 );
- TEST_ASSERT( mbedtls_mpi_safe_cond_assign( &dst, &src, 0 ) == 0 );
- TEST_ASSERT( sign_is_valid( &dst ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &dst, &ref ) == 0 );
+ mbedtls_mpi_free(&dst);
+ TEST_ASSERT(mbedtls_test_read_mpi(&dst, dst_hex) == 0);
+ TEST_ASSERT(mbedtls_mpi_safe_cond_assign(&dst, &src, 0) == 0);
+ TEST_ASSERT(sign_is_valid(&dst));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&dst, &ref) == 0);
exit:
- mbedtls_mpi_free( &src );
- mbedtls_mpi_free( &dst );
- mbedtls_mpi_free( &ref );
+ mbedtls_mpi_free(&src);
+ mbedtls_mpi_free(&dst);
+ mbedtls_mpi_free(&ref);
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_copy_self( char *input_X )
+void mpi_copy_self(char *input_X)
{
mbedtls_mpi X, A;
- mbedtls_mpi_init( &A );
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&A);
+ mbedtls_mpi_init(&X);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_mpi_copy( &X, &X ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_mpi_copy(&X, &X) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_X ) == 0 );
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_X) == 0);
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &A) == 0);
exit:
- mbedtls_mpi_free( &A );
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&A);
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_swap( char *X_hex, char *Y_hex )
+void mbedtls_mpi_swap(char *X_hex, char *Y_hex)
{
mbedtls_mpi X, Y, X0, Y0;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y );
- mbedtls_mpi_init( &X0 ); mbedtls_mpi_init( &Y0 );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y);
+ mbedtls_mpi_init(&X0); mbedtls_mpi_init(&Y0);
- TEST_ASSERT( mbedtls_test_read_mpi( &X0, X_hex ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y0, Y_hex ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X0, X_hex) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y0, Y_hex) == 0);
/* mbedtls_mpi_swap() */
- TEST_ASSERT( mbedtls_test_read_mpi( &X, X_hex ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, Y_hex ) == 0 );
- mbedtls_mpi_swap( &X, &Y );
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( sign_is_valid( &Y ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y0 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &X0 ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, X_hex) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, Y_hex) == 0);
+ mbedtls_mpi_swap(&X, &Y);
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(sign_is_valid(&Y));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &Y0) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Y, &X0) == 0);
/* mbedtls_mpi_safe_cond_swap(), swap done */
- mbedtls_mpi_free( &X );
- mbedtls_mpi_free( &Y );
- TEST_ASSERT( mbedtls_test_read_mpi( &X, X_hex ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, Y_hex ) == 0 );
- TEST_ASSERT( mbedtls_mpi_safe_cond_swap( &X, &Y, 1 ) == 0 );
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( sign_is_valid( &Y ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &Y0 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &X0 ) == 0 );
+ mbedtls_mpi_free(&X);
+ mbedtls_mpi_free(&Y);
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, X_hex) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, Y_hex) == 0);
+ TEST_ASSERT(mbedtls_mpi_safe_cond_swap(&X, &Y, 1) == 0);
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(sign_is_valid(&Y));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &Y0) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Y, &X0) == 0);
/* mbedtls_mpi_safe_cond_swap(), swap not done */
- mbedtls_mpi_free( &X );
- mbedtls_mpi_free( &Y );
- TEST_ASSERT( mbedtls_test_read_mpi( &X, X_hex ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, Y_hex ) == 0 );
- TEST_ASSERT( mbedtls_mpi_safe_cond_swap( &X, &Y, 0 ) == 0 );
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( sign_is_valid( &Y ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &X0 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &Y0 ) == 0 );
+ mbedtls_mpi_free(&X);
+ mbedtls_mpi_free(&Y);
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, X_hex) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, Y_hex) == 0);
+ TEST_ASSERT(mbedtls_mpi_safe_cond_swap(&X, &Y, 0) == 0);
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(sign_is_valid(&Y));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &X0) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Y, &Y0) == 0);
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y );
- mbedtls_mpi_free( &X0 ); mbedtls_mpi_free( &Y0 );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y);
+ mbedtls_mpi_free(&X0); mbedtls_mpi_free(&Y0);
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_swap_self( char *X_hex )
+void mpi_swap_self(char *X_hex)
{
mbedtls_mpi X, X0;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &X0 );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&X0);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, X_hex ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &X0, X_hex ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, X_hex) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&X0, X_hex) == 0);
- mbedtls_mpi_swap( &X, &X );
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &X0 ) == 0 );
+ mbedtls_mpi_swap(&X, &X);
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &X0) == 0);
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &X0 );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&X0);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_shrink( int before, int used, int min, int after )
+void mbedtls_mpi_shrink(int before, int used, int min, int after)
{
mbedtls_mpi X;
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&X);
- TEST_ASSERT( mbedtls_mpi_grow( &X, before ) == 0 );
- if( used > 0 )
- {
- size_t used_bit_count = used * 8 * sizeof( mbedtls_mpi_uint );
- TEST_ASSERT( mbedtls_mpi_set_bit( &X, used_bit_count - 1, 1 ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_grow(&X, before) == 0);
+ if (used > 0) {
+ size_t used_bit_count = used * 8 * sizeof(mbedtls_mpi_uint);
+ TEST_ASSERT(mbedtls_mpi_set_bit(&X, used_bit_count - 1, 1) == 0);
}
- TEST_EQUAL( X.n, (size_t) before );
- TEST_ASSERT( mbedtls_mpi_shrink( &X, min ) == 0 );
- TEST_EQUAL( X.n, (size_t) after );
+ TEST_EQUAL(X.n, (size_t) before);
+ TEST_ASSERT(mbedtls_mpi_shrink(&X, min) == 0);
+ TEST_EQUAL(X.n, (size_t) after);
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_add_mpi( char * input_X, char * input_Y,
- char * input_A )
+void mbedtls_mpi_add_mpi(char *input_X, char *input_Y,
+ char *input_A)
{
mbedtls_mpi X, Y, Z, A;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y); mbedtls_mpi_init(&Z); mbedtls_mpi_init(&A);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, input_Y ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- TEST_ASSERT( mbedtls_mpi_add_mpi( &Z, &X, &Y ) == 0 );
- TEST_ASSERT( sign_is_valid( &Z ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, input_Y) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ TEST_ASSERT(mbedtls_mpi_add_mpi(&Z, &X, &Y) == 0);
+ TEST_ASSERT(sign_is_valid(&Z));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Z, &A) == 0);
/* result == first operand */
- TEST_ASSERT( mbedtls_mpi_add_mpi( &X, &X, &Y ) == 0 );
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_add_mpi(&X, &X, &Y) == 0);
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &A) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
/* result == second operand */
- TEST_ASSERT( mbedtls_mpi_add_mpi( &Y, &X, &Y ) == 0 );
- TEST_ASSERT( sign_is_valid( &Y ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_add_mpi(&Y, &X, &Y) == 0);
+ TEST_ASSERT(sign_is_valid(&Y));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Y, &A) == 0);
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y); mbedtls_mpi_free(&Z); mbedtls_mpi_free(&A);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_add_mpi_inplace( char * input_X, char * input_A )
+void mbedtls_mpi_add_mpi_inplace(char *input_X, char *input_A)
{
mbedtls_mpi X, A;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &A );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&A);
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_mpi_sub_abs( &X, &X, &X ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_int( &X, 0 ) == 0 );
- TEST_ASSERT( sign_is_valid( &X ) );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_mpi_sub_abs(&X, &X, &X) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_int(&X, 0) == 0);
+ TEST_ASSERT(sign_is_valid(&X));
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_mpi_add_abs( &X, &X, &X ) == 0 );
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_mpi_add_abs(&X, &X, &X) == 0);
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &A) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_mpi_add_mpi( &X, &X, &X ) == 0 );
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_mpi_add_mpi(&X, &X, &X) == 0);
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &A) == 0);
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&A);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_add_abs( char * input_X, char * input_Y,
- char * input_A )
+void mbedtls_mpi_add_abs(char *input_X, char *input_Y,
+ char *input_A)
{
mbedtls_mpi X, Y, Z, A;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y); mbedtls_mpi_init(&Z); mbedtls_mpi_init(&A);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, input_Y ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- TEST_ASSERT( mbedtls_mpi_add_abs( &Z, &X, &Y ) == 0 );
- TEST_ASSERT( sign_is_valid( &Z ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, input_Y) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ TEST_ASSERT(mbedtls_mpi_add_abs(&Z, &X, &Y) == 0);
+ TEST_ASSERT(sign_is_valid(&Z));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Z, &A) == 0);
/* result == first operand */
- TEST_ASSERT( mbedtls_mpi_add_abs( &X, &X, &Y ) == 0 );
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_add_abs(&X, &X, &Y) == 0);
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &A) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
/* result == second operand */
- TEST_ASSERT( mbedtls_mpi_add_abs( &Y, &X, &Y ) == 0 );
- TEST_ASSERT( sign_is_valid( &Y ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_add_abs(&Y, &X, &Y) == 0);
+ TEST_ASSERT(sign_is_valid(&Y));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Y, &A) == 0);
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y); mbedtls_mpi_free(&Z); mbedtls_mpi_free(&A);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_add_int( char * input_X, int input_Y,
- char * input_A )
+void mbedtls_mpi_add_int(char *input_X, int input_Y,
+ char *input_A)
{
mbedtls_mpi X, Z, A;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Z); mbedtls_mpi_init(&A);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- TEST_ASSERT( mbedtls_mpi_add_int( &Z, &X, input_Y ) == 0 );
- TEST_ASSERT( sign_is_valid( &Z ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ TEST_ASSERT(mbedtls_mpi_add_int(&Z, &X, input_Y) == 0);
+ TEST_ASSERT(sign_is_valid(&Z));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Z, &A) == 0);
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Z); mbedtls_mpi_free(&A);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_sub_mpi( char * input_X, char * input_Y,
- char * input_A )
+void mbedtls_mpi_sub_mpi(char *input_X, char *input_Y,
+ char *input_A)
{
mbedtls_mpi X, Y, Z, A;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y); mbedtls_mpi_init(&Z); mbedtls_mpi_init(&A);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, input_Y ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- TEST_ASSERT( mbedtls_mpi_sub_mpi( &Z, &X, &Y ) == 0 );
- TEST_ASSERT( sign_is_valid( &Z ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, input_Y) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ TEST_ASSERT(mbedtls_mpi_sub_mpi(&Z, &X, &Y) == 0);
+ TEST_ASSERT(sign_is_valid(&Z));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Z, &A) == 0);
/* result == first operand */
- TEST_ASSERT( mbedtls_mpi_sub_mpi( &X, &X, &Y ) == 0 );
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_sub_mpi(&X, &X, &Y) == 0);
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &A) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
/* result == second operand */
- TEST_ASSERT( mbedtls_mpi_sub_mpi( &Y, &X, &Y ) == 0 );
- TEST_ASSERT( sign_is_valid( &Y ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_sub_mpi(&Y, &X, &Y) == 0);
+ TEST_ASSERT(sign_is_valid(&Y));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Y, &A) == 0);
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y); mbedtls_mpi_free(&Z); mbedtls_mpi_free(&A);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_sub_abs( char * input_X, char * input_Y,
- char * input_A, int sub_result )
+void mbedtls_mpi_sub_abs(char *input_X, char *input_Y,
+ char *input_A, int sub_result)
{
mbedtls_mpi X, Y, Z, A;
int res;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y); mbedtls_mpi_init(&Z); mbedtls_mpi_init(&A);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, input_Y ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, input_Y) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
- res = mbedtls_mpi_sub_abs( &Z, &X, &Y );
- TEST_ASSERT( res == sub_result );
- TEST_ASSERT( sign_is_valid( &Z ) );
- if( res == 0 )
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
+ res = mbedtls_mpi_sub_abs(&Z, &X, &Y);
+ TEST_ASSERT(res == sub_result);
+ TEST_ASSERT(sign_is_valid(&Z));
+ if (res == 0) {
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Z, &A) == 0);
+ }
/* result == first operand */
- TEST_ASSERT( mbedtls_mpi_sub_abs( &X, &X, &Y ) == sub_result );
- TEST_ASSERT( sign_is_valid( &X ) );
- if( sub_result == 0 )
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_sub_abs(&X, &X, &Y) == sub_result);
+ TEST_ASSERT(sign_is_valid(&X));
+ if (sub_result == 0) {
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &A) == 0);
+ }
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
/* result == second operand */
- TEST_ASSERT( mbedtls_mpi_sub_abs( &Y, &X, &Y ) == sub_result );
- TEST_ASSERT( sign_is_valid( &Y ) );
- if( sub_result == 0 )
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Y, &A ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_sub_abs(&Y, &X, &Y) == sub_result);
+ TEST_ASSERT(sign_is_valid(&Y));
+ if (sub_result == 0) {
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Y, &A) == 0);
+ }
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y); mbedtls_mpi_free(&Z); mbedtls_mpi_free(&A);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_sub_int( char * input_X, int input_Y,
- char * input_A )
+void mbedtls_mpi_sub_int(char *input_X, int input_Y,
+ char *input_A)
{
mbedtls_mpi X, Z, A;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Z); mbedtls_mpi_init(&A);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- TEST_ASSERT( mbedtls_mpi_sub_int( &Z, &X, input_Y ) == 0 );
- TEST_ASSERT( sign_is_valid( &Z ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ TEST_ASSERT(mbedtls_mpi_sub_int(&Z, &X, input_Y) == 0);
+ TEST_ASSERT(sign_is_valid(&Z));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Z, &A) == 0);
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Z); mbedtls_mpi_free(&A);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_mul_mpi( char * input_X, char * input_Y,
- char * input_A )
+void mbedtls_mpi_mul_mpi(char *input_X, char *input_Y,
+ char *input_A)
{
mbedtls_mpi X, Y, Z, A;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y); mbedtls_mpi_init(&Z); mbedtls_mpi_init(&A);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, input_Y ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- TEST_ASSERT( mbedtls_mpi_mul_mpi( &Z, &X, &Y ) == 0 );
- TEST_ASSERT( sign_is_valid( &Z ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, input_Y) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ TEST_ASSERT(mbedtls_mpi_mul_mpi(&Z, &X, &Y) == 0);
+ TEST_ASSERT(sign_is_valid(&Z));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Z, &A) == 0);
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y); mbedtls_mpi_free(&Z); mbedtls_mpi_free(&A);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_mul_int( char * input_X, int input_Y,
- char * input_A, char * result_comparison )
+void mbedtls_mpi_mul_int(char *input_X, int input_Y,
+ char *input_A, char *result_comparison)
{
mbedtls_mpi X, Z, A;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Z); mbedtls_mpi_init(&A);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- TEST_ASSERT( mbedtls_mpi_mul_int( &Z, &X, input_Y ) == 0 );
- TEST_ASSERT( sign_is_valid( &Z ) );
- if( strcmp( result_comparison, "==" ) == 0 )
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
- else if( strcmp( result_comparison, "!=" ) == 0 )
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) != 0 );
- else
- TEST_ASSERT( "unknown operator" == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ TEST_ASSERT(mbedtls_mpi_mul_int(&Z, &X, input_Y) == 0);
+ TEST_ASSERT(sign_is_valid(&Z));
+ if (strcmp(result_comparison, "==") == 0) {
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Z, &A) == 0);
+ } else if (strcmp(result_comparison, "!=") == 0) {
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Z, &A) != 0);
+ } else {
+ TEST_ASSERT("unknown operator" == 0);
+ }
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Z); mbedtls_mpi_free(&A);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_div_mpi( char * input_X, char * input_Y,
- char * input_A, char * input_B,
- int div_result )
+void mbedtls_mpi_div_mpi(char *input_X, char *input_Y,
+ char *input_A, char *input_B,
+ int div_result)
{
mbedtls_mpi X, Y, Q, R, A, B;
int res;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &R );
- mbedtls_mpi_init( &A ); mbedtls_mpi_init( &B );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y); mbedtls_mpi_init(&Q); mbedtls_mpi_init(&R);
+ mbedtls_mpi_init(&A); mbedtls_mpi_init(&B);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, input_Y ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &B, input_B ) == 0 );
- res = mbedtls_mpi_div_mpi( &Q, &R, &X, &Y );
- TEST_ASSERT( res == div_result );
- if( res == 0 )
- {
- TEST_ASSERT( sign_is_valid( &Q ) );
- TEST_ASSERT( sign_is_valid( &R ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Q, &A ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R, &B ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, input_Y) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&B, input_B) == 0);
+ res = mbedtls_mpi_div_mpi(&Q, &R, &X, &Y);
+ TEST_ASSERT(res == div_result);
+ if (res == 0) {
+ TEST_ASSERT(sign_is_valid(&Q));
+ TEST_ASSERT(sign_is_valid(&R));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Q, &A) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R, &B) == 0);
}
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &R );
- mbedtls_mpi_free( &A ); mbedtls_mpi_free( &B );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y); mbedtls_mpi_free(&Q); mbedtls_mpi_free(&R);
+ mbedtls_mpi_free(&A); mbedtls_mpi_free(&B);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_div_int( char * input_X, int input_Y,
- char * input_A, char * input_B,
- int div_result )
+void mbedtls_mpi_div_int(char *input_X, int input_Y,
+ char *input_A, char *input_B,
+ int div_result)
{
mbedtls_mpi X, Q, R, A, B;
int res;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &R ); mbedtls_mpi_init( &A );
- mbedtls_mpi_init( &B );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Q); mbedtls_mpi_init(&R); mbedtls_mpi_init(&A);
+ mbedtls_mpi_init(&B);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &B, input_B ) == 0 );
- res = mbedtls_mpi_div_int( &Q, &R, &X, input_Y );
- TEST_ASSERT( res == div_result );
- if( res == 0 )
- {
- TEST_ASSERT( sign_is_valid( &Q ) );
- TEST_ASSERT( sign_is_valid( &R ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Q, &A ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R, &B ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&B, input_B) == 0);
+ res = mbedtls_mpi_div_int(&Q, &R, &X, input_Y);
+ TEST_ASSERT(res == div_result);
+ if (res == 0) {
+ TEST_ASSERT(sign_is_valid(&Q));
+ TEST_ASSERT(sign_is_valid(&R));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Q, &A) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R, &B) == 0);
}
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &R ); mbedtls_mpi_free( &A );
- mbedtls_mpi_free( &B );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Q); mbedtls_mpi_free(&R); mbedtls_mpi_free(&A);
+ mbedtls_mpi_free(&B);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_mod_mpi( char * input_X, char * input_Y,
- char * input_A, int div_result )
+void mbedtls_mpi_mod_mpi(char *input_X, char *input_Y,
+ char *input_A, int div_result)
{
mbedtls_mpi X, Y, A;
int res;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &A );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y); mbedtls_mpi_init(&A);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, input_Y ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- res = mbedtls_mpi_mod_mpi( &X, &X, &Y );
- TEST_ASSERT( res == div_result );
- if( res == 0 )
- {
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, input_Y) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ res = mbedtls_mpi_mod_mpi(&X, &X, &Y);
+ TEST_ASSERT(res == div_result);
+ if (res == 0) {
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &A) == 0);
}
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y); mbedtls_mpi_free(&A);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_mod_int( char * input_X, char * input_Y,
- char * input_A, int mod_result )
+void mbedtls_mpi_mod_int(char *input_X, char *input_Y,
+ char *input_A, int mod_result)
{
mbedtls_mpi X;
mbedtls_mpi Y;
@@ -1192,18 +1190,18 @@
int res;
mbedtls_mpi_uint r;
- mbedtls_mpi_init( &X );
- mbedtls_mpi_init( &Y );
- mbedtls_mpi_init( &A );
+ mbedtls_mpi_init(&X);
+ mbedtls_mpi_init(&Y);
+ mbedtls_mpi_init(&A);
/* We use MPIs to read Y and A since the test framework limits us to
* ints, so we can't have 64-bit values */
- TEST_EQUAL( mbedtls_test_read_mpi( &X, input_X ), 0 );
- TEST_EQUAL( mbedtls_test_read_mpi( &Y, input_Y ), 0 );
- TEST_EQUAL( mbedtls_test_read_mpi( &A, input_A ), 0 );
+ TEST_EQUAL(mbedtls_test_read_mpi(&X, input_X), 0);
+ TEST_EQUAL(mbedtls_test_read_mpi(&Y, input_Y), 0);
+ TEST_EQUAL(mbedtls_test_read_mpi(&A, input_A), 0);
- TEST_EQUAL( Y.n, 1 );
- TEST_EQUAL( A.n, 1 );
+ TEST_EQUAL(Y.n, 1);
+ TEST_EQUAL(A.n, 1);
/* Convert the MPIs for Y and A to (signed) mbedtls_mpi_sints */
@@ -1214,301 +1212,297 @@
* easy to test for, and this helps guard against human error. */
mbedtls_mpi_sint y = (mbedtls_mpi_sint) Y.p[0];
- TEST_ASSERT( y >= 0 ); /* If y < 0 here, we can't make negative y */
- if( Y.s == -1 )
+ TEST_ASSERT(y >= 0); /* If y < 0 here, we can't make negative y */
+ if (Y.s == -1) {
y = -y;
+ }
mbedtls_mpi_sint a = (mbedtls_mpi_sint) A.p[0];
- TEST_ASSERT( a >= 0 ); /* Same goes for a */
- if( A.s == -1 )
+ TEST_ASSERT(a >= 0); /* Same goes for a */
+ if (A.s == -1) {
a = -a;
+ }
- res = mbedtls_mpi_mod_int( &r, &X, y );
- TEST_EQUAL( res, mod_result );
- if( res == 0 )
- {
- TEST_EQUAL( r, a );
+ res = mbedtls_mpi_mod_int(&r, &X, y);
+ TEST_EQUAL(res, mod_result);
+ if (res == 0) {
+ TEST_EQUAL(r, a);
}
exit:
- mbedtls_mpi_free( &X );
- mbedtls_mpi_free( &Y );
- mbedtls_mpi_free( &A );
+ mbedtls_mpi_free(&X);
+ mbedtls_mpi_free(&Y);
+ mbedtls_mpi_free(&A);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_exp_mod( char * input_A, char * input_E,
- char * input_N, char * input_X,
- int exp_result )
+void mbedtls_mpi_exp_mod(char *input_A, char *input_E,
+ char *input_N, char *input_X,
+ int exp_result)
{
mbedtls_mpi A, E, N, RR, Z, X;
int res;
- mbedtls_mpi_init( &A ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &N );
- mbedtls_mpi_init( &RR ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&A); mbedtls_mpi_init(&E); mbedtls_mpi_init(&N);
+ mbedtls_mpi_init(&RR); mbedtls_mpi_init(&Z); mbedtls_mpi_init(&X);
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
- res = mbedtls_mpi_exp_mod( &Z, &A, &E, &N, NULL );
- TEST_ASSERT( res == exp_result );
- if( res == 0 )
- {
- TEST_ASSERT( sign_is_valid( &Z ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &X ) == 0 );
+ res = mbedtls_mpi_exp_mod(&Z, &A, &E, &N, NULL);
+ TEST_ASSERT(res == exp_result);
+ if (res == 0) {
+ TEST_ASSERT(sign_is_valid(&Z));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Z, &X) == 0);
}
/* Now test again with the speed-up parameter supplied as an output. */
- res = mbedtls_mpi_exp_mod( &Z, &A, &E, &N, &RR );
- TEST_ASSERT( res == exp_result );
- if( res == 0 )
- {
- TEST_ASSERT( sign_is_valid( &Z ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &X ) == 0 );
+ res = mbedtls_mpi_exp_mod(&Z, &A, &E, &N, &RR);
+ TEST_ASSERT(res == exp_result);
+ if (res == 0) {
+ TEST_ASSERT(sign_is_valid(&Z));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Z, &X) == 0);
}
/* Now test again with the speed-up parameter supplied in calculated form. */
- res = mbedtls_mpi_exp_mod( &Z, &A, &E, &N, &RR );
- TEST_ASSERT( res == exp_result );
- if( res == 0 )
- {
- TEST_ASSERT( sign_is_valid( &Z ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &X ) == 0 );
+ res = mbedtls_mpi_exp_mod(&Z, &A, &E, &N, &RR);
+ TEST_ASSERT(res == exp_result);
+ if (res == 0) {
+ TEST_ASSERT(sign_is_valid(&Z));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Z, &X) == 0);
}
exit:
- mbedtls_mpi_free( &A ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &N );
- mbedtls_mpi_free( &RR ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&A); mbedtls_mpi_free(&E); mbedtls_mpi_free(&N);
+ mbedtls_mpi_free(&RR); mbedtls_mpi_free(&Z); mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_exp_mod_size( int A_bytes, int E_bytes, int N_bytes,
- char * input_RR, int exp_result )
+void mbedtls_mpi_exp_mod_size(int A_bytes, int E_bytes, int N_bytes,
+ char *input_RR, int exp_result)
{
mbedtls_mpi A, E, N, RR, Z;
- mbedtls_mpi_init( &A ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &N );
- mbedtls_mpi_init( &RR ); mbedtls_mpi_init( &Z );
+ mbedtls_mpi_init(&A); mbedtls_mpi_init(&E); mbedtls_mpi_init(&N);
+ mbedtls_mpi_init(&RR); mbedtls_mpi_init(&Z);
/* Set A to 2^(A_bytes - 1) + 1 */
- TEST_ASSERT( mbedtls_mpi_lset( &A, 1 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_shift_l( &A, ( A_bytes * 8 ) - 1 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_set_bit( &A, 0, 1 ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_lset(&A, 1) == 0);
+ TEST_ASSERT(mbedtls_mpi_shift_l(&A, (A_bytes * 8) - 1) == 0);
+ TEST_ASSERT(mbedtls_mpi_set_bit(&A, 0, 1) == 0);
/* Set E to 2^(E_bytes - 1) + 1 */
- TEST_ASSERT( mbedtls_mpi_lset( &E, 1 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_shift_l( &E, ( E_bytes * 8 ) - 1 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_set_bit( &E, 0, 1 ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_lset(&E, 1) == 0);
+ TEST_ASSERT(mbedtls_mpi_shift_l(&E, (E_bytes * 8) - 1) == 0);
+ TEST_ASSERT(mbedtls_mpi_set_bit(&E, 0, 1) == 0);
/* Set N to 2^(N_bytes - 1) + 1 */
- TEST_ASSERT( mbedtls_mpi_lset( &N, 1 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_shift_l( &N, ( N_bytes * 8 ) - 1 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_set_bit( &N, 0, 1 ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_lset(&N, 1) == 0);
+ TEST_ASSERT(mbedtls_mpi_shift_l(&N, (N_bytes * 8) - 1) == 0);
+ TEST_ASSERT(mbedtls_mpi_set_bit(&N, 0, 1) == 0);
- if( strlen( input_RR ) )
- TEST_ASSERT( mbedtls_test_read_mpi( &RR, input_RR ) == 0 );
+ if (strlen(input_RR)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&RR, input_RR) == 0);
+ }
- TEST_ASSERT( mbedtls_mpi_exp_mod( &Z, &A, &E, &N, &RR ) == exp_result );
+ TEST_ASSERT(mbedtls_mpi_exp_mod(&Z, &A, &E, &N, &RR) == exp_result);
exit:
- mbedtls_mpi_free( &A ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &N );
- mbedtls_mpi_free( &RR ); mbedtls_mpi_free( &Z );
+ mbedtls_mpi_free(&A); mbedtls_mpi_free(&E); mbedtls_mpi_free(&N);
+ mbedtls_mpi_free(&RR); mbedtls_mpi_free(&Z);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_inv_mod( char * input_X, char * input_Y,
- char * input_A, int div_result )
+void mbedtls_mpi_inv_mod(char *input_X, char *input_Y,
+ char *input_A, int div_result)
{
mbedtls_mpi X, Y, Z, A;
int res;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z ); mbedtls_mpi_init( &A );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y); mbedtls_mpi_init(&Z); mbedtls_mpi_init(&A);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, input_Y ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- res = mbedtls_mpi_inv_mod( &Z, &X, &Y );
- TEST_ASSERT( res == div_result );
- if( res == 0 )
- {
- TEST_ASSERT( sign_is_valid( &Z ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Z, &A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, input_Y) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ res = mbedtls_mpi_inv_mod(&Z, &X, &Y);
+ TEST_ASSERT(res == div_result);
+ if (res == 0) {
+ TEST_ASSERT(sign_is_valid(&Z));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Z, &A) == 0);
}
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y); mbedtls_mpi_free(&Z); mbedtls_mpi_free(&A);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_GENPRIME */
-void mbedtls_mpi_is_prime( char * input_X, int div_result )
+void mbedtls_mpi_is_prime(char *input_X, int div_result)
{
mbedtls_mpi X;
int res;
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&X);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- res = mbedtls_mpi_is_prime_ext( &X, 40, mbedtls_test_rnd_std_rand, NULL );
- TEST_ASSERT( res == div_result );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ res = mbedtls_mpi_is_prime_ext(&X, 40, mbedtls_test_rnd_std_rand, NULL);
+ TEST_ASSERT(res == div_result);
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_GENPRIME */
-void mbedtls_mpi_is_prime_det( data_t * input_X, data_t * witnesses,
- int chunk_len, int rounds )
+void mbedtls_mpi_is_prime_det(data_t *input_X, data_t *witnesses,
+ int chunk_len, int rounds)
{
mbedtls_mpi X;
int res;
mbedtls_test_mpi_random rand;
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&X);
rand.data = witnesses;
rand.pos = 0;
rand.chunk_len = chunk_len;
- TEST_ASSERT( mbedtls_mpi_read_binary( &X, input_X->x, input_X->len ) == 0 );
- res = mbedtls_mpi_is_prime_ext( &X, rounds - 1,
- mbedtls_test_mpi_miller_rabin_determinizer,
- &rand );
- TEST_ASSERT( res == 0 );
+ TEST_ASSERT(mbedtls_mpi_read_binary(&X, input_X->x, input_X->len) == 0);
+ res = mbedtls_mpi_is_prime_ext(&X, rounds - 1,
+ mbedtls_test_mpi_miller_rabin_determinizer,
+ &rand);
+ TEST_ASSERT(res == 0);
rand.data = witnesses;
rand.pos = 0;
rand.chunk_len = chunk_len;
- res = mbedtls_mpi_is_prime_ext( &X, rounds,
- mbedtls_test_mpi_miller_rabin_determinizer,
- &rand );
- TEST_ASSERT( res == MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
+ res = mbedtls_mpi_is_prime_ext(&X, rounds,
+ mbedtls_test_mpi_miller_rabin_determinizer,
+ &rand);
+ TEST_ASSERT(res == MBEDTLS_ERR_MPI_NOT_ACCEPTABLE);
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_GENPRIME */
-void mbedtls_mpi_gen_prime( int bits, int flags, int ref_ret )
+void mbedtls_mpi_gen_prime(int bits, int flags, int ref_ret)
{
mbedtls_mpi X;
int my_ret;
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&X);
- my_ret = mbedtls_mpi_gen_prime( &X, bits, flags,
- mbedtls_test_rnd_std_rand, NULL );
- TEST_ASSERT( my_ret == ref_ret );
+ my_ret = mbedtls_mpi_gen_prime(&X, bits, flags,
+ mbedtls_test_rnd_std_rand, NULL);
+ TEST_ASSERT(my_ret == ref_ret);
- if( ref_ret == 0 )
- {
- size_t actual_bits = mbedtls_mpi_bitlen( &X );
+ if (ref_ret == 0) {
+ size_t actual_bits = mbedtls_mpi_bitlen(&X);
- TEST_ASSERT( actual_bits >= (size_t) bits );
- TEST_ASSERT( actual_bits <= (size_t) bits + 1 );
- TEST_ASSERT( sign_is_valid( &X ) );
+ TEST_ASSERT(actual_bits >= (size_t) bits);
+ TEST_ASSERT(actual_bits <= (size_t) bits + 1);
+ TEST_ASSERT(sign_is_valid(&X));
- TEST_ASSERT( mbedtls_mpi_is_prime_ext( &X, 40,
- mbedtls_test_rnd_std_rand,
- NULL ) == 0 );
- if( flags & MBEDTLS_MPI_GEN_PRIME_FLAG_DH )
- {
+ TEST_ASSERT(mbedtls_mpi_is_prime_ext(&X, 40,
+ mbedtls_test_rnd_std_rand,
+ NULL) == 0);
+ if (flags & MBEDTLS_MPI_GEN_PRIME_FLAG_DH) {
/* X = ( X - 1 ) / 2 */
- TEST_ASSERT( mbedtls_mpi_shift_r( &X, 1 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_is_prime_ext( &X, 40,
- mbedtls_test_rnd_std_rand,
- NULL ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_shift_r(&X, 1) == 0);
+ TEST_ASSERT(mbedtls_mpi_is_prime_ext(&X, 40,
+ mbedtls_test_rnd_std_rand,
+ NULL) == 0);
}
}
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_shift_l( char * input_X, int shift_X,
- char * input_A )
+void mbedtls_mpi_shift_l(char *input_X, int shift_X,
+ char *input_A)
{
mbedtls_mpi X, A;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &A );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&A);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- TEST_ASSERT( mbedtls_mpi_shift_l( &X, shift_X ) == 0 );
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ TEST_ASSERT(mbedtls_mpi_shift_l(&X, shift_X) == 0);
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &A) == 0);
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&A);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_mpi_shift_r( char * input_X, int shift_X,
- char * input_A )
+void mbedtls_mpi_shift_r(char *input_X, int shift_X,
+ char *input_A)
{
mbedtls_mpi X, A;
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &A );
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&A);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, input_X ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &A, input_A ) == 0 );
- TEST_ASSERT( mbedtls_mpi_shift_r( &X, shift_X ) == 0 );
- TEST_ASSERT( sign_is_valid( &X ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &X, &A ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, input_X) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&A, input_A) == 0);
+ TEST_ASSERT(mbedtls_mpi_shift_r(&X, shift_X) == 0);
+ TEST_ASSERT(sign_is_valid(&X));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&X, &A) == 0);
exit:
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &A );
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&A);
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_fill_random( int wanted_bytes, int rng_bytes,
- int before, int expected_ret )
+void mpi_fill_random(int wanted_bytes, int rng_bytes,
+ int before, int expected_ret)
{
mbedtls_mpi X;
int ret;
size_t bytes_left = rng_bytes;
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&X);
- if( before != 0 )
- {
+ if (before != 0) {
/* Set X to sign(before) * 2^(|before|-1) */
- TEST_ASSERT( mbedtls_mpi_lset( &X, before > 0 ? 1 : -1 ) == 0 );
- if( before < 0 )
- before = - before;
- TEST_ASSERT( mbedtls_mpi_shift_l( &X, before - 1 ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_lset(&X, before > 0 ? 1 : -1) == 0);
+ if (before < 0) {
+ before = -before;
+ }
+ TEST_ASSERT(mbedtls_mpi_shift_l(&X, before - 1) == 0);
}
- ret = mbedtls_mpi_fill_random( &X, wanted_bytes,
- f_rng_bytes_left, &bytes_left );
- TEST_ASSERT( ret == expected_ret );
+ ret = mbedtls_mpi_fill_random(&X, wanted_bytes,
+ f_rng_bytes_left, &bytes_left);
+ TEST_ASSERT(ret == expected_ret);
- if( expected_ret == 0 )
- {
+ if (expected_ret == 0) {
/* mbedtls_mpi_fill_random is documented to use bytes from the RNG
* as a big-endian representation of the number. We know when
* our RNG function returns null bytes, so we know how many
* leading zero bytes the number has. */
size_t leading_zeros = 0;
- if( wanted_bytes > 0 && rng_bytes % 256 == 0 )
+ if (wanted_bytes > 0 && rng_bytes % 256 == 0) {
leading_zeros = 1;
- TEST_ASSERT( mbedtls_mpi_size( &X ) + leading_zeros ==
- (size_t) wanted_bytes );
- TEST_ASSERT( (int) bytes_left == rng_bytes - wanted_bytes );
- TEST_ASSERT( sign_is_valid( &X ) );
+ }
+ TEST_ASSERT(mbedtls_mpi_size(&X) + leading_zeros ==
+ (size_t) wanted_bytes);
+ TEST_ASSERT((int) bytes_left == rng_bytes - wanted_bytes);
+ TEST_ASSERT(sign_is_valid(&X));
}
exit:
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_random_many( int min, data_t *bound_bytes, int iterations )
+void mpi_random_many(int min, data_t *bound_bytes, int iterations)
{
/* Generate numbers in the range 1..bound-1. Do it iterations times.
* This function assumes that the value of bound is at least 2 and
@@ -1528,71 +1522,60 @@
int full_stats;
size_t i;
- mbedtls_mpi_init( &upper_bound );
- mbedtls_mpi_init( &result );
+ mbedtls_mpi_init(&upper_bound);
+ mbedtls_mpi_init(&result);
- TEST_EQUAL( 0, mbedtls_mpi_read_binary( &upper_bound,
- bound_bytes->x, bound_bytes->len ) );
- n_bits = mbedtls_mpi_bitlen( &upper_bound );
+ TEST_EQUAL(0, mbedtls_mpi_read_binary(&upper_bound,
+ bound_bytes->x, bound_bytes->len));
+ n_bits = mbedtls_mpi_bitlen(&upper_bound);
/* Consider a bound "small" if it's less than 2^5. This value is chosen
* to be small enough that the probability of missing one value is
* negligible given the number of iterations. It must be less than
* 256 because some of the code below assumes that "small" values
* fit in a byte. */
- if( n_bits <= 5 )
- {
+ if (n_bits <= 5) {
full_stats = 1;
stats_len = bound_bytes->x[bound_bytes->len - 1];
- }
- else
- {
+ } else {
full_stats = 0;
stats_len = n_bits;
}
- ASSERT_ALLOC( stats, stats_len );
+ ASSERT_ALLOC(stats, stats_len);
- for( i = 0; i < (size_t) iterations; i++ )
- {
- mbedtls_test_set_step( i );
- TEST_EQUAL( 0, mbedtls_mpi_random( &result, min, &upper_bound,
- mbedtls_test_rnd_std_rand, NULL ) );
+ for (i = 0; i < (size_t) iterations; i++) {
+ mbedtls_test_set_step(i);
+ TEST_EQUAL(0, mbedtls_mpi_random(&result, min, &upper_bound,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_ASSERT( sign_is_valid( &result ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &result, &upper_bound ) < 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_int( &result, min ) >= 0 );
- if( full_stats )
- {
+ TEST_ASSERT(sign_is_valid(&result));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&result, &upper_bound) < 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_int(&result, min) >= 0);
+ if (full_stats) {
uint8_t value;
- TEST_EQUAL( 0, mbedtls_mpi_write_binary( &result, &value, 1 ) );
- TEST_ASSERT( value < stats_len );
+ TEST_EQUAL(0, mbedtls_mpi_write_binary(&result, &value, 1));
+ TEST_ASSERT(value < stats_len);
++stats[value];
- }
- else
- {
- for( b = 0; b < n_bits; b++ )
- stats[b] += mbedtls_mpi_get_bit( &result, b );
+ } else {
+ for (b = 0; b < n_bits; b++) {
+ stats[b] += mbedtls_mpi_get_bit(&result, b);
+ }
}
}
- if( full_stats )
- {
- for( b = min; b < stats_len; b++ )
- {
- mbedtls_test_set_step( 1000000 + b );
+ if (full_stats) {
+ for (b = min; b < stats_len; b++) {
+ mbedtls_test_set_step(1000000 + b);
/* Assert that each value has been reached at least once.
* This is almost guaranteed if the iteration count is large
* enough. This is a very crude way of checking the distribution.
*/
- TEST_ASSERT( stats[b] > 0 );
+ TEST_ASSERT(stats[b] > 0);
}
- }
- else
- {
+ } else {
int statistically_safe_all_the_way =
- is_significantly_above_a_power_of_2( bound_bytes );
- for( b = 0; b < n_bits; b++ )
- {
- mbedtls_test_set_step( 1000000 + b );
+ is_significantly_above_a_power_of_2(bound_bytes);
+ for (b = 0; b < n_bits; b++) {
+ mbedtls_test_set_step(1000000 + b);
/* Assert that each bit has been set in at least one result and
* clear in at least one result. Provided that iterations is not
* too small, it would be extremely unlikely for this not to be
@@ -1601,78 +1584,77 @@
* As an exception, the top bit may legitimately never be set
* if bound is a power of 2 or only slightly above.
*/
- if( statistically_safe_all_the_way || b != n_bits - 1 )
- {
- TEST_ASSERT( stats[b] > 0 );
+ if (statistically_safe_all_the_way || b != n_bits - 1) {
+ TEST_ASSERT(stats[b] > 0);
}
- TEST_ASSERT( stats[b] < (size_t) iterations );
+ TEST_ASSERT(stats[b] < (size_t) iterations);
}
}
exit:
- mbedtls_mpi_free( &upper_bound );
- mbedtls_mpi_free( &result );
- mbedtls_free( stats );
+ mbedtls_mpi_free(&upper_bound);
+ mbedtls_mpi_free(&result);
+ mbedtls_free(stats);
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_random_sizes( int min, data_t *bound_bytes, int nlimbs, int before )
+void mpi_random_sizes(int min, data_t *bound_bytes, int nlimbs, int before)
{
mbedtls_mpi upper_bound;
mbedtls_mpi result;
- mbedtls_mpi_init( &upper_bound );
- mbedtls_mpi_init( &result );
+ mbedtls_mpi_init(&upper_bound);
+ mbedtls_mpi_init(&result);
- if( before != 0 )
- {
+ if (before != 0) {
/* Set result to sign(before) * 2^(|before|-1) */
- TEST_ASSERT( mbedtls_mpi_lset( &result, before > 0 ? 1 : -1 ) == 0 );
- if( before < 0 )
- before = - before;
- TEST_ASSERT( mbedtls_mpi_shift_l( &result, before - 1 ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_lset(&result, before > 0 ? 1 : -1) == 0);
+ if (before < 0) {
+ before = -before;
+ }
+ TEST_ASSERT(mbedtls_mpi_shift_l(&result, before - 1) == 0);
}
- TEST_EQUAL( 0, mbedtls_mpi_grow( &result, nlimbs ) );
- TEST_EQUAL( 0, mbedtls_mpi_read_binary( &upper_bound,
- bound_bytes->x, bound_bytes->len ) );
- TEST_EQUAL( 0, mbedtls_mpi_random( &result, min, &upper_bound,
- mbedtls_test_rnd_std_rand, NULL ) );
- TEST_ASSERT( sign_is_valid( &result ) );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &result, &upper_bound ) < 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_int( &result, min ) >= 0 );
+ TEST_EQUAL(0, mbedtls_mpi_grow(&result, nlimbs));
+ TEST_EQUAL(0, mbedtls_mpi_read_binary(&upper_bound,
+ bound_bytes->x, bound_bytes->len));
+ TEST_EQUAL(0, mbedtls_mpi_random(&result, min, &upper_bound,
+ mbedtls_test_rnd_std_rand, NULL));
+ TEST_ASSERT(sign_is_valid(&result));
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&result, &upper_bound) < 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_int(&result, min) >= 0);
exit:
- mbedtls_mpi_free( &upper_bound );
- mbedtls_mpi_free( &result );
+ mbedtls_mpi_free(&upper_bound);
+ mbedtls_mpi_free(&result);
}
/* END_CASE */
/* BEGIN_CASE */
-void mpi_random_fail( int min, data_t *bound_bytes, int expected_ret )
+void mpi_random_fail(int min, data_t *bound_bytes, int expected_ret)
{
mbedtls_mpi upper_bound;
mbedtls_mpi result;
int actual_ret;
- mbedtls_mpi_init( &upper_bound );
- mbedtls_mpi_init( &result );
+ mbedtls_mpi_init(&upper_bound);
+ mbedtls_mpi_init(&result);
- TEST_EQUAL( 0, mbedtls_mpi_read_binary( &upper_bound,
- bound_bytes->x, bound_bytes->len ) );
- actual_ret = mbedtls_mpi_random( &result, min, &upper_bound,
- mbedtls_test_rnd_std_rand, NULL );
- TEST_EQUAL( expected_ret, actual_ret );
+ TEST_EQUAL(0, mbedtls_mpi_read_binary(&upper_bound,
+ bound_bytes->x, bound_bytes->len));
+ actual_ret = mbedtls_mpi_random(&result, min, &upper_bound,
+ mbedtls_test_rnd_std_rand, NULL);
+ TEST_EQUAL(expected_ret, actual_ret);
exit:
- mbedtls_mpi_free( &upper_bound );
- mbedtls_mpi_free( &result );
+ mbedtls_mpi_free(&upper_bound);
+ mbedtls_mpi_free(&result);
}
/* END_CASE */
/* BEGIN_CASE */
-void most_negative_mpi_sint( )
+void most_negative_mpi_sint()
{
/* Ad hoc tests for n = -p = -2^(biL-1) as a mbedtls_mpi_sint. We
* guarantee that mbedtls_mpi_sint is a two's complement type, so this
@@ -1690,134 +1672,134 @@
*/
mbedtls_mpi A, R, X;
- mbedtls_mpi_init( &A );
- mbedtls_mpi_init( &R );
- mbedtls_mpi_init( &X );
+ mbedtls_mpi_init(&A);
+ mbedtls_mpi_init(&R);
+ mbedtls_mpi_init(&X);
- const size_t biL = 8 * sizeof( mbedtls_mpi_sint );
- mbedtls_mpi_uint most_positive_plus_1 = (mbedtls_mpi_uint) 1 << ( biL - 1 );
+ const size_t biL = 8 * sizeof(mbedtls_mpi_sint);
+ mbedtls_mpi_uint most_positive_plus_1 = (mbedtls_mpi_uint) 1 << (biL - 1);
const mbedtls_mpi_sint most_positive = most_positive_plus_1 - 1;
- const mbedtls_mpi_sint most_negative = - most_positive - 1;
- TEST_EQUAL( (mbedtls_mpi_uint) most_negative,
- (mbedtls_mpi_uint) 1 << ( biL - 1 ) );
- TEST_EQUAL( (mbedtls_mpi_uint) most_negative << 1, 0 );
+ const mbedtls_mpi_sint most_negative = -most_positive - 1;
+ TEST_EQUAL((mbedtls_mpi_uint) most_negative,
+ (mbedtls_mpi_uint) 1 << (biL - 1));
+ TEST_EQUAL((mbedtls_mpi_uint) most_negative << 1, 0);
/* Test mbedtls_mpi_lset() */
- TEST_EQUAL( mbedtls_mpi_lset( &A, most_negative ), 0 );
- TEST_EQUAL( A.s, -1 );
- TEST_EQUAL( A.n, 1 );
- TEST_EQUAL( A.p[0], most_positive_plus_1 );
+ TEST_EQUAL(mbedtls_mpi_lset(&A, most_negative), 0);
+ TEST_EQUAL(A.s, -1);
+ TEST_EQUAL(A.n, 1);
+ TEST_EQUAL(A.p[0], most_positive_plus_1);
/* Test mbedtls_mpi_cmp_int(): -p == -p */
- TEST_EQUAL( mbedtls_mpi_cmp_int( &A, most_negative ), 0 );
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&A, most_negative), 0);
/* Test mbedtls_mpi_cmp_int(): -(p+1) < -p */
A.p[0] = most_positive_plus_1 + 1;
- TEST_EQUAL( mbedtls_mpi_cmp_int( &A, most_negative ), -1 );
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&A, most_negative), -1);
/* Test mbedtls_mpi_cmp_int(): -(p-1) > -p */
A.p[0] = most_positive_plus_1 - 1;
- TEST_EQUAL( mbedtls_mpi_cmp_int( &A, most_negative ), 1 );
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&A, most_negative), 1);
/* Test mbedtls_mpi_add_int(): (p-1) + (-p) */
- TEST_EQUAL( mbedtls_mpi_lset( &A, most_positive ), 0 );
- TEST_EQUAL( mbedtls_mpi_add_int( &X, &A, most_negative ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &X, -1 ), 0 );
+ TEST_EQUAL(mbedtls_mpi_lset(&A, most_positive), 0);
+ TEST_EQUAL(mbedtls_mpi_add_int(&X, &A, most_negative), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&X, -1), 0);
/* Test mbedtls_mpi_add_int(): (0) + (-p) */
- TEST_EQUAL( mbedtls_mpi_lset( &A, 0 ), 0 );
- TEST_EQUAL( mbedtls_mpi_add_int( &X, &A, most_negative ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &X, most_negative ), 0 );
+ TEST_EQUAL(mbedtls_mpi_lset(&A, 0), 0);
+ TEST_EQUAL(mbedtls_mpi_add_int(&X, &A, most_negative), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&X, most_negative), 0);
/* Test mbedtls_mpi_add_int(): (-p) + (-p) */
- TEST_EQUAL( mbedtls_mpi_lset( &A, most_negative ), 0 );
- TEST_EQUAL( mbedtls_mpi_add_int( &X, &A, most_negative ), 0 );
- TEST_EQUAL( X.s, -1 );
- TEST_EQUAL( X.n, 2 );
- TEST_EQUAL( X.p[0], 0 );
- TEST_EQUAL( X.p[1], 1 );
+ TEST_EQUAL(mbedtls_mpi_lset(&A, most_negative), 0);
+ TEST_EQUAL(mbedtls_mpi_add_int(&X, &A, most_negative), 0);
+ TEST_EQUAL(X.s, -1);
+ TEST_EQUAL(X.n, 2);
+ TEST_EQUAL(X.p[0], 0);
+ TEST_EQUAL(X.p[1], 1);
/* Test mbedtls_mpi_sub_int(): (p) - (-p) */
- mbedtls_mpi_free( &X );
- TEST_EQUAL( mbedtls_mpi_lset( &A, most_positive ), 0 );
- TEST_EQUAL( mbedtls_mpi_sub_int( &X, &A, most_negative ), 0 );
- TEST_EQUAL( X.s, 1 );
- TEST_EQUAL( X.n, 1 );
- TEST_EQUAL( X.p[0], ~(mbedtls_mpi_uint)0 );
+ mbedtls_mpi_free(&X);
+ TEST_EQUAL(mbedtls_mpi_lset(&A, most_positive), 0);
+ TEST_EQUAL(mbedtls_mpi_sub_int(&X, &A, most_negative), 0);
+ TEST_EQUAL(X.s, 1);
+ TEST_EQUAL(X.n, 1);
+ TEST_EQUAL(X.p[0], ~(mbedtls_mpi_uint) 0);
/* Test mbedtls_mpi_sub_int(): (0) - (-p) */
- TEST_EQUAL( mbedtls_mpi_lset( &A, 0 ), 0 );
- TEST_EQUAL( mbedtls_mpi_sub_int( &X, &A, most_negative ), 0 );
- TEST_EQUAL( X.s, 1 );
- TEST_EQUAL( X.n, 1 );
- TEST_EQUAL( X.p[0], most_positive_plus_1 );
+ TEST_EQUAL(mbedtls_mpi_lset(&A, 0), 0);
+ TEST_EQUAL(mbedtls_mpi_sub_int(&X, &A, most_negative), 0);
+ TEST_EQUAL(X.s, 1);
+ TEST_EQUAL(X.n, 1);
+ TEST_EQUAL(X.p[0], most_positive_plus_1);
/* Test mbedtls_mpi_sub_int(): (-p) - (-p) */
- TEST_EQUAL( mbedtls_mpi_lset( &A, most_negative ), 0 );
- TEST_EQUAL( mbedtls_mpi_sub_int( &X, &A, most_negative ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &X, 0 ), 0 );
+ TEST_EQUAL(mbedtls_mpi_lset(&A, most_negative), 0);
+ TEST_EQUAL(mbedtls_mpi_sub_int(&X, &A, most_negative), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&X, 0), 0);
/* Test mbedtls_mpi_div_int(): (-p+1) / (-p) */
- TEST_EQUAL( mbedtls_mpi_lset( &A, -most_positive ), 0 );
- TEST_EQUAL( mbedtls_mpi_div_int( &X, &R, &A, most_negative ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &X, 0 ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &R, -most_positive ), 0 );
+ TEST_EQUAL(mbedtls_mpi_lset(&A, -most_positive), 0);
+ TEST_EQUAL(mbedtls_mpi_div_int(&X, &R, &A, most_negative), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&X, 0), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&R, -most_positive), 0);
/* Test mbedtls_mpi_div_int(): (-p) / (-p) */
- TEST_EQUAL( mbedtls_mpi_lset( &A, most_negative ), 0 );
- TEST_EQUAL( mbedtls_mpi_div_int( &X, &R, &A, most_negative ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &X, 1 ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &R, 0 ), 0 );
+ TEST_EQUAL(mbedtls_mpi_lset(&A, most_negative), 0);
+ TEST_EQUAL(mbedtls_mpi_div_int(&X, &R, &A, most_negative), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&X, 1), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&R, 0), 0);
/* Test mbedtls_mpi_div_int(): (-2*p) / (-p) */
- TEST_EQUAL( mbedtls_mpi_shift_l( &A, 1 ), 0 );
- TEST_EQUAL( mbedtls_mpi_div_int( &X, &R, &A, most_negative ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &X, 2 ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &R, 0 ), 0 );
+ TEST_EQUAL(mbedtls_mpi_shift_l(&A, 1), 0);
+ TEST_EQUAL(mbedtls_mpi_div_int(&X, &R, &A, most_negative), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&X, 2), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&R, 0), 0);
/* Test mbedtls_mpi_div_int(): (-2*p+1) / (-p) */
- TEST_EQUAL( mbedtls_mpi_add_int( &A, &A, 1 ), 0 );
- TEST_EQUAL( mbedtls_mpi_div_int( &X, &R, &A, most_negative ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &X, 1 ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &R, -most_positive ), 0 );
+ TEST_EQUAL(mbedtls_mpi_add_int(&A, &A, 1), 0);
+ TEST_EQUAL(mbedtls_mpi_div_int(&X, &R, &A, most_negative), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&X, 1), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&R, -most_positive), 0);
/* Test mbedtls_mpi_div_int(): (p-1) / (-p) */
- TEST_EQUAL( mbedtls_mpi_lset( &A, most_positive ), 0 );
- TEST_EQUAL( mbedtls_mpi_div_int( &X, &R, &A, most_negative ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &X, 0 ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &R, most_positive ), 0 );
+ TEST_EQUAL(mbedtls_mpi_lset(&A, most_positive), 0);
+ TEST_EQUAL(mbedtls_mpi_div_int(&X, &R, &A, most_negative), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&X, 0), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&R, most_positive), 0);
/* Test mbedtls_mpi_div_int(): (p) / (-p) */
- TEST_EQUAL( mbedtls_mpi_add_int( &A, &A, 1 ), 0 );
- TEST_EQUAL( mbedtls_mpi_div_int( &X, &R, &A, most_negative ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &X, -1 ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &R, 0 ), 0 );
+ TEST_EQUAL(mbedtls_mpi_add_int(&A, &A, 1), 0);
+ TEST_EQUAL(mbedtls_mpi_div_int(&X, &R, &A, most_negative), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&X, -1), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&R, 0), 0);
/* Test mbedtls_mpi_div_int(): (2*p) / (-p) */
- TEST_EQUAL( mbedtls_mpi_shift_l( &A, 1 ), 0 );
- TEST_EQUAL( mbedtls_mpi_div_int( &X, &R, &A, most_negative ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &X, -2 ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_int( &R, 0 ), 0 );
+ TEST_EQUAL(mbedtls_mpi_shift_l(&A, 1), 0);
+ TEST_EQUAL(mbedtls_mpi_div_int(&X, &R, &A, most_negative), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&X, -2), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_int(&R, 0), 0);
/* Test mbedtls_mpi_mod_int(): never valid */
- TEST_EQUAL( mbedtls_mpi_mod_int( X.p, &A, most_negative ),
- MBEDTLS_ERR_MPI_NEGATIVE_VALUE );
+ TEST_EQUAL(mbedtls_mpi_mod_int(X.p, &A, most_negative),
+ MBEDTLS_ERR_MPI_NEGATIVE_VALUE);
/* Test mbedtls_mpi_random(): never valid */
- TEST_EQUAL( mbedtls_mpi_random( &X, most_negative, &A,
- mbedtls_test_rnd_std_rand, NULL ),
- MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
+ TEST_EQUAL(mbedtls_mpi_random(&X, most_negative, &A,
+ mbedtls_test_rnd_std_rand, NULL),
+ MBEDTLS_ERR_MPI_BAD_INPUT_DATA);
exit:
- mbedtls_mpi_free( &A );
- mbedtls_mpi_free( &R );
- mbedtls_mpi_free( &X );
+ mbedtls_mpi_free(&A);
+ mbedtls_mpi_free(&R);
+ mbedtls_mpi_free(&X);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void mpi_selftest( )
+void mpi_selftest()
{
- TEST_ASSERT( mbedtls_mpi_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_blowfish.function b/tests/suites/test_suite_blowfish.function
index f89353c..9541711 100644
--- a/tests/suites/test_suite_blowfish.function
+++ b/tests/suites/test_suite_blowfish.function
@@ -8,156 +8,156 @@
*/
/* BEGIN_CASE */
-void blowfish_valid_param( )
+void blowfish_valid_param()
{
- TEST_VALID_PARAM( mbedtls_blowfish_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_blowfish_free(NULL));
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void blowfish_invalid_param( )
+void blowfish_invalid_param()
{
mbedtls_blowfish_context ctx;
unsigned char buf[16] = { 0 };
- size_t const valid_keylength = sizeof( buf ) * 8;
+ size_t const valid_keylength = sizeof(buf) * 8;
size_t valid_mode = MBEDTLS_BLOWFISH_ENCRYPT;
size_t invalid_mode = 42;
size_t off;
((void) off);
- TEST_INVALID_PARAM( mbedtls_blowfish_init( NULL ) );
- TEST_VALID_PARAM( mbedtls_blowfish_free( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_blowfish_init(NULL));
+ TEST_VALID_PARAM(mbedtls_blowfish_free(NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_setkey( NULL,
- buf,
- valid_keylength ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_setkey( &ctx,
- NULL,
- valid_keylength ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_setkey(NULL,
+ buf,
+ valid_keylength));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_setkey(&ctx,
+ NULL,
+ valid_keylength));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_ecb( NULL,
- valid_mode,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_ecb( &ctx,
- invalid_mode,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_ecb( &ctx,
- valid_mode,
- NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_ecb( &ctx,
- valid_mode,
- buf, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_ecb(NULL,
+ valid_mode,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_ecb(&ctx,
+ invalid_mode,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_ecb(&ctx,
+ valid_mode,
+ NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_ecb(&ctx,
+ valid_mode,
+ buf, NULL));
#if defined(MBEDTLS_CIPHER_MODE_CBC)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_cbc( NULL,
- valid_mode,
- sizeof( buf ),
- buf, buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_cbc( &ctx,
- invalid_mode,
- sizeof( buf ),
- buf, buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_cbc( &ctx,
- valid_mode,
- sizeof( buf ),
- NULL, buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_cbc( &ctx,
- valid_mode,
- sizeof( buf ),
- buf, NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_cbc( &ctx,
- valid_mode,
- sizeof( buf ),
- buf, buf, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_cbc(NULL,
+ valid_mode,
+ sizeof(buf),
+ buf, buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_cbc(&ctx,
+ invalid_mode,
+ sizeof(buf),
+ buf, buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_cbc(&ctx,
+ valid_mode,
+ sizeof(buf),
+ NULL, buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_cbc(&ctx,
+ valid_mode,
+ sizeof(buf),
+ buf, NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_cbc(&ctx,
+ valid_mode,
+ sizeof(buf),
+ buf, buf, NULL));
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_cfb64( NULL,
- valid_mode,
- sizeof( buf ),
- &off, buf,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_cfb64( &ctx,
- invalid_mode,
- sizeof( buf ),
- &off, buf,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_cfb64( &ctx,
- valid_mode,
- sizeof( buf ),
- NULL, buf,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_cfb64( &ctx,
- valid_mode,
- sizeof( buf ),
- &off, NULL,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_cfb64( &ctx,
- valid_mode,
- sizeof( buf ),
- &off, buf,
- NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_cfb64( &ctx,
- valid_mode,
- sizeof( buf ),
- &off, buf,
- buf, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_cfb64(NULL,
+ valid_mode,
+ sizeof(buf),
+ &off, buf,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_cfb64(&ctx,
+ invalid_mode,
+ sizeof(buf),
+ &off, buf,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_cfb64(&ctx,
+ valid_mode,
+ sizeof(buf),
+ NULL, buf,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_cfb64(&ctx,
+ valid_mode,
+ sizeof(buf),
+ &off, NULL,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_cfb64(&ctx,
+ valid_mode,
+ sizeof(buf),
+ &off, buf,
+ NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_cfb64(&ctx,
+ valid_mode,
+ sizeof(buf),
+ &off, buf,
+ buf, NULL));
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_CTR)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_ctr( NULL,
- sizeof( buf ),
- &off,
- buf, buf,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_ctr( &ctx,
- sizeof( buf ),
- NULL,
- buf, buf,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_ctr( &ctx,
- sizeof( buf ),
- &off,
- NULL, buf,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_ctr( &ctx,
- sizeof( buf ),
- &off,
- buf, NULL,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_ctr( &ctx,
- sizeof( buf ),
- &off,
- buf, buf,
- NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
- mbedtls_blowfish_crypt_ctr( &ctx,
- sizeof( buf ),
- &off,
- buf, buf,
- buf, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_ctr(NULL,
+ sizeof(buf),
+ &off,
+ buf, buf,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_ctr(&ctx,
+ sizeof(buf),
+ NULL,
+ buf, buf,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_ctr(&ctx,
+ sizeof(buf),
+ &off,
+ NULL, buf,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_ctr(&ctx,
+ sizeof(buf),
+ &off,
+ buf, NULL,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_ctr(&ctx,
+ sizeof(buf),
+ &off,
+ buf, buf,
+ NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_BLOWFISH_BAD_INPUT_DATA,
+ mbedtls_blowfish_crypt_ctr(&ctx,
+ sizeof(buf),
+ &off,
+ buf, buf,
+ buf, NULL));
#endif /* MBEDTLS_CIPHER_MODE_CTR */
exit:
@@ -166,155 +166,157 @@
/* END_CASE */
/* BEGIN_CASE */
-void blowfish_encrypt_ecb( data_t * key_str, data_t * src_str,
- data_t * dst, int setkey_result )
+void blowfish_encrypt_ecb(data_t *key_str, data_t *src_str,
+ data_t *dst, int setkey_result)
{
unsigned char output[100];
mbedtls_blowfish_context ctx;
memset(output, 0x00, 100);
- mbedtls_blowfish_init( &ctx );
+ mbedtls_blowfish_init(&ctx);
- TEST_ASSERT( mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 ) == setkey_result );
- if( setkey_result == 0 )
- {
- TEST_ASSERT( mbedtls_blowfish_crypt_ecb( &ctx, MBEDTLS_BLOWFISH_ENCRYPT, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_blowfish_setkey(&ctx, key_str->x, key_str->len * 8) == setkey_result);
+ if (setkey_result == 0) {
+ TEST_ASSERT(mbedtls_blowfish_crypt_ecb(&ctx, MBEDTLS_BLOWFISH_ENCRYPT, src_str->x,
+ output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 8, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 8, dst->len) == 0);
}
exit:
- mbedtls_blowfish_free( &ctx );
+ mbedtls_blowfish_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void blowfish_decrypt_ecb( data_t * key_str, data_t * src_str,
- data_t * dst, int setkey_result )
+void blowfish_decrypt_ecb(data_t *key_str, data_t *src_str,
+ data_t *dst, int setkey_result)
{
unsigned char output[100];
mbedtls_blowfish_context ctx;
memset(output, 0x00, 100);
- mbedtls_blowfish_init( &ctx );
+ mbedtls_blowfish_init(&ctx);
- TEST_ASSERT( mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 ) == setkey_result );
- if( setkey_result == 0 )
- {
- TEST_ASSERT( mbedtls_blowfish_crypt_ecb( &ctx, MBEDTLS_BLOWFISH_DECRYPT, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_blowfish_setkey(&ctx, key_str->x, key_str->len * 8) == setkey_result);
+ if (setkey_result == 0) {
+ TEST_ASSERT(mbedtls_blowfish_crypt_ecb(&ctx, MBEDTLS_BLOWFISH_DECRYPT, src_str->x,
+ output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 8, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 8, dst->len) == 0);
}
exit:
- mbedtls_blowfish_free( &ctx );
+ mbedtls_blowfish_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void blowfish_encrypt_cbc( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst,
- int cbc_result )
+void blowfish_encrypt_cbc(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst,
+ int cbc_result)
{
unsigned char output[100];
mbedtls_blowfish_context ctx;
memset(output, 0x00, 100);
- mbedtls_blowfish_init( &ctx );
+ mbedtls_blowfish_init(&ctx);
- mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 );
+ mbedtls_blowfish_setkey(&ctx, key_str->x, key_str->len * 8);
- TEST_ASSERT( mbedtls_blowfish_crypt_cbc( &ctx, MBEDTLS_BLOWFISH_ENCRYPT, src_str->len , iv_str->x, src_str->x, output ) == cbc_result );
- if( cbc_result == 0 )
- {
+ TEST_ASSERT(mbedtls_blowfish_crypt_cbc(&ctx, MBEDTLS_BLOWFISH_ENCRYPT, src_str->len, iv_str->x,
+ src_str->x, output) == cbc_result);
+ if (cbc_result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
- src_str->len, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
+ src_str->len, dst->len) == 0);
}
exit:
- mbedtls_blowfish_free( &ctx );
+ mbedtls_blowfish_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void blowfish_decrypt_cbc( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst,
- int cbc_result )
+void blowfish_decrypt_cbc(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst,
+ int cbc_result)
{
unsigned char output[100];
mbedtls_blowfish_context ctx;
memset(output, 0x00, 100);
- mbedtls_blowfish_init( &ctx );
+ mbedtls_blowfish_init(&ctx);
- mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 );
- TEST_ASSERT( mbedtls_blowfish_crypt_cbc( &ctx, MBEDTLS_BLOWFISH_DECRYPT, src_str->len , iv_str->x, src_str->x, output ) == cbc_result );
- if( cbc_result == 0)
- {
+ mbedtls_blowfish_setkey(&ctx, key_str->x, key_str->len * 8);
+ TEST_ASSERT(mbedtls_blowfish_crypt_cbc(&ctx, MBEDTLS_BLOWFISH_DECRYPT, src_str->len, iv_str->x,
+ src_str->x, output) == cbc_result);
+ if (cbc_result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, src_str->len,
- dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, src_str->len,
+ dst->len) == 0);
}
exit:
- mbedtls_blowfish_free( &ctx );
+ mbedtls_blowfish_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
-void blowfish_encrypt_cfb64( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst )
+void blowfish_encrypt_cfb64(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst)
{
unsigned char output[100];
mbedtls_blowfish_context ctx;
size_t iv_offset = 0;
memset(output, 0x00, 100);
- mbedtls_blowfish_init( &ctx );
+ mbedtls_blowfish_init(&ctx);
- mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 );
- TEST_ASSERT( mbedtls_blowfish_crypt_cfb64( &ctx, MBEDTLS_BLOWFISH_ENCRYPT, src_str->len, &iv_offset, iv_str->x, src_str->x, output ) == 0 );
+ mbedtls_blowfish_setkey(&ctx, key_str->x, key_str->len * 8);
+ TEST_ASSERT(mbedtls_blowfish_crypt_cfb64(&ctx, MBEDTLS_BLOWFISH_ENCRYPT, src_str->len,
+ &iv_offset, iv_str->x, src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, src_str->len,
- dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, src_str->len,
+ dst->len) == 0);
exit:
- mbedtls_blowfish_free( &ctx );
+ mbedtls_blowfish_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
-void blowfish_decrypt_cfb64( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst )
+void blowfish_decrypt_cfb64(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst)
{
unsigned char output[100];
mbedtls_blowfish_context ctx;
size_t iv_offset = 0;
memset(output, 0x00, 100);
- mbedtls_blowfish_init( &ctx );
+ mbedtls_blowfish_init(&ctx);
- mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 );
- TEST_ASSERT( mbedtls_blowfish_crypt_cfb64( &ctx, MBEDTLS_BLOWFISH_DECRYPT, src_str->len, &iv_offset, iv_str->x, src_str->x, output ) == 0 );
+ mbedtls_blowfish_setkey(&ctx, key_str->x, key_str->len * 8);
+ TEST_ASSERT(mbedtls_blowfish_crypt_cfb64(&ctx, MBEDTLS_BLOWFISH_DECRYPT, src_str->len,
+ &iv_offset, iv_str->x, src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, src_str->len,
- dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, src_str->len,
+ dst->len) == 0);
exit:
- mbedtls_blowfish_free( &ctx );
+ mbedtls_blowfish_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CTR */
-void blowfish_encrypt_ctr( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst )
+void blowfish_encrypt_ctr(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst)
{
unsigned char stream_str[100];
unsigned char output[100];
@@ -323,16 +325,17 @@
memset(stream_str, 0x00, 100);
memset(output, 0x00, 100);
- mbedtls_blowfish_init( &ctx );
+ mbedtls_blowfish_init(&ctx);
- mbedtls_blowfish_setkey( &ctx, key_str->x, key_str->len * 8 );
- TEST_ASSERT( mbedtls_blowfish_crypt_ctr( &ctx, src_str->len, &iv_offset, iv_str->x, stream_str, src_str->x, output ) == 0 );
+ mbedtls_blowfish_setkey(&ctx, key_str->x, key_str->len * 8);
+ TEST_ASSERT(mbedtls_blowfish_crypt_ctr(&ctx, src_str->len, &iv_offset, iv_str->x, stream_str,
+ src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, src_str->len,
- dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, src_str->len,
+ dst->len) == 0);
exit:
- mbedtls_blowfish_free( &ctx );
+ mbedtls_blowfish_free(&ctx);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_camellia.function b/tests/suites/test_suite_camellia.function
index 312495c..da4276a 100644
--- a/tests/suites/test_suite_camellia.function
+++ b/tests/suites/test_suite_camellia.function
@@ -8,14 +8,14 @@
*/
/* BEGIN_CASE */
-void camellia_valid_param( )
+void camellia_valid_param()
{
- TEST_VALID_PARAM( mbedtls_camellia_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_camellia_free(NULL));
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void camellia_invalid_param( )
+void camellia_invalid_param()
{
mbedtls_camellia_context ctx;
unsigned char buf[16] = { 0 };
@@ -25,147 +25,147 @@
size_t off;
((void) off);
- TEST_INVALID_PARAM( mbedtls_camellia_init( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_camellia_init(NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_setkey_enc( NULL,
- buf,
- valid_keybits ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_setkey_enc( &ctx,
- NULL,
- valid_keybits ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_setkey_enc(NULL,
+ buf,
+ valid_keybits));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_setkey_enc(&ctx,
+ NULL,
+ valid_keybits));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_setkey_dec( NULL,
- buf,
- valid_keybits ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_setkey_dec( &ctx,
- NULL,
- valid_keybits ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_setkey_dec(NULL,
+ buf,
+ valid_keybits));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_setkey_dec(&ctx,
+ NULL,
+ valid_keybits));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_ecb( NULL,
- valid_mode,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_ecb( &ctx,
- invalid_mode,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_ecb( &ctx,
- valid_mode,
- NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_ecb( &ctx,
- valid_mode,
- buf, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_ecb(NULL,
+ valid_mode,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_ecb(&ctx,
+ invalid_mode,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_ecb(&ctx,
+ valid_mode,
+ NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_ecb(&ctx,
+ valid_mode,
+ buf, NULL));
#if defined(MBEDTLS_CIPHER_MODE_CBC)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_cbc( NULL,
- valid_mode,
- sizeof( buf ),
- buf, buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_cbc( &ctx,
- invalid_mode,
- sizeof( buf ),
- buf, buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_cbc( &ctx,
- valid_mode,
- sizeof( buf ),
- NULL, buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_cbc( &ctx,
- valid_mode,
- sizeof( buf ),
- buf, NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_cbc( &ctx,
- valid_mode,
- sizeof( buf ),
- buf, buf, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_cbc(NULL,
+ valid_mode,
+ sizeof(buf),
+ buf, buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_cbc(&ctx,
+ invalid_mode,
+ sizeof(buf),
+ buf, buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_cbc(&ctx,
+ valid_mode,
+ sizeof(buf),
+ NULL, buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_cbc(&ctx,
+ valid_mode,
+ sizeof(buf),
+ buf, NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_cbc(&ctx,
+ valid_mode,
+ sizeof(buf),
+ buf, buf, NULL));
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_cfb128( NULL,
- valid_mode,
- sizeof( buf ),
- &off, buf,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_cfb128( &ctx,
- invalid_mode,
- sizeof( buf ),
- &off, buf,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_cfb128( &ctx,
- valid_mode,
- sizeof( buf ),
- NULL, buf,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_cfb128( &ctx,
- valid_mode,
- sizeof( buf ),
- &off, NULL,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_cfb128( &ctx,
- valid_mode,
- sizeof( buf ),
- &off, buf,
- NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_cfb128( &ctx,
- valid_mode,
- sizeof( buf ),
- &off, buf,
- buf, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_cfb128(NULL,
+ valid_mode,
+ sizeof(buf),
+ &off, buf,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_cfb128(&ctx,
+ invalid_mode,
+ sizeof(buf),
+ &off, buf,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_cfb128(&ctx,
+ valid_mode,
+ sizeof(buf),
+ NULL, buf,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_cfb128(&ctx,
+ valid_mode,
+ sizeof(buf),
+ &off, NULL,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_cfb128(&ctx,
+ valid_mode,
+ sizeof(buf),
+ &off, buf,
+ NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_cfb128(&ctx,
+ valid_mode,
+ sizeof(buf),
+ &off, buf,
+ buf, NULL));
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_CTR)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_ctr( NULL,
- sizeof( buf ),
- &off,
- buf, buf,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_ctr( &ctx,
- sizeof( buf ),
- NULL,
- buf, buf,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_ctr( &ctx,
- sizeof( buf ),
- &off,
- NULL, buf,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_ctr( &ctx,
- sizeof( buf ),
- &off,
- buf, NULL,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_ctr( &ctx,
- sizeof( buf ),
- &off,
- buf, buf,
- NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
- mbedtls_camellia_crypt_ctr( &ctx,
- sizeof( buf ),
- &off,
- buf, buf,
- buf, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_ctr(NULL,
+ sizeof(buf),
+ &off,
+ buf, buf,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_ctr(&ctx,
+ sizeof(buf),
+ NULL,
+ buf, buf,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_ctr(&ctx,
+ sizeof(buf),
+ &off,
+ NULL, buf,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_ctr(&ctx,
+ sizeof(buf),
+ &off,
+ buf, NULL,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_ctr(&ctx,
+ sizeof(buf),
+ &off,
+ buf, buf,
+ NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CAMELLIA_BAD_INPUT_DATA,
+ mbedtls_camellia_crypt_ctr(&ctx,
+ sizeof(buf),
+ &off,
+ buf, buf,
+ buf, NULL));
#endif /* MBEDTLS_CIPHER_MODE_CTR */
exit:
@@ -174,152 +174,154 @@
/* END_CASE */
/* BEGIN_CASE */
-void camellia_encrypt_ecb( data_t * key_str, data_t * src_str,
- data_t * dst, int setkey_result )
+void camellia_encrypt_ecb(data_t *key_str, data_t *src_str,
+ data_t *dst, int setkey_result)
{
unsigned char output[100];
mbedtls_camellia_context ctx;
memset(output, 0x00, 100);
- mbedtls_camellia_init( &ctx );
+ mbedtls_camellia_init(&ctx);
- TEST_ASSERT( mbedtls_camellia_setkey_enc( &ctx, key_str->x, key_str->len * 8 ) == setkey_result );
- if( setkey_result == 0 )
- {
- TEST_ASSERT( mbedtls_camellia_crypt_ecb( &ctx, MBEDTLS_CAMELLIA_ENCRYPT, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_camellia_setkey_enc(&ctx, key_str->x, key_str->len * 8) == setkey_result);
+ if (setkey_result == 0) {
+ TEST_ASSERT(mbedtls_camellia_crypt_ecb(&ctx, MBEDTLS_CAMELLIA_ENCRYPT, src_str->x,
+ output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);
}
exit:
- mbedtls_camellia_free( &ctx );
+ mbedtls_camellia_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void camellia_decrypt_ecb( data_t * key_str, data_t * src_str,
- data_t * dst, int setkey_result )
+void camellia_decrypt_ecb(data_t *key_str, data_t *src_str,
+ data_t *dst, int setkey_result)
{
unsigned char output[100];
mbedtls_camellia_context ctx;
memset(output, 0x00, 100);
- mbedtls_camellia_init( &ctx );
+ mbedtls_camellia_init(&ctx);
- TEST_ASSERT( mbedtls_camellia_setkey_dec( &ctx, key_str->x, key_str->len * 8 ) == setkey_result );
- if( setkey_result == 0 )
- {
- TEST_ASSERT( mbedtls_camellia_crypt_ecb( &ctx, MBEDTLS_CAMELLIA_DECRYPT, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_camellia_setkey_dec(&ctx, key_str->x, key_str->len * 8) == setkey_result);
+ if (setkey_result == 0) {
+ TEST_ASSERT(mbedtls_camellia_crypt_ecb(&ctx, MBEDTLS_CAMELLIA_DECRYPT, src_str->x,
+ output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);
}
exit:
- mbedtls_camellia_free( &ctx );
+ mbedtls_camellia_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void camellia_encrypt_cbc( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst, int cbc_result )
+void camellia_encrypt_cbc(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst, int cbc_result)
{
unsigned char output[100];
mbedtls_camellia_context ctx;
memset(output, 0x00, 100);
- mbedtls_camellia_init( &ctx );
+ mbedtls_camellia_init(&ctx);
- mbedtls_camellia_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
- TEST_ASSERT( mbedtls_camellia_crypt_cbc( &ctx, MBEDTLS_CAMELLIA_ENCRYPT, src_str->len, iv_str->x, src_str->x, output) == cbc_result );
- if( cbc_result == 0 )
- {
+ mbedtls_camellia_setkey_enc(&ctx, key_str->x, key_str->len * 8);
+ TEST_ASSERT(mbedtls_camellia_crypt_cbc(&ctx, MBEDTLS_CAMELLIA_ENCRYPT, src_str->len, iv_str->x,
+ src_str->x, output) == cbc_result);
+ if (cbc_result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, src_str->len,
- dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, src_str->len,
+ dst->len) == 0);
}
exit:
- mbedtls_camellia_free( &ctx );
+ mbedtls_camellia_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void camellia_decrypt_cbc( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst,
- int cbc_result )
+void camellia_decrypt_cbc(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst,
+ int cbc_result)
{
unsigned char output[100];
mbedtls_camellia_context ctx;
memset(output, 0x00, 100);
- mbedtls_camellia_init( &ctx );
+ mbedtls_camellia_init(&ctx);
- mbedtls_camellia_setkey_dec( &ctx, key_str->x, key_str->len * 8 );
- TEST_ASSERT( mbedtls_camellia_crypt_cbc( &ctx, MBEDTLS_CAMELLIA_DECRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
- if( cbc_result == 0 )
- {
+ mbedtls_camellia_setkey_dec(&ctx, key_str->x, key_str->len * 8);
+ TEST_ASSERT(mbedtls_camellia_crypt_cbc(&ctx, MBEDTLS_CAMELLIA_DECRYPT, src_str->len, iv_str->x,
+ src_str->x, output) == cbc_result);
+ if (cbc_result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, src_str->len,
- dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, src_str->len,
+ dst->len) == 0);
}
exit:
- mbedtls_camellia_free( &ctx );
+ mbedtls_camellia_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
-void camellia_encrypt_cfb128( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst )
+void camellia_encrypt_cfb128(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst)
{
unsigned char output[100];
mbedtls_camellia_context ctx;
size_t iv_offset = 0;
memset(output, 0x00, 100);
- mbedtls_camellia_init( &ctx );
+ mbedtls_camellia_init(&ctx);
- mbedtls_camellia_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
- TEST_ASSERT( mbedtls_camellia_crypt_cfb128( &ctx, MBEDTLS_CAMELLIA_ENCRYPT, 16, &iv_offset, iv_str->x, src_str->x, output ) == 0 );
+ mbedtls_camellia_setkey_enc(&ctx, key_str->x, key_str->len * 8);
+ TEST_ASSERT(mbedtls_camellia_crypt_cfb128(&ctx, MBEDTLS_CAMELLIA_ENCRYPT, 16, &iv_offset,
+ iv_str->x, src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);
exit:
- mbedtls_camellia_free( &ctx );
+ mbedtls_camellia_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CFB */
-void camellia_decrypt_cfb128( data_t * key_str, data_t * iv_str,
- data_t * src_str,
- data_t * dst )
+void camellia_decrypt_cfb128(data_t *key_str, data_t *iv_str,
+ data_t *src_str,
+ data_t *dst)
{
unsigned char output[100];
mbedtls_camellia_context ctx;
size_t iv_offset = 0;
memset(output, 0x00, 100);
- mbedtls_camellia_init( &ctx );
+ mbedtls_camellia_init(&ctx);
- mbedtls_camellia_setkey_enc( &ctx, key_str->x, key_str->len * 8 );
- TEST_ASSERT( mbedtls_camellia_crypt_cfb128( &ctx, MBEDTLS_CAMELLIA_DECRYPT, 16, &iv_offset, iv_str->x, src_str->x, output ) == 0 );
+ mbedtls_camellia_setkey_enc(&ctx, key_str->x, key_str->len * 8);
+ TEST_ASSERT(mbedtls_camellia_crypt_cfb128(&ctx, MBEDTLS_CAMELLIA_DECRYPT, 16, &iv_offset,
+ iv_str->x, src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 16, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 16, dst->len) == 0);
exit:
- mbedtls_camellia_free( &ctx );
+ mbedtls_camellia_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void camellia_selftest( )
+void camellia_selftest()
{
- TEST_ASSERT( mbedtls_camellia_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_camellia_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_ccm.function b/tests/suites/test_suite_ccm.function
index 5a3726e..735c9aa 100644
--- a/tests/suites/test_suite_ccm.function
+++ b/tests/suites/test_suite_ccm.function
@@ -8,34 +8,34 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST:MBEDTLS_AES_C */
-void mbedtls_ccm_self_test( )
+void mbedtls_ccm_self_test()
{
- TEST_ASSERT( mbedtls_ccm_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_ccm_self_test(1) == 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_ccm_setkey( int cipher_id, int key_size, int result )
+void mbedtls_ccm_setkey(int cipher_id, int key_size, int result)
{
mbedtls_ccm_context ctx;
unsigned char key[32];
int ret;
- mbedtls_ccm_init( &ctx );
+ mbedtls_ccm_init(&ctx);
- memset( key, 0x2A, sizeof( key ) );
- TEST_ASSERT( (unsigned) key_size <= 8 * sizeof( key ) );
+ memset(key, 0x2A, sizeof(key));
+ TEST_ASSERT((unsigned) key_size <= 8 * sizeof(key));
- ret = mbedtls_ccm_setkey( &ctx, cipher_id, key, key_size );
- TEST_ASSERT( ret == result );
+ ret = mbedtls_ccm_setkey(&ctx, cipher_id, key, key_size);
+ TEST_ASSERT(ret == result);
exit:
- mbedtls_ccm_free( &ctx );
+ mbedtls_ccm_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
-void ccm_lengths( int msg_len, int iv_len, int add_len, int tag_len, int res )
+void ccm_lengths(int msg_len, int iv_len, int add_len, int tag_len, int res)
{
mbedtls_ccm_context ctx;
unsigned char key[16];
@@ -46,38 +46,39 @@
unsigned char tag[18];
int decrypt_ret;
- mbedtls_ccm_init( &ctx );
+ mbedtls_ccm_init(&ctx);
- ASSERT_ALLOC_WEAK( add, add_len );
- memset( key, 0, sizeof( key ) );
- memset( msg, 0, sizeof( msg ) );
- memset( iv, 0, sizeof( iv ) );
- memset( out, 0, sizeof( out ) );
- memset( tag, 0, sizeof( tag ) );
+ ASSERT_ALLOC_WEAK(add, add_len);
+ memset(key, 0, sizeof(key));
+ memset(msg, 0, sizeof(msg));
+ memset(iv, 0, sizeof(iv));
+ memset(out, 0, sizeof(out));
+ memset(tag, 0, sizeof(tag));
- TEST_ASSERT( mbedtls_ccm_setkey( &ctx, MBEDTLS_CIPHER_ID_AES,
- key, 8 * sizeof( key ) ) == 0 );
+ TEST_ASSERT(mbedtls_ccm_setkey(&ctx, MBEDTLS_CIPHER_ID_AES,
+ key, 8 * sizeof(key)) == 0);
- TEST_ASSERT( mbedtls_ccm_encrypt_and_tag( &ctx, msg_len, iv, iv_len, add, add_len,
- msg, out, tag, tag_len ) == res );
+ TEST_ASSERT(mbedtls_ccm_encrypt_and_tag(&ctx, msg_len, iv, iv_len, add, add_len,
+ msg, out, tag, tag_len) == res);
- decrypt_ret = mbedtls_ccm_auth_decrypt( &ctx, msg_len, iv, iv_len, add, add_len,
- msg, out, tag, tag_len );
+ decrypt_ret = mbedtls_ccm_auth_decrypt(&ctx, msg_len, iv, iv_len, add, add_len,
+ msg, out, tag, tag_len);
- if( res == 0 )
- TEST_ASSERT( decrypt_ret == MBEDTLS_ERR_CCM_AUTH_FAILED );
- else
- TEST_ASSERT( decrypt_ret == res );
+ if (res == 0) {
+ TEST_ASSERT(decrypt_ret == MBEDTLS_ERR_CCM_AUTH_FAILED);
+ } else {
+ TEST_ASSERT(decrypt_ret == res);
+ }
exit:
- mbedtls_free( add );
- mbedtls_ccm_free( &ctx );
+ mbedtls_free(add);
+ mbedtls_ccm_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
-void ccm_star_lengths( int msg_len, int iv_len, int add_len, int tag_len,
- int res )
+void ccm_star_lengths(int msg_len, int iv_len, int add_len, int tag_len,
+ int res)
{
mbedtls_ccm_context ctx;
unsigned char key[16];
@@ -88,115 +89,115 @@
unsigned char tag[18];
int decrypt_ret;
- mbedtls_ccm_init( &ctx );
+ mbedtls_ccm_init(&ctx);
- memset( key, 0, sizeof( key ) );
- memset( msg, 0, sizeof( msg ) );
- memset( iv, 0, sizeof( iv ) );
- memset( add, 0, sizeof( add ) );
- memset( out, 0, sizeof( out ) );
- memset( tag, 0, sizeof( tag ) );
+ memset(key, 0, sizeof(key));
+ memset(msg, 0, sizeof(msg));
+ memset(iv, 0, sizeof(iv));
+ memset(add, 0, sizeof(add));
+ memset(out, 0, sizeof(out));
+ memset(tag, 0, sizeof(tag));
- TEST_ASSERT( mbedtls_ccm_setkey( &ctx, MBEDTLS_CIPHER_ID_AES,
- key, 8 * sizeof( key ) ) == 0 );
+ TEST_ASSERT(mbedtls_ccm_setkey(&ctx, MBEDTLS_CIPHER_ID_AES,
+ key, 8 * sizeof(key)) == 0);
- TEST_ASSERT( mbedtls_ccm_star_encrypt_and_tag( &ctx, msg_len, iv, iv_len,
- add, add_len, msg, out, tag, tag_len ) == res );
+ TEST_ASSERT(mbedtls_ccm_star_encrypt_and_tag(&ctx, msg_len, iv, iv_len,
+ add, add_len, msg, out, tag, tag_len) == res);
- decrypt_ret = mbedtls_ccm_star_auth_decrypt( &ctx, msg_len, iv, iv_len, add,
- add_len, msg, out, tag, tag_len );
+ decrypt_ret = mbedtls_ccm_star_auth_decrypt(&ctx, msg_len, iv, iv_len, add,
+ add_len, msg, out, tag, tag_len);
- if( res == 0 && tag_len != 0 )
- TEST_ASSERT( decrypt_ret == MBEDTLS_ERR_CCM_AUTH_FAILED );
- else
- TEST_ASSERT( decrypt_ret == res );
+ if (res == 0 && tag_len != 0) {
+ TEST_ASSERT(decrypt_ret == MBEDTLS_ERR_CCM_AUTH_FAILED);
+ } else {
+ TEST_ASSERT(decrypt_ret == res);
+ }
exit:
- mbedtls_ccm_free( &ctx );
+ mbedtls_ccm_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_ccm_encrypt_and_tag( int cipher_id, data_t * key,
- data_t * msg, data_t * iv,
- data_t * add, data_t * result )
+void mbedtls_ccm_encrypt_and_tag(int cipher_id, data_t *key,
+ data_t *msg, data_t *iv,
+ data_t *add, data_t *result)
{
mbedtls_ccm_context ctx;
size_t tag_len;
- uint8_t * msg_n_tag = (uint8_t *)malloc( result->len + 2 );
+ uint8_t *msg_n_tag = (uint8_t *) malloc(result->len + 2);
- mbedtls_ccm_init( &ctx );
+ mbedtls_ccm_init(&ctx);
- memset( msg_n_tag, 0, result->len + 2 );
- memcpy( msg_n_tag, msg->x, msg->len );
+ memset(msg_n_tag, 0, result->len + 2);
+ memcpy(msg_n_tag, msg->x, msg->len);
tag_len = result->len - msg->len;
- TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key->x, key->len * 8 ) == 0 );
+ TEST_ASSERT(mbedtls_ccm_setkey(&ctx, cipher_id, key->x, key->len * 8) == 0);
/* Test with input == output */
- TEST_ASSERT( mbedtls_ccm_encrypt_and_tag( &ctx, msg->len, iv->x, iv->len, add->x, add->len,
- msg_n_tag, msg_n_tag, msg_n_tag + msg->len, tag_len ) == 0 );
+ TEST_ASSERT(mbedtls_ccm_encrypt_and_tag(&ctx, msg->len, iv->x, iv->len, add->x, add->len,
+ msg_n_tag, msg_n_tag, msg_n_tag + msg->len,
+ tag_len) == 0);
- TEST_ASSERT( memcmp( msg_n_tag, result->x, result->len ) == 0 );
+ TEST_ASSERT(memcmp(msg_n_tag, result->x, result->len) == 0);
/* Check we didn't write past the end */
- TEST_ASSERT( msg_n_tag[result->len] == 0 && msg_n_tag[result->len + 1] == 0 );
+ TEST_ASSERT(msg_n_tag[result->len] == 0 && msg_n_tag[result->len + 1] == 0);
exit:
- mbedtls_ccm_free( &ctx );
- free( msg_n_tag );
+ mbedtls_ccm_free(&ctx);
+ free(msg_n_tag);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_ccm_auth_decrypt( int cipher_id, data_t * key,
- data_t * msg, data_t * iv,
- data_t * add, int tag_len, int result,
- data_t * expected_msg )
+void mbedtls_ccm_auth_decrypt(int cipher_id, data_t *key,
+ data_t *msg, data_t *iv,
+ data_t *add, int tag_len, int result,
+ data_t *expected_msg)
{
unsigned char tag[16];
mbedtls_ccm_context ctx;
- mbedtls_ccm_init( &ctx );
+ mbedtls_ccm_init(&ctx);
- memset( tag, 0x00, sizeof( tag ) );
+ memset(tag, 0x00, sizeof(tag));
msg->len -= tag_len;
- memcpy( tag, msg->x + msg->len, tag_len );
+ memcpy(tag, msg->x + msg->len, tag_len);
- TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key->x, key->len * 8 ) == 0 );
+ TEST_ASSERT(mbedtls_ccm_setkey(&ctx, cipher_id, key->x, key->len * 8) == 0);
/* Test with input == output */
- TEST_ASSERT( mbedtls_ccm_auth_decrypt( &ctx, msg->len, iv->x, iv->len, add->x, add->len,
- msg->x, msg->x, msg->x + msg->len, tag_len ) == result );
+ TEST_ASSERT(mbedtls_ccm_auth_decrypt(&ctx, msg->len, iv->x, iv->len, add->x, add->len,
+ msg->x, msg->x, msg->x + msg->len, tag_len) == result);
- if( result == 0 )
- {
- TEST_ASSERT( memcmp( msg->x, expected_msg->x, expected_msg->len ) == 0 );
- }
- else
- {
+ if (result == 0) {
+ TEST_ASSERT(memcmp(msg->x, expected_msg->x, expected_msg->len) == 0);
+ } else {
size_t i;
- for( i = 0; i < msg->len; i++ )
- TEST_ASSERT( msg->x[i] == 0 );
+ for (i = 0; i < msg->len; i++) {
+ TEST_ASSERT(msg->x[i] == 0);
+ }
}
/* Check we didn't write past the end (where the original tag is) */
- TEST_ASSERT( memcmp( msg->x + msg->len, tag, tag_len ) == 0 );
+ TEST_ASSERT(memcmp(msg->x + msg->len, tag, tag_len) == 0);
exit:
- mbedtls_ccm_free( &ctx );
+ mbedtls_ccm_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_ccm_star_encrypt_and_tag( int cipher_id,
- data_t *key, data_t *msg,
- data_t *source_address, data_t *frame_counter,
- int sec_level, data_t *add,
- data_t *expected_result, int output_ret )
+void mbedtls_ccm_star_encrypt_and_tag(int cipher_id,
+ data_t *key, data_t *msg,
+ data_t *source_address, data_t *frame_counter,
+ int sec_level, data_t *add,
+ data_t *expected_result, int output_ret)
{
unsigned char iv[13];
unsigned char result[50];
@@ -204,49 +205,50 @@
size_t iv_len, tag_len;
int ret;
- mbedtls_ccm_init( &ctx );
+ mbedtls_ccm_init(&ctx);
- memset( result, 0x00, sizeof( result ) );
+ memset(result, 0x00, sizeof(result));
- if( sec_level % 4 == 0)
+ if (sec_level % 4 == 0) {
tag_len = 0;
- else
- tag_len = 1 << ( sec_level % 4 + 1);
+ } else {
+ tag_len = 1 << (sec_level % 4 + 1);
+ }
- TEST_ASSERT( source_address->len == 8 );
- TEST_ASSERT( frame_counter->len == 4 );
- memcpy( iv, source_address->x, source_address->len );
- memcpy( iv + source_address->len, frame_counter->x, frame_counter->len );
+ TEST_ASSERT(source_address->len == 8);
+ TEST_ASSERT(frame_counter->len == 4);
+ memcpy(iv, source_address->x, source_address->len);
+ memcpy(iv + source_address->len, frame_counter->x, frame_counter->len);
iv[source_address->len + frame_counter->len] = sec_level;
- iv_len = sizeof( iv );
+ iv_len = sizeof(iv);
- TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id,
- key->x, key->len * 8 ) == 0 );
+ TEST_ASSERT(mbedtls_ccm_setkey(&ctx, cipher_id,
+ key->x, key->len * 8) == 0);
- ret = mbedtls_ccm_star_encrypt_and_tag( &ctx, msg->len, iv, iv_len,
- add->x, add->len, msg->x,
- result, result + msg->len, tag_len );
+ ret = mbedtls_ccm_star_encrypt_and_tag(&ctx, msg->len, iv, iv_len,
+ add->x, add->len, msg->x,
+ result, result + msg->len, tag_len);
- TEST_ASSERT( ret == output_ret );
+ TEST_ASSERT(ret == output_ret);
- TEST_ASSERT( memcmp( result,
- expected_result->x, expected_result->len ) == 0 );
+ TEST_ASSERT(memcmp(result,
+ expected_result->x, expected_result->len) == 0);
/* Check we didn't write past the end */
- TEST_ASSERT( result[expected_result->len] == 0 &&
- result[expected_result->len + 1] == 0 );
+ TEST_ASSERT(result[expected_result->len] == 0 &&
+ result[expected_result->len + 1] == 0);
exit:
- mbedtls_ccm_free( &ctx );
+ mbedtls_ccm_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_ccm_star_auth_decrypt( int cipher_id,
- data_t *key, data_t *msg,
- data_t *source_address, data_t *frame_counter,
- int sec_level, data_t *add,
- data_t *expected_result, int output_ret )
+void mbedtls_ccm_star_auth_decrypt(int cipher_id,
+ data_t *key, data_t *msg,
+ data_t *source_address, data_t *frame_counter,
+ int sec_level, data_t *add,
+ data_t *expected_result, int output_ret)
{
unsigned char iv[13];
unsigned char result[50];
@@ -254,46 +256,47 @@
size_t iv_len, tag_len;
int ret;
- mbedtls_ccm_init( &ctx );
+ mbedtls_ccm_init(&ctx);
- memset( iv, 0x00, sizeof( iv ) );
- memset( result, '+', sizeof( result ) );
+ memset(iv, 0x00, sizeof(iv));
+ memset(result, '+', sizeof(result));
- if( sec_level % 4 == 0)
+ if (sec_level % 4 == 0) {
tag_len = 0;
- else
- tag_len = 1 << ( sec_level % 4 + 1);
+ } else {
+ tag_len = 1 << (sec_level % 4 + 1);
+ }
- TEST_ASSERT( source_address->len == 8 );
- TEST_ASSERT( frame_counter->len == 4 );
- memcpy( iv, source_address->x, source_address->len );
- memcpy( iv + source_address->len, frame_counter->x, frame_counter->len );
+ TEST_ASSERT(source_address->len == 8);
+ TEST_ASSERT(frame_counter->len == 4);
+ memcpy(iv, source_address->x, source_address->len);
+ memcpy(iv + source_address->len, frame_counter->x, frame_counter->len);
iv[source_address->len + frame_counter->len] = sec_level;
- iv_len = sizeof( iv );
+ iv_len = sizeof(iv);
- TEST_ASSERT( mbedtls_ccm_setkey( &ctx, cipher_id, key->x, key->len * 8 ) == 0 );
+ TEST_ASSERT(mbedtls_ccm_setkey(&ctx, cipher_id, key->x, key->len * 8) == 0);
- ret = mbedtls_ccm_star_auth_decrypt( &ctx, msg->len - tag_len, iv, iv_len,
- add->x, add->len, msg->x, result,
- msg->x + msg->len - tag_len, tag_len );
+ ret = mbedtls_ccm_star_auth_decrypt(&ctx, msg->len - tag_len, iv, iv_len,
+ add->x, add->len, msg->x, result,
+ msg->x + msg->len - tag_len, tag_len);
- TEST_ASSERT( ret == output_ret );
+ TEST_ASSERT(ret == output_ret);
- TEST_ASSERT( memcmp( result, expected_result->x,
- expected_result->len ) == 0 );
+ TEST_ASSERT(memcmp(result, expected_result->x,
+ expected_result->len) == 0);
/* Check we didn't write past the end (where the original tag is) */
- TEST_ASSERT( ( msg->len + 2 ) <= sizeof( result ) );
- TEST_EQUAL( result[msg->len], '+' );
- TEST_EQUAL( result[msg->len + 1], '+' );
+ TEST_ASSERT((msg->len + 2) <= sizeof(result));
+ TEST_EQUAL(result[msg->len], '+');
+ TEST_EQUAL(result[msg->len + 1], '+');
exit:
- mbedtls_ccm_free( &ctx );
+ mbedtls_ccm_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void ccm_invalid_param( )
+void ccm_invalid_param()
{
struct mbedtls_ccm_context ctx;
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
@@ -301,205 +304,205 @@
int valid_len = sizeof(valid_buffer);
int valid_bitlen = valid_len * 8;
- mbedtls_ccm_init( &ctx );
+ mbedtls_ccm_init(&ctx);
/* mbedtls_ccm_init() */
- TEST_INVALID_PARAM( mbedtls_ccm_init( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_ccm_init(NULL));
/* mbedtls_ccm_setkey() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_setkey( NULL, valid_cipher, valid_buffer, valid_bitlen ) );
+ mbedtls_ccm_setkey(NULL, valid_cipher, valid_buffer, valid_bitlen));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_setkey( &ctx, valid_cipher, NULL, valid_bitlen ) );
+ mbedtls_ccm_setkey(&ctx, valid_cipher, NULL, valid_bitlen));
/* mbedtls_ccm_encrypt_and_tag() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_encrypt_and_tag( NULL, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_encrypt_and_tag(NULL, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
- NULL, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_encrypt_and_tag(&ctx, valid_len,
+ NULL, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
- valid_buffer, valid_len,
- NULL, valid_len,
- valid_buffer, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_encrypt_and_tag(&ctx, valid_len,
+ valid_buffer, valid_len,
+ NULL, valid_len,
+ valid_buffer, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- NULL, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_encrypt_and_tag(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ NULL, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, NULL,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_encrypt_and_tag(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, NULL,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_encrypt_and_tag( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- NULL, valid_len ) );
+ mbedtls_ccm_encrypt_and_tag(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ NULL, valid_len));
/* mbedtls_ccm_star_encrypt_and_tag() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_star_encrypt_and_tag( NULL, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- valid_buffer, valid_len) );
+ mbedtls_ccm_star_encrypt_and_tag(NULL, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
- NULL, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_star_encrypt_and_tag(&ctx, valid_len,
+ NULL, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
- valid_buffer, valid_len,
- NULL, valid_len,
- valid_buffer, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_star_encrypt_and_tag(&ctx, valid_len,
+ valid_buffer, valid_len,
+ NULL, valid_len,
+ valid_buffer, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- NULL, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_star_encrypt_and_tag(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ NULL, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, NULL,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_star_encrypt_and_tag(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, NULL,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_star_encrypt_and_tag( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- NULL, valid_len ) );
+ mbedtls_ccm_star_encrypt_and_tag(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ NULL, valid_len));
/* mbedtls_ccm_auth_decrypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_auth_decrypt( NULL, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_auth_decrypt(NULL, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_auth_decrypt( &ctx, valid_len,
- NULL, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_auth_decrypt(&ctx, valid_len,
+ NULL, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_auth_decrypt( &ctx, valid_len,
- valid_buffer, valid_len,
- NULL, valid_len,
- valid_buffer, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_auth_decrypt(&ctx, valid_len,
+ valid_buffer, valid_len,
+ NULL, valid_len,
+ valid_buffer, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_auth_decrypt( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- NULL, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_auth_decrypt(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ NULL, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_auth_decrypt( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, NULL,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_auth_decrypt(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, NULL,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_auth_decrypt( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- NULL, valid_len ) );
+ mbedtls_ccm_auth_decrypt(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ NULL, valid_len));
/* mbedtls_ccm_star_auth_decrypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_star_auth_decrypt( NULL, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_star_auth_decrypt(NULL, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
- NULL, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_star_auth_decrypt(&ctx, valid_len,
+ NULL, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
- valid_buffer, valid_len,
- NULL, valid_len,
- valid_buffer, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_star_auth_decrypt(&ctx, valid_len,
+ valid_buffer, valid_len,
+ NULL, valid_len,
+ valid_buffer, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- NULL, valid_buffer,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_star_auth_decrypt(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ NULL, valid_buffer,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, NULL,
- valid_buffer, valid_len ) );
+ mbedtls_ccm_star_auth_decrypt(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, NULL,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CCM_BAD_INPUT,
- mbedtls_ccm_star_auth_decrypt( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- NULL, valid_len ) );
+ mbedtls_ccm_star_auth_decrypt(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ NULL, valid_len));
exit:
- mbedtls_ccm_free( &ctx );
+ mbedtls_ccm_free(&ctx);
return;
}
/* END_CASE */
/* BEGIN_CASE */
-void ccm_valid_param( )
+void ccm_valid_param()
{
- TEST_VALID_PARAM( mbedtls_ccm_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_ccm_free(NULL));
exit:
return;
}
diff --git a/tests/suites/test_suite_chacha20.function b/tests/suites/test_suite_chacha20.function
index 67c8de2..7f49561 100644
--- a/tests/suites/test_suite_chacha20.function
+++ b/tests/suites/test_suite_chacha20.function
@@ -8,43 +8,44 @@
*/
/* BEGIN_CASE */
-void chacha20_crypt( data_t *key_str,
- data_t *nonce_str,
- int counter,
- data_t *src_str,
- data_t *expected_output_str )
+void chacha20_crypt(data_t *key_str,
+ data_t *nonce_str,
+ int counter,
+ data_t *src_str,
+ data_t *expected_output_str)
{
unsigned char output[375];
mbedtls_chacha20_context ctx;
- memset( output, 0x00, sizeof( output ) );
+ memset(output, 0x00, sizeof(output));
- TEST_ASSERT( src_str->len == expected_output_str->len );
- TEST_ASSERT( key_str->len == 32U );
- TEST_ASSERT( nonce_str->len == 12U );
+ TEST_ASSERT(src_str->len == expected_output_str->len);
+ TEST_ASSERT(key_str->len == 32U);
+ TEST_ASSERT(nonce_str->len == 12U);
/*
* Test the integrated API
*/
- TEST_ASSERT( mbedtls_chacha20_crypt( key_str->x, nonce_str->x, counter, src_str->len, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_chacha20_crypt(key_str->x, nonce_str->x, counter, src_str->len, src_str->x,
+ output) == 0);
- ASSERT_COMPARE( output, expected_output_str->len,
- expected_output_str->x, expected_output_str->len );
+ ASSERT_COMPARE(output, expected_output_str->len,
+ expected_output_str->x, expected_output_str->len);
/*
* Test the streaming API
*/
- mbedtls_chacha20_init( &ctx );
+ mbedtls_chacha20_init(&ctx);
- TEST_ASSERT( mbedtls_chacha20_setkey( &ctx, key_str->x ) == 0 );
+ TEST_ASSERT(mbedtls_chacha20_setkey(&ctx, key_str->x) == 0);
- TEST_ASSERT( mbedtls_chacha20_starts( &ctx, nonce_str->x, counter ) == 0 );
+ TEST_ASSERT(mbedtls_chacha20_starts(&ctx, nonce_str->x, counter) == 0);
- memset( output, 0x00, sizeof( output ) );
- TEST_ASSERT( mbedtls_chacha20_update( &ctx, src_str->len, src_str->x, output ) == 0 );
+ memset(output, 0x00, sizeof(output));
+ TEST_ASSERT(mbedtls_chacha20_update(&ctx, src_str->len, src_str->x, output) == 0);
- ASSERT_COMPARE( output, expected_output_str->len,
- expected_output_str->x, expected_output_str->len );
+ ASSERT_COMPARE(output, expected_output_str->len,
+ expected_output_str->x, expected_output_str->len);
/*
* Test the streaming API again, piecewise
@@ -52,17 +53,17 @@
/* Don't free/init the context nor set the key again,
* in order to test that starts() does the right thing. */
- TEST_ASSERT( mbedtls_chacha20_starts( &ctx, nonce_str->x, counter ) == 0 );
+ TEST_ASSERT(mbedtls_chacha20_starts(&ctx, nonce_str->x, counter) == 0);
- memset( output, 0x00, sizeof( output ) );
- TEST_ASSERT( mbedtls_chacha20_update( &ctx, 1, src_str->x, output ) == 0 );
- TEST_ASSERT( mbedtls_chacha20_update( &ctx, src_str->len - 1,
- src_str->x + 1, output + 1 ) == 0 );
+ memset(output, 0x00, sizeof(output));
+ TEST_ASSERT(mbedtls_chacha20_update(&ctx, 1, src_str->x, output) == 0);
+ TEST_ASSERT(mbedtls_chacha20_update(&ctx, src_str->len - 1,
+ src_str->x + 1, output + 1) == 0);
- ASSERT_COMPARE( output, expected_output_str->len,
- expected_output_str->x, expected_output_str->len );
+ ASSERT_COMPARE(output, expected_output_str->len,
+ expected_output_str->x, expected_output_str->len);
- mbedtls_chacha20_free( &ctx );
+ mbedtls_chacha20_free(&ctx);
}
/* END_CASE */
@@ -74,37 +75,37 @@
unsigned char src[1];
unsigned char dst[1];
uint32_t counter = 0;
- size_t len = sizeof( src );
+ size_t len = sizeof(src);
mbedtls_chacha20_context ctx;
- TEST_INVALID_PARAM( mbedtls_chacha20_init( NULL ) );
- TEST_VALID_PARAM( mbedtls_chacha20_free( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_chacha20_init(NULL));
+ TEST_VALID_PARAM(mbedtls_chacha20_free(NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
- mbedtls_chacha20_setkey( NULL, key ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
- mbedtls_chacha20_setkey( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
+ mbedtls_chacha20_setkey(NULL, key));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
+ mbedtls_chacha20_setkey(&ctx, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
- mbedtls_chacha20_starts( NULL, nonce, counter ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
- mbedtls_chacha20_starts( &ctx, NULL, counter ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
+ mbedtls_chacha20_starts(NULL, nonce, counter));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
+ mbedtls_chacha20_starts(&ctx, NULL, counter));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
- mbedtls_chacha20_update( NULL, 0, src, dst ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
- mbedtls_chacha20_update( &ctx, len, NULL, dst ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
- mbedtls_chacha20_update( &ctx, len, src, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
+ mbedtls_chacha20_update(NULL, 0, src, dst));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
+ mbedtls_chacha20_update(&ctx, len, NULL, dst));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
+ mbedtls_chacha20_update(&ctx, len, src, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
- mbedtls_chacha20_crypt( NULL, nonce, counter, 0, src, dst ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
- mbedtls_chacha20_crypt( key, NULL, counter, 0, src, dst ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
- mbedtls_chacha20_crypt( key, nonce, counter, len, NULL, dst ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
- mbedtls_chacha20_crypt( key, nonce, counter, len, src, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
+ mbedtls_chacha20_crypt(NULL, nonce, counter, 0, src, dst));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
+ mbedtls_chacha20_crypt(key, NULL, counter, 0, src, dst));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
+ mbedtls_chacha20_crypt(key, nonce, counter, len, NULL, dst));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CHACHA20_BAD_INPUT_DATA,
+ mbedtls_chacha20_crypt(key, nonce, counter, len, src, NULL));
exit:
return;
@@ -115,6 +116,6 @@
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
void chacha20_self_test()
{
- TEST_ASSERT( mbedtls_chacha20_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_chacha20_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_chachapoly.function b/tests/suites/test_suite_chachapoly.function
index 96128e4..906e3f5 100644
--- a/tests/suites/test_suite_chachapoly.function
+++ b/tests/suites/test_suite_chachapoly.function
@@ -8,61 +8,71 @@
*/
/* BEGIN_CASE */
-void mbedtls_chachapoly_enc( data_t *key_str, data_t *nonce_str, data_t *aad_str, data_t *input_str, data_t *output_str, data_t *mac_str )
+void mbedtls_chachapoly_enc(data_t *key_str,
+ data_t *nonce_str,
+ data_t *aad_str,
+ data_t *input_str,
+ data_t *output_str,
+ data_t *mac_str)
{
unsigned char output[265];
unsigned char mac[16]; /* size set by the standard */
mbedtls_chachapoly_context ctx;
- TEST_ASSERT( key_str->len == 32 );
- TEST_ASSERT( nonce_str->len == 12 );
- TEST_ASSERT( mac_str->len == 16 );
+ TEST_ASSERT(key_str->len == 32);
+ TEST_ASSERT(nonce_str->len == 12);
+ TEST_ASSERT(mac_str->len == 16);
- mbedtls_chachapoly_init( &ctx );
+ mbedtls_chachapoly_init(&ctx);
- TEST_ASSERT( mbedtls_chachapoly_setkey( &ctx, key_str->x ) == 0 );
+ TEST_ASSERT(mbedtls_chachapoly_setkey(&ctx, key_str->x) == 0);
- TEST_ASSERT( mbedtls_chachapoly_encrypt_and_tag( &ctx,
- input_str->len, nonce_str->x,
- aad_str->x, aad_str->len,
- input_str->x, output, mac ) == 0 );
+ TEST_ASSERT(mbedtls_chachapoly_encrypt_and_tag(&ctx,
+ input_str->len, nonce_str->x,
+ aad_str->x, aad_str->len,
+ input_str->x, output, mac) == 0);
- TEST_ASSERT( memcmp( output_str->x, output, output_str->len ) == 0 );
- TEST_ASSERT( memcmp( mac_str->x, mac, 16U ) == 0 );
+ TEST_ASSERT(memcmp(output_str->x, output, output_str->len) == 0);
+ TEST_ASSERT(memcmp(mac_str->x, mac, 16U) == 0);
exit:
- mbedtls_chachapoly_free( &ctx );
+ mbedtls_chachapoly_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_chachapoly_dec( data_t *key_str, data_t *nonce_str, data_t *aad_str, data_t *input_str, data_t *output_str, data_t *mac_str, int ret_exp )
+void mbedtls_chachapoly_dec(data_t *key_str,
+ data_t *nonce_str,
+ data_t *aad_str,
+ data_t *input_str,
+ data_t *output_str,
+ data_t *mac_str,
+ int ret_exp)
{
unsigned char output[265];
int ret;
mbedtls_chachapoly_context ctx;
- TEST_ASSERT( key_str->len == 32 );
- TEST_ASSERT( nonce_str->len == 12 );
- TEST_ASSERT( mac_str->len == 16 );
+ TEST_ASSERT(key_str->len == 32);
+ TEST_ASSERT(nonce_str->len == 12);
+ TEST_ASSERT(mac_str->len == 16);
- mbedtls_chachapoly_init( &ctx );
+ mbedtls_chachapoly_init(&ctx);
- TEST_ASSERT( mbedtls_chachapoly_setkey( &ctx, key_str->x ) == 0 );
+ TEST_ASSERT(mbedtls_chachapoly_setkey(&ctx, key_str->x) == 0);
- ret = mbedtls_chachapoly_auth_decrypt( &ctx,
- input_str->len, nonce_str->x,
- aad_str->x, aad_str->len,
- mac_str->x, input_str->x, output );
+ ret = mbedtls_chachapoly_auth_decrypt(&ctx,
+ input_str->len, nonce_str->x,
+ aad_str->x, aad_str->len,
+ mac_str->x, input_str->x, output);
- TEST_ASSERT( ret == ret_exp );
- if( ret_exp == 0 )
- {
- TEST_ASSERT( memcmp( output_str->x, output, output_str->len ) == 0 );
+ TEST_ASSERT(ret == ret_exp);
+ if (ret_exp == 0) {
+ TEST_ASSERT(memcmp(output_str->x, output, output_str->len) == 0);
}
exit:
- mbedtls_chachapoly_free( &ctx );
+ mbedtls_chachapoly_free(&ctx);
}
/* END_CASE */
@@ -75,122 +85,122 @@
unsigned char input[1];
unsigned char output[1];
unsigned char mac[16];
- size_t input_len = sizeof( input );
- size_t aad_len = sizeof( aad );
+ size_t input_len = sizeof(input);
+ size_t aad_len = sizeof(aad);
mbedtls_chachapoly_context ctx;
- memset( key, 0x00, sizeof( key ) );
- memset( nonce, 0x00, sizeof( nonce ) );
- memset( aad, 0x00, sizeof( aad ) );
- memset( input, 0x00, sizeof( input ) );
- memset( output, 0x00, sizeof( output ) );
- memset( mac, 0x00, sizeof( mac ) );
+ memset(key, 0x00, sizeof(key));
+ memset(nonce, 0x00, sizeof(nonce));
+ memset(aad, 0x00, sizeof(aad));
+ memset(input, 0x00, sizeof(input));
+ memset(output, 0x00, sizeof(output));
+ memset(mac, 0x00, sizeof(mac));
- TEST_INVALID_PARAM( mbedtls_chachapoly_init( NULL ) );
- TEST_VALID_PARAM( mbedtls_chachapoly_free( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_chachapoly_init(NULL));
+ TEST_VALID_PARAM(mbedtls_chachapoly_free(NULL));
/* setkey */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_setkey( NULL, key ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_setkey( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_setkey(NULL, key));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_setkey(&ctx, NULL));
/* encrypt_and_tag */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_encrypt_and_tag( NULL,
- 0, nonce,
- aad, 0,
- input, output, mac ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_encrypt_and_tag( &ctx,
- 0, NULL,
- aad, 0,
- input, output, mac ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_encrypt_and_tag( &ctx,
- 0, nonce,
- NULL, aad_len,
- input, output, mac ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_encrypt_and_tag( &ctx,
- input_len, nonce,
- aad, 0,
- NULL, output, mac ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_encrypt_and_tag( &ctx,
- input_len, nonce,
- aad, 0,
- input, NULL, mac ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_encrypt_and_tag( &ctx,
- 0, nonce,
- aad, 0,
- input, output, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_encrypt_and_tag(NULL,
+ 0, nonce,
+ aad, 0,
+ input, output, mac));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_encrypt_and_tag(&ctx,
+ 0, NULL,
+ aad, 0,
+ input, output, mac));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_encrypt_and_tag(&ctx,
+ 0, nonce,
+ NULL, aad_len,
+ input, output, mac));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_encrypt_and_tag(&ctx,
+ input_len, nonce,
+ aad, 0,
+ NULL, output, mac));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_encrypt_and_tag(&ctx,
+ input_len, nonce,
+ aad, 0,
+ input, NULL, mac));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_encrypt_and_tag(&ctx,
+ 0, nonce,
+ aad, 0,
+ input, output, NULL));
/* auth_decrypt */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_auth_decrypt( NULL,
- 0, nonce,
- aad, 0,
- mac, input, output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_auth_decrypt( &ctx,
- 0, NULL,
- aad, 0,
- mac, input, output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_auth_decrypt( &ctx,
- 0, nonce,
- NULL, aad_len,
- mac, input, output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_auth_decrypt( &ctx,
- 0, nonce,
- aad, 0,
- NULL, input, output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_auth_decrypt( &ctx,
- input_len, nonce,
- aad, 0,
- mac, NULL, output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_auth_decrypt( &ctx,
- input_len, nonce,
- aad, 0,
- mac, input, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_auth_decrypt(NULL,
+ 0, nonce,
+ aad, 0,
+ mac, input, output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_auth_decrypt(&ctx,
+ 0, NULL,
+ aad, 0,
+ mac, input, output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_auth_decrypt(&ctx,
+ 0, nonce,
+ NULL, aad_len,
+ mac, input, output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_auth_decrypt(&ctx,
+ 0, nonce,
+ aad, 0,
+ NULL, input, output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_auth_decrypt(&ctx,
+ input_len, nonce,
+ aad, 0,
+ mac, NULL, output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_auth_decrypt(&ctx,
+ input_len, nonce,
+ aad, 0,
+ mac, input, NULL));
/* starts */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_starts( NULL, nonce,
- MBEDTLS_CHACHAPOLY_ENCRYPT ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_starts( &ctx, NULL,
- MBEDTLS_CHACHAPOLY_ENCRYPT ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_starts(NULL, nonce,
+ MBEDTLS_CHACHAPOLY_ENCRYPT));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_starts(&ctx, NULL,
+ MBEDTLS_CHACHAPOLY_ENCRYPT));
/* update_aad */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_update_aad( NULL, aad,
- aad_len ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_update_aad( &ctx, NULL,
- aad_len ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_update_aad(NULL, aad,
+ aad_len));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_update_aad(&ctx, NULL,
+ aad_len));
/* update */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_update( NULL, input_len,
- input, output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_update( &ctx, input_len,
- NULL, output ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_update( &ctx, input_len,
- input, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_update(NULL, input_len,
+ input, output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_update(&ctx, input_len,
+ NULL, output));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_update(&ctx, input_len,
+ input, NULL));
/* finish */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_finish( NULL, mac ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_chachapoly_finish( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_finish(NULL, mac));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_chachapoly_finish(&ctx, NULL));
exit:
return;
@@ -206,80 +216,80 @@
unsigned char input[1];
unsigned char output[1];
unsigned char mac[16];
- size_t input_len = sizeof( input );
- size_t aad_len = sizeof( aad );
+ size_t input_len = sizeof(input);
+ size_t aad_len = sizeof(aad);
mbedtls_chachapoly_context ctx;
- memset( key, 0x00, sizeof( key ) );
- memset( nonce, 0x00, sizeof( nonce ) );
- memset( aad, 0x00, sizeof( aad ) );
- memset( input, 0x00, sizeof( input ) );
- memset( output, 0x00, sizeof( output ) );
- memset( mac, 0x00, sizeof( mac ) );
+ memset(key, 0x00, sizeof(key));
+ memset(nonce, 0x00, sizeof(nonce));
+ memset(aad, 0x00, sizeof(aad));
+ memset(input, 0x00, sizeof(input));
+ memset(output, 0x00, sizeof(output));
+ memset(mac, 0x00, sizeof(mac));
/* Initial state: finish, update, update_aad forbidden */
- mbedtls_chachapoly_init( &ctx );
+ mbedtls_chachapoly_init(&ctx);
- TEST_ASSERT( mbedtls_chachapoly_finish( &ctx, mac )
- == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE );
- TEST_ASSERT( mbedtls_chachapoly_update( &ctx, input_len, input, output )
- == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE );
- TEST_ASSERT( mbedtls_chachapoly_update_aad( &ctx, aad, aad_len )
- == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE );
+ TEST_ASSERT(mbedtls_chachapoly_finish(&ctx, mac)
+ == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE);
+ TEST_ASSERT(mbedtls_chachapoly_update(&ctx, input_len, input, output)
+ == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE);
+ TEST_ASSERT(mbedtls_chachapoly_update_aad(&ctx, aad, aad_len)
+ == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE);
/* Still initial state: finish, update, update_aad forbidden */
- TEST_ASSERT( mbedtls_chachapoly_setkey( &ctx, key )
- == 0 );
+ TEST_ASSERT(mbedtls_chachapoly_setkey(&ctx, key)
+ == 0);
- TEST_ASSERT( mbedtls_chachapoly_finish( &ctx, mac )
- == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE );
- TEST_ASSERT( mbedtls_chachapoly_update( &ctx, input_len, input, output )
- == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE );
- TEST_ASSERT( mbedtls_chachapoly_update_aad( &ctx, aad, aad_len )
- == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE );
+ TEST_ASSERT(mbedtls_chachapoly_finish(&ctx, mac)
+ == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE);
+ TEST_ASSERT(mbedtls_chachapoly_update(&ctx, input_len, input, output)
+ == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE);
+ TEST_ASSERT(mbedtls_chachapoly_update_aad(&ctx, aad, aad_len)
+ == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE);
/* Starts -> finish OK */
- TEST_ASSERT( mbedtls_chachapoly_starts( &ctx, nonce, MBEDTLS_CHACHAPOLY_ENCRYPT )
- == 0 );
- TEST_ASSERT( mbedtls_chachapoly_finish( &ctx, mac )
- == 0 );
+ TEST_ASSERT(mbedtls_chachapoly_starts(&ctx, nonce, MBEDTLS_CHACHAPOLY_ENCRYPT)
+ == 0);
+ TEST_ASSERT(mbedtls_chachapoly_finish(&ctx, mac)
+ == 0);
/* After finish: update, update_aad forbidden */
- TEST_ASSERT( mbedtls_chachapoly_update( &ctx, input_len, input, output )
- == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE );
- TEST_ASSERT( mbedtls_chachapoly_update_aad( &ctx, aad, aad_len )
- == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE );
+ TEST_ASSERT(mbedtls_chachapoly_update(&ctx, input_len, input, output)
+ == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE);
+ TEST_ASSERT(mbedtls_chachapoly_update_aad(&ctx, aad, aad_len)
+ == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE);
/* Starts -> update* OK */
- TEST_ASSERT( mbedtls_chachapoly_starts( &ctx, nonce, MBEDTLS_CHACHAPOLY_ENCRYPT )
- == 0 );
- TEST_ASSERT( mbedtls_chachapoly_update( &ctx, input_len, input, output )
- == 0 );
- TEST_ASSERT( mbedtls_chachapoly_update( &ctx, input_len, input, output )
- == 0 );
+ TEST_ASSERT(mbedtls_chachapoly_starts(&ctx, nonce, MBEDTLS_CHACHAPOLY_ENCRYPT)
+ == 0);
+ TEST_ASSERT(mbedtls_chachapoly_update(&ctx, input_len, input, output)
+ == 0);
+ TEST_ASSERT(mbedtls_chachapoly_update(&ctx, input_len, input, output)
+ == 0);
/* After update: update_aad forbidden */
- TEST_ASSERT( mbedtls_chachapoly_update_aad( &ctx, aad, aad_len )
- == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE );
+ TEST_ASSERT(mbedtls_chachapoly_update_aad(&ctx, aad, aad_len)
+ == MBEDTLS_ERR_CHACHAPOLY_BAD_STATE);
/* Starts -> update_aad* -> finish OK */
- TEST_ASSERT( mbedtls_chachapoly_starts( &ctx, nonce, MBEDTLS_CHACHAPOLY_ENCRYPT )
- == 0 );
- TEST_ASSERT( mbedtls_chachapoly_update_aad( &ctx, aad, aad_len )
- == 0 );
- TEST_ASSERT( mbedtls_chachapoly_update_aad( &ctx, aad, aad_len )
- == 0 );
- TEST_ASSERT( mbedtls_chachapoly_finish( &ctx, mac )
- == 0 );
+ TEST_ASSERT(mbedtls_chachapoly_starts(&ctx, nonce, MBEDTLS_CHACHAPOLY_ENCRYPT)
+ == 0);
+ TEST_ASSERT(mbedtls_chachapoly_update_aad(&ctx, aad, aad_len)
+ == 0);
+ TEST_ASSERT(mbedtls_chachapoly_update_aad(&ctx, aad, aad_len)
+ == 0);
+ TEST_ASSERT(mbedtls_chachapoly_finish(&ctx, mac)
+ == 0);
exit:
- mbedtls_chachapoly_free( &ctx );
+ mbedtls_chachapoly_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
void chachapoly_selftest()
{
- TEST_ASSERT( mbedtls_chachapoly_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_chachapoly_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_cipher.function b/tests/suites/test_suite_cipher.function
index 4fe54c0..ef9ff0a 100644
--- a/tests/suites/test_suite_cipher.function
+++ b/tests/suites/test_suite_cipher.function
@@ -20,35 +20,33 @@
* individual ciphers, and it doesn't work with the PSA wrappers. So don't do
* it, and instead start with a fresh context.
*/
-static int cipher_reset_key( mbedtls_cipher_context_t *ctx, int cipher_id,
- int use_psa, size_t tag_len, const data_t *key, int direction )
+static int cipher_reset_key(mbedtls_cipher_context_t *ctx, int cipher_id,
+ int use_psa, size_t tag_len, const data_t *key, int direction)
{
- mbedtls_cipher_free( ctx );
- mbedtls_cipher_init( ctx );
+ mbedtls_cipher_free(ctx);
+ mbedtls_cipher_init(ctx);
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
(void) use_psa;
(void) tag_len;
#else
- if( use_psa == 1 )
- {
- TEST_ASSERT( 0 == mbedtls_cipher_setup_psa( ctx,
- mbedtls_cipher_info_from_type( cipher_id ),
- tag_len ) );
- }
- else
+ if (use_psa == 1) {
+ TEST_ASSERT(0 == mbedtls_cipher_setup_psa(ctx,
+ mbedtls_cipher_info_from_type(cipher_id),
+ tag_len));
+ } else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
{
- TEST_ASSERT( 0 == mbedtls_cipher_setup( ctx,
- mbedtls_cipher_info_from_type( cipher_id ) ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setup(ctx,
+ mbedtls_cipher_info_from_type(cipher_id)));
}
- TEST_ASSERT( 0 == mbedtls_cipher_setkey( ctx, key->x, 8 * key->len,
- direction ) );
- return( 1 );
+ TEST_ASSERT(0 == mbedtls_cipher_setkey(ctx, key->x, 8 * key->len,
+ direction));
+ return 1;
exit:
- return( 0 );
+ return 0;
}
/*
@@ -56,11 +54,13 @@
* return 1 if it is,
* 0 if it isn't.
*/
-int buffer_is_all_zero( const uint8_t *buf, size_t size )
+int buffer_is_all_zero(const uint8_t *buf, size_t size)
{
- for( size_t i = 0; i < size; i++ )
- if( buf[i] != 0 )
+ for (size_t i = 0; i < size; i++) {
+ if (buf[i] != 0) {
return 0;
+ }
+ }
return 1;
}
#endif /* MBEDTLS_CIPHER_AUTH_CRYPT */
@@ -73,17 +73,18 @@
*/
/* BEGIN_CASE */
-void mbedtls_cipher_list( )
+void mbedtls_cipher_list()
{
const int *cipher_type;
- for( cipher_type = mbedtls_cipher_list(); *cipher_type != 0; cipher_type++ )
- TEST_ASSERT( mbedtls_cipher_info_from_type( *cipher_type ) != NULL );
+ for (cipher_type = mbedtls_cipher_list(); *cipher_type != 0; cipher_type++) {
+ TEST_ASSERT(mbedtls_cipher_info_from_type(*cipher_type) != NULL);
+ }
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_invalid_param_unconditional( )
+void cipher_invalid_param_unconditional()
{
mbedtls_cipher_context_t valid_ctx;
mbedtls_cipher_context_t invalid_ctx;
@@ -93,120 +94,120 @@
int valid_size = sizeof(valid_buffer);
int valid_bitlen = valid_size * 8;
const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
- *( mbedtls_cipher_list() ) );
+ *(mbedtls_cipher_list()));
size_t size_t_var;
- (void)valid_mode; /* In some configurations this is unused */
+ (void) valid_mode; /* In some configurations this is unused */
- mbedtls_cipher_init( &valid_ctx );
- mbedtls_cipher_init( &invalid_ctx );
+ mbedtls_cipher_init(&valid_ctx);
+ mbedtls_cipher_init(&invalid_ctx);
- TEST_ASSERT( mbedtls_cipher_setup( &valid_ctx, valid_info ) == 0 );
+ TEST_ASSERT(mbedtls_cipher_setup(&valid_ctx, valid_info) == 0);
/* mbedtls_cipher_setup() */
- TEST_ASSERT( mbedtls_cipher_setup( &valid_ctx, NULL ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_setup(&valid_ctx, NULL) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
/* mbedtls_cipher_get_block_size() */
- TEST_ASSERT( mbedtls_cipher_get_block_size( &invalid_ctx ) == 0 );
+ TEST_ASSERT(mbedtls_cipher_get_block_size(&invalid_ctx) == 0);
/* mbedtls_cipher_get_cipher_mode() */
- TEST_ASSERT( mbedtls_cipher_get_cipher_mode( &invalid_ctx ) ==
- MBEDTLS_MODE_NONE );
+ TEST_ASSERT(mbedtls_cipher_get_cipher_mode(&invalid_ctx) ==
+ MBEDTLS_MODE_NONE);
/* mbedtls_cipher_get_iv_size() */
- TEST_ASSERT( mbedtls_cipher_get_iv_size( &invalid_ctx ) == 0 );
+ TEST_ASSERT(mbedtls_cipher_get_iv_size(&invalid_ctx) == 0);
/* mbedtls_cipher_get_type() */
TEST_ASSERT(
- mbedtls_cipher_get_type( &invalid_ctx ) ==
+ mbedtls_cipher_get_type(&invalid_ctx) ==
MBEDTLS_CIPHER_NONE);
/* mbedtls_cipher_get_name() */
- TEST_ASSERT( mbedtls_cipher_get_name( &invalid_ctx ) == 0 );
+ TEST_ASSERT(mbedtls_cipher_get_name(&invalid_ctx) == 0);
/* mbedtls_cipher_get_key_bitlen() */
- TEST_ASSERT( mbedtls_cipher_get_key_bitlen( &invalid_ctx ) ==
- MBEDTLS_KEY_LENGTH_NONE );
+ TEST_ASSERT(mbedtls_cipher_get_key_bitlen(&invalid_ctx) ==
+ MBEDTLS_KEY_LENGTH_NONE);
/* mbedtls_cipher_get_operation() */
- TEST_ASSERT( mbedtls_cipher_get_operation( &invalid_ctx ) ==
- MBEDTLS_OPERATION_NONE );
+ TEST_ASSERT(mbedtls_cipher_get_operation(&invalid_ctx) ==
+ MBEDTLS_OPERATION_NONE);
/* mbedtls_cipher_setkey() */
TEST_ASSERT(
- mbedtls_cipher_setkey( &invalid_ctx,
- valid_buffer,
- valid_bitlen,
- valid_operation ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ mbedtls_cipher_setkey(&invalid_ctx,
+ valid_buffer,
+ valid_bitlen,
+ valid_operation) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
/* mbedtls_cipher_set_iv() */
TEST_ASSERT(
- mbedtls_cipher_set_iv( &invalid_ctx,
- valid_buffer,
- valid_size ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ mbedtls_cipher_set_iv(&invalid_ctx,
+ valid_buffer,
+ valid_size) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
/* mbedtls_cipher_reset() */
- TEST_ASSERT( mbedtls_cipher_reset( &invalid_ctx ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_reset(&invalid_ctx) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
/* mbedtls_cipher_update_ad() */
TEST_ASSERT(
- mbedtls_cipher_update_ad( &invalid_ctx,
- valid_buffer,
- valid_size ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ mbedtls_cipher_update_ad(&invalid_ctx,
+ valid_buffer,
+ valid_size) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
/* mbedtls_cipher_set_padding_mode() */
- TEST_ASSERT( mbedtls_cipher_set_padding_mode( &invalid_ctx, valid_mode ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_set_padding_mode(&invalid_ctx, valid_mode) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
#endif
/* mbedtls_cipher_update() */
TEST_ASSERT(
- mbedtls_cipher_update( &invalid_ctx,
- valid_buffer,
- valid_size,
- valid_buffer,
- &size_t_var ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ mbedtls_cipher_update(&invalid_ctx,
+ valid_buffer,
+ valid_size,
+ valid_buffer,
+ &size_t_var) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
/* mbedtls_cipher_finish() */
TEST_ASSERT(
- mbedtls_cipher_finish( &invalid_ctx,
- valid_buffer,
- &size_t_var ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ mbedtls_cipher_finish(&invalid_ctx,
+ valid_buffer,
+ &size_t_var) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
/* mbedtls_cipher_write_tag() */
TEST_ASSERT(
- mbedtls_cipher_write_tag( &invalid_ctx,
- valid_buffer,
- valid_size ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ mbedtls_cipher_write_tag(&invalid_ctx,
+ valid_buffer,
+ valid_size) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
/* mbedtls_cipher_check_tag() */
TEST_ASSERT(
- mbedtls_cipher_check_tag( &invalid_ctx,
- valid_buffer,
- valid_size ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ mbedtls_cipher_check_tag(&invalid_ctx,
+ valid_buffer,
+ valid_size) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
exit:
- mbedtls_cipher_free( &invalid_ctx );
- mbedtls_cipher_free( &valid_ctx );
+ mbedtls_cipher_free(&invalid_ctx);
+ mbedtls_cipher_free(&valid_ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void cipher_invalid_param_conditional( )
+void cipher_invalid_param_conditional()
{
mbedtls_cipher_context_t valid_ctx;
@@ -217,488 +218,488 @@
int valid_size = sizeof(valid_buffer);
int valid_bitlen = valid_size * 8;
const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
- *( mbedtls_cipher_list() ) );
+ *(mbedtls_cipher_list()));
size_t size_t_var;
- (void)valid_mode; /* In some configurations this is unused */
+ (void) valid_mode; /* In some configurations this is unused */
/* mbedtls_cipher_init() */
- TEST_VALID_PARAM( mbedtls_cipher_init( &valid_ctx ) );
- TEST_INVALID_PARAM( mbedtls_cipher_init( NULL ) );
+ TEST_VALID_PARAM(mbedtls_cipher_init(&valid_ctx));
+ TEST_INVALID_PARAM(mbedtls_cipher_init(NULL));
/* mbedtls_cipher_setup() */
- TEST_VALID_PARAM( mbedtls_cipher_setup( &valid_ctx, valid_info ) );
+ TEST_VALID_PARAM(mbedtls_cipher_setup(&valid_ctx, valid_info));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_setup( NULL, valid_info ) );
+ mbedtls_cipher_setup(NULL, valid_info));
/* mbedtls_cipher_get_block_size() */
- TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_block_size( NULL ) );
+ TEST_INVALID_PARAM_RET(0, mbedtls_cipher_get_block_size(NULL));
/* mbedtls_cipher_get_cipher_mode() */
TEST_INVALID_PARAM_RET(
MBEDTLS_MODE_NONE,
- mbedtls_cipher_get_cipher_mode( NULL ) );
+ mbedtls_cipher_get_cipher_mode(NULL));
/* mbedtls_cipher_get_iv_size() */
- TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_iv_size( NULL ) );
+ TEST_INVALID_PARAM_RET(0, mbedtls_cipher_get_iv_size(NULL));
/* mbedtls_cipher_get_type() */
TEST_INVALID_PARAM_RET(
MBEDTLS_CIPHER_NONE,
- mbedtls_cipher_get_type( NULL ) );
+ mbedtls_cipher_get_type(NULL));
/* mbedtls_cipher_get_name() */
- TEST_INVALID_PARAM_RET( 0, mbedtls_cipher_get_name( NULL ) );
+ TEST_INVALID_PARAM_RET(0, mbedtls_cipher_get_name(NULL));
/* mbedtls_cipher_get_key_bitlen() */
TEST_INVALID_PARAM_RET(
MBEDTLS_KEY_LENGTH_NONE,
- mbedtls_cipher_get_key_bitlen( NULL ) );
+ mbedtls_cipher_get_key_bitlen(NULL));
/* mbedtls_cipher_get_operation() */
TEST_INVALID_PARAM_RET(
MBEDTLS_OPERATION_NONE,
- mbedtls_cipher_get_operation( NULL ) );
+ mbedtls_cipher_get_operation(NULL));
/* mbedtls_cipher_setkey() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_setkey( NULL,
- valid_buffer,
- valid_bitlen,
- valid_operation ) );
+ mbedtls_cipher_setkey(NULL,
+ valid_buffer,
+ valid_bitlen,
+ valid_operation));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_setkey( &valid_ctx,
- NULL,
- valid_bitlen,
- valid_operation ) );
+ mbedtls_cipher_setkey(&valid_ctx,
+ NULL,
+ valid_bitlen,
+ valid_operation));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_setkey( &valid_ctx,
- valid_buffer,
- valid_bitlen,
- invalid_operation ) );
+ mbedtls_cipher_setkey(&valid_ctx,
+ valid_buffer,
+ valid_bitlen,
+ invalid_operation));
/* mbedtls_cipher_set_iv() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_set_iv( NULL,
- valid_buffer,
- valid_size ) );
+ mbedtls_cipher_set_iv(NULL,
+ valid_buffer,
+ valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_set_iv( &valid_ctx,
- NULL,
- valid_size ) );
+ mbedtls_cipher_set_iv(&valid_ctx,
+ NULL,
+ valid_size));
/* mbedtls_cipher_reset() */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_reset( NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
+ mbedtls_cipher_reset(NULL));
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
/* mbedtls_cipher_update_ad() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_update_ad( NULL,
- valid_buffer,
- valid_size ) );
+ mbedtls_cipher_update_ad(NULL,
+ valid_buffer,
+ valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_update_ad( &valid_ctx,
- NULL,
- valid_size ) );
+ mbedtls_cipher_update_ad(&valid_ctx,
+ NULL,
+ valid_size));
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
/* mbedtls_cipher_set_padding_mode() */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_set_padding_mode( NULL, valid_mode ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
+ mbedtls_cipher_set_padding_mode(NULL, valid_mode));
#endif
/* mbedtls_cipher_update() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_update( NULL,
- valid_buffer,
- valid_size,
- valid_buffer,
- &size_t_var ) );
+ mbedtls_cipher_update(NULL,
+ valid_buffer,
+ valid_size,
+ valid_buffer,
+ &size_t_var));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_update( &valid_ctx,
- NULL, valid_size,
- valid_buffer,
- &size_t_var ) );
+ mbedtls_cipher_update(&valid_ctx,
+ NULL, valid_size,
+ valid_buffer,
+ &size_t_var));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_update( &valid_ctx,
- valid_buffer, valid_size,
- NULL,
- &size_t_var ) );
+ mbedtls_cipher_update(&valid_ctx,
+ valid_buffer, valid_size,
+ NULL,
+ &size_t_var));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_update( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer,
- NULL ) );
+ mbedtls_cipher_update(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer,
+ NULL));
/* mbedtls_cipher_finish() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_finish( NULL,
- valid_buffer,
- &size_t_var ) );
+ mbedtls_cipher_finish(NULL,
+ valid_buffer,
+ &size_t_var));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_finish( &valid_ctx,
- NULL,
- &size_t_var ) );
+ mbedtls_cipher_finish(&valid_ctx,
+ NULL,
+ &size_t_var));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_finish( &valid_ctx,
- valid_buffer,
- NULL ) );
+ mbedtls_cipher_finish(&valid_ctx,
+ valid_buffer,
+ NULL));
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
/* mbedtls_cipher_write_tag() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_write_tag( NULL,
- valid_buffer,
- valid_size ) );
+ mbedtls_cipher_write_tag(NULL,
+ valid_buffer,
+ valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_write_tag( &valid_ctx,
- NULL,
- valid_size ) );
+ mbedtls_cipher_write_tag(&valid_ctx,
+ NULL,
+ valid_size));
/* mbedtls_cipher_check_tag() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_check_tag( NULL,
- valid_buffer,
- valid_size ) );
+ mbedtls_cipher_check_tag(NULL,
+ valid_buffer,
+ valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_check_tag( &valid_ctx,
- NULL,
- valid_size ) );
+ mbedtls_cipher_check_tag(&valid_ctx,
+ NULL,
+ valid_size));
#endif /* defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C) */
/* mbedtls_cipher_crypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_crypt( NULL,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, &size_t_var ) );
+ mbedtls_cipher_crypt(NULL,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, &size_t_var));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_crypt( &valid_ctx,
- NULL, valid_size,
- valid_buffer, valid_size,
- valid_buffer, &size_t_var ) );
+ mbedtls_cipher_crypt(&valid_ctx,
+ NULL, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, &size_t_var));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_crypt( &valid_ctx,
- valid_buffer, valid_size,
- NULL, valid_size,
- valid_buffer, &size_t_var ) );
+ mbedtls_cipher_crypt(&valid_ctx,
+ valid_buffer, valid_size,
+ NULL, valid_size,
+ valid_buffer, &size_t_var));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_crypt( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- NULL, &size_t_var ) );
+ mbedtls_cipher_crypt(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ NULL, &size_t_var));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_crypt( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, NULL ) );
+ mbedtls_cipher_crypt(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, NULL));
#if defined(MBEDTLS_CIPHER_MODE_AEAD)
/* mbedtls_cipher_auth_encrypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_encrypt( NULL,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, &size_t_var,
- valid_buffer, valid_size ) );
+ mbedtls_cipher_auth_encrypt(NULL,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, &size_t_var,
+ valid_buffer, valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_encrypt( &valid_ctx,
- NULL, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, &size_t_var,
- valid_buffer, valid_size ) );
+ mbedtls_cipher_auth_encrypt(&valid_ctx,
+ NULL, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, &size_t_var,
+ valid_buffer, valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_encrypt( &valid_ctx,
- valid_buffer, valid_size,
- NULL, valid_size,
- valid_buffer, valid_size,
- valid_buffer, &size_t_var,
- valid_buffer, valid_size ) );
+ mbedtls_cipher_auth_encrypt(&valid_ctx,
+ valid_buffer, valid_size,
+ NULL, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, &size_t_var,
+ valid_buffer, valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_encrypt( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- NULL, valid_size,
- valid_buffer, &size_t_var,
- valid_buffer, valid_size ) );
+ mbedtls_cipher_auth_encrypt(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ NULL, valid_size,
+ valid_buffer, &size_t_var,
+ valid_buffer, valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_encrypt( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- NULL, &size_t_var,
- valid_buffer, valid_size ) );
+ mbedtls_cipher_auth_encrypt(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ NULL, &size_t_var,
+ valid_buffer, valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_encrypt( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, NULL,
- valid_buffer, valid_size ) );
+ mbedtls_cipher_auth_encrypt(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, NULL,
+ valid_buffer, valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_encrypt( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, &size_t_var,
- NULL, valid_size ) );
+ mbedtls_cipher_auth_encrypt(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, &size_t_var,
+ NULL, valid_size));
/* mbedtls_cipher_auth_decrypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_decrypt( NULL,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, &size_t_var,
- valid_buffer, valid_size ) );
+ mbedtls_cipher_auth_decrypt(NULL,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, &size_t_var,
+ valid_buffer, valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_decrypt( &valid_ctx,
- NULL, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, &size_t_var,
- valid_buffer, valid_size ) );
+ mbedtls_cipher_auth_decrypt(&valid_ctx,
+ NULL, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, &size_t_var,
+ valid_buffer, valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_decrypt( &valid_ctx,
- valid_buffer, valid_size,
- NULL, valid_size,
- valid_buffer, valid_size,
- valid_buffer, &size_t_var,
- valid_buffer, valid_size ) );
+ mbedtls_cipher_auth_decrypt(&valid_ctx,
+ valid_buffer, valid_size,
+ NULL, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, &size_t_var,
+ valid_buffer, valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_decrypt( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- NULL, valid_size,
- valid_buffer, &size_t_var,
- valid_buffer, valid_size ) );
+ mbedtls_cipher_auth_decrypt(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ NULL, valid_size,
+ valid_buffer, &size_t_var,
+ valid_buffer, valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_decrypt( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- NULL, &size_t_var,
- valid_buffer, valid_size ) );
+ mbedtls_cipher_auth_decrypt(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ NULL, &size_t_var,
+ valid_buffer, valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_decrypt( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, NULL,
- valid_buffer, valid_size ) );
+ mbedtls_cipher_auth_decrypt(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, NULL,
+ valid_buffer, valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_decrypt( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, &size_t_var,
- NULL, valid_size ) );
+ mbedtls_cipher_auth_decrypt(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, &size_t_var,
+ NULL, valid_size));
#endif /* defined(MBEDTLS_CIPHER_MODE_AEAD) */
#if defined(MBEDTLS_CIPHER_MODE_AEAD) || defined(MBEDTLS_NIST_KW_C)
/* mbedtls_cipher_auth_encrypt_ext */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_encrypt_ext( NULL,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size, &size_t_var,
- valid_size ) );
+ mbedtls_cipher_auth_encrypt_ext(NULL,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size, &size_t_var,
+ valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
- NULL, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size, &size_t_var,
- valid_size ) );
+ mbedtls_cipher_auth_encrypt_ext(&valid_ctx,
+ NULL, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size, &size_t_var,
+ valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
- valid_buffer, valid_size,
- NULL, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size, &size_t_var,
- valid_size ) );
+ mbedtls_cipher_auth_encrypt_ext(&valid_ctx,
+ valid_buffer, valid_size,
+ NULL, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size, &size_t_var,
+ valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- NULL, valid_size,
- valid_buffer, valid_size, &size_t_var,
- valid_size ) );
+ mbedtls_cipher_auth_encrypt_ext(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ NULL, valid_size,
+ valid_buffer, valid_size, &size_t_var,
+ valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- NULL, valid_size, &size_t_var,
- valid_size ) );
+ mbedtls_cipher_auth_encrypt_ext(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ NULL, valid_size, &size_t_var,
+ valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_encrypt_ext( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size, NULL,
- valid_size ) );
+ mbedtls_cipher_auth_encrypt_ext(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size, NULL,
+ valid_size));
/* mbedtls_cipher_auth_decrypt_ext */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_decrypt_ext( NULL,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size, &size_t_var,
- valid_size ) );
+ mbedtls_cipher_auth_decrypt_ext(NULL,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size, &size_t_var,
+ valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
- NULL, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size, &size_t_var,
- valid_size ) );
+ mbedtls_cipher_auth_decrypt_ext(&valid_ctx,
+ NULL, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size, &size_t_var,
+ valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
- valid_buffer, valid_size,
- NULL, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size, &size_t_var,
- valid_size ) );
+ mbedtls_cipher_auth_decrypt_ext(&valid_ctx,
+ valid_buffer, valid_size,
+ NULL, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size, &size_t_var,
+ valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- NULL, valid_size,
- valid_buffer, valid_size, &size_t_var,
- valid_size ) );
+ mbedtls_cipher_auth_decrypt_ext(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ NULL, valid_size,
+ valid_buffer, valid_size, &size_t_var,
+ valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- NULL, valid_size, &size_t_var,
- valid_size ) );
+ mbedtls_cipher_auth_decrypt_ext(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ NULL, valid_size, &size_t_var,
+ valid_size));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA,
- mbedtls_cipher_auth_decrypt_ext( &valid_ctx,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size,
- valid_buffer, valid_size, NULL,
- valid_size ) );
+ mbedtls_cipher_auth_decrypt_ext(&valid_ctx,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size,
+ valid_buffer, valid_size, NULL,
+ valid_size));
#endif /* MBEDTLS_CIPHER_MODE_AEAD || MBEDTLS_NIST_KW_C */
/* mbedtls_cipher_free() */
- TEST_VALID_PARAM( mbedtls_cipher_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_cipher_free(NULL));
exit:
- TEST_VALID_PARAM( mbedtls_cipher_free( &valid_ctx ) );
+ TEST_VALID_PARAM(mbedtls_cipher_free(&valid_ctx));
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
-void cipher_special_behaviours( )
+void cipher_special_behaviours()
{
const mbedtls_cipher_info_t *cipher_info;
mbedtls_cipher_context_t ctx;
unsigned char input[32];
unsigned char output[32];
-#if defined (MBEDTLS_CIPHER_MODE_CBC)
+#if defined(MBEDTLS_CIPHER_MODE_CBC)
unsigned char iv[32];
#endif
size_t olen = 0;
- mbedtls_cipher_init( &ctx );
- memset( input, 0, sizeof( input ) );
- memset( output, 0, sizeof( output ) );
+ mbedtls_cipher_init(&ctx);
+ memset(input, 0, sizeof(input));
+ memset(output, 0, sizeof(output));
#if defined(MBEDTLS_CIPHER_MODE_CBC)
- memset( iv, 0, sizeof( iv ) );
+ memset(iv, 0, sizeof(iv));
/* Check and get info structures */
- cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_CBC );
- TEST_ASSERT( NULL != cipher_info );
+ cipher_info = mbedtls_cipher_info_from_type(MBEDTLS_CIPHER_AES_128_CBC);
+ TEST_ASSERT(NULL != cipher_info);
- TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx, cipher_info));
/* IV too big */
- TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, MBEDTLS_MAX_IV_LENGTH + 1 )
- == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
+ TEST_ASSERT(mbedtls_cipher_set_iv(&ctx, iv, MBEDTLS_MAX_IV_LENGTH + 1)
+ == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE);
/* IV too small */
- TEST_ASSERT( mbedtls_cipher_set_iv( &ctx, iv, 0 )
- == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_set_iv(&ctx, iv, 0)
+ == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- mbedtls_cipher_free( &ctx );
- mbedtls_cipher_init( &ctx );
+ mbedtls_cipher_free(&ctx);
+ mbedtls_cipher_init(&ctx);
#endif /* MBEDTLS_CIPHER_MODE_CBC */
- cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_ECB );
- TEST_ASSERT( NULL != cipher_info );
+ cipher_info = mbedtls_cipher_info_from_type(MBEDTLS_CIPHER_AES_128_ECB);
+ TEST_ASSERT(NULL != cipher_info);
- TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx, cipher_info));
/* Update ECB with partial block */
- TEST_ASSERT( mbedtls_cipher_update( &ctx, input, 1, output, &olen )
- == MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED );
+ TEST_ASSERT(mbedtls_cipher_update(&ctx, input, 1, output, &olen)
+ == MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED);
exit:
- mbedtls_cipher_free( &ctx );
+ mbedtls_cipher_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void enc_dec_buf( int cipher_id, char * cipher_string, int key_len,
- int length_val, int pad_mode )
+void enc_dec_buf(int cipher_id, char *cipher_string, int key_len,
+ int length_val, int pad_mode)
{
size_t length = length_val, outlen, total_len, i, block_size, iv_len;
unsigned char key[64];
@@ -716,28 +717,27 @@
/*
* Prepare contexts
*/
- mbedtls_cipher_init( &ctx_dec );
- mbedtls_cipher_init( &ctx_enc );
+ mbedtls_cipher_init(&ctx_dec);
+ mbedtls_cipher_init(&ctx_enc);
- memset( key, 0x2a, sizeof( key ) );
+ memset(key, 0x2a, sizeof(key));
/* Check and get info structures */
- cipher_info = mbedtls_cipher_info_from_type( cipher_id );
- TEST_ASSERT( NULL != cipher_info );
- TEST_ASSERT( mbedtls_cipher_info_from_string( cipher_string ) == cipher_info );
+ cipher_info = mbedtls_cipher_info_from_type(cipher_id);
+ TEST_ASSERT(NULL != cipher_info);
+ TEST_ASSERT(mbedtls_cipher_info_from_string(cipher_string) == cipher_info);
/* Initialise enc and dec contexts */
- TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
- TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx_dec, cipher_info));
+ TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx_enc, cipher_info));
- TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
- TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx_dec, key, key_len, MBEDTLS_DECRYPT));
+ TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx_enc, key, key_len, MBEDTLS_ENCRYPT));
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
- if( -1 != pad_mode )
- {
- TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
- TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
+ if (-1 != pad_mode) {
+ TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx_dec, pad_mode));
+ TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx_enc, pad_mode));
}
#else
(void) pad_mode;
@@ -746,90 +746,90 @@
/*
* Do a few encode/decode cycles
*/
- for( i = 0; i < 3; i++ )
- {
- memset( iv , 0x00 + i, sizeof( iv ) );
- memset( ad, 0x10 + i, sizeof( ad ) );
- memset( inbuf, 0x20 + i, sizeof( inbuf ) );
+ for (i = 0; i < 3; i++) {
+ memset(iv, 0x00 + i, sizeof(iv));
+ memset(ad, 0x10 + i, sizeof(ad));
+ memset(inbuf, 0x20 + i, sizeof(inbuf));
- memset( encbuf, 0, sizeof( encbuf ) );
- memset( decbuf, 0, sizeof( decbuf ) );
- memset( tag, 0, sizeof( tag ) );
+ memset(encbuf, 0, sizeof(encbuf));
+ memset(decbuf, 0, sizeof(decbuf));
+ memset(tag, 0, sizeof(tag));
- if( cipher_info->type == MBEDTLS_CIPHER_CHACHA20 ||
- cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305 )
- iv_len = 12;
- else
- iv_len = sizeof(iv);
+ if (cipher_info->type == MBEDTLS_CIPHER_CHACHA20 ||
+ cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305) {
+ iv_len = 12;
+ } else {
+ iv_len = sizeof(iv);
+ }
- TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, iv_len ) );
- TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, iv_len ) );
+ TEST_ASSERT(0 == mbedtls_cipher_set_iv(&ctx_dec, iv, iv_len));
+ TEST_ASSERT(0 == mbedtls_cipher_set_iv(&ctx_enc, iv, iv_len));
- TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
- TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
+ TEST_ASSERT(0 == mbedtls_cipher_reset(&ctx_dec));
+ TEST_ASSERT(0 == mbedtls_cipher_reset(&ctx_enc));
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
- TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, ad, sizeof( ad ) - i ) );
- TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, ad, sizeof( ad ) - i ) );
+ TEST_ASSERT(0 == mbedtls_cipher_update_ad(&ctx_dec, ad, sizeof(ad) - i));
+ TEST_ASSERT(0 == mbedtls_cipher_update_ad(&ctx_enc, ad, sizeof(ad) - i));
#endif
- block_size = mbedtls_cipher_get_block_size( &ctx_enc );
- TEST_ASSERT( block_size != 0 );
+ block_size = mbedtls_cipher_get_block_size(&ctx_enc);
+ TEST_ASSERT(block_size != 0);
- /* encode length number of bytes from inbuf */
- TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, length, encbuf, &outlen ) );
- total_len = outlen;
+ /* encode length number of bytes from inbuf */
+ TEST_ASSERT(0 == mbedtls_cipher_update(&ctx_enc, inbuf, length, encbuf, &outlen));
+ total_len = outlen;
- TEST_ASSERT( total_len == length ||
- ( total_len % block_size == 0 &&
- total_len < length &&
- total_len + block_size > length ) );
+ TEST_ASSERT(total_len == length ||
+ (total_len % block_size == 0 &&
+ total_len < length &&
+ total_len + block_size > length));
- TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + outlen, &outlen ) );
- total_len += outlen;
+ TEST_ASSERT(0 == mbedtls_cipher_finish(&ctx_enc, encbuf + outlen, &outlen));
+ total_len += outlen;
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
- TEST_ASSERT( 0 == mbedtls_cipher_write_tag( &ctx_enc, tag, sizeof( tag ) ) );
+ TEST_ASSERT(0 == mbedtls_cipher_write_tag(&ctx_enc, tag, sizeof(tag)));
#endif
- TEST_ASSERT( total_len == length ||
- ( total_len % block_size == 0 &&
- total_len > length &&
- total_len <= length + block_size ) );
+ TEST_ASSERT(total_len == length ||
+ (total_len % block_size == 0 &&
+ total_len > length &&
+ total_len <= length + block_size));
- /* decode the previously encoded string */
- TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, total_len, decbuf, &outlen ) );
- total_len = outlen;
+ /* decode the previously encoded string */
+ TEST_ASSERT(0 == mbedtls_cipher_update(&ctx_dec, encbuf, total_len, decbuf, &outlen));
+ total_len = outlen;
- TEST_ASSERT( total_len == length ||
- ( total_len % block_size == 0 &&
- total_len < length &&
- total_len + block_size >= length ) );
+ TEST_ASSERT(total_len == length ||
+ (total_len % block_size == 0 &&
+ total_len < length &&
+ total_len + block_size >= length));
- TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + outlen, &outlen ) );
- total_len += outlen;
+ TEST_ASSERT(0 == mbedtls_cipher_finish(&ctx_dec, decbuf + outlen, &outlen));
+ total_len += outlen;
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
- TEST_ASSERT( 0 == mbedtls_cipher_check_tag( &ctx_dec, tag, sizeof( tag ) ) );
+ TEST_ASSERT(0 == mbedtls_cipher_check_tag(&ctx_dec, tag, sizeof(tag)));
#endif
- /* check result */
- TEST_ASSERT( total_len == length );
- TEST_ASSERT( 0 == memcmp(inbuf, decbuf, length) );
+ /* check result */
+ TEST_ASSERT(total_len == length);
+ TEST_ASSERT(0 == memcmp(inbuf, decbuf, length));
}
/*
* Done
*/
exit:
- mbedtls_cipher_free( &ctx_dec );
- mbedtls_cipher_free( &ctx_enc );
+ mbedtls_cipher_free(&ctx_dec);
+ mbedtls_cipher_free(&ctx_enc);
}
/* END_CASE */
/* BEGIN_CASE */
-void enc_fail( int cipher_id, int pad_mode, int key_len, int length_val,
- int ret )
+void enc_fail(int cipher_id, int pad_mode, int key_len, int length_val,
+ int ret)
{
size_t length = length_val;
unsigned char key[32];
@@ -843,46 +843,46 @@
size_t outlen = 0;
- memset( key, 0, 32 );
- memset( iv , 0, 16 );
+ memset(key, 0, 32);
+ memset(iv, 0, 16);
- mbedtls_cipher_init( &ctx );
+ mbedtls_cipher_init(&ctx);
- memset( inbuf, 5, 64 );
- memset( encbuf, 0, 64 );
+ memset(inbuf, 5, 64);
+ memset(encbuf, 0, 64);
/* Check and get info structures */
- cipher_info = mbedtls_cipher_info_from_type( cipher_id );
- TEST_ASSERT( NULL != cipher_info );
+ cipher_info = mbedtls_cipher_info_from_type(cipher_id);
+ TEST_ASSERT(NULL != cipher_info);
/* Initialise context */
- TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
- TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key, key_len, MBEDTLS_ENCRYPT ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx, cipher_info));
+ TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx, key, key_len, MBEDTLS_ENCRYPT));
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
- TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
+ TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx, pad_mode));
#else
(void) pad_mode;
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
- TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv, 16 ) );
- TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
+ TEST_ASSERT(0 == mbedtls_cipher_set_iv(&ctx, iv, 16));
+ TEST_ASSERT(0 == mbedtls_cipher_reset(&ctx));
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
- TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, NULL, 0 ) );
+ TEST_ASSERT(0 == mbedtls_cipher_update_ad(&ctx, NULL, 0));
#endif
/* encode length number of bytes from inbuf */
- TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, inbuf, length, encbuf, &outlen ) );
- TEST_ASSERT( ret == mbedtls_cipher_finish( &ctx, encbuf + outlen, &outlen ) );
+ TEST_ASSERT(0 == mbedtls_cipher_update(&ctx, inbuf, length, encbuf, &outlen));
+ TEST_ASSERT(ret == mbedtls_cipher_finish(&ctx, encbuf + outlen, &outlen));
/* done */
exit:
- mbedtls_cipher_free( &ctx );
+ mbedtls_cipher_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void dec_empty_buf( int cipher,
- int expected_update_ret,
- int expected_finish_ret )
+void dec_empty_buf(int cipher,
+ int expected_update_ret,
+ int expected_finish_ret)
{
unsigned char key[32];
unsigned char iv[16];
@@ -896,47 +896,47 @@
size_t outlen = 0;
- memset( key, 0, 32 );
- memset( iv , 0, 16 );
+ memset(key, 0, 32);
+ memset(iv, 0, 16);
- mbedtls_cipher_init( &ctx_dec );
+ mbedtls_cipher_init(&ctx_dec);
- memset( encbuf, 0, 64 );
- memset( decbuf, 0, 64 );
+ memset(encbuf, 0, 64);
+ memset(decbuf, 0, 64);
/* Initialise context */
- cipher_info = mbedtls_cipher_info_from_type( cipher );
- TEST_ASSERT( NULL != cipher_info);
+ cipher_info = mbedtls_cipher_info_from_type(cipher);
+ TEST_ASSERT(NULL != cipher_info);
- if( cipher_info->type == MBEDTLS_CIPHER_CHACHA20 ||
- cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305 )
+ if (cipher_info->type == MBEDTLS_CIPHER_CHACHA20 ||
+ cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305) {
iv_len = 12;
+ }
- TEST_ASSERT( sizeof(key) * 8 >= cipher_info->key_bitlen );
+ TEST_ASSERT(sizeof(key) * 8 >= cipher_info->key_bitlen);
- TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx_dec, cipher_info));
- TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec,
- key, cipher_info->key_bitlen,
- MBEDTLS_DECRYPT ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx_dec,
+ key, cipher_info->key_bitlen,
+ MBEDTLS_DECRYPT));
- TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, iv_len ) );
+ TEST_ASSERT(0 == mbedtls_cipher_set_iv(&ctx_dec, iv, iv_len));
- TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
+ TEST_ASSERT(0 == mbedtls_cipher_reset(&ctx_dec));
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
- TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
+ TEST_ASSERT(0 == mbedtls_cipher_update_ad(&ctx_dec, NULL, 0));
#endif
/* decode 0-byte string */
- TEST_ASSERT( expected_update_ret ==
- mbedtls_cipher_update( &ctx_dec, encbuf, 0, decbuf, &outlen ) );
- TEST_ASSERT( 0 == outlen );
+ TEST_ASSERT(expected_update_ret ==
+ mbedtls_cipher_update(&ctx_dec, encbuf, 0, decbuf, &outlen));
+ TEST_ASSERT(0 == outlen);
- if ( expected_finish_ret == 0 &&
- ( cipher_info->mode == MBEDTLS_MODE_CBC ||
- cipher_info->mode == MBEDTLS_MODE_ECB ) )
- {
+ if (expected_finish_ret == 0 &&
+ (cipher_info->mode == MBEDTLS_MODE_CBC ||
+ cipher_info->mode == MBEDTLS_MODE_ECB)) {
/* Non-CBC and non-ECB ciphers are OK with decrypting empty buffers and
* return success, not MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED, when
* decrypting an empty buffer.
@@ -945,20 +945,20 @@
expected_finish_ret = MBEDTLS_ERR_CIPHER_FULL_BLOCK_EXPECTED;
}
- TEST_ASSERT( expected_finish_ret == mbedtls_cipher_finish(
- &ctx_dec, decbuf + outlen, &outlen ) );
- TEST_ASSERT( 0 == outlen );
+ TEST_ASSERT(expected_finish_ret == mbedtls_cipher_finish(
+ &ctx_dec, decbuf + outlen, &outlen));
+ TEST_ASSERT(0 == outlen);
exit:
- mbedtls_cipher_free( &ctx_dec );
+ mbedtls_cipher_free(&ctx_dec);
}
/* END_CASE */
/* BEGIN_CASE */
-void enc_dec_buf_multipart( int cipher_id, int key_len, int first_length_val,
- int second_length_val, int pad_mode,
- int first_encrypt_output_len, int second_encrypt_output_len,
- int first_decrypt_output_len, int second_decrypt_output_len )
+void enc_dec_buf_multipart(int cipher_id, int key_len, int first_length_val,
+ int second_length_val, int pad_mode,
+ int first_encrypt_output_len, int second_encrypt_output_len,
+ int first_decrypt_output_len, int second_decrypt_output_len)
{
size_t first_length = first_length_val;
size_t second_length = second_length_val;
@@ -978,115 +978,121 @@
size_t outlen = 0;
size_t totaloutlen = 0;
- memset( key, 0, 32 );
- memset( iv , 0, 16 );
+ memset(key, 0, 32);
+ memset(iv, 0, 16);
- mbedtls_cipher_init( &ctx_dec );
- mbedtls_cipher_init( &ctx_enc );
+ mbedtls_cipher_init(&ctx_dec);
+ mbedtls_cipher_init(&ctx_enc);
- memset( inbuf, 5, 64 );
- memset( encbuf, 0, 64 );
- memset( decbuf, 0, 64 );
+ memset(inbuf, 5, 64);
+ memset(encbuf, 0, 64);
+ memset(decbuf, 0, 64);
/* Initialise enc and dec contexts */
- cipher_info = mbedtls_cipher_info_from_type( cipher_id );
- TEST_ASSERT( NULL != cipher_info);
+ cipher_info = mbedtls_cipher_info_from_type(cipher_id);
+ TEST_ASSERT(NULL != cipher_info);
- TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
- TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx_dec, cipher_info));
+ TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx_enc, cipher_info));
- TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_dec, key, key_len, MBEDTLS_DECRYPT ) );
- TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx_enc, key, key_len, MBEDTLS_ENCRYPT ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx_dec, key, key_len, MBEDTLS_DECRYPT));
+ TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx_enc, key, key_len, MBEDTLS_ENCRYPT));
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
- if( -1 != pad_mode )
- {
- TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_dec, pad_mode ) );
- TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx_enc, pad_mode ) );
+ if (-1 != pad_mode) {
+ TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx_dec, pad_mode));
+ TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx_enc, pad_mode));
}
#else
(void) pad_mode;
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
- if( cipher_info->type == MBEDTLS_CIPHER_CHACHA20 ||
- cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305 )
+ if (cipher_info->type == MBEDTLS_CIPHER_CHACHA20 ||
+ cipher_info->type == MBEDTLS_CIPHER_CHACHA20_POLY1305) {
iv_len = 12;
- else
+ } else {
iv_len = sizeof(iv);
+ }
- TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_dec, iv, iv_len ) );
- TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx_enc, iv, iv_len ) );
+ TEST_ASSERT(0 == mbedtls_cipher_set_iv(&ctx_dec, iv, iv_len));
+ TEST_ASSERT(0 == mbedtls_cipher_set_iv(&ctx_enc, iv, iv_len));
- TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_dec ) );
- TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx_enc ) );
+ TEST_ASSERT(0 == mbedtls_cipher_reset(&ctx_dec));
+ TEST_ASSERT(0 == mbedtls_cipher_reset(&ctx_enc));
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
- TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_dec, NULL, 0 ) );
- TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx_enc, NULL, 0 ) );
+ TEST_ASSERT(0 == mbedtls_cipher_update_ad(&ctx_dec, NULL, 0));
+ TEST_ASSERT(0 == mbedtls_cipher_update_ad(&ctx_enc, NULL, 0));
#endif
- block_size = mbedtls_cipher_get_block_size( &ctx_enc );
- TEST_ASSERT( block_size != 0 );
+ block_size = mbedtls_cipher_get_block_size(&ctx_enc);
+ TEST_ASSERT(block_size != 0);
/* encode length number of bytes from inbuf */
- TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf, first_length, encbuf, &outlen ) );
- TEST_ASSERT( (size_t)first_encrypt_output_len == outlen );
+ TEST_ASSERT(0 == mbedtls_cipher_update(&ctx_enc, inbuf, first_length, encbuf, &outlen));
+ TEST_ASSERT((size_t) first_encrypt_output_len == outlen);
totaloutlen = outlen;
- TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_enc, inbuf + first_length, second_length, encbuf + totaloutlen, &outlen ) );
- TEST_ASSERT( (size_t)second_encrypt_output_len == outlen );
+ TEST_ASSERT(0 ==
+ mbedtls_cipher_update(&ctx_enc, inbuf + first_length, second_length,
+ encbuf + totaloutlen,
+ &outlen));
+ TEST_ASSERT((size_t) second_encrypt_output_len == outlen);
totaloutlen += outlen;
- TEST_ASSERT( totaloutlen == length ||
- ( totaloutlen % block_size == 0 &&
- totaloutlen < length &&
- totaloutlen + block_size > length ) );
+ TEST_ASSERT(totaloutlen == length ||
+ (totaloutlen % block_size == 0 &&
+ totaloutlen < length &&
+ totaloutlen + block_size > length));
- TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_enc, encbuf + totaloutlen, &outlen ) );
+ TEST_ASSERT(0 == mbedtls_cipher_finish(&ctx_enc, encbuf + totaloutlen, &outlen));
totaloutlen += outlen;
- TEST_ASSERT( totaloutlen == length ||
- ( totaloutlen % block_size == 0 &&
- totaloutlen > length &&
- totaloutlen <= length + block_size ) );
+ TEST_ASSERT(totaloutlen == length ||
+ (totaloutlen % block_size == 0 &&
+ totaloutlen > length &&
+ totaloutlen <= length + block_size));
/* decode the previously encoded string */
second_length = totaloutlen - first_length;
- TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf, first_length, decbuf, &outlen ) );
- TEST_ASSERT( (size_t)first_decrypt_output_len == outlen );
+ TEST_ASSERT(0 == mbedtls_cipher_update(&ctx_dec, encbuf, first_length, decbuf, &outlen));
+ TEST_ASSERT((size_t) first_decrypt_output_len == outlen);
totaloutlen = outlen;
- TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx_dec, encbuf + first_length, second_length, decbuf + totaloutlen, &outlen ) );
- TEST_ASSERT( (size_t)second_decrypt_output_len == outlen );
+ TEST_ASSERT(0 ==
+ mbedtls_cipher_update(&ctx_dec, encbuf + first_length, second_length,
+ decbuf + totaloutlen,
+ &outlen));
+ TEST_ASSERT((size_t) second_decrypt_output_len == outlen);
totaloutlen += outlen;
- TEST_ASSERT( totaloutlen == length ||
- ( totaloutlen % block_size == 0 &&
- totaloutlen < length &&
- totaloutlen + block_size >= length ) );
+ TEST_ASSERT(totaloutlen == length ||
+ (totaloutlen % block_size == 0 &&
+ totaloutlen < length &&
+ totaloutlen + block_size >= length));
- TEST_ASSERT( 0 == mbedtls_cipher_finish( &ctx_dec, decbuf + totaloutlen, &outlen ) );
+ TEST_ASSERT(0 == mbedtls_cipher_finish(&ctx_dec, decbuf + totaloutlen, &outlen));
totaloutlen += outlen;
- TEST_ASSERT( totaloutlen == length );
+ TEST_ASSERT(totaloutlen == length);
- TEST_ASSERT( 0 == memcmp(inbuf, decbuf, length) );
+ TEST_ASSERT(0 == memcmp(inbuf, decbuf, length));
exit:
- mbedtls_cipher_free( &ctx_dec );
- mbedtls_cipher_free( &ctx_enc );
+ mbedtls_cipher_free(&ctx_dec);
+ mbedtls_cipher_free(&ctx_enc);
}
/* END_CASE */
/* BEGIN_CASE */
-void decrypt_test_vec( int cipher_id, int pad_mode, data_t * key,
- data_t * iv, data_t * cipher,
- data_t * clear, data_t * ad, data_t * tag,
- int finish_result, int tag_result )
+void decrypt_test_vec(int cipher_id, int pad_mode, data_t *key,
+ data_t *iv, data_t *cipher,
+ data_t *clear, data_t *ad, data_t *tag,
+ int finish_result, int tag_result)
{
unsigned char output[265];
mbedtls_cipher_context_t ctx;
size_t outlen, total_len;
- mbedtls_cipher_init( &ctx );
+ mbedtls_cipher_init(&ctx);
- memset( output, 0x00, sizeof( output ) );
+ memset(output, 0x00, sizeof(output));
#if !defined(MBEDTLS_GCM_C) && !defined(MBEDTLS_CHACHAPOLY_C)
((void) ad);
@@ -1094,48 +1100,48 @@
#endif
/* Prepare context */
- TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
- mbedtls_cipher_info_from_type( cipher_id ) ) );
- TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx,
+ mbedtls_cipher_info_from_type(cipher_id)));
+ TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx, key->x, 8 * key->len, MBEDTLS_DECRYPT));
#if defined(MBEDTLS_CIPHER_MODE_WITH_PADDING)
- if( pad_mode != -1 )
- TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
+ if (pad_mode != -1) {
+ TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx, pad_mode));
+ }
#else
(void) pad_mode;
#endif /* MBEDTLS_CIPHER_MODE_WITH_PADDING */
- TEST_ASSERT( 0 == mbedtls_cipher_set_iv( &ctx, iv->x, iv->len ) );
- TEST_ASSERT( 0 == mbedtls_cipher_reset( &ctx ) );
+ TEST_ASSERT(0 == mbedtls_cipher_set_iv(&ctx, iv->x, iv->len));
+ TEST_ASSERT(0 == mbedtls_cipher_reset(&ctx));
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
- TEST_ASSERT( 0 == mbedtls_cipher_update_ad( &ctx, ad->x, ad->len ) );
+ TEST_ASSERT(0 == mbedtls_cipher_update_ad(&ctx, ad->x, ad->len));
#endif
/* decode buffer and check tag->x */
total_len = 0;
- TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, cipher->x, cipher->len, output, &outlen ) );
+ TEST_ASSERT(0 == mbedtls_cipher_update(&ctx, cipher->x, cipher->len, output, &outlen));
total_len += outlen;
- TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
- &outlen ) );
+ TEST_ASSERT(finish_result == mbedtls_cipher_finish(&ctx, output + outlen,
+ &outlen));
total_len += outlen;
#if defined(MBEDTLS_GCM_C) || defined(MBEDTLS_CHACHAPOLY_C)
- TEST_ASSERT( tag_result == mbedtls_cipher_check_tag( &ctx, tag->x, tag->len ) );
+ TEST_ASSERT(tag_result == mbedtls_cipher_check_tag(&ctx, tag->x, tag->len));
#endif
/* check plaintext only if everything went fine */
- if( 0 == finish_result && 0 == tag_result )
- {
- TEST_ASSERT( total_len == clear->len );
- TEST_ASSERT( 0 == memcmp( output, clear->x, clear->len ) );
+ if (0 == finish_result && 0 == tag_result) {
+ TEST_ASSERT(total_len == clear->len);
+ TEST_ASSERT(0 == memcmp(output, clear->x, clear->len));
}
exit:
- mbedtls_cipher_free( &ctx );
+ mbedtls_cipher_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_AUTH_CRYPT */
-void auth_crypt_tv( int cipher_id, data_t * key, data_t * iv,
- data_t * ad, data_t * cipher, data_t * tag,
- char * result, data_t * clear, int use_psa )
+void auth_crypt_tv(int cipher_id, data_t *key, data_t *iv,
+ data_t *ad, data_t *cipher, data_t *tag,
+ char *result, data_t *clear, int use_psa)
{
/*
* Take an AEAD ciphertext + tag and perform a pair
@@ -1172,19 +1178,23 @@
/* Null pointers are documented as valid for inputs of length 0.
* The test framework passes non-null pointers, so set them to NULL.
* key, cipher and tag can't be empty. */
- if( iv->len == 0 )
+ if (iv->len == 0) {
iv->x = NULL;
- if( ad->len == 0 )
+ }
+ if (ad->len == 0) {
ad->x = NULL;
- if( clear->len == 0 )
+ }
+ if (clear->len == 0) {
clear->x = NULL;
+ }
- mbedtls_cipher_init( &ctx );
+ mbedtls_cipher_init(&ctx);
/* Initialize PSA Crypto */
#if defined(MBEDTLS_USE_PSA_CRYPTO)
- if( use_psa == 1 )
- PSA_ASSERT( psa_crypto_init( ) );
+ if (use_psa == 1) {
+ PSA_ASSERT(psa_crypto_init());
+ }
#else
(void) use_psa;
#endif
@@ -1209,125 +1219,121 @@
/*
* Prepare context for decryption
*/
- if( ! cipher_reset_key( &ctx, cipher_id, use_psa, tag->len, key,
- MBEDTLS_DECRYPT ) )
+ if (!cipher_reset_key(&ctx, cipher_id, use_psa, tag->len, key,
+ MBEDTLS_DECRYPT)) {
goto exit;
+ }
/*
* prepare buffer for decryption
* (we need the tag appended to the ciphertext)
*/
cipher_plus_tag_len = cipher->len + tag->len;
- ASSERT_ALLOC( 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 );
+ ASSERT_ALLOC(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);
/*
* Compute length of output buffer according to the documentation
*/
- if( using_nist_kw )
+ if (using_nist_kw) {
decrypt_buf_len = cipher_plus_tag_len - 8;
- else
+ } else {
decrypt_buf_len = cipher_plus_tag_len - tag->len;
+ }
/*
* Try decrypting to a buffer that's 1B too small
*/
- if( decrypt_buf_len != 0 )
- {
- ASSERT_ALLOC( decrypt_buf, decrypt_buf_len - 1 );
+ if (decrypt_buf_len != 0) {
+ ASSERT_ALLOC(decrypt_buf, decrypt_buf_len - 1);
outlen = 0;
- ret = mbedtls_cipher_auth_decrypt_ext( &ctx, iv->x, iv->len,
- ad->x, ad->len, cipher_plus_tag, cipher_plus_tag_len,
- decrypt_buf, decrypt_buf_len - 1, &outlen, tag->len );
- TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ ret = mbedtls_cipher_auth_decrypt_ext(&ctx, iv->x, iv->len,
+ ad->x, ad->len, cipher_plus_tag, cipher_plus_tag_len,
+ decrypt_buf, decrypt_buf_len - 1, &outlen, tag->len);
+ TEST_ASSERT(ret == MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- mbedtls_free( decrypt_buf );
+ mbedtls_free(decrypt_buf);
decrypt_buf = NULL;
}
/*
* Authenticate and decrypt, and check result
*/
- ASSERT_ALLOC( decrypt_buf, decrypt_buf_len );
+ ASSERT_ALLOC(decrypt_buf, decrypt_buf_len);
outlen = 0;
- ret = mbedtls_cipher_auth_decrypt_ext( &ctx, iv->x, iv->len,
- ad->x, ad->len, cipher_plus_tag, cipher_plus_tag_len,
- decrypt_buf, decrypt_buf_len, &outlen, tag->len );
+ ret = mbedtls_cipher_auth_decrypt_ext(&ctx, iv->x, iv->len,
+ ad->x, ad->len, cipher_plus_tag, cipher_plus_tag_len,
+ decrypt_buf, decrypt_buf_len, &outlen, tag->len);
- if( strcmp( result, "FAIL" ) == 0 )
- {
- TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED );
- TEST_ASSERT( buffer_is_all_zero( decrypt_buf, decrypt_buf_len ) );
- }
- else
- {
- TEST_ASSERT( ret == 0 );
- ASSERT_COMPARE( decrypt_buf, outlen, clear->x, clear->len );
+ if (strcmp(result, "FAIL") == 0) {
+ TEST_ASSERT(ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED);
+ TEST_ASSERT(buffer_is_all_zero(decrypt_buf, decrypt_buf_len));
+ } else {
+ TEST_ASSERT(ret == 0);
+ ASSERT_COMPARE(decrypt_buf, outlen, clear->x, clear->len);
}
/* Free this, but keep cipher_plus_tag for deprecated function with PSA */
- mbedtls_free( decrypt_buf );
+ mbedtls_free(decrypt_buf);
decrypt_buf = NULL;
/*
* Encrypt back if test data was authentic
*/
- if( strcmp( result, "FAIL" ) != 0 )
- {
+ if (strcmp(result, "FAIL") != 0) {
/* prepare context for encryption */
- if( ! cipher_reset_key( &ctx, cipher_id, use_psa, tag->len, key,
- MBEDTLS_ENCRYPT ) )
+ if (!cipher_reset_key(&ctx, cipher_id, use_psa, tag->len, key,
+ MBEDTLS_ENCRYPT)) {
goto exit;
+ }
/*
* Compute size of output buffer according to documentation
*/
- if( using_nist_kw )
- {
+ if (using_nist_kw) {
encrypt_buf_len = clear->len + 8;
- if( using_nist_kw_padding && encrypt_buf_len % 8 != 0 )
+ if (using_nist_kw_padding && encrypt_buf_len % 8 != 0) {
encrypt_buf_len += 8 - encrypt_buf_len % 8;
- }
- else
- {
+ }
+ } else {
encrypt_buf_len = clear->len + tag->len;
}
/*
* Try encrypting with an output buffer that's 1B too small
*/
- ASSERT_ALLOC( encrypt_buf, encrypt_buf_len - 1 );
+ ASSERT_ALLOC(encrypt_buf, encrypt_buf_len - 1);
outlen = 0;
- ret = mbedtls_cipher_auth_encrypt_ext( &ctx, iv->x, iv->len,
- ad->x, ad->len, clear->x, clear->len,
- encrypt_buf, encrypt_buf_len - 1, &outlen, tag->len );
- TEST_ASSERT( ret != 0 );
+ ret = mbedtls_cipher_auth_encrypt_ext(&ctx, iv->x, iv->len,
+ ad->x, ad->len, clear->x, clear->len,
+ encrypt_buf, encrypt_buf_len - 1, &outlen, tag->len);
+ TEST_ASSERT(ret != 0);
- mbedtls_free( encrypt_buf );
+ mbedtls_free(encrypt_buf);
encrypt_buf = NULL;
/*
* Encrypt and check the result
*/
- ASSERT_ALLOC( encrypt_buf, encrypt_buf_len );
+ ASSERT_ALLOC(encrypt_buf, encrypt_buf_len);
outlen = 0;
- ret = mbedtls_cipher_auth_encrypt_ext( &ctx, iv->x, iv->len,
- ad->x, ad->len, clear->x, clear->len,
- encrypt_buf, encrypt_buf_len, &outlen, tag->len );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_cipher_auth_encrypt_ext(&ctx, iv->x, iv->len,
+ ad->x, ad->len, clear->x, clear->len,
+ encrypt_buf, encrypt_buf_len, &outlen, tag->len);
+ TEST_ASSERT(ret == 0);
- TEST_ASSERT( outlen == cipher->len + tag->len );
- TEST_ASSERT( memcmp( encrypt_buf, cipher->x, cipher->len ) == 0 );
- TEST_ASSERT( memcmp( encrypt_buf + cipher->len,
- tag->x, tag->len ) == 0 );
+ TEST_ASSERT(outlen == cipher->len + tag->len);
+ TEST_ASSERT(memcmp(encrypt_buf, cipher->x, cipher->len) == 0);
+ TEST_ASSERT(memcmp(encrypt_buf + cipher->len,
+ tag->x, tag->len) == 0);
- mbedtls_free( encrypt_buf );
+ mbedtls_free(encrypt_buf);
encrypt_buf = NULL;
}
@@ -1343,22 +1349,21 @@
/*
* Prepare context for decryption
*/
- if( ! cipher_reset_key( &ctx, cipher_id, use_psa, tag->len, key,
- MBEDTLS_DECRYPT ) )
+ if (!cipher_reset_key(&ctx, cipher_id, use_psa, tag->len, key,
+ MBEDTLS_DECRYPT)) {
goto exit;
+ }
/*
* Prepare pointers for decryption
*/
#if defined(MBEDTLS_USE_PSA_CRYPTO)
- if( use_psa == 1 )
- {
+ if (use_psa == 1) {
/* PSA requires that the tag immediately follows the ciphertext.
* Fortunately, we already have that from testing the new API. */
tmp_cipher = cipher_plus_tag;
tmp_tag = tmp_cipher + cipher->len;
- }
- else
+ } else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
{
tmp_cipher = cipher->x;
@@ -1369,58 +1374,51 @@
* Authenticate and decrypt, and check result
*/
- ASSERT_ALLOC( decrypt_buf, cipher->len );
+ ASSERT_ALLOC(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,
- tmp_tag, tag->len );
+ ret = mbedtls_cipher_auth_decrypt(&ctx, iv->x, iv->len, ad->x, ad->len,
+ tmp_cipher, cipher->len, decrypt_buf, &outlen,
+ tmp_tag, tag->len);
- if( using_nist_kw )
- {
+ if (using_nist_kw) {
/* NIST_KW with legacy API */
- TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
- }
- else if( strcmp( result, "FAIL" ) == 0 )
- {
+ TEST_ASSERT(ret == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE);
+ } else if (strcmp(result, "FAIL") == 0) {
/* unauthentic message */
- TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED );
- TEST_ASSERT( buffer_is_all_zero( decrypt_buf, cipher->len ) );
- }
- else
- {
+ TEST_ASSERT(ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED);
+ TEST_ASSERT(buffer_is_all_zero(decrypt_buf, cipher->len));
+ } else {
/* authentic message: is the plaintext correct? */
- TEST_ASSERT( ret == 0 );
- ASSERT_COMPARE( decrypt_buf, outlen, clear->x, clear->len );
+ TEST_ASSERT(ret == 0);
+ ASSERT_COMPARE(decrypt_buf, outlen, clear->x, clear->len);
}
- mbedtls_free( decrypt_buf );
+ mbedtls_free(decrypt_buf);
decrypt_buf = NULL;
- mbedtls_free( cipher_plus_tag );
+ mbedtls_free(cipher_plus_tag);
cipher_plus_tag = NULL;
/*
* Encrypt back if test data was authentic
*/
- if( strcmp( result, "FAIL" ) != 0 )
- {
+ if (strcmp(result, "FAIL") != 0) {
/* prepare context for encryption */
- if( ! cipher_reset_key( &ctx, cipher_id, use_psa, tag->len, key,
- MBEDTLS_ENCRYPT ) )
+ if (!cipher_reset_key(&ctx, cipher_id, use_psa, tag->len, key,
+ MBEDTLS_ENCRYPT)) {
goto exit;
+ }
/* prepare buffers for encryption */
#if defined(MBEDTLS_USE_PSA_CRYPTO)
- if( use_psa )
- {
- ASSERT_ALLOC( cipher_plus_tag, cipher->len + tag->len );
+ if (use_psa) {
+ ASSERT_ALLOC(cipher_plus_tag, cipher->len + tag->len);
tmp_cipher = cipher_plus_tag;
tmp_tag = cipher_plus_tag + cipher->len;
- }
- else
+ } else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
{
- ASSERT_ALLOC( encrypt_buf, cipher->len );
- ASSERT_ALLOC( tag_buf, tag->len );
+ ASSERT_ALLOC(encrypt_buf, cipher->len);
+ ASSERT_ALLOC(tag_buf, tag->len);
tmp_cipher = encrypt_buf;
tmp_tag = tag_buf;
}
@@ -1429,22 +1427,20 @@
* Encrypt and check the result
*/
outlen = 0;
- ret = mbedtls_cipher_auth_encrypt( &ctx, iv->x, iv->len, ad->x, ad->len,
- clear->x, clear->len, tmp_cipher, &outlen,
- tmp_tag, tag->len );
+ ret = mbedtls_cipher_auth_encrypt(&ctx, iv->x, iv->len, ad->x, ad->len,
+ clear->x, clear->len, tmp_cipher, &outlen,
+ tmp_tag, tag->len);
- if( using_nist_kw )
- {
- TEST_ASSERT( ret == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE );
- }
- else
- {
- TEST_ASSERT( ret == 0 );
+ if (using_nist_kw) {
+ TEST_ASSERT(ret == MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE);
+ } else {
+ TEST_ASSERT(ret == 0);
- TEST_ASSERT( outlen == cipher->len );
- if( cipher->len != 0 )
- TEST_ASSERT( memcmp( tmp_cipher, cipher->x, cipher->len ) == 0 );
- TEST_ASSERT( memcmp( tmp_tag, tag->x, tag->len ) == 0 );
+ TEST_ASSERT(outlen == cipher->len);
+ if (cipher->len != 0) {
+ TEST_ASSERT(memcmp(tmp_cipher, cipher->x, cipher->len) == 0);
+ }
+ TEST_ASSERT(memcmp(tmp_tag, tag->x, tag->len) == 0);
}
}
@@ -1452,158 +1448,161 @@
exit:
- mbedtls_cipher_free( &ctx );
- mbedtls_free( decrypt_buf );
- mbedtls_free( encrypt_buf );
- mbedtls_free( cipher_plus_tag );
+ mbedtls_cipher_free(&ctx);
+ mbedtls_free(decrypt_buf);
+ mbedtls_free(encrypt_buf);
+ mbedtls_free(cipher_plus_tag);
#if !defined(MBEDTLS_DEPRECATED_WARNING) && \
!defined(MBEDTLS_DEPRECATED_REMOVED)
- mbedtls_free( tag_buf );
+ mbedtls_free(tag_buf);
#endif /* !MBEDTLS_DEPRECATED_WARNING && !MBEDTLS_DEPRECATED_REMOVED */
#if defined(MBEDTLS_USE_PSA_CRYPTO)
- if( use_psa == 1 )
- PSA_DONE( );
+ if (use_psa == 1) {
+ PSA_DONE();
+ }
#endif /* MBEDTLS_USE_PSA_CRYPTO */
}
/* END_CASE */
/* BEGIN_CASE */
-void test_vec_ecb( int cipher_id, int operation, data_t * key,
- data_t * input, data_t * result, int finish_result
- )
+void test_vec_ecb(int cipher_id, int operation, data_t *key,
+ data_t *input, data_t *result, int finish_result
+ )
{
mbedtls_cipher_context_t ctx;
unsigned char output[32];
size_t outlen;
- mbedtls_cipher_init( &ctx );
+ mbedtls_cipher_init(&ctx);
- memset( output, 0x00, sizeof( output ) );
+ memset(output, 0x00, sizeof(output));
/* Prepare context */
- TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
- mbedtls_cipher_info_from_type( cipher_id ) ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx,
+ mbedtls_cipher_info_from_type(cipher_id)));
- TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, operation ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx, key->x, 8 * key->len, operation));
- TEST_ASSERT( 0 == mbedtls_cipher_update( &ctx, input->x,
- mbedtls_cipher_get_block_size( &ctx ),
- output, &outlen ) );
- TEST_ASSERT( outlen == mbedtls_cipher_get_block_size( &ctx ) );
- TEST_ASSERT( finish_result == mbedtls_cipher_finish( &ctx, output + outlen,
- &outlen ) );
- TEST_ASSERT( 0 == outlen );
+ TEST_ASSERT(0 == mbedtls_cipher_update(&ctx, input->x,
+ mbedtls_cipher_get_block_size(&ctx),
+ output, &outlen));
+ TEST_ASSERT(outlen == mbedtls_cipher_get_block_size(&ctx));
+ TEST_ASSERT(finish_result == mbedtls_cipher_finish(&ctx, output + outlen,
+ &outlen));
+ TEST_ASSERT(0 == outlen);
/* check plaintext only if everything went fine */
- if( 0 == finish_result )
- TEST_ASSERT( 0 == memcmp( output, result->x,
- mbedtls_cipher_get_block_size( &ctx ) ) );
+ if (0 == finish_result) {
+ TEST_ASSERT(0 == memcmp(output, result->x,
+ mbedtls_cipher_get_block_size(&ctx)));
+ }
exit:
- mbedtls_cipher_free( &ctx );
+ mbedtls_cipher_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
-void test_vec_crypt( int cipher_id, int operation, data_t *key,
- data_t *iv, data_t *input, data_t *result,
- int finish_result, int use_psa )
+void test_vec_crypt(int cipher_id, int operation, data_t *key,
+ data_t *iv, data_t *input, data_t *result,
+ int finish_result, int use_psa)
{
mbedtls_cipher_context_t ctx;
unsigned char output[32];
size_t outlen;
- mbedtls_cipher_init( &ctx );
+ mbedtls_cipher_init(&ctx);
- memset( output, 0x00, sizeof( output ) );
+ memset(output, 0x00, sizeof(output));
/* Prepare context */
#if !defined(MBEDTLS_USE_PSA_CRYPTO)
(void) use_psa;
#else
- if( use_psa == 1 )
- {
- PSA_ASSERT( psa_crypto_init( ) );
- TEST_ASSERT( 0 == mbedtls_cipher_setup_psa( &ctx,
- mbedtls_cipher_info_from_type( cipher_id ), 0 ) );
- }
- else
+ if (use_psa == 1) {
+ PSA_ASSERT(psa_crypto_init());
+ TEST_ASSERT(0 == mbedtls_cipher_setup_psa(&ctx,
+ mbedtls_cipher_info_from_type(cipher_id), 0));
+ } else
#endif /* MBEDTLS_USE_PSA_CRYPTO */
- TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx,
- mbedtls_cipher_info_from_type( cipher_id ) ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx,
+ mbedtls_cipher_info_from_type(cipher_id)));
- TEST_ASSERT( 0 == mbedtls_cipher_setkey( &ctx, key->x, 8 * key->len, operation ) );
- if( MBEDTLS_MODE_CBC == ctx.cipher_info->mode )
- TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, MBEDTLS_PADDING_NONE ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setkey(&ctx, key->x, 8 * key->len, operation));
+ if (MBEDTLS_MODE_CBC == ctx.cipher_info->mode) {
+ TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx, MBEDTLS_PADDING_NONE));
+ }
- TEST_ASSERT( finish_result == mbedtls_cipher_crypt( &ctx, iv->len ? iv->x : NULL,
- iv->len, input->x, input->len,
- output, &outlen ) );
- TEST_ASSERT( result->len == outlen );
+ TEST_ASSERT(finish_result == mbedtls_cipher_crypt(&ctx, iv->len ? iv->x : NULL,
+ iv->len, input->x, input->len,
+ output, &outlen));
+ TEST_ASSERT(result->len == outlen);
/* check plaintext only if everything went fine */
- if( 0 == finish_result )
- TEST_ASSERT( 0 == memcmp( output, result->x, outlen ) );
+ if (0 == finish_result) {
+ TEST_ASSERT(0 == memcmp(output, result->x, outlen));
+ }
exit:
- mbedtls_cipher_free( &ctx );
+ mbedtls_cipher_free(&ctx);
#if defined(MBEDTLS_USE_PSA_CRYPTO)
- PSA_DONE( );
+ PSA_DONE();
#endif /* MBEDTLS_USE_PSA_CRYPTO */
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_WITH_PADDING */
-void set_padding( int cipher_id, int pad_mode, int ret )
+void set_padding(int cipher_id, int pad_mode, int ret)
{
const mbedtls_cipher_info_t *cipher_info;
mbedtls_cipher_context_t ctx;
- mbedtls_cipher_init( &ctx );
+ mbedtls_cipher_init(&ctx);
- cipher_info = mbedtls_cipher_info_from_type( cipher_id );
- TEST_ASSERT( NULL != cipher_info );
- TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx, cipher_info ) );
+ cipher_info = mbedtls_cipher_info_from_type(cipher_id);
+ TEST_ASSERT(NULL != cipher_info);
+ TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx, cipher_info));
- TEST_ASSERT( ret == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
+ TEST_ASSERT(ret == mbedtls_cipher_set_padding_mode(&ctx, pad_mode));
exit:
- mbedtls_cipher_free( &ctx );
+ mbedtls_cipher_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void check_padding( int pad_mode, data_t * input, int ret, int dlen_check
- )
+void check_padding(int pad_mode, data_t *input, int ret, int dlen_check
+ )
{
mbedtls_cipher_info_t cipher_info;
mbedtls_cipher_context_t ctx;
size_t dlen;
/* build a fake context just for getting access to get_padding */
- mbedtls_cipher_init( &ctx );
+ mbedtls_cipher_init(&ctx);
cipher_info.mode = MBEDTLS_MODE_CBC;
ctx.cipher_info = &cipher_info;
- TEST_ASSERT( 0 == mbedtls_cipher_set_padding_mode( &ctx, pad_mode ) );
+ TEST_ASSERT(0 == mbedtls_cipher_set_padding_mode(&ctx, pad_mode));
- TEST_ASSERT( ret == ctx.get_padding( input->x, input->len, &dlen ) );
- if( 0 == ret )
- TEST_ASSERT( dlen == (size_t) dlen_check );
+ TEST_ASSERT(ret == ctx.get_padding(input->x, input->len, &dlen));
+ if (0 == ret) {
+ TEST_ASSERT(dlen == (size_t) dlen_check);
+ }
}
/* END_CASE */
/* BEGIN_CASE */
-void iv_len_validity( int cipher_id, char * cipher_string,
- int iv_len_val, int ret )
+void iv_len_validity(int cipher_id, char *cipher_string,
+ int iv_len_val, int ret)
{
size_t iv_len = iv_len_val;
unsigned char iv[16];
/* Initialise iv buffer */
- memset( iv, 0, sizeof( iv ) );
+ memset(iv, 0, sizeof(iv));
const mbedtls_cipher_info_t *cipher_info;
mbedtls_cipher_context_t ctx_dec;
@@ -1612,23 +1611,23 @@
/*
* Prepare contexts
*/
- mbedtls_cipher_init( &ctx_dec );
- mbedtls_cipher_init( &ctx_enc );
+ mbedtls_cipher_init(&ctx_dec);
+ mbedtls_cipher_init(&ctx_enc);
/* Check and get info structures */
- cipher_info = mbedtls_cipher_info_from_type( cipher_id );
- TEST_ASSERT( NULL != cipher_info );
- TEST_ASSERT( mbedtls_cipher_info_from_string( cipher_string ) == cipher_info );
+ cipher_info = mbedtls_cipher_info_from_type(cipher_id);
+ TEST_ASSERT(NULL != cipher_info);
+ TEST_ASSERT(mbedtls_cipher_info_from_string(cipher_string) == cipher_info);
/* Initialise enc and dec contexts */
- TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_dec, cipher_info ) );
- TEST_ASSERT( 0 == mbedtls_cipher_setup( &ctx_enc, cipher_info ) );
+ TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx_dec, cipher_info));
+ TEST_ASSERT(0 == mbedtls_cipher_setup(&ctx_enc, cipher_info));
- TEST_ASSERT( ret == mbedtls_cipher_set_iv( &ctx_dec, iv, iv_len ) );
- TEST_ASSERT( ret == mbedtls_cipher_set_iv( &ctx_enc, iv, iv_len ) );
+ TEST_ASSERT(ret == mbedtls_cipher_set_iv(&ctx_dec, iv, iv_len));
+ TEST_ASSERT(ret == mbedtls_cipher_set_iv(&ctx_enc, iv, iv_len));
exit:
- mbedtls_cipher_free( &ctx_dec );
- mbedtls_cipher_free( &ctx_enc );
+ mbedtls_cipher_free(&ctx_dec);
+ mbedtls_cipher_free(&ctx_enc);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_cmac.function b/tests/suites/test_suite_cmac.function
index c3d7da4..9624e8f 100644
--- a/tests/suites/test_suite_cmac.function
+++ b/tests/suites/test_suite_cmac.function
@@ -9,14 +9,14 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void mbedtls_cmac_self_test( )
+void mbedtls_cmac_self_test()
{
- TEST_ASSERT( mbedtls_cmac_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_cmac_self_test(1) == 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_cmac_null_args( )
+void mbedtls_cmac_null_args()
{
mbedtls_cipher_context_t ctx;
const mbedtls_cipher_info_t *cipher_info;
@@ -24,108 +24,108 @@
unsigned char test_data[MBEDTLS_CIPHER_BLKSIZE_MAX];
unsigned char test_output[MBEDTLS_CIPHER_BLKSIZE_MAX];
- mbedtls_cipher_init( &ctx );
+ mbedtls_cipher_init(&ctx);
/* Test NULL cipher info */
- TEST_ASSERT( mbedtls_cipher_cmac_update( &ctx, test_data, 16 ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx, test_data, 16) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- cipher_info = mbedtls_cipher_info_from_type( MBEDTLS_CIPHER_AES_128_ECB );
- TEST_ASSERT( mbedtls_cipher_setup( &ctx, cipher_info ) == 0 );
+ cipher_info = mbedtls_cipher_info_from_type(MBEDTLS_CIPHER_AES_128_ECB);
+ TEST_ASSERT(mbedtls_cipher_setup(&ctx, cipher_info) == 0);
- TEST_ASSERT( mbedtls_cipher_cmac_starts( NULL, test_key, 128 ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_cmac_starts(NULL, test_key, 128) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_cipher_cmac_starts( &ctx, NULL, 128 ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_cmac_starts(&ctx, NULL, 128) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_cipher_cmac_update( NULL, test_data, 16 ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_cmac_update(NULL, test_data, 16) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_cipher_cmac_update( &ctx, NULL, 16 ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx, NULL, 16) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_cipher_cmac_finish( NULL, test_output ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_cmac_finish(NULL, test_output) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_cipher_cmac_finish( &ctx, NULL ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_cmac_finish(&ctx, NULL) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_cipher_cmac_reset( NULL ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_cmac_reset(NULL) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_cipher_cmac( NULL,
- test_key, 128,
- test_data, 16,
- test_output ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_cmac(NULL,
+ test_key, 128,
+ test_data, 16,
+ test_output) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_cipher_cmac( cipher_info,
- NULL, 128,
- test_data, 16,
- test_output ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_cmac(cipher_info,
+ NULL, 128,
+ test_data, 16,
+ test_output) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_cipher_cmac( cipher_info,
- test_key, 128,
- NULL, 16,
- test_output ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_cmac(cipher_info,
+ test_key, 128,
+ NULL, 16,
+ test_output) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_cipher_cmac( cipher_info,
- test_key, 128,
- test_data, 16,
- NULL ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_cipher_cmac(cipher_info,
+ test_key, 128,
+ test_data, 16,
+ NULL) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
#if defined(MBEDTLS_AES_C)
- TEST_ASSERT( mbedtls_aes_cmac_prf_128( NULL, 16,
- test_data, 16,
- test_output ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_aes_cmac_prf_128(NULL, 16,
+ test_data, 16,
+ test_output) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_aes_cmac_prf_128( test_key, 16,
- NULL, 16,
- test_output ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_aes_cmac_prf_128(test_key, 16,
+ NULL, 16,
+ test_output) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_aes_cmac_prf_128( test_key, 16,
- test_data, 16,
- NULL ) ==
- MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_aes_cmac_prf_128(test_key, 16,
+ test_data, 16,
+ NULL) ==
+ MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA);
#endif
exit:
- mbedtls_cipher_free( &ctx );
+ mbedtls_cipher_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_cmac_setkey( int cipher_type, int key_size, int result )
+void mbedtls_cmac_setkey(int cipher_type, int key_size, int result)
{
const mbedtls_cipher_info_t *cipher_info;
unsigned char key[32];
unsigned char buf[16];
unsigned char tmp[16];
- memset( key, 0x2A, sizeof( key ) );
- TEST_ASSERT( (unsigned) key_size <= 8 * sizeof( key ) );
+ memset(key, 0x2A, sizeof(key));
+ TEST_ASSERT((unsigned) key_size <= 8 * sizeof(key));
- TEST_ASSERT( ( cipher_info = mbedtls_cipher_info_from_type( cipher_type ) )
- != NULL );
+ TEST_ASSERT((cipher_info = mbedtls_cipher_info_from_type(cipher_type))
+ != NULL);
- memset( buf, 0x2A, sizeof( buf ) );
- TEST_ASSERT( ( result == mbedtls_cipher_cmac( cipher_info, key, key_size,
- buf, 16, tmp ) ) != 0 );
+ memset(buf, 0x2A, sizeof(buf));
+ TEST_ASSERT((result == mbedtls_cipher_cmac(cipher_info, key, key_size,
+ buf, 16, tmp)) != 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_cmac_multiple_blocks( int cipher_type, data_t * key,
- int keybits, int block_size,
- data_t * block1, int block1_len,
- data_t * block2, int block2_len,
- data_t * block3, int block3_len,
- data_t * block4, int block4_len,
- data_t * expected_result )
+void mbedtls_cmac_multiple_blocks(int cipher_type, data_t *key,
+ int keybits, int block_size,
+ data_t *block1, int block1_len,
+ data_t *block2, int block2_len,
+ data_t *block3, int block3_len,
+ data_t *block4, int block4_len,
+ data_t *expected_result)
{
const mbedtls_cipher_info_t *cipher_info;
mbedtls_cipher_context_t ctx;
@@ -133,74 +133,78 @@
/* Convert the test parameters to binary data */
- mbedtls_cipher_init( &ctx );
+ mbedtls_cipher_init(&ctx);
/* Validate the test inputs */
- TEST_ASSERT( block1_len <= 100 );
- TEST_ASSERT( block2_len <= 100 );
- TEST_ASSERT( block3_len <= 100 );
- TEST_ASSERT( block4_len <= 100 );
+ TEST_ASSERT(block1_len <= 100);
+ TEST_ASSERT(block2_len <= 100);
+ TEST_ASSERT(block3_len <= 100);
+ TEST_ASSERT(block4_len <= 100);
/* Set up */
- TEST_ASSERT( ( cipher_info = mbedtls_cipher_info_from_type( cipher_type ) )
- != NULL );
+ TEST_ASSERT((cipher_info = mbedtls_cipher_info_from_type(cipher_type))
+ != NULL);
- TEST_ASSERT( mbedtls_cipher_setup( &ctx, cipher_info ) == 0 );
+ TEST_ASSERT(mbedtls_cipher_setup(&ctx, cipher_info) == 0);
- TEST_ASSERT( mbedtls_cipher_cmac_starts( &ctx,
- (const unsigned char*)key->x,
- keybits ) == 0 );
+ TEST_ASSERT(mbedtls_cipher_cmac_starts(&ctx,
+ (const unsigned char *) key->x,
+ keybits) == 0);
/* Multiple partial and complete blocks. A negative length means skip the
* update operation */
- if( block1_len >= 0)
- TEST_ASSERT( mbedtls_cipher_cmac_update( &ctx,
- (unsigned char*)block1->x,
- block1_len ) == 0);
+ if (block1_len >= 0) {
+ TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
+ (unsigned char *) block1->x,
+ block1_len) == 0);
+ }
- if( block2_len >= 0 )
- TEST_ASSERT( mbedtls_cipher_cmac_update( &ctx,
- (unsigned char*)block2->x,
- block2_len ) == 0);
+ if (block2_len >= 0) {
+ TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
+ (unsigned char *) block2->x,
+ block2_len) == 0);
+ }
- if( block3_len >= 0 )
- TEST_ASSERT( mbedtls_cipher_cmac_update( &ctx,
- (unsigned char*)block3->x,
- block3_len ) == 0);
+ if (block3_len >= 0) {
+ TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
+ (unsigned char *) block3->x,
+ block3_len) == 0);
+ }
- if( block4_len >= 0 )
- TEST_ASSERT( mbedtls_cipher_cmac_update( &ctx,
- (unsigned char*)block4->x,
- block4_len ) == 0);
+ if (block4_len >= 0) {
+ TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
+ (unsigned char *) block4->x,
+ block4_len) == 0);
+ }
- TEST_ASSERT( mbedtls_cipher_cmac_finish( &ctx, output ) == 0 );
+ TEST_ASSERT(mbedtls_cipher_cmac_finish(&ctx, output) == 0);
- TEST_ASSERT( memcmp( output, expected_result->x, block_size ) == 0 );
+ TEST_ASSERT(memcmp(output, expected_result->x, block_size) == 0);
exit:
- mbedtls_cipher_free( &ctx );
+ mbedtls_cipher_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_cmac_multiple_operations_same_key( int cipher_type,
- data_t * key, int keybits,
- int block_size,
- data_t * block_a1,
- int block_a1_len,
- data_t * block_a2,
- int block_a2_len,
- data_t * block_a3,
- int block_a3_len,
- data_t * expected_result_a,
- data_t * block_b1,
- int block_b1_len,
- data_t * block_b2,
- int block_b2_len,
- data_t * block_b3,
- int block_b3_len,
- data_t * expected_result_b
- )
+void mbedtls_cmac_multiple_operations_same_key(int cipher_type,
+ data_t *key, int keybits,
+ int block_size,
+ data_t *block_a1,
+ int block_a1_len,
+ data_t *block_a2,
+ int block_a2_len,
+ data_t *block_a3,
+ int block_a3_len,
+ data_t *expected_result_a,
+ data_t *block_b1,
+ int block_b1_len,
+ data_t *block_b2,
+ int block_b2_len,
+ data_t *block_b3,
+ int block_b3_len,
+ data_t *expected_result_b
+ )
{
const mbedtls_cipher_info_t *cipher_info;
mbedtls_cipher_context_t ctx;
@@ -210,77 +214,82 @@
- mbedtls_cipher_init( &ctx );
+ mbedtls_cipher_init(&ctx);
/* Validate the test inputs */
- TEST_ASSERT( block_a1_len <= 100 );
- TEST_ASSERT( block_a2_len <= 100 );
- TEST_ASSERT( block_a3_len <= 100 );
+ TEST_ASSERT(block_a1_len <= 100);
+ TEST_ASSERT(block_a2_len <= 100);
+ TEST_ASSERT(block_a3_len <= 100);
- TEST_ASSERT( block_b1_len <= 100 );
- TEST_ASSERT( block_b2_len <= 100 );
- TEST_ASSERT( block_b3_len <= 100 );
+ TEST_ASSERT(block_b1_len <= 100);
+ TEST_ASSERT(block_b2_len <= 100);
+ TEST_ASSERT(block_b3_len <= 100);
/* Set up */
- TEST_ASSERT( ( cipher_info = mbedtls_cipher_info_from_type( cipher_type ) )
- != NULL );
+ TEST_ASSERT((cipher_info = mbedtls_cipher_info_from_type(cipher_type))
+ != NULL);
- TEST_ASSERT( mbedtls_cipher_setup( &ctx, cipher_info ) == 0 );
+ TEST_ASSERT(mbedtls_cipher_setup(&ctx, cipher_info) == 0);
- TEST_ASSERT( mbedtls_cipher_cmac_starts( &ctx,
- (const unsigned char*)key->x,
- keybits ) == 0 );
+ TEST_ASSERT(mbedtls_cipher_cmac_starts(&ctx,
+ (const unsigned char *) key->x,
+ keybits) == 0);
/* Sequence A */
/* Multiple partial and complete blocks. A negative length means skip the
* update operation */
- if( block_a1_len >= 0 )
- TEST_ASSERT( mbedtls_cipher_cmac_update( &ctx,
- (unsigned char*)block_a1->x,
- block_a1_len ) == 0);
+ if (block_a1_len >= 0) {
+ TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
+ (unsigned char *) block_a1->x,
+ block_a1_len) == 0);
+ }
- if( block_a2_len >= 0 )
- TEST_ASSERT( mbedtls_cipher_cmac_update( &ctx,
- (unsigned char*)block_a2->x,
- block_a2_len ) == 0);
+ if (block_a2_len >= 0) {
+ TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
+ (unsigned char *) block_a2->x,
+ block_a2_len) == 0);
+ }
- if( block_a3_len >= 0 )
- TEST_ASSERT( mbedtls_cipher_cmac_update( &ctx,
- (unsigned char*)block_a3->x,
- block_a3_len ) == 0);
+ if (block_a3_len >= 0) {
+ TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
+ (unsigned char *) block_a3->x,
+ block_a3_len) == 0);
+ }
- TEST_ASSERT( mbedtls_cipher_cmac_finish( &ctx, output ) == 0 );
+ TEST_ASSERT(mbedtls_cipher_cmac_finish(&ctx, output) == 0);
- TEST_ASSERT( memcmp( output, expected_result_a->x, block_size ) == 0 );
+ TEST_ASSERT(memcmp(output, expected_result_a->x, block_size) == 0);
- TEST_ASSERT( mbedtls_cipher_cmac_reset( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_cipher_cmac_reset(&ctx) == 0);
/* Sequence B */
/* Multiple partial and complete blocks. A negative length means skip the
* update operation */
- if( block_b1_len >= 0)
- TEST_ASSERT( mbedtls_cipher_cmac_update( &ctx,
- (unsigned char*)block_b1->x,
- block_b1_len ) == 0);
+ if (block_b1_len >= 0) {
+ TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
+ (unsigned char *) block_b1->x,
+ block_b1_len) == 0);
+ }
- if( block_b2_len >= 0 )
- TEST_ASSERT( mbedtls_cipher_cmac_update( &ctx,
- (unsigned char*)block_b2->x,
- block_b2_len ) == 0);
+ if (block_b2_len >= 0) {
+ TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
+ (unsigned char *) block_b2->x,
+ block_b2_len) == 0);
+ }
- if( block_b3_len >= 0 )
- TEST_ASSERT( mbedtls_cipher_cmac_update( &ctx,
- (unsigned char*)block_b3->x,
- block_b3_len ) == 0);
+ if (block_b3_len >= 0) {
+ TEST_ASSERT(mbedtls_cipher_cmac_update(&ctx,
+ (unsigned char *) block_b3->x,
+ block_b3_len) == 0);
+ }
- TEST_ASSERT( mbedtls_cipher_cmac_finish( &ctx, output ) == 0 );
+ TEST_ASSERT(mbedtls_cipher_cmac_finish(&ctx, output) == 0);
- TEST_ASSERT( memcmp( output, expected_result_b->x, block_size ) == 0 );
+ TEST_ASSERT(memcmp(output, expected_result_b->x, block_size) == 0);
exit:
- mbedtls_cipher_free( &ctx );
+ mbedtls_cipher_free(&ctx);
}
/* END_CASE */
-
diff --git a/tests/suites/test_suite_constant_time.function b/tests/suites/test_suite_constant_time.function
index a3673b7..a40149a 100644
--- a/tests/suites/test_suite_constant_time.function
+++ b/tests/suites/test_suite_constant_time.function
@@ -16,34 +16,33 @@
/* END_HEADER */
/* BEGIN_CASE depends_on:MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC:MBEDTLS_TEST_HOOKS */
-void ssl_cf_memcpy_offset( int offset_min, int offset_max, int len )
+void ssl_cf_memcpy_offset(int offset_min, int offset_max, int len)
{
unsigned char *dst = NULL;
unsigned char *src = NULL;
size_t src_len = offset_max + len;
size_t secret;
- ASSERT_ALLOC( dst, len );
- ASSERT_ALLOC( src, src_len );
+ ASSERT_ALLOC(dst, len);
+ ASSERT_ALLOC(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 );
+ mbedtls_test_rnd_std_rand(NULL, src, src_len);
- for( secret = offset_min; secret <= (size_t) offset_max; secret++ )
- {
- mbedtls_test_set_step( (int) secret );
+ for (secret = offset_min; secret <= (size_t) offset_max; secret++) {
+ mbedtls_test_set_step((int) secret);
- TEST_CF_SECRET( &secret, sizeof( secret ) );
- mbedtls_ct_memcpy_offset( dst, src, secret,
- offset_min, offset_max, len );
- TEST_CF_PUBLIC( &secret, sizeof( secret ) );
- TEST_CF_PUBLIC( dst, len );
+ TEST_CF_SECRET(&secret, sizeof(secret));
+ mbedtls_ct_memcpy_offset(dst, src, secret,
+ offset_min, offset_max, len);
+ TEST_CF_PUBLIC(&secret, sizeof(secret));
+ TEST_CF_PUBLIC(dst, len);
- ASSERT_COMPARE( dst, len, src + secret, len );
+ ASSERT_COMPARE(dst, len, src + secret, len);
}
exit:
- mbedtls_free( dst );
- mbedtls_free( src );
+ mbedtls_free(dst);
+ mbedtls_free(src);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_constant_time_hmac.function b/tests/suites/test_suite_constant_time_hmac.function
index c19cde9..57d5a4e 100644
--- a/tests/suites/test_suite_constant_time_hmac.function
+++ b/tests/suites/test_suite_constant_time_hmac.function
@@ -8,7 +8,7 @@
/* END_HEADER */
/* BEGIN_CASE depends_on:MBEDTLS_SSL_SOME_SUITES_USE_TLS_CBC:MBEDTLS_TEST_HOOKS */
-void ssl_cf_hmac( int hash )
+void ssl_cf_hmac(int hash)
{
/*
* Test the function mbedtls_ct_hmac() against a reference
@@ -25,78 +25,77 @@
unsigned char *out = NULL;
unsigned char rec_num = 0;
- mbedtls_md_init( &ctx );
- mbedtls_md_init( &ref_ctx );
+ mbedtls_md_init(&ctx);
+ mbedtls_md_init(&ref_ctx);
- md_info = mbedtls_md_info_from_type( hash );
- TEST_ASSERT( md_info != NULL );
- out_len = mbedtls_md_get_size( md_info );
- TEST_ASSERT( out_len != 0 );
+ md_info = mbedtls_md_info_from_type(hash);
+ TEST_ASSERT(md_info != NULL);
+ out_len = mbedtls_md_get_size(md_info);
+ TEST_ASSERT(out_len != 0);
block_size = hash == MBEDTLS_MD_SHA384 ? 128 : 64;
/* Use allocated out buffer to catch overwrites */
- ASSERT_ALLOC( out, out_len );
+ ASSERT_ALLOC(out, out_len);
/* Set up contexts with the given hash and a dummy key */
- TEST_EQUAL( 0, mbedtls_md_setup( &ctx, md_info, 1 ) );
- TEST_EQUAL( 0, mbedtls_md_setup( &ref_ctx, md_info, 1 ) );
- memset( ref_out, 42, sizeof( ref_out ) );
- TEST_EQUAL( 0, mbedtls_md_hmac_starts( &ctx, ref_out, out_len ) );
- TEST_EQUAL( 0, mbedtls_md_hmac_starts( &ref_ctx, ref_out, out_len ) );
- memset( ref_out, 0, sizeof( ref_out ) );
+ TEST_EQUAL(0, mbedtls_md_setup(&ctx, md_info, 1));
+ TEST_EQUAL(0, mbedtls_md_setup(&ref_ctx, md_info, 1));
+ memset(ref_out, 42, sizeof(ref_out));
+ TEST_EQUAL(0, mbedtls_md_hmac_starts(&ctx, ref_out, out_len));
+ TEST_EQUAL(0, mbedtls_md_hmac_starts(&ref_ctx, ref_out, out_len));
+ memset(ref_out, 0, sizeof(ref_out));
/*
* Test all possible lengths up to a point. The difference between
* max_in_len and min_in_len is at most 255, and make sure they both vary
* by at least one block size.
*/
- for( max_in_len = 0; max_in_len <= 255 + block_size; max_in_len++ )
- {
- mbedtls_test_set_step( max_in_len * 10000 );
+ for (max_in_len = 0; max_in_len <= 255 + block_size; max_in_len++) {
+ mbedtls_test_set_step(max_in_len * 10000);
/* Use allocated in buffer to catch overreads */
- ASSERT_ALLOC( data, max_in_len );
+ ASSERT_ALLOC(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++ )
- {
- mbedtls_test_set_step( max_in_len * 10000 + in_len );
+ for (in_len = min_in_len; in_len <= max_in_len; in_len++) {
+ mbedtls_test_set_step(max_in_len * 10000 + in_len);
/* Set up dummy data and add_data */
rec_num++;
- memset( add_data, rec_num, sizeof( add_data ) );
- for( i = 0; i < in_len; i++ )
- data[i] = ( i & 0xff ) ^ rec_num;
+ memset(add_data, rec_num, sizeof(add_data));
+ for (i = 0; i < in_len; i++) {
+ data[i] = (i & 0xff) ^ rec_num;
+ }
/* Get the function's result */
- TEST_CF_SECRET( &in_len, sizeof( in_len ) );
- TEST_EQUAL( 0, mbedtls_ct_hmac( &ctx, add_data, sizeof( add_data ),
- data, in_len,
- min_in_len, max_in_len,
- out ) );
- TEST_CF_PUBLIC( &in_len, sizeof( in_len ) );
- TEST_CF_PUBLIC( out, out_len );
+ TEST_CF_SECRET(&in_len, sizeof(in_len));
+ TEST_EQUAL(0, mbedtls_ct_hmac(&ctx, add_data, sizeof(add_data),
+ data, in_len,
+ min_in_len, max_in_len,
+ out));
+ TEST_CF_PUBLIC(&in_len, sizeof(in_len));
+ TEST_CF_PUBLIC(out, out_len);
/* Compute the reference result */
- TEST_EQUAL( 0, mbedtls_md_hmac_update( &ref_ctx, add_data,
- sizeof( add_data ) ) );
- TEST_EQUAL( 0, mbedtls_md_hmac_update( &ref_ctx, data, in_len ) );
- TEST_EQUAL( 0, mbedtls_md_hmac_finish( &ref_ctx, ref_out ) );
- TEST_EQUAL( 0, mbedtls_md_hmac_reset( &ref_ctx ) );
+ TEST_EQUAL(0, mbedtls_md_hmac_update(&ref_ctx, add_data,
+ sizeof(add_data)));
+ TEST_EQUAL(0, mbedtls_md_hmac_update(&ref_ctx, data, in_len));
+ TEST_EQUAL(0, mbedtls_md_hmac_finish(&ref_ctx, ref_out));
+ TEST_EQUAL(0, mbedtls_md_hmac_reset(&ref_ctx));
/* Compare */
- ASSERT_COMPARE( out, out_len, ref_out, out_len );
+ ASSERT_COMPARE(out, out_len, ref_out, out_len);
}
- mbedtls_free( data );
+ mbedtls_free(data);
data = NULL;
}
exit:
- mbedtls_md_free( &ref_ctx );
- mbedtls_md_free( &ctx );
+ mbedtls_md_free(&ref_ctx);
+ mbedtls_md_free(&ctx);
- mbedtls_free( data );
- mbedtls_free( out );
+ mbedtls_free(data);
+ mbedtls_free(out);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_ctr_drbg.function b/tests/suites/test_suite_ctr_drbg.function
index c3ffe3b..29753ff 100644
--- a/tests/suites/test_suite_ctr_drbg.function
+++ b/tests/suites/test_suite_ctr_drbg.function
@@ -4,8 +4,7 @@
#include "string.h"
/* Modes for ctr_drbg_validate */
-enum reseed_mode
-{
+enum reseed_mode {
RESEED_NEVER, /* never reseed */
RESEED_FIRST, /* instantiate, reseed, generate, generate */
RESEED_SECOND, /* instantiate, generate, reseed, generate */
@@ -14,83 +13,83 @@
static size_t test_offset_idx = 0;
static size_t test_max_idx = 0;
-static int mbedtls_test_entropy_func( void *data, unsigned char *buf, size_t len )
+static int mbedtls_test_entropy_func(void *data, unsigned char *buf, size_t len)
{
const unsigned char *p = (unsigned char *) data;
- if( test_offset_idx + len > test_max_idx )
- return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
- memcpy( buf, p + test_offset_idx, len );
+ if (test_offset_idx + len > test_max_idx) {
+ return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
+ }
+ memcpy(buf, p + test_offset_idx, len);
test_offset_idx += len;
- return( 0 );
+ return 0;
}
-static void ctr_drbg_validate_internal( int reseed_mode, data_t * nonce,
- int entropy_len_arg, data_t * entropy,
- data_t * reseed,
- data_t * add1, data_t * add2,
- data_t * result )
+static void ctr_drbg_validate_internal(int reseed_mode, data_t *nonce,
+ int entropy_len_arg, data_t *entropy,
+ data_t *reseed,
+ data_t *add1, data_t *add2,
+ data_t *result)
{
mbedtls_ctr_drbg_context ctx;
unsigned char buf[64];
size_t entropy_chunk_len = (size_t) entropy_len_arg;
- TEST_ASSERT( entropy_chunk_len <= sizeof( buf ) );
+ TEST_ASSERT(entropy_chunk_len <= sizeof(buf));
test_offset_idx = 0;
- mbedtls_ctr_drbg_init( &ctx );
+ mbedtls_ctr_drbg_init(&ctx);
test_max_idx = entropy->len;
/* CTR_DRBG_Instantiate(entropy[:entropy->len], nonce, perso, <ignored>)
* where nonce||perso = nonce[nonce->len] */
- mbedtls_ctr_drbg_set_entropy_len( &ctx, entropy_chunk_len );
- mbedtls_ctr_drbg_set_nonce_len( &ctx, 0 );
- TEST_ASSERT( mbedtls_ctr_drbg_seed(
- &ctx,
- mbedtls_test_entropy_func, entropy->x,
- nonce->x, nonce->len ) == 0 );
- if( reseed_mode == RESEED_ALWAYS )
+ mbedtls_ctr_drbg_set_entropy_len(&ctx, entropy_chunk_len);
+ mbedtls_ctr_drbg_set_nonce_len(&ctx, 0);
+ TEST_ASSERT(mbedtls_ctr_drbg_seed(
+ &ctx,
+ mbedtls_test_entropy_func, entropy->x,
+ nonce->x, nonce->len) == 0);
+ if (reseed_mode == RESEED_ALWAYS) {
mbedtls_ctr_drbg_set_prediction_resistance(
&ctx,
- MBEDTLS_CTR_DRBG_PR_ON );
+ MBEDTLS_CTR_DRBG_PR_ON);
+ }
- if( reseed_mode == RESEED_FIRST )
- {
+ if (reseed_mode == RESEED_FIRST) {
/* CTR_DRBG_Reseed(entropy[idx:idx+entropy->len],
* reseed[:reseed->len]) */
- TEST_ASSERT( mbedtls_ctr_drbg_reseed(
- &ctx,
- reseed->x, reseed->len ) == 0 );
+ TEST_ASSERT(mbedtls_ctr_drbg_reseed(
+ &ctx,
+ reseed->x, reseed->len) == 0);
}
/* CTR_DRBG_Generate(result->len * 8 bits, add1[:add1->len]) -> buf */
/* Then reseed if prediction resistance is enabled. */
- TEST_ASSERT( mbedtls_ctr_drbg_random_with_add(
- &ctx,
- buf, result->len,
- add1->x, add1->len ) == 0 );
+ TEST_ASSERT(mbedtls_ctr_drbg_random_with_add(
+ &ctx,
+ buf, result->len,
+ add1->x, add1->len) == 0);
- if( reseed_mode == RESEED_SECOND )
- {
+ if (reseed_mode == RESEED_SECOND) {
/* CTR_DRBG_Reseed(entropy[idx:idx+entropy->len],
* reseed[:reseed->len]) */
- TEST_ASSERT( mbedtls_ctr_drbg_reseed(
- &ctx,
- reseed->x, reseed->len ) == 0 );
+ TEST_ASSERT(mbedtls_ctr_drbg_reseed(
+ &ctx,
+ reseed->x, reseed->len) == 0);
}
/* CTR_DRBG_Generate(result->len * 8 bits, add2->x[:add2->len]) -> buf */
/* Then reseed if prediction resistance is enabled. */
- TEST_ASSERT( mbedtls_ctr_drbg_random_with_add(
- &ctx,
- buf, result->len,
- add2->x, add2->len ) == 0 );
- TEST_ASSERT( memcmp( buf, result->x, result->len ) == 0 );
+ TEST_ASSERT(mbedtls_ctr_drbg_random_with_add(
+ &ctx,
+ buf, result->len,
+ add2->x, add2->len) == 0);
+ TEST_ASSERT(memcmp(buf, result->x, result->len) == 0);
exit:
- mbedtls_ctr_drbg_free( &ctx );
+ mbedtls_ctr_drbg_free(&ctx);
}
/* END_HEADER */
@@ -101,127 +100,127 @@
*/
/* BEGIN_CASE */
-void ctr_drbg_special_behaviours( )
+void ctr_drbg_special_behaviours()
{
mbedtls_ctr_drbg_context ctx;
unsigned char output[512];
unsigned char additional[512];
- mbedtls_ctr_drbg_init( &ctx );
- memset( output, 0, sizeof( output ) );
- memset( additional, 0, sizeof( additional ) );
+ mbedtls_ctr_drbg_init(&ctx);
+ memset(output, 0, sizeof(output));
+ memset(additional, 0, sizeof(additional));
- TEST_ASSERT( mbedtls_ctr_drbg_random_with_add( &ctx,
- output, MBEDTLS_CTR_DRBG_MAX_REQUEST + 1,
- additional, 16 ) ==
- MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG );
- TEST_ASSERT( mbedtls_ctr_drbg_random_with_add( &ctx,
- output, 16,
- additional, MBEDTLS_CTR_DRBG_MAX_INPUT + 1 ) ==
- MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
+ TEST_ASSERT(mbedtls_ctr_drbg_random_with_add(&ctx,
+ output, MBEDTLS_CTR_DRBG_MAX_REQUEST + 1,
+ additional, 16) ==
+ MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG);
+ TEST_ASSERT(mbedtls_ctr_drbg_random_with_add(&ctx,
+ output, 16,
+ additional, MBEDTLS_CTR_DRBG_MAX_INPUT + 1) ==
+ MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG);
- TEST_ASSERT( mbedtls_ctr_drbg_reseed( &ctx, additional,
- MBEDTLS_CTR_DRBG_MAX_SEED_INPUT + 1 ) ==
- MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
+ TEST_ASSERT(mbedtls_ctr_drbg_reseed(&ctx, additional,
+ MBEDTLS_CTR_DRBG_MAX_SEED_INPUT + 1) ==
+ MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG);
- mbedtls_ctr_drbg_set_entropy_len( &ctx, ~0 );
- TEST_ASSERT( mbedtls_ctr_drbg_reseed( &ctx, additional,
- MBEDTLS_CTR_DRBG_MAX_SEED_INPUT ) ==
- MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG );
+ mbedtls_ctr_drbg_set_entropy_len(&ctx, ~0);
+ TEST_ASSERT(mbedtls_ctr_drbg_reseed(&ctx, additional,
+ MBEDTLS_CTR_DRBG_MAX_SEED_INPUT) ==
+ MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG);
exit:
- mbedtls_ctr_drbg_free( &ctx );
+ mbedtls_ctr_drbg_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void ctr_drbg_validate_no_reseed( data_t * add_init, data_t * entropy,
- data_t * add1, data_t * add2,
- data_t * result_string )
+void ctr_drbg_validate_no_reseed(data_t *add_init, data_t *entropy,
+ data_t *add1, data_t *add2,
+ data_t *result_string)
{
data_t empty = { 0, 0 };
- ctr_drbg_validate_internal( RESEED_NEVER, add_init,
- entropy->len, entropy,
- &empty, add1, add2,
- result_string );
+ ctr_drbg_validate_internal(RESEED_NEVER, add_init,
+ entropy->len, entropy,
+ &empty, add1, add2,
+ result_string);
goto exit; // goto is needed to avoid warning ( no test assertions in func)
}
/* END_CASE */
/* BEGIN_CASE */
-void ctr_drbg_validate_pr( data_t * add_init, data_t * entropy,
- data_t * add1, data_t * add2,
- data_t * result_string )
+void ctr_drbg_validate_pr(data_t *add_init, data_t *entropy,
+ data_t *add1, data_t *add2,
+ data_t *result_string)
{
data_t empty = { 0, 0 };
- ctr_drbg_validate_internal( RESEED_ALWAYS, add_init,
- entropy->len / 3, entropy,
- &empty, add1, add2,
- result_string );
+ ctr_drbg_validate_internal(RESEED_ALWAYS, add_init,
+ entropy->len / 3, entropy,
+ &empty, add1, add2,
+ result_string);
goto exit; // goto is needed to avoid warning ( no test assertions in func)
}
/* END_CASE */
/* BEGIN_CASE */
-void ctr_drbg_validate_reseed_between( data_t * add_init, data_t * entropy,
- data_t * add1, data_t * add_reseed,
- data_t * add2, data_t * result_string )
+void ctr_drbg_validate_reseed_between(data_t *add_init, data_t *entropy,
+ data_t *add1, data_t *add_reseed,
+ data_t *add2, data_t *result_string)
{
- ctr_drbg_validate_internal( RESEED_SECOND, add_init,
- entropy->len / 2, entropy,
- add_reseed, add1, add2,
- result_string );
+ ctr_drbg_validate_internal(RESEED_SECOND, add_init,
+ entropy->len / 2, entropy,
+ add_reseed, add1, add2,
+ result_string);
goto exit; // goto is needed to avoid warning ( no test assertions in func)
}
/* END_CASE */
/* BEGIN_CASE */
-void ctr_drbg_validate_reseed_first( data_t * add_init, data_t * entropy,
- data_t * add1, data_t * add_reseed,
- data_t * add2, data_t * result_string )
+void ctr_drbg_validate_reseed_first(data_t *add_init, data_t *entropy,
+ data_t *add1, data_t *add_reseed,
+ data_t *add2, data_t *result_string)
{
- ctr_drbg_validate_internal( RESEED_FIRST, add_init,
- entropy->len / 2, entropy,
- add_reseed, add1, add2,
- result_string );
+ ctr_drbg_validate_internal(RESEED_FIRST, add_init,
+ entropy->len / 2, entropy,
+ add_reseed, add1, add2,
+ result_string);
goto exit; // goto is needed to avoid warning ( no test assertions in func)
}
/* END_CASE */
/* BEGIN_CASE */
-void ctr_drbg_entropy_strength( int expected_bit_strength )
+void ctr_drbg_entropy_strength(int expected_bit_strength)
{
unsigned char entropy[/*initial entropy*/ MBEDTLS_CTR_DRBG_ENTROPY_LEN +
- /*nonce*/ MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN +
- /*reseed*/ MBEDTLS_CTR_DRBG_ENTROPY_LEN];
+ /*nonce*/ MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN +
+ /*reseed*/ MBEDTLS_CTR_DRBG_ENTROPY_LEN];
mbedtls_ctr_drbg_context ctx;
size_t last_idx;
size_t byte_strength = expected_bit_strength / 8;
- mbedtls_ctr_drbg_init( &ctx );
+ mbedtls_ctr_drbg_init(&ctx);
test_offset_idx = 0;
- test_max_idx = sizeof( entropy );
- memset( entropy, 0, sizeof( entropy ) );
+ test_max_idx = sizeof(entropy);
+ memset(entropy, 0, sizeof(entropy));
/* The initial seeding must grab at least byte_strength bytes of entropy
* for the entropy input and byte_strength/2 bytes for a nonce. */
- TEST_ASSERT( mbedtls_ctr_drbg_seed( &ctx,
- mbedtls_test_entropy_func, entropy,
- NULL, 0 ) == 0 );
- TEST_ASSERT( test_offset_idx >= ( byte_strength * 3 + 1 ) / 2 );
+ TEST_ASSERT(mbedtls_ctr_drbg_seed(&ctx,
+ mbedtls_test_entropy_func, entropy,
+ NULL, 0) == 0);
+ TEST_ASSERT(test_offset_idx >= (byte_strength * 3 + 1) / 2);
last_idx = test_offset_idx;
/* A reseed must grab at least byte_strength bytes of entropy. */
- TEST_ASSERT( mbedtls_ctr_drbg_reseed( &ctx, NULL, 0 ) == 0 );
- TEST_ASSERT( test_offset_idx - last_idx >= byte_strength );
+ TEST_ASSERT(mbedtls_ctr_drbg_reseed(&ctx, NULL, 0) == 0);
+ TEST_ASSERT(test_offset_idx - last_idx >= byte_strength);
exit:
- mbedtls_ctr_drbg_free( &ctx );
+ mbedtls_ctr_drbg_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void ctr_drbg_entropy_usage( int entropy_nonce_len )
+void ctr_drbg_entropy_usage(int entropy_nonce_len)
{
unsigned char out[16];
unsigned char add[16];
@@ -230,109 +229,109 @@
size_t i, reps = 10;
size_t expected_idx = 0;
- mbedtls_ctr_drbg_init( &ctx );
+ mbedtls_ctr_drbg_init(&ctx);
test_offset_idx = 0;
- test_max_idx = sizeof( entropy );
- memset( entropy, 0, sizeof( entropy ) );
- memset( out, 0, sizeof( out ) );
- memset( add, 0, sizeof( add ) );
+ test_max_idx = sizeof(entropy);
+ memset(entropy, 0, sizeof(entropy));
+ memset(out, 0, sizeof(out));
+ memset(add, 0, sizeof(add));
- if( entropy_nonce_len >= 0 )
- TEST_ASSERT( mbedtls_ctr_drbg_set_nonce_len( &ctx, entropy_nonce_len ) == 0 );
+ if (entropy_nonce_len >= 0) {
+ TEST_ASSERT(mbedtls_ctr_drbg_set_nonce_len(&ctx, entropy_nonce_len) == 0);
+ }
/* Set reseed interval before seed */
- mbedtls_ctr_drbg_set_reseed_interval( &ctx, 2 * reps );
+ mbedtls_ctr_drbg_set_reseed_interval(&ctx, 2 * reps);
/* Init must use entropy */
- TEST_ASSERT( mbedtls_ctr_drbg_seed( &ctx, mbedtls_test_entropy_func, entropy, NULL, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_ctr_drbg_seed(&ctx, mbedtls_test_entropy_func, entropy, NULL, 0) == 0);
expected_idx += MBEDTLS_CTR_DRBG_ENTROPY_LEN;
- if( entropy_nonce_len >= 0 )
+ if (entropy_nonce_len >= 0) {
expected_idx += entropy_nonce_len;
- else
+ } else {
expected_idx += MBEDTLS_CTR_DRBG_ENTROPY_NONCE_LEN;
- TEST_EQUAL( test_offset_idx, expected_idx );
+ }
+ TEST_EQUAL(test_offset_idx, expected_idx);
/* By default, PR is off, and reseed interval was set to
* 2 * reps so the next few calls should not use entropy */
- for( i = 0; i < reps; i++ )
- {
- TEST_ASSERT( mbedtls_ctr_drbg_random( &ctx, out, sizeof( out ) - 4 ) == 0 );
- TEST_ASSERT( mbedtls_ctr_drbg_random_with_add( &ctx, out, sizeof( out ) - 4,
- add, sizeof( add ) ) == 0 );
+ for (i = 0; i < reps; i++) {
+ TEST_ASSERT(mbedtls_ctr_drbg_random(&ctx, out, sizeof(out) - 4) == 0);
+ TEST_ASSERT(mbedtls_ctr_drbg_random_with_add(&ctx, out, sizeof(out) - 4,
+ add, sizeof(add)) == 0);
}
- TEST_EQUAL( test_offset_idx, expected_idx );
+ TEST_EQUAL(test_offset_idx, expected_idx);
/* While at it, make sure we didn't write past the requested length */
- TEST_ASSERT( out[sizeof( out ) - 4] == 0 );
- TEST_ASSERT( out[sizeof( out ) - 3] == 0 );
- TEST_ASSERT( out[sizeof( out ) - 2] == 0 );
- TEST_ASSERT( out[sizeof( out ) - 1] == 0 );
+ TEST_ASSERT(out[sizeof(out) - 4] == 0);
+ TEST_ASSERT(out[sizeof(out) - 3] == 0);
+ TEST_ASSERT(out[sizeof(out) - 2] == 0);
+ TEST_ASSERT(out[sizeof(out) - 1] == 0);
/* There have been 2 * reps calls to random. The next call should reseed */
- TEST_ASSERT( mbedtls_ctr_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
+ TEST_ASSERT(mbedtls_ctr_drbg_random(&ctx, out, sizeof(out)) == 0);
expected_idx += MBEDTLS_CTR_DRBG_ENTROPY_LEN;
- TEST_EQUAL( test_offset_idx, expected_idx );
+ TEST_EQUAL(test_offset_idx, expected_idx);
/* Set reseed interval after seed */
- mbedtls_ctr_drbg_set_reseed_interval( &ctx, 4 * reps + 1 );
+ mbedtls_ctr_drbg_set_reseed_interval(&ctx, 4 * reps + 1);
/* The next few calls should not reseed */
- for( i = 0; i < (2 * reps); i++ )
- {
- TEST_ASSERT( mbedtls_ctr_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
- TEST_ASSERT( mbedtls_ctr_drbg_random_with_add( &ctx, out, sizeof( out ) ,
- add, sizeof( add ) ) == 0 );
+ for (i = 0; i < (2 * reps); i++) {
+ TEST_ASSERT(mbedtls_ctr_drbg_random(&ctx, out, sizeof(out)) == 0);
+ TEST_ASSERT(mbedtls_ctr_drbg_random_with_add(&ctx, out, sizeof(out),
+ add, sizeof(add)) == 0);
}
- TEST_EQUAL( test_offset_idx, expected_idx );
+ TEST_EQUAL(test_offset_idx, expected_idx);
/* Call update with too much data (sizeof entropy > MAX(_SEED)_INPUT).
* Make sure it's detected as an error and doesn't cause memory
* corruption. */
- TEST_ASSERT( mbedtls_ctr_drbg_update_ret(
- &ctx, entropy, sizeof( entropy ) ) != 0 );
+ TEST_ASSERT(mbedtls_ctr_drbg_update_ret(
+ &ctx, entropy, sizeof(entropy)) != 0);
/* Now enable PR, so the next few calls should all reseed */
- mbedtls_ctr_drbg_set_prediction_resistance( &ctx, MBEDTLS_CTR_DRBG_PR_ON );
- TEST_ASSERT( mbedtls_ctr_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
+ mbedtls_ctr_drbg_set_prediction_resistance(&ctx, MBEDTLS_CTR_DRBG_PR_ON);
+ TEST_ASSERT(mbedtls_ctr_drbg_random(&ctx, out, sizeof(out)) == 0);
expected_idx += MBEDTLS_CTR_DRBG_ENTROPY_LEN;
- TEST_EQUAL( test_offset_idx, expected_idx );
+ TEST_EQUAL(test_offset_idx, expected_idx);
/* Finally, check setting entropy_len */
- mbedtls_ctr_drbg_set_entropy_len( &ctx, 42 );
- TEST_ASSERT( mbedtls_ctr_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
+ mbedtls_ctr_drbg_set_entropy_len(&ctx, 42);
+ TEST_ASSERT(mbedtls_ctr_drbg_random(&ctx, out, sizeof(out)) == 0);
expected_idx += 42;
- TEST_EQUAL( test_offset_idx, expected_idx );
+ TEST_EQUAL(test_offset_idx, expected_idx);
- mbedtls_ctr_drbg_set_entropy_len( &ctx, 13 );
- TEST_ASSERT( mbedtls_ctr_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
+ mbedtls_ctr_drbg_set_entropy_len(&ctx, 13);
+ TEST_ASSERT(mbedtls_ctr_drbg_random(&ctx, out, sizeof(out)) == 0);
expected_idx += 13;
- TEST_EQUAL( test_offset_idx, expected_idx );
+ TEST_EQUAL(test_offset_idx, expected_idx);
exit:
- mbedtls_ctr_drbg_free( &ctx );
+ mbedtls_ctr_drbg_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO */
-void ctr_drbg_seed_file( char * path, int ret )
+void ctr_drbg_seed_file(char *path, int ret)
{
mbedtls_ctr_drbg_context ctx;
- mbedtls_ctr_drbg_init( &ctx );
+ mbedtls_ctr_drbg_init(&ctx);
- TEST_ASSERT( mbedtls_ctr_drbg_seed( &ctx, mbedtls_test_rnd_std_rand,
- NULL, NULL, 0 ) == 0 );
- TEST_ASSERT( mbedtls_ctr_drbg_write_seed_file( &ctx, path ) == ret );
- TEST_ASSERT( mbedtls_ctr_drbg_update_seed_file( &ctx, path ) == ret );
+ TEST_ASSERT(mbedtls_ctr_drbg_seed(&ctx, mbedtls_test_rnd_std_rand,
+ NULL, NULL, 0) == 0);
+ TEST_ASSERT(mbedtls_ctr_drbg_write_seed_file(&ctx, path) == ret);
+ TEST_ASSERT(mbedtls_ctr_drbg_update_seed_file(&ctx, path) == ret);
exit:
- mbedtls_ctr_drbg_free( &ctx );
+ mbedtls_ctr_drbg_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void ctr_drbg_selftest( )
+void ctr_drbg_selftest()
{
- TEST_ASSERT( mbedtls_ctr_drbg_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_ctr_drbg_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_debug.function b/tests/suites/test_suite_debug.function
index cadc947..cbb3a63 100644
--- a/tests/suites/test_suite_debug.function
+++ b/tests/suites/test_suite_debug.function
@@ -2,8 +2,7 @@
#include "mbedtls/debug.h"
#include "string.h"
-struct buffer_data
-{
+struct buffer_data {
char buf[2000];
char *ptr;
};
@@ -14,29 +13,32 @@
char *p = buffer->ptr;
((void) level);
- memcpy( p, file, strlen( file ) );
- p += strlen( file );
+ memcpy(p, file, strlen(file));
+ p += strlen(file);
*p++ = '(';
- *p++ = '0' + ( line / 1000 ) % 10;
- *p++ = '0' + ( line / 100 ) % 10;
- *p++ = '0' + ( line / 10 ) % 10;
- *p++ = '0' + ( line / 1 ) % 10;
+ *p++ = '0' + (line / 1000) % 10;
+ *p++ = '0' + (line / 100) % 10;
+ *p++ = '0' + (line / 10) % 10;
+ *p++ = '0' + (line / 1) % 10;
*p++ = ')';
*p++ = ':';
*p++ = ' ';
#if defined(MBEDTLS_THREADING_C)
/* Skip "thread ID" (up to the first space) as it is not predictable */
- while( *str++ != ' ' );
+ while (*str++ != ' ') {
+ ;
+ }
#endif
- memcpy( p, str, strlen( str ) );
- p += strlen( str );
+ memcpy(p, str, strlen(str));
+ p += strlen(str);
/* Detect if debug messages output partial lines and mark them */
- if( p[-1] != '\n' )
+ if (p[-1] != '\n') {
*p++ = '*';
+ }
buffer->ptr = p;
}
@@ -48,148 +50,148 @@
*/
/* BEGIN_CASE */
-void debug_print_msg_threshold( int threshold, int level, char * file,
- int line, char * result_str )
+void debug_print_msg_threshold(int threshold, int level, char *file,
+ int line, char *result_str)
{
mbedtls_ssl_context ssl;
mbedtls_ssl_config conf;
struct buffer_data buffer;
- mbedtls_ssl_init( &ssl );
- mbedtls_ssl_config_init( &conf );
- memset( buffer.buf, 0, 2000 );
+ mbedtls_ssl_init(&ssl);
+ mbedtls_ssl_config_init(&conf);
+ memset(buffer.buf, 0, 2000);
buffer.ptr = buffer.buf;
- TEST_ASSERT( mbedtls_ssl_setup( &ssl, &conf ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_setup(&ssl, &conf) == 0);
- mbedtls_debug_set_threshold( threshold );
- mbedtls_ssl_conf_dbg( &conf, string_debug, &buffer);
+ mbedtls_debug_set_threshold(threshold);
+ mbedtls_ssl_conf_dbg(&conf, string_debug, &buffer);
- mbedtls_debug_print_msg( &ssl, level, file, line,
- "Text message, 2 == %d", 2 );
+ mbedtls_debug_print_msg(&ssl, level, file, line,
+ "Text message, 2 == %d", 2);
- TEST_ASSERT( strcmp( buffer.buf, result_str ) == 0 );
+ TEST_ASSERT(strcmp(buffer.buf, result_str) == 0);
exit:
- mbedtls_ssl_free( &ssl );
- mbedtls_ssl_config_free( &conf );
+ mbedtls_ssl_free(&ssl);
+ mbedtls_ssl_config_free(&conf);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_debug_print_ret( char * file, int line, char * text, int value,
- char * result_str )
+void mbedtls_debug_print_ret(char *file, int line, char *text, int value,
+ char *result_str)
{
mbedtls_ssl_context ssl;
mbedtls_ssl_config conf;
struct buffer_data buffer;
- mbedtls_ssl_init( &ssl );
- mbedtls_ssl_config_init( &conf );
- memset( buffer.buf, 0, 2000 );
+ mbedtls_ssl_init(&ssl);
+ mbedtls_ssl_config_init(&conf);
+ memset(buffer.buf, 0, 2000);
buffer.ptr = buffer.buf;
- TEST_ASSERT( mbedtls_ssl_setup( &ssl, &conf ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_setup(&ssl, &conf) == 0);
- mbedtls_ssl_conf_dbg( &conf, string_debug, &buffer);
+ mbedtls_ssl_conf_dbg(&conf, string_debug, &buffer);
- mbedtls_debug_print_ret( &ssl, 0, file, line, text, value);
+ mbedtls_debug_print_ret(&ssl, 0, file, line, text, value);
- TEST_ASSERT( strcmp( buffer.buf, result_str ) == 0 );
+ TEST_ASSERT(strcmp(buffer.buf, result_str) == 0);
exit:
- mbedtls_ssl_free( &ssl );
- mbedtls_ssl_config_free( &conf );
+ mbedtls_ssl_free(&ssl);
+ mbedtls_ssl_config_free(&conf);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_debug_print_buf( char * file, int line, char * text,
- data_t * data, char * result_str )
+void mbedtls_debug_print_buf(char *file, int line, char *text,
+ data_t *data, char *result_str)
{
mbedtls_ssl_context ssl;
mbedtls_ssl_config conf;
struct buffer_data buffer;
- mbedtls_ssl_init( &ssl );
- mbedtls_ssl_config_init( &conf );
- memset( buffer.buf, 0, 2000 );
+ mbedtls_ssl_init(&ssl);
+ mbedtls_ssl_config_init(&conf);
+ memset(buffer.buf, 0, 2000);
buffer.ptr = buffer.buf;
- TEST_ASSERT( mbedtls_ssl_setup( &ssl, &conf ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_setup(&ssl, &conf) == 0);
- mbedtls_ssl_conf_dbg( &conf, string_debug, &buffer);
+ mbedtls_ssl_conf_dbg(&conf, string_debug, &buffer);
- mbedtls_debug_print_buf( &ssl, 0, file, line, text, data->x, data->len );
+ mbedtls_debug_print_buf(&ssl, 0, file, line, text, data->x, data->len);
- TEST_ASSERT( strcmp( buffer.buf, result_str ) == 0 );
+ TEST_ASSERT(strcmp(buffer.buf, result_str) == 0);
exit:
- mbedtls_ssl_free( &ssl );
- mbedtls_ssl_config_free( &conf );
+ mbedtls_ssl_free(&ssl);
+ mbedtls_ssl_config_free(&conf);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C */
-void mbedtls_debug_print_crt( char * crt_file, char * file, int line,
- char * prefix, char * result_str )
+void mbedtls_debug_print_crt(char *crt_file, char *file, int line,
+ char *prefix, char *result_str)
{
mbedtls_x509_crt crt;
mbedtls_ssl_context ssl;
mbedtls_ssl_config conf;
struct buffer_data buffer;
- mbedtls_ssl_init( &ssl );
- mbedtls_ssl_config_init( &conf );
- mbedtls_x509_crt_init( &crt );
- memset( buffer.buf, 0, 2000 );
+ mbedtls_ssl_init(&ssl);
+ mbedtls_ssl_config_init(&conf);
+ mbedtls_x509_crt_init(&crt);
+ memset(buffer.buf, 0, 2000);
buffer.ptr = buffer.buf;
- TEST_ASSERT( mbedtls_ssl_setup( &ssl, &conf ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_setup(&ssl, &conf) == 0);
- mbedtls_ssl_conf_dbg( &conf, string_debug, &buffer);
+ mbedtls_ssl_conf_dbg(&conf, string_debug, &buffer);
- TEST_ASSERT( mbedtls_x509_crt_parse_file( &crt, crt_file ) == 0 );
- mbedtls_debug_print_crt( &ssl, 0, file, line, prefix, &crt);
+ TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
+ mbedtls_debug_print_crt(&ssl, 0, file, line, prefix, &crt);
- TEST_ASSERT( strcmp( buffer.buf, result_str ) == 0 );
+ TEST_ASSERT(strcmp(buffer.buf, result_str) == 0);
exit:
- mbedtls_x509_crt_free( &crt );
- mbedtls_ssl_free( &ssl );
- mbedtls_ssl_config_free( &conf );
+ mbedtls_x509_crt_free(&crt);
+ mbedtls_ssl_free(&ssl);
+ mbedtls_ssl_config_free(&conf);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_BIGNUM_C */
-void mbedtls_debug_print_mpi( char * value, char * file, int line,
- char * prefix, char * result_str )
+void mbedtls_debug_print_mpi(char *value, char *file, int line,
+ char *prefix, char *result_str)
{
mbedtls_ssl_context ssl;
mbedtls_ssl_config conf;
struct buffer_data buffer;
mbedtls_mpi val;
- mbedtls_ssl_init( &ssl );
- mbedtls_ssl_config_init( &conf );
- mbedtls_mpi_init( &val );
- memset( buffer.buf, 0, 2000 );
+ mbedtls_ssl_init(&ssl);
+ mbedtls_ssl_config_init(&conf);
+ mbedtls_mpi_init(&val);
+ memset(buffer.buf, 0, 2000);
buffer.ptr = buffer.buf;
- TEST_ASSERT( mbedtls_ssl_setup( &ssl, &conf ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_setup(&ssl, &conf) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &val, value ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&val, value) == 0);
- mbedtls_ssl_conf_dbg( &conf, string_debug, &buffer);
+ mbedtls_ssl_conf_dbg(&conf, string_debug, &buffer);
- mbedtls_debug_print_mpi( &ssl, 0, file, line, prefix, &val);
+ mbedtls_debug_print_mpi(&ssl, 0, file, line, prefix, &val);
- TEST_ASSERT( strcmp( buffer.buf, result_str ) == 0 );
+ TEST_ASSERT(strcmp(buffer.buf, result_str) == 0);
exit:
- mbedtls_mpi_free( &val );
- mbedtls_ssl_free( &ssl );
- mbedtls_ssl_config_free( &conf );
+ mbedtls_mpi_free(&val);
+ mbedtls_ssl_free(&ssl);
+ mbedtls_ssl_config_free(&conf);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_des.function b/tests/suites/test_suite_des.function
index 7256fb5..b846d77 100644
--- a/tests/suites/test_suite_des.function
+++ b/tests/suites/test_suite_des.function
@@ -8,269 +8,273 @@
*/
/* BEGIN_CASE */
-void des_check_weak( data_t * key, int ret )
+void des_check_weak(data_t *key, int ret)
{
- TEST_ASSERT( mbedtls_des_key_check_weak( key->x ) == ret );
+ TEST_ASSERT(mbedtls_des_key_check_weak(key->x) == ret);
}
/* END_CASE */
/* BEGIN_CASE */
-void des_encrypt_ecb( data_t * key_str, data_t * src_str, data_t * dst )
+void des_encrypt_ecb(data_t *key_str, data_t *src_str, data_t *dst)
{
unsigned char output[100];
mbedtls_des_context ctx;
memset(output, 0x00, 100);
- mbedtls_des_init( &ctx );
+ mbedtls_des_init(&ctx);
- TEST_ASSERT( mbedtls_des_setkey_enc( &ctx, key_str->x ) == 0 );
- TEST_ASSERT( mbedtls_des_crypt_ecb( &ctx, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_des_setkey_enc(&ctx, key_str->x) == 0);
+ TEST_ASSERT(mbedtls_des_crypt_ecb(&ctx, src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 8, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 8, dst->len) == 0);
exit:
- mbedtls_des_free( &ctx );
+ mbedtls_des_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void des_decrypt_ecb( data_t * key_str, data_t * src_str, data_t * dst )
+void des_decrypt_ecb(data_t *key_str, data_t *src_str, data_t *dst)
{
unsigned char output[100];
mbedtls_des_context ctx;
memset(output, 0x00, 100);
- mbedtls_des_init( &ctx );
+ mbedtls_des_init(&ctx);
- TEST_ASSERT( mbedtls_des_setkey_dec( &ctx, key_str->x ) == 0 );
- TEST_ASSERT( mbedtls_des_crypt_ecb( &ctx, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_des_setkey_dec(&ctx, key_str->x) == 0);
+ TEST_ASSERT(mbedtls_des_crypt_ecb(&ctx, src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 8, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 8, dst->len) == 0);
exit:
- mbedtls_des_free( &ctx );
+ mbedtls_des_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void des_encrypt_cbc( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst, int cbc_result )
+void des_encrypt_cbc(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst, int cbc_result)
{
unsigned char output[100];
mbedtls_des_context ctx;
memset(output, 0x00, 100);
- mbedtls_des_init( &ctx );
+ mbedtls_des_init(&ctx);
- TEST_ASSERT( mbedtls_des_setkey_enc( &ctx, key_str->x ) == 0 );
- TEST_ASSERT( mbedtls_des_crypt_cbc( &ctx, MBEDTLS_DES_ENCRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
- if( cbc_result == 0 )
- {
+ TEST_ASSERT(mbedtls_des_setkey_enc(&ctx, key_str->x) == 0);
+ TEST_ASSERT(mbedtls_des_crypt_cbc(&ctx, MBEDTLS_DES_ENCRYPT, src_str->len, iv_str->x,
+ src_str->x, output) == cbc_result);
+ if (cbc_result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, src_str->len,
- dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, src_str->len,
+ dst->len) == 0);
}
exit:
- mbedtls_des_free( &ctx );
+ mbedtls_des_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void des_decrypt_cbc( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst,
- int cbc_result )
+void des_decrypt_cbc(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst,
+ int cbc_result)
{
unsigned char output[100];
mbedtls_des_context ctx;
memset(output, 0x00, 100);
- mbedtls_des_init( &ctx );
+ mbedtls_des_init(&ctx);
- TEST_ASSERT( mbedtls_des_setkey_dec( &ctx, key_str->x ) == 0 );
- TEST_ASSERT( mbedtls_des_crypt_cbc( &ctx, MBEDTLS_DES_DECRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
- if( cbc_result == 0 )
- {
+ TEST_ASSERT(mbedtls_des_setkey_dec(&ctx, key_str->x) == 0);
+ TEST_ASSERT(mbedtls_des_crypt_cbc(&ctx, MBEDTLS_DES_DECRYPT, src_str->len, iv_str->x,
+ src_str->x, output) == cbc_result);
+ if (cbc_result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, src_str->len,
- dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, src_str->len,
+ dst->len) == 0);
}
exit:
- mbedtls_des_free( &ctx );
+ mbedtls_des_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void des3_encrypt_ecb( int key_count, data_t * key_str,
- data_t * src_str, data_t * dst )
+void des3_encrypt_ecb(int key_count, data_t *key_str,
+ data_t *src_str, data_t *dst)
{
unsigned char output[100];
mbedtls_des3_context ctx;
memset(output, 0x00, 100);
- mbedtls_des3_init( &ctx );
+ mbedtls_des3_init(&ctx);
- if( key_count == 2 )
- TEST_ASSERT( mbedtls_des3_set2key_enc( &ctx, key_str->x ) == 0 );
- else if( key_count == 3 )
- TEST_ASSERT( mbedtls_des3_set3key_enc( &ctx, key_str->x ) == 0 );
- else
- TEST_ASSERT( 0 );
+ if (key_count == 2) {
+ TEST_ASSERT(mbedtls_des3_set2key_enc(&ctx, key_str->x) == 0);
+ } else if (key_count == 3) {
+ TEST_ASSERT(mbedtls_des3_set3key_enc(&ctx, key_str->x) == 0);
+ } else {
+ TEST_ASSERT(0);
+ }
- TEST_ASSERT( mbedtls_des3_crypt_ecb( &ctx, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_des3_crypt_ecb(&ctx, src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 8, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 8, dst->len) == 0);
exit:
- mbedtls_des3_free( &ctx );
+ mbedtls_des3_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void des3_decrypt_ecb( int key_count, data_t * key_str,
- data_t * src_str, data_t * dst )
+void des3_decrypt_ecb(int key_count, data_t *key_str,
+ data_t *src_str, data_t *dst)
{
unsigned char output[100];
mbedtls_des3_context ctx;
memset(output, 0x00, 100);
- mbedtls_des3_init( &ctx );
+ mbedtls_des3_init(&ctx);
- if( key_count == 2 )
- TEST_ASSERT( mbedtls_des3_set2key_dec( &ctx, key_str->x ) == 0 );
- else if( key_count == 3 )
- TEST_ASSERT( mbedtls_des3_set3key_dec( &ctx, key_str->x ) == 0 );
- else
- TEST_ASSERT( 0 );
+ if (key_count == 2) {
+ TEST_ASSERT(mbedtls_des3_set2key_dec(&ctx, key_str->x) == 0);
+ } else if (key_count == 3) {
+ TEST_ASSERT(mbedtls_des3_set3key_dec(&ctx, key_str->x) == 0);
+ } else {
+ TEST_ASSERT(0);
+ }
- TEST_ASSERT( mbedtls_des3_crypt_ecb( &ctx, src_str->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_des3_crypt_ecb(&ctx, src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 8, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 8, dst->len) == 0);
exit:
- mbedtls_des3_free( &ctx );
+ mbedtls_des3_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void des3_encrypt_cbc( int key_count, data_t * key_str,
- data_t * iv_str, data_t * src_str,
- data_t * dst, int cbc_result )
+void des3_encrypt_cbc(int key_count, data_t *key_str,
+ data_t *iv_str, data_t *src_str,
+ data_t *dst, int cbc_result)
{
unsigned char output[100];
mbedtls_des3_context ctx;
memset(output, 0x00, 100);
- mbedtls_des3_init( &ctx );
+ mbedtls_des3_init(&ctx);
- if( key_count == 2 )
- TEST_ASSERT( mbedtls_des3_set2key_enc( &ctx, key_str->x ) == 0 );
- else if( key_count == 3 )
- TEST_ASSERT( mbedtls_des3_set3key_enc( &ctx, key_str->x ) == 0 );
- else
- TEST_ASSERT( 0 );
+ if (key_count == 2) {
+ TEST_ASSERT(mbedtls_des3_set2key_enc(&ctx, key_str->x) == 0);
+ } else if (key_count == 3) {
+ TEST_ASSERT(mbedtls_des3_set3key_enc(&ctx, key_str->x) == 0);
+ } else {
+ TEST_ASSERT(0);
+ }
- TEST_ASSERT( mbedtls_des3_crypt_cbc( &ctx, MBEDTLS_DES_ENCRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
+ TEST_ASSERT(mbedtls_des3_crypt_cbc(&ctx, MBEDTLS_DES_ENCRYPT, src_str->len, iv_str->x,
+ src_str->x, output) == cbc_result);
- if( cbc_result == 0 )
- {
+ if (cbc_result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
- src_str->len, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
+ src_str->len, dst->len) == 0);
}
exit:
- mbedtls_des3_free( &ctx );
+ mbedtls_des3_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void des3_decrypt_cbc( int key_count, data_t * key_str,
- data_t * iv_str, data_t * src_str,
- data_t * dst, int cbc_result )
+void des3_decrypt_cbc(int key_count, data_t *key_str,
+ data_t *iv_str, data_t *src_str,
+ data_t *dst, int cbc_result)
{
unsigned char output[100];
mbedtls_des3_context ctx;
memset(output, 0x00, 100);
- mbedtls_des3_init( &ctx );
+ mbedtls_des3_init(&ctx);
- if( key_count == 2 )
- TEST_ASSERT( mbedtls_des3_set2key_dec( &ctx, key_str->x ) == 0 );
- else if( key_count == 3 )
- TEST_ASSERT( mbedtls_des3_set3key_dec( &ctx, key_str->x ) == 0 );
- else
- TEST_ASSERT( 0 );
+ if (key_count == 2) {
+ TEST_ASSERT(mbedtls_des3_set2key_dec(&ctx, key_str->x) == 0);
+ } else if (key_count == 3) {
+ TEST_ASSERT(mbedtls_des3_set3key_dec(&ctx, key_str->x) == 0);
+ } else {
+ TEST_ASSERT(0);
+ }
- TEST_ASSERT( mbedtls_des3_crypt_cbc( &ctx, MBEDTLS_DES_DECRYPT, src_str->len, iv_str->x, src_str->x, output ) == cbc_result );
+ TEST_ASSERT(mbedtls_des3_crypt_cbc(&ctx, MBEDTLS_DES_DECRYPT, src_str->len, iv_str->x,
+ src_str->x, output) == cbc_result);
- if( cbc_result == 0 )
- {
+ if (cbc_result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, src_str->len,
- dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, src_str->len,
+ dst->len) == 0);
}
exit:
- mbedtls_des3_free( &ctx );
+ mbedtls_des3_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void des_key_parity_run( )
+void des_key_parity_run()
{
int i, j, cnt;
unsigned char key[MBEDTLS_DES_KEY_SIZE];
unsigned int parity;
- memset( key, 0, MBEDTLS_DES_KEY_SIZE );
+ memset(key, 0, MBEDTLS_DES_KEY_SIZE);
cnt = 0;
// Iterate through all possible byte values
//
- for( i = 0; i < 32; i++ )
- {
- for( j = 0; j < 8; j++ )
+ for (i = 0; i < 32; i++) {
+ for (j = 0; j < 8; j++) {
key[j] = cnt++;
+ }
// Set the key parity according to the table
//
- mbedtls_des_key_set_parity( key );
+ mbedtls_des_key_set_parity(key);
// Check the parity with a function
//
- for( j = 0; j < 8; j++ )
- {
- parity = key[j] ^ ( key[j] >> 4 );
+ for (j = 0; j < 8; j++) {
+ parity = key[j] ^ (key[j] >> 4);
parity = parity ^
- ( parity >> 1 ) ^
- ( parity >> 2 ) ^
- ( parity >> 3 );
+ (parity >> 1) ^
+ (parity >> 2) ^
+ (parity >> 3);
parity &= 1;
- if( parity != 1 )
- TEST_ASSERT( 0 );
+ if (parity != 1) {
+ TEST_ASSERT(0);
+ }
}
// Check the parity with the table
//
- TEST_ASSERT( mbedtls_des_key_check_key_parity( key ) == 0 );
+ TEST_ASSERT(mbedtls_des_key_check_key_parity(key) == 0);
}
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void des_selftest( )
+void des_selftest()
{
- TEST_ASSERT( mbedtls_des_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_des_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_dhm.function b/tests/suites/test_suite_dhm.function
index 5d82fe6..1251723 100644
--- a/tests/suites/test_suite_dhm.function
+++ b/tests/suites/test_suite_dhm.function
@@ -4,63 +4,66 @@
/* Sanity checks on a Diffie-Hellman parameter: check the length-value
* syntax and check that the value is the expected one (taken from the
* DHM context by the caller). */
-static int check_dhm_param_output( const mbedtls_mpi *expected,
- const unsigned char *buffer,
- size_t size,
- size_t *offset )
+static int check_dhm_param_output(const mbedtls_mpi *expected,
+ const unsigned char *buffer,
+ size_t size,
+ size_t *offset)
{
size_t n;
mbedtls_mpi actual;
int ok = 0;
- mbedtls_mpi_init( &actual );
+ mbedtls_mpi_init(&actual);
++mbedtls_test_info.step;
- TEST_ASSERT( size >= *offset + 2 );
- n = ( buffer[*offset] << 8 ) | buffer[*offset + 1];
+ TEST_ASSERT(size >= *offset + 2);
+ n = (buffer[*offset] << 8) | buffer[*offset + 1];
*offset += 2;
/* The DHM param output from Mbed TLS has leading zeros stripped, as
* permitted but not required by RFC 5246 \S4.4. */
- TEST_EQUAL( n, mbedtls_mpi_size( expected ) );
- TEST_ASSERT( size >= *offset + n );
- TEST_EQUAL( 0, mbedtls_mpi_read_binary( &actual, buffer + *offset, n ) );
- TEST_EQUAL( 0, mbedtls_mpi_cmp_mpi( expected, &actual ) );
+ TEST_EQUAL(n, mbedtls_mpi_size(expected));
+ TEST_ASSERT(size >= *offset + n);
+ TEST_EQUAL(0, mbedtls_mpi_read_binary(&actual, buffer + *offset, n));
+ TEST_EQUAL(0, mbedtls_mpi_cmp_mpi(expected, &actual));
*offset += n;
ok = 1;
exit:
- mbedtls_mpi_free( &actual );
- return( ok );
+ mbedtls_mpi_free(&actual);
+ return ok;
}
/* Sanity checks on Diffie-Hellman parameters: syntax, range, and comparison
* against the context. */
-static int check_dhm_params( const mbedtls_dhm_context *ctx,
- size_t x_size,
- const unsigned char *ske, size_t ske_len )
+static int check_dhm_params(const mbedtls_dhm_context *ctx,
+ size_t x_size,
+ const unsigned char *ske, size_t ske_len)
{
size_t offset = 0;
/* Check that ctx->X and ctx->GX are within range. */
- TEST_ASSERT( mbedtls_mpi_cmp_int( &ctx->X, 1 ) > 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &ctx->X, &ctx->P ) < 0 );
- TEST_ASSERT( mbedtls_mpi_size( &ctx->X ) <= x_size );
- TEST_ASSERT( mbedtls_mpi_cmp_int( &ctx->GX, 1 ) > 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &ctx->GX, &ctx->P ) < 0 );
+ TEST_ASSERT(mbedtls_mpi_cmp_int(&ctx->X, 1) > 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&ctx->X, &ctx->P) < 0);
+ TEST_ASSERT(mbedtls_mpi_size(&ctx->X) <= x_size);
+ TEST_ASSERT(mbedtls_mpi_cmp_int(&ctx->GX, 1) > 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&ctx->GX, &ctx->P) < 0);
/* Check ske: it must contain P, G and G^X, each prefixed with a
* 2-byte size. */
- if( !check_dhm_param_output( &ctx->P, ske, ske_len, &offset ) )
+ if (!check_dhm_param_output(&ctx->P, ske, ske_len, &offset)) {
goto exit;
- if( !check_dhm_param_output( &ctx->G, ske, ske_len, &offset ) )
+ }
+ if (!check_dhm_param_output(&ctx->G, ske, ske_len, &offset)) {
goto exit;
- if( !check_dhm_param_output( &ctx->GX, ske, ske_len, &offset ) )
+ }
+ if (!check_dhm_param_output(&ctx->GX, ske, ske_len, &offset)) {
goto exit;
- TEST_EQUAL( offset, ske_len );
+ }
+ TEST_EQUAL(offset, ske_len);
- return( 1 );
+ return 1;
exit:
- return( 0 );
+ return 0;
}
/* END_HEADER */
@@ -71,104 +74,104 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void dhm_invalid_params( )
+void dhm_invalid_params()
{
mbedtls_dhm_context ctx;
unsigned char buf[42] = { 0 };
unsigned char *buf_null = NULL;
mbedtls_mpi X;
- size_t const buflen = sizeof( buf );
+ size_t const buflen = sizeof(buf);
size_t len;
- TEST_INVALID_PARAM( mbedtls_dhm_init( NULL ) );
- TEST_VALID_PARAM( mbedtls_dhm_free( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_dhm_init(NULL));
+ TEST_VALID_PARAM(mbedtls_dhm_free(NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_read_params( NULL,
- (unsigned char**) &buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_read_params( &ctx, &buf_null, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_read_params( &ctx, NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_read_params( &ctx,
- (unsigned char**) &buf,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_read_params(NULL,
+ (unsigned char **) &buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_read_params(&ctx, &buf_null, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_read_params(&ctx, NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_read_params(&ctx,
+ (unsigned char **) &buf,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_make_params( NULL, buflen,
- buf, &len,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_make_params( &ctx, buflen,
- NULL, &len,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_make_params( &ctx, buflen,
- buf, NULL,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_make_params( &ctx, buflen,
- buf, &len,
- NULL,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_make_params(NULL, buflen,
+ buf, &len,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_make_params(&ctx, buflen,
+ NULL, &len,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_make_params(&ctx, buflen,
+ buf, NULL,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_make_params(&ctx, buflen,
+ buf, &len,
+ NULL,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_set_group( NULL, &X, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_set_group( &ctx, NULL, &X ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_set_group( &ctx, &X, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_set_group(NULL, &X, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_set_group(&ctx, NULL, &X));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_set_group(&ctx, &X, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_read_public( NULL, buf, buflen ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_read_public( &ctx, NULL, buflen ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_read_public(NULL, buf, buflen));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_read_public(&ctx, NULL, buflen));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_make_public( NULL, buflen,
- buf, buflen,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_make_public( &ctx, buflen,
- NULL, buflen,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_make_public( &ctx, buflen,
- buf, buflen,
- NULL,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_make_public(NULL, buflen,
+ buf, buflen,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_make_public(&ctx, buflen,
+ NULL, buflen,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_make_public(&ctx, buflen,
+ buf, buflen,
+ NULL,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_calc_secret( NULL, buf, buflen, &len,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_calc_secret( &ctx, NULL, buflen, &len,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_calc_secret( &ctx, buf, buflen, NULL,
- mbedtls_test_rnd_std_rand,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_calc_secret(NULL, buf, buflen, &len,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_calc_secret(&ctx, NULL, buflen, &len,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_calc_secret(&ctx, buf, buflen, NULL,
+ mbedtls_test_rnd_std_rand,
+ NULL));
#if defined(MBEDTLS_ASN1_PARSE_C)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_parse_dhm( NULL, buf, buflen ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_parse_dhm( &ctx, NULL, buflen ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_parse_dhm(NULL, buf, buflen));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_parse_dhm(&ctx, NULL, buflen));
#if defined(MBEDTLS_FS_IO)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_parse_dhmfile( NULL, "" ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
- mbedtls_dhm_parse_dhmfile( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_parse_dhmfile(NULL, ""));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_DHM_BAD_INPUT_DATA,
+ mbedtls_dhm_parse_dhmfile(&ctx, NULL));
#endif /* MBEDTLS_FS_IO */
#endif /* MBEDTLS_ASN1_PARSE_C */
@@ -178,8 +181,8 @@
/* END_CASE */
/* BEGIN_CASE */
-void dhm_do_dhm( char *input_P, int x_size,
- char *input_G, int result )
+void dhm_do_dhm(char *input_P, int x_size,
+ char *input_G, int result)
{
mbedtls_dhm_context ctx_srv;
mbedtls_dhm_context ctx_cli;
@@ -195,65 +198,67 @@
int i;
mbedtls_test_rnd_pseudo_info rnd_info;
- mbedtls_dhm_init( &ctx_srv );
- mbedtls_dhm_init( &ctx_cli );
- memset( ske, 0x00, 1000 );
- memset( pub_cli, 0x00, 1000 );
- memset( sec_srv, 0x00, 1000 );
- memset( sec_cli, 0x00, 1000 );
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ mbedtls_dhm_init(&ctx_srv);
+ mbedtls_dhm_init(&ctx_cli);
+ memset(ske, 0x00, 1000);
+ memset(pub_cli, 0x00, 1000);
+ memset(sec_srv, 0x00, 1000);
+ memset(sec_cli, 0x00, 1000);
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
/*
* Set params
*/
- TEST_ASSERT( mbedtls_test_read_mpi( &ctx_srv.P, input_P ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &ctx_srv.G, input_G ) == 0 );
- pub_cli_len = mbedtls_mpi_size( &ctx_srv.P );
+ TEST_ASSERT(mbedtls_test_read_mpi(&ctx_srv.P, input_P) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&ctx_srv.G, input_G) == 0);
+ pub_cli_len = mbedtls_mpi_size(&ctx_srv.P);
/*
* First key exchange
*/
- mbedtls_test_set_step( 10 );
- TEST_ASSERT( mbedtls_dhm_make_params( &ctx_srv, x_size, ske, &ske_len,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == result );
- if ( result != 0 )
+ mbedtls_test_set_step(10);
+ TEST_ASSERT(mbedtls_dhm_make_params(&ctx_srv, x_size, ske, &ske_len,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == result);
+ if (result != 0) {
goto exit;
- if( !check_dhm_params( &ctx_srv, x_size, ske, ske_len ) )
+ }
+ if (!check_dhm_params(&ctx_srv, x_size, ske, ske_len)) {
goto exit;
+ }
ske[ske_len++] = 0;
ske[ske_len++] = 0;
- TEST_ASSERT( mbedtls_dhm_read_params( &ctx_cli, &p, ske + ske_len ) == 0 );
+ TEST_ASSERT(mbedtls_dhm_read_params(&ctx_cli, &p, ske + ske_len) == 0);
- TEST_ASSERT( mbedtls_dhm_make_public( &ctx_cli, x_size, pub_cli, pub_cli_len,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_dhm_read_public( &ctx_srv, pub_cli, pub_cli_len ) == 0 );
+ TEST_ASSERT(mbedtls_dhm_make_public(&ctx_cli, x_size, pub_cli, pub_cli_len,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_dhm_read_public(&ctx_srv, pub_cli, pub_cli_len) == 0);
- TEST_ASSERT( mbedtls_dhm_calc_secret( &ctx_srv, sec_srv, sizeof( sec_srv ),
- &sec_srv_len,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_dhm_calc_secret( &ctx_cli, sec_cli, sizeof( sec_cli ), &sec_cli_len, NULL, NULL ) == 0 );
+ TEST_ASSERT(mbedtls_dhm_calc_secret(&ctx_srv, sec_srv, sizeof(sec_srv),
+ &sec_srv_len,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_dhm_calc_secret(&ctx_cli, sec_cli, sizeof(sec_cli), &sec_cli_len, NULL,
+ NULL) == 0);
- TEST_ASSERT( sec_srv_len == sec_cli_len );
- TEST_ASSERT( sec_srv_len != 0 );
- TEST_ASSERT( memcmp( sec_srv, sec_cli, sec_srv_len ) == 0 );
+ TEST_ASSERT(sec_srv_len == sec_cli_len);
+ TEST_ASSERT(sec_srv_len != 0);
+ TEST_ASSERT(memcmp(sec_srv, sec_cli, sec_srv_len) == 0);
/* Re-do calc_secret on server a few times to test update of blinding values */
- for( i = 0; i < 3; i++ )
- {
- mbedtls_test_set_step( 20 + i );
+ for (i = 0; i < 3; i++) {
+ mbedtls_test_set_step(20 + i);
sec_srv_len = 1000;
- TEST_ASSERT( mbedtls_dhm_calc_secret( &ctx_srv, sec_srv,
- sizeof( sec_srv ), &sec_srv_len,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
+ TEST_ASSERT(mbedtls_dhm_calc_secret(&ctx_srv, sec_srv,
+ sizeof(sec_srv), &sec_srv_len,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
- TEST_ASSERT( sec_srv_len == sec_cli_len );
- TEST_ASSERT( sec_srv_len != 0 );
- TEST_ASSERT( memcmp( sec_srv, sec_cli, sec_srv_len ) == 0 );
+ TEST_ASSERT(sec_srv_len == sec_cli_len);
+ TEST_ASSERT(sec_srv_len != 0);
+ TEST_ASSERT(memcmp(sec_srv, sec_cli, sec_srv_len) == 0);
}
/*
@@ -261,94 +266,96 @@
*/
p = ske;
- mbedtls_test_set_step( 30 );
- TEST_ASSERT( mbedtls_dhm_make_params( &ctx_srv, x_size, ske, &ske_len,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- if( !check_dhm_params( &ctx_srv, x_size, ske, ske_len ) )
+ mbedtls_test_set_step(30);
+ TEST_ASSERT(mbedtls_dhm_make_params(&ctx_srv, x_size, ske, &ske_len,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ if (!check_dhm_params(&ctx_srv, x_size, ske, ske_len)) {
goto exit;
+ }
ske[ske_len++] = 0;
ske[ske_len++] = 0;
- TEST_ASSERT( mbedtls_dhm_read_params( &ctx_cli, &p, ske + ske_len ) == 0 );
+ TEST_ASSERT(mbedtls_dhm_read_params(&ctx_cli, &p, ske + ske_len) == 0);
- TEST_ASSERT( mbedtls_dhm_make_public( &ctx_cli, x_size, pub_cli, pub_cli_len,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_dhm_read_public( &ctx_srv, pub_cli, pub_cli_len ) == 0 );
+ TEST_ASSERT(mbedtls_dhm_make_public(&ctx_cli, x_size, pub_cli, pub_cli_len,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_dhm_read_public(&ctx_srv, pub_cli, pub_cli_len) == 0);
- TEST_ASSERT( mbedtls_dhm_calc_secret( &ctx_srv, sec_srv, sizeof( sec_srv ),
- &sec_srv_len,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_dhm_calc_secret( &ctx_cli, sec_cli, sizeof( sec_cli ), &sec_cli_len, NULL, NULL ) == 0 );
+ TEST_ASSERT(mbedtls_dhm_calc_secret(&ctx_srv, sec_srv, sizeof(sec_srv),
+ &sec_srv_len,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_dhm_calc_secret(&ctx_cli, sec_cli, sizeof(sec_cli), &sec_cli_len, NULL,
+ NULL) == 0);
- TEST_ASSERT( sec_srv_len == sec_cli_len );
- TEST_ASSERT( sec_srv_len != 0 );
- TEST_ASSERT( memcmp( sec_srv, sec_cli, sec_srv_len ) == 0 );
+ TEST_ASSERT(sec_srv_len == sec_cli_len);
+ TEST_ASSERT(sec_srv_len != 0);
+ TEST_ASSERT(memcmp(sec_srv, sec_cli, sec_srv_len) == 0);
exit:
- mbedtls_dhm_free( &ctx_srv );
- mbedtls_dhm_free( &ctx_cli );
+ mbedtls_dhm_free(&ctx_srv);
+ mbedtls_dhm_free(&ctx_cli);
}
/* END_CASE */
/* BEGIN_CASE */
-void dhm_make_public( int P_bytes, char *input_G, int result )
+void dhm_make_public(int P_bytes, char *input_G, int result)
{
mbedtls_mpi P, G;
mbedtls_dhm_context ctx;
unsigned char output[MBEDTLS_MPI_MAX_SIZE];
- mbedtls_mpi_init( &P );
- mbedtls_mpi_init( &G );
- mbedtls_dhm_init( &ctx );
+ mbedtls_mpi_init(&P);
+ mbedtls_mpi_init(&G);
+ mbedtls_dhm_init(&ctx);
- TEST_ASSERT( mbedtls_mpi_lset( &P, 1 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_shift_l( &P, ( P_bytes * 8 ) - 1 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_set_bit( &P, 0, 1 ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_lset(&P, 1) == 0);
+ TEST_ASSERT(mbedtls_mpi_shift_l(&P, (P_bytes * 8) - 1) == 0);
+ TEST_ASSERT(mbedtls_mpi_set_bit(&P, 0, 1) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &G, input_G ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&G, input_G) == 0);
- TEST_ASSERT( mbedtls_dhm_set_group( &ctx, &P, &G ) == 0 );
- TEST_ASSERT( mbedtls_dhm_make_public( &ctx, (int) mbedtls_mpi_size( &P ),
- output, sizeof(output),
- &mbedtls_test_rnd_pseudo_rand,
- NULL ) == result );
+ TEST_ASSERT(mbedtls_dhm_set_group(&ctx, &P, &G) == 0);
+ TEST_ASSERT(mbedtls_dhm_make_public(&ctx, (int) mbedtls_mpi_size(&P),
+ output, sizeof(output),
+ &mbedtls_test_rnd_pseudo_rand,
+ NULL) == result);
exit:
- mbedtls_mpi_free( &P );
- mbedtls_mpi_free( &G );
- mbedtls_dhm_free( &ctx );
+ mbedtls_mpi_free(&P);
+ mbedtls_mpi_free(&G);
+ mbedtls_dhm_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO */
-void dhm_file( char * filename, char * p, char * g, int len )
+void dhm_file(char *filename, char *p, char *g, int len)
{
mbedtls_dhm_context ctx;
mbedtls_mpi P, G;
- mbedtls_dhm_init( &ctx );
- mbedtls_mpi_init( &P ); mbedtls_mpi_init( &G );
+ mbedtls_dhm_init(&ctx);
+ mbedtls_mpi_init(&P); mbedtls_mpi_init(&G);
- TEST_ASSERT( mbedtls_test_read_mpi( &P, p ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &G, g ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&P, p) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&G, g) == 0);
- TEST_ASSERT( mbedtls_dhm_parse_dhmfile( &ctx, filename ) == 0 );
+ TEST_ASSERT(mbedtls_dhm_parse_dhmfile(&ctx, filename) == 0);
- TEST_ASSERT( ctx.len == (size_t) len );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &ctx.P, &P ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &ctx.G, &G ) == 0 );
+ TEST_ASSERT(ctx.len == (size_t) len);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&ctx.P, &P) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&ctx.G, &G) == 0);
exit:
- mbedtls_mpi_free( &P ); mbedtls_mpi_free( &G );
- mbedtls_dhm_free( &ctx );
+ mbedtls_mpi_free(&P); mbedtls_mpi_free(&G);
+ mbedtls_dhm_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void dhm_selftest( )
+void dhm_selftest()
{
- TEST_ASSERT( mbedtls_dhm_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_dhm_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_ecdh.function b/tests/suites/test_suite_ecdh.function
index cd1b368..0de7c08 100644
--- a/tests/suites/test_suite_ecdh.function
+++ b/tests/suites/test_suite_ecdh.function
@@ -1,39 +1,39 @@
/* BEGIN_HEADER */
#include "mbedtls/ecdh.h"
-static int load_public_key( int grp_id, data_t *point,
- mbedtls_ecp_keypair *ecp )
+static int load_public_key(int grp_id, data_t *point,
+ mbedtls_ecp_keypair *ecp)
{
int ok = 0;
- TEST_ASSERT( mbedtls_ecp_group_load( &ecp->grp, grp_id ) == 0 );
- TEST_ASSERT( mbedtls_ecp_point_read_binary( &ecp->grp,
- &ecp->Q,
- point->x,
- point->len ) == 0 );
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &ecp->grp,
- &ecp->Q ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&ecp->grp, grp_id) == 0);
+ TEST_ASSERT(mbedtls_ecp_point_read_binary(&ecp->grp,
+ &ecp->Q,
+ point->x,
+ point->len) == 0);
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&ecp->grp,
+ &ecp->Q) == 0);
ok = 1;
exit:
- return( ok );
+ return ok;
}
-static int load_private_key( int grp_id, data_t *private_key,
- mbedtls_ecp_keypair *ecp,
- mbedtls_test_rnd_pseudo_info *rnd_info )
+static int load_private_key(int grp_id, data_t *private_key,
+ mbedtls_ecp_keypair *ecp,
+ mbedtls_test_rnd_pseudo_info *rnd_info)
{
int ok = 0;
- TEST_ASSERT( mbedtls_ecp_read_key( grp_id, ecp,
- private_key->x,
- private_key->len ) == 0 );
- TEST_ASSERT( mbedtls_ecp_check_privkey( &ecp->grp, &ecp->d ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_read_key(grp_id, ecp,
+ private_key->x,
+ private_key->len) == 0);
+ TEST_ASSERT(mbedtls_ecp_check_privkey(&ecp->grp, &ecp->d) == 0);
/* Calculate the public key from the private key. */
- TEST_ASSERT( mbedtls_ecp_mul( &ecp->grp, &ecp->Q, &ecp->d,
- &ecp->grp.G,
- &mbedtls_test_rnd_pseudo_rand,
- rnd_info ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_mul(&ecp->grp, &ecp->Q, &ecp->d,
+ &ecp->grp.G,
+ &mbedtls_test_rnd_pseudo_rand,
+ rnd_info) == 0);
ok = 1;
exit:
- return( ok );
+ return ok;
}
/* END_HEADER */
@@ -44,14 +44,14 @@
*/
/* BEGIN_CASE */
-void ecdh_valid_param( )
+void ecdh_valid_param()
{
- TEST_VALID_PARAM( mbedtls_ecdh_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_ecdh_free(NULL));
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void ecdh_invalid_param( )
+void ecdh_invalid_param()
{
mbedtls_ecp_group grp;
mbedtls_ecdh_context ctx;
@@ -61,124 +61,124 @@
size_t olen;
unsigned char buf[42] = { 0 };
const unsigned char *buf_null = NULL;
- size_t const buflen = sizeof( buf );
+ size_t const buflen = sizeof(buf);
int invalid_side = 42;
mbedtls_ecp_group_id valid_grp = MBEDTLS_ECP_DP_SECP192R1;
- mbedtls_ecp_keypair_init( &kp );
- mbedtls_ecdh_init( &ctx );
- TEST_INVALID_PARAM( mbedtls_ecdh_init( NULL ) );
+ mbedtls_ecp_keypair_init(&kp);
+ mbedtls_ecdh_init(&ctx);
+ TEST_INVALID_PARAM(mbedtls_ecdh_init(NULL));
#if defined(MBEDTLS_ECP_RESTARTABLE)
- TEST_INVALID_PARAM( mbedtls_ecdh_enable_restart( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_ecdh_enable_restart(NULL));
#endif /* MBEDTLS_ECP_RESTARTABLE */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_gen_public( NULL, &m, &P,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_gen_public( &grp, NULL, &P,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_gen_public( &grp, &m, NULL,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_gen_public( &grp, &m, &P,
- NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_gen_public(NULL, &m, &P,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_gen_public(&grp, NULL, &P,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_gen_public(&grp, &m, NULL,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_gen_public(&grp, &m, &P,
+ NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_compute_shared( NULL, &m, &P, &m,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_compute_shared( &grp, NULL, &P, &m,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_compute_shared( &grp, &m, NULL, &m,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_compute_shared( &grp, &m, &P, NULL,
- mbedtls_test_rnd_std_rand,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_compute_shared(NULL, &m, &P, &m,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_compute_shared(&grp, NULL, &P, &m,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_compute_shared(&grp, &m, NULL, &m,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_compute_shared(&grp, &m, &P, NULL,
+ mbedtls_test_rnd_std_rand,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_setup( NULL, valid_grp ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_setup(NULL, valid_grp));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_make_params( NULL, &olen, buf, buflen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_make_params(NULL, &olen, buf, buflen,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_make_params( &ctx, NULL, buf, buflen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_make_params(&ctx, NULL, buf, buflen,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_make_params( &ctx, &olen, NULL, buflen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_make_params(&ctx, &olen, NULL, buflen,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_make_params( &ctx, &olen, buf, buflen, NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_make_params(&ctx, &olen, buf, buflen, NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_read_params( NULL,
- (const unsigned char**) &buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_read_params( &ctx, &buf_null,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_read_params( &ctx, NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_read_params( &ctx,
- (const unsigned char**) &buf,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_read_params(NULL,
+ (const unsigned char **) &buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_read_params(&ctx, &buf_null,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_read_params(&ctx, NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_read_params(&ctx,
+ (const unsigned char **) &buf,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_get_params( NULL, &kp,
- MBEDTLS_ECDH_OURS ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_get_params( &ctx, NULL,
- MBEDTLS_ECDH_OURS ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_get_params( &ctx, &kp,
- invalid_side ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_get_params(NULL, &kp,
+ MBEDTLS_ECDH_OURS));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_get_params(&ctx, NULL,
+ MBEDTLS_ECDH_OURS));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_get_params(&ctx, &kp,
+ invalid_side));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_make_public( NULL, &olen, buf, buflen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_make_public(NULL, &olen, buf, buflen,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_make_public( &ctx, NULL, buf, buflen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_make_public(&ctx, NULL, buf, buflen,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_make_public( &ctx, &olen, NULL, buflen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_make_public(&ctx, &olen, NULL, buflen,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_make_public( &ctx, &olen, buf, buflen, NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_make_public(&ctx, &olen, buf, buflen, NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_read_public( NULL, buf, buflen ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_read_public( &ctx, NULL, buflen ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_read_public(NULL, buf, buflen));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_read_public(&ctx, NULL, buflen));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_calc_secret( NULL, &olen, buf, buflen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_calc_secret(NULL, &olen, buf, buflen,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_calc_secret( &ctx, NULL, buf, buflen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_calc_secret(&ctx, NULL, buf, buflen,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdh_calc_secret( &ctx, &olen, NULL, buflen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdh_calc_secret(&ctx, &olen, NULL, buflen,
+ mbedtls_test_rnd_std_rand, NULL));
exit:
return;
@@ -186,59 +186,59 @@
/* END_CASE */
/* BEGIN_CASE */
-void ecdh_primitive_random( int id )
+void ecdh_primitive_random(int id)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point qA, qB;
mbedtls_mpi dA, dB, zA, zB;
mbedtls_test_rnd_pseudo_info rnd_info;
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_point_init( &qA ); mbedtls_ecp_point_init( &qB );
- mbedtls_mpi_init( &dA ); mbedtls_mpi_init( &dB );
- mbedtls_mpi_init( &zA ); mbedtls_mpi_init( &zB );
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_point_init(&qA); mbedtls_ecp_point_init(&qB);
+ mbedtls_mpi_init(&dA); mbedtls_mpi_init(&dB);
+ mbedtls_mpi_init(&zA); mbedtls_mpi_init(&zB);
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
- TEST_ASSERT( mbedtls_ecdh_gen_public( &grp, &dA, &qA,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_gen_public( &grp, &dB, &qB,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_compute_shared( &grp, &zA, &qB, &dA,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_compute_shared( &grp, &zB, &qA, &dB,
- NULL, NULL ) == 0 );
+ TEST_ASSERT(mbedtls_ecdh_gen_public(&grp, &dA, &qA,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecdh_gen_public(&grp, &dB, &qB,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecdh_compute_shared(&grp, &zA, &qB, &dA,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecdh_compute_shared(&grp, &zB, &qA, &dB,
+ NULL, NULL) == 0);
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &zA, &zB ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&zA, &zB) == 0);
exit:
- mbedtls_ecp_group_free( &grp );
- mbedtls_ecp_point_free( &qA ); mbedtls_ecp_point_free( &qB );
- mbedtls_mpi_free( &dA ); mbedtls_mpi_free( &dB );
- mbedtls_mpi_free( &zA ); mbedtls_mpi_free( &zB );
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_ecp_point_free(&qA); mbedtls_ecp_point_free(&qB);
+ mbedtls_mpi_free(&dA); mbedtls_mpi_free(&dB);
+ mbedtls_mpi_free(&zA); mbedtls_mpi_free(&zB);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecdh_primitive_testvec( int id, data_t * rnd_buf_A, char * xA_str,
- char * yA_str, data_t * rnd_buf_B,
- char * xB_str, char * yB_str, char * z_str )
+void ecdh_primitive_testvec(int id, data_t *rnd_buf_A, char *xA_str,
+ char *yA_str, data_t *rnd_buf_B,
+ char *xB_str, char *yB_str, char *z_str)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point qA, qB;
mbedtls_mpi dA, dB, zA, zB, check;
mbedtls_test_rnd_buf_info rnd_info_A, rnd_info_B;
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_point_init( &qA ); mbedtls_ecp_point_init( &qB );
- mbedtls_mpi_init( &dA ); mbedtls_mpi_init( &dB );
- mbedtls_mpi_init( &zA ); mbedtls_mpi_init( &zB ); mbedtls_mpi_init( &check );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_point_init(&qA); mbedtls_ecp_point_init(&qB);
+ mbedtls_mpi_init(&dA); mbedtls_mpi_init(&dB);
+ mbedtls_mpi_init(&zA); mbedtls_mpi_init(&zB); mbedtls_mpi_init(&check);
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
rnd_info_A.buf = rnd_buf_A->x;
rnd_info_A.length = rnd_buf_A->len;
@@ -246,14 +246,14 @@
rnd_info_A.fallback_p_rng = NULL;
/* Fix rnd_buf_A->x by shifting it left if necessary */
- if( grp.nbits % 8 != 0 )
- {
- unsigned char shift = 8 - ( grp.nbits % 8 );
+ if (grp.nbits % 8 != 0) {
+ unsigned char shift = 8 - (grp.nbits % 8);
size_t i;
- for( i = 0; i < rnd_info_A.length - 1; i++ )
+ for (i = 0; i < rnd_info_A.length - 1; i++) {
rnd_buf_A->x[i] = rnd_buf_A->x[i] << shift
- | rnd_buf_A->x[i+1] >> ( 8 - shift );
+ | rnd_buf_A->x[i+1] >> (8 - shift);
+ }
rnd_buf_A->x[rnd_info_A.length-1] <<= shift;
}
@@ -264,52 +264,52 @@
rnd_info_B.fallback_p_rng = NULL;
/* Fix rnd_buf_B->x by shifting it left if necessary */
- if( grp.nbits % 8 != 0 )
- {
- unsigned char shift = 8 - ( grp.nbits % 8 );
+ if (grp.nbits % 8 != 0) {
+ unsigned char shift = 8 - (grp.nbits % 8);
size_t i;
- for( i = 0; i < rnd_info_B.length - 1; i++ )
+ for (i = 0; i < rnd_info_B.length - 1; i++) {
rnd_buf_B->x[i] = rnd_buf_B->x[i] << shift
- | rnd_buf_B->x[i+1] >> ( 8 - shift );
+ | rnd_buf_B->x[i+1] >> (8 - shift);
+ }
rnd_buf_B->x[rnd_info_B.length-1] <<= shift;
}
- TEST_ASSERT( mbedtls_ecdh_gen_public( &grp, &dA, &qA,
- mbedtls_test_rnd_buffer_rand,
- &rnd_info_A ) == 0 );
- TEST_ASSERT( ! mbedtls_ecp_is_zero( &qA ) );
- TEST_ASSERT( mbedtls_test_read_mpi( &check, xA_str ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &qA.X, &check ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &check, yA_str ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &qA.Y, &check ) == 0 );
+ TEST_ASSERT(mbedtls_ecdh_gen_public(&grp, &dA, &qA,
+ mbedtls_test_rnd_buffer_rand,
+ &rnd_info_A) == 0);
+ TEST_ASSERT(!mbedtls_ecp_is_zero(&qA));
+ TEST_ASSERT(mbedtls_test_read_mpi(&check, xA_str) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&qA.X, &check) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&check, yA_str) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&qA.Y, &check) == 0);
- TEST_ASSERT( mbedtls_ecdh_gen_public( &grp, &dB, &qB,
- mbedtls_test_rnd_buffer_rand,
- &rnd_info_B ) == 0 );
- TEST_ASSERT( ! mbedtls_ecp_is_zero( &qB ) );
- TEST_ASSERT( mbedtls_test_read_mpi( &check, xB_str ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &qB.X, &check ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &check, yB_str ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &qB.Y, &check ) == 0 );
+ TEST_ASSERT(mbedtls_ecdh_gen_public(&grp, &dB, &qB,
+ mbedtls_test_rnd_buffer_rand,
+ &rnd_info_B) == 0);
+ TEST_ASSERT(!mbedtls_ecp_is_zero(&qB));
+ TEST_ASSERT(mbedtls_test_read_mpi(&check, xB_str) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&qB.X, &check) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&check, yB_str) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&qB.Y, &check) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &check, z_str ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_compute_shared( &grp, &zA, &qB, &dA, NULL, NULL ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &zA, &check ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_compute_shared( &grp, &zB, &qA, &dB, NULL, NULL ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &zB, &check ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&check, z_str) == 0);
+ TEST_ASSERT(mbedtls_ecdh_compute_shared(&grp, &zA, &qB, &dA, NULL, NULL) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&zA, &check) == 0);
+ TEST_ASSERT(mbedtls_ecdh_compute_shared(&grp, &zB, &qA, &dB, NULL, NULL) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&zB, &check) == 0);
exit:
- mbedtls_ecp_group_free( &grp );
- mbedtls_ecp_point_free( &qA ); mbedtls_ecp_point_free( &qB );
- mbedtls_mpi_free( &dA ); mbedtls_mpi_free( &dB );
- mbedtls_mpi_free( &zA ); mbedtls_mpi_free( &zB ); mbedtls_mpi_free( &check );
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_ecp_point_free(&qA); mbedtls_ecp_point_free(&qB);
+ mbedtls_mpi_free(&dA); mbedtls_mpi_free(&dB);
+ mbedtls_mpi_free(&zA); mbedtls_mpi_free(&zB); mbedtls_mpi_free(&check);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecdh_exchange( int id )
+void ecdh_exchange(int id)
{
mbedtls_ecdh_context srv, cli;
unsigned char buf[1000];
@@ -319,41 +319,41 @@
unsigned char res_buf[1000];
size_t res_len;
- mbedtls_ecdh_init( &srv );
- mbedtls_ecdh_init( &cli );
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ mbedtls_ecdh_init(&srv);
+ mbedtls_ecdh_init(&cli);
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
- TEST_ASSERT( mbedtls_ecdh_setup( &srv, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecdh_setup(&srv, id) == 0);
- memset( buf, 0x00, sizeof( buf ) ); vbuf = buf;
- TEST_ASSERT( mbedtls_ecdh_make_params( &srv, &len, buf, 1000,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_read_params( &cli, &vbuf, buf + len ) == 0 );
+ memset(buf, 0x00, sizeof(buf)); vbuf = buf;
+ TEST_ASSERT(mbedtls_ecdh_make_params(&srv, &len, buf, 1000,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecdh_read_params(&cli, &vbuf, buf + len) == 0);
- memset( buf, 0x00, sizeof( buf ) );
- TEST_ASSERT( mbedtls_ecdh_make_public( &cli, &len, buf, 1000,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_read_public( &srv, buf, len ) == 0 );
+ memset(buf, 0x00, sizeof(buf));
+ TEST_ASSERT(mbedtls_ecdh_make_public(&cli, &len, buf, 1000,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecdh_read_public(&srv, buf, len) == 0);
- TEST_ASSERT( mbedtls_ecdh_calc_secret( &srv, &len, buf, 1000,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_calc_secret( &cli, &res_len, res_buf, 1000,
- NULL, NULL ) == 0 );
- TEST_ASSERT( len == res_len );
- TEST_ASSERT( memcmp( buf, res_buf, len ) == 0 );
+ TEST_ASSERT(mbedtls_ecdh_calc_secret(&srv, &len, buf, 1000,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecdh_calc_secret(&cli, &res_len, res_buf, 1000,
+ NULL, NULL) == 0);
+ TEST_ASSERT(len == res_len);
+ TEST_ASSERT(memcmp(buf, res_buf, len) == 0);
exit:
- mbedtls_ecdh_free( &srv );
- mbedtls_ecdh_free( &cli );
+ mbedtls_ecdh_free(&srv);
+ mbedtls_ecdh_free(&cli);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECP_RESTARTABLE */
-void ecdh_restart( int id, data_t *dA, data_t *dB, data_t *z,
- int enable, int max_ops, int min_restart, int max_restart )
+void ecdh_restart(int id, data_t *dA, data_t *dB, data_t *z,
+ int enable, int max_ops, int min_restart, int max_restart)
{
int ret;
mbedtls_ecdh_context srv, cli;
@@ -364,9 +364,9 @@
int cnt_restart;
mbedtls_ecp_group grp;
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecdh_init( &srv );
- mbedtls_ecdh_init( &cli );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecdh_init(&srv);
+ mbedtls_ecdh_init(&cli);
rnd_info_A.fallback_f_rng = mbedtls_test_rnd_std_rand;
rnd_info_A.fallback_p_rng = NULL;
@@ -380,103 +380,102 @@
/* The ECDH context is not guaranteed to have an mbedtls_ecp_group structure
* in every configuration, therefore we load it separately. */
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
/* Otherwise we would have to fix the random buffer,
* as in ecdh_primitive_testvec. */
- TEST_ASSERT( grp.nbits % 8 == 0 );
+ TEST_ASSERT(grp.nbits % 8 == 0);
- TEST_ASSERT( mbedtls_ecdh_setup( &srv, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecdh_setup(&srv, id) == 0);
/* set up restart parameters */
- mbedtls_ecp_set_max_ops( max_ops );
+ mbedtls_ecp_set_max_ops(max_ops);
- if( enable )
- {
- mbedtls_ecdh_enable_restart( &srv );
- mbedtls_ecdh_enable_restart( &cli );
+ if (enable) {
+ mbedtls_ecdh_enable_restart(&srv);
+ mbedtls_ecdh_enable_restart(&cli);
}
/* server writes its parameters */
- memset( buf, 0x00, sizeof( buf ) );
+ memset(buf, 0x00, sizeof(buf));
len = 0;
cnt_restart = 0;
do {
- ret = mbedtls_ecdh_make_params( &srv, &len, buf, sizeof( buf ),
- mbedtls_test_rnd_buffer_rand,
- &rnd_info_A );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
+ ret = mbedtls_ecdh_make_params(&srv, &len, buf, sizeof(buf),
+ mbedtls_test_rnd_buffer_rand,
+ &rnd_info_A);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart);
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( cnt_restart >= min_restart );
- TEST_ASSERT( cnt_restart <= max_restart );
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(cnt_restart >= min_restart);
+ TEST_ASSERT(cnt_restart <= max_restart);
/* client read server params */
vbuf = buf;
- TEST_ASSERT( mbedtls_ecdh_read_params( &cli, &vbuf, buf + len ) == 0 );
+ TEST_ASSERT(mbedtls_ecdh_read_params(&cli, &vbuf, buf + len) == 0);
/* client writes its key share */
- memset( buf, 0x00, sizeof( buf ) );
+ memset(buf, 0x00, sizeof(buf));
len = 0;
cnt_restart = 0;
do {
- ret = mbedtls_ecdh_make_public( &cli, &len, buf, sizeof( buf ),
- mbedtls_test_rnd_buffer_rand,
- &rnd_info_B );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
+ ret = mbedtls_ecdh_make_public(&cli, &len, buf, sizeof(buf),
+ mbedtls_test_rnd_buffer_rand,
+ &rnd_info_B);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart);
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( cnt_restart >= min_restart );
- TEST_ASSERT( cnt_restart <= max_restart );
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(cnt_restart >= min_restart);
+ TEST_ASSERT(cnt_restart <= max_restart);
/* server reads client key share */
- TEST_ASSERT( mbedtls_ecdh_read_public( &srv, buf, len ) == 0 );
+ TEST_ASSERT(mbedtls_ecdh_read_public(&srv, buf, len) == 0);
/* server computes shared secret */
- memset( buf, 0, sizeof( buf ) );
+ memset(buf, 0, sizeof(buf));
len = 0;
cnt_restart = 0;
do {
- ret = mbedtls_ecdh_calc_secret( &srv, &len, buf, sizeof( buf ),
- NULL, NULL );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
+ ret = mbedtls_ecdh_calc_secret(&srv, &len, buf, sizeof(buf),
+ NULL, NULL);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart);
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( cnt_restart >= min_restart );
- TEST_ASSERT( cnt_restart <= max_restart );
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(cnt_restart >= min_restart);
+ TEST_ASSERT(cnt_restart <= max_restart);
- TEST_ASSERT( len == z->len );
- TEST_ASSERT( memcmp( buf, z->x, len ) == 0 );
+ TEST_ASSERT(len == z->len);
+ TEST_ASSERT(memcmp(buf, z->x, len) == 0);
/* client computes shared secret */
- memset( buf, 0, sizeof( buf ) );
+ memset(buf, 0, sizeof(buf));
len = 0;
cnt_restart = 0;
do {
- ret = mbedtls_ecdh_calc_secret( &cli, &len, buf, sizeof( buf ),
- NULL, NULL );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
+ ret = mbedtls_ecdh_calc_secret(&cli, &len, buf, sizeof(buf),
+ NULL, NULL);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart);
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( cnt_restart >= min_restart );
- TEST_ASSERT( cnt_restart <= max_restart );
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(cnt_restart >= min_restart);
+ TEST_ASSERT(cnt_restart <= max_restart);
- TEST_ASSERT( len == z->len );
- TEST_ASSERT( memcmp( buf, z->x, len ) == 0 );
+ TEST_ASSERT(len == z->len);
+ TEST_ASSERT(memcmp(buf, z->x, len) == 0);
exit:
- mbedtls_ecp_group_free( &grp );
- mbedtls_ecdh_free( &srv );
- mbedtls_ecdh_free( &cli );
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_ecdh_free(&srv);
+ mbedtls_ecdh_free(&cli);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECDH_LEGACY_CONTEXT */
-void ecdh_exchange_legacy( int id )
+void ecdh_exchange_legacy(int id)
{
mbedtls_ecdh_context srv, cli;
unsigned char buf[1000];
@@ -485,43 +484,43 @@
mbedtls_test_rnd_pseudo_info rnd_info;
- mbedtls_ecdh_init( &srv );
- mbedtls_ecdh_init( &cli );
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ mbedtls_ecdh_init(&srv);
+ mbedtls_ecdh_init(&cli);
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
- TEST_ASSERT( mbedtls_ecp_group_load( &srv.grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&srv.grp, id) == 0);
- memset( buf, 0x00, sizeof( buf ) ); vbuf = buf;
- TEST_ASSERT( mbedtls_ecdh_make_params( &srv, &len, buf, 1000,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_read_params( &cli, &vbuf, buf + len ) == 0 );
+ memset(buf, 0x00, sizeof(buf)); vbuf = buf;
+ TEST_ASSERT(mbedtls_ecdh_make_params(&srv, &len, buf, 1000,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecdh_read_params(&cli, &vbuf, buf + len) == 0);
- memset( buf, 0x00, sizeof( buf ) );
- TEST_ASSERT( mbedtls_ecdh_make_public( &cli, &len, buf, 1000,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_read_public( &srv, buf, len ) == 0 );
+ memset(buf, 0x00, sizeof(buf));
+ TEST_ASSERT(mbedtls_ecdh_make_public(&cli, &len, buf, 1000,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecdh_read_public(&srv, buf, len) == 0);
- TEST_ASSERT( mbedtls_ecdh_calc_secret( &srv, &len, buf, 1000,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_calc_secret( &cli, &len, buf, 1000, NULL,
- NULL ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &srv.z, &cli.z ) == 0 );
+ TEST_ASSERT(mbedtls_ecdh_calc_secret(&srv, &len, buf, 1000,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecdh_calc_secret(&cli, &len, buf, 1000, NULL,
+ NULL) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&srv.z, &cli.z) == 0);
exit:
- mbedtls_ecdh_free( &srv );
- mbedtls_ecdh_free( &cli );
+ mbedtls_ecdh_free(&srv);
+ mbedtls_ecdh_free(&cli);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecdh_exchange_calc_secret( int grp_id,
- data_t *our_private_key,
- data_t *their_point,
- int ours_first,
- data_t *expected )
+void ecdh_exchange_calc_secret(int grp_id,
+ data_t *our_private_key,
+ data_t *their_point,
+ int ours_first,
+ data_t *expected)
{
mbedtls_test_rnd_pseudo_info rnd_info;
mbedtls_ecp_keypair our_key;
@@ -530,92 +529,90 @@
unsigned char shared_secret[MBEDTLS_ECP_MAX_BYTES];
size_t shared_secret_length = 0;
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
- mbedtls_ecdh_init( &ecdh );
- mbedtls_ecp_keypair_init( &our_key );
- mbedtls_ecp_keypair_init( &their_key );
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
+ mbedtls_ecdh_init(&ecdh);
+ mbedtls_ecp_keypair_init(&our_key);
+ mbedtls_ecp_keypair_init(&their_key);
- if( ! load_private_key( grp_id, our_private_key, &our_key, &rnd_info ) )
+ if (!load_private_key(grp_id, our_private_key, &our_key, &rnd_info)) {
goto exit;
- if( ! load_public_key( grp_id, their_point, &their_key ) )
+ }
+ if (!load_public_key(grp_id, their_point, &their_key)) {
goto exit;
+ }
/* Import the keys to the ECDH calculation. */
- if( ours_first )
- {
- TEST_ASSERT( mbedtls_ecdh_get_params(
- &ecdh, &our_key, MBEDTLS_ECDH_OURS ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_get_params(
- &ecdh, &their_key, MBEDTLS_ECDH_THEIRS ) == 0 );
- }
- else
- {
- TEST_ASSERT( mbedtls_ecdh_get_params(
- &ecdh, &their_key, MBEDTLS_ECDH_THEIRS ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_get_params(
- &ecdh, &our_key, MBEDTLS_ECDH_OURS ) == 0 );
+ if (ours_first) {
+ TEST_ASSERT(mbedtls_ecdh_get_params(
+ &ecdh, &our_key, MBEDTLS_ECDH_OURS) == 0);
+ TEST_ASSERT(mbedtls_ecdh_get_params(
+ &ecdh, &their_key, MBEDTLS_ECDH_THEIRS) == 0);
+ } else {
+ TEST_ASSERT(mbedtls_ecdh_get_params(
+ &ecdh, &their_key, MBEDTLS_ECDH_THEIRS) == 0);
+ TEST_ASSERT(mbedtls_ecdh_get_params(
+ &ecdh, &our_key, MBEDTLS_ECDH_OURS) == 0);
}
/* Perform the ECDH calculation. */
- TEST_ASSERT( mbedtls_ecdh_calc_secret(
- &ecdh,
- &shared_secret_length,
- shared_secret, sizeof( shared_secret ),
- &mbedtls_test_rnd_pseudo_rand, &rnd_info ) == 0 );
- TEST_ASSERT( shared_secret_length == expected->len );
- TEST_ASSERT( memcmp( expected->x, shared_secret,
- shared_secret_length ) == 0 );
+ TEST_ASSERT(mbedtls_ecdh_calc_secret(
+ &ecdh,
+ &shared_secret_length,
+ shared_secret, sizeof(shared_secret),
+ &mbedtls_test_rnd_pseudo_rand, &rnd_info) == 0);
+ TEST_ASSERT(shared_secret_length == expected->len);
+ TEST_ASSERT(memcmp(expected->x, shared_secret,
+ shared_secret_length) == 0);
exit:
- mbedtls_ecdh_free( &ecdh );
- mbedtls_ecp_keypair_free( &our_key );
- mbedtls_ecp_keypair_free( &their_key );
+ mbedtls_ecdh_free(&ecdh);
+ mbedtls_ecp_keypair_free(&our_key);
+ mbedtls_ecp_keypair_free(&their_key);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecdh_exchange_get_params_fail( int our_grp_id,
- data_t *our_private_key,
- int their_grp_id,
- data_t *their_point,
- int ours_first,
- int expected_ret )
+void ecdh_exchange_get_params_fail(int our_grp_id,
+ data_t *our_private_key,
+ int their_grp_id,
+ data_t *their_point,
+ int ours_first,
+ int expected_ret)
{
mbedtls_test_rnd_pseudo_info rnd_info;
mbedtls_ecp_keypair our_key;
mbedtls_ecp_keypair their_key;
mbedtls_ecdh_context ecdh;
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
- mbedtls_ecdh_init( &ecdh );
- mbedtls_ecp_keypair_init( &our_key );
- mbedtls_ecp_keypair_init( &their_key );
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
+ mbedtls_ecdh_init(&ecdh);
+ mbedtls_ecp_keypair_init(&our_key);
+ mbedtls_ecp_keypair_init(&their_key);
- if( ! load_private_key( our_grp_id, our_private_key, &our_key, &rnd_info ) )
+ if (!load_private_key(our_grp_id, our_private_key, &our_key, &rnd_info)) {
goto exit;
- if( ! load_public_key( their_grp_id, their_point, &their_key ) )
- goto exit;
-
- if( ours_first )
- {
- TEST_ASSERT( mbedtls_ecdh_get_params(
- &ecdh, &our_key, MBEDTLS_ECDH_OURS ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_get_params(
- &ecdh, &their_key, MBEDTLS_ECDH_THEIRS ) ==
- expected_ret );
}
- else
- {
- TEST_ASSERT( mbedtls_ecdh_get_params(
- &ecdh, &their_key, MBEDTLS_ECDH_THEIRS ) == 0 );
- TEST_ASSERT( mbedtls_ecdh_get_params(
- &ecdh, &our_key, MBEDTLS_ECDH_OURS ) ==
- expected_ret );
+ if (!load_public_key(their_grp_id, their_point, &their_key)) {
+ goto exit;
+ }
+
+ if (ours_first) {
+ TEST_ASSERT(mbedtls_ecdh_get_params(
+ &ecdh, &our_key, MBEDTLS_ECDH_OURS) == 0);
+ TEST_ASSERT(mbedtls_ecdh_get_params(
+ &ecdh, &their_key, MBEDTLS_ECDH_THEIRS) ==
+ expected_ret);
+ } else {
+ TEST_ASSERT(mbedtls_ecdh_get_params(
+ &ecdh, &their_key, MBEDTLS_ECDH_THEIRS) == 0);
+ TEST_ASSERT(mbedtls_ecdh_get_params(
+ &ecdh, &our_key, MBEDTLS_ECDH_OURS) ==
+ expected_ret);
}
exit:
- mbedtls_ecdh_free( &ecdh );
- mbedtls_ecp_keypair_free( &our_key );
- mbedtls_ecp_keypair_free( &their_key );
+ mbedtls_ecdh_free(&ecdh);
+ mbedtls_ecp_keypair_free(&our_key);
+ mbedtls_ecp_keypair_free(&their_key);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_ecdsa.function b/tests/suites/test_suite_ecdsa.function
index 1ca7c39..470495d 100644
--- a/tests/suites/test_suite_ecdsa.function
+++ b/tests/suites/test_suite_ecdsa.function
@@ -8,7 +8,7 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void ecdsa_invalid_param( )
+void ecdsa_invalid_param()
{
mbedtls_ecdsa_context ctx;
mbedtls_ecp_keypair key;
@@ -20,204 +20,204 @@
size_t slen;
unsigned char buf[42] = { 0 };
- mbedtls_ecdsa_init( &ctx );
- mbedtls_ecp_keypair_init( &key );
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_point_init( &P );
- mbedtls_mpi_init( &m );
+ mbedtls_ecdsa_init(&ctx);
+ mbedtls_ecp_keypair_init(&key);
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_point_init(&P);
+ mbedtls_mpi_init(&m);
- TEST_INVALID_PARAM( mbedtls_ecdsa_init( NULL ) );
- TEST_VALID_PARAM( mbedtls_ecdsa_free( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_ecdsa_init(NULL));
+ TEST_VALID_PARAM(mbedtls_ecdsa_free(NULL));
#if defined(MBEDTLS_ECP_RESTARTABLE)
- TEST_INVALID_PARAM( mbedtls_ecdsa_restart_init( NULL ) );
- TEST_VALID_PARAM( mbedtls_ecdsa_restart_free( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_ecdsa_restart_init(NULL));
+ TEST_VALID_PARAM(mbedtls_ecdsa_restart_free(NULL));
#endif /* MBEDTLS_ECP_RESTARTABLE */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_sign( NULL, &m, &m, &m,
- buf, sizeof( buf ),
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_sign( &grp, NULL, &m, &m,
- buf, sizeof( buf ),
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_sign( &grp, &m, NULL, &m,
- buf, sizeof( buf ),
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_sign( &grp, &m, &m, NULL,
- buf, sizeof( buf ),
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_sign( &grp, &m, &m, &m,
- NULL, sizeof( buf ),
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_sign( &grp, &m, &m, &m,
- buf, sizeof( buf ),
- NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_sign(NULL, &m, &m, &m,
+ buf, sizeof(buf),
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_sign(&grp, NULL, &m, &m,
+ buf, sizeof(buf),
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_sign(&grp, &m, NULL, &m,
+ buf, sizeof(buf),
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_sign(&grp, &m, &m, NULL,
+ buf, sizeof(buf),
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_sign(&grp, &m, &m, &m,
+ NULL, sizeof(buf),
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_sign(&grp, &m, &m, &m,
+ buf, sizeof(buf),
+ NULL, NULL));
#if defined(MBEDTLS_ECDSA_DETERMINISTIC)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_sign_det_ext( NULL, &m, &m, &m,
- buf, sizeof( buf ),
- valid_md,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_sign_det_ext( &grp, NULL, &m, &m,
- buf, sizeof( buf ),
- valid_md,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_sign_det_ext( &grp, &m, NULL, &m,
- buf, sizeof( buf ),
- valid_md,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_sign_det_ext( &grp, &m, &m, NULL,
- buf, sizeof( buf ),
- valid_md,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_sign_det_ext( &grp, &m, &m, &m,
- NULL, sizeof( buf ),
- valid_md,
- mbedtls_test_rnd_std_rand,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_sign_det_ext(NULL, &m, &m, &m,
+ buf, sizeof(buf),
+ valid_md,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_sign_det_ext(&grp, NULL, &m, &m,
+ buf, sizeof(buf),
+ valid_md,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_sign_det_ext(&grp, &m, NULL, &m,
+ buf, sizeof(buf),
+ valid_md,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_sign_det_ext(&grp, &m, &m, NULL,
+ buf, sizeof(buf),
+ valid_md,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_sign_det_ext(&grp, &m, &m, &m,
+ NULL, sizeof(buf),
+ valid_md,
+ mbedtls_test_rnd_std_rand,
+ NULL));
#endif /* MBEDTLS_ECDSA_DETERMINISTIC */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_verify( NULL,
- buf, sizeof( buf ),
- &P, &m, &m ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_verify( &grp,
- NULL, sizeof( buf ),
- &P, &m, &m ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_verify( &grp,
- buf, sizeof( buf ),
- NULL, &m, &m ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_verify( &grp,
- buf, sizeof( buf ),
- &P, NULL, &m ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_verify( &grp,
- buf, sizeof( buf ),
- &P, &m, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_verify(NULL,
+ buf, sizeof(buf),
+ &P, &m, &m));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_verify(&grp,
+ NULL, sizeof(buf),
+ &P, &m, &m));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_verify(&grp,
+ buf, sizeof(buf),
+ NULL, &m, &m));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_verify(&grp,
+ buf, sizeof(buf),
+ &P, NULL, &m));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_verify(&grp,
+ buf, sizeof(buf),
+ &P, &m, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_write_signature( NULL, valid_md, buf, sizeof( buf ),
- buf, &slen, mbedtls_test_rnd_std_rand,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_write_signature(NULL, valid_md, buf, sizeof(buf),
+ buf, &slen, mbedtls_test_rnd_std_rand,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_write_signature( &ctx, valid_md, NULL, sizeof( buf ),
- buf, &slen, mbedtls_test_rnd_std_rand,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_write_signature(&ctx, valid_md, NULL, sizeof(buf),
+ buf, &slen, mbedtls_test_rnd_std_rand,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_write_signature( &ctx, valid_md, buf, sizeof( buf ),
- NULL, &slen, mbedtls_test_rnd_std_rand,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_write_signature(&ctx, valid_md, buf, sizeof(buf),
+ NULL, &slen, mbedtls_test_rnd_std_rand,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_write_signature( &ctx, valid_md, buf, sizeof( buf ),
- buf, NULL, mbedtls_test_rnd_std_rand,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_write_signature(&ctx, valid_md, buf, sizeof(buf),
+ buf, NULL, mbedtls_test_rnd_std_rand,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_write_signature_restartable( NULL, valid_md, buf,
- sizeof( buf ), buf, &slen,
- mbedtls_test_rnd_std_rand,
- NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_write_signature_restartable(NULL, valid_md, buf,
+ sizeof(buf), buf, &slen,
+ mbedtls_test_rnd_std_rand,
+ NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_write_signature_restartable( &ctx, valid_md, NULL,
- sizeof( buf ), buf, &slen,
- mbedtls_test_rnd_std_rand,
- NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_write_signature_restartable(&ctx, valid_md, NULL,
+ sizeof(buf), buf, &slen,
+ mbedtls_test_rnd_std_rand,
+ NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_write_signature_restartable( &ctx, valid_md, buf,
- sizeof( buf ), NULL, &slen,
- mbedtls_test_rnd_std_rand,
- NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_write_signature_restartable(&ctx, valid_md, buf,
+ sizeof(buf), NULL, &slen,
+ mbedtls_test_rnd_std_rand,
+ NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_write_signature_restartable( &ctx, valid_md, buf,
- sizeof( buf ), buf, NULL,
- mbedtls_test_rnd_std_rand,
- NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_write_signature_restartable(&ctx, valid_md, buf,
+ sizeof(buf), buf, NULL,
+ mbedtls_test_rnd_std_rand,
+ NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_read_signature( NULL,
- buf, sizeof( buf ),
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_read_signature( &ctx,
- NULL, sizeof( buf ),
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_read_signature( &ctx,
- buf, sizeof( buf ),
- NULL, sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_read_signature(NULL,
+ buf, sizeof(buf),
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_read_signature(&ctx,
+ NULL, sizeof(buf),
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_read_signature(&ctx,
+ buf, sizeof(buf),
+ NULL, sizeof(buf)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_read_signature_restartable( NULL,
- buf, sizeof( buf ),
- buf, sizeof( buf ),
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_read_signature_restartable( &ctx,
- NULL, sizeof( buf ),
- buf, sizeof( buf ),
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_read_signature_restartable( &ctx,
- buf, sizeof( buf ),
- NULL, sizeof( buf ),
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_read_signature_restartable(NULL,
+ buf, sizeof(buf),
+ buf, sizeof(buf),
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_read_signature_restartable(&ctx,
+ NULL, sizeof(buf),
+ buf, sizeof(buf),
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_read_signature_restartable(&ctx,
+ buf, sizeof(buf),
+ NULL, sizeof(buf),
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_genkey( NULL, valid_group,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_genkey( &ctx, valid_group,
- NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_genkey(NULL, valid_group,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_genkey(&ctx, valid_group,
+ NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_from_keypair( NULL, &key ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecdsa_from_keypair( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_from_keypair(NULL, &key));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecdsa_from_keypair(&ctx, NULL));
exit:
- mbedtls_ecdsa_free( &ctx );
- mbedtls_ecp_keypair_free( &key );
- mbedtls_ecp_group_free( &grp );
- mbedtls_ecp_point_free( &P );
- mbedtls_mpi_free( &m );
+ mbedtls_ecdsa_free(&ctx);
+ mbedtls_ecp_keypair_free(&key);
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_ecp_point_free(&P);
+ mbedtls_mpi_free(&m);
return;
}
/* END_CASE */
/* BEGIN_CASE */
-void ecdsa_prim_zero( int id )
+void ecdsa_prim_zero(int id)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point Q;
@@ -225,31 +225,31 @@
mbedtls_test_rnd_pseudo_info rnd_info;
unsigned char buf[MBEDTLS_MD_MAX_SIZE];
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_point_init( &Q );
- mbedtls_mpi_init( &d ); mbedtls_mpi_init( &r ); mbedtls_mpi_init( &s );
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
- memset( buf, 0, sizeof( buf ) );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_point_init(&Q);
+ mbedtls_mpi_init(&d); mbedtls_mpi_init(&r); mbedtls_mpi_init(&s);
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
+ memset(buf, 0, sizeof(buf));
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
- TEST_ASSERT( mbedtls_ecp_gen_keypair( &grp, &d, &Q,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
+ TEST_ASSERT(mbedtls_ecp_gen_keypair(&grp, &d, &Q,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
- TEST_ASSERT( mbedtls_ecdsa_sign( &grp, &r, &s, &d, buf, sizeof( buf ),
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecdsa_verify( &grp, buf, sizeof( buf ), &Q, &r, &s ) == 0 );
+ TEST_ASSERT(mbedtls_ecdsa_sign(&grp, &r, &s, &d, buf, sizeof(buf),
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecdsa_verify(&grp, buf, sizeof(buf), &Q, &r, &s) == 0);
exit:
- mbedtls_ecp_group_free( &grp );
- mbedtls_ecp_point_free( &Q );
- mbedtls_mpi_free( &d ); mbedtls_mpi_free( &r ); mbedtls_mpi_free( &s );
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_ecp_point_free(&Q);
+ mbedtls_mpi_free(&d); mbedtls_mpi_free(&r); mbedtls_mpi_free(&s);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecdsa_prim_random( int id )
+void ecdsa_prim_random(int id)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point Q;
@@ -257,152 +257,151 @@
mbedtls_test_rnd_pseudo_info rnd_info;
unsigned char buf[MBEDTLS_MD_MAX_SIZE];
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_point_init( &Q );
- mbedtls_mpi_init( &d ); mbedtls_mpi_init( &r ); mbedtls_mpi_init( &s );
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
- memset( buf, 0, sizeof( buf ) );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_point_init(&Q);
+ mbedtls_mpi_init(&d); mbedtls_mpi_init(&r); mbedtls_mpi_init(&s);
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
+ memset(buf, 0, sizeof(buf));
/* prepare material for signature */
- TEST_ASSERT( mbedtls_test_rnd_pseudo_rand( &rnd_info,
- buf, sizeof( buf ) ) == 0 );
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
- TEST_ASSERT( mbedtls_ecp_gen_keypair( &grp, &d, &Q,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
+ TEST_ASSERT(mbedtls_test_rnd_pseudo_rand(&rnd_info,
+ buf, sizeof(buf)) == 0);
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
+ TEST_ASSERT(mbedtls_ecp_gen_keypair(&grp, &d, &Q,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
- TEST_ASSERT( mbedtls_ecdsa_sign( &grp, &r, &s, &d, buf, sizeof( buf ),
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecdsa_verify( &grp, buf, sizeof( buf ), &Q, &r, &s ) == 0 );
+ TEST_ASSERT(mbedtls_ecdsa_sign(&grp, &r, &s, &d, buf, sizeof(buf),
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecdsa_verify(&grp, buf, sizeof(buf), &Q, &r, &s) == 0);
exit:
- mbedtls_ecp_group_free( &grp );
- mbedtls_ecp_point_free( &Q );
- mbedtls_mpi_free( &d ); mbedtls_mpi_free( &r ); mbedtls_mpi_free( &s );
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_ecp_point_free(&Q);
+ mbedtls_mpi_free(&d); mbedtls_mpi_free(&r); mbedtls_mpi_free(&s);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecdsa_prim_test_vectors( int id, char * d_str, char * xQ_str,
- char * yQ_str, data_t * rnd_buf,
- data_t * hash, char * r_str, char * s_str,
- int result )
+void ecdsa_prim_test_vectors(int id, char *d_str, char *xQ_str,
+ char *yQ_str, data_t *rnd_buf,
+ data_t *hash, char *r_str, char *s_str,
+ int result)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point Q;
mbedtls_mpi d, r, s, r_check, s_check, zero;
mbedtls_test_rnd_buf_info rnd_info;
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_point_init( &Q );
- mbedtls_mpi_init( &d ); mbedtls_mpi_init( &r ); mbedtls_mpi_init( &s );
- mbedtls_mpi_init( &r_check ); mbedtls_mpi_init( &s_check );
- mbedtls_mpi_init( &zero );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_point_init(&Q);
+ mbedtls_mpi_init(&d); mbedtls_mpi_init(&r); mbedtls_mpi_init(&s);
+ mbedtls_mpi_init(&r_check); mbedtls_mpi_init(&s_check);
+ mbedtls_mpi_init(&zero);
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
- TEST_ASSERT( mbedtls_ecp_point_read_string( &Q, 16, xQ_str, yQ_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &d, d_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &r_check, r_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &s_check, s_str ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
+ TEST_ASSERT(mbedtls_ecp_point_read_string(&Q, 16, xQ_str, yQ_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&d, d_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&r_check, r_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&s_check, s_str) == 0);
rnd_info.fallback_f_rng = mbedtls_test_rnd_std_rand;
rnd_info.fallback_p_rng = NULL;
rnd_info.buf = rnd_buf->x;
rnd_info.length = rnd_buf->len;
/* Fix rnd_buf->x by shifting it left if necessary */
- if( grp.nbits % 8 != 0 )
- {
- unsigned char shift = 8 - ( grp.nbits % 8 );
+ if (grp.nbits % 8 != 0) {
+ unsigned char shift = 8 - (grp.nbits % 8);
size_t i;
- for( i = 0; i < rnd_info.length - 1; i++ )
- rnd_buf->x[i] = rnd_buf->x[i] << shift | rnd_buf->x[i+1] >> ( 8 - shift );
+ for (i = 0; i < rnd_info.length - 1; i++) {
+ rnd_buf->x[i] = rnd_buf->x[i] << shift | rnd_buf->x[i+1] >> (8 - shift);
+ }
rnd_buf->x[rnd_info.length-1] <<= shift;
}
- TEST_ASSERT( mbedtls_ecdsa_sign( &grp, &r, &s, &d, hash->x, hash->len,
- mbedtls_test_rnd_buffer_rand, &rnd_info ) == result );
+ TEST_ASSERT(mbedtls_ecdsa_sign(&grp, &r, &s, &d, hash->x, hash->len,
+ mbedtls_test_rnd_buffer_rand, &rnd_info) == result);
- if ( result == 0)
- {
+ if (result == 0) {
/* Check we generated the expected values */
- TEST_EQUAL( mbedtls_mpi_cmp_mpi( &r, &r_check ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_mpi( &s, &s_check ), 0 );
+ TEST_EQUAL(mbedtls_mpi_cmp_mpi(&r, &r_check), 0);
+ TEST_EQUAL(mbedtls_mpi_cmp_mpi(&s, &s_check), 0);
/* Valid signature */
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len,
- &Q, &r_check, &s_check ), 0 );
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len,
+ &Q, &r_check, &s_check), 0);
/* Invalid signature: wrong public key (G instead of Q) */
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len,
- &grp.G, &r_check, &s_check ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len,
+ &grp.G, &r_check, &s_check), MBEDTLS_ERR_ECP_VERIFY_FAILED);
/* Invalid signatures: r or s or both one off */
- TEST_EQUAL( mbedtls_mpi_sub_int( &r, &r_check, 1 ), 0 );
- TEST_EQUAL( mbedtls_mpi_add_int( &s, &s_check, 1 ), 0 );
+ TEST_EQUAL(mbedtls_mpi_sub_int(&r, &r_check, 1), 0);
+ TEST_EQUAL(mbedtls_mpi_add_int(&s, &s_check, 1), 0);
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &r, &s_check ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &r_check, &s ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &r, &s ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &r, &s_check), MBEDTLS_ERR_ECP_VERIFY_FAILED);
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &r_check, &s), MBEDTLS_ERR_ECP_VERIFY_FAILED);
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &r, &s), MBEDTLS_ERR_ECP_VERIFY_FAILED);
/* Invalid signatures: r, s or both (CVE-2022-21449) are zero */
- TEST_EQUAL( mbedtls_mpi_lset( &zero, 0 ), 0 );
+ TEST_EQUAL(mbedtls_mpi_lset(&zero, 0), 0);
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &zero, &s_check ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &r_check, &zero ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &zero, &zero ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &zero, &s_check), MBEDTLS_ERR_ECP_VERIFY_FAILED);
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &r_check, &zero), MBEDTLS_ERR_ECP_VERIFY_FAILED);
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &zero, &zero), MBEDTLS_ERR_ECP_VERIFY_FAILED);
/* Invalid signatures: r, s or both are == N */
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &grp.N, &s_check ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &r_check, &grp.N ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &grp.N, &grp.N ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &grp.N, &s_check), MBEDTLS_ERR_ECP_VERIFY_FAILED);
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &r_check, &grp.N), MBEDTLS_ERR_ECP_VERIFY_FAILED);
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &grp.N, &grp.N), MBEDTLS_ERR_ECP_VERIFY_FAILED);
/* Invalid signatures: r, s or both are negative */
- TEST_EQUAL( mbedtls_mpi_sub_mpi( &r, &r_check, &grp.N ), 0 );
- TEST_EQUAL( mbedtls_mpi_sub_mpi( &s, &s_check, &grp.N ), 0 );
+ TEST_EQUAL(mbedtls_mpi_sub_mpi(&r, &r_check, &grp.N), 0);
+ TEST_EQUAL(mbedtls_mpi_sub_mpi(&s, &s_check, &grp.N), 0);
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &r, &s_check ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &r_check, &s ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &r, &s ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &r, &s_check), MBEDTLS_ERR_ECP_VERIFY_FAILED);
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &r_check, &s), MBEDTLS_ERR_ECP_VERIFY_FAILED);
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &r, &s), MBEDTLS_ERR_ECP_VERIFY_FAILED);
/* Invalid signatures: r or s or both are > N */
- TEST_EQUAL( mbedtls_mpi_add_mpi( &r, &r_check, &grp.N ), 0 );
- TEST_EQUAL( mbedtls_mpi_add_mpi( &s, &s_check, &grp.N ), 0 );
+ TEST_EQUAL(mbedtls_mpi_add_mpi(&r, &r_check, &grp.N), 0);
+ TEST_EQUAL(mbedtls_mpi_add_mpi(&s, &s_check, &grp.N), 0);
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &r, &s_check ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &r_check, &s ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
- TEST_EQUAL( mbedtls_ecdsa_verify( &grp, hash->x, hash->len, &Q,
- &r, &s ), MBEDTLS_ERR_ECP_VERIFY_FAILED );
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &r, &s_check), MBEDTLS_ERR_ECP_VERIFY_FAILED);
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &r_check, &s), MBEDTLS_ERR_ECP_VERIFY_FAILED);
+ TEST_EQUAL(mbedtls_ecdsa_verify(&grp, hash->x, hash->len, &Q,
+ &r, &s), MBEDTLS_ERR_ECP_VERIFY_FAILED);
}
exit:
- mbedtls_ecp_group_free( &grp );
- mbedtls_ecp_point_free( &Q );
- mbedtls_mpi_free( &d ); mbedtls_mpi_free( &r ); mbedtls_mpi_free( &s );
- mbedtls_mpi_free( &r_check ); mbedtls_mpi_free( &s_check );
- mbedtls_mpi_free( &zero );
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_ecp_point_free(&Q);
+ mbedtls_mpi_free(&d); mbedtls_mpi_free(&r); mbedtls_mpi_free(&s);
+ mbedtls_mpi_free(&r_check); mbedtls_mpi_free(&s_check);
+ mbedtls_mpi_free(&zero);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECDSA_DETERMINISTIC */
-void ecdsa_det_test_vectors( int id, char * d_str, int md_alg, char * msg,
- char * r_str, char * s_str )
+void ecdsa_det_test_vectors(int id, char *d_str, int md_alg, char *msg,
+ char *r_str, char *s_str)
{
mbedtls_ecp_group grp;
mbedtls_mpi d, r, s, r_check, s_check;
@@ -410,40 +409,40 @@
size_t hlen;
const mbedtls_md_info_t *md_info;
- mbedtls_ecp_group_init( &grp );
- mbedtls_mpi_init( &d ); mbedtls_mpi_init( &r ); mbedtls_mpi_init( &s );
- mbedtls_mpi_init( &r_check ); mbedtls_mpi_init( &s_check );
- memset( hash, 0, sizeof( hash ) );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_mpi_init(&d); mbedtls_mpi_init(&r); mbedtls_mpi_init(&s);
+ mbedtls_mpi_init(&r_check); mbedtls_mpi_init(&s_check);
+ memset(hash, 0, sizeof(hash));
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &d, d_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &r_check, r_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &s_check, s_str ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&d, d_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&r_check, r_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&s_check, s_str) == 0);
- md_info = mbedtls_md_info_from_type( md_alg );
- TEST_ASSERT( md_info != NULL );
- hlen = mbedtls_md_get_size( md_info );
- TEST_ASSERT( mbedtls_md( md_info, (const unsigned char *) msg,
- strlen( msg ), hash ) == 0 );
+ md_info = mbedtls_md_info_from_type(md_alg);
+ TEST_ASSERT(md_info != NULL);
+ hlen = mbedtls_md_get_size(md_info);
+ TEST_ASSERT(mbedtls_md(md_info, (const unsigned char *) msg,
+ strlen(msg), hash) == 0);
TEST_ASSERT(
- mbedtls_ecdsa_sign_det_ext( &grp, &r, &s, &d, hash, hlen,
- md_alg, mbedtls_test_rnd_std_rand,
- NULL )
- == 0 );
+ mbedtls_ecdsa_sign_det_ext(&grp, &r, &s, &d, hash, hlen,
+ md_alg, mbedtls_test_rnd_std_rand,
+ NULL)
+ == 0);
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &r, &r_check ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &s, &s_check ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&r, &r_check) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&s, &s_check) == 0);
exit:
- mbedtls_ecp_group_free( &grp );
- mbedtls_mpi_free( &d ); mbedtls_mpi_free( &r ); mbedtls_mpi_free( &s );
- mbedtls_mpi_free( &r_check ); mbedtls_mpi_free( &s_check );
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_mpi_free(&d); mbedtls_mpi_free(&r); mbedtls_mpi_free(&s);
+ mbedtls_mpi_free(&r_check); mbedtls_mpi_free(&s_check);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
-void ecdsa_write_read_zero( int id )
+void ecdsa_write_read_zero(int id)
{
mbedtls_ecdsa_context ctx;
mbedtls_test_rnd_pseudo_info rnd_info;
@@ -451,59 +450,60 @@
unsigned char sig[200];
size_t sig_len, i;
- mbedtls_ecdsa_init( &ctx );
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
- memset( hash, 0, sizeof( hash ) );
- memset( sig, 0x2a, sizeof( sig ) );
+ mbedtls_ecdsa_init(&ctx);
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
+ memset(hash, 0, sizeof(hash));
+ memset(sig, 0x2a, sizeof(sig));
/* generate signing key */
- TEST_ASSERT( mbedtls_ecdsa_genkey( &ctx, id,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
+ TEST_ASSERT(mbedtls_ecdsa_genkey(&ctx, id,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
/* generate and write signature, then read and verify it */
- TEST_ASSERT( mbedtls_ecdsa_write_signature( &ctx, MBEDTLS_MD_SHA256,
- hash, sizeof( hash ),
- sig, &sig_len, &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecdsa_read_signature( &ctx, hash, sizeof( hash ),
- sig, sig_len ) == 0 );
+ TEST_ASSERT(mbedtls_ecdsa_write_signature(&ctx, MBEDTLS_MD_SHA256,
+ hash, sizeof(hash),
+ sig, &sig_len, &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecdsa_read_signature(&ctx, hash, sizeof(hash),
+ sig, sig_len) == 0);
/* check we didn't write past the announced length */
- for( i = sig_len; i < sizeof( sig ); i++ )
- TEST_ASSERT( sig[i] == 0x2a );
+ for (i = sig_len; i < sizeof(sig); i++) {
+ TEST_ASSERT(sig[i] == 0x2a);
+ }
/* try verification with invalid length */
- TEST_ASSERT( mbedtls_ecdsa_read_signature( &ctx, hash, sizeof( hash ),
- sig, sig_len - 1 ) != 0 );
- TEST_ASSERT( mbedtls_ecdsa_read_signature( &ctx, hash, sizeof( hash ),
- sig, sig_len + 1 ) != 0 );
+ TEST_ASSERT(mbedtls_ecdsa_read_signature(&ctx, hash, sizeof(hash),
+ sig, sig_len - 1) != 0);
+ TEST_ASSERT(mbedtls_ecdsa_read_signature(&ctx, hash, sizeof(hash),
+ sig, sig_len + 1) != 0);
/* try invalid sequence tag */
sig[0]++;
- TEST_ASSERT( mbedtls_ecdsa_read_signature( &ctx, hash, sizeof( hash ),
- sig, sig_len ) != 0 );
+ TEST_ASSERT(mbedtls_ecdsa_read_signature(&ctx, hash, sizeof(hash),
+ sig, sig_len) != 0);
sig[0]--;
/* try modifying r */
sig[10]++;
- TEST_ASSERT( mbedtls_ecdsa_read_signature( &ctx, hash, sizeof( hash ),
- sig, sig_len ) == MBEDTLS_ERR_ECP_VERIFY_FAILED );
+ TEST_ASSERT(mbedtls_ecdsa_read_signature(&ctx, hash, sizeof(hash),
+ sig, sig_len) == MBEDTLS_ERR_ECP_VERIFY_FAILED);
sig[10]--;
/* try modifying s */
sig[sig_len - 1]++;
- TEST_ASSERT( mbedtls_ecdsa_read_signature( &ctx, hash, sizeof( hash ),
- sig, sig_len ) == MBEDTLS_ERR_ECP_VERIFY_FAILED );
+ TEST_ASSERT(mbedtls_ecdsa_read_signature(&ctx, hash, sizeof(hash),
+ sig, sig_len) == MBEDTLS_ERR_ECP_VERIFY_FAILED);
sig[sig_len - 1]--;
exit:
- mbedtls_ecdsa_free( &ctx );
+ mbedtls_ecdsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
-void ecdsa_write_read_random( int id )
+void ecdsa_write_read_random(int id)
{
mbedtls_ecdsa_context ctx;
mbedtls_test_rnd_pseudo_info rnd_info;
@@ -511,127 +511,131 @@
unsigned char sig[200];
size_t sig_len, i;
- mbedtls_ecdsa_init( &ctx );
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
- memset( hash, 0, sizeof( hash ) );
- memset( sig, 0x2a, sizeof( sig ) );
+ mbedtls_ecdsa_init(&ctx);
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
+ memset(hash, 0, sizeof(hash));
+ memset(sig, 0x2a, sizeof(sig));
/* prepare material for signature */
- TEST_ASSERT( mbedtls_test_rnd_pseudo_rand( &rnd_info,
- hash, sizeof( hash ) ) == 0 );
+ TEST_ASSERT(mbedtls_test_rnd_pseudo_rand(&rnd_info,
+ hash, sizeof(hash)) == 0);
/* generate signing key */
- TEST_ASSERT( mbedtls_ecdsa_genkey( &ctx, id,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
+ TEST_ASSERT(mbedtls_ecdsa_genkey(&ctx, id,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
/* generate and write signature, then read and verify it */
- TEST_ASSERT( mbedtls_ecdsa_write_signature( &ctx, MBEDTLS_MD_SHA256,
- hash, sizeof( hash ),
- sig, &sig_len, &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecdsa_read_signature( &ctx, hash, sizeof( hash ),
- sig, sig_len ) == 0 );
+ TEST_ASSERT(mbedtls_ecdsa_write_signature(&ctx, MBEDTLS_MD_SHA256,
+ hash, sizeof(hash),
+ sig, &sig_len, &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecdsa_read_signature(&ctx, hash, sizeof(hash),
+ sig, sig_len) == 0);
/* check we didn't write past the announced length */
- for( i = sig_len; i < sizeof( sig ); i++ )
- TEST_ASSERT( sig[i] == 0x2a );
+ for (i = sig_len; i < sizeof(sig); i++) {
+ TEST_ASSERT(sig[i] == 0x2a);
+ }
/* try verification with invalid length */
- TEST_ASSERT( mbedtls_ecdsa_read_signature( &ctx, hash, sizeof( hash ),
- sig, sig_len - 1 ) != 0 );
- TEST_ASSERT( mbedtls_ecdsa_read_signature( &ctx, hash, sizeof( hash ),
- sig, sig_len + 1 ) != 0 );
+ TEST_ASSERT(mbedtls_ecdsa_read_signature(&ctx, hash, sizeof(hash),
+ sig, sig_len - 1) != 0);
+ TEST_ASSERT(mbedtls_ecdsa_read_signature(&ctx, hash, sizeof(hash),
+ sig, sig_len + 1) != 0);
/* try invalid sequence tag */
sig[0]++;
- TEST_ASSERT( mbedtls_ecdsa_read_signature( &ctx, hash, sizeof( hash ),
- sig, sig_len ) != 0 );
+ TEST_ASSERT(mbedtls_ecdsa_read_signature(&ctx, hash, sizeof(hash),
+ sig, sig_len) != 0);
sig[0]--;
/* try modifying r */
sig[10]++;
- TEST_ASSERT( mbedtls_ecdsa_read_signature( &ctx, hash, sizeof( hash ),
- sig, sig_len ) == MBEDTLS_ERR_ECP_VERIFY_FAILED );
+ TEST_ASSERT(mbedtls_ecdsa_read_signature(&ctx, hash, sizeof(hash),
+ sig, sig_len) == MBEDTLS_ERR_ECP_VERIFY_FAILED);
sig[10]--;
/* try modifying s */
sig[sig_len - 1]++;
- TEST_ASSERT( mbedtls_ecdsa_read_signature( &ctx, hash, sizeof( hash ),
- sig, sig_len ) == MBEDTLS_ERR_ECP_VERIFY_FAILED );
+ TEST_ASSERT(mbedtls_ecdsa_read_signature(&ctx, hash, sizeof(hash),
+ sig, sig_len) == MBEDTLS_ERR_ECP_VERIFY_FAILED);
sig[sig_len - 1]--;
exit:
- mbedtls_ecdsa_free( &ctx );
+ mbedtls_ecdsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECP_RESTARTABLE */
-void ecdsa_read_restart( int id, data_t *pk, data_t *hash, data_t *sig,
- int max_ops, int min_restart, int max_restart )
+void ecdsa_read_restart(int id, data_t *pk, data_t *hash, data_t *sig,
+ int max_ops, int min_restart, int max_restart)
{
mbedtls_ecdsa_context ctx;
mbedtls_ecdsa_restart_ctx rs_ctx;
int ret, cnt_restart;
- mbedtls_ecdsa_init( &ctx );
- mbedtls_ecdsa_restart_init( &rs_ctx );
+ mbedtls_ecdsa_init(&ctx);
+ mbedtls_ecdsa_restart_init(&rs_ctx);
- TEST_ASSERT( mbedtls_ecp_group_load( &ctx.grp, id ) == 0 );
- TEST_ASSERT( mbedtls_ecp_point_read_binary( &ctx.grp, &ctx.Q,
- pk->x, pk->len ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&ctx.grp, id) == 0);
+ TEST_ASSERT(mbedtls_ecp_point_read_binary(&ctx.grp, &ctx.Q,
+ pk->x, pk->len) == 0);
- mbedtls_ecp_set_max_ops( max_ops );
+ mbedtls_ecp_set_max_ops(max_ops);
cnt_restart = 0;
do {
- ret = mbedtls_ecdsa_read_signature_restartable( &ctx,
- hash->x, hash->len, sig->x, sig->len, &rs_ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
+ ret = mbedtls_ecdsa_read_signature_restartable(&ctx,
+ hash->x, hash->len, sig->x, sig->len,
+ &rs_ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart);
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( cnt_restart >= min_restart );
- TEST_ASSERT( cnt_restart <= max_restart );
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(cnt_restart >= min_restart);
+ TEST_ASSERT(cnt_restart <= max_restart);
/* try modifying r */
- TEST_ASSERT( sig->len > 10 );
+ TEST_ASSERT(sig->len > 10);
sig->x[10]++;
do {
- ret = mbedtls_ecdsa_read_signature_restartable( &ctx,
- hash->x, hash->len, sig->x, sig->len, &rs_ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
- TEST_ASSERT( ret == MBEDTLS_ERR_ECP_VERIFY_FAILED );
+ ret = mbedtls_ecdsa_read_signature_restartable(&ctx,
+ hash->x, hash->len, sig->x, sig->len,
+ &rs_ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
+ TEST_ASSERT(ret == MBEDTLS_ERR_ECP_VERIFY_FAILED);
sig->x[10]--;
/* try modifying s */
sig->x[sig->len - 1]++;
do {
- ret = mbedtls_ecdsa_read_signature_restartable( &ctx,
- hash->x, hash->len, sig->x, sig->len, &rs_ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
- TEST_ASSERT( ret == MBEDTLS_ERR_ECP_VERIFY_FAILED );
+ ret = mbedtls_ecdsa_read_signature_restartable(&ctx,
+ hash->x, hash->len, sig->x, sig->len,
+ &rs_ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
+ TEST_ASSERT(ret == MBEDTLS_ERR_ECP_VERIFY_FAILED);
sig->x[sig->len - 1]--;
/* Do we leak memory when aborting an operation?
* This test only makes sense when we actually restart */
- if( min_restart > 0 )
- {
- ret = mbedtls_ecdsa_read_signature_restartable( &ctx,
- hash->x, hash->len, sig->x, sig->len, &rs_ctx );
- TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
+ if (min_restart > 0) {
+ ret = mbedtls_ecdsa_read_signature_restartable(&ctx,
+ hash->x, hash->len, sig->x, sig->len,
+ &rs_ctx);
+ TEST_ASSERT(ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
}
exit:
- mbedtls_ecdsa_free( &ctx );
- mbedtls_ecdsa_restart_free( &rs_ctx );
+ mbedtls_ecdsa_free(&ctx);
+ mbedtls_ecdsa_restart_free(&rs_ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECP_RESTARTABLE:MBEDTLS_ECDSA_DETERMINISTIC */
-void ecdsa_write_restart( int id, char *d_str, int md_alg,
- char *msg, data_t *sig_check,
- int max_ops, int min_restart, int max_restart )
+void ecdsa_write_restart(int id, char *d_str, int md_alg,
+ char *msg, data_t *sig_check,
+ int max_ops, int min_restart, int max_restart)
{
int ret, cnt_restart;
mbedtls_ecdsa_restart_ctx rs_ctx;
@@ -641,86 +645,99 @@
size_t hlen, slen;
const mbedtls_md_info_t *md_info;
- mbedtls_ecdsa_restart_init( &rs_ctx );
- mbedtls_ecdsa_init( &ctx );
- memset( hash, 0, sizeof( hash ) );
- memset( sig, 0, sizeof( sig ) );
+ mbedtls_ecdsa_restart_init(&rs_ctx);
+ mbedtls_ecdsa_init(&ctx);
+ memset(hash, 0, sizeof(hash));
+ memset(sig, 0, sizeof(sig));
- TEST_ASSERT( mbedtls_ecp_group_load( &ctx.grp, id ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &ctx.d, d_str ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&ctx.grp, id) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&ctx.d, d_str) == 0);
- md_info = mbedtls_md_info_from_type( md_alg );
- TEST_ASSERT( md_info != NULL );
+ md_info = mbedtls_md_info_from_type(md_alg);
+ TEST_ASSERT(md_info != NULL);
- hlen = mbedtls_md_get_size( md_info );
- TEST_ASSERT( mbedtls_md( md_info,
- (const unsigned char *) msg, strlen( msg ),
- hash ) == 0 );
+ hlen = mbedtls_md_get_size(md_info);
+ TEST_ASSERT(mbedtls_md(md_info,
+ (const unsigned char *) msg, strlen(msg),
+ hash) == 0);
- mbedtls_ecp_set_max_ops( max_ops );
+ mbedtls_ecp_set_max_ops(max_ops);
- slen = sizeof( sig );
+ slen = sizeof(sig);
cnt_restart = 0;
do {
- ret = mbedtls_ecdsa_write_signature_restartable( &ctx,
- md_alg, hash, hlen, sig, &slen, NULL, NULL, &rs_ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
+ ret = mbedtls_ecdsa_write_signature_restartable(&ctx,
+ md_alg,
+ hash,
+ hlen,
+ sig,
+ &slen,
+ NULL,
+ NULL,
+ &rs_ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart);
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( slen == sig_check->len );
- TEST_ASSERT( memcmp( sig, sig_check->x, slen ) == 0 );
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(slen == sig_check->len);
+ TEST_ASSERT(memcmp(sig, sig_check->x, slen) == 0);
- TEST_ASSERT( cnt_restart >= min_restart );
- TEST_ASSERT( cnt_restart <= max_restart );
+ TEST_ASSERT(cnt_restart >= min_restart);
+ TEST_ASSERT(cnt_restart <= max_restart);
/* Do we leak memory when aborting an operation?
* This test only makes sense when we actually restart */
- if( min_restart > 0 )
- {
- ret = mbedtls_ecdsa_write_signature_restartable( &ctx,
- md_alg, hash, hlen, sig, &slen, NULL, NULL, &rs_ctx );
- TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
+ if (min_restart > 0) {
+ ret = mbedtls_ecdsa_write_signature_restartable(&ctx,
+ md_alg,
+ hash,
+ hlen,
+ sig,
+ &slen,
+ NULL,
+ NULL,
+ &rs_ctx);
+ TEST_ASSERT(ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
}
exit:
- mbedtls_ecdsa_restart_free( &rs_ctx );
- mbedtls_ecdsa_free( &ctx );
+ mbedtls_ecdsa_restart_free(&rs_ctx);
+ mbedtls_ecdsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecdsa_verify( int grp_id, char * x, char * y, char * r, char * s, data_t * content, int expected )
+void ecdsa_verify(int grp_id, char *x, char *y, char *r, char *s, data_t *content, int expected)
{
mbedtls_ecdsa_context ctx;
mbedtls_mpi sig_r, sig_s;
- mbedtls_ecdsa_init( &ctx );
- mbedtls_mpi_init( &sig_r );
- mbedtls_mpi_init( &sig_s );
+ mbedtls_ecdsa_init(&ctx);
+ mbedtls_mpi_init(&sig_r);
+ mbedtls_mpi_init(&sig_s);
/* Prepare ECP group context */
- TEST_EQUAL( mbedtls_ecp_group_load( &ctx.grp, grp_id ), 0 );
+ TEST_EQUAL(mbedtls_ecp_group_load(&ctx.grp, grp_id), 0);
/* Prepare public key */
- TEST_EQUAL( mbedtls_test_read_mpi( &ctx.Q.X, x ), 0 );
- TEST_EQUAL( mbedtls_test_read_mpi( &ctx.Q.Y, y ), 0 );
- TEST_EQUAL( mbedtls_mpi_lset( &ctx.Q.Z, 1 ), 0 );
+ TEST_EQUAL(mbedtls_test_read_mpi(&ctx.Q.X, x), 0);
+ TEST_EQUAL(mbedtls_test_read_mpi(&ctx.Q.Y, y), 0);
+ TEST_EQUAL(mbedtls_mpi_lset(&ctx.Q.Z, 1), 0);
/* Prepare signature R & S */
- TEST_EQUAL( mbedtls_test_read_mpi( &sig_r, r ), 0 );
- TEST_EQUAL( mbedtls_test_read_mpi( &sig_s, s ), 0 );
+ TEST_EQUAL(mbedtls_test_read_mpi(&sig_r, r), 0);
+ TEST_EQUAL(mbedtls_test_read_mpi(&sig_s, s), 0);
/* Test whether public key has expected validity */
- TEST_EQUAL( mbedtls_ecp_check_pubkey( &ctx.grp, &ctx.Q ),
- expected == MBEDTLS_ERR_ECP_INVALID_KEY ? MBEDTLS_ERR_ECP_INVALID_KEY : 0 );
+ TEST_EQUAL(mbedtls_ecp_check_pubkey(&ctx.grp, &ctx.Q),
+ expected == MBEDTLS_ERR_ECP_INVALID_KEY ? MBEDTLS_ERR_ECP_INVALID_KEY : 0);
/* Verification */
- int result = mbedtls_ecdsa_verify( &ctx.grp, content->x, content->len, &ctx.Q, &sig_r, &sig_s );
+ int result = mbedtls_ecdsa_verify(&ctx.grp, content->x, content->len, &ctx.Q, &sig_r, &sig_s);
- TEST_EQUAL( result, expected );
+ TEST_EQUAL(result, expected);
exit:
- mbedtls_ecdsa_free( &ctx );
- mbedtls_mpi_free( &sig_r );
- mbedtls_mpi_free( &sig_s );
+ mbedtls_ecdsa_free(&ctx);
+ mbedtls_mpi_free(&sig_r);
+ mbedtls_mpi_free(&sig_s);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_ecjpake.function b/tests/suites/test_suite_ecjpake.function
index 2246f2d..16f52b2 100644
--- a/tests/suites/test_suite_ecjpake.function
+++ b/tests/suites/test_suite_ecjpake.function
@@ -63,33 +63,33 @@
};
/* Load my private and public keys, and peer's public keys */
-static int ecjpake_test_load( mbedtls_ecjpake_context *ctx,
- const unsigned char *xm1, size_t len_xm1,
- const unsigned char *xm2, size_t len_xm2,
- const unsigned char *Xm1, size_t len_Xm1,
- const unsigned char *Xm2, size_t len_Xm2,
- const unsigned char *Xp1, size_t len_Xp1,
- const unsigned char *Xp2, size_t len_Xp2 )
+static int ecjpake_test_load(mbedtls_ecjpake_context *ctx,
+ const unsigned char *xm1, size_t len_xm1,
+ const unsigned char *xm2, size_t len_xm2,
+ const unsigned char *Xm1, size_t len_Xm1,
+ const unsigned char *Xm2, size_t len_Xm2,
+ const unsigned char *Xp1, size_t len_Xp1,
+ const unsigned char *Xp2, size_t len_Xp2)
{
int ret;
- MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &ctx->xm1, xm1, len_xm1 ) );
- MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &ctx->xm2, xm2, len_xm2 ) );
+ MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&ctx->xm1, xm1, len_xm1));
+ MBEDTLS_MPI_CHK(mbedtls_mpi_read_binary(&ctx->xm2, xm2, len_xm2));
- MBEDTLS_MPI_CHK( mbedtls_ecp_point_read_binary( &ctx->grp,
- &ctx->Xm1, Xm1, len_Xm1 ) );
- MBEDTLS_MPI_CHK( mbedtls_ecp_point_read_binary( &ctx->grp,
- &ctx->Xm2, Xm2, len_Xm2 ) );
- MBEDTLS_MPI_CHK( mbedtls_ecp_point_read_binary( &ctx->grp,
- &ctx->Xp1, Xp1, len_Xp1 ) );
- MBEDTLS_MPI_CHK( mbedtls_ecp_point_read_binary( &ctx->grp,
- &ctx->Xp2, Xp2, len_Xp2 ) );
+ MBEDTLS_MPI_CHK(mbedtls_ecp_point_read_binary(&ctx->grp,
+ &ctx->Xm1, Xm1, len_Xm1));
+ MBEDTLS_MPI_CHK(mbedtls_ecp_point_read_binary(&ctx->grp,
+ &ctx->Xm2, Xm2, len_Xm2));
+ MBEDTLS_MPI_CHK(mbedtls_ecp_point_read_binary(&ctx->grp,
+ &ctx->Xp1, Xp1, len_Xp1));
+ MBEDTLS_MPI_CHK(mbedtls_ecp_point_read_binary(&ctx->grp,
+ &ctx->Xp2, Xp2, len_Xp2));
cleanup:
- return( ret );
+ return ret;
}
-#define ADD_SIZE( x ) x, sizeof( x )
+#define ADD_SIZE(x) x, sizeof(x)
#endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED && MBEDTLS_SHA256_C */
/* END_HEADER */
@@ -99,101 +99,101 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void ecjpake_invalid_param( )
+void ecjpake_invalid_param()
{
mbedtls_ecjpake_context ctx;
unsigned char buf[42] = { 0 };
size_t olen;
- size_t const len = sizeof( buf );
+ size_t const len = sizeof(buf);
mbedtls_ecjpake_role valid_role = MBEDTLS_ECJPAKE_SERVER;
mbedtls_ecjpake_role invalid_role = (mbedtls_ecjpake_role) 42;
mbedtls_md_type_t valid_md = MBEDTLS_MD_SHA256;
mbedtls_ecp_group_id valid_group = MBEDTLS_ECP_DP_SECP256R1;
- mbedtls_ecjpake_init( &ctx );
+ mbedtls_ecjpake_init(&ctx);
- TEST_INVALID_PARAM( mbedtls_ecjpake_init( NULL ) );
- TEST_VALID_PARAM( mbedtls_ecjpake_free( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_ecjpake_init(NULL));
+ TEST_VALID_PARAM(mbedtls_ecjpake_free(NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_setup( NULL,
- valid_role,
- valid_md,
- valid_group,
- buf, len ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_setup( &ctx,
- invalid_role,
- valid_md,
- valid_group,
- buf, len ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_setup( &ctx,
- valid_role,
- valid_md,
- valid_group,
- NULL, len ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_setup(NULL,
+ valid_role,
+ valid_md,
+ valid_group,
+ buf, len));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_setup(&ctx,
+ invalid_role,
+ valid_md,
+ valid_group,
+ buf, len));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_setup(&ctx,
+ valid_role,
+ valid_md,
+ valid_group,
+ NULL, len));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_check( NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_check(NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_write_round_one( NULL, buf, len, &olen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_write_round_one(NULL, buf, len, &olen,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_write_round_one( &ctx, NULL, len, &olen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_write_round_one(&ctx, NULL, len, &olen,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_write_round_one( &ctx, buf, len, NULL,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_write_round_one(&ctx, buf, len, NULL,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_write_round_one( &ctx, buf, len, &olen, NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_write_round_one(&ctx, buf, len, &olen, NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_write_round_two( NULL, buf, len, &olen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_write_round_two(NULL, buf, len, &olen,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_write_round_two( &ctx, NULL, len, &olen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_write_round_two(&ctx, NULL, len, &olen,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_write_round_two( &ctx, buf, len, NULL,
- mbedtls_test_rnd_std_rand, NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_write_round_two( &ctx, buf, len, &olen, NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_write_round_two(&ctx, buf, len, NULL,
+ mbedtls_test_rnd_std_rand, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_write_round_two(&ctx, buf, len, &olen, NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_read_round_one( NULL,
- buf, len ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_read_round_one( &ctx,
- NULL, len ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_read_round_one(NULL,
+ buf, len));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_read_round_one(&ctx,
+ NULL, len));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_read_round_two( NULL,
- buf, len ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_read_round_two( &ctx,
- NULL, len ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_read_round_two(NULL,
+ buf, len));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_read_round_two(&ctx,
+ NULL, len));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_derive_secret( NULL, buf, len, &olen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_derive_secret(NULL, buf, len, &olen,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_derive_secret( &ctx, NULL, len, &olen,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_derive_secret(&ctx, NULL, len, &olen,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_derive_secret( &ctx, buf, len, NULL,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_derive_secret(&ctx, buf, len, NULL,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecjpake_derive_secret( &ctx, buf, len, &olen, NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecjpake_derive_secret(&ctx, buf, len, &olen, NULL, NULL));
exit:
return;
@@ -201,98 +201,102 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void ecjpake_selftest( )
+void ecjpake_selftest()
{
- TEST_ASSERT( mbedtls_ecjpake_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_ecjpake_self_test(1) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECP_DP_SECP256R1_ENABLED:MBEDTLS_SHA256_C */
-void read_bad_md( data_t *msg )
+void read_bad_md(data_t *msg)
{
mbedtls_ecjpake_context corrupt_ctx;
- const unsigned char * pw = NULL;
+ const unsigned char *pw = NULL;
const size_t pw_len = 0;
int any_role = MBEDTLS_ECJPAKE_CLIENT;
- mbedtls_ecjpake_init( &corrupt_ctx );
- TEST_ASSERT( mbedtls_ecjpake_setup( &corrupt_ctx, any_role,
- MBEDTLS_MD_SHA256, MBEDTLS_ECP_DP_SECP256R1, pw, pw_len ) == 0 );
+ mbedtls_ecjpake_init(&corrupt_ctx);
+ TEST_ASSERT(mbedtls_ecjpake_setup(&corrupt_ctx, any_role,
+ MBEDTLS_MD_SHA256, MBEDTLS_ECP_DP_SECP256R1, pw,
+ pw_len) == 0);
corrupt_ctx.md_info = NULL;
- TEST_ASSERT( mbedtls_ecjpake_read_round_one( &corrupt_ctx, msg->x,
- msg->len ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_ecjpake_read_round_one(&corrupt_ctx, msg->x,
+ msg->len) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
exit:
- mbedtls_ecjpake_free( &corrupt_ctx );
+ mbedtls_ecjpake_free(&corrupt_ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECP_DP_SECP256R1_ENABLED:MBEDTLS_SHA256_C */
-void read_round_one( int role, data_t * msg, int ref_ret )
+void read_round_one(int role, data_t *msg, int ref_ret)
{
mbedtls_ecjpake_context ctx;
- const unsigned char * pw = NULL;
+ const unsigned char *pw = NULL;
const size_t pw_len = 0;
- mbedtls_ecjpake_init( &ctx );
+ mbedtls_ecjpake_init(&ctx);
- TEST_ASSERT( mbedtls_ecjpake_setup( &ctx, role,
- MBEDTLS_MD_SHA256, MBEDTLS_ECP_DP_SECP256R1, pw, pw_len ) == 0 );
+ TEST_ASSERT(mbedtls_ecjpake_setup(&ctx, role,
+ MBEDTLS_MD_SHA256, MBEDTLS_ECP_DP_SECP256R1, pw,
+ pw_len) == 0);
- TEST_ASSERT( mbedtls_ecjpake_read_round_one( &ctx, msg->x, msg->len ) == ref_ret );
+ TEST_ASSERT(mbedtls_ecjpake_read_round_one(&ctx, msg->x, msg->len) == ref_ret);
exit:
- mbedtls_ecjpake_free( &ctx );
+ mbedtls_ecjpake_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECP_DP_SECP256R1_ENABLED:MBEDTLS_SHA256_C */
-void read_round_two_cli( data_t * msg, int ref_ret )
+void read_round_two_cli(data_t *msg, int ref_ret)
{
mbedtls_ecjpake_context ctx;
- const unsigned char * pw = NULL;
+ const unsigned char *pw = NULL;
const size_t pw_len = 0;
- mbedtls_ecjpake_init( &ctx );
+ mbedtls_ecjpake_init(&ctx);
- TEST_ASSERT( mbedtls_ecjpake_setup( &ctx, MBEDTLS_ECJPAKE_CLIENT,
- MBEDTLS_MD_SHA256, MBEDTLS_ECP_DP_SECP256R1, pw, pw_len ) == 0 );
+ TEST_ASSERT(mbedtls_ecjpake_setup(&ctx, MBEDTLS_ECJPAKE_CLIENT,
+ MBEDTLS_MD_SHA256, MBEDTLS_ECP_DP_SECP256R1, pw,
+ pw_len) == 0);
- TEST_ASSERT( ecjpake_test_load( &ctx,
- ADD_SIZE( ecjpake_test_x1 ), ADD_SIZE( ecjpake_test_x2 ),
- ADD_SIZE( ecjpake_test_X1 ), ADD_SIZE( ecjpake_test_X2 ),
- ADD_SIZE( ecjpake_test_X3 ), ADD_SIZE( ecjpake_test_X4 ) )
- == 0 );
+ TEST_ASSERT(ecjpake_test_load(&ctx,
+ ADD_SIZE(ecjpake_test_x1), ADD_SIZE(ecjpake_test_x2),
+ ADD_SIZE(ecjpake_test_X1), ADD_SIZE(ecjpake_test_X2),
+ ADD_SIZE(ecjpake_test_X3), ADD_SIZE(ecjpake_test_X4))
+ == 0);
- TEST_ASSERT( mbedtls_ecjpake_read_round_two( &ctx, msg->x, msg->len ) == ref_ret );
+ TEST_ASSERT(mbedtls_ecjpake_read_round_two(&ctx, msg->x, msg->len) == ref_ret);
exit:
- mbedtls_ecjpake_free( &ctx );
+ mbedtls_ecjpake_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECP_DP_SECP256R1_ENABLED:MBEDTLS_SHA256_C */
-void read_round_two_srv( data_t * msg, int ref_ret )
+void read_round_two_srv(data_t *msg, int ref_ret)
{
mbedtls_ecjpake_context ctx;
- const unsigned char * pw = NULL;
+ const unsigned char *pw = NULL;
const size_t pw_len = 0;
- mbedtls_ecjpake_init( &ctx );
+ mbedtls_ecjpake_init(&ctx);
- TEST_ASSERT( mbedtls_ecjpake_setup( &ctx, MBEDTLS_ECJPAKE_SERVER,
- MBEDTLS_MD_SHA256, MBEDTLS_ECP_DP_SECP256R1, pw, pw_len ) == 0 );
+ TEST_ASSERT(mbedtls_ecjpake_setup(&ctx, MBEDTLS_ECJPAKE_SERVER,
+ MBEDTLS_MD_SHA256, MBEDTLS_ECP_DP_SECP256R1, pw,
+ pw_len) == 0);
- TEST_ASSERT( ecjpake_test_load( &ctx,
- ADD_SIZE( ecjpake_test_x3 ), ADD_SIZE( ecjpake_test_x4 ),
- ADD_SIZE( ecjpake_test_X3 ), ADD_SIZE( ecjpake_test_X4 ),
- ADD_SIZE( ecjpake_test_X1 ), ADD_SIZE( ecjpake_test_X2 ) )
- == 0 );
+ TEST_ASSERT(ecjpake_test_load(&ctx,
+ ADD_SIZE(ecjpake_test_x3), ADD_SIZE(ecjpake_test_x4),
+ ADD_SIZE(ecjpake_test_X3), ADD_SIZE(ecjpake_test_X4),
+ ADD_SIZE(ecjpake_test_X1), ADD_SIZE(ecjpake_test_X2))
+ == 0);
- TEST_ASSERT( mbedtls_ecjpake_read_round_two( &ctx, msg->x, msg->len ) == ref_ret );
+ TEST_ASSERT(mbedtls_ecjpake_read_round_two(&ctx, msg->x, msg->len) == ref_ret);
exit:
- mbedtls_ecjpake_free( &ctx );
+ mbedtls_ecjpake_free(&ctx);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_ecp.function b/tests/suites/test_suite_ecp.function
index 0bce782..6110a78 100644
--- a/tests/suites/test_suite_ecp.function
+++ b/tests/suites/test_suite_ecp.function
@@ -6,52 +6,67 @@
#include "ecp_invasive.h"
#if defined(MBEDTLS_TEST_HOOKS) && \
- ( defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED) || \
- defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED) || \
- defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED) )
+ (defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED) || \
+ defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED))
#define HAVE_FIX_NEGATIVE
#endif
#define ECP_PF_UNKNOWN -1
-#define ECP_PT_RESET( x ) \
- mbedtls_ecp_point_free( x ); \
- mbedtls_ecp_point_init( x );
+#define ECP_PT_RESET(x) \
+ mbedtls_ecp_point_free(x); \
+ mbedtls_ecp_point_init(x);
/* Auxiliary function to compare two mbedtls_ecp_group objects. */
-inline static int mbedtls_ecp_group_cmp( mbedtls_ecp_group *grp1,
- mbedtls_ecp_group *grp2 )
+inline static int mbedtls_ecp_group_cmp(mbedtls_ecp_group *grp1,
+ mbedtls_ecp_group *grp2)
{
- if( mbedtls_mpi_cmp_mpi( &grp1->P, &grp2->P ) != 0 )
+ if (mbedtls_mpi_cmp_mpi(&grp1->P, &grp2->P) != 0) {
return 1;
- if( mbedtls_mpi_cmp_mpi( &grp1->A, &grp2->A ) != 0 )
+ }
+ if (mbedtls_mpi_cmp_mpi(&grp1->A, &grp2->A) != 0) {
return 1;
- if( mbedtls_mpi_cmp_mpi( &grp1->B, &grp2->B ) != 0 )
+ }
+ if (mbedtls_mpi_cmp_mpi(&grp1->B, &grp2->B) != 0) {
return 1;
- if( mbedtls_mpi_cmp_mpi( &grp1->N, &grp2->N ) != 0 )
+ }
+ if (mbedtls_mpi_cmp_mpi(&grp1->N, &grp2->N) != 0) {
return 1;
- if( mbedtls_ecp_point_cmp( &grp1->G, &grp2->G ) != 0 )
+ }
+ if (mbedtls_ecp_point_cmp(&grp1->G, &grp2->G) != 0) {
return 1;
- if( grp1->id != grp2->id )
+ }
+ if (grp1->id != grp2->id) {
return 1;
- if( grp1->pbits != grp2->pbits )
+ }
+ if (grp1->pbits != grp2->pbits) {
return 1;
- if( grp1->nbits != grp2->nbits )
+ }
+ if (grp1->nbits != grp2->nbits) {
return 1;
- if( grp1->h != grp2->h )
+ }
+ if (grp1->h != grp2->h) {
return 1;
- if( grp1->modp != grp2->modp )
+ }
+ if (grp1->modp != grp2->modp) {
return 1;
- if( grp1->t_pre != grp2->t_pre )
+ }
+ if (grp1->t_pre != grp2->t_pre) {
return 1;
- if( grp1->t_post != grp2->t_post )
+ }
+ if (grp1->t_post != grp2->t_post) {
return 1;
- if( grp1->t_data != grp2->t_data )
+ }
+ if (grp1->t_data != grp2->t_data) {
return 1;
- if( grp1->T_size != grp2->T_size )
+ }
+ if (grp1->T_size != grp2->T_size) {
return 1;
- if( grp1->T != grp2->T )
+ }
+ if (grp1->T != grp2->T) {
return 1;
+ }
return 0;
}
@@ -64,14 +79,14 @@
*/
/* BEGIN_CASE */
-void ecp_valid_param( )
+void ecp_valid_param()
{
- TEST_VALID_PARAM( mbedtls_ecp_group_free( NULL ) );
- TEST_VALID_PARAM( mbedtls_ecp_keypair_free( NULL ) );
- TEST_VALID_PARAM( mbedtls_ecp_point_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_ecp_group_free(NULL));
+ TEST_VALID_PARAM(mbedtls_ecp_keypair_free(NULL));
+ TEST_VALID_PARAM(mbedtls_ecp_point_free(NULL));
#if defined(MBEDTLS_ECP_RESTARTABLE)
- TEST_VALID_PARAM( mbedtls_ecp_restart_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_ecp_restart_free(NULL));
#endif /* MBEDTLS_ECP_RESTARTABLE */
exit:
@@ -80,7 +95,7 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void ecp_invalid_param( )
+void ecp_invalid_param()
{
mbedtls_ecp_group grp;
mbedtls_ecp_keypair kp;
@@ -97,316 +112,316 @@
mbedtls_ecp_restart_ctx restart_ctx;
#endif /* MBEDTLS_ECP_RESTARTABLE */
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_point_init( &P );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_point_init(&P);
- TEST_INVALID_PARAM( mbedtls_ecp_point_init( NULL ) );
- TEST_INVALID_PARAM( mbedtls_ecp_keypair_init( NULL ) );
- TEST_INVALID_PARAM( mbedtls_ecp_group_init( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_ecp_point_init(NULL));
+ TEST_INVALID_PARAM(mbedtls_ecp_keypair_init(NULL));
+ TEST_INVALID_PARAM(mbedtls_ecp_group_init(NULL));
#if defined(MBEDTLS_ECP_RESTARTABLE)
- TEST_INVALID_PARAM( mbedtls_ecp_restart_init( NULL ) );
- TEST_INVALID_PARAM( mbedtls_ecp_check_budget( NULL, &restart_ctx, 42 ) );
+ TEST_INVALID_PARAM(mbedtls_ecp_restart_init(NULL));
+ TEST_INVALID_PARAM(mbedtls_ecp_check_budget(NULL, &restart_ctx, 42));
#endif /* MBEDTLS_ECP_RESTARTABLE */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_copy( NULL, &P ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_copy( &P, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_copy(NULL, &P));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_copy(&P, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_group_copy( NULL, &grp ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_group_copy( &grp, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_group_copy(NULL, &grp));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_group_copy(&grp, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_gen_privkey( NULL,
- &m,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_gen_privkey( &grp,
- NULL,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_gen_privkey( &grp,
- &m,
- NULL,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_gen_privkey(NULL,
+ &m,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_gen_privkey(&grp,
+ NULL,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_gen_privkey(&grp,
+ &m,
+ NULL,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_set_zero( NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_is_zero( NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_set_zero(NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_is_zero(NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_point_cmp( NULL, &P ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_point_cmp( &P, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_point_cmp(NULL, &P));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_point_cmp(&P, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_point_read_string( NULL, 2,
- x, x ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_point_read_string( &P, 2,
- NULL, x ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_point_read_string( &P, 2,
- x, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_point_read_string(NULL, 2,
+ x, x));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_point_read_string(&P, 2,
+ NULL, x));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_point_read_string(&P, 2,
+ x, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_point_write_binary( NULL, &P,
- valid_fmt,
- &olen,
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_point_write_binary( &grp, NULL,
- valid_fmt,
- &olen,
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_point_write_binary( &grp, &P,
- invalid_fmt,
- &olen,
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_point_write_binary( &grp, &P,
- valid_fmt,
- NULL,
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_point_write_binary( &grp, &P,
- valid_fmt,
- &olen,
- NULL, sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_point_write_binary(NULL, &P,
+ valid_fmt,
+ &olen,
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_point_write_binary(&grp, NULL,
+ valid_fmt,
+ &olen,
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_point_write_binary(&grp, &P,
+ invalid_fmt,
+ &olen,
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_point_write_binary(&grp, &P,
+ valid_fmt,
+ NULL,
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_point_write_binary(&grp, &P,
+ valid_fmt,
+ &olen,
+ NULL, sizeof(buf)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_point_read_binary( NULL, &P, buf,
- sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_point_read_binary( &grp, NULL, buf,
- sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_point_read_binary( &grp, &P, NULL,
- sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_point_read_binary(NULL, &P, buf,
+ sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_point_read_binary(&grp, NULL, buf,
+ sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_point_read_binary(&grp, &P, NULL,
+ sizeof(buf)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_read_point( NULL, &P,
- (const unsigned char **) &buf,
- sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_read_point( &grp, NULL,
- (const unsigned char **) &buf,
- sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_read_point( &grp, &P, &null_buf,
- sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_read_point( &grp, &P, NULL,
- sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_read_point(NULL, &P,
+ (const unsigned char **) &buf,
+ sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_read_point(&grp, NULL,
+ (const unsigned char **) &buf,
+ sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_read_point(&grp, &P, &null_buf,
+ sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_read_point(&grp, &P, NULL,
+ sizeof(buf)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_write_point( NULL, &P,
- valid_fmt,
- &olen,
- buf,
- sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_write_point( &grp, NULL,
- valid_fmt,
- &olen,
- buf,
- sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_write_point( &grp, &P,
- invalid_fmt,
- &olen,
- buf,
- sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_write_point( &grp, &P,
- valid_fmt,
- NULL,
- buf,
- sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_write_point( &grp, &P,
- valid_fmt,
- &olen,
- NULL,
- sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_write_point(NULL, &P,
+ valid_fmt,
+ &olen,
+ buf,
+ sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_write_point(&grp, NULL,
+ valid_fmt,
+ &olen,
+ buf,
+ sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_write_point(&grp, &P,
+ invalid_fmt,
+ &olen,
+ buf,
+ sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_write_point(&grp, &P,
+ valid_fmt,
+ NULL,
+ buf,
+ sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_write_point(&grp, &P,
+ valid_fmt,
+ &olen,
+ NULL,
+ sizeof(buf)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_group_load( NULL, valid_group ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_group_load(NULL, valid_group));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_read_group( NULL,
- (const unsigned char **) &buf,
- sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_read_group( &grp, NULL,
- sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_read_group( &grp, &null_buf,
- sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_read_group(NULL,
+ (const unsigned char **) &buf,
+ sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_read_group(&grp, NULL,
+ sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_read_group(&grp, &null_buf,
+ sizeof(buf)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_read_group_id( NULL,
- (const unsigned char **) &buf,
- sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_read_group_id( &valid_group, NULL,
- sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_read_group_id( &valid_group,
- &null_buf,
- sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_read_group_id(NULL,
+ (const unsigned char **) &buf,
+ sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_read_group_id(&valid_group, NULL,
+ sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_read_group_id(&valid_group,
+ &null_buf,
+ sizeof(buf)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_write_group( NULL, &olen,
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_write_group( &grp, NULL,
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_tls_write_group( &grp, &olen,
- NULL, sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_write_group(NULL, &olen,
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_write_group(&grp, NULL,
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_tls_write_group(&grp, &olen,
+ NULL, sizeof(buf)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_mul( NULL, &P, &m, &P,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_mul( &grp, NULL, &m, &P,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_mul( &grp, &P, NULL, &P,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_mul( &grp, &P, &m, NULL,
- mbedtls_test_rnd_std_rand,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_mul(NULL, &P, &m, &P,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_mul(&grp, NULL, &m, &P,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_mul(&grp, &P, NULL, &P,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_mul(&grp, &P, &m, NULL,
+ mbedtls_test_rnd_std_rand,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_mul_restartable( NULL, &P, &m, &P,
- mbedtls_test_rnd_std_rand,
- NULL , NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_mul_restartable( &grp, NULL, &m, &P,
- mbedtls_test_rnd_std_rand,
- NULL , NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_mul_restartable( &grp, &P, NULL, &P,
- mbedtls_test_rnd_std_rand,
- NULL , NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_mul_restartable( &grp, &P, &m, NULL,
- mbedtls_test_rnd_std_rand,
- NULL , NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_mul_restartable(NULL, &P, &m, &P,
+ mbedtls_test_rnd_std_rand,
+ NULL, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_mul_restartable(&grp, NULL, &m, &P,
+ mbedtls_test_rnd_std_rand,
+ NULL, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_mul_restartable(&grp, &P, NULL, &P,
+ mbedtls_test_rnd_std_rand,
+ NULL, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_mul_restartable(&grp, &P, &m, NULL,
+ mbedtls_test_rnd_std_rand,
+ NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_muladd( NULL, &P, &m, &P,
- &m, &P ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_muladd( &grp, NULL, &m, &P,
- &m, &P ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_muladd( &grp, &P, NULL, &P,
- &m, &P ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_muladd( &grp, &P, &m, NULL,
- &m, &P ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_muladd( &grp, &P, &m, &P,
- NULL, &P ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_muladd( &grp, &P, &m, &P,
- &m, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_muladd(NULL, &P, &m, &P,
+ &m, &P));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_muladd(&grp, NULL, &m, &P,
+ &m, &P));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_muladd(&grp, &P, NULL, &P,
+ &m, &P));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_muladd(&grp, &P, &m, NULL,
+ &m, &P));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_muladd(&grp, &P, &m, &P,
+ NULL, &P));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_muladd(&grp, &P, &m, &P,
+ &m, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_muladd_restartable( NULL, &P, &m, &P,
- &m, &P, NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_muladd_restartable( &grp, NULL, &m, &P,
- &m, &P, NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_muladd_restartable( &grp, &P, NULL, &P,
- &m, &P, NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_muladd_restartable( &grp, &P, &m, NULL,
- &m, &P, NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_muladd_restartable( &grp, &P, &m, &P,
- NULL, &P, NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_muladd_restartable( &grp, &P, &m, &P,
- &m, NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_muladd_restartable(NULL, &P, &m, &P,
+ &m, &P, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_muladd_restartable(&grp, NULL, &m, &P,
+ &m, &P, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_muladd_restartable(&grp, &P, NULL, &P,
+ &m, &P, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_muladd_restartable(&grp, &P, &m, NULL,
+ &m, &P, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_muladd_restartable(&grp, &P, &m, &P,
+ NULL, &P, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_muladd_restartable(&grp, &P, &m, &P,
+ &m, NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_check_pubkey( NULL, &P ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_check_pubkey( &grp, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_check_pubkey(NULL, &P));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_check_pubkey(&grp, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_check_pub_priv( NULL, &kp ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_check_pub_priv( &kp, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_check_pub_priv(NULL, &kp));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_check_pub_priv(&kp, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_check_privkey( NULL, &m ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_check_privkey( &grp, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_check_privkey(NULL, &m));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_check_privkey(&grp, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_gen_keypair_base( NULL, &P, &m, &P,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_gen_keypair_base(NULL, &P, &m, &P,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_gen_keypair_base( &grp, NULL, &m, &P,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_gen_keypair_base(&grp, NULL, &m, &P,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_gen_keypair_base( &grp, &P, NULL, &P,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_gen_keypair_base(&grp, &P, NULL, &P,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_gen_keypair_base( &grp, &P, &m, NULL,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_gen_keypair_base(&grp, &P, &m, NULL,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_gen_keypair_base( &grp, &P, &m, &P, NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_gen_keypair_base(&grp, &P, &m, &P, NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_gen_keypair( NULL,
- &m, &P,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_gen_keypair( &grp,
- NULL, &P,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_gen_keypair( &grp,
- &m, NULL,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_gen_keypair( &grp,
- &m, &P,
- NULL,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_gen_keypair(NULL,
+ &m, &P,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_gen_keypair(&grp,
+ NULL, &P,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_gen_keypair(&grp,
+ &m, NULL,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_gen_keypair(&grp,
+ &m, &P,
+ NULL,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_gen_key( valid_group, NULL,
- mbedtls_test_rnd_std_rand,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
- mbedtls_ecp_gen_key( valid_group, &kp,
- NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_gen_key(valid_group, NULL,
+ mbedtls_test_rnd_std_rand,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_ECP_BAD_INPUT_DATA,
+ mbedtls_ecp_gen_key(valid_group, &kp,
+ NULL, NULL));
exit:
return;
@@ -414,55 +429,55 @@
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_ecp_curve_info( int id, int tls_id, int size, char * name )
+void mbedtls_ecp_curve_info(int id, int tls_id, int size, char *name)
{
const mbedtls_ecp_curve_info *by_id, *by_tls, *by_name;
- by_id = mbedtls_ecp_curve_info_from_grp_id( id );
- by_tls = mbedtls_ecp_curve_info_from_tls_id( tls_id );
- by_name = mbedtls_ecp_curve_info_from_name( name );
- TEST_ASSERT( by_id != NULL );
- TEST_ASSERT( by_tls != NULL );
- TEST_ASSERT( by_name != NULL );
+ by_id = mbedtls_ecp_curve_info_from_grp_id(id);
+ by_tls = mbedtls_ecp_curve_info_from_tls_id(tls_id);
+ by_name = mbedtls_ecp_curve_info_from_name(name);
+ TEST_ASSERT(by_id != NULL);
+ TEST_ASSERT(by_tls != NULL);
+ TEST_ASSERT(by_name != NULL);
- TEST_ASSERT( by_id == by_tls );
- TEST_ASSERT( by_id == by_name );
+ TEST_ASSERT(by_id == by_tls);
+ TEST_ASSERT(by_id == by_name);
- TEST_ASSERT( by_id->bit_size == size );
- TEST_ASSERT( size <= MBEDTLS_ECP_MAX_BITS );
- TEST_ASSERT( size <= MBEDTLS_ECP_MAX_BYTES * 8 );
+ TEST_ASSERT(by_id->bit_size == size);
+ TEST_ASSERT(size <= MBEDTLS_ECP_MAX_BITS);
+ TEST_ASSERT(size <= MBEDTLS_ECP_MAX_BYTES * 8);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecp_check_pub( int grp_id, char * x_hex, char * y_hex, char * z_hex,
- int ret )
+void ecp_check_pub(int grp_id, char *x_hex, char *y_hex, char *z_hex,
+ int ret)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point P;
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_point_init( &P );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_point_init(&P);
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, grp_id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, grp_id) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &P.X, x_hex ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &P.Y, y_hex ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &P.Z, z_hex ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&P.X, x_hex) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&P.Y, y_hex) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&P.Z, z_hex) == 0);
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &grp, &P ) == ret );
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&grp, &P) == ret);
exit:
- mbedtls_ecp_group_free( &grp );
- mbedtls_ecp_point_free( &P );
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_ecp_point_free(&P);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECP_RESTARTABLE */
-void ecp_test_vect_restart( int id,
- char *dA_str, char *xA_str, char *yA_str,
- char *dB_str, char *xZ_str, char *yZ_str,
- int max_ops, int min_restarts, int max_restarts )
+void ecp_test_vect_restart(int id,
+ char *dA_str, char *xA_str, char *yA_str,
+ char *dB_str, char *xZ_str, char *yZ_str,
+ int max_ops, int min_restarts, int max_restarts)
{
/*
* Test for early restart. Based on test vectors like ecp_test_vect(),
@@ -489,75 +504,74 @@
int cnt_restarts;
int ret;
- mbedtls_ecp_restart_init( &ctx );
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_point_init( &R ); mbedtls_ecp_point_init( &P );
- mbedtls_mpi_init( &dA ); mbedtls_mpi_init( &xA ); mbedtls_mpi_init( &yA );
- mbedtls_mpi_init( &dB ); mbedtls_mpi_init( &xZ ); mbedtls_mpi_init( &yZ );
+ mbedtls_ecp_restart_init(&ctx);
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_point_init(&R); mbedtls_ecp_point_init(&P);
+ mbedtls_mpi_init(&dA); mbedtls_mpi_init(&xA); mbedtls_mpi_init(&yA);
+ mbedtls_mpi_init(&dB); mbedtls_mpi_init(&xZ); mbedtls_mpi_init(&yZ);
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &dA, dA_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &xA, xA_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &yA, yA_str ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&dA, dA_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&xA, xA_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&yA, yA_str) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &dB, dB_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &xZ, xZ_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &yZ, yZ_str ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&dB, dB_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&xZ, xZ_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&yZ, yZ_str) == 0);
- mbedtls_ecp_set_max_ops( (unsigned) max_ops );
+ mbedtls_ecp_set_max_ops((unsigned) max_ops);
/* Base point case */
cnt_restarts = 0;
do {
- ECP_PT_RESET( &R );
- ret = mbedtls_ecp_mul_restartable( &grp, &R, &dA, &grp.G, NULL, NULL, &ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restarts );
+ ECP_PT_RESET(&R);
+ ret = mbedtls_ecp_mul_restartable(&grp, &R, &dA, &grp.G, NULL, NULL, &ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restarts);
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.X, &xA ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.Y, &yA ) == 0 );
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.X, &xA) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.Y, &yA) == 0);
- TEST_ASSERT( cnt_restarts >= min_restarts );
- TEST_ASSERT( cnt_restarts <= max_restarts );
+ TEST_ASSERT(cnt_restarts >= min_restarts);
+ TEST_ASSERT(cnt_restarts <= max_restarts);
/* Non-base point case */
- mbedtls_ecp_copy( &P, &R );
+ mbedtls_ecp_copy(&P, &R);
cnt_restarts = 0;
do {
- ECP_PT_RESET( &R );
- ret = mbedtls_ecp_mul_restartable( &grp, &R, &dB, &P, NULL, NULL, &ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restarts );
+ ECP_PT_RESET(&R);
+ ret = mbedtls_ecp_mul_restartable(&grp, &R, &dB, &P, NULL, NULL, &ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restarts);
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.X, &xZ ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.Y, &yZ ) == 0 );
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.X, &xZ) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.Y, &yZ) == 0);
- TEST_ASSERT( cnt_restarts >= min_restarts );
- TEST_ASSERT( cnt_restarts <= max_restarts );
+ TEST_ASSERT(cnt_restarts >= min_restarts);
+ TEST_ASSERT(cnt_restarts <= max_restarts);
/* Do we leak memory when aborting an operation?
* This test only makes sense when we actually restart */
- if( min_restarts > 0 )
- {
- ret = mbedtls_ecp_mul_restartable( &grp, &R, &dB, &P, NULL, NULL, &ctx );
- TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
+ if (min_restarts > 0) {
+ ret = mbedtls_ecp_mul_restartable(&grp, &R, &dB, &P, NULL, NULL, &ctx);
+ TEST_ASSERT(ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
}
exit:
- mbedtls_ecp_restart_free( &ctx );
- mbedtls_ecp_group_free( &grp );
- mbedtls_ecp_point_free( &R ); mbedtls_ecp_point_free( &P );
- mbedtls_mpi_free( &dA ); mbedtls_mpi_free( &xA ); mbedtls_mpi_free( &yA );
- mbedtls_mpi_free( &dB ); mbedtls_mpi_free( &xZ ); mbedtls_mpi_free( &yZ );
+ mbedtls_ecp_restart_free(&ctx);
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_ecp_point_free(&R); mbedtls_ecp_point_free(&P);
+ mbedtls_mpi_free(&dA); mbedtls_mpi_free(&xA); mbedtls_mpi_free(&yA);
+ mbedtls_mpi_free(&dB); mbedtls_mpi_free(&xZ); mbedtls_mpi_free(&yZ);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECP_RESTARTABLE:MBEDTLS_ECP_SHORT_WEIERSTRASS_ENABLED */
-void ecp_muladd_restart( int id, char *xR_str, char *yR_str,
- char *u1_str, char *u2_str,
- char *xQ_str, char *yQ_str,
- int max_ops, int min_restarts, int max_restarts )
+void ecp_muladd_restart(int id, char *xR_str, char *yR_str,
+ char *u1_str, char *u2_str,
+ char *xQ_str, char *yQ_str,
+ int max_ops, int min_restarts, int max_restarts)
{
/*
* Compute R = u1 * G + u2 * Q
@@ -572,246 +586,244 @@
int cnt_restarts;
int ret;
- mbedtls_ecp_restart_init( &ctx );
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_point_init( &R );
- mbedtls_ecp_point_init( &Q );
- mbedtls_mpi_init( &u1 ); mbedtls_mpi_init( &u2 );
- mbedtls_mpi_init( &xR ); mbedtls_mpi_init( &yR );
+ mbedtls_ecp_restart_init(&ctx);
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_point_init(&R);
+ mbedtls_ecp_point_init(&Q);
+ mbedtls_mpi_init(&u1); mbedtls_mpi_init(&u2);
+ mbedtls_mpi_init(&xR); mbedtls_mpi_init(&yR);
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &u1, u1_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &u2, u2_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &xR, xR_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &yR, yR_str ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&u1, u1_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&u2, u2_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&xR, xR_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&yR, yR_str) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &Q.X, xQ_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Q.Y, yQ_str ) == 0 );
- TEST_ASSERT( mbedtls_mpi_lset( &Q.Z, 1 ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&Q.X, xQ_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Q.Y, yQ_str) == 0);
+ TEST_ASSERT(mbedtls_mpi_lset(&Q.Z, 1) == 0);
- mbedtls_ecp_set_max_ops( (unsigned) max_ops );
+ mbedtls_ecp_set_max_ops((unsigned) max_ops);
cnt_restarts = 0;
do {
- ECP_PT_RESET( &R );
- ret = mbedtls_ecp_muladd_restartable( &grp, &R,
- &u1, &grp.G, &u2, &Q, &ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restarts );
+ ECP_PT_RESET(&R);
+ ret = mbedtls_ecp_muladd_restartable(&grp, &R,
+ &u1, &grp.G, &u2, &Q, &ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restarts);
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.X, &xR ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.Y, &yR ) == 0 );
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.X, &xR) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.Y, &yR) == 0);
- TEST_ASSERT( cnt_restarts >= min_restarts );
- TEST_ASSERT( cnt_restarts <= max_restarts );
+ TEST_ASSERT(cnt_restarts >= min_restarts);
+ TEST_ASSERT(cnt_restarts <= max_restarts);
/* Do we leak memory when aborting an operation?
* This test only makes sense when we actually restart */
- if( min_restarts > 0 )
- {
- ret = mbedtls_ecp_muladd_restartable( &grp, &R,
- &u1, &grp.G, &u2, &Q, &ctx );
- TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
+ if (min_restarts > 0) {
+ ret = mbedtls_ecp_muladd_restartable(&grp, &R,
+ &u1, &grp.G, &u2, &Q, &ctx);
+ TEST_ASSERT(ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
}
exit:
- mbedtls_ecp_restart_free( &ctx );
- mbedtls_ecp_group_free( &grp );
- mbedtls_ecp_point_free( &R );
- mbedtls_ecp_point_free( &Q );
- mbedtls_mpi_free( &u1 ); mbedtls_mpi_free( &u2 );
- mbedtls_mpi_free( &xR ); mbedtls_mpi_free( &yR );
+ mbedtls_ecp_restart_free(&ctx);
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_ecp_point_free(&R);
+ mbedtls_ecp_point_free(&Q);
+ mbedtls_mpi_free(&u1); mbedtls_mpi_free(&u2);
+ mbedtls_mpi_free(&xR); mbedtls_mpi_free(&yR);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecp_test_vect( int id, char * dA_str, char * xA_str, char * yA_str,
- char * dB_str, char * xB_str, char * yB_str,
- char * xZ_str, char * yZ_str )
+void ecp_test_vect(int id, char *dA_str, char *xA_str, char *yA_str,
+ char *dB_str, char *xB_str, char *yB_str,
+ char *xZ_str, char *yZ_str)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point R;
mbedtls_mpi dA, xA, yA, dB, xB, yB, xZ, yZ;
mbedtls_test_rnd_pseudo_info rnd_info;
- mbedtls_ecp_group_init( &grp ); mbedtls_ecp_point_init( &R );
- mbedtls_mpi_init( &dA ); mbedtls_mpi_init( &xA ); mbedtls_mpi_init( &yA ); mbedtls_mpi_init( &dB );
- mbedtls_mpi_init( &xB ); mbedtls_mpi_init( &yB ); mbedtls_mpi_init( &xZ ); mbedtls_mpi_init( &yZ );
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ mbedtls_ecp_group_init(&grp); mbedtls_ecp_point_init(&R);
+ mbedtls_mpi_init(&dA); mbedtls_mpi_init(&xA); mbedtls_mpi_init(&yA); mbedtls_mpi_init(&dB);
+ mbedtls_mpi_init(&xB); mbedtls_mpi_init(&yB); mbedtls_mpi_init(&xZ); mbedtls_mpi_init(&yZ);
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &grp, &grp.G ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&grp, &grp.G) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &dA, dA_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &xA, xA_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &yA, yA_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &dB, dB_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &xB, xB_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &yB, yB_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &xZ, xZ_str ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &yZ, yZ_str ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&dA, dA_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&xA, xA_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&yA, yA_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&dB, dB_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&xB, xB_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&yB, yB_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&xZ, xZ_str) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&yZ, yZ_str) == 0);
- TEST_ASSERT( mbedtls_ecp_mul( &grp, &R, &dA, &grp.G,
- &mbedtls_test_rnd_pseudo_rand, &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.X, &xA ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.Y, &yA ) == 0 );
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &grp, &R ) == 0 );
- TEST_ASSERT( mbedtls_ecp_mul( &grp, &R, &dB, &R, NULL, NULL ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.X, &xZ ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.Y, &yZ ) == 0 );
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &grp, &R ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_mul(&grp, &R, &dA, &grp.G,
+ &mbedtls_test_rnd_pseudo_rand, &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.X, &xA) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.Y, &yA) == 0);
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&grp, &R) == 0);
+ TEST_ASSERT(mbedtls_ecp_mul(&grp, &R, &dB, &R, NULL, NULL) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.X, &xZ) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.Y, &yZ) == 0);
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&grp, &R) == 0);
- TEST_ASSERT( mbedtls_ecp_mul( &grp, &R, &dB, &grp.G, NULL, NULL ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.X, &xB ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.Y, &yB ) == 0 );
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &grp, &R ) == 0 );
- TEST_ASSERT( mbedtls_ecp_mul( &grp, &R, &dA, &R,
- &mbedtls_test_rnd_pseudo_rand, &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.X, &xZ ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.Y, &yZ ) == 0 );
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &grp, &R ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_mul(&grp, &R, &dB, &grp.G, NULL, NULL) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.X, &xB) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.Y, &yB) == 0);
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&grp, &R) == 0);
+ TEST_ASSERT(mbedtls_ecp_mul(&grp, &R, &dA, &R,
+ &mbedtls_test_rnd_pseudo_rand, &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.X, &xZ) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.Y, &yZ) == 0);
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&grp, &R) == 0);
exit:
- mbedtls_ecp_group_free( &grp ); mbedtls_ecp_point_free( &R );
- mbedtls_mpi_free( &dA ); mbedtls_mpi_free( &xA ); mbedtls_mpi_free( &yA ); mbedtls_mpi_free( &dB );
- mbedtls_mpi_free( &xB ); mbedtls_mpi_free( &yB ); mbedtls_mpi_free( &xZ ); mbedtls_mpi_free( &yZ );
+ mbedtls_ecp_group_free(&grp); mbedtls_ecp_point_free(&R);
+ mbedtls_mpi_free(&dA); mbedtls_mpi_free(&xA); mbedtls_mpi_free(&yA); mbedtls_mpi_free(&dB);
+ mbedtls_mpi_free(&xB); mbedtls_mpi_free(&yB); mbedtls_mpi_free(&xZ); mbedtls_mpi_free(&yZ);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecp_test_vec_x( int id, char * dA_hex, char * xA_hex, char * dB_hex,
- char * xB_hex, char * xS_hex )
+void ecp_test_vec_x(int id, char *dA_hex, char *xA_hex, char *dB_hex,
+ char *xB_hex, char *xS_hex)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point R;
mbedtls_mpi dA, xA, dB, xB, xS;
mbedtls_test_rnd_pseudo_info rnd_info;
- mbedtls_ecp_group_init( &grp ); mbedtls_ecp_point_init( &R );
- mbedtls_mpi_init( &dA ); mbedtls_mpi_init( &xA );
- mbedtls_mpi_init( &dB ); mbedtls_mpi_init( &xB );
- mbedtls_mpi_init( &xS );
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ mbedtls_ecp_group_init(&grp); mbedtls_ecp_point_init(&R);
+ mbedtls_mpi_init(&dA); mbedtls_mpi_init(&xA);
+ mbedtls_mpi_init(&dB); mbedtls_mpi_init(&xB);
+ mbedtls_mpi_init(&xS);
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &grp, &grp.G ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&grp, &grp.G) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &dA, dA_hex ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &dB, dB_hex ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &xA, xA_hex ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &xB, xB_hex ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &xS, xS_hex ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&dA, dA_hex) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&dB, dB_hex) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&xA, xA_hex) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&xB, xB_hex) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&xS, xS_hex) == 0);
- TEST_ASSERT( mbedtls_ecp_mul( &grp, &R, &dA, &grp.G,
- &mbedtls_test_rnd_pseudo_rand, &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &grp, &R ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.X, &xA ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_mul(&grp, &R, &dA, &grp.G,
+ &mbedtls_test_rnd_pseudo_rand, &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&grp, &R) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.X, &xA) == 0);
- TEST_ASSERT( mbedtls_ecp_mul( &grp, &R, &dB, &R,
- &mbedtls_test_rnd_pseudo_rand, &rnd_info ) == 0 );
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &grp, &R ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.X, &xS ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_mul(&grp, &R, &dB, &R,
+ &mbedtls_test_rnd_pseudo_rand, &rnd_info) == 0);
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&grp, &R) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.X, &xS) == 0);
- TEST_ASSERT( mbedtls_ecp_mul( &grp, &R, &dB, &grp.G, NULL, NULL ) == 0 );
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &grp, &R ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.X, &xB ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_mul(&grp, &R, &dB, &grp.G, NULL, NULL) == 0);
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&grp, &R) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.X, &xB) == 0);
- TEST_ASSERT( mbedtls_ecp_mul( &grp, &R, &dA, &R, NULL, NULL ) == 0 );
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &grp, &R ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R.X, &xS ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_mul(&grp, &R, &dA, &R, NULL, NULL) == 0);
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&grp, &R) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R.X, &xS) == 0);
exit:
- mbedtls_ecp_group_free( &grp ); mbedtls_ecp_point_free( &R );
- mbedtls_mpi_free( &dA ); mbedtls_mpi_free( &xA );
- mbedtls_mpi_free( &dB ); mbedtls_mpi_free( &xB );
- mbedtls_mpi_free( &xS );
+ mbedtls_ecp_group_free(&grp); mbedtls_ecp_point_free(&R);
+ mbedtls_mpi_free(&dA); mbedtls_mpi_free(&xA);
+ mbedtls_mpi_free(&dB); mbedtls_mpi_free(&xB);
+ mbedtls_mpi_free(&xS);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecp_test_mul( int id, data_t * n_hex,
- data_t * Px_hex, data_t * Py_hex, data_t * Pz_hex,
- data_t * nPx_hex, data_t * nPy_hex, data_t * nPz_hex,
- int expected_ret )
+void ecp_test_mul(int id, data_t *n_hex,
+ data_t *Px_hex, data_t *Py_hex, data_t *Pz_hex,
+ data_t *nPx_hex, data_t *nPy_hex, data_t *nPz_hex,
+ int expected_ret)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point P, nP, R;
mbedtls_mpi n;
mbedtls_test_rnd_pseudo_info rnd_info;
- mbedtls_ecp_group_init( &grp ); mbedtls_ecp_point_init( &R );
- mbedtls_ecp_point_init( &P ); mbedtls_ecp_point_init( &nP );
- mbedtls_mpi_init( &n );
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ mbedtls_ecp_group_init(&grp); mbedtls_ecp_point_init(&R);
+ mbedtls_ecp_point_init(&P); mbedtls_ecp_point_init(&nP);
+ mbedtls_mpi_init(&n);
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &grp, &grp.G ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&grp, &grp.G) == 0);
- TEST_ASSERT( mbedtls_mpi_read_binary( &n, n_hex->x, n_hex->len ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_read_binary(&n, n_hex->x, n_hex->len) == 0);
- TEST_ASSERT( mbedtls_mpi_read_binary( &P.X, Px_hex->x, Px_hex->len ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &P.Y, Py_hex->x, Py_hex->len ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &P.Z, Pz_hex->x, Pz_hex->len ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &nP.X, nPx_hex->x, nPx_hex->len )
- == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &nP.Y, nPy_hex->x, nPy_hex->len )
- == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &nP.Z, nPz_hex->x, nPz_hex->len )
- == 0 );
+ TEST_ASSERT(mbedtls_mpi_read_binary(&P.X, Px_hex->x, Px_hex->len) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&P.Y, Py_hex->x, Py_hex->len) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&P.Z, Pz_hex->x, Pz_hex->len) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&nP.X, nPx_hex->x, nPx_hex->len)
+ == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&nP.Y, nPy_hex->x, nPy_hex->len)
+ == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&nP.Z, nPz_hex->x, nPz_hex->len)
+ == 0);
- TEST_ASSERT( mbedtls_ecp_mul( &grp, &R, &n, &P,
- &mbedtls_test_rnd_pseudo_rand, &rnd_info )
- == expected_ret );
+ TEST_ASSERT(mbedtls_ecp_mul(&grp, &R, &n, &P,
+ &mbedtls_test_rnd_pseudo_rand, &rnd_info)
+ == expected_ret);
- if( expected_ret == 0 )
- {
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &nP.X, &R.X ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &nP.Y, &R.Y ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &nP.Z, &R.Z ) == 0 );
+ if (expected_ret == 0) {
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&nP.X, &R.X) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&nP.Y, &R.Y) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&nP.Z, &R.Z) == 0);
}
exit:
- mbedtls_ecp_group_free( &grp ); mbedtls_ecp_point_free( &R );
- mbedtls_ecp_point_free( &P ); mbedtls_ecp_point_free( &nP );
- mbedtls_mpi_free( &n );
+ mbedtls_ecp_group_free(&grp); mbedtls_ecp_point_free(&R);
+ mbedtls_ecp_point_free(&P); mbedtls_ecp_point_free(&nP);
+ mbedtls_mpi_free(&n);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecp_test_mul_rng( int id, data_t * d_hex)
+void ecp_test_mul_rng(int id, data_t *d_hex)
{
mbedtls_ecp_group grp;
mbedtls_mpi d;
mbedtls_ecp_point Q;
- mbedtls_ecp_group_init( &grp ); mbedtls_mpi_init( &d );
- mbedtls_ecp_point_init( &Q );
+ mbedtls_ecp_group_init(&grp); mbedtls_mpi_init(&d);
+ mbedtls_ecp_point_init(&Q);
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &grp, &grp.G ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&grp, &grp.G) == 0);
- TEST_ASSERT( mbedtls_mpi_read_binary( &d, d_hex->x, d_hex->len ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_read_binary(&d, d_hex->x, d_hex->len) == 0);
- TEST_ASSERT( mbedtls_ecp_mul( &grp, &Q, &d, &grp.G,
- &mbedtls_test_rnd_zero_rand, NULL )
- == MBEDTLS_ERR_ECP_RANDOM_FAILED );
+ TEST_ASSERT(mbedtls_ecp_mul(&grp, &Q, &d, &grp.G,
+ &mbedtls_test_rnd_zero_rand, NULL)
+ == MBEDTLS_ERR_ECP_RANDOM_FAILED);
exit:
- mbedtls_ecp_group_free( &grp ); mbedtls_mpi_free( &d );
- mbedtls_ecp_point_free( &Q );
+ mbedtls_ecp_group_free(&grp); mbedtls_mpi_free(&d);
+ mbedtls_ecp_point_free(&Q);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECP_SHORT_WEIERSTRASS_ENABLED */
-void ecp_muladd( int id,
- data_t *u1_bin, data_t *P1_bin,
- data_t *u2_bin, data_t *P2_bin,
- data_t *expected_result )
+void ecp_muladd(int id,
+ data_t *u1_bin, data_t *P1_bin,
+ data_t *u2_bin, data_t *P2_bin,
+ data_t *expected_result)
{
/* Compute R = u1 * P1 + u2 * P2 */
mbedtls_ecp_group grp;
@@ -820,152 +832,147 @@
uint8_t actual_result[MBEDTLS_ECP_MAX_PT_LEN];
size_t len;
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_point_init( &P1 );
- mbedtls_ecp_point_init( &P2 );
- mbedtls_ecp_point_init( &R );
- mbedtls_mpi_init( &u1 );
- mbedtls_mpi_init( &u2 );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_point_init(&P1);
+ mbedtls_ecp_point_init(&P2);
+ mbedtls_ecp_point_init(&R);
+ mbedtls_mpi_init(&u1);
+ mbedtls_mpi_init(&u2);
- TEST_EQUAL( 0, mbedtls_ecp_group_load( &grp, id ) );
- TEST_EQUAL( 0, mbedtls_mpi_read_binary( &u1, u1_bin->x, u1_bin->len ) );
- TEST_EQUAL( 0, mbedtls_mpi_read_binary( &u2, u2_bin->x, u2_bin->len ) );
- TEST_EQUAL( 0, mbedtls_ecp_point_read_binary( &grp, &P1,
- P1_bin->x, P1_bin->len ) );
- TEST_EQUAL( 0, mbedtls_ecp_point_read_binary( &grp, &P2,
- P2_bin->x, P2_bin->len ) );
+ TEST_EQUAL(0, mbedtls_ecp_group_load(&grp, id));
+ TEST_EQUAL(0, mbedtls_mpi_read_binary(&u1, u1_bin->x, u1_bin->len));
+ TEST_EQUAL(0, mbedtls_mpi_read_binary(&u2, u2_bin->x, u2_bin->len));
+ TEST_EQUAL(0, mbedtls_ecp_point_read_binary(&grp, &P1,
+ P1_bin->x, P1_bin->len));
+ TEST_EQUAL(0, mbedtls_ecp_point_read_binary(&grp, &P2,
+ P2_bin->x, P2_bin->len));
- TEST_EQUAL( 0, mbedtls_ecp_muladd( &grp, &R, &u1, &P1, &u2, &P2 ) );
- TEST_EQUAL( 0, mbedtls_ecp_point_write_binary(
- &grp, &R, MBEDTLS_ECP_PF_UNCOMPRESSED,
- &len, actual_result, sizeof( actual_result ) ) );
- TEST_ASSERT( len <= MBEDTLS_ECP_MAX_PT_LEN );
+ TEST_EQUAL(0, mbedtls_ecp_muladd(&grp, &R, &u1, &P1, &u2, &P2));
+ TEST_EQUAL(0, mbedtls_ecp_point_write_binary(
+ &grp, &R, MBEDTLS_ECP_PF_UNCOMPRESSED,
+ &len, actual_result, sizeof(actual_result)));
+ TEST_ASSERT(len <= MBEDTLS_ECP_MAX_PT_LEN);
- ASSERT_COMPARE( expected_result->x, expected_result->len,
- actual_result, len );
+ ASSERT_COMPARE(expected_result->x, expected_result->len,
+ actual_result, len);
exit:
- mbedtls_ecp_group_free( &grp );
- mbedtls_ecp_point_free( &P1 );
- mbedtls_ecp_point_free( &P2 );
- mbedtls_ecp_point_free( &R );
- mbedtls_mpi_free( &u1 );
- mbedtls_mpi_free( &u2 );
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_ecp_point_free(&P1);
+ mbedtls_ecp_point_free(&P2);
+ mbedtls_ecp_point_free(&R);
+ mbedtls_mpi_free(&u1);
+ mbedtls_mpi_free(&u2);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecp_fast_mod( int id, char * N_str )
+void ecp_fast_mod(int id, char *N_str)
{
mbedtls_ecp_group grp;
mbedtls_mpi N, R;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &R );
- mbedtls_ecp_group_init( &grp );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&R);
+ mbedtls_ecp_group_init(&grp);
- TEST_ASSERT( mbedtls_test_read_mpi( &N, N_str ) == 0 );
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
- TEST_ASSERT( grp.modp != NULL );
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, N_str) == 0);
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
+ TEST_ASSERT(grp.modp != NULL);
/*
* Store correct result before we touch N
*/
- TEST_ASSERT( mbedtls_mpi_mod_mpi( &R, &N, &grp.P ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_mod_mpi(&R, &N, &grp.P) == 0);
- TEST_ASSERT( grp.modp( &N ) == 0 );
- TEST_ASSERT( mbedtls_mpi_bitlen( &N ) <= grp.pbits + 3 );
+ TEST_ASSERT(grp.modp(&N) == 0);
+ TEST_ASSERT(mbedtls_mpi_bitlen(&N) <= grp.pbits + 3);
/*
* Use mod rather than addition/subtraction in case previous test fails
*/
- TEST_ASSERT( mbedtls_mpi_mod_mpi( &N, &N, &grp.P ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &N, &R ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_mod_mpi(&N, &N, &grp.P) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&N, &R) == 0);
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &R );
- mbedtls_ecp_group_free( &grp );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&R);
+ mbedtls_ecp_group_free(&grp);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecp_write_binary( int id, char * x, char * y, char * z, int format,
- data_t * out, int blen, int ret )
+void ecp_write_binary(int id, char *x, char *y, char *z, int format,
+ data_t *out, int blen, int ret)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point P;
unsigned char buf[256];
size_t olen;
- memset( buf, 0, sizeof( buf ) );
+ memset(buf, 0, sizeof(buf));
- mbedtls_ecp_group_init( &grp ); mbedtls_ecp_point_init( &P );
+ mbedtls_ecp_group_init(&grp); mbedtls_ecp_point_init(&P);
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &P.X, x ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &P.Y, y ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &P.Z, z ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&P.X, x) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&P.Y, y) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&P.Z, z) == 0);
- TEST_ASSERT( mbedtls_ecp_point_write_binary( &grp, &P, format,
- &olen, buf, blen ) == ret );
+ TEST_ASSERT(mbedtls_ecp_point_write_binary(&grp, &P, format,
+ &olen, buf, blen) == ret);
- if( ret == 0 )
- {
- TEST_ASSERT( olen <= MBEDTLS_ECP_MAX_PT_LEN );
- TEST_ASSERT( mbedtls_test_hexcmp( buf, out->x, olen, out->len ) == 0 );
+ if (ret == 0) {
+ TEST_ASSERT(olen <= MBEDTLS_ECP_MAX_PT_LEN);
+ TEST_ASSERT(mbedtls_test_hexcmp(buf, out->x, olen, out->len) == 0);
}
exit:
- mbedtls_ecp_group_free( &grp ); mbedtls_ecp_point_free( &P );
+ mbedtls_ecp_group_free(&grp); mbedtls_ecp_point_free(&P);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecp_read_binary( int id, data_t * buf, char * x, char * y, char * z,
- int ret )
+void ecp_read_binary(int id, data_t *buf, char *x, char *y, char *z,
+ int ret)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point P;
mbedtls_mpi X, Y, Z;
- mbedtls_ecp_group_init( &grp ); mbedtls_ecp_point_init( &P );
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z );
+ mbedtls_ecp_group_init(&grp); mbedtls_ecp_point_init(&P);
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y); mbedtls_mpi_init(&Z);
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, x ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, y ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Z, z ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, x) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, y) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Z, z) == 0);
- TEST_ASSERT( mbedtls_ecp_point_read_binary( &grp, &P, buf->x, buf->len ) == ret );
+ TEST_ASSERT(mbedtls_ecp_point_read_binary(&grp, &P, buf->x, buf->len) == ret);
- if( ret == 0 )
- {
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &P.X, &X ) == 0 );
- if( mbedtls_ecp_get_type( &grp ) == MBEDTLS_ECP_TYPE_MONTGOMERY )
- {
- TEST_ASSERT( mbedtls_mpi_cmp_int( &Y, 0 ) == 0 );
- TEST_ASSERT( P.Y.p == NULL );
- TEST_ASSERT( mbedtls_mpi_cmp_int( &Z, 1 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_int( &P.Z, 1 ) == 0 );
- }
- else
- {
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &P.Y, &Y ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &P.Z, &Z ) == 0 );
+ if (ret == 0) {
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&P.X, &X) == 0);
+ if (mbedtls_ecp_get_type(&grp) == MBEDTLS_ECP_TYPE_MONTGOMERY) {
+ TEST_ASSERT(mbedtls_mpi_cmp_int(&Y, 0) == 0);
+ TEST_ASSERT(P.Y.p == NULL);
+ TEST_ASSERT(mbedtls_mpi_cmp_int(&Z, 1) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_int(&P.Z, 1) == 0);
+ } else {
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&P.Y, &Y) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&P.Z, &Z) == 0);
}
}
exit:
- mbedtls_ecp_group_free( &grp ); mbedtls_ecp_point_free( &P );
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z );
+ mbedtls_ecp_group_free(&grp); mbedtls_ecp_point_free(&P);
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y); mbedtls_mpi_free(&Z);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_ecp_tls_read_point( int id, data_t * buf, char * x, char * y,
- char * z, int ret )
+void mbedtls_ecp_tls_read_point(int id, data_t *buf, char *x, char *y,
+ char *z, int ret)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point P;
@@ -973,33 +980,32 @@
const unsigned char *vbuf = buf->x;
- mbedtls_ecp_group_init( &grp ); mbedtls_ecp_point_init( &P );
- mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z );
+ mbedtls_ecp_group_init(&grp); mbedtls_ecp_point_init(&P);
+ mbedtls_mpi_init(&X); mbedtls_mpi_init(&Y); mbedtls_mpi_init(&Z);
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
- TEST_ASSERT( mbedtls_test_read_mpi( &X, x ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Y, y ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Z, z ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&X, x) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Y, y) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Z, z) == 0);
- TEST_ASSERT( mbedtls_ecp_tls_read_point( &grp, &P, &vbuf, buf->len ) == ret );
+ TEST_ASSERT(mbedtls_ecp_tls_read_point(&grp, &P, &vbuf, buf->len) == ret);
- if( ret == 0 )
- {
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &P.X, &X ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &P.Y, &Y ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &P.Z, &Z ) == 0 );
- TEST_ASSERT( (uint32_t)( vbuf - buf->x ) == buf->len );
+ if (ret == 0) {
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&P.X, &X) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&P.Y, &Y) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&P.Z, &Z) == 0);
+ TEST_ASSERT((uint32_t) (vbuf - buf->x) == buf->len);
}
exit:
- mbedtls_ecp_group_free( &grp ); mbedtls_ecp_point_free( &P );
- mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z );
+ mbedtls_ecp_group_free(&grp); mbedtls_ecp_point_free(&P);
+ mbedtls_mpi_free(&X); mbedtls_mpi_free(&Y); mbedtls_mpi_free(&Z);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecp_tls_write_read_point( int id )
+void ecp_tls_write_read_point(int id)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point pt;
@@ -1007,75 +1013,74 @@
const unsigned char *vbuf;
size_t olen;
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_point_init( &pt );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_point_init(&pt);
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
- memset( buf, 0x00, sizeof( buf ) ); vbuf = buf;
- TEST_ASSERT( mbedtls_ecp_tls_write_point( &grp, &grp.G,
- MBEDTLS_ECP_PF_COMPRESSED, &olen, buf, 256 ) == 0 );
- TEST_ASSERT( mbedtls_ecp_tls_read_point( &grp, &pt, &vbuf, olen )
- == MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE );
- TEST_ASSERT( vbuf == buf + olen );
+ memset(buf, 0x00, sizeof(buf)); vbuf = buf;
+ TEST_ASSERT(mbedtls_ecp_tls_write_point(&grp, &grp.G,
+ MBEDTLS_ECP_PF_COMPRESSED, &olen, buf, 256) == 0);
+ TEST_ASSERT(mbedtls_ecp_tls_read_point(&grp, &pt, &vbuf, olen)
+ == MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE);
+ TEST_ASSERT(vbuf == buf + olen);
- memset( buf, 0x00, sizeof( buf ) ); vbuf = buf;
- TEST_ASSERT( mbedtls_ecp_tls_write_point( &grp, &grp.G,
- MBEDTLS_ECP_PF_UNCOMPRESSED, &olen, buf, 256 ) == 0 );
- TEST_ASSERT( mbedtls_ecp_tls_read_point( &grp, &pt, &vbuf, olen ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &grp.G.X, &pt.X ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &grp.G.Y, &pt.Y ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &grp.G.Z, &pt.Z ) == 0 );
- TEST_ASSERT( vbuf == buf + olen );
+ memset(buf, 0x00, sizeof(buf)); vbuf = buf;
+ TEST_ASSERT(mbedtls_ecp_tls_write_point(&grp, &grp.G,
+ MBEDTLS_ECP_PF_UNCOMPRESSED, &olen, buf, 256) == 0);
+ TEST_ASSERT(mbedtls_ecp_tls_read_point(&grp, &pt, &vbuf, olen) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&grp.G.X, &pt.X) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&grp.G.Y, &pt.Y) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&grp.G.Z, &pt.Z) == 0);
+ TEST_ASSERT(vbuf == buf + olen);
- memset( buf, 0x00, sizeof( buf ) ); vbuf = buf;
- TEST_ASSERT( mbedtls_ecp_set_zero( &pt ) == 0 );
- TEST_ASSERT( mbedtls_ecp_tls_write_point( &grp, &pt,
- MBEDTLS_ECP_PF_COMPRESSED, &olen, buf, 256 ) == 0 );
- TEST_ASSERT( mbedtls_ecp_tls_read_point( &grp, &pt, &vbuf, olen ) == 0 );
- TEST_ASSERT( mbedtls_ecp_is_zero( &pt ) );
- TEST_ASSERT( vbuf == buf + olen );
+ memset(buf, 0x00, sizeof(buf)); vbuf = buf;
+ TEST_ASSERT(mbedtls_ecp_set_zero(&pt) == 0);
+ TEST_ASSERT(mbedtls_ecp_tls_write_point(&grp, &pt,
+ MBEDTLS_ECP_PF_COMPRESSED, &olen, buf, 256) == 0);
+ TEST_ASSERT(mbedtls_ecp_tls_read_point(&grp, &pt, &vbuf, olen) == 0);
+ TEST_ASSERT(mbedtls_ecp_is_zero(&pt));
+ TEST_ASSERT(vbuf == buf + olen);
- memset( buf, 0x00, sizeof( buf ) ); vbuf = buf;
- TEST_ASSERT( mbedtls_ecp_set_zero( &pt ) == 0 );
- TEST_ASSERT( mbedtls_ecp_tls_write_point( &grp, &pt,
- MBEDTLS_ECP_PF_UNCOMPRESSED, &olen, buf, 256 ) == 0 );
- TEST_ASSERT( mbedtls_ecp_tls_read_point( &grp, &pt, &vbuf, olen ) == 0 );
- TEST_ASSERT( mbedtls_ecp_is_zero( &pt ) );
- TEST_ASSERT( vbuf == buf + olen );
+ memset(buf, 0x00, sizeof(buf)); vbuf = buf;
+ TEST_ASSERT(mbedtls_ecp_set_zero(&pt) == 0);
+ TEST_ASSERT(mbedtls_ecp_tls_write_point(&grp, &pt,
+ MBEDTLS_ECP_PF_UNCOMPRESSED, &olen, buf, 256) == 0);
+ TEST_ASSERT(mbedtls_ecp_tls_read_point(&grp, &pt, &vbuf, olen) == 0);
+ TEST_ASSERT(mbedtls_ecp_is_zero(&pt));
+ TEST_ASSERT(vbuf == buf + olen);
exit:
- mbedtls_ecp_group_free( &grp );
- mbedtls_ecp_point_free( &pt );
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_ecp_point_free(&pt);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_ecp_tls_read_group( data_t * buf, int result, int bits,
- int record_len )
+void mbedtls_ecp_tls_read_group(data_t *buf, int result, int bits,
+ int record_len)
{
mbedtls_ecp_group grp;
const unsigned char *vbuf = buf->x;
int ret;
- mbedtls_ecp_group_init( &grp );
+ mbedtls_ecp_group_init(&grp);
- ret = mbedtls_ecp_tls_read_group( &grp, &vbuf, buf->len );
+ ret = mbedtls_ecp_tls_read_group(&grp, &vbuf, buf->len);
- TEST_ASSERT( ret == result );
- if( ret == 0)
- {
- TEST_ASSERT( mbedtls_mpi_bitlen( &grp.P ) == (size_t) bits );
- TEST_ASSERT( vbuf - buf->x == record_len);
+ TEST_ASSERT(ret == result);
+ if (ret == 0) {
+ TEST_ASSERT(mbedtls_mpi_bitlen(&grp.P) == (size_t) bits);
+ TEST_ASSERT(vbuf - buf->x == record_len);
}
exit:
- mbedtls_ecp_group_free( &grp );
+ mbedtls_ecp_group_free(&grp);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecp_tls_write_read_group( int id )
+void ecp_tls_write_read_group(int id)
{
mbedtls_ecp_group grp1, grp2;
unsigned char buf[10];
@@ -1083,33 +1088,32 @@
size_t len;
int ret;
- mbedtls_ecp_group_init( &grp1 );
- mbedtls_ecp_group_init( &grp2 );
- memset( buf, 0x00, sizeof( buf ) );
+ mbedtls_ecp_group_init(&grp1);
+ mbedtls_ecp_group_init(&grp2);
+ memset(buf, 0x00, sizeof(buf));
- TEST_ASSERT( mbedtls_ecp_group_load( &grp1, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp1, id) == 0);
- TEST_ASSERT( mbedtls_ecp_tls_write_group( &grp1, &len, buf, 10 ) == 0 );
- ret = mbedtls_ecp_tls_read_group( &grp2, &vbuf, len );
- TEST_ASSERT( ret == 0 );
+ TEST_ASSERT(mbedtls_ecp_tls_write_group(&grp1, &len, buf, 10) == 0);
+ ret = mbedtls_ecp_tls_read_group(&grp2, &vbuf, len);
+ TEST_ASSERT(ret == 0);
- if( ret == 0 )
- {
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &grp1.N, &grp2.N ) == 0 );
- TEST_ASSERT( grp1.id == grp2.id );
+ if (ret == 0) {
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&grp1.N, &grp2.N) == 0);
+ TEST_ASSERT(grp1.id == grp2.id);
}
exit:
- mbedtls_ecp_group_free( &grp1 );
- mbedtls_ecp_group_free( &grp2 );
+ mbedtls_ecp_group_free(&grp1);
+ mbedtls_ecp_group_free(&grp2);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECDH_C:MBEDTLS_ECDSA_C */
-void mbedtls_ecp_group_metadata( int id, int bit_size, int crv_type,
- char* P, char* A, char* B,
- char* G_x, char* G_y, char* N,
- int tls_id )
+void mbedtls_ecp_group_metadata(int id, int bit_size, int crv_type,
+ char *P, char *A, char *B,
+ char *G_x, char *G_y, char *N,
+ int tls_id)
{
mbedtls_ecp_group grp, grp_read, grp_cpy;
const mbedtls_ecp_group_id *g_id;
@@ -1122,316 +1126,317 @@
const unsigned char *vbuf = buf;
size_t olen;
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_group_init( &grp_read );
- mbedtls_ecp_group_init( &grp_cpy );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_group_init(&grp_read);
+ mbedtls_ecp_group_init(&grp_cpy);
- mbedtls_mpi_init( &exp_P );
- mbedtls_mpi_init( &exp_A );
- mbedtls_mpi_init( &exp_B );
- mbedtls_mpi_init( &exp_G_x );
- mbedtls_mpi_init( &exp_G_y );
- mbedtls_mpi_init( &exp_N );
+ mbedtls_mpi_init(&exp_P);
+ mbedtls_mpi_init(&exp_A);
+ mbedtls_mpi_init(&exp_B);
+ mbedtls_mpi_init(&exp_G_x);
+ mbedtls_mpi_init(&exp_G_y);
+ mbedtls_mpi_init(&exp_N);
// Read expected parameters
- TEST_EQUAL( mbedtls_test_read_mpi( &exp_P, P ), 0 );
- TEST_EQUAL( mbedtls_test_read_mpi( &exp_A, A ), 0 );
- TEST_EQUAL( mbedtls_test_read_mpi( &exp_G_x, G_x ), 0 );
- TEST_EQUAL( mbedtls_test_read_mpi( &exp_N, N ), 0 );
- TEST_EQUAL( mbedtls_test_read_mpi( &exp_B, B ), 0 );
- TEST_EQUAL( mbedtls_test_read_mpi( &exp_G_y, G_y ), 0 );
+ TEST_EQUAL(mbedtls_test_read_mpi(&exp_P, P), 0);
+ TEST_EQUAL(mbedtls_test_read_mpi(&exp_A, A), 0);
+ TEST_EQUAL(mbedtls_test_read_mpi(&exp_G_x, G_x), 0);
+ TEST_EQUAL(mbedtls_test_read_mpi(&exp_N, N), 0);
+ TEST_EQUAL(mbedtls_test_read_mpi(&exp_B, B), 0);
+ TEST_EQUAL(mbedtls_test_read_mpi(&exp_G_y, G_y), 0);
// Convert exp_A to internal representation (A+2)/4
- if( crv_type == MBEDTLS_ECP_TYPE_MONTGOMERY )
- {
- TEST_EQUAL( mbedtls_mpi_add_int( &exp_A, &exp_A, 2 ), 0 );
- TEST_EQUAL( mbedtls_mpi_div_int( &exp_A, NULL, &exp_A, 4 ), 0 );
+ if (crv_type == MBEDTLS_ECP_TYPE_MONTGOMERY) {
+ TEST_EQUAL(mbedtls_mpi_add_int(&exp_A, &exp_A, 2), 0);
+ TEST_EQUAL(mbedtls_mpi_div_int(&exp_A, NULL, &exp_A, 4), 0);
}
// Load group
- TEST_EQUAL( mbedtls_ecp_group_load( &grp, id ), 0 );
+ TEST_EQUAL(mbedtls_ecp_group_load(&grp, id), 0);
// Compare group with expected parameters
// A is NULL for SECPxxxR1 curves
// B and G_y are NULL for curve25519 and curve448
- TEST_EQUAL( mbedtls_mpi_cmp_mpi( &exp_P, &grp.P ), 0 );
- if( *A != 0 )
- TEST_EQUAL( mbedtls_mpi_cmp_mpi( &exp_A, &grp.A ), 0 );
- if( *B != 0 )
- TEST_EQUAL( mbedtls_mpi_cmp_mpi( &exp_B, &grp.B ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_mpi( &exp_G_x, &grp.G.X ), 0 );
- if( *G_y != 0 )
- TEST_EQUAL( mbedtls_mpi_cmp_mpi( &exp_G_y, &grp.G.Y ), 0 );
- TEST_EQUAL( mbedtls_mpi_cmp_mpi( &exp_N, &grp.N ), 0 );
+ TEST_EQUAL(mbedtls_mpi_cmp_mpi(&exp_P, &grp.P), 0);
+ if (*A != 0) {
+ TEST_EQUAL(mbedtls_mpi_cmp_mpi(&exp_A, &grp.A), 0);
+ }
+ if (*B != 0) {
+ TEST_EQUAL(mbedtls_mpi_cmp_mpi(&exp_B, &grp.B), 0);
+ }
+ TEST_EQUAL(mbedtls_mpi_cmp_mpi(&exp_G_x, &grp.G.X), 0);
+ if (*G_y != 0) {
+ TEST_EQUAL(mbedtls_mpi_cmp_mpi(&exp_G_y, &grp.G.Y), 0);
+ }
+ TEST_EQUAL(mbedtls_mpi_cmp_mpi(&exp_N, &grp.N), 0);
// Load curve info and compare with known values
- crv = mbedtls_ecp_curve_info_from_grp_id( id );
- TEST_EQUAL( crv->grp_id, id );
- TEST_EQUAL( crv->bit_size, bit_size );
- TEST_EQUAL( crv->tls_id, tls_id );
+ crv = mbedtls_ecp_curve_info_from_grp_id(id);
+ TEST_EQUAL(crv->grp_id, id);
+ TEST_EQUAL(crv->bit_size, bit_size);
+ TEST_EQUAL(crv->tls_id, tls_id);
// Load curve from TLS ID and name, and compare IDs
- crv_tls_id = mbedtls_ecp_curve_info_from_tls_id( crv->tls_id );
- crv_name = mbedtls_ecp_curve_info_from_name( crv->name );
- TEST_EQUAL( crv_tls_id->grp_id, id );
- TEST_EQUAL( crv_name->grp_id, id );
+ crv_tls_id = mbedtls_ecp_curve_info_from_tls_id(crv->tls_id);
+ crv_name = mbedtls_ecp_curve_info_from_name(crv->name);
+ TEST_EQUAL(crv_tls_id->grp_id, id);
+ TEST_EQUAL(crv_name->grp_id, id);
// Validate write_group against test data
- TEST_EQUAL( mbedtls_ecp_tls_write_group( &grp, &olen,
- buf, sizeof( buf ) ),
- 0 );
- TEST_EQUAL( mbedtls_test_hexcmp( buf, ecparameters, olen,
- sizeof( ecparameters ) ),
- 0 );
+ TEST_EQUAL(mbedtls_ecp_tls_write_group(&grp, &olen,
+ buf, sizeof(buf)),
+ 0);
+ TEST_EQUAL(mbedtls_test_hexcmp(buf, ecparameters, olen,
+ sizeof(ecparameters)),
+ 0);
// Read group from buffer and compare with expected ID
- TEST_EQUAL( mbedtls_ecp_tls_read_group_id( &read_g_id, &vbuf, olen ),
- 0 );
- TEST_EQUAL( read_g_id, id );
+ TEST_EQUAL(mbedtls_ecp_tls_read_group_id(&read_g_id, &vbuf, olen),
+ 0);
+ TEST_EQUAL(read_g_id, id);
vbuf = buf;
- TEST_EQUAL( mbedtls_ecp_tls_read_group( &grp_read, &vbuf, olen ),
- 0 );
- TEST_EQUAL( grp_read.id, id );
+ TEST_EQUAL(mbedtls_ecp_tls_read_group(&grp_read, &vbuf, olen),
+ 0);
+ TEST_EQUAL(grp_read.id, id);
// Check curve type, and if it can be used for ECDH/ECDSA
- TEST_EQUAL( mbedtls_ecp_get_type( &grp ), crv_type );
- TEST_EQUAL( mbedtls_ecdh_can_do( id ), 1 );
- TEST_EQUAL( mbedtls_ecdsa_can_do( id ),
- crv_type == MBEDTLS_ECP_TYPE_SHORT_WEIERSTRASS );
+ TEST_EQUAL(mbedtls_ecp_get_type(&grp), crv_type);
+ TEST_EQUAL(mbedtls_ecdh_can_do(id), 1);
+ TEST_EQUAL(mbedtls_ecdsa_can_do(id),
+ crv_type == MBEDTLS_ECP_TYPE_SHORT_WEIERSTRASS);
// Copy group and compare with original
- TEST_EQUAL( mbedtls_ecp_group_copy( &grp_cpy, &grp ), 0 );
- TEST_EQUAL( mbedtls_ecp_group_cmp( &grp, &grp_cpy ), 0 );
+ TEST_EQUAL(mbedtls_ecp_group_copy(&grp_cpy, &grp), 0);
+ TEST_EQUAL(mbedtls_ecp_group_cmp(&grp, &grp_cpy), 0);
// Check curve is in curve list and group ID list
- for( crv = mbedtls_ecp_curve_list( );
- crv->grp_id != MBEDTLS_ECP_DP_NONE &&
- crv->grp_id != (unsigned) id;
- crv++ );
- TEST_EQUAL( crv->grp_id, id );
- for( g_id = mbedtls_ecp_grp_id_list( );
+ for (crv = mbedtls_ecp_curve_list();
+ crv->grp_id != MBEDTLS_ECP_DP_NONE &&
+ crv->grp_id != (unsigned) id;
+ crv++) {
+ ;
+ }
+ TEST_EQUAL(crv->grp_id, id);
+ for (g_id = mbedtls_ecp_grp_id_list();
*g_id != MBEDTLS_ECP_DP_NONE && *g_id != (unsigned) id;
- g_id++ );
- TEST_EQUAL( *g_id, (unsigned) id );
+ g_id++) {
+ ;
+ }
+ TEST_EQUAL(*g_id, (unsigned) id);
exit:
- mbedtls_ecp_group_free( &grp ); mbedtls_ecp_group_free( &grp_cpy );
- mbedtls_ecp_group_free( &grp_read );
- mbedtls_mpi_free( &exp_P ); mbedtls_mpi_free( &exp_A );
- mbedtls_mpi_free( &exp_B ); mbedtls_mpi_free( &exp_G_x );
- mbedtls_mpi_free( &exp_G_y ); mbedtls_mpi_free( &exp_N );
+ mbedtls_ecp_group_free(&grp); mbedtls_ecp_group_free(&grp_cpy);
+ mbedtls_ecp_group_free(&grp_read);
+ mbedtls_mpi_free(&exp_P); mbedtls_mpi_free(&exp_A);
+ mbedtls_mpi_free(&exp_B); mbedtls_mpi_free(&exp_G_x);
+ mbedtls_mpi_free(&exp_G_y); mbedtls_mpi_free(&exp_N);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_ecp_check_privkey( int id, char * key_hex, int ret )
+void mbedtls_ecp_check_privkey(int id, char *key_hex, int ret)
{
mbedtls_ecp_group grp;
mbedtls_mpi d;
- mbedtls_ecp_group_init( &grp );
- mbedtls_mpi_init( &d );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_mpi_init(&d);
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &d, key_hex ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&d, key_hex) == 0);
- TEST_ASSERT( mbedtls_ecp_check_privkey( &grp, &d ) == ret );
+ TEST_ASSERT(mbedtls_ecp_check_privkey(&grp, &d) == ret);
exit:
- mbedtls_ecp_group_free( &grp );
- mbedtls_mpi_free( &d );
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_mpi_free(&d);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_ecp_check_pub_priv( int id_pub, char * Qx_pub, char * Qy_pub,
- int id, char * d, char * Qx, char * Qy,
- int ret )
+void mbedtls_ecp_check_pub_priv(int id_pub, char *Qx_pub, char *Qy_pub,
+ int id, char *d, char *Qx, char *Qy,
+ int ret)
{
mbedtls_ecp_keypair pub, prv;
- mbedtls_ecp_keypair_init( &pub );
- mbedtls_ecp_keypair_init( &prv );
+ mbedtls_ecp_keypair_init(&pub);
+ mbedtls_ecp_keypair_init(&prv);
- if( id_pub != MBEDTLS_ECP_DP_NONE )
- TEST_ASSERT( mbedtls_ecp_group_load( &pub.grp, id_pub ) == 0 );
- TEST_ASSERT( mbedtls_ecp_point_read_string( &pub.Q, 16, Qx_pub, Qy_pub ) == 0 );
+ if (id_pub != MBEDTLS_ECP_DP_NONE) {
+ TEST_ASSERT(mbedtls_ecp_group_load(&pub.grp, id_pub) == 0);
+ }
+ TEST_ASSERT(mbedtls_ecp_point_read_string(&pub.Q, 16, Qx_pub, Qy_pub) == 0);
- if( id != MBEDTLS_ECP_DP_NONE )
- TEST_ASSERT( mbedtls_ecp_group_load( &prv.grp, id ) == 0 );
- TEST_ASSERT( mbedtls_ecp_point_read_string( &prv.Q, 16, Qx, Qy ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &prv.d, d ) == 0 );
+ if (id != MBEDTLS_ECP_DP_NONE) {
+ TEST_ASSERT(mbedtls_ecp_group_load(&prv.grp, id) == 0);
+ }
+ TEST_ASSERT(mbedtls_ecp_point_read_string(&prv.Q, 16, Qx, Qy) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&prv.d, d) == 0);
- TEST_ASSERT( mbedtls_ecp_check_pub_priv( &pub, &prv ) == ret );
+ TEST_ASSERT(mbedtls_ecp_check_pub_priv(&pub, &prv) == ret);
exit:
- mbedtls_ecp_keypair_free( &pub );
- mbedtls_ecp_keypair_free( &prv );
+ mbedtls_ecp_keypair_free(&pub);
+ mbedtls_ecp_keypair_free(&prv);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_ecp_gen_keypair( int id )
+void mbedtls_ecp_gen_keypair(int id)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point Q;
mbedtls_mpi d;
mbedtls_test_rnd_pseudo_info rnd_info;
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_point_init( &Q );
- mbedtls_mpi_init( &d );
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_point_init(&Q);
+ mbedtls_mpi_init(&d);
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
- TEST_ASSERT( mbedtls_ecp_gen_keypair( &grp, &d, &Q,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_gen_keypair(&grp, &d, &Q,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &grp, &Q ) == 0 );
- TEST_ASSERT( mbedtls_ecp_check_privkey( &grp, &d ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&grp, &Q) == 0);
+ TEST_ASSERT(mbedtls_ecp_check_privkey(&grp, &d) == 0);
exit:
- mbedtls_ecp_group_free( &grp );
- mbedtls_ecp_point_free( &Q );
- mbedtls_mpi_free( &d );
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_ecp_point_free(&Q);
+ mbedtls_mpi_free(&d);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_ecp_gen_key( int id )
+void mbedtls_ecp_gen_key(int id)
{
mbedtls_ecp_keypair key;
mbedtls_test_rnd_pseudo_info rnd_info;
- mbedtls_ecp_keypair_init( &key );
- memset( &rnd_info, 0x00, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ mbedtls_ecp_keypair_init(&key);
+ memset(&rnd_info, 0x00, sizeof(mbedtls_test_rnd_pseudo_info));
- TEST_ASSERT( mbedtls_ecp_gen_key( id, &key,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_gen_key(id, &key,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info) == 0);
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &key.grp, &key.Q ) == 0 );
- TEST_ASSERT( mbedtls_ecp_check_privkey( &key.grp, &key.d ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&key.grp, &key.Q) == 0);
+ TEST_ASSERT(mbedtls_ecp_check_privkey(&key.grp, &key.d) == 0);
exit:
- mbedtls_ecp_keypair_free( &key );
+ mbedtls_ecp_keypair_free(&key);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_ecp_read_key( int grp_id, data_t* in_key, int expected, int canonical )
+void mbedtls_ecp_read_key(int grp_id, data_t *in_key, int expected, int canonical)
{
int ret = 0;
mbedtls_ecp_keypair key;
mbedtls_ecp_keypair key2;
- mbedtls_ecp_keypair_init( &key );
- mbedtls_ecp_keypair_init( &key2 );
+ mbedtls_ecp_keypair_init(&key);
+ mbedtls_ecp_keypair_init(&key2);
- ret = mbedtls_ecp_read_key( grp_id, &key, in_key->x, in_key->len );
- TEST_ASSERT( ret == expected );
+ ret = mbedtls_ecp_read_key(grp_id, &key, in_key->x, in_key->len);
+ TEST_ASSERT(ret == expected);
- if( expected == 0 )
- {
- ret = mbedtls_ecp_check_privkey( &key.grp, &key.d );
- TEST_ASSERT( ret == 0 );
+ if (expected == 0) {
+ ret = mbedtls_ecp_check_privkey(&key.grp, &key.d);
+ TEST_ASSERT(ret == 0);
- if( canonical )
- {
+ if (canonical) {
unsigned char buf[MBEDTLS_ECP_MAX_BYTES];
- ret = mbedtls_ecp_write_key( &key, buf, in_key->len );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_ecp_write_key(&key, buf, in_key->len);
+ TEST_ASSERT(ret == 0);
- ASSERT_COMPARE( in_key->x, in_key->len,
- buf, in_key->len );
- }
- else
- {
+ ASSERT_COMPARE(in_key->x, in_key->len,
+ buf, in_key->len);
+ } else {
unsigned char export1[MBEDTLS_ECP_MAX_BYTES];
unsigned char export2[MBEDTLS_ECP_MAX_BYTES];
- ret = mbedtls_ecp_write_key( &key, export1, in_key->len );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_ecp_write_key(&key, export1, in_key->len);
+ TEST_ASSERT(ret == 0);
- ret = mbedtls_ecp_read_key( grp_id, &key2, export1, in_key->len );
- TEST_ASSERT( ret == expected );
+ ret = mbedtls_ecp_read_key(grp_id, &key2, export1, in_key->len);
+ TEST_ASSERT(ret == expected);
- ret = mbedtls_ecp_write_key( &key2, export2, in_key->len );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_ecp_write_key(&key2, export2, in_key->len);
+ TEST_ASSERT(ret == 0);
- ASSERT_COMPARE( export1, in_key->len,
- export2, in_key->len );
+ ASSERT_COMPARE(export1, in_key->len,
+ export2, in_key->len);
}
}
exit:
- mbedtls_ecp_keypair_free( &key );
- mbedtls_ecp_keypair_free( &key2 );
+ mbedtls_ecp_keypair_free(&key);
+ mbedtls_ecp_keypair_free(&key2);
}
/* END_CASE */
/* BEGIN_CASE depends_on:HAVE_FIX_NEGATIVE */
-void fix_negative( data_t *N_bin, int c, int bits )
+void fix_negative(data_t *N_bin, int c, int bits)
{
mbedtls_mpi C, M, N;
- mbedtls_mpi_init( &C );
- mbedtls_mpi_init( &M );
- mbedtls_mpi_init( &N );
+ mbedtls_mpi_init(&C);
+ mbedtls_mpi_init(&M);
+ mbedtls_mpi_init(&N);
/* C = - c * 2^bits (positive since c is negative) */
- TEST_EQUAL( 0, mbedtls_mpi_lset( &C, -c ) );
- TEST_EQUAL( 0, mbedtls_mpi_shift_l( &C, bits ) );
+ TEST_EQUAL(0, mbedtls_mpi_lset(&C, -c));
+ TEST_EQUAL(0, mbedtls_mpi_shift_l(&C, bits));
- TEST_EQUAL( 0, mbedtls_mpi_read_binary( &N, N_bin->x, N_bin->len ) );
- TEST_EQUAL( 0, mbedtls_mpi_grow( &N, C.n ) );
+ TEST_EQUAL(0, mbedtls_mpi_read_binary(&N, N_bin->x, N_bin->len));
+ TEST_EQUAL(0, mbedtls_mpi_grow(&N, C.n));
/* M = N - C = - ( C - N ) (expected result of fix_negative) */
- TEST_EQUAL( 0, mbedtls_mpi_sub_mpi( &M, &N, &C ) );
+ TEST_EQUAL(0, mbedtls_mpi_sub_mpi(&M, &N, &C));
- mbedtls_ecp_fix_negative( &N, c, bits );
+ mbedtls_ecp_fix_negative(&N, c, bits);
- TEST_EQUAL( 0, mbedtls_mpi_cmp_mpi( &N, &M ) );
+ TEST_EQUAL(0, mbedtls_mpi_cmp_mpi(&N, &M));
exit:
- mbedtls_mpi_free( &C );
- mbedtls_mpi_free( &M );
- mbedtls_mpi_free( &N );
+ mbedtls_mpi_free(&C);
+ mbedtls_mpi_free(&M);
+ mbedtls_mpi_free(&N);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_TEST_HOOKS:MBEDTLS_ECP_MONTGOMERY_ENABLED */
-void genkey_mx_known_answer( int bits, data_t *seed, data_t *expected )
+void genkey_mx_known_answer(int bits, data_t *seed, data_t *expected)
{
mbedtls_test_rnd_buf_info rnd_info;
mbedtls_mpi d;
int ret;
uint8_t *actual = NULL;
- mbedtls_mpi_init( &d );
+ mbedtls_mpi_init(&d);
rnd_info.buf = seed->x;
rnd_info.length = seed->len;
rnd_info.fallback_f_rng = NULL;
rnd_info.fallback_p_rng = NULL;
- ASSERT_ALLOC( actual, expected->len );
+ ASSERT_ALLOC(actual, expected->len);
- ret = mbedtls_ecp_gen_privkey_mx( bits, &d,
- mbedtls_test_rnd_buffer_rand, &rnd_info );
+ ret = mbedtls_ecp_gen_privkey_mx(bits, &d,
+ mbedtls_test_rnd_buffer_rand, &rnd_info);
- if( expected->len == 0 )
- {
+ if (expected->len == 0) {
/* Expecting an error (happens if there isn't enough randomness) */
- TEST_ASSERT( ret != 0 );
- }
- else
- {
- TEST_EQUAL( ret, 0 );
- TEST_EQUAL( (size_t) bits + 1, mbedtls_mpi_bitlen( &d ) );
- TEST_EQUAL( 0, mbedtls_mpi_write_binary( &d, actual, expected->len ) );
+ TEST_ASSERT(ret != 0);
+ } else {
+ TEST_EQUAL(ret, 0);
+ TEST_EQUAL((size_t) bits + 1, mbedtls_mpi_bitlen(&d));
+ TEST_EQUAL(0, mbedtls_mpi_write_binary(&d, actual, expected->len));
/* Test the exact result. This assumes that the output of the
* RNG is used in a specific way, which is overly constraining.
* The advantage is that it's easier to test the expected properties
@@ -1442,109 +1447,109 @@
* (can be enforced by checking these bits).
* - Other bits must be random (by testing with different RNG outputs,
* we validate that those bits are indeed influenced by the RNG). */
- ASSERT_COMPARE( expected->x, expected->len,
- actual, expected->len );
+ ASSERT_COMPARE(expected->x, expected->len,
+ actual, expected->len);
}
exit:
- mbedtls_free( actual );
- mbedtls_mpi_free( &d );
+ mbedtls_free(actual);
+ mbedtls_mpi_free(&d);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecp_set_zero( int id, data_t * P_bin )
+void ecp_set_zero(int id, data_t *P_bin)
{
mbedtls_ecp_group grp;
mbedtls_ecp_point pt, zero_pt, nonzero_pt;
- mbedtls_ecp_group_init( &grp );
- mbedtls_ecp_point_init( &pt );
- mbedtls_ecp_point_init( &zero_pt );
- mbedtls_ecp_point_init( &nonzero_pt );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_ecp_point_init(&pt);
+ mbedtls_ecp_point_init(&zero_pt);
+ mbedtls_ecp_point_init(&nonzero_pt);
// Set zero and non-zero points for comparison
- TEST_EQUAL( mbedtls_ecp_set_zero( &zero_pt ), 0 );
- TEST_EQUAL( mbedtls_ecp_group_load( &grp, id ), 0 );
- TEST_EQUAL( mbedtls_ecp_point_read_binary( &grp, &nonzero_pt,
- P_bin->x, P_bin->len ), 0 );
- TEST_EQUAL( mbedtls_ecp_is_zero( &zero_pt ), 1 );
- TEST_EQUAL( mbedtls_ecp_is_zero( &nonzero_pt ), 0 );
+ TEST_EQUAL(mbedtls_ecp_set_zero(&zero_pt), 0);
+ TEST_EQUAL(mbedtls_ecp_group_load(&grp, id), 0);
+ TEST_EQUAL(mbedtls_ecp_point_read_binary(&grp, &nonzero_pt,
+ P_bin->x, P_bin->len), 0);
+ TEST_EQUAL(mbedtls_ecp_is_zero(&zero_pt), 1);
+ TEST_EQUAL(mbedtls_ecp_is_zero(&nonzero_pt), 0);
// Test initialized point
- TEST_EQUAL( mbedtls_ecp_set_zero( &pt ), 0 );
- TEST_EQUAL( mbedtls_ecp_is_zero( &pt ), 1 );
- TEST_EQUAL( mbedtls_ecp_point_cmp( &zero_pt, &pt ), 0 );
- TEST_EQUAL( mbedtls_ecp_point_cmp( &nonzero_pt, &zero_pt ),
- MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
+ TEST_EQUAL(mbedtls_ecp_set_zero(&pt), 0);
+ TEST_EQUAL(mbedtls_ecp_is_zero(&pt), 1);
+ TEST_EQUAL(mbedtls_ecp_point_cmp(&zero_pt, &pt), 0);
+ TEST_EQUAL(mbedtls_ecp_point_cmp(&nonzero_pt, &zero_pt),
+ MBEDTLS_ERR_ECP_BAD_INPUT_DATA);
// Test zeroed point
- TEST_EQUAL( mbedtls_ecp_set_zero( &pt ), 0 );
- TEST_EQUAL( mbedtls_ecp_is_zero( &pt ), 1 );
- TEST_EQUAL( mbedtls_ecp_point_cmp( &zero_pt, &pt ), 0 );
- TEST_EQUAL( mbedtls_ecp_point_cmp( &nonzero_pt, &pt ),
- MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
+ TEST_EQUAL(mbedtls_ecp_set_zero(&pt), 0);
+ TEST_EQUAL(mbedtls_ecp_is_zero(&pt), 1);
+ TEST_EQUAL(mbedtls_ecp_point_cmp(&zero_pt, &pt), 0);
+ TEST_EQUAL(mbedtls_ecp_point_cmp(&nonzero_pt, &pt),
+ MBEDTLS_ERR_ECP_BAD_INPUT_DATA);
// Set point to non-zero value
- TEST_EQUAL( mbedtls_ecp_point_read_binary( &grp, &pt,
- P_bin->x, P_bin->len ), 0 );
- TEST_EQUAL( mbedtls_ecp_is_zero( &pt ), 0 );
- TEST_EQUAL( mbedtls_ecp_point_cmp( &zero_pt, &pt ),
- MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
- TEST_EQUAL( mbedtls_ecp_point_cmp( &nonzero_pt, &pt), 0 );
+ TEST_EQUAL(mbedtls_ecp_point_read_binary(&grp, &pt,
+ P_bin->x, P_bin->len), 0);
+ TEST_EQUAL(mbedtls_ecp_is_zero(&pt), 0);
+ TEST_EQUAL(mbedtls_ecp_point_cmp(&zero_pt, &pt),
+ MBEDTLS_ERR_ECP_BAD_INPUT_DATA);
+ TEST_EQUAL(mbedtls_ecp_point_cmp(&nonzero_pt, &pt), 0);
// Test non-zero point
- TEST_EQUAL( mbedtls_ecp_set_zero( &pt ), 0 );
- TEST_EQUAL( mbedtls_ecp_is_zero( &pt ), 1 );
- TEST_EQUAL( mbedtls_ecp_point_cmp( &zero_pt, &pt ), 0 );
- TEST_EQUAL( mbedtls_ecp_point_cmp( &nonzero_pt, &pt ),
- MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
+ TEST_EQUAL(mbedtls_ecp_set_zero(&pt), 0);
+ TEST_EQUAL(mbedtls_ecp_is_zero(&pt), 1);
+ TEST_EQUAL(mbedtls_ecp_point_cmp(&zero_pt, &pt), 0);
+ TEST_EQUAL(mbedtls_ecp_point_cmp(&nonzero_pt, &pt),
+ MBEDTLS_ERR_ECP_BAD_INPUT_DATA);
// Test freed non-zero point
- TEST_EQUAL( mbedtls_ecp_point_read_binary( &grp, &pt,
- P_bin->x, P_bin->len ), 0 );
- mbedtls_ecp_point_free( &pt );
- TEST_EQUAL( mbedtls_ecp_set_zero( &pt ), 0 );
- TEST_EQUAL( mbedtls_ecp_is_zero( &pt ), 1 );
- TEST_EQUAL( mbedtls_ecp_point_cmp( &zero_pt, &pt ), 0 );
- TEST_EQUAL( mbedtls_ecp_point_cmp( &nonzero_pt, &pt),
- MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
+ TEST_EQUAL(mbedtls_ecp_point_read_binary(&grp, &pt,
+ P_bin->x, P_bin->len), 0);
+ mbedtls_ecp_point_free(&pt);
+ TEST_EQUAL(mbedtls_ecp_set_zero(&pt), 0);
+ TEST_EQUAL(mbedtls_ecp_is_zero(&pt), 1);
+ TEST_EQUAL(mbedtls_ecp_point_cmp(&zero_pt, &pt), 0);
+ TEST_EQUAL(mbedtls_ecp_point_cmp(&nonzero_pt, &pt),
+ MBEDTLS_ERR_ECP_BAD_INPUT_DATA);
exit:
- mbedtls_ecp_group_free( &grp );
- mbedtls_ecp_point_free( &pt );
- mbedtls_ecp_point_free( &zero_pt );
- mbedtls_ecp_point_free( &nonzero_pt );
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_ecp_point_free(&pt);
+ mbedtls_ecp_point_free(&zero_pt);
+ mbedtls_ecp_point_free(&nonzero_pt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void ecp_selftest( )
+void ecp_selftest()
{
- TEST_ASSERT( mbedtls_ecp_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_self_test(1) == 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void ecp_check_order( int id, char * expected_order_hex )
+void ecp_check_order(int id, char *expected_order_hex)
{
mbedtls_ecp_group grp;
mbedtls_mpi expected_n;
- mbedtls_ecp_group_init( &grp );
- mbedtls_mpi_init( &expected_n );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_mpi_init(&expected_n);
- TEST_ASSERT( mbedtls_ecp_group_load( &grp, id ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &expected_n, expected_order_hex ) == 0);
+ TEST_ASSERT(mbedtls_ecp_group_load(&grp, id) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&expected_n, expected_order_hex) == 0);
// check sign bits are well-formed (i.e. 1 or -1) - see #5810
- TEST_ASSERT( grp.N.s == -1 || grp.N.s == 1);
- TEST_ASSERT( expected_n.s == -1 || expected_n.s == 1);
+ TEST_ASSERT(grp.N.s == -1 || grp.N.s == 1);
+ TEST_ASSERT(expected_n.s == -1 || expected_n.s == 1);
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &grp.N, &expected_n ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&grp.N, &expected_n) == 0);
exit:
- mbedtls_ecp_group_free( &grp );
- mbedtls_mpi_free( &expected_n );
+ mbedtls_ecp_group_free(&grp);
+ mbedtls_mpi_free(&expected_n);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_entropy.function b/tests/suites/test_suite_entropy.function
index e5e88bb..b04ed54 100644
--- a/tests/suites/test_suite_entropy.function
+++ b/tests/suites/test_suite_entropy.function
@@ -4,15 +4,13 @@
#include "mbedtls/md.h"
#include "string.h"
-typedef enum
-{
+typedef enum {
DUMMY_CONSTANT_LENGTH, /* Output context->length bytes */
DUMMY_REQUESTED_LENGTH, /* Output whatever length was requested */
DUMMY_FAIL, /* Return an error code */
} entropy_dummy_instruction;
-typedef struct
-{
+typedef struct {
entropy_dummy_instruction instruction;
size_t length; /* Length to return for DUMMY_CONSTANT_LENGTH */
size_t calls; /* Incremented at each call */
@@ -24,14 +22,13 @@
* If data is NULL, write exactly the requested length.
* Otherwise, write the length indicated by data or error if negative
*/
-static int entropy_dummy_source( void *arg, unsigned char *output,
- size_t len, size_t *olen )
+static int entropy_dummy_source(void *arg, unsigned char *output,
+ size_t len, size_t *olen)
{
entropy_dummy_context *context = arg;
++context->calls;
- switch( context->instruction )
- {
+ switch (context->instruction) {
case DUMMY_CONSTANT_LENGTH:
*olen = context->length;
break;
@@ -39,11 +36,11 @@
*olen = len;
break;
case DUMMY_FAIL:
- return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
+ return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
}
- memset( output, 0x2a, *olen );
- return( 0 );
+ memset(output, 0x2a, *olen);
+ return 0;
}
/*
@@ -57,7 +54,7 @@
* This might break memory checks in the future if sources need 'free-ing' then
* as well.
*/
-static void entropy_clear_sources( mbedtls_entropy_context *ctx )
+static void entropy_clear_sources(mbedtls_entropy_context *ctx)
{
ctx->source_count = 0;
}
@@ -68,63 +65,71 @@
*/
static unsigned char buffer_seed[MBEDTLS_ENTROPY_BLOCK_SIZE];
-int buffer_nv_seed_read( unsigned char *buf, size_t buf_len )
+int buffer_nv_seed_read(unsigned char *buf, size_t buf_len)
{
- if( buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE )
- return( -1 );
+ if (buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE) {
+ return -1;
+ }
- memcpy( buf, buffer_seed, MBEDTLS_ENTROPY_BLOCK_SIZE );
- return( 0 );
+ memcpy(buf, buffer_seed, MBEDTLS_ENTROPY_BLOCK_SIZE);
+ return 0;
}
-int buffer_nv_seed_write( unsigned char *buf, size_t buf_len )
+int buffer_nv_seed_write(unsigned char *buf, size_t buf_len)
{
- if( buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE )
- return( -1 );
+ if (buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE) {
+ return -1;
+ }
- memcpy( buffer_seed, buf, MBEDTLS_ENTROPY_BLOCK_SIZE );
- return( 0 );
+ memcpy(buffer_seed, buf, MBEDTLS_ENTROPY_BLOCK_SIZE);
+ return 0;
}
/*
* NV seed read/write helpers that fill the base seedfile
*/
-static int write_nv_seed( unsigned char *buf, size_t buf_len )
+static int write_nv_seed(unsigned char *buf, size_t buf_len)
{
FILE *f;
- if( buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE )
- return( -1 );
+ if (buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE) {
+ return -1;
+ }
- if( ( f = fopen( MBEDTLS_PLATFORM_STD_NV_SEED_FILE, "w" ) ) == NULL )
- return( -1 );
+ if ((f = fopen(MBEDTLS_PLATFORM_STD_NV_SEED_FILE, "w")) == NULL) {
+ return -1;
+ }
- if( fwrite( buf, 1, MBEDTLS_ENTROPY_BLOCK_SIZE, f ) !=
- MBEDTLS_ENTROPY_BLOCK_SIZE )
- return( -1 );
+ if (fwrite(buf, 1, MBEDTLS_ENTROPY_BLOCK_SIZE, f) !=
+ MBEDTLS_ENTROPY_BLOCK_SIZE) {
+ return -1;
+ }
- fclose( f );
+ fclose(f);
- return( 0 );
+ return 0;
}
-int read_nv_seed( unsigned char *buf, size_t buf_len )
+int read_nv_seed(unsigned char *buf, size_t buf_len)
{
FILE *f;
- if( buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE )
- return( -1 );
+ if (buf_len != MBEDTLS_ENTROPY_BLOCK_SIZE) {
+ return -1;
+ }
- if( ( f = fopen( MBEDTLS_PLATFORM_STD_NV_SEED_FILE, "rb" ) ) == NULL )
- return( -1 );
+ if ((f = fopen(MBEDTLS_PLATFORM_STD_NV_SEED_FILE, "rb")) == NULL) {
+ return -1;
+ }
- if( fread( buf, 1, MBEDTLS_ENTROPY_BLOCK_SIZE, f ) !=
- MBEDTLS_ENTROPY_BLOCK_SIZE )
- return( -1 );
+ if (fread(buf, 1, MBEDTLS_ENTROPY_BLOCK_SIZE, f) !=
+ MBEDTLS_ENTROPY_BLOCK_SIZE) {
+ return -1;
+ }
- fclose( f );
+ fclose(f);
- return( 0 );
+ return 0;
}
#endif /* MBEDTLS_ENTROPY_NV_SEED */
/* END_HEADER */
@@ -135,7 +140,7 @@
*/
/* BEGIN_CASE */
-void entropy_init_free( int reinit )
+void entropy_init_free(int reinit)
{
mbedtls_entropy_context ctx;
@@ -143,12 +148,13 @@
* to call mbedtls_entropy_free() unconditionally on an error path without
* checking whether it has already been called in the success path. */
- mbedtls_entropy_init( &ctx );
- mbedtls_entropy_free( &ctx );
+ mbedtls_entropy_init(&ctx);
+ mbedtls_entropy_free(&ctx);
- if( reinit )
- mbedtls_entropy_init( &ctx );
- mbedtls_entropy_free( &ctx );
+ if (reinit) {
+ mbedtls_entropy_init(&ctx);
+ }
+ mbedtls_entropy_free(&ctx);
/* This test case always succeeds, functionally speaking. A plausible
* bug might trigger an invalid pointer dereference or a memory leak. */
@@ -157,189 +163,190 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
-void entropy_seed_file( char * path, int ret )
+void entropy_seed_file(char *path, int ret)
{
mbedtls_entropy_context ctx;
- mbedtls_entropy_init( &ctx );
+ mbedtls_entropy_init(&ctx);
- TEST_ASSERT( mbedtls_entropy_write_seed_file( &ctx, path ) == ret );
- TEST_ASSERT( mbedtls_entropy_update_seed_file( &ctx, path ) == ret );
+ TEST_ASSERT(mbedtls_entropy_write_seed_file(&ctx, path) == ret);
+ TEST_ASSERT(mbedtls_entropy_update_seed_file(&ctx, path) == ret);
exit:
- mbedtls_entropy_free( &ctx );
+ mbedtls_entropy_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
-void entropy_write_base_seed_file( int ret )
+void entropy_write_base_seed_file(int ret)
{
mbedtls_entropy_context ctx;
- mbedtls_entropy_init( &ctx );
+ mbedtls_entropy_init(&ctx);
- TEST_ASSERT( mbedtls_entropy_write_seed_file( &ctx, MBEDTLS_PLATFORM_STD_NV_SEED_FILE ) == ret );
- TEST_ASSERT( mbedtls_entropy_update_seed_file( &ctx, MBEDTLS_PLATFORM_STD_NV_SEED_FILE ) == ret );
+ TEST_ASSERT(mbedtls_entropy_write_seed_file(&ctx, MBEDTLS_PLATFORM_STD_NV_SEED_FILE) == ret);
+ TEST_ASSERT(mbedtls_entropy_update_seed_file(&ctx, MBEDTLS_PLATFORM_STD_NV_SEED_FILE) == ret);
exit:
- mbedtls_entropy_free( &ctx );
+ mbedtls_entropy_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void entropy_no_sources( )
+void entropy_no_sources()
{
mbedtls_entropy_context ctx;
unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
- mbedtls_entropy_init( &ctx );
- entropy_clear_sources( &ctx );
- TEST_EQUAL( mbedtls_entropy_func( &ctx, buf, sizeof( buf ) ),
- MBEDTLS_ERR_ENTROPY_NO_SOURCES_DEFINED );
+ mbedtls_entropy_init(&ctx);
+ entropy_clear_sources(&ctx);
+ TEST_EQUAL(mbedtls_entropy_func(&ctx, buf, sizeof(buf)),
+ MBEDTLS_ERR_ENTROPY_NO_SOURCES_DEFINED);
exit:
- mbedtls_entropy_free( &ctx );
+ mbedtls_entropy_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void entropy_too_many_sources( )
+void entropy_too_many_sources()
{
mbedtls_entropy_context ctx;
size_t i;
- entropy_dummy_context dummy = {DUMMY_REQUESTED_LENGTH, 0, 0};
+ entropy_dummy_context dummy = { DUMMY_REQUESTED_LENGTH, 0, 0 };
- mbedtls_entropy_init( &ctx );
+ mbedtls_entropy_init(&ctx);
/*
* It's hard to tell precisely when the error will occur,
* since we don't know how many sources were automatically added.
*/
- for( i = 0; i < MBEDTLS_ENTROPY_MAX_SOURCES; i++ )
- (void) mbedtls_entropy_add_source( &ctx, entropy_dummy_source, &dummy,
- 16, MBEDTLS_ENTROPY_SOURCE_WEAK );
+ for (i = 0; i < MBEDTLS_ENTROPY_MAX_SOURCES; i++) {
+ (void) mbedtls_entropy_add_source(&ctx, entropy_dummy_source, &dummy,
+ 16, MBEDTLS_ENTROPY_SOURCE_WEAK);
+ }
- TEST_ASSERT( mbedtls_entropy_add_source( &ctx, entropy_dummy_source, &dummy,
- 16, MBEDTLS_ENTROPY_SOURCE_WEAK )
- == MBEDTLS_ERR_ENTROPY_MAX_SOURCES );
+ TEST_ASSERT(mbedtls_entropy_add_source(&ctx, entropy_dummy_source, &dummy,
+ 16, MBEDTLS_ENTROPY_SOURCE_WEAK)
+ == MBEDTLS_ERR_ENTROPY_MAX_SOURCES);
exit:
- mbedtls_entropy_free( &ctx );
+ mbedtls_entropy_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:ENTROPY_HAVE_STRONG */
-void entropy_func_len( int len, int ret )
+void entropy_func_len(int len, int ret)
{
mbedtls_entropy_context ctx;
unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE + 10] = { 0 };
unsigned char acc[MBEDTLS_ENTROPY_BLOCK_SIZE + 10] = { 0 };
size_t i, j;
- mbedtls_entropy_init( &ctx );
+ mbedtls_entropy_init(&ctx);
/*
* See comments in mbedtls_entropy_self_test()
*/
- for( i = 0; i < 8; i++ )
- {
- TEST_ASSERT( mbedtls_entropy_func( &ctx, buf, len ) == ret );
- for( j = 0; j < sizeof( buf ); j++ )
+ for (i = 0; i < 8; i++) {
+ TEST_ASSERT(mbedtls_entropy_func(&ctx, buf, len) == ret);
+ for (j = 0; j < sizeof(buf); j++) {
acc[j] |= buf[j];
+ }
}
- if( ret == 0 )
- for( j = 0; j < (size_t) len; j++ )
- TEST_ASSERT( acc[j] != 0 );
+ if (ret == 0) {
+ for (j = 0; j < (size_t) len; j++) {
+ TEST_ASSERT(acc[j] != 0);
+ }
+ }
- for( j = len; j < sizeof( buf ); j++ )
- TEST_ASSERT( acc[j] == 0 );
+ for (j = len; j < sizeof(buf); j++) {
+ TEST_ASSERT(acc[j] == 0);
+ }
exit:
- mbedtls_entropy_free( &ctx );
+ mbedtls_entropy_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void entropy_source_fail( char * path )
+void entropy_source_fail(char *path)
{
mbedtls_entropy_context ctx;
unsigned char buf[16];
- entropy_dummy_context dummy = {DUMMY_FAIL, 0, 0};
+ entropy_dummy_context dummy = { DUMMY_FAIL, 0, 0 };
- mbedtls_entropy_init( &ctx );
+ mbedtls_entropy_init(&ctx);
- TEST_ASSERT( mbedtls_entropy_add_source( &ctx, entropy_dummy_source,
- &dummy, 16,
- MBEDTLS_ENTROPY_SOURCE_WEAK )
- == 0 );
+ TEST_ASSERT(mbedtls_entropy_add_source(&ctx, entropy_dummy_source,
+ &dummy, 16,
+ MBEDTLS_ENTROPY_SOURCE_WEAK)
+ == 0);
- TEST_ASSERT( mbedtls_entropy_func( &ctx, buf, sizeof( buf ) )
- == MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
- TEST_ASSERT( mbedtls_entropy_gather( &ctx )
- == MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
+ TEST_ASSERT(mbedtls_entropy_func(&ctx, buf, sizeof(buf))
+ == MBEDTLS_ERR_ENTROPY_SOURCE_FAILED);
+ TEST_ASSERT(mbedtls_entropy_gather(&ctx)
+ == MBEDTLS_ERR_ENTROPY_SOURCE_FAILED);
#if defined(MBEDTLS_FS_IO) && defined(MBEDTLS_ENTROPY_NV_SEED)
- TEST_ASSERT( mbedtls_entropy_write_seed_file( &ctx, path )
- == MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
- TEST_ASSERT( mbedtls_entropy_update_seed_file( &ctx, path )
- == MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
+ TEST_ASSERT(mbedtls_entropy_write_seed_file(&ctx, path)
+ == MBEDTLS_ERR_ENTROPY_SOURCE_FAILED);
+ TEST_ASSERT(mbedtls_entropy_update_seed_file(&ctx, path)
+ == MBEDTLS_ERR_ENTROPY_SOURCE_FAILED);
#else
((void) path);
#endif
exit:
- mbedtls_entropy_free( &ctx );
+ mbedtls_entropy_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void entropy_threshold( int threshold, int chunk_size, int result )
+void entropy_threshold(int threshold, int chunk_size, int result)
{
mbedtls_entropy_context ctx;
entropy_dummy_context strong =
- {DUMMY_CONSTANT_LENGTH, MBEDTLS_ENTROPY_BLOCK_SIZE, 0};
- entropy_dummy_context weak = {DUMMY_CONSTANT_LENGTH, chunk_size, 0};
+ { DUMMY_CONSTANT_LENGTH, MBEDTLS_ENTROPY_BLOCK_SIZE, 0 };
+ entropy_dummy_context weak = { DUMMY_CONSTANT_LENGTH, chunk_size, 0 };
unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE] = { 0 };
int ret;
- mbedtls_entropy_init( &ctx );
- entropy_clear_sources( &ctx );
+ mbedtls_entropy_init(&ctx);
+ entropy_clear_sources(&ctx);
/* Set strong source that reaches its threshold immediately and
* a weak source whose threshold is a test parameter. */
- TEST_ASSERT( mbedtls_entropy_add_source( &ctx, entropy_dummy_source,
- &strong, 1,
- MBEDTLS_ENTROPY_SOURCE_STRONG ) == 0 );
- TEST_ASSERT( mbedtls_entropy_add_source( &ctx, entropy_dummy_source,
- &weak, threshold,
- MBEDTLS_ENTROPY_SOURCE_WEAK ) == 0 );
+ TEST_ASSERT(mbedtls_entropy_add_source(&ctx, entropy_dummy_source,
+ &strong, 1,
+ MBEDTLS_ENTROPY_SOURCE_STRONG) == 0);
+ TEST_ASSERT(mbedtls_entropy_add_source(&ctx, entropy_dummy_source,
+ &weak, threshold,
+ MBEDTLS_ENTROPY_SOURCE_WEAK) == 0);
- ret = mbedtls_entropy_func( &ctx, buf, sizeof( buf ) );
+ ret = mbedtls_entropy_func(&ctx, buf, sizeof(buf));
- if( result >= 0 )
- {
- TEST_ASSERT( ret == 0 );
+ if (result >= 0) {
+ TEST_ASSERT(ret == 0);
#if defined(MBEDTLS_ENTROPY_NV_SEED)
/* If the NV seed functionality is enabled, there are two entropy
* updates: before and after updating the NV seed. */
result *= 2;
#endif
- TEST_ASSERT( weak.calls == (size_t) result );
- }
- else
- {
- TEST_ASSERT( ret == result );
+ TEST_ASSERT(weak.calls == (size_t) result);
+ } else {
+ TEST_ASSERT(ret == result);
}
exit:
- mbedtls_entropy_free( &ctx );
+ mbedtls_entropy_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void entropy_calls( int strength1, int strength2,
- int threshold, int chunk_size,
- int result )
+void entropy_calls(int strength1, int strength2,
+ int threshold, int chunk_size,
+ int result)
{
/*
* if result >= 0: result = expected number of calls to source 1
@@ -347,101 +354,98 @@
*/
mbedtls_entropy_context ctx;
- entropy_dummy_context dummy1 = {DUMMY_CONSTANT_LENGTH, chunk_size, 0};
- entropy_dummy_context dummy2 = {DUMMY_CONSTANT_LENGTH, chunk_size, 0};
+ entropy_dummy_context dummy1 = { DUMMY_CONSTANT_LENGTH, chunk_size, 0 };
+ entropy_dummy_context dummy2 = { DUMMY_CONSTANT_LENGTH, chunk_size, 0 };
unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE] = { 0 };
int ret;
- mbedtls_entropy_init( &ctx );
- entropy_clear_sources( &ctx );
+ mbedtls_entropy_init(&ctx);
+ entropy_clear_sources(&ctx);
- TEST_ASSERT( mbedtls_entropy_add_source( &ctx, entropy_dummy_source,
- &dummy1, threshold,
- strength1 ) == 0 );
- TEST_ASSERT( mbedtls_entropy_add_source( &ctx, entropy_dummy_source,
- &dummy2, threshold,
- strength2 ) == 0 );
+ TEST_ASSERT(mbedtls_entropy_add_source(&ctx, entropy_dummy_source,
+ &dummy1, threshold,
+ strength1) == 0);
+ TEST_ASSERT(mbedtls_entropy_add_source(&ctx, entropy_dummy_source,
+ &dummy2, threshold,
+ strength2) == 0);
- ret = mbedtls_entropy_func( &ctx, buf, sizeof( buf ) );
+ ret = mbedtls_entropy_func(&ctx, buf, sizeof(buf));
- if( result >= 0 )
- {
- TEST_ASSERT( ret == 0 );
+ if (result >= 0) {
+ TEST_ASSERT(ret == 0);
#if defined(MBEDTLS_ENTROPY_NV_SEED)
/* If the NV seed functionality is enabled, there are two entropy
* updates: before and after updating the NV seed. */
result *= 2;
#endif
- TEST_ASSERT( dummy1.calls == (size_t) result );
- }
- else
- {
- TEST_ASSERT( ret == result );
+ TEST_ASSERT(dummy1.calls == (size_t) result);
+ } else {
+ TEST_ASSERT(ret == result);
}
exit:
- mbedtls_entropy_free( &ctx );
+ mbedtls_entropy_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO */
-void nv_seed_file_create( )
+void nv_seed_file_create()
{
unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
- memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
+ memset(buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE);
- TEST_ASSERT( write_nv_seed( buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
+ TEST_ASSERT(write_nv_seed(buf, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_FS_IO:MBEDTLS_PLATFORM_NV_SEED_ALT */
-void entropy_nv_seed_std_io( )
+void entropy_nv_seed_std_io()
{
unsigned char io_seed[MBEDTLS_ENTROPY_BLOCK_SIZE];
unsigned char check_seed[MBEDTLS_ENTROPY_BLOCK_SIZE];
- memset( io_seed, 1, MBEDTLS_ENTROPY_BLOCK_SIZE );
- memset( check_seed, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
+ memset(io_seed, 1, MBEDTLS_ENTROPY_BLOCK_SIZE);
+ memset(check_seed, 0, MBEDTLS_ENTROPY_BLOCK_SIZE);
- mbedtls_platform_set_nv_seed( mbedtls_platform_std_nv_seed_read,
- mbedtls_platform_std_nv_seed_write );
+ mbedtls_platform_set_nv_seed(mbedtls_platform_std_nv_seed_read,
+ mbedtls_platform_std_nv_seed_write);
/* Check if platform NV read and write manipulate the same data */
- TEST_ASSERT( write_nv_seed( io_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
- TEST_ASSERT( mbedtls_nv_seed_read( check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) ==
- MBEDTLS_ENTROPY_BLOCK_SIZE );
+ TEST_ASSERT(write_nv_seed(io_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+ TEST_ASSERT(mbedtls_nv_seed_read(check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) ==
+ MBEDTLS_ENTROPY_BLOCK_SIZE);
- TEST_ASSERT( memcmp( io_seed, check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
+ TEST_ASSERT(memcmp(io_seed, check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
- memset( check_seed, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
+ memset(check_seed, 0, MBEDTLS_ENTROPY_BLOCK_SIZE);
/* Check if platform NV write and raw read manipulate the same data */
- TEST_ASSERT( mbedtls_nv_seed_write( io_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) ==
- MBEDTLS_ENTROPY_BLOCK_SIZE );
- TEST_ASSERT( read_nv_seed( check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
+ TEST_ASSERT(mbedtls_nv_seed_write(io_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) ==
+ MBEDTLS_ENTROPY_BLOCK_SIZE);
+ TEST_ASSERT(read_nv_seed(check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
- TEST_ASSERT( memcmp( io_seed, check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
+ TEST_ASSERT(memcmp(io_seed, check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_MD_C:MBEDTLS_ENTROPY_NV_SEED:MBEDTLS_PLATFORM_NV_SEED_ALT */
-void entropy_nv_seed( data_t * read_seed )
+void entropy_nv_seed(data_t *read_seed)
{
#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
const mbedtls_md_info_t *md_info =
- mbedtls_md_info_from_type( MBEDTLS_MD_SHA512 );
+ mbedtls_md_info_from_type(MBEDTLS_MD_SHA512);
#elif defined(MBEDTLS_ENTROPY_SHA256_ACCUMULATOR)
const mbedtls_md_info_t *md_info =
- mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 );
+ mbedtls_md_info_from_type(MBEDTLS_MD_SHA256);
#else
#error "Unsupported entropy accumulator"
#endif
mbedtls_md_context_t accumulator;
mbedtls_entropy_context ctx;
- int (*original_mbedtls_nv_seed_read)( unsigned char *buf, size_t buf_len ) =
+ int (*original_mbedtls_nv_seed_read)(unsigned char *buf, size_t buf_len) =
mbedtls_nv_seed_read;
- int (*original_mbedtls_nv_seed_write)( unsigned char *buf, size_t buf_len ) =
+ int (*original_mbedtls_nv_seed_write)(unsigned char *buf, size_t buf_len) =
mbedtls_nv_seed_write;
unsigned char header[2];
@@ -451,80 +455,80 @@
unsigned char check_seed[MBEDTLS_ENTROPY_BLOCK_SIZE];
unsigned char check_entropy[MBEDTLS_ENTROPY_BLOCK_SIZE];
- memset( entropy, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
- memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
- memset( empty, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
- memset( check_seed, 2, MBEDTLS_ENTROPY_BLOCK_SIZE );
- memset( check_entropy, 3, MBEDTLS_ENTROPY_BLOCK_SIZE );
+ memset(entropy, 0, MBEDTLS_ENTROPY_BLOCK_SIZE);
+ memset(buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE);
+ memset(empty, 0, MBEDTLS_ENTROPY_BLOCK_SIZE);
+ memset(check_seed, 2, MBEDTLS_ENTROPY_BLOCK_SIZE);
+ memset(check_entropy, 3, MBEDTLS_ENTROPY_BLOCK_SIZE);
// Make sure we read/write NV seed from our buffers
- mbedtls_platform_set_nv_seed( buffer_nv_seed_read, buffer_nv_seed_write );
+ mbedtls_platform_set_nv_seed(buffer_nv_seed_read, buffer_nv_seed_write);
- mbedtls_md_init( &accumulator );
- mbedtls_entropy_init( &ctx );
- entropy_clear_sources( &ctx );
+ mbedtls_md_init(&accumulator);
+ mbedtls_entropy_init(&ctx);
+ entropy_clear_sources(&ctx);
- TEST_ASSERT( mbedtls_entropy_add_source( &ctx, mbedtls_nv_seed_poll, NULL,
- MBEDTLS_ENTROPY_BLOCK_SIZE,
- MBEDTLS_ENTROPY_SOURCE_STRONG ) == 0 );
+ TEST_ASSERT(mbedtls_entropy_add_source(&ctx, mbedtls_nv_seed_poll, NULL,
+ MBEDTLS_ENTROPY_BLOCK_SIZE,
+ MBEDTLS_ENTROPY_SOURCE_STRONG) == 0);
// Set the initial NV seed to read
- TEST_ASSERT( read_seed->len >= MBEDTLS_ENTROPY_BLOCK_SIZE );
- memcpy( buffer_seed, read_seed->x, MBEDTLS_ENTROPY_BLOCK_SIZE );
+ TEST_ASSERT(read_seed->len >= MBEDTLS_ENTROPY_BLOCK_SIZE);
+ memcpy(buffer_seed, read_seed->x, MBEDTLS_ENTROPY_BLOCK_SIZE);
// Do an entropy run
- TEST_ASSERT( mbedtls_entropy_func( &ctx, entropy, sizeof( entropy ) ) == 0 );
+ TEST_ASSERT(mbedtls_entropy_func(&ctx, entropy, sizeof(entropy)) == 0);
// Determine what should have happened with manual entropy internal logic
// Init accumulator
header[1] = MBEDTLS_ENTROPY_BLOCK_SIZE;
- TEST_ASSERT( mbedtls_md_setup( &accumulator, md_info, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_md_setup(&accumulator, md_info, 0) == 0);
// First run for updating write_seed
header[0] = 0;
- TEST_ASSERT( mbedtls_md_starts( &accumulator ) == 0 );
- TEST_ASSERT( mbedtls_md_update( &accumulator, header, 2 ) == 0 );
- TEST_ASSERT( mbedtls_md_update( &accumulator,
- read_seed->x, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
- TEST_ASSERT( mbedtls_md_finish( &accumulator, buf ) == 0 );
+ TEST_ASSERT(mbedtls_md_starts(&accumulator) == 0);
+ TEST_ASSERT(mbedtls_md_update(&accumulator, header, 2) == 0);
+ TEST_ASSERT(mbedtls_md_update(&accumulator,
+ read_seed->x, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+ TEST_ASSERT(mbedtls_md_finish(&accumulator, buf) == 0);
- TEST_ASSERT( mbedtls_md_starts( &accumulator ) == 0 );
- TEST_ASSERT( mbedtls_md_update( &accumulator,
- buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
+ TEST_ASSERT(mbedtls_md_starts(&accumulator) == 0);
+ TEST_ASSERT(mbedtls_md_update(&accumulator,
+ buf, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
- TEST_ASSERT( mbedtls_md( md_info, buf, MBEDTLS_ENTROPY_BLOCK_SIZE,
- check_seed ) == 0 );
+ TEST_ASSERT(mbedtls_md(md_info, buf, MBEDTLS_ENTROPY_BLOCK_SIZE,
+ check_seed) == 0);
// Second run for actual entropy (triggers mbedtls_entropy_update_nv_seed)
header[0] = MBEDTLS_ENTROPY_SOURCE_MANUAL;
- TEST_ASSERT( mbedtls_md_update( &accumulator, header, 2 ) == 0 );
- TEST_ASSERT( mbedtls_md_update( &accumulator,
- empty, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
+ TEST_ASSERT(mbedtls_md_update(&accumulator, header, 2) == 0);
+ TEST_ASSERT(mbedtls_md_update(&accumulator,
+ empty, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
header[0] = 0;
- TEST_ASSERT( mbedtls_md_update( &accumulator, header, 2 ) == 0 );
- TEST_ASSERT( mbedtls_md_update( &accumulator,
- check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
- TEST_ASSERT( mbedtls_md_finish( &accumulator, buf ) == 0 );
+ TEST_ASSERT(mbedtls_md_update(&accumulator, header, 2) == 0);
+ TEST_ASSERT(mbedtls_md_update(&accumulator,
+ check_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+ TEST_ASSERT(mbedtls_md_finish(&accumulator, buf) == 0);
- TEST_ASSERT( mbedtls_md( md_info, buf, MBEDTLS_ENTROPY_BLOCK_SIZE,
- check_entropy ) == 0 );
+ TEST_ASSERT(mbedtls_md(md_info, buf, MBEDTLS_ENTROPY_BLOCK_SIZE,
+ check_entropy) == 0);
// Check result of both NV file and entropy received with the manual calculations
- TEST_ASSERT( memcmp( check_seed, buffer_seed, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
- TEST_ASSERT( memcmp( check_entropy, entropy, MBEDTLS_ENTROPY_BLOCK_SIZE ) == 0 );
+ TEST_ASSERT(memcmp(check_seed, buffer_seed, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
+ TEST_ASSERT(memcmp(check_entropy, entropy, MBEDTLS_ENTROPY_BLOCK_SIZE) == 0);
exit:
- mbedtls_md_free( &accumulator );
- mbedtls_entropy_free( &ctx );
+ mbedtls_md_free(&accumulator);
+ mbedtls_entropy_free(&ctx);
mbedtls_nv_seed_read = original_mbedtls_nv_seed_read;
mbedtls_nv_seed_write = original_mbedtls_nv_seed_write;
}
/* END_CASE */
/* BEGIN_CASE depends_on:ENTROPY_HAVE_STRONG:MBEDTLS_SELF_TEST */
-void entropy_selftest( int result )
+void entropy_selftest(int result)
{
- TEST_ASSERT( mbedtls_entropy_self_test( 1 ) == result );
+ TEST_ASSERT(mbedtls_entropy_self_test(1) == result);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_error.function b/tests/suites/test_suite_error.function
index 68831ce..4c38ab0 100644
--- a/tests/suites/test_suite_error.function
+++ b/tests/suites/test_suite_error.function
@@ -8,14 +8,14 @@
*/
/* BEGIN_CASE */
-void error_strerror( int code, char * result_str )
+void error_strerror(int code, char *result_str)
{
char buf[500];
- memset( buf, 0, sizeof( buf ) );
+ memset(buf, 0, sizeof(buf));
- mbedtls_strerror( code, buf, 500 );
+ mbedtls_strerror(code, buf, 500);
- TEST_ASSERT( strcmp( buf, result_str ) == 0 );
+ TEST_ASSERT(strcmp(buf, result_str) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_gcm.function b/tests/suites/test_suite_gcm.function
index afe862d..b0c7bbc 100644
--- a/tests/suites/test_suite_gcm.function
+++ b/tests/suites/test_suite_gcm.function
@@ -8,107 +8,114 @@
*/
/* BEGIN_CASE */
-void gcm_bad_parameters( int cipher_id, int direction,
- data_t *key_str, data_t *src_str,
- data_t *iv_str, data_t *add_str,
- int tag_len_bits, int gcm_result )
+void gcm_bad_parameters(int cipher_id, int direction,
+ data_t *key_str, data_t *src_str,
+ data_t *iv_str, data_t *add_str,
+ int tag_len_bits, int gcm_result)
{
unsigned char output[128];
unsigned char tag_output[16];
mbedtls_gcm_context ctx;
size_t tag_len = tag_len_bits / 8;
- mbedtls_gcm_init( &ctx );
+ mbedtls_gcm_init(&ctx);
- memset( output, 0x00, sizeof( output ) );
- memset( tag_output, 0x00, sizeof( tag_output ) );
+ memset(output, 0x00, sizeof(output));
+ memset(tag_output, 0x00, sizeof(tag_output));
- TEST_ASSERT( mbedtls_gcm_setkey( &ctx, cipher_id, key_str->x, key_str->len * 8 ) == 0 );
- TEST_ASSERT( mbedtls_gcm_crypt_and_tag( &ctx, direction, src_str->len, iv_str->x, iv_str->len,
- add_str->x, add_str->len, src_str->x, output, tag_len, tag_output ) == gcm_result );
+ TEST_ASSERT(mbedtls_gcm_setkey(&ctx, cipher_id, key_str->x, key_str->len * 8) == 0);
+ TEST_ASSERT(mbedtls_gcm_crypt_and_tag(&ctx, direction, src_str->len, iv_str->x, iv_str->len,
+ add_str->x, add_str->len, src_str->x, output, tag_len,
+ tag_output) == gcm_result);
exit:
- mbedtls_gcm_free( &ctx );
+ mbedtls_gcm_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void gcm_encrypt_and_tag( int cipher_id, data_t * key_str,
- data_t * src_str, data_t * iv_str,
- data_t * add_str, data_t * dst,
- int tag_len_bits, data_t * tag,
- int init_result )
+void gcm_encrypt_and_tag(int cipher_id, data_t *key_str,
+ data_t *src_str, data_t *iv_str,
+ data_t *add_str, data_t *dst,
+ int tag_len_bits, data_t *tag,
+ int init_result)
{
unsigned char output[128];
unsigned char tag_output[16];
mbedtls_gcm_context ctx;
size_t tag_len = tag_len_bits / 8;
- mbedtls_gcm_init( &ctx );
+ mbedtls_gcm_init(&ctx);
memset(output, 0x00, 128);
memset(tag_output, 0x00, 16);
- TEST_ASSERT( mbedtls_gcm_setkey( &ctx, cipher_id, key_str->x, key_str->len * 8 ) == init_result );
- if( init_result == 0 )
- {
- TEST_ASSERT( mbedtls_gcm_crypt_and_tag( &ctx, MBEDTLS_GCM_ENCRYPT, src_str->len, iv_str->x, iv_str->len, add_str->x, add_str->len, src_str->x, output, tag_len, tag_output ) == 0 );
+ TEST_ASSERT(mbedtls_gcm_setkey(&ctx, cipher_id, key_str->x, key_str->len * 8) == init_result);
+ if (init_result == 0) {
+ TEST_ASSERT(mbedtls_gcm_crypt_and_tag(&ctx, MBEDTLS_GCM_ENCRYPT, src_str->len, iv_str->x,
+ iv_str->len, add_str->x, add_str->len, src_str->x,
+ output, tag_len, tag_output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
- src_str->len, dst->len ) == 0 );
- TEST_ASSERT( mbedtls_test_hexcmp( tag_output, tag->x,
- tag_len, tag->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
+ src_str->len, dst->len) == 0);
+ TEST_ASSERT(mbedtls_test_hexcmp(tag_output, tag->x,
+ tag_len, tag->len) == 0);
}
exit:
- mbedtls_gcm_free( &ctx );
+ mbedtls_gcm_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void gcm_decrypt_and_verify( int cipher_id, data_t * key_str,
- data_t * src_str, data_t * iv_str,
- data_t * add_str, int tag_len_bits,
- data_t * tag_str, char * result,
- data_t * pt_result, int init_result )
+void gcm_decrypt_and_verify(int cipher_id, data_t *key_str,
+ data_t *src_str, data_t *iv_str,
+ data_t *add_str, int tag_len_bits,
+ data_t *tag_str, char *result,
+ data_t *pt_result, int init_result)
{
unsigned char output[128];
mbedtls_gcm_context ctx;
int ret;
size_t tag_len = tag_len_bits / 8;
- mbedtls_gcm_init( &ctx );
+ mbedtls_gcm_init(&ctx);
memset(output, 0x00, 128);
- TEST_ASSERT( mbedtls_gcm_setkey( &ctx, cipher_id, key_str->x, key_str->len * 8 ) == init_result );
- if( init_result == 0 )
- {
- ret = mbedtls_gcm_auth_decrypt( &ctx, src_str->len, iv_str->x, iv_str->len, add_str->x, add_str->len, tag_str->x, tag_len, src_str->x, output );
+ TEST_ASSERT(mbedtls_gcm_setkey(&ctx, cipher_id, key_str->x, key_str->len * 8) == init_result);
+ if (init_result == 0) {
+ ret = mbedtls_gcm_auth_decrypt(&ctx,
+ src_str->len,
+ iv_str->x,
+ iv_str->len,
+ add_str->x,
+ add_str->len,
+ tag_str->x,
+ tag_len,
+ src_str->x,
+ output);
- if( strcmp( "FAIL", result ) == 0 )
- {
- TEST_ASSERT( ret == MBEDTLS_ERR_GCM_AUTH_FAILED );
- }
- else
- {
- TEST_ASSERT( ret == 0 );
+ if (strcmp("FAIL", result) == 0) {
+ TEST_ASSERT(ret == MBEDTLS_ERR_GCM_AUTH_FAILED);
+ } else {
+ TEST_ASSERT(ret == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, pt_result->x,
- src_str->len,
- pt_result->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, pt_result->x,
+ src_str->len,
+ pt_result->len) == 0);
}
}
exit:
- mbedtls_gcm_free( &ctx );
+ mbedtls_gcm_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void gcm_invalid_param( )
+void gcm_invalid_param()
{
mbedtls_gcm_context ctx;
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
@@ -117,168 +124,168 @@
int valid_len = sizeof(valid_buffer);
int valid_bitlen = 128, invalid_bitlen = 1;
- mbedtls_gcm_init( &ctx );
+ mbedtls_gcm_init(&ctx);
/* mbedtls_gcm_init() */
- TEST_INVALID_PARAM( mbedtls_gcm_init( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_gcm_init(NULL));
/* mbedtls_gcm_setkey */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_setkey( NULL, valid_cipher, valid_buffer, valid_bitlen ) );
+ mbedtls_gcm_setkey(NULL, valid_cipher, valid_buffer, valid_bitlen));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_setkey( &ctx, valid_cipher, NULL, valid_bitlen ) );
+ mbedtls_gcm_setkey(&ctx, valid_cipher, NULL, valid_bitlen));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_setkey( &ctx, valid_cipher, valid_buffer, invalid_bitlen ) );
+ mbedtls_gcm_setkey(&ctx, valid_cipher, valid_buffer, invalid_bitlen));
/* mbedtls_gcm_crypt_and_tag() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_crypt_and_tag( NULL, valid_mode, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- valid_len, valid_buffer ) );
+ mbedtls_gcm_crypt_and_tag(NULL, valid_mode, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ valid_len, valid_buffer));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
- NULL, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- valid_len, valid_buffer ) );
+ mbedtls_gcm_crypt_and_tag(&ctx, valid_mode, valid_len,
+ NULL, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ valid_len, valid_buffer));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
- valid_buffer, valid_len,
- NULL, valid_len,
- valid_buffer, valid_buffer,
- valid_len, valid_buffer ) );
+ mbedtls_gcm_crypt_and_tag(&ctx, valid_mode, valid_len,
+ valid_buffer, valid_len,
+ NULL, valid_len,
+ valid_buffer, valid_buffer,
+ valid_len, valid_buffer));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- NULL, valid_buffer,
- valid_len, valid_buffer ) );
+ mbedtls_gcm_crypt_and_tag(&ctx, valid_mode, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ NULL, valid_buffer,
+ valid_len, valid_buffer));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, NULL,
- valid_len, valid_buffer ) );
+ mbedtls_gcm_crypt_and_tag(&ctx, valid_mode, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, NULL,
+ valid_len, valid_buffer));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_crypt_and_tag( &ctx, valid_mode, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer,
- valid_len, NULL ) );
+ mbedtls_gcm_crypt_and_tag(&ctx, valid_mode, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer,
+ valid_len, NULL));
/* mbedtls_gcm_auth_decrypt() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_auth_decrypt( NULL, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer) );
+ mbedtls_gcm_auth_decrypt(NULL, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_auth_decrypt( &ctx, valid_len,
- NULL, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer) );
+ mbedtls_gcm_auth_decrypt(&ctx, valid_len,
+ NULL, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_auth_decrypt( &ctx, valid_len,
- valid_buffer, valid_len,
- NULL, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_buffer) );
+ mbedtls_gcm_auth_decrypt(&ctx, valid_len,
+ valid_buffer, valid_len,
+ NULL, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_buffer));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_auth_decrypt( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- NULL, valid_len,
- valid_buffer, valid_buffer) );
+ mbedtls_gcm_auth_decrypt(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ NULL, valid_len,
+ valid_buffer, valid_buffer));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_auth_decrypt( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- NULL, valid_buffer) );
+ mbedtls_gcm_auth_decrypt(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ NULL, valid_buffer));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_auth_decrypt( &ctx, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, valid_len,
- valid_buffer, NULL) );
+ mbedtls_gcm_auth_decrypt(&ctx, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len,
+ valid_buffer, NULL));
/* mbedtls_gcm_starts() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_starts( NULL, valid_mode,
- valid_buffer, valid_len,
- valid_buffer, valid_len ) );
+ mbedtls_gcm_starts(NULL, valid_mode,
+ valid_buffer, valid_len,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_starts( &ctx, valid_mode,
- NULL, valid_len,
- valid_buffer, valid_len ) );
+ mbedtls_gcm_starts(&ctx, valid_mode,
+ NULL, valid_len,
+ valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_starts( &ctx, valid_mode,
- valid_buffer, valid_len,
- NULL, valid_len ) );
+ mbedtls_gcm_starts(&ctx, valid_mode,
+ valid_buffer, valid_len,
+ NULL, valid_len));
/* mbedtls_gcm_update() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_update( NULL, valid_len,
- valid_buffer, valid_buffer ) );
+ mbedtls_gcm_update(NULL, valid_len,
+ valid_buffer, valid_buffer));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_update( &ctx, valid_len,
- NULL, valid_buffer ) );
+ mbedtls_gcm_update(&ctx, valid_len,
+ NULL, valid_buffer));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_update( &ctx, valid_len,
- valid_buffer, NULL ) );
+ mbedtls_gcm_update(&ctx, valid_len,
+ valid_buffer, NULL));
/* mbedtls_gcm_finish() */
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_finish( NULL, valid_buffer, valid_len ) );
+ mbedtls_gcm_finish(NULL, valid_buffer, valid_len));
TEST_INVALID_PARAM_RET(
MBEDTLS_ERR_GCM_BAD_INPUT,
- mbedtls_gcm_finish( &ctx, NULL, valid_len ) );
+ mbedtls_gcm_finish(&ctx, NULL, valid_len));
exit:
- mbedtls_gcm_free( &ctx );
+ mbedtls_gcm_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void gcm_valid_param( )
+void gcm_valid_param()
{
- TEST_VALID_PARAM( mbedtls_gcm_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_gcm_free(NULL));
exit:
return;
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST:MBEDTLS_AES_C */
-void gcm_selftest( )
+void gcm_selftest()
{
- TEST_ASSERT( mbedtls_gcm_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_gcm_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_hkdf.function b/tests/suites/test_suite_hkdf.function
index 4c597c3..2bfbf3c 100644
--- a/tests/suites/test_suite_hkdf.function
+++ b/tests/suites/test_suite_hkdf.function
@@ -9,29 +9,29 @@
*/
/* BEGIN_CASE */
-void test_hkdf( int md_alg, data_t *ikm, data_t *salt, data_t *info,
- data_t *expected_okm )
+void test_hkdf(int md_alg, data_t *ikm, data_t *salt, data_t *info,
+ data_t *expected_okm)
{
int ret;
unsigned char okm[128] = { '\0' };
- const mbedtls_md_info_t *md = mbedtls_md_info_from_type( md_alg );
- TEST_ASSERT( md != NULL );
+ const mbedtls_md_info_t *md = mbedtls_md_info_from_type(md_alg);
+ TEST_ASSERT(md != NULL);
- TEST_ASSERT( expected_okm->len <= sizeof( okm ) );
+ TEST_ASSERT(expected_okm->len <= sizeof(okm));
- ret = mbedtls_hkdf( md, salt->x, salt->len, ikm->x, ikm->len,
- info->x, info->len, okm, expected_okm->len );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_hkdf(md, salt->x, salt->len, ikm->x, ikm->len,
+ info->x, info->len, okm, expected_okm->len);
+ TEST_ASSERT(ret == 0);
- ASSERT_COMPARE( okm , expected_okm->len,
- expected_okm->x, expected_okm->len );
+ ASSERT_COMPARE(okm, expected_okm->len,
+ expected_okm->x, expected_okm->len);
}
/* END_CASE */
/* BEGIN_CASE */
-void test_hkdf_extract( int md_alg, char *hex_ikm_string,
- char *hex_salt_string, char *hex_prk_string )
+void test_hkdf_extract(int md_alg, char *hex_ikm_string,
+ char *hex_salt_string, char *hex_prk_string)
{
int ret;
unsigned char *ikm = NULL;
@@ -40,20 +40,20 @@
unsigned char *output_prk = NULL;
size_t ikm_len, salt_len, prk_len, output_prk_len;
- const mbedtls_md_info_t *md = mbedtls_md_info_from_type( md_alg );
- TEST_ASSERT( md != NULL );
+ const mbedtls_md_info_t *md = mbedtls_md_info_from_type(md_alg);
+ TEST_ASSERT(md != NULL);
- output_prk_len = mbedtls_md_get_size( md );
- output_prk = mbedtls_calloc( 1, output_prk_len );
+ output_prk_len = mbedtls_md_get_size(md);
+ output_prk = mbedtls_calloc(1, output_prk_len);
- ikm = mbedtls_test_unhexify_alloc( hex_ikm_string, &ikm_len );
- salt = mbedtls_test_unhexify_alloc( hex_salt_string, &salt_len );
- prk = mbedtls_test_unhexify_alloc( hex_prk_string, &prk_len );
+ ikm = mbedtls_test_unhexify_alloc(hex_ikm_string, &ikm_len);
+ salt = mbedtls_test_unhexify_alloc(hex_salt_string, &salt_len);
+ prk = mbedtls_test_unhexify_alloc(hex_prk_string, &prk_len);
- ret = mbedtls_hkdf_extract( md, salt, salt_len, ikm, ikm_len, output_prk );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_hkdf_extract(md, salt, salt_len, ikm, ikm_len, output_prk);
+ TEST_ASSERT(ret == 0);
- ASSERT_COMPARE( output_prk, output_prk_len, prk, prk_len );
+ ASSERT_COMPARE(output_prk, output_prk_len, prk, prk_len);
exit:
mbedtls_free(ikm);
@@ -64,8 +64,8 @@
/* END_CASE */
/* BEGIN_CASE */
-void test_hkdf_expand( int md_alg, char *hex_info_string,
- char *hex_prk_string, char *hex_okm_string )
+void test_hkdf_expand(int md_alg, char *hex_info_string,
+ char *hex_prk_string, char *hex_okm_string)
{
enum { OKM_LEN = 1024 };
int ret;
@@ -75,21 +75,21 @@
unsigned char *output_okm = NULL;
size_t info_len, prk_len, okm_len;
- const mbedtls_md_info_t *md = mbedtls_md_info_from_type( md_alg );
- TEST_ASSERT( md != NULL );
+ const mbedtls_md_info_t *md = mbedtls_md_info_from_type(md_alg);
+ TEST_ASSERT(md != NULL);
- output_okm = mbedtls_calloc( OKM_LEN, 1 );
+ output_okm = mbedtls_calloc(OKM_LEN, 1);
- prk = mbedtls_test_unhexify_alloc( hex_prk_string, &prk_len );
- info = mbedtls_test_unhexify_alloc( hex_info_string, &info_len );
- okm = mbedtls_test_unhexify_alloc( hex_okm_string, &okm_len );
- TEST_ASSERT( prk_len == mbedtls_md_get_size( md ) );
- TEST_ASSERT( okm_len < OKM_LEN );
+ prk = mbedtls_test_unhexify_alloc(hex_prk_string, &prk_len);
+ info = mbedtls_test_unhexify_alloc(hex_info_string, &info_len);
+ okm = mbedtls_test_unhexify_alloc(hex_okm_string, &okm_len);
+ TEST_ASSERT(prk_len == mbedtls_md_get_size(md));
+ TEST_ASSERT(okm_len < OKM_LEN);
- ret = mbedtls_hkdf_expand( md, prk, prk_len, info, info_len,
- output_okm, OKM_LEN );
- TEST_ASSERT( ret == 0 );
- ASSERT_COMPARE( output_okm, okm_len, okm, okm_len );
+ ret = mbedtls_hkdf_expand(md, prk, prk_len, info, info_len,
+ output_okm, OKM_LEN);
+ TEST_ASSERT(ret == 0);
+ ASSERT_COMPARE(output_okm, okm_len, okm, okm_len);
exit:
mbedtls_free(info);
@@ -100,7 +100,7 @@
/* END_CASE */
/* BEGIN_CASE */
-void test_hkdf_extract_ret( int hash_len, int ret )
+void test_hkdf_extract_ret(int hash_len, int ret)
{
int output_ret;
unsigned char *salt = NULL;
@@ -109,17 +109,17 @@
size_t salt_len, ikm_len;
struct mbedtls_md_info_t fake_md_info;
- memset( &fake_md_info, 0, sizeof( fake_md_info ) );
+ memset(&fake_md_info, 0, sizeof(fake_md_info));
fake_md_info.type = MBEDTLS_MD_NONE;
fake_md_info.size = hash_len;
- prk = mbedtls_calloc( MBEDTLS_MD_MAX_SIZE, 1 );
+ prk = mbedtls_calloc(MBEDTLS_MD_MAX_SIZE, 1);
salt_len = 0;
ikm_len = 0;
- output_ret = mbedtls_hkdf_extract( &fake_md_info, salt, salt_len,
- ikm, ikm_len, prk );
- TEST_ASSERT( output_ret == ret );
+ output_ret = mbedtls_hkdf_extract(&fake_md_info, salt, salt_len,
+ ikm, ikm_len, prk);
+ TEST_ASSERT(output_ret == ret);
exit:
mbedtls_free(prk);
@@ -127,7 +127,7 @@
/* END_CASE */
/* BEGIN_CASE */
-void test_hkdf_expand_ret( int hash_len, int prk_len, int okm_len, int ret )
+void test_hkdf_expand_ret(int hash_len, int prk_len, int okm_len, int ret)
{
int output_ret;
unsigned char *info = NULL;
@@ -136,21 +136,23 @@
size_t info_len;
struct mbedtls_md_info_t fake_md_info;
- memset( &fake_md_info, 0, sizeof( fake_md_info ) );
+ memset(&fake_md_info, 0, sizeof(fake_md_info));
fake_md_info.type = MBEDTLS_MD_NONE;
fake_md_info.size = hash_len;
info_len = 0;
- if (prk_len > 0)
- prk = mbedtls_calloc( prk_len, 1 );
+ if (prk_len > 0) {
+ prk = mbedtls_calloc(prk_len, 1);
+ }
- if (okm_len > 0)
- okm = mbedtls_calloc( okm_len, 1 );
+ if (okm_len > 0) {
+ okm = mbedtls_calloc(okm_len, 1);
+ }
- output_ret = mbedtls_hkdf_expand( &fake_md_info, prk, prk_len,
- info, info_len, okm, okm_len );
- TEST_ASSERT( output_ret == ret );
+ output_ret = mbedtls_hkdf_expand(&fake_md_info, prk, prk_len,
+ info, info_len, okm, okm_len);
+ TEST_ASSERT(output_ret == ret);
exit:
mbedtls_free(prk);
diff --git a/tests/suites/test_suite_hmac_drbg.function b/tests/suites/test_suite_hmac_drbg.function
index b83d760..830155a 100644
--- a/tests/suites/test_suite_hmac_drbg.function
+++ b/tests/suites/test_suite_hmac_drbg.function
@@ -2,25 +2,25 @@
#include "mbedtls/hmac_drbg.h"
#include "string.h"
-typedef struct
-{
+typedef struct {
unsigned char *p;
size_t len;
} entropy_ctx;
-static int mbedtls_test_entropy_func( void *data, unsigned char *buf, size_t len )
+static int mbedtls_test_entropy_func(void *data, unsigned char *buf, size_t len)
{
entropy_ctx *ctx = (entropy_ctx *) data;
- if( len > ctx->len )
- return( -1 );
+ if (len > ctx->len) {
+ return -1;
+ }
- memcpy( buf, ctx->p, len );
+ memcpy(buf, ctx->p, len);
ctx->p += len;
ctx->len -= len;
- return( 0 );
+ return 0;
}
/* END_HEADER */
@@ -30,7 +30,7 @@
*/
/* BEGIN_CASE */
-void hmac_drbg_entropy_usage( int md_alg )
+void hmac_drbg_entropy_usage(int md_alg)
{
unsigned char out[16];
unsigned char buf[1024];
@@ -41,112 +41,111 @@
size_t default_entropy_len;
size_t expected_consumed_entropy = 0;
- mbedtls_hmac_drbg_init( &ctx );
- memset( buf, 0, sizeof( buf ) );
- memset( out, 0, sizeof( out ) );
+ mbedtls_hmac_drbg_init(&ctx);
+ memset(buf, 0, sizeof(buf));
+ memset(out, 0, sizeof(out));
- entropy.len = sizeof( buf );
+ entropy.len = sizeof(buf);
entropy.p = buf;
- md_info = mbedtls_md_info_from_type( md_alg );
- TEST_ASSERT( md_info != NULL );
- if( mbedtls_md_get_size( md_info ) <= 20 )
+ md_info = mbedtls_md_info_from_type(md_alg);
+ TEST_ASSERT(md_info != NULL);
+ if (mbedtls_md_get_size(md_info) <= 20) {
default_entropy_len = 16;
- else if( mbedtls_md_get_size( md_info ) <= 28 )
+ } else if (mbedtls_md_get_size(md_info) <= 28) {
default_entropy_len = 24;
- else
+ } else {
default_entropy_len = 32;
+ }
/* Set reseed interval before seed */
- mbedtls_hmac_drbg_set_reseed_interval( &ctx, 2 * reps );
+ mbedtls_hmac_drbg_set_reseed_interval(&ctx, 2 * reps);
/* Init must use entropy */
- TEST_ASSERT( mbedtls_hmac_drbg_seed( &ctx, md_info, mbedtls_test_entropy_func, &entropy,
- NULL, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_hmac_drbg_seed(&ctx, md_info, mbedtls_test_entropy_func, &entropy,
+ NULL, 0) == 0);
/* default_entropy_len of entropy, plus half as much for the nonce */
expected_consumed_entropy += default_entropy_len * 3 / 2;
- TEST_EQUAL( sizeof( buf ) - entropy.len, expected_consumed_entropy );
+ TEST_EQUAL(sizeof(buf) - entropy.len, expected_consumed_entropy);
/* By default, PR is off, and reseed interval was set to
* 2 * reps so the next few calls should not use entropy */
- for( i = 0; i < reps; i++ )
- {
- TEST_ASSERT( mbedtls_hmac_drbg_random( &ctx, out, sizeof( out ) - 4 ) == 0 );
- TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, out, sizeof( out ) - 4,
- buf, 16 ) == 0 );
+ for (i = 0; i < reps; i++) {
+ TEST_ASSERT(mbedtls_hmac_drbg_random(&ctx, out, sizeof(out) - 4) == 0);
+ TEST_ASSERT(mbedtls_hmac_drbg_random_with_add(&ctx, out, sizeof(out) - 4,
+ buf, 16) == 0);
}
- TEST_EQUAL( sizeof( buf ) - entropy.len, expected_consumed_entropy );
+ TEST_EQUAL(sizeof(buf) - entropy.len, expected_consumed_entropy);
/* While at it, make sure we didn't write past the requested length */
- TEST_ASSERT( out[sizeof( out ) - 4] == 0 );
- TEST_ASSERT( out[sizeof( out ) - 3] == 0 );
- TEST_ASSERT( out[sizeof( out ) - 2] == 0 );
- TEST_ASSERT( out[sizeof( out ) - 1] == 0 );
+ TEST_ASSERT(out[sizeof(out) - 4] == 0);
+ TEST_ASSERT(out[sizeof(out) - 3] == 0);
+ TEST_ASSERT(out[sizeof(out) - 2] == 0);
+ TEST_ASSERT(out[sizeof(out) - 1] == 0);
/* There have been 2 * reps calls to random. The next call should reseed */
- TEST_ASSERT( mbedtls_hmac_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
+ TEST_ASSERT(mbedtls_hmac_drbg_random(&ctx, out, sizeof(out)) == 0);
expected_consumed_entropy += default_entropy_len;
- TEST_EQUAL( sizeof( buf ) - entropy.len, expected_consumed_entropy );
+ TEST_EQUAL(sizeof(buf) - entropy.len, expected_consumed_entropy);
/* Set reseed interval after seed */
- mbedtls_hmac_drbg_set_reseed_interval( &ctx, 4 * reps + 1);
+ mbedtls_hmac_drbg_set_reseed_interval(&ctx, 4 * reps + 1);
/* The new few calls should not reseed */
- for( i = 0; i < (2 * reps); i++ )
- {
- TEST_ASSERT( mbedtls_hmac_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
- TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, out, sizeof( out ) ,
- buf, 16 ) == 0 );
+ for (i = 0; i < (2 * reps); i++) {
+ TEST_ASSERT(mbedtls_hmac_drbg_random(&ctx, out, sizeof(out)) == 0);
+ TEST_ASSERT(mbedtls_hmac_drbg_random_with_add(&ctx, out, sizeof(out),
+ buf, 16) == 0);
}
- TEST_EQUAL( sizeof( buf ) - entropy.len, expected_consumed_entropy );
+ TEST_EQUAL(sizeof(buf) - entropy.len, expected_consumed_entropy);
/* Now enable PR, so the next few calls should all reseed */
- mbedtls_hmac_drbg_set_prediction_resistance( &ctx, MBEDTLS_HMAC_DRBG_PR_ON );
- TEST_ASSERT( mbedtls_hmac_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
+ mbedtls_hmac_drbg_set_prediction_resistance(&ctx, MBEDTLS_HMAC_DRBG_PR_ON);
+ TEST_ASSERT(mbedtls_hmac_drbg_random(&ctx, out, sizeof(out)) == 0);
expected_consumed_entropy += default_entropy_len;
- TEST_EQUAL( sizeof( buf ) - entropy.len, expected_consumed_entropy );
+ TEST_EQUAL(sizeof(buf) - entropy.len, expected_consumed_entropy);
/* Finally, check setting entropy_len */
- mbedtls_hmac_drbg_set_entropy_len( &ctx, 42 );
- TEST_ASSERT( mbedtls_hmac_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
+ mbedtls_hmac_drbg_set_entropy_len(&ctx, 42);
+ TEST_ASSERT(mbedtls_hmac_drbg_random(&ctx, out, sizeof(out)) == 0);
expected_consumed_entropy += 42;
- TEST_EQUAL( sizeof( buf ) - entropy.len, expected_consumed_entropy );
+ TEST_EQUAL(sizeof(buf) - entropy.len, expected_consumed_entropy);
- mbedtls_hmac_drbg_set_entropy_len( &ctx, 13 );
- TEST_ASSERT( mbedtls_hmac_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
+ mbedtls_hmac_drbg_set_entropy_len(&ctx, 13);
+ TEST_ASSERT(mbedtls_hmac_drbg_random(&ctx, out, sizeof(out)) == 0);
expected_consumed_entropy += 13;
- TEST_EQUAL( sizeof( buf ) - entropy.len, expected_consumed_entropy );
+ TEST_EQUAL(sizeof(buf) - entropy.len, expected_consumed_entropy);
exit:
- mbedtls_hmac_drbg_free( &ctx );
+ mbedtls_hmac_drbg_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO */
-void hmac_drbg_seed_file( int md_alg, char * path, int ret )
+void hmac_drbg_seed_file(int md_alg, char *path, int ret)
{
const mbedtls_md_info_t *md_info;
mbedtls_hmac_drbg_context ctx;
- mbedtls_hmac_drbg_init( &ctx );
+ mbedtls_hmac_drbg_init(&ctx);
- md_info = mbedtls_md_info_from_type( md_alg );
- TEST_ASSERT( md_info != NULL );
+ md_info = mbedtls_md_info_from_type(md_alg);
+ TEST_ASSERT(md_info != NULL);
- TEST_ASSERT( mbedtls_hmac_drbg_seed( &ctx, md_info,
- mbedtls_test_rnd_std_rand, NULL,
- NULL, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_hmac_drbg_seed(&ctx, md_info,
+ mbedtls_test_rnd_std_rand, NULL,
+ NULL, 0) == 0);
- TEST_ASSERT( mbedtls_hmac_drbg_write_seed_file( &ctx, path ) == ret );
- TEST_ASSERT( mbedtls_hmac_drbg_update_seed_file( &ctx, path ) == ret );
+ TEST_ASSERT(mbedtls_hmac_drbg_write_seed_file(&ctx, path) == ret);
+ TEST_ASSERT(mbedtls_hmac_drbg_update_seed_file(&ctx, path) == ret);
exit:
- mbedtls_hmac_drbg_free( &ctx );
+ mbedtls_hmac_drbg_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void hmac_drbg_buf( int md_alg )
+void hmac_drbg_buf(int md_alg)
{
unsigned char out[16];
unsigned char buf[100];
@@ -154,30 +153,31 @@
mbedtls_hmac_drbg_context ctx;
size_t i;
- mbedtls_hmac_drbg_init( &ctx );
- memset( buf, 0, sizeof( buf ) );
- memset( out, 0, sizeof( out ) );
+ mbedtls_hmac_drbg_init(&ctx);
+ memset(buf, 0, sizeof(buf));
+ memset(out, 0, sizeof(out));
- md_info = mbedtls_md_info_from_type( md_alg );
- TEST_ASSERT( md_info != NULL );
- TEST_ASSERT( mbedtls_hmac_drbg_seed_buf( &ctx, md_info, buf, sizeof( buf ) ) == 0 );
+ md_info = mbedtls_md_info_from_type(md_alg);
+ TEST_ASSERT(md_info != NULL);
+ TEST_ASSERT(mbedtls_hmac_drbg_seed_buf(&ctx, md_info, buf, sizeof(buf)) == 0);
/* Make sure it never tries to reseed (would segfault otherwise) */
- mbedtls_hmac_drbg_set_reseed_interval( &ctx, 3 );
- mbedtls_hmac_drbg_set_prediction_resistance( &ctx, MBEDTLS_HMAC_DRBG_PR_ON );
+ mbedtls_hmac_drbg_set_reseed_interval(&ctx, 3);
+ mbedtls_hmac_drbg_set_prediction_resistance(&ctx, MBEDTLS_HMAC_DRBG_PR_ON);
- for( i = 0; i < 30; i++ )
- TEST_ASSERT( mbedtls_hmac_drbg_random( &ctx, out, sizeof( out ) ) == 0 );
+ for (i = 0; i < 30; i++) {
+ TEST_ASSERT(mbedtls_hmac_drbg_random(&ctx, out, sizeof(out)) == 0);
+ }
exit:
- mbedtls_hmac_drbg_free( &ctx );
+ mbedtls_hmac_drbg_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void hmac_drbg_no_reseed( int md_alg, data_t * entropy,
- data_t * custom, data_t * add1,
- data_t * add2, data_t * output )
+void hmac_drbg_no_reseed(int md_alg, data_t *entropy,
+ data_t *custom, data_t *add1,
+ data_t *add2, data_t *output)
{
unsigned char data[1024];
unsigned char my_output[512];
@@ -185,111 +185,111 @@
const mbedtls_md_info_t *md_info;
mbedtls_hmac_drbg_context ctx;
- mbedtls_hmac_drbg_init( &ctx );
+ mbedtls_hmac_drbg_init(&ctx);
p_entropy.p = entropy->x;
p_entropy.len = entropy->len;
- md_info = mbedtls_md_info_from_type( md_alg );
- TEST_ASSERT( md_info != NULL );
+ md_info = mbedtls_md_info_from_type(md_alg);
+ TEST_ASSERT(md_info != NULL);
/* Test the simplified buffer-based variant */
- memcpy( data, entropy->x, p_entropy.len );
- memcpy( data + p_entropy.len, custom->x, custom->len );
- TEST_ASSERT( mbedtls_hmac_drbg_seed_buf( &ctx, md_info,
- data, p_entropy.len + custom->len ) == 0 );
- TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
- add1->x, add1->len ) == 0 );
- TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
- add2->x, add2->len ) == 0 );
+ memcpy(data, entropy->x, p_entropy.len);
+ memcpy(data + p_entropy.len, custom->x, custom->len);
+ TEST_ASSERT(mbedtls_hmac_drbg_seed_buf(&ctx, md_info,
+ data, p_entropy.len + custom->len) == 0);
+ TEST_ASSERT(mbedtls_hmac_drbg_random_with_add(&ctx, my_output, output->len,
+ add1->x, add1->len) == 0);
+ TEST_ASSERT(mbedtls_hmac_drbg_random_with_add(&ctx, my_output, output->len,
+ add2->x, add2->len) == 0);
/* Reset context for second run */
- mbedtls_hmac_drbg_free( &ctx );
+ mbedtls_hmac_drbg_free(&ctx);
- TEST_ASSERT( memcmp( my_output, output->x, output->len ) == 0 );
+ TEST_ASSERT(memcmp(my_output, output->x, output->len) == 0);
/* And now the normal entropy-based variant */
- TEST_ASSERT( mbedtls_hmac_drbg_seed( &ctx, md_info, mbedtls_test_entropy_func, &p_entropy,
- custom->x, custom->len ) == 0 );
- TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
- add1->x, add1->len ) == 0 );
- TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
- add2->x, add2->len ) == 0 );
- TEST_ASSERT( memcmp( my_output, output->x, output->len ) == 0 );
+ TEST_ASSERT(mbedtls_hmac_drbg_seed(&ctx, md_info, mbedtls_test_entropy_func, &p_entropy,
+ custom->x, custom->len) == 0);
+ TEST_ASSERT(mbedtls_hmac_drbg_random_with_add(&ctx, my_output, output->len,
+ add1->x, add1->len) == 0);
+ TEST_ASSERT(mbedtls_hmac_drbg_random_with_add(&ctx, my_output, output->len,
+ add2->x, add2->len) == 0);
+ TEST_ASSERT(memcmp(my_output, output->x, output->len) == 0);
exit:
- mbedtls_hmac_drbg_free( &ctx );
+ mbedtls_hmac_drbg_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void hmac_drbg_nopr( int md_alg, data_t * entropy, data_t * custom,
- data_t * add1, data_t * add2, data_t * add3,
- data_t * output )
+void hmac_drbg_nopr(int md_alg, data_t *entropy, data_t *custom,
+ data_t *add1, data_t *add2, data_t *add3,
+ data_t *output)
{
unsigned char my_output[512];
entropy_ctx p_entropy;
const mbedtls_md_info_t *md_info;
mbedtls_hmac_drbg_context ctx;
- mbedtls_hmac_drbg_init( &ctx );
+ mbedtls_hmac_drbg_init(&ctx);
p_entropy.p = entropy->x;
p_entropy.len = entropy->len;
- md_info = mbedtls_md_info_from_type( md_alg );
- TEST_ASSERT( md_info != NULL );
+ md_info = mbedtls_md_info_from_type(md_alg);
+ TEST_ASSERT(md_info != NULL);
- TEST_ASSERT( mbedtls_hmac_drbg_seed( &ctx, md_info, mbedtls_test_entropy_func, &p_entropy,
- custom->x, custom->len ) == 0 );
- TEST_ASSERT( mbedtls_hmac_drbg_reseed( &ctx, add1->x, add1->len ) == 0 );
- TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
- add2->x, add2->len ) == 0 );
- TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
- add3->x, add3->len ) == 0 );
+ TEST_ASSERT(mbedtls_hmac_drbg_seed(&ctx, md_info, mbedtls_test_entropy_func, &p_entropy,
+ custom->x, custom->len) == 0);
+ TEST_ASSERT(mbedtls_hmac_drbg_reseed(&ctx, add1->x, add1->len) == 0);
+ TEST_ASSERT(mbedtls_hmac_drbg_random_with_add(&ctx, my_output, output->len,
+ add2->x, add2->len) == 0);
+ TEST_ASSERT(mbedtls_hmac_drbg_random_with_add(&ctx, my_output, output->len,
+ add3->x, add3->len) == 0);
- TEST_ASSERT( memcmp( my_output, output->x, output->len ) == 0 );
+ TEST_ASSERT(memcmp(my_output, output->x, output->len) == 0);
exit:
- mbedtls_hmac_drbg_free( &ctx );
+ mbedtls_hmac_drbg_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void hmac_drbg_pr( int md_alg, data_t * entropy, data_t * custom,
- data_t * add1, data_t * add2, data_t * output )
+void hmac_drbg_pr(int md_alg, data_t *entropy, data_t *custom,
+ data_t *add1, data_t *add2, data_t *output)
{
unsigned char my_output[512];
entropy_ctx p_entropy;
const mbedtls_md_info_t *md_info;
mbedtls_hmac_drbg_context ctx;
- mbedtls_hmac_drbg_init( &ctx );
+ mbedtls_hmac_drbg_init(&ctx);
p_entropy.p = entropy->x;
p_entropy.len = entropy->len;
- md_info = mbedtls_md_info_from_type( md_alg );
- TEST_ASSERT( md_info != NULL );
+ md_info = mbedtls_md_info_from_type(md_alg);
+ TEST_ASSERT(md_info != NULL);
- TEST_ASSERT( mbedtls_hmac_drbg_seed( &ctx, md_info, mbedtls_test_entropy_func, &p_entropy,
- custom->x, custom->len ) == 0 );
- mbedtls_hmac_drbg_set_prediction_resistance( &ctx, MBEDTLS_HMAC_DRBG_PR_ON );
- TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
- add1->x, add1->len ) == 0 );
- TEST_ASSERT( mbedtls_hmac_drbg_random_with_add( &ctx, my_output, output->len,
- add2->x, add2->len ) == 0 );
+ TEST_ASSERT(mbedtls_hmac_drbg_seed(&ctx, md_info, mbedtls_test_entropy_func, &p_entropy,
+ custom->x, custom->len) == 0);
+ mbedtls_hmac_drbg_set_prediction_resistance(&ctx, MBEDTLS_HMAC_DRBG_PR_ON);
+ TEST_ASSERT(mbedtls_hmac_drbg_random_with_add(&ctx, my_output, output->len,
+ add1->x, add1->len) == 0);
+ TEST_ASSERT(mbedtls_hmac_drbg_random_with_add(&ctx, my_output, output->len,
+ add2->x, add2->len) == 0);
- TEST_ASSERT( memcmp( my_output, output->x, output->len ) == 0 );
+ TEST_ASSERT(memcmp(my_output, output->x, output->len) == 0);
exit:
- mbedtls_hmac_drbg_free( &ctx );
+ mbedtls_hmac_drbg_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void hmac_drbg_selftest( )
+void hmac_drbg_selftest()
{
- TEST_ASSERT( mbedtls_hmac_drbg_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_hmac_drbg_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_md.function b/tests/suites/test_suite_md.function
index da3e852..c875389 100644
--- a/tests/suites/test_suite_md.function
+++ b/tests/suites/test_suite_md.function
@@ -8,15 +8,15 @@
*/
/* BEGIN_CASE */
-void mbedtls_md_process( )
+void mbedtls_md_process()
{
const int *md_type_ptr;
const mbedtls_md_info_t *info;
mbedtls_md_context_t ctx;
unsigned char buf[150];
- mbedtls_md_init( &ctx );
- memset( buf, 0, sizeof( buf ) );
+ mbedtls_md_init(&ctx);
+ memset(buf, 0, sizeof(buf));
/*
* Very minimal testing of mbedtls_md_process, just make sure the various
@@ -26,159 +26,160 @@
*
* Also tests that mbedtls_md_list() only returns valid MDs.
*/
- for( md_type_ptr = mbedtls_md_list(); *md_type_ptr != 0; md_type_ptr++ )
- {
- info = mbedtls_md_info_from_type( *md_type_ptr );
- TEST_ASSERT( info != NULL );
- TEST_ASSERT( mbedtls_md_setup( &ctx, info, 0 ) == 0 );
- TEST_ASSERT( mbedtls_md_starts( &ctx ) == 0 );
- TEST_ASSERT( mbedtls_md_process( &ctx, buf ) == 0 );
- mbedtls_md_free( &ctx );
+ for (md_type_ptr = mbedtls_md_list(); *md_type_ptr != 0; md_type_ptr++) {
+ info = mbedtls_md_info_from_type(*md_type_ptr);
+ TEST_ASSERT(info != NULL);
+ TEST_ASSERT(mbedtls_md_setup(&ctx, info, 0) == 0);
+ TEST_ASSERT(mbedtls_md_starts(&ctx) == 0);
+ TEST_ASSERT(mbedtls_md_process(&ctx, buf) == 0);
+ mbedtls_md_free(&ctx);
}
exit:
- mbedtls_md_free( &ctx );
+ mbedtls_md_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void md_null_args( )
+void md_null_args()
{
mbedtls_md_context_t ctx;
- const mbedtls_md_info_t *info = mbedtls_md_info_from_type( *( mbedtls_md_list() ) );
+ const mbedtls_md_info_t *info = mbedtls_md_info_from_type(*(mbedtls_md_list()));
unsigned char buf[1] = { 0 };
- mbedtls_md_init( &ctx );
+ mbedtls_md_init(&ctx);
- TEST_ASSERT( mbedtls_md_get_size( NULL ) == 0 );
- TEST_ASSERT( mbedtls_md_get_type( NULL ) == MBEDTLS_MD_NONE );
- TEST_ASSERT( mbedtls_md_get_name( NULL ) == NULL );
+ TEST_ASSERT(mbedtls_md_get_size(NULL) == 0);
+ TEST_ASSERT(mbedtls_md_get_type(NULL) == MBEDTLS_MD_NONE);
+ TEST_ASSERT(mbedtls_md_get_name(NULL) == NULL);
- TEST_ASSERT( mbedtls_md_info_from_string( NULL ) == NULL );
+ TEST_ASSERT(mbedtls_md_info_from_string(NULL) == NULL);
- TEST_ASSERT( mbedtls_md_setup( &ctx, NULL, 0 ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- TEST_ASSERT( mbedtls_md_setup( NULL, info, 0 ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_md_setup(&ctx, NULL, 0) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
+ TEST_ASSERT(mbedtls_md_setup(NULL, info, 0) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_md_starts( NULL ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- TEST_ASSERT( mbedtls_md_starts( &ctx ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_md_starts(NULL) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
+ TEST_ASSERT(mbedtls_md_starts(&ctx) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_md_update( NULL, buf, 1 ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- TEST_ASSERT( mbedtls_md_update( &ctx, buf, 1 ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_md_update(NULL, buf, 1) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
+ TEST_ASSERT(mbedtls_md_update(&ctx, buf, 1) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_md_finish( NULL, buf ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- TEST_ASSERT( mbedtls_md_finish( &ctx, buf ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_md_finish(NULL, buf) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
+ TEST_ASSERT(mbedtls_md_finish(&ctx, buf) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_md( NULL, buf, 1, buf ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_md(NULL, buf, 1, buf) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
#if defined(MBEDTLS_FS_IO)
- TEST_ASSERT( mbedtls_md_file( NULL, "", buf ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_md_file(NULL, "", buf) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
#endif
- TEST_ASSERT( mbedtls_md_hmac_starts( NULL, buf, 1 )
- == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- TEST_ASSERT( mbedtls_md_hmac_starts( &ctx, buf, 1 )
- == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_md_hmac_starts(NULL, buf, 1)
+ == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
+ TEST_ASSERT(mbedtls_md_hmac_starts(&ctx, buf, 1)
+ == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_md_hmac_update( NULL, buf, 1 )
- == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- TEST_ASSERT( mbedtls_md_hmac_update( &ctx, buf, 1 )
- == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_md_hmac_update(NULL, buf, 1)
+ == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
+ TEST_ASSERT(mbedtls_md_hmac_update(&ctx, buf, 1)
+ == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_md_hmac_finish( NULL, buf )
- == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- TEST_ASSERT( mbedtls_md_hmac_finish( &ctx, buf )
- == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_md_hmac_finish(NULL, buf)
+ == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
+ TEST_ASSERT(mbedtls_md_hmac_finish(&ctx, buf)
+ == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_md_hmac_reset( NULL ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- TEST_ASSERT( mbedtls_md_hmac_reset( &ctx ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_md_hmac_reset(NULL) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
+ TEST_ASSERT(mbedtls_md_hmac_reset(&ctx) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_md_hmac( NULL, buf, 1, buf, 1, buf )
- == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_md_hmac(NULL, buf, 1, buf, 1, buf)
+ == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_md_process( NULL, buf ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- TEST_ASSERT( mbedtls_md_process( &ctx, buf ) == MBEDTLS_ERR_MD_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_md_process(NULL, buf) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
+ TEST_ASSERT(mbedtls_md_process(&ctx, buf) == MBEDTLS_ERR_MD_BAD_INPUT_DATA);
/* Ok, this is not NULL arg but NULL return... */
- TEST_ASSERT( mbedtls_md_info_from_type( MBEDTLS_MD_NONE ) == NULL );
- TEST_ASSERT( mbedtls_md_info_from_string( "no such md" ) == NULL );
+ TEST_ASSERT(mbedtls_md_info_from_type(MBEDTLS_MD_NONE) == NULL);
+ TEST_ASSERT(mbedtls_md_info_from_string("no such md") == NULL);
}
/* END_CASE */
/* BEGIN_CASE */
-void md_info( int md_type, char * md_name, int md_size )
+void md_info(int md_type, char *md_name, int md_size)
{
const mbedtls_md_info_t *md_info;
const int *md_type_ptr;
int found;
- md_info = mbedtls_md_info_from_type( md_type );
- TEST_ASSERT( md_info != NULL );
- TEST_ASSERT( md_info == mbedtls_md_info_from_string( md_name ) );
+ md_info = mbedtls_md_info_from_type(md_type);
+ TEST_ASSERT(md_info != NULL);
+ TEST_ASSERT(md_info == mbedtls_md_info_from_string(md_name));
- TEST_ASSERT( mbedtls_md_get_type( md_info ) == (mbedtls_md_type_t) md_type );
- TEST_ASSERT( mbedtls_md_get_size( md_info ) == (unsigned char) md_size );
- TEST_ASSERT( strcmp( mbedtls_md_get_name( md_info ), md_name ) == 0 );
+ TEST_ASSERT(mbedtls_md_get_type(md_info) == (mbedtls_md_type_t) md_type);
+ TEST_ASSERT(mbedtls_md_get_size(md_info) == (unsigned char) md_size);
+ TEST_ASSERT(strcmp(mbedtls_md_get_name(md_info), md_name) == 0);
found = 0;
- for( md_type_ptr = mbedtls_md_list(); *md_type_ptr != 0; md_type_ptr++ )
- if( *md_type_ptr == md_type )
+ for (md_type_ptr = mbedtls_md_list(); *md_type_ptr != 0; md_type_ptr++) {
+ if (*md_type_ptr == md_type) {
found = 1;
- TEST_ASSERT( found == 1 );
+ }
+ }
+ TEST_ASSERT(found == 1);
}
/* END_CASE */
/* BEGIN_CASE */
-void md_text( char * text_md_name, char * text_src_string,
- data_t * hash )
+void md_text(char *text_md_name, char *text_src_string,
+ data_t *hash)
{
char md_name[100];
unsigned char src_str[1000];
unsigned char output[100];
const mbedtls_md_info_t *md_info = NULL;
- memset( md_name, 0x00, 100 );
- memset( src_str, 0x00, 1000 );
- memset( output, 0x00, 100 );
+ memset(md_name, 0x00, 100);
+ memset(src_str, 0x00, 1000);
+ memset(output, 0x00, 100);
- strncpy( (char *) src_str, text_src_string, sizeof( src_str ) - 1 );
- strncpy( (char *) md_name, text_md_name, sizeof( md_name ) - 1 );
+ strncpy((char *) src_str, text_src_string, sizeof(src_str) - 1);
+ strncpy((char *) md_name, text_md_name, sizeof(md_name) - 1);
md_info = mbedtls_md_info_from_string(md_name);
- TEST_ASSERT( md_info != NULL );
+ TEST_ASSERT(md_info != NULL);
- TEST_ASSERT ( 0 == mbedtls_md( md_info, src_str, strlen( (char *) src_str ), output ) );
+ TEST_ASSERT(0 == mbedtls_md(md_info, src_str, strlen((char *) src_str), output));
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
- mbedtls_md_get_size( md_info ),
- hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x,
+ mbedtls_md_get_size(md_info),
+ hash->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void md_hex( char * text_md_name, data_t * src_str, data_t * hash )
+void md_hex(char *text_md_name, data_t *src_str, data_t *hash)
{
char md_name[100];
unsigned char output[100];
const mbedtls_md_info_t *md_info = NULL;
- memset( md_name, 0x00, 100 );
- memset( output, 0x00, 100 );
+ memset(md_name, 0x00, 100);
+ memset(output, 0x00, 100);
- strncpy( (char *) md_name, text_md_name, sizeof( md_name ) - 1 );
- md_info = mbedtls_md_info_from_string( md_name );
- TEST_ASSERT( md_info != NULL );
+ strncpy((char *) md_name, text_md_name, sizeof(md_name) - 1);
+ md_info = mbedtls_md_info_from_string(md_name);
+ TEST_ASSERT(md_info != NULL);
- TEST_ASSERT ( 0 == mbedtls_md( md_info, src_str->x, src_str->len, output ) );
+ TEST_ASSERT(0 == mbedtls_md(md_info, src_str->x, src_str->len, output));
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
- mbedtls_md_get_size( md_info ),
- hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x,
+ mbedtls_md_get_size(md_info),
+ hash->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void md_text_multi( char * text_md_name, char * text_src_string,
- data_t * hash )
+void md_text_multi(char *text_md_name, char *text_src_string,
+ data_t *hash)
{
char md_name[100];
unsigned char src_str[1000];
@@ -188,51 +189,51 @@
const mbedtls_md_info_t *md_info = NULL;
mbedtls_md_context_t ctx, ctx_copy;
- mbedtls_md_init( &ctx );
- mbedtls_md_init( &ctx_copy );
+ mbedtls_md_init(&ctx);
+ mbedtls_md_init(&ctx_copy);
- memset( md_name, 0x00, 100 );
- memset( src_str, 0x00, 1000 );
- memset( output, 0x00, 100 );
+ memset(md_name, 0x00, 100);
+ memset(src_str, 0x00, 1000);
+ memset(output, 0x00, 100);
- strncpy( (char *) src_str, text_src_string, sizeof(src_str) - 1 );
- strncpy( (char *) md_name, text_md_name, sizeof(md_name) - 1 );
- len = strlen( (char *) src_str );
+ strncpy((char *) src_str, text_src_string, sizeof(src_str) - 1);
+ strncpy((char *) md_name, text_md_name, sizeof(md_name) - 1);
+ len = strlen((char *) src_str);
halfway = len / 2;
md_info = mbedtls_md_info_from_string(md_name);
- TEST_ASSERT( md_info != NULL );
- TEST_ASSERT ( 0 == mbedtls_md_setup( &ctx, md_info, 0 ) );
- TEST_ASSERT ( 0 == mbedtls_md_setup( &ctx_copy, md_info, 0 ) );
+ TEST_ASSERT(md_info != NULL);
+ TEST_ASSERT(0 == mbedtls_md_setup(&ctx, md_info, 0));
+ TEST_ASSERT(0 == mbedtls_md_setup(&ctx_copy, md_info, 0));
- TEST_ASSERT ( 0 == mbedtls_md_starts( &ctx ) );
- TEST_ASSERT ( ctx.md_ctx != NULL );
- TEST_ASSERT ( 0 == mbedtls_md_update( &ctx, src_str, halfway ) );
- TEST_ASSERT ( 0 == mbedtls_md_clone( &ctx_copy, &ctx ) );
+ TEST_ASSERT(0 == mbedtls_md_starts(&ctx));
+ TEST_ASSERT(ctx.md_ctx != NULL);
+ TEST_ASSERT(0 == mbedtls_md_update(&ctx, src_str, halfway));
+ TEST_ASSERT(0 == mbedtls_md_clone(&ctx_copy, &ctx));
- TEST_ASSERT ( 0 == mbedtls_md_update( &ctx, src_str + halfway, len - halfway ) );
- TEST_ASSERT ( 0 == mbedtls_md_finish( &ctx, output ) );
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
- mbedtls_md_get_size( md_info ),
- hash->len) == 0 );
+ TEST_ASSERT(0 == mbedtls_md_update(&ctx, src_str + halfway, len - halfway));
+ TEST_ASSERT(0 == mbedtls_md_finish(&ctx, output));
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x,
+ mbedtls_md_get_size(md_info),
+ hash->len) == 0);
/* Test clone */
- memset( output, 0x00, 100 );
+ memset(output, 0x00, 100);
- TEST_ASSERT ( 0 == mbedtls_md_update( &ctx_copy, src_str + halfway, len - halfway ) );
- TEST_ASSERT ( 0 == mbedtls_md_finish( &ctx_copy, output ) );
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
- mbedtls_md_get_size( md_info ),
- hash->len ) == 0 );
+ TEST_ASSERT(0 == mbedtls_md_update(&ctx_copy, src_str + halfway, len - halfway));
+ TEST_ASSERT(0 == mbedtls_md_finish(&ctx_copy, output));
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x,
+ mbedtls_md_get_size(md_info),
+ hash->len) == 0);
exit:
- mbedtls_md_free( &ctx );
- mbedtls_md_free( &ctx_copy );
+ mbedtls_md_free(&ctx);
+ mbedtls_md_free(&ctx_copy);
}
/* END_CASE */
/* BEGIN_CASE */
-void md_hex_multi( char * text_md_name, data_t * src_str, data_t * hash )
+void md_hex_multi(char *text_md_name, data_t *src_str, data_t *hash)
{
char md_name[100];
unsigned char output[100];
@@ -240,73 +241,74 @@
mbedtls_md_context_t ctx, ctx_copy;
int halfway;
- mbedtls_md_init( &ctx );
- mbedtls_md_init( &ctx_copy );
+ mbedtls_md_init(&ctx);
+ mbedtls_md_init(&ctx_copy);
- memset( md_name, 0x00, 100 );
- memset( output, 0x00, 100 );
+ memset(md_name, 0x00, 100);
+ memset(output, 0x00, 100);
- strncpy( (char *) md_name, text_md_name, sizeof( md_name ) - 1 );
+ strncpy((char *) md_name, text_md_name, sizeof(md_name) - 1);
md_info = mbedtls_md_info_from_string(md_name);
- TEST_ASSERT( md_info != NULL );
- TEST_ASSERT ( 0 == mbedtls_md_setup( &ctx, md_info, 0 ) );
- TEST_ASSERT ( 0 == mbedtls_md_setup( &ctx_copy, md_info, 0 ) );
+ TEST_ASSERT(md_info != NULL);
+ TEST_ASSERT(0 == mbedtls_md_setup(&ctx, md_info, 0));
+ TEST_ASSERT(0 == mbedtls_md_setup(&ctx_copy, md_info, 0));
halfway = src_str->len / 2;
- TEST_ASSERT ( 0 == mbedtls_md_starts( &ctx ) );
- TEST_ASSERT ( ctx.md_ctx != NULL );
- TEST_ASSERT ( 0 == mbedtls_md_update( &ctx, src_str->x, halfway ) );
- TEST_ASSERT ( 0 == mbedtls_md_clone( &ctx_copy, &ctx ) );
+ TEST_ASSERT(0 == mbedtls_md_starts(&ctx));
+ TEST_ASSERT(ctx.md_ctx != NULL);
+ TEST_ASSERT(0 == mbedtls_md_update(&ctx, src_str->x, halfway));
+ TEST_ASSERT(0 == mbedtls_md_clone(&ctx_copy, &ctx));
- TEST_ASSERT ( 0 == mbedtls_md_update( &ctx, src_str->x + halfway, src_str->len - halfway) );
- TEST_ASSERT ( 0 == mbedtls_md_finish( &ctx, output ) );
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
- mbedtls_md_get_size( md_info ),
- hash->len ) == 0 );
+ TEST_ASSERT(0 == mbedtls_md_update(&ctx, src_str->x + halfway, src_str->len - halfway));
+ TEST_ASSERT(0 == mbedtls_md_finish(&ctx, output));
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x,
+ mbedtls_md_get_size(md_info),
+ hash->len) == 0);
/* Test clone */
- memset( output, 0x00, 100 );
+ memset(output, 0x00, 100);
- TEST_ASSERT ( 0 == mbedtls_md_update( &ctx_copy, src_str->x + halfway, src_str->len - halfway ) );
- TEST_ASSERT ( 0 == mbedtls_md_finish( &ctx_copy, output ) );
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
- mbedtls_md_get_size( md_info ),
- hash->len ) == 0 );
+ TEST_ASSERT(0 == mbedtls_md_update(&ctx_copy, src_str->x + halfway, src_str->len - halfway));
+ TEST_ASSERT(0 == mbedtls_md_finish(&ctx_copy, output));
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x,
+ mbedtls_md_get_size(md_info),
+ hash->len) == 0);
exit:
- mbedtls_md_free( &ctx );
- mbedtls_md_free( &ctx_copy );
+ mbedtls_md_free(&ctx);
+ mbedtls_md_free(&ctx_copy);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_md_hmac( char * text_md_name, int trunc_size,
- data_t * key_str, data_t * src_str,
- data_t * hash )
+void mbedtls_md_hmac(char *text_md_name, int trunc_size,
+ data_t *key_str, data_t *src_str,
+ data_t *hash)
{
char md_name[100];
unsigned char output[100];
const mbedtls_md_info_t *md_info = NULL;
- memset( md_name, 0x00, 100 );
- memset( output, 0x00, 100 );
+ memset(md_name, 0x00, 100);
+ memset(output, 0x00, 100);
- strncpy( (char *) md_name, text_md_name, sizeof( md_name ) - 1 );
- md_info = mbedtls_md_info_from_string( md_name );
- TEST_ASSERT( md_info != NULL );
+ strncpy((char *) md_name, text_md_name, sizeof(md_name) - 1);
+ md_info = mbedtls_md_info_from_string(md_name);
+ TEST_ASSERT(md_info != NULL);
- TEST_ASSERT ( mbedtls_md_hmac( md_info, key_str->x, key_str->len, src_str->x, src_str->len, output ) == 0 );
+ TEST_ASSERT(mbedtls_md_hmac(md_info, key_str->x, key_str->len, src_str->x, src_str->len,
+ output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
- trunc_size, hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x,
+ trunc_size, hash->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void md_hmac_multi( char * text_md_name, int trunc_size, data_t * key_str,
- data_t * src_str, data_t * hash )
+void md_hmac_multi(char *text_md_name, int trunc_size, data_t *key_str,
+ data_t *src_str, data_t *hash)
{
char md_name[100];
unsigned char output[100];
@@ -314,62 +316,62 @@
mbedtls_md_context_t ctx;
int halfway;
- mbedtls_md_init( &ctx );
+ mbedtls_md_init(&ctx);
- memset( md_name, 0x00, 100 );
- memset( output, 0x00, 100 );
+ memset(md_name, 0x00, 100);
+ memset(output, 0x00, 100);
- strncpy( (char *) md_name, text_md_name, sizeof( md_name ) - 1 );
- md_info = mbedtls_md_info_from_string( md_name );
- TEST_ASSERT( md_info != NULL );
- TEST_ASSERT ( 0 == mbedtls_md_setup( &ctx, md_info, 1 ) );
+ strncpy((char *) md_name, text_md_name, sizeof(md_name) - 1);
+ md_info = mbedtls_md_info_from_string(md_name);
+ TEST_ASSERT(md_info != NULL);
+ TEST_ASSERT(0 == mbedtls_md_setup(&ctx, md_info, 1));
halfway = src_str->len / 2;
- TEST_ASSERT ( 0 == mbedtls_md_hmac_starts( &ctx, key_str->x, key_str->len ) );
- TEST_ASSERT ( ctx.md_ctx != NULL );
- TEST_ASSERT ( 0 == mbedtls_md_hmac_update( &ctx, src_str->x, halfway ) );
- TEST_ASSERT ( 0 == mbedtls_md_hmac_update( &ctx, src_str->x + halfway, src_str->len - halfway ) );
- TEST_ASSERT ( 0 == mbedtls_md_hmac_finish( &ctx, output ) );
+ TEST_ASSERT(0 == mbedtls_md_hmac_starts(&ctx, key_str->x, key_str->len));
+ TEST_ASSERT(ctx.md_ctx != NULL);
+ TEST_ASSERT(0 == mbedtls_md_hmac_update(&ctx, src_str->x, halfway));
+ TEST_ASSERT(0 == mbedtls_md_hmac_update(&ctx, src_str->x + halfway, src_str->len - halfway));
+ TEST_ASSERT(0 == mbedtls_md_hmac_finish(&ctx, output));
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
- trunc_size, hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x,
+ trunc_size, hash->len) == 0);
/* Test again, for reset() */
- memset( output, 0x00, 100 );
+ memset(output, 0x00, 100);
- TEST_ASSERT ( 0 == mbedtls_md_hmac_reset( &ctx ) );
- TEST_ASSERT ( 0 == mbedtls_md_hmac_update( &ctx, src_str->x, halfway ) );
- TEST_ASSERT ( 0 == mbedtls_md_hmac_update( &ctx, src_str->x + halfway, src_str->len - halfway ) );
- TEST_ASSERT ( 0 == mbedtls_md_hmac_finish( &ctx, output ) );
+ TEST_ASSERT(0 == mbedtls_md_hmac_reset(&ctx));
+ TEST_ASSERT(0 == mbedtls_md_hmac_update(&ctx, src_str->x, halfway));
+ TEST_ASSERT(0 == mbedtls_md_hmac_update(&ctx, src_str->x + halfway, src_str->len - halfway));
+ TEST_ASSERT(0 == mbedtls_md_hmac_finish(&ctx, output));
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
- trunc_size, hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x,
+ trunc_size, hash->len) == 0);
exit:
- mbedtls_md_free( &ctx );
+ mbedtls_md_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO */
-void mbedtls_md_file( char * text_md_name, char * filename,
- data_t * hash )
+void mbedtls_md_file(char *text_md_name, char *filename,
+ data_t *hash)
{
char md_name[100];
unsigned char output[100];
const mbedtls_md_info_t *md_info = NULL;
- memset( md_name, 0x00, 100 );
- memset( output, 0x00, 100 );
+ memset(md_name, 0x00, 100);
+ memset(output, 0x00, 100);
- strncpy( (char *) md_name, text_md_name, sizeof( md_name ) - 1 );
- md_info = mbedtls_md_info_from_string( md_name );
- TEST_ASSERT( md_info != NULL );
+ strncpy((char *) md_name, text_md_name, sizeof(md_name) - 1);
+ md_info = mbedtls_md_info_from_string(md_name);
+ TEST_ASSERT(md_info != NULL);
- TEST_ASSERT( mbedtls_md_file( md_info, filename, output ) == 0 );
+ TEST_ASSERT(mbedtls_md_file(md_info, filename, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
- mbedtls_md_get_size( md_info ),
- hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x,
+ mbedtls_md_get_size(md_info),
+ hash->len) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_mdx.function b/tests/suites/test_suite_mdx.function
index aa35c58..452acf5 100644
--- a/tests/suites/test_suite_mdx.function
+++ b/tests/suites/test_suite_mdx.function
@@ -6,67 +6,67 @@
/* END_HEADER */
/* BEGIN_CASE depends_on:MBEDTLS_MD2_C */
-void md2_text( char * text_src_string, data_t * hash )
+void md2_text(char *text_src_string, data_t *hash)
{
int ret;
unsigned char src_str[100];
unsigned char output[16];
- memset( src_str, 0x00, sizeof src_str );
- memset( output, 0x00, sizeof output );
+ memset(src_str, 0x00, sizeof src_str);
+ memset(output, 0x00, sizeof output);
- strncpy( (char *) src_str, text_src_string, sizeof(src_str) - 1 );
+ strncpy((char *) src_str, text_src_string, sizeof(src_str) - 1);
- ret = mbedtls_md2_ret( src_str, strlen( (char *) src_str ), output );
- TEST_ASSERT( ret == 0 ) ;
+ ret = mbedtls_md2_ret(src_str, strlen((char *) src_str), output);
+ TEST_ASSERT(ret == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
- sizeof output, hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x,
+ sizeof output, hash->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_MD4_C */
-void md4_text( char * text_src_string, data_t * hash )
+void md4_text(char *text_src_string, data_t *hash)
{
int ret;
unsigned char src_str[100];
unsigned char output[16];
- memset( src_str, 0x00, sizeof src_str );
- memset( output, 0x00, sizeof output );
+ memset(src_str, 0x00, sizeof src_str);
+ memset(output, 0x00, sizeof output);
- strncpy( (char *) src_str, text_src_string, sizeof(src_str) - 1 );
+ strncpy((char *) src_str, text_src_string, sizeof(src_str) - 1);
- ret = mbedtls_md4_ret( src_str, strlen( (char *) src_str ), output );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_md4_ret(src_str, strlen((char *) src_str), output);
+ TEST_ASSERT(ret == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
- sizeof output, hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x,
+ sizeof output, hash->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_MD5_C */
-void md5_text( char * text_src_string, data_t * hash )
+void md5_text(char *text_src_string, data_t *hash)
{
int ret;
unsigned char src_str[100];
unsigned char output[16];
- memset( src_str, 0x00, sizeof src_str );
- memset( output, 0x00, sizeof output );
+ memset(src_str, 0x00, sizeof src_str);
+ memset(output, 0x00, sizeof output);
- strncpy( (char *) src_str, text_src_string, sizeof(src_str) - 1 );
+ strncpy((char *) src_str, text_src_string, sizeof(src_str) - 1);
- ret = mbedtls_md5_ret( src_str, strlen( (char *) src_str ), output );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_md5_ret(src_str, strlen((char *) src_str), output);
+ TEST_ASSERT(ret == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
- sizeof output, hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x,
+ sizeof output, hash->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RIPEMD160_C */
-void ripemd160_text( char * text_src_string, data_t * hash )
+void ripemd160_text(char *text_src_string, data_t *hash)
{
int ret;
unsigned char src_str[100];
@@ -75,40 +75,40 @@
memset(src_str, 0x00, sizeof src_str);
memset(output, 0x00, sizeof output);
- strncpy( (char *) src_str, text_src_string, sizeof(src_str) - 1 );
+ strncpy((char *) src_str, text_src_string, sizeof(src_str) - 1);
- ret = mbedtls_ripemd160_ret( src_str, strlen( (char *) src_str ), output );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_ripemd160_ret(src_str, strlen((char *) src_str), output);
+ TEST_ASSERT(ret == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x,
- sizeof output, hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x,
+ sizeof output, hash->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_MD2_C:MBEDTLS_SELF_TEST */
-void md2_selftest( )
+void md2_selftest()
{
- TEST_ASSERT( mbedtls_md2_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_md2_self_test(1) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_MD4_C:MBEDTLS_SELF_TEST */
-void md4_selftest( )
+void md4_selftest()
{
- TEST_ASSERT( mbedtls_md4_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_md4_self_test(1) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_MD5_C:MBEDTLS_SELF_TEST */
-void md5_selftest( )
+void md5_selftest()
{
- TEST_ASSERT( mbedtls_md5_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_md5_self_test(1) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RIPEMD160_C:MBEDTLS_SELF_TEST */
-void ripemd160_selftest( )
+void ripemd160_selftest()
{
- TEST_ASSERT( mbedtls_ripemd160_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_ripemd160_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_memory_buffer_alloc.function b/tests/suites/test_suite_memory_buffer_alloc.function
index cc884c2..2b81097 100644
--- a/tests/suites/test_suite_memory_buffer_alloc.function
+++ b/tests/suites/test_suite_memory_buffer_alloc.function
@@ -10,34 +10,36 @@
*/
/* BEGIN_SUITE_HELPERS */
-static int check_pointer( void *p )
+static int check_pointer(void *p)
{
- if( p == NULL )
- return( -1 );
+ if (p == NULL) {
+ return -1;
+ }
- if( (size_t) p % MBEDTLS_MEMORY_ALIGN_MULTIPLE != 0 )
- return( -1 );
+ if ((size_t) p % MBEDTLS_MEMORY_ALIGN_MULTIPLE != 0) {
+ return -1;
+ }
- return( 0 );
+ return 0;
}
/* END_SUITE_HELPERS */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void mbedtls_memory_buffer_alloc_self_test( )
+void mbedtls_memory_buffer_alloc_self_test()
{
- TEST_ASSERT( mbedtls_memory_buffer_alloc_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_self_test(1) == 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void memory_buffer_alloc_free_alloc( int a_bytes, int b_bytes, int c_bytes,
- int d_bytes, int free_a, int free_b,
- int free_c, int free_d, int e_bytes,
- int f_bytes )
+void memory_buffer_alloc_free_alloc(int a_bytes, int b_bytes, int c_bytes,
+ int d_bytes, int free_a, int free_b,
+ int free_c, int free_d, int e_bytes,
+ int f_bytes)
{
unsigned char buf[1024];
unsigned char *ptr_a = NULL, *ptr_b = NULL, *ptr_c = NULL, *ptr_d = NULL,
- *ptr_e = NULL, *ptr_f = NULL;
+ *ptr_e = NULL, *ptr_f = NULL;
#if defined(MBEDTLS_MEMORY_DEBUG)
size_t reported_blocks;
@@ -45,98 +47,88 @@
#endif
size_t allocated_bytes = 0;
- mbedtls_memory_buffer_alloc_init( buf, sizeof( buf ) );
+ mbedtls_memory_buffer_alloc_init(buf, sizeof(buf));
- mbedtls_memory_buffer_set_verify( MBEDTLS_MEMORY_VERIFY_ALWAYS );
+ mbedtls_memory_buffer_set_verify(MBEDTLS_MEMORY_VERIFY_ALWAYS);
- if( a_bytes > 0 )
- {
- ptr_a = mbedtls_calloc( a_bytes, sizeof(char) );
- TEST_ASSERT( check_pointer( ptr_a ) == 0 );
+ if (a_bytes > 0) {
+ ptr_a = mbedtls_calloc(a_bytes, sizeof(char));
+ TEST_ASSERT(check_pointer(ptr_a) == 0);
allocated_bytes += a_bytes * sizeof(char);
}
- if( b_bytes > 0 )
- {
- ptr_b = mbedtls_calloc( b_bytes, sizeof(char) );
- TEST_ASSERT( check_pointer( ptr_b ) == 0 );
+ if (b_bytes > 0) {
+ ptr_b = mbedtls_calloc(b_bytes, sizeof(char));
+ TEST_ASSERT(check_pointer(ptr_b) == 0);
allocated_bytes += b_bytes * sizeof(char);
}
- if( c_bytes > 0 )
- {
- ptr_c = mbedtls_calloc( c_bytes, sizeof(char) );
- TEST_ASSERT( check_pointer( ptr_c ) == 0 );
+ if (c_bytes > 0) {
+ ptr_c = mbedtls_calloc(c_bytes, sizeof(char));
+ TEST_ASSERT(check_pointer(ptr_c) == 0);
allocated_bytes += c_bytes * sizeof(char);
}
- if( d_bytes > 0 )
- {
- ptr_d = mbedtls_calloc( d_bytes, sizeof(char) );
- TEST_ASSERT( check_pointer( ptr_d ) == 0 );
+ if (d_bytes > 0) {
+ ptr_d = mbedtls_calloc(d_bytes, sizeof(char));
+ TEST_ASSERT(check_pointer(ptr_d) == 0);
allocated_bytes += d_bytes * sizeof(char);
}
#if defined(MBEDTLS_MEMORY_DEBUG)
- mbedtls_memory_buffer_alloc_cur_get( &reported_bytes, &reported_blocks );
- TEST_ASSERT( reported_bytes == allocated_bytes );
+ mbedtls_memory_buffer_alloc_cur_get(&reported_bytes, &reported_blocks);
+ TEST_ASSERT(reported_bytes == allocated_bytes);
#endif
- if( free_a )
- {
- mbedtls_free( ptr_a );
+ if (free_a) {
+ mbedtls_free(ptr_a);
ptr_a = NULL;
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0);
allocated_bytes -= a_bytes * sizeof(char);
}
- if( free_b )
- {
- mbedtls_free( ptr_b );
+ if (free_b) {
+ mbedtls_free(ptr_b);
ptr_b = NULL;
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0);
allocated_bytes -= b_bytes * sizeof(char);
}
- if( free_c )
- {
- mbedtls_free( ptr_c );
+ if (free_c) {
+ mbedtls_free(ptr_c);
ptr_c = NULL;
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0);
allocated_bytes -= c_bytes * sizeof(char);
}
- if( free_d )
- {
- mbedtls_free( ptr_d );
+ if (free_d) {
+ mbedtls_free(ptr_d);
ptr_d = NULL;
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0);
allocated_bytes -= d_bytes * sizeof(char);
}
#if defined(MBEDTLS_MEMORY_DEBUG)
- mbedtls_memory_buffer_alloc_cur_get( &reported_bytes, &reported_blocks );
- TEST_ASSERT( reported_bytes == allocated_bytes );
+ mbedtls_memory_buffer_alloc_cur_get(&reported_bytes, &reported_blocks);
+ TEST_ASSERT(reported_bytes == allocated_bytes);
#endif
- if( e_bytes > 0 )
- {
- ptr_e = mbedtls_calloc( e_bytes, sizeof(char) );
- TEST_ASSERT( check_pointer( ptr_e ) == 0 );
+ if (e_bytes > 0) {
+ ptr_e = mbedtls_calloc(e_bytes, sizeof(char));
+ TEST_ASSERT(check_pointer(ptr_e) == 0);
}
- if( f_bytes > 0 )
- {
- ptr_f = mbedtls_calloc( f_bytes, sizeof(char) );
- TEST_ASSERT( check_pointer( ptr_f ) == 0 );
+ if (f_bytes > 0) {
+ ptr_f = mbedtls_calloc(f_bytes, sizeof(char));
+ TEST_ASSERT(check_pointer(ptr_f) == 0);
}
/* Once blocks are reallocated, the block allocated to the memory request
@@ -144,61 +136,55 @@
* bytes, and makes it hard to know what the reported size will be, so
* we don't check the size after blocks have been reallocated. */
- if( ptr_a != NULL )
- {
- mbedtls_free( ptr_a );
+ if (ptr_a != NULL) {
+ mbedtls_free(ptr_a);
ptr_a = NULL;
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0);
}
- if( ptr_b != NULL )
- {
- mbedtls_free( ptr_b );
+ if (ptr_b != NULL) {
+ mbedtls_free(ptr_b);
ptr_b = NULL;
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0);
}
- if( ptr_c != NULL )
- {
- mbedtls_free( ptr_c );
+ if (ptr_c != NULL) {
+ mbedtls_free(ptr_c);
ptr_c = NULL;
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0);
}
- if( ptr_d != NULL )
- {
- mbedtls_free( ptr_d );
+ if (ptr_d != NULL) {
+ mbedtls_free(ptr_d);
ptr_d = NULL;
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0);
}
- if( ptr_e != NULL )
- {
- mbedtls_free( ptr_e );
+ if (ptr_e != NULL) {
+ mbedtls_free(ptr_e);
ptr_e = NULL;
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0);
}
- if( ptr_f != NULL )
- {
- mbedtls_free( ptr_f );
+ if (ptr_f != NULL) {
+ mbedtls_free(ptr_f);
ptr_f = NULL;
}
#if defined(MBEDTLS_MEMORY_DEBUG)
- mbedtls_memory_buffer_alloc_cur_get( &reported_bytes, &reported_blocks );
- TEST_ASSERT( reported_bytes == 0 );
+ mbedtls_memory_buffer_alloc_cur_get(&reported_bytes, &reported_blocks);
+ TEST_ASSERT(reported_bytes == 0);
#endif
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0);
exit:
- mbedtls_memory_buffer_alloc_free( );
+ mbedtls_memory_buffer_alloc_free();
}
/* END_CASE */
/* BEGIN_CASE */
-void memory_buffer_alloc_oom_test( )
+void memory_buffer_alloc_oom_test()
{
unsigned char buf[1024];
unsigned char *ptr_a = NULL, *ptr_b = NULL, *ptr_c = NULL;
@@ -206,71 +192,70 @@
size_t reported_blocks, reported_bytes;
#endif
- (void)ptr_c;
+ (void) ptr_c;
- mbedtls_memory_buffer_alloc_init( buf, sizeof( buf ) );
+ mbedtls_memory_buffer_alloc_init(buf, sizeof(buf));
- mbedtls_memory_buffer_set_verify( MBEDTLS_MEMORY_VERIFY_ALWAYS );
+ mbedtls_memory_buffer_set_verify(MBEDTLS_MEMORY_VERIFY_ALWAYS);
- ptr_a = mbedtls_calloc( 432, sizeof(char) );
- TEST_ASSERT( check_pointer( ptr_a ) == 0 );
+ ptr_a = mbedtls_calloc(432, sizeof(char));
+ TEST_ASSERT(check_pointer(ptr_a) == 0);
- ptr_b = mbedtls_calloc( 432, sizeof(char) );
- TEST_ASSERT( check_pointer( ptr_b ) == 0 );
+ ptr_b = mbedtls_calloc(432, sizeof(char));
+ TEST_ASSERT(check_pointer(ptr_b) == 0);
- ptr_c = mbedtls_calloc( 431, sizeof(char) );
- TEST_ASSERT( ptr_c == NULL );
+ ptr_c = mbedtls_calloc(431, sizeof(char));
+ TEST_ASSERT(ptr_c == NULL);
#if defined(MBEDTLS_MEMORY_DEBUG)
- mbedtls_memory_buffer_alloc_cur_get( &reported_bytes, &reported_blocks );
- TEST_ASSERT( reported_bytes >= 864 && reported_bytes <= sizeof(buf) );
+ mbedtls_memory_buffer_alloc_cur_get(&reported_bytes, &reported_blocks);
+ TEST_ASSERT(reported_bytes >= 864 && reported_bytes <= sizeof(buf));
#endif
- mbedtls_free( ptr_a );
+ mbedtls_free(ptr_a);
ptr_a = NULL;
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0);
- mbedtls_free( ptr_b );
+ mbedtls_free(ptr_b);
ptr_b = NULL;
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0);
#if defined(MBEDTLS_MEMORY_DEBUG)
- mbedtls_memory_buffer_alloc_cur_get( &reported_bytes, &reported_blocks );
- TEST_ASSERT( reported_bytes == 0 );
+ mbedtls_memory_buffer_alloc_cur_get(&reported_bytes, &reported_blocks);
+ TEST_ASSERT(reported_bytes == 0);
#endif
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0);
exit:
- mbedtls_memory_buffer_alloc_free( );
+ mbedtls_memory_buffer_alloc_free();
}
/* END_CASE */
/* BEGIN_CASE */
-void memory_buffer_heap_too_small( )
+void memory_buffer_heap_too_small()
{
unsigned char buf[1];
- mbedtls_memory_buffer_alloc_init( buf, sizeof( buf ) );
+ mbedtls_memory_buffer_alloc_init(buf, sizeof(buf));
/* With MBEDTLS_MEMORY_DEBUG enabled, this prints a message
* "FATAL: verification of first header failed".
*/
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() != 0 );
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() != 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void memory_buffer_underalloc( )
+void memory_buffer_underalloc()
{
unsigned char buf[100];
size_t i;
- mbedtls_memory_buffer_alloc_init( buf, sizeof( buf ) );
- for( i = 1; i < MBEDTLS_MEMORY_ALIGN_MULTIPLE; i++ )
- {
- TEST_ASSERT( mbedtls_calloc( 1,
- (size_t)-( MBEDTLS_MEMORY_ALIGN_MULTIPLE - i ) ) == NULL );
- TEST_ASSERT( mbedtls_memory_buffer_alloc_verify() == 0 );
+ mbedtls_memory_buffer_alloc_init(buf, sizeof(buf));
+ for (i = 1; i < MBEDTLS_MEMORY_ALIGN_MULTIPLE; i++) {
+ TEST_ASSERT(mbedtls_calloc(1,
+ (size_t) -(MBEDTLS_MEMORY_ALIGN_MULTIPLE - i)) == NULL);
+ TEST_ASSERT(mbedtls_memory_buffer_alloc_verify() == 0);
}
exit:
diff --git a/tests/suites/test_suite_mps.function b/tests/suites/test_suite_mps.function
index 5ef3288..a9ccf22 100644
--- a/tests/suites/test_suite_mps.function
+++ b/tests/suites/test_suite_mps.function
@@ -25,7 +25,7 @@
*/
/* BEGIN_CASE depends_on:TEST_SUITE_MPS_READER */
-void mbedtls_mps_reader_no_pausing_single_step_single_round( int with_acc )
+void mbedtls_mps_reader_no_pausing_single_step_single_round(int with_acc)
{
/* This test exercises the most basic use of the MPS reader:
* - The 'producing' layer provides a buffer
@@ -46,29 +46,31 @@
unsigned char *tmp;
int paused;
mbedtls_mps_reader rd;
- for( size_t i=0; (unsigned) i < sizeof( bufA ); i++ )
+ for (size_t i = 0; (unsigned) i < sizeof(bufA); i++) {
bufA[i] = (unsigned char) i;
+ }
/* Preparation (lower layer) */
- if( with_acc == 0 )
- mbedtls_mps_reader_init( &rd, NULL, 0 );
- else
- mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
+ if (with_acc == 0) {
+ mbedtls_mps_reader_init(&rd, NULL, 0);
+ } else {
+ mbedtls_mps_reader_init(&rd, acc, sizeof(acc));
+ }
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufA, sizeof(bufA)) == 0);
/* Consumption (upper layer) */
/* Consume exactly what's available */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 100, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 100, bufA, 100 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 100, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 100, bufA, 100);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
/* Wrapup (lower layer) */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, &paused ) == 0 );
- TEST_ASSERT( paused == 0 );
- mbedtls_mps_reader_free( &rd );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, &paused) == 0);
+ TEST_ASSERT(paused == 0);
+ mbedtls_mps_reader_free(&rd);
}
/* END_CASE */
/* BEGIN_CASE depends_on:TEST_SUITE_MPS_READER */
-void mbedtls_mps_reader_no_pausing_single_step_multiple_rounds( int with_acc )
+void mbedtls_mps_reader_no_pausing_single_step_multiple_rounds(int with_acc)
{
/* This test exercises multiple rounds of the basic use of the MPS reader:
* - The 'producing' layer provides a buffer
@@ -89,37 +91,40 @@
unsigned char acc[10];
unsigned char *tmp;
mbedtls_mps_reader rd;
- for( size_t i=0; (unsigned) i < sizeof( bufA ); i++ )
+ for (size_t i = 0; (unsigned) i < sizeof(bufA); i++) {
bufA[i] = (unsigned char) i;
- for( size_t i=0; (unsigned) i < sizeof( bufB ); i++ )
- bufB[i] = ~ ((unsigned char) i);
+ }
+ for (size_t i = 0; (unsigned) i < sizeof(bufB); i++) {
+ bufB[i] = ~((unsigned char) i);
+ }
/* Preparation (lower layer) */
- if( with_acc == 0 )
- mbedtls_mps_reader_init( &rd, NULL, 0 );
- else
- mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
+ if (with_acc == 0) {
+ mbedtls_mps_reader_init(&rd, NULL, 0);
+ } else {
+ mbedtls_mps_reader_init(&rd, acc, sizeof(acc));
+ }
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufA, sizeof(bufA)) == 0);
/* Consumption (upper layer) */
/* Consume exactly what's available */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 100, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 100, bufA, 100 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 100, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 100, bufA, 100);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
/* Preparation */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufB, sizeof(bufB)) == 0);
/* Consumption */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 100, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 100, bufB, 100 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 100, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 100, bufB, 100);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
/* Wrapup (lower layer) */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
- mbedtls_mps_reader_free( &rd );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
+ mbedtls_mps_reader_free(&rd);
}
/* END_CASE */
/* BEGIN_CASE depends_on:TEST_SUITE_MPS_READER */
-void mbedtls_mps_reader_no_pausing_multiple_steps_single_round( int with_acc )
+void mbedtls_mps_reader_no_pausing_multiple_steps_single_round(int with_acc)
{
/* This test exercises one round of the following:
* - The 'producing' layer provides a buffer
@@ -144,31 +149,33 @@
unsigned char *tmp;
mbedtls_mps_size_t tmp_len;
mbedtls_mps_reader rd;
- for( size_t i=0; (unsigned) i < sizeof( buf ); i++ )
+ for (size_t i = 0; (unsigned) i < sizeof(buf); i++) {
buf[i] = (unsigned char) i;
+ }
/* Preparation (lower layer) */
- if( with_acc == 0 )
- mbedtls_mps_reader_init( &rd, NULL, 0 );
- else
- mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
+ if (with_acc == 0) {
+ mbedtls_mps_reader_init(&rd, NULL, 0);
+ } else {
+ mbedtls_mps_reader_init(&rd, acc, sizeof(acc));
+ }
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, buf, sizeof(buf)) == 0);
/* Consumption (upper layer) */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, buf, 10 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 70, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 70, buf + 10, 70 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 30, &tmp, &tmp_len ) == 0 );
- ASSERT_COMPARE( tmp, tmp_len, buf + 80, 20 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, buf, 10);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 70, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 70, buf + 10, 70);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 30, &tmp, &tmp_len) == 0);
+ ASSERT_COMPARE(tmp, tmp_len, buf + 80, 20);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
/* Wrapup (lower layer) */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
- mbedtls_mps_reader_free( &rd );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
+ mbedtls_mps_reader_free(&rd);
}
/* END_CASE */
/* BEGIN_CASE depends_on:TEST_SUITE_MPS_READER */
-void mbedtls_mps_reader_no_pausing_multiple_steps_multiple_rounds( int with_acc )
+void mbedtls_mps_reader_no_pausing_multiple_steps_multiple_rounds(int with_acc)
{
/* This test exercises one round of fetching a buffer in multiple chunks
* and passing it back to the producer afterwards, followed by another
@@ -179,35 +186,38 @@
unsigned char *tmp;
mbedtls_mps_size_t tmp_len;
mbedtls_mps_reader rd;
- for( size_t i=0; (unsigned) i < sizeof( bufA ); i++ )
+ for (size_t i = 0; (unsigned) i < sizeof(bufA); i++) {
bufA[i] = (unsigned char) i;
- for( size_t i=0; (unsigned) i < sizeof( bufB ); i++ )
- bufB[i] = ~ ((unsigned char) i);
+ }
+ for (size_t i = 0; (unsigned) i < sizeof(bufB); i++) {
+ bufB[i] = ~((unsigned char) i);
+ }
/* Preparation (lower layer) */
- if( with_acc == 0 )
- mbedtls_mps_reader_init( &rd, NULL, 0 );
- else
- mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
+ if (with_acc == 0) {
+ mbedtls_mps_reader_init(&rd, NULL, 0);
+ } else {
+ mbedtls_mps_reader_init(&rd, acc, sizeof(acc));
+ }
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufA, sizeof(bufA)) == 0);
/* Consumption (upper layer) */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA, 10 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 70, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 70, bufA + 10, 70 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 30, &tmp, &tmp_len ) == 0 );
- ASSERT_COMPARE( tmp, tmp_len, bufA + 80, 20 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA, 10);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 70, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 70, bufA + 10, 70);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 30, &tmp, &tmp_len) == 0);
+ ASSERT_COMPARE(tmp, tmp_len, bufA + 80, 20);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
/* Preparation */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufB, sizeof(bufB)) == 0);
/* Consumption */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 100, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 100, bufB, 100 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 100, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 100, bufB, 100);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
/* Wrapup */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
- mbedtls_mps_reader_free( &rd );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
+ mbedtls_mps_reader_free(&rd);
}
/* END_CASE */
@@ -224,22 +234,23 @@
unsigned char buf[100];
unsigned char *tmp;
mbedtls_mps_reader rd;
- for( size_t i=0; (unsigned) i < sizeof( buf ); i++ )
+ for (size_t i = 0; (unsigned) i < sizeof(buf); i++) {
buf[i] = (unsigned char) i;
+ }
/* Preparation (lower layer) */
- mbedtls_mps_reader_init( &rd, NULL, 0 );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
+ mbedtls_mps_reader_init(&rd, NULL, 0);
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, buf, sizeof(buf)) == 0);
/* Consumption (upper layer) */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 50, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 50, buf, 50 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 100, &tmp, NULL ) ==
- MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 50, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 50, buf, 50);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 100, &tmp, NULL) ==
+ MBEDTLS_ERR_MPS_READER_OUT_OF_DATA);
/* Wrapup (lower layer) */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) ==
- MBEDTLS_ERR_MPS_READER_NEED_ACCUMULATOR );
- mbedtls_mps_reader_free( &rd );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) ==
+ MBEDTLS_ERR_MPS_READER_NEED_ACCUMULATOR);
+ mbedtls_mps_reader_free(&rd);
}
/* END_CASE */
@@ -264,28 +275,29 @@
mbedtls_mps_reader rd;
mbedtls_mps_size_t tmp_len;
- for( size_t i=0; (unsigned) i < sizeof( buf ); i++ )
+ for (size_t i = 0; (unsigned) i < sizeof(buf); i++) {
buf[i] = (unsigned char) i;
+ }
/* Preparation (lower layer) */
- mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
+ mbedtls_mps_reader_init(&rd, acc, sizeof(acc));
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, buf, sizeof(buf)) == 0);
/* Consumption (upper layer) */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 50, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 50, buf, 50 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, buf + 50, 10 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 100, &tmp, NULL ) ==
- MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 50, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 50, buf, 50);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, buf + 50, 10);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 100, &tmp, NULL) ==
+ MBEDTLS_ERR_MPS_READER_OUT_OF_DATA);
/* Wrapup (lower layer) */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) ==
- MBEDTLS_ERR_MPS_READER_ACCUMULATOR_TOO_SMALL );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) ==
+ MBEDTLS_ERR_MPS_READER_ACCUMULATOR_TOO_SMALL);
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 50, &tmp, &tmp_len ) == 0 );
- ASSERT_COMPARE( tmp, tmp_len, buf + 50, 50 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 50, &tmp, &tmp_len) == 0);
+ ASSERT_COMPARE(tmp, tmp_len, buf + 50, 50);
- mbedtls_mps_reader_free( &rd );
+ mbedtls_mps_reader_free(&rd);
}
/* END_CASE */
@@ -304,28 +316,29 @@
unsigned char *tmp;
mbedtls_mps_reader rd;
- for( size_t i=0; (unsigned) i < sizeof( buf ); i++ )
+ for (size_t i = 0; (unsigned) i < sizeof(buf); i++) {
buf[i] = (unsigned char) i;
+ }
/* Preparation (lower layer) */
- mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
+ mbedtls_mps_reader_init(&rd, acc, sizeof(acc));
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, buf, sizeof(buf)) == 0);
/* Consumption (upper layer) */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 50, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 50, buf, 50 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 50, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 50, buf, 50);
/* Excess request */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, (mbedtls_mps_size_t) -1, &tmp, NULL ) ==
- MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, (mbedtls_mps_size_t) -1, &tmp, NULL) ==
+ MBEDTLS_ERR_MPS_READER_OUT_OF_DATA);
/* Wrapup (lower layer) */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) ==
- MBEDTLS_ERR_MPS_READER_ACCUMULATOR_TOO_SMALL );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) ==
+ MBEDTLS_ERR_MPS_READER_ACCUMULATOR_TOO_SMALL);
- mbedtls_mps_reader_free( &rd );
+ mbedtls_mps_reader_free(&rd);
}
/* END_CASE */
/* BEGIN_CASE depends_on:TEST_SUITE_MPS_READER */
-void mbedtls_mps_reader_pausing( int option )
+void mbedtls_mps_reader_pausing(int option)
{
/* This test exercises the behaviour of the reader when the
* accumulator is used to fulfill a consumer's request.
@@ -349,108 +362,108 @@
unsigned char acc[40];
int paused;
mbedtls_mps_reader rd;
- for( size_t i=0; (unsigned) i < sizeof( bufA ); i++ )
+ for (size_t i = 0; (unsigned) i < sizeof(bufA); i++) {
bufA[i] = (unsigned char) i;
- for( size_t i=0; (unsigned) i < sizeof( bufB ); i++ )
- bufB[i] = ~ ((unsigned char) i);
+ }
+ for (size_t i = 0; (unsigned) i < sizeof(bufB); i++) {
+ bufB[i] = ~((unsigned char) i);
+ }
/* Preparation (lower layer) */
- mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
+ mbedtls_mps_reader_init(&rd, acc, sizeof(acc));
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufA, sizeof(bufA)) == 0);
/* Consumption (upper layer) */
/* Ask for more than what's available. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 80, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 80, bufA, 80 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
- switch( option )
- {
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 80, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 80, bufA, 80);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 80, 10);
+ switch (option) {
case 0: /* Single uncommitted fetch at pausing */
case 1:
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
break;
default: /* Multiple uncommitted fetches at pausing */
break;
}
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) ==
- MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) ==
+ MBEDTLS_ERR_MPS_READER_OUT_OF_DATA);
/* Preparation */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, &paused ) == 0 );
- TEST_ASSERT( paused == 1 );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, &paused) == 0);
+ TEST_ASSERT(paused == 1);
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufB, sizeof(bufB)) == 0);
/* Consumption */
- switch( option )
- {
+ switch (option) {
case 0: /* Single fetch at pausing, re-fetch with commit. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
- ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 90, 10);
+ ASSERT_COMPARE(tmp + 10, 10, bufB, 10);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
break;
case 1: /* Single fetch at pausing, re-fetch without commit. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
- ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 90, 10);
+ ASSERT_COMPARE(tmp + 10, 10, bufB, 10);
break;
case 2: /* Multiple fetches at pausing, repeat without commit. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
- ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 80, 10);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 90, 10);
+ ASSERT_COMPARE(tmp + 10, 10, bufB, 10);
break;
case 3: /* Multiple fetches at pausing, repeat with commit 1. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
- ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 80, 10);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 90, 10);
+ ASSERT_COMPARE(tmp + 10, 10, bufB, 10);
break;
case 4: /* Multiple fetches at pausing, repeat with commit 2. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
- ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 80, 10);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 90, 10);
+ ASSERT_COMPARE(tmp + 10, 10, bufB, 10);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
break;
case 5: /* Multiple fetches at pausing, repeat with commit 3. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
- ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 80, 10);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 90, 10);
+ ASSERT_COMPARE(tmp + 10, 10, bufB, 10);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
break;
default:
- TEST_ASSERT( 0 );
+ TEST_ASSERT(0);
}
/* In all cases, fetch the rest of the second buffer. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 90, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 90, bufB + 10, 90 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 90, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 90, bufB + 10, 90);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
/* Wrapup */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
- mbedtls_mps_reader_free( &rd );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
+ mbedtls_mps_reader_free(&rd);
}
/* END_CASE */
/* BEGIN_CASE depends_on:TEST_SUITE_MPS_READER */
-void mbedtls_mps_reader_pausing_multiple_feeds( int option )
+void mbedtls_mps_reader_pausing_multiple_feeds(int option)
{
/* This test exercises the behaviour of the MPS reader
* in the following situation:
@@ -471,93 +484,91 @@
unsigned char acc[70];
mbedtls_mps_reader rd;
mbedtls_mps_size_t fetch_len;
- for( size_t i=0; (unsigned) i < sizeof( bufA ); i++ )
+ for (size_t i = 0; (unsigned) i < sizeof(bufA); i++) {
bufA[i] = (unsigned char) i;
- for( size_t i=0; (unsigned) i < sizeof( bufB ); i++ )
- bufB[i] = ~ ((unsigned char) i);
+ }
+ for (size_t i = 0; (unsigned) i < sizeof(bufB); i++) {
+ bufB[i] = ~((unsigned char) i);
+ }
/* Preparation (lower layer) */
- mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
+ mbedtls_mps_reader_init(&rd, acc, sizeof(acc));
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufA, sizeof(bufA)) == 0);
/* Consumption (upper layer) */
/* Ask for more than what's available. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 80, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 80, bufA, 80 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 80, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 80, bufA, 80);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
/* 20 left, ask for 70 -> 50 overhead */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 70, &tmp, NULL ) ==
- MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 70, &tmp, NULL) ==
+ MBEDTLS_ERR_MPS_READER_OUT_OF_DATA);
/* Preparation */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
- switch( option )
- {
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
+ switch (option) {
case 0: /* 10 + 10 + 80 byte feed */
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB, 10 ) ==
- MBEDTLS_ERR_MPS_READER_NEED_MORE );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB + 10, 10 ) ==
- MBEDTLS_ERR_MPS_READER_NEED_MORE );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB + 20, 80 ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufB, 10) ==
+ MBEDTLS_ERR_MPS_READER_NEED_MORE);
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufB + 10, 10) ==
+ MBEDTLS_ERR_MPS_READER_NEED_MORE);
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufB + 20, 80) == 0);
break;
case 1: /* 50 x 1byte */
- for( size_t num_feed = 0; num_feed < 49; num_feed++ )
- {
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB + num_feed, 1 ) ==
- MBEDTLS_ERR_MPS_READER_NEED_MORE );
+ for (size_t num_feed = 0; num_feed < 49; num_feed++) {
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufB + num_feed, 1) ==
+ MBEDTLS_ERR_MPS_READER_NEED_MORE);
}
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB + 49, 1 ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufB + 49, 1) == 0);
break;
case 2: /* 49 x 1byte + 51bytes */
- for( size_t num_feed = 0; num_feed < 49; num_feed++ )
- {
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB + num_feed, 1 ) ==
- MBEDTLS_ERR_MPS_READER_NEED_MORE );
+ for (size_t num_feed = 0; num_feed < 49; num_feed++) {
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufB + num_feed, 1) ==
+ MBEDTLS_ERR_MPS_READER_NEED_MORE);
}
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB + 49, 51 ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufB + 49, 51) == 0);
break;
default:
- TEST_ASSERT( 0 );
+ TEST_ASSERT(0);
break;
}
/* Consumption */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 70, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 20, bufA + 80, 20 );
- ASSERT_COMPARE( tmp + 20, 50, bufB, 50 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 1000, &tmp, &fetch_len ) == 0 );
- switch( option )
- {
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 70, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 20, bufA + 80, 20);
+ ASSERT_COMPARE(tmp + 20, 50, bufB, 50);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 1000, &tmp, &fetch_len) == 0);
+ switch (option) {
case 0:
- TEST_ASSERT( fetch_len == 50 );
+ TEST_ASSERT(fetch_len == 50);
break;
case 1:
- TEST_ASSERT( fetch_len == 0 );
+ TEST_ASSERT(fetch_len == 0);
break;
case 2:
- TEST_ASSERT( fetch_len == 50 );
+ TEST_ASSERT(fetch_len == 50);
break;
default:
- TEST_ASSERT( 0 );
+ TEST_ASSERT(0);
break;
}
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
/* Wrapup */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
- mbedtls_mps_reader_free( &rd );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
+ mbedtls_mps_reader_free(&rd);
}
/* END_CASE */
/* BEGIN_CASE depends_on:TEST_SUITE_MPS_READER */
-void mbedtls_mps_reader_reclaim_data_left( int option )
+void mbedtls_mps_reader_reclaim_data_left(int option)
{
/* This test exercises the behaviour of the MPS reader when a
* call to mbedtls_mps_reader_reclaim() is made before all data
@@ -566,53 +577,53 @@
unsigned char buf[100];
unsigned char *tmp;
mbedtls_mps_reader rd;
- for( size_t i=0; (unsigned) i < sizeof( buf ); i++ )
+ for (size_t i = 0; (unsigned) i < sizeof(buf); i++) {
buf[i] = (unsigned char) i;
+ }
/* Preparation (lower layer) */
- mbedtls_mps_reader_init( &rd, NULL, 0 );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
+ mbedtls_mps_reader_init(&rd, NULL, 0);
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, buf, sizeof(buf)) == 0);
/* Consumption (upper layer) */
- switch( option )
- {
+ switch (option) {
case 0:
/* Fetch (but not commit) the entire buffer. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, sizeof( buf ), &tmp, NULL )
- == 0 );
- ASSERT_COMPARE( tmp, 100, buf, 100 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, sizeof(buf), &tmp, NULL)
+ == 0);
+ ASSERT_COMPARE(tmp, 100, buf, 100);
break;
case 1:
/* Fetch (but not commit) parts of the buffer. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, sizeof( buf ) / 2,
- &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, sizeof( buf ) / 2, buf, sizeof( buf ) / 2 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, sizeof(buf) / 2,
+ &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, sizeof(buf) / 2, buf, sizeof(buf) / 2);
break;
case 2:
/* Fetch and commit parts of the buffer, then
* fetch but not commit the rest of the buffer. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, sizeof( buf ) / 2,
- &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, sizeof( buf ) / 2, buf, sizeof( buf ) / 2 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, sizeof( buf ) / 2,
- &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, sizeof( buf ) / 2,
- buf + sizeof( buf ) / 2,
- sizeof( buf ) / 2 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, sizeof(buf) / 2,
+ &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, sizeof(buf) / 2, buf, sizeof(buf) / 2);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, sizeof(buf) / 2,
+ &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, sizeof(buf) / 2,
+ buf + sizeof(buf) / 2,
+ sizeof(buf) / 2);
break;
default:
- TEST_ASSERT( 0 );
+ TEST_ASSERT(0);
break;
}
/* Wrapup */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) ==
- MBEDTLS_ERR_MPS_READER_DATA_LEFT );
- mbedtls_mps_reader_free( &rd );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) ==
+ MBEDTLS_ERR_MPS_READER_DATA_LEFT);
+ mbedtls_mps_reader_free(&rd);
}
/* END_CASE */
@@ -626,33 +637,34 @@
unsigned char *tmp;
mbedtls_mps_reader rd;
- for( size_t i=0; (unsigned) i < sizeof( buf ); i++ )
+ for (size_t i = 0; (unsigned) i < sizeof(buf); i++) {
buf[i] = (unsigned char) i;
+ }
/* Preparation (lower layer) */
- mbedtls_mps_reader_init( &rd, NULL, 0 );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
+ mbedtls_mps_reader_init(&rd, NULL, 0);
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, buf, sizeof(buf)) == 0);
/* Consumption (upper layer) */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 50, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 50, buf, 50 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 50, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 50, buf + 50, 50 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 50, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 50, buf, 50);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 50, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 50, buf + 50, 50);
/* Preparation */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) ==
- MBEDTLS_ERR_MPS_READER_DATA_LEFT );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) ==
+ MBEDTLS_ERR_MPS_READER_DATA_LEFT);
/* Consumption */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 50, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 50, buf + 50, 50 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 50, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 50, buf + 50, 50);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
/* Wrapup */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
- mbedtls_mps_reader_free( &rd );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
+ mbedtls_mps_reader_free(&rd);
}
/* END_CASE */
/* BEGIN_CASE depends_on:TEST_SUITE_MPS_READER */
-void mbedtls_mps_reader_multiple_pausing( int option )
+void mbedtls_mps_reader_multiple_pausing(int option)
{
/* This test exercises the behaviour of the MPS reader
* in the following situation:
@@ -670,126 +682,128 @@
unsigned char acc[50];
mbedtls_mps_size_t tmp_len;
mbedtls_mps_reader rd;
- for( size_t i=0; (unsigned) i < sizeof( bufA ); i++ )
+ for (size_t i = 0; (unsigned) i < sizeof(bufA); i++) {
bufA[i] = (unsigned char) i;
- for( size_t i=0; (unsigned) i < sizeof( bufB ); i++ )
- bufB[i] = ~ ((unsigned char) i);
- for( size_t i=0; (unsigned) i < sizeof( bufC ); i++ )
- bufC[i] = ~ ((unsigned char) i);
+ }
+ for (size_t i = 0; (unsigned) i < sizeof(bufB); i++) {
+ bufB[i] = ~((unsigned char) i);
+ }
+ for (size_t i = 0; (unsigned) i < sizeof(bufC); i++) {
+ bufC[i] = ~((unsigned char) i);
+ }
/* Preparation (lower layer) */
- mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
+ mbedtls_mps_reader_init(&rd, acc, sizeof(acc));
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufA, sizeof(bufA)) == 0);
/* Consumption (upper layer) */
/* Ask for more than what's available. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 80, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 80, bufA, 80 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) ==
- MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 80, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 80, bufA, 80);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 80, 10);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) ==
+ MBEDTLS_ERR_MPS_READER_OUT_OF_DATA);
/* Preparation */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufB, sizeof(bufB)) == 0);
- switch( option )
- {
+ switch (option) {
case 0: /* Fetch same chunks, commit afterwards, and
* then exceed bounds of new buffer; accumulator
* large enough. */
/* Consume */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, &tmp_len ) == 0 );
- ASSERT_COMPARE( tmp, tmp_len, bufA + 80, 10 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
- ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) ==
- MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, &tmp_len) == 0);
+ ASSERT_COMPARE(tmp, tmp_len, bufA + 80, 10);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 90, 10);
+ ASSERT_COMPARE(tmp + 10, 10, bufB, 10);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) ==
+ MBEDTLS_ERR_MPS_READER_OUT_OF_DATA);
/* Prepare */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufC, sizeof( bufC ) ) == 0 );;
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufC, sizeof(bufC)) == 0);;
/* Consume */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufB + 10, 10 );
- ASSERT_COMPARE( tmp + 10, 10, bufC, 10 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufB + 10, 10);
+ ASSERT_COMPARE(tmp + 10, 10, bufC, 10);
break;
case 1: /* Fetch same chunks, commit afterwards, and
* then exceed bounds of new buffer; accumulator
* not large enough. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
- ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 51, &tmp, NULL ) ==
- MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 80, 10);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 90, 10);
+ ASSERT_COMPARE(tmp + 10, 10, bufB, 10);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 51, &tmp, NULL) ==
+ MBEDTLS_ERR_MPS_READER_OUT_OF_DATA);
/* Prepare */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) ==
- MBEDTLS_ERR_MPS_READER_ACCUMULATOR_TOO_SMALL );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) ==
+ MBEDTLS_ERR_MPS_READER_ACCUMULATOR_TOO_SMALL);
break;
case 2: /* Fetch same chunks, don't commit afterwards, and
* then exceed bounds of new buffer; accumulator
* large enough. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
- ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) ==
- MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 80, 10);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 90, 10);
+ ASSERT_COMPARE(tmp + 10, 10, bufB, 10);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) ==
+ MBEDTLS_ERR_MPS_READER_OUT_OF_DATA);
/* Prepare */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufC, sizeof( bufC ) ) == 0 );;
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufC, sizeof(bufC)) == 0);;
/* Consume */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 50, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 20, bufA + 80, 20 );
- ASSERT_COMPARE( tmp + 20, 20, bufB, 20 );
- ASSERT_COMPARE( tmp + 40, 10, bufC, 10 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 50, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 20, bufA + 80, 20);
+ ASSERT_COMPARE(tmp + 20, 20, bufB, 20);
+ ASSERT_COMPARE(tmp + 40, 10, bufC, 10);
break;
case 3: /* Fetch same chunks, don't commit afterwards, and
* then exceed bounds of new buffer; accumulator
* not large enough. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 80, 10 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 10, bufA + 90, 10 );
- ASSERT_COMPARE( tmp + 10, 10, bufB, 10 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 21, &tmp, NULL ) ==
- MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 80, 10);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 10, bufA + 90, 10);
+ ASSERT_COMPARE(tmp + 10, 10, bufB, 10);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 21, &tmp, NULL) ==
+ MBEDTLS_ERR_MPS_READER_OUT_OF_DATA);
/* Prepare */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) ==
- MBEDTLS_ERR_MPS_READER_ACCUMULATOR_TOO_SMALL );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) ==
+ MBEDTLS_ERR_MPS_READER_ACCUMULATOR_TOO_SMALL);
break;
default:
- TEST_ASSERT( 0 );
+ TEST_ASSERT(0);
break;
}
- mbedtls_mps_reader_free( &rd );
+ mbedtls_mps_reader_free(&rd);
}
/* END_CASE */
/* BEGIN_CASE depends_on:TEST_SUITE_MPS_READER:MBEDTLS_MPS_STATE_VALIDATION */
-void mbedtls_mps_reader_random_usage( int num_out_chunks,
- int max_chunk_size,
- int max_request,
- int acc_size )
+void mbedtls_mps_reader_random_usage(int num_out_chunks,
+ int max_chunk_size,
+ int max_request,
+ int acc_size)
{
/* Randomly pass a reader object back and forth between lower and
@@ -829,130 +843,108 @@
* returning the reader to the upper layer. */
mbedtls_mps_reader rd;
- if( acc_size > 0 )
- {
- ASSERT_ALLOC( acc, acc_size );
+ if (acc_size > 0) {
+ ASSERT_ALLOC(acc, acc_size);
}
/* This probably needs to be changed because we want
* our tests to be deterministic. */
// srand( time( NULL ) );
- ASSERT_ALLOC( outgoing, num_out_chunks * max_chunk_size );
- ASSERT_ALLOC( incoming, num_out_chunks * max_chunk_size );
+ ASSERT_ALLOC(outgoing, num_out_chunks * max_chunk_size);
+ ASSERT_ALLOC(incoming, num_out_chunks * max_chunk_size);
- mbedtls_mps_reader_init( &rd, acc, acc_size );
+ mbedtls_mps_reader_init(&rd, acc, acc_size);
cur_out_chunk = 0;
in_commit = 0;
in_fetch = 0;
out_pos = 0;
- while( cur_out_chunk < (unsigned) num_out_chunks )
- {
- if( mode == 0 )
- {
+ while (cur_out_chunk < (unsigned) num_out_chunks) {
+ if (mode == 0) {
/* Choose randomly between reclaim and feed */
rand_op = rand() % 2;
- if( rand_op == 0 )
- {
+ if (rand_op == 0) {
/* Reclaim */
- ret = mbedtls_mps_reader_reclaim( &rd, NULL );
+ ret = mbedtls_mps_reader_reclaim(&rd, NULL);
- if( ret == 0 )
- {
- TEST_ASSERT( cur_chunk != NULL );
- mbedtls_free( cur_chunk );
+ if (ret == 0) {
+ TEST_ASSERT(cur_chunk != NULL);
+ mbedtls_free(cur_chunk);
cur_chunk = NULL;
}
reclaimed = 1;
- }
- else
- {
+ } else {
/* Feed reader with a random chunk */
unsigned char *tmp = NULL;
size_t tmp_size;
- if( cur_out_chunk == (unsigned) num_out_chunks )
+ if (cur_out_chunk == (unsigned) num_out_chunks) {
continue;
+ }
- tmp_size = ( rand() % max_chunk_size ) + 1;
- ASSERT_ALLOC( tmp, tmp_size );
+ tmp_size = (rand() % max_chunk_size) + 1;
+ ASSERT_ALLOC(tmp, tmp_size);
- TEST_ASSERT( mbedtls_test_rnd_std_rand( NULL, tmp, tmp_size ) == 0 );
- ret = mbedtls_mps_reader_feed( &rd, tmp, tmp_size );
+ TEST_ASSERT(mbedtls_test_rnd_std_rand(NULL, tmp, tmp_size) == 0);
+ ret = mbedtls_mps_reader_feed(&rd, tmp, tmp_size);
- if( ret == 0 || ret == MBEDTLS_ERR_MPS_READER_NEED_MORE )
- {
+ if (ret == 0 || ret == MBEDTLS_ERR_MPS_READER_NEED_MORE) {
cur_out_chunk++;
- memcpy( outgoing + out_pos, tmp, tmp_size );
+ memcpy(outgoing + out_pos, tmp, tmp_size);
out_pos += tmp_size;
}
- if( ret == 0 )
- {
- TEST_ASSERT( cur_chunk == NULL );
+ if (ret == 0) {
+ TEST_ASSERT(cur_chunk == NULL);
cur_chunk = tmp;
- }
- else
- {
- mbedtls_free( tmp );
+ } else {
+ mbedtls_free(tmp);
}
}
/* Randomly switch to consumption mode if reclaim
* was called at least once. */
- if( reclaimed == 1 && rand() % 3 == 0 )
- {
+ if (reclaimed == 1 && rand() % 3 == 0) {
in_fetch = 0;
mode = 1;
}
- }
- else
- {
+ } else {
/* Choose randomly between get tolerating fewer data,
* get not tolerating fewer data, and commit. */
rand_op = rand() % 3;
- if( rand_op == 0 || rand_op == 1 )
- {
+ if (rand_op == 0 || rand_op == 1) {
mbedtls_mps_size_t get_size, real_size;
unsigned char *chunk_get;
- get_size = ( rand() % max_request ) + 1;
- if( rand_op == 0 )
- {
- ret = mbedtls_mps_reader_get( &rd, get_size, &chunk_get,
- &real_size );
- }
- else
- {
+ get_size = (rand() % max_request) + 1;
+ if (rand_op == 0) {
+ ret = mbedtls_mps_reader_get(&rd, get_size, &chunk_get,
+ &real_size);
+ } else {
real_size = get_size;
- ret = mbedtls_mps_reader_get( &rd, get_size, &chunk_get, NULL );
+ ret = mbedtls_mps_reader_get(&rd, get_size, &chunk_get, NULL);
}
/* Check if output is in accordance with what was written */
- if( ret == 0 )
- {
- memcpy( incoming + in_commit + in_fetch,
- chunk_get, real_size );
- TEST_ASSERT( memcmp( incoming + in_commit + in_fetch,
- outgoing + in_commit + in_fetch,
- real_size ) == 0 );
+ if (ret == 0) {
+ memcpy(incoming + in_commit + in_fetch,
+ chunk_get, real_size);
+ TEST_ASSERT(memcmp(incoming + in_commit + in_fetch,
+ outgoing + in_commit + in_fetch,
+ real_size) == 0);
in_fetch += real_size;
}
- }
- else if( rand_op == 2 ) /* Commit */
- {
- ret = mbedtls_mps_reader_commit( &rd );
- if( ret == 0 )
- {
+ } else if (rand_op == 2) { /* Commit */
+ ret = mbedtls_mps_reader_commit(&rd);
+ if (ret == 0) {
in_commit += in_fetch;
in_fetch = 0;
}
}
/* Randomly switch back to preparation */
- if( rand() % 3 == 0 )
- {
+ if (rand() % 3 == 0) {
reclaimed = 0;
mode = 0;
}
@@ -960,16 +952,16 @@
}
/* Cleanup */
- mbedtls_mps_reader_free( &rd );
- mbedtls_free( incoming );
- mbedtls_free( outgoing );
- mbedtls_free( acc );
- mbedtls_free( cur_chunk );
+ mbedtls_mps_reader_free(&rd);
+ mbedtls_free(incoming);
+ mbedtls_free(outgoing);
+ mbedtls_free(acc);
+ mbedtls_free(cur_chunk);
}
/* END_CASE */
/* BEGIN_CASE depends_on:TEST_SUITE_MPS_READER */
-void mbedtls_reader_inconsistent_usage( int option )
+void mbedtls_reader_inconsistent_usage(int option)
{
/* This test exercises the behaviour of the MPS reader
* in the following situation:
@@ -989,130 +981,130 @@
unsigned char acc[40];
mbedtls_mps_reader rd;
int success = 0;
- for( size_t i=0; (unsigned) i < sizeof( bufA ); i++ )
+ for (size_t i = 0; (unsigned) i < sizeof(bufA); i++) {
bufA[i] = (unsigned char) i;
- for( size_t i=0; (unsigned) i < sizeof( bufB ); i++ )
- bufB[i] = ~ ((unsigned char) i);
+ }
+ for (size_t i = 0; (unsigned) i < sizeof(bufB); i++) {
+ bufB[i] = ~((unsigned char) i);
+ }
/* Preparation (lower layer) */
- mbedtls_mps_reader_init( &rd, acc, sizeof( acc ) );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufA, sizeof( bufA ) ) == 0 );
+ mbedtls_mps_reader_init(&rd, acc, sizeof(acc));
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufA, sizeof(bufA)) == 0);
/* Consumption (upper layer) */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 80, &tmp, NULL ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 20, &tmp, NULL ) ==
- MBEDTLS_ERR_MPS_READER_OUT_OF_DATA );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 80, &tmp, NULL) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, NULL) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 20, &tmp, NULL) ==
+ MBEDTLS_ERR_MPS_READER_OUT_OF_DATA);
/* Preparation */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, bufB, sizeof( bufB ) ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, bufB, sizeof(bufB)) == 0);
/* Consumption */
- switch( option )
- {
+ switch (option) {
case 0:
/* Ask for buffered data in a single chunk, no commit */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 30, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 20, bufA + 80, 20 );
- ASSERT_COMPARE( tmp + 20, 10, bufB, 10 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 30, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 20, bufA + 80, 20);
+ ASSERT_COMPARE(tmp + 20, 10, bufB, 10);
success = 1;
break;
case 1:
/* Ask for buffered data in a single chunk, with commit */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 30, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 20, bufA + 80, 20 );
- ASSERT_COMPARE( tmp + 20, 10, bufB, 10 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 30, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 20, bufA + 80, 20);
+ ASSERT_COMPARE(tmp + 20, 10, bufB, 10);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
success = 1;
break;
case 2:
/* Ask for more than was requested when pausing, #1 */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 31, &tmp, NULL ) ==
- MBEDTLS_ERR_MPS_READER_INCONSISTENT_REQUESTS );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 31, &tmp, NULL) ==
+ MBEDTLS_ERR_MPS_READER_INCONSISTENT_REQUESTS);
break;
case 3:
/* Ask for more than was requested when pausing #2 */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, (mbedtls_mps_size_t) -1, &tmp, NULL ) ==
- MBEDTLS_ERR_MPS_READER_INCONSISTENT_REQUESTS );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, (mbedtls_mps_size_t) -1, &tmp, NULL) ==
+ MBEDTLS_ERR_MPS_READER_INCONSISTENT_REQUESTS);
break;
case 4:
/* Asking for buffered data in different
* chunks than before CAN fail. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 15, bufA + 80, 15 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 10, &tmp, NULL ) ==
- MBEDTLS_ERR_MPS_READER_INCONSISTENT_REQUESTS );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 15, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 15, bufA + 80, 15);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 10, &tmp, NULL) ==
+ MBEDTLS_ERR_MPS_READER_INCONSISTENT_REQUESTS);
break;
case 5:
/* Asking for buffered data different chunks
* than before NEED NOT fail - no commits */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 15, bufA + 80, 15 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 5, bufA + 95, 5 );
- ASSERT_COMPARE( tmp + 5, 10, bufB, 10 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 15, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 15, bufA + 80, 15);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 15, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 5, bufA + 95, 5);
+ ASSERT_COMPARE(tmp + 5, 10, bufB, 10);
success = 1;
break;
case 6:
/* Asking for buffered data different chunks
* than before NEED NOT fail - intermediate commit */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 15, bufA + 80, 15 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 5, bufA + 95, 5 );
- ASSERT_COMPARE( tmp + 5, 10, bufB, 10 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 15, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 15, bufA + 80, 15);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 15, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 5, bufA + 95, 5);
+ ASSERT_COMPARE(tmp + 5, 10, bufB, 10);
success = 1;
break;
case 7:
/* Asking for buffered data different chunks
* than before NEED NOT fail - end commit */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 15, bufA + 80, 15 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 5, bufA + 95, 5 );
- ASSERT_COMPARE( tmp + 5, 10, bufB, 10 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 15, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 15, bufA + 80, 15);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 15, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 5, bufA + 95, 5);
+ ASSERT_COMPARE(tmp + 5, 10, bufB, 10);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
success = 1;
break;
case 8:
/* Asking for buffered data different chunks
* than before NEED NOT fail - intermediate & end commit */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 15, bufA + 80, 15 );
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 15, &tmp, NULL ) == 0 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
- ASSERT_COMPARE( tmp, 5, bufA + 95, 5 );
- ASSERT_COMPARE( tmp + 5, 10, bufB, 10 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 15, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 15, bufA + 80, 15);
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 15, &tmp, NULL) == 0);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
+ ASSERT_COMPARE(tmp, 5, bufA + 95, 5);
+ ASSERT_COMPARE(tmp + 5, 10, bufB, 10);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
success = 1;
break;
default:
- TEST_ASSERT( 0 );
+ TEST_ASSERT(0);
break;
}
- if( success == 1 )
- {
+ if (success == 1) {
/* In all succeeding cases, fetch the rest of the second buffer. */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 90, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 90, bufB + 10, 90 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 90, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 90, bufB + 10, 90);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
/* Wrapup */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
}
/* Wrapup */
- mbedtls_mps_reader_free( &rd );
+ mbedtls_mps_reader_free(&rd);
}
/* END_CASE */
@@ -1124,25 +1116,26 @@
unsigned char buf[100];
unsigned char *tmp;
mbedtls_mps_reader rd;
- for( size_t i=0; (unsigned) i < sizeof( buf ); i++ )
+ for (size_t i = 0; (unsigned) i < sizeof(buf); i++) {
buf[i] = (unsigned char) i;
+ }
/* Preparation (lower layer) */
- mbedtls_mps_reader_init( &rd, NULL, 0 );
+ mbedtls_mps_reader_init(&rd, NULL, 0);
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, NULL, sizeof( buf ) ) ==
- MBEDTLS_ERR_MPS_READER_INVALID_ARG );
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, NULL, sizeof(buf)) ==
+ MBEDTLS_ERR_MPS_READER_INVALID_ARG);
/* Subsequent feed-calls should still succeed. */
- TEST_ASSERT( mbedtls_mps_reader_feed( &rd, buf, sizeof( buf ) ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_feed(&rd, buf, sizeof(buf)) == 0);
/* Consumption (upper layer) */
- TEST_ASSERT( mbedtls_mps_reader_get( &rd, 100, &tmp, NULL ) == 0 );
- ASSERT_COMPARE( tmp, 100, buf, 100 );
- TEST_ASSERT( mbedtls_mps_reader_commit( &rd ) == 0 );
+ TEST_ASSERT(mbedtls_mps_reader_get(&rd, 100, &tmp, NULL) == 0);
+ ASSERT_COMPARE(tmp, 100, buf, 100);
+ TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
/* Wrapup */
- TEST_ASSERT( mbedtls_mps_reader_reclaim( &rd, NULL ) == 0 );
- mbedtls_mps_reader_free( &rd );
+ TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
+ mbedtls_mps_reader_free(&rd);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_net.function b/tests/suites/test_suite_net.function
index 08d48b3..fa09f5a 100644
--- a/tests/suites/test_suite_net.function
+++ b/tests/suites/test_suite_net.function
@@ -30,19 +30,18 @@
*
* \return \c 0 on success, a negative error code on error.
*/
-static int open_file_on_fd( mbedtls_net_context *ctx, int wanted_fd )
+static int open_file_on_fd(mbedtls_net_context *ctx, int wanted_fd)
{
- int got_fd = open( "/dev/null", O_RDONLY );
- TEST_ASSERT( got_fd >= 0 );
- if( got_fd != wanted_fd )
- {
- TEST_ASSERT( dup2( got_fd, wanted_fd ) >= 0 );
- TEST_ASSERT( close( got_fd ) >= 0 );
+ int got_fd = open("/dev/null", O_RDONLY);
+ TEST_ASSERT(got_fd >= 0);
+ if (got_fd != wanted_fd) {
+ TEST_ASSERT(dup2(got_fd, wanted_fd) >= 0);
+ TEST_ASSERT(close(got_fd) >= 0);
}
ctx->fd = wanted_fd;
- return( 0 );
+ return 0;
exit:
- return( -1 );
+ return -1;
}
#endif /* MBEDTLS_PLATFORM_IS_UNIXLIKE */
@@ -54,16 +53,17 @@
*/
/* BEGIN_CASE */
-void context_init_free( int reinit )
+void context_init_free(int reinit)
{
mbedtls_net_context ctx;
- mbedtls_net_init( &ctx );
- mbedtls_net_free( &ctx );
+ mbedtls_net_init(&ctx);
+ mbedtls_net_free(&ctx);
- if( reinit )
- mbedtls_net_init( &ctx );
- mbedtls_net_free( &ctx );
+ if (reinit) {
+ mbedtls_net_init(&ctx);
+ }
+ mbedtls_net_free(&ctx);
/* This test case always succeeds, functionally speaking. A plausible
* bug might trigger an invalid pointer dereference or a memory leak. */
@@ -72,7 +72,7 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PLATFORM_IS_UNIXLIKE */
-void poll_beyond_fd_setsize( )
+void poll_beyond_fd_setsize()
{
/* Test that mbedtls_net_poll does not misbehave when given a file
* descriptor greater or equal to FD_SETSIZE. This code is specific to
@@ -85,7 +85,7 @@
mbedtls_net_context ctx;
uint8_t buf[1];
- mbedtls_net_init( &ctx );
+ mbedtls_net_init(&ctx);
/* On many systems, by default, the maximum permitted file descriptor
* number is less than FD_SETSIZE. If so, raise the limit if
@@ -99,17 +99,16 @@
* might do); but we don't do such things in our test code, so the unit
* test will run if it can.
*/
- TEST_ASSERT( getrlimit( RLIMIT_NOFILE, &rlim_nofile ) == 0 );
- if( rlim_nofile.rlim_cur < FD_SETSIZE + 1 )
- {
+ TEST_ASSERT(getrlimit(RLIMIT_NOFILE, &rlim_nofile) == 0);
+ if (rlim_nofile.rlim_cur < FD_SETSIZE + 1) {
rlim_t old_rlim_cur = rlim_nofile.rlim_cur;
rlim_nofile.rlim_cur = FD_SETSIZE + 1;
- TEST_ASSUME( setrlimit( RLIMIT_NOFILE, &rlim_nofile ) == 0 );
+ TEST_ASSUME(setrlimit(RLIMIT_NOFILE, &rlim_nofile) == 0);
rlim_nofile.rlim_cur = old_rlim_cur;
restore_rlim_nofile = 1;
}
- TEST_ASSERT( open_file_on_fd( &ctx, FD_SETSIZE ) == 0 );
+ TEST_ASSERT(open_file_on_fd(&ctx, FD_SETSIZE) == 0);
/* In principle, mbedtls_net_poll() with valid arguments should succeed.
* However, we know that on Unix-like platforms (and others), this function
@@ -122,16 +121,17 @@
* is problematic on the particular platform where the code is running,
* a memory sanitizer such as UBSan should catch it.
*/
- ret = mbedtls_net_poll( &ctx, MBEDTLS_NET_POLL_READ, 0 );
- TEST_EQUAL( ret, MBEDTLS_ERR_NET_POLL_FAILED );
+ ret = mbedtls_net_poll(&ctx, MBEDTLS_NET_POLL_READ, 0);
+ TEST_EQUAL(ret, MBEDTLS_ERR_NET_POLL_FAILED);
/* mbedtls_net_recv_timeout() uses select() and fd_set in the same way. */
- ret = mbedtls_net_recv_timeout( &ctx, buf, sizeof( buf ), 0 );
- TEST_EQUAL( ret, MBEDTLS_ERR_NET_POLL_FAILED );
+ ret = mbedtls_net_recv_timeout(&ctx, buf, sizeof(buf), 0);
+ TEST_EQUAL(ret, MBEDTLS_ERR_NET_POLL_FAILED);
exit:
- mbedtls_net_free( &ctx );
- if( restore_rlim_nofile )
- setrlimit( RLIMIT_NOFILE, &rlim_nofile );
+ mbedtls_net_free(&ctx);
+ if (restore_rlim_nofile) {
+ setrlimit(RLIMIT_NOFILE, &rlim_nofile);
+ }
}
/* END_CASE */
diff --git a/tests/suites/test_suite_nist_kw.function b/tests/suites/test_suite_nist_kw.function
index 6a81052..f2b7944 100644
--- a/tests/suites/test_suite_nist_kw.function
+++ b/tests/suites/test_suite_nist_kw.function
@@ -8,14 +8,14 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST:MBEDTLS_AES_C */
-void mbedtls_nist_kw_self_test( )
+void mbedtls_nist_kw_self_test()
{
- TEST_ASSERT( mbedtls_nist_kw_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_self_test(1) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
-void mbedtls_nist_kw_mix_contexts( )
+void mbedtls_nist_kw_mix_contexts()
{
mbedtls_nist_kw_context ctx1, ctx2;
unsigned char key[16];
@@ -24,129 +24,126 @@
unsigned char ciphertext2[40];
size_t output_len, i;
- memset( plaintext, 0, sizeof( plaintext ) );
- memset( ciphertext1, 0, sizeof( ciphertext1 ) );
- memset( ciphertext2, 0, sizeof( ciphertext2 ) );
- memset( key, 0, sizeof( key ) );
+ memset(plaintext, 0, sizeof(plaintext));
+ memset(ciphertext1, 0, sizeof(ciphertext1));
+ memset(ciphertext2, 0, sizeof(ciphertext2));
+ memset(key, 0, sizeof(key));
/*
* 1. Check wrap and unwrap with two separate contexts
*/
- mbedtls_nist_kw_init( &ctx1 );
- mbedtls_nist_kw_init( &ctx2 );
+ mbedtls_nist_kw_init(&ctx1);
+ mbedtls_nist_kw_init(&ctx2);
- TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx1,
- MBEDTLS_CIPHER_ID_AES,
- key, sizeof( key ) * 8,
- 1 ) == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_setkey(&ctx1,
+ MBEDTLS_CIPHER_ID_AES,
+ key, sizeof(key) * 8,
+ 1) == 0);
- TEST_ASSERT( mbedtls_nist_kw_wrap( &ctx1, MBEDTLS_KW_MODE_KW,
- plaintext, sizeof( plaintext ),
- ciphertext1, &output_len,
- sizeof( ciphertext1 ) ) == 0 );
- TEST_ASSERT( output_len == sizeof( ciphertext1 ) );
+ TEST_ASSERT(mbedtls_nist_kw_wrap(&ctx1, MBEDTLS_KW_MODE_KW,
+ plaintext, sizeof(plaintext),
+ ciphertext1, &output_len,
+ sizeof(ciphertext1)) == 0);
+ TEST_ASSERT(output_len == sizeof(ciphertext1));
- TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx2,
- MBEDTLS_CIPHER_ID_AES,
- key, sizeof( key ) * 8,
- 0 ) == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_setkey(&ctx2,
+ MBEDTLS_CIPHER_ID_AES,
+ key, sizeof(key) * 8,
+ 0) == 0);
- TEST_ASSERT( mbedtls_nist_kw_unwrap( &ctx2, MBEDTLS_KW_MODE_KW,
- ciphertext1, output_len,
- plaintext, &output_len,
- sizeof( plaintext ) ) == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_unwrap(&ctx2, MBEDTLS_KW_MODE_KW,
+ ciphertext1, output_len,
+ plaintext, &output_len,
+ sizeof(plaintext)) == 0);
- TEST_ASSERT( output_len == sizeof( plaintext ) );
- for( i = 0; i < sizeof( plaintext ); i++ )
- {
- TEST_ASSERT( plaintext[i] == 0 );
+ TEST_ASSERT(output_len == sizeof(plaintext));
+ for (i = 0; i < sizeof(plaintext); i++) {
+ TEST_ASSERT(plaintext[i] == 0);
}
- mbedtls_nist_kw_free( &ctx1 );
- mbedtls_nist_kw_free( &ctx2 );
+ mbedtls_nist_kw_free(&ctx1);
+ mbedtls_nist_kw_free(&ctx2);
/*
* 2. Check wrapping with two modes, on same context
*/
- mbedtls_nist_kw_init( &ctx1 );
- mbedtls_nist_kw_init( &ctx2 );
- output_len = sizeof( ciphertext1 );
+ mbedtls_nist_kw_init(&ctx1);
+ mbedtls_nist_kw_init(&ctx2);
+ output_len = sizeof(ciphertext1);
- TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx1,
- MBEDTLS_CIPHER_ID_AES,
- key, sizeof( key ) * 8,
- 1 ) == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_setkey(&ctx1,
+ MBEDTLS_CIPHER_ID_AES,
+ key, sizeof(key) * 8,
+ 1) == 0);
- TEST_ASSERT( mbedtls_nist_kw_wrap( &ctx1, MBEDTLS_KW_MODE_KW,
- plaintext, sizeof( plaintext ),
- ciphertext1, &output_len,
- sizeof( ciphertext1 ) ) == 0 );
- TEST_ASSERT( output_len == sizeof( ciphertext1 ) );
+ TEST_ASSERT(mbedtls_nist_kw_wrap(&ctx1, MBEDTLS_KW_MODE_KW,
+ plaintext, sizeof(plaintext),
+ ciphertext1, &output_len,
+ sizeof(ciphertext1)) == 0);
+ TEST_ASSERT(output_len == sizeof(ciphertext1));
- TEST_ASSERT( mbedtls_nist_kw_wrap( &ctx1, MBEDTLS_KW_MODE_KWP,
- plaintext, sizeof( plaintext ),
- ciphertext2, &output_len,
- sizeof( ciphertext2 ) ) == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_wrap(&ctx1, MBEDTLS_KW_MODE_KWP,
+ plaintext, sizeof(plaintext),
+ ciphertext2, &output_len,
+ sizeof(ciphertext2)) == 0);
- TEST_ASSERT( output_len == sizeof( ciphertext2 ) );
+ TEST_ASSERT(output_len == sizeof(ciphertext2));
- TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx2,
- MBEDTLS_CIPHER_ID_AES,
- key, sizeof( key ) * 8,
- 0 ) == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_setkey(&ctx2,
+ MBEDTLS_CIPHER_ID_AES,
+ key, sizeof(key) * 8,
+ 0) == 0);
- TEST_ASSERT( mbedtls_nist_kw_unwrap( &ctx2, MBEDTLS_KW_MODE_KW,
- ciphertext1, sizeof( ciphertext1 ),
- plaintext, &output_len,
- sizeof( plaintext ) ) == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_unwrap(&ctx2, MBEDTLS_KW_MODE_KW,
+ ciphertext1, sizeof(ciphertext1),
+ plaintext, &output_len,
+ sizeof(plaintext)) == 0);
- TEST_ASSERT( output_len == sizeof( plaintext ) );
+ TEST_ASSERT(output_len == sizeof(plaintext));
- for( i = 0; i < sizeof( plaintext ); i++ )
- {
- TEST_ASSERT( plaintext[i] == 0 );
+ for (i = 0; i < sizeof(plaintext); i++) {
+ TEST_ASSERT(plaintext[i] == 0);
}
- TEST_ASSERT( mbedtls_nist_kw_unwrap( &ctx2, MBEDTLS_KW_MODE_KWP,
- ciphertext2, sizeof( ciphertext2 ),
- plaintext, &output_len,
- sizeof( plaintext ) ) == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_unwrap(&ctx2, MBEDTLS_KW_MODE_KWP,
+ ciphertext2, sizeof(ciphertext2),
+ plaintext, &output_len,
+ sizeof(plaintext)) == 0);
- TEST_ASSERT( output_len == sizeof( plaintext ) );
+ TEST_ASSERT(output_len == sizeof(plaintext));
- for( i = 0; i < sizeof( plaintext ); i++ )
- {
- TEST_ASSERT( plaintext[i] == 0 );
+ for (i = 0; i < sizeof(plaintext); i++) {
+ TEST_ASSERT(plaintext[i] == 0);
}
exit:
- mbedtls_nist_kw_free( &ctx1 );
- mbedtls_nist_kw_free( &ctx2 );
+ mbedtls_nist_kw_free(&ctx1);
+ mbedtls_nist_kw_free(&ctx2);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_nist_kw_setkey( int cipher_id, int key_size,
- int is_wrap, int result )
+void mbedtls_nist_kw_setkey(int cipher_id, int key_size,
+ int is_wrap, int result)
{
mbedtls_nist_kw_context ctx;
unsigned char key[32];
int ret;
- mbedtls_nist_kw_init( &ctx );
+ mbedtls_nist_kw_init(&ctx);
- memset( key, 0x2A, sizeof( key ) );
- TEST_ASSERT( (unsigned) key_size <= 8 * sizeof( key ) );
+ memset(key, 0x2A, sizeof(key));
+ TEST_ASSERT((unsigned) key_size <= 8 * sizeof(key));
- ret = mbedtls_nist_kw_setkey( &ctx, cipher_id, key, key_size, is_wrap );
- TEST_ASSERT( ret == result );
+ ret = mbedtls_nist_kw_setkey(&ctx, cipher_id, key, key_size, is_wrap);
+ TEST_ASSERT(ret == result);
exit:
- mbedtls_nist_kw_free( &ctx );
+ mbedtls_nist_kw_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
-void nist_kw_plaintext_lengths( int in_len, int out_len, int mode, int res )
+void nist_kw_plaintext_lengths(int in_len, int out_len, int mode, int res)
{
mbedtls_nist_kw_context ctx;
unsigned char key[16];
@@ -154,50 +151,46 @@
unsigned char *ciphertext = NULL;
size_t output_len = out_len;
- mbedtls_nist_kw_init( &ctx );
+ mbedtls_nist_kw_init(&ctx);
- memset( key, 0, sizeof( key ) );
+ memset(key, 0, sizeof(key));
- if( in_len != 0 )
- {
- plaintext = mbedtls_calloc( 1, in_len );
- TEST_ASSERT( plaintext != NULL );
+ if (in_len != 0) {
+ plaintext = mbedtls_calloc(1, in_len);
+ TEST_ASSERT(plaintext != NULL);
}
- if( out_len != 0 )
- {
- ciphertext = mbedtls_calloc( 1, output_len );
- TEST_ASSERT( ciphertext != NULL );
+ if (out_len != 0) {
+ ciphertext = mbedtls_calloc(1, output_len);
+ TEST_ASSERT(ciphertext != NULL);
}
- TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx, MBEDTLS_CIPHER_ID_AES,
- key, 8 * sizeof( key ), 1 ) == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_setkey(&ctx, MBEDTLS_CIPHER_ID_AES,
+ key, 8 * sizeof(key), 1) == 0);
- TEST_ASSERT( mbedtls_nist_kw_wrap( &ctx, mode, plaintext, in_len,
- ciphertext, &output_len,
- output_len ) == res );
- if( res == 0 )
- {
- if( mode == MBEDTLS_KW_MODE_KWP )
- TEST_ASSERT( output_len == (size_t) in_len + 8 -
- ( in_len % 8 ) + 8 );
- else
- TEST_ASSERT( output_len == (size_t) in_len + 8 );
- }
- else
- {
- TEST_ASSERT( output_len == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_wrap(&ctx, mode, plaintext, in_len,
+ ciphertext, &output_len,
+ output_len) == res);
+ if (res == 0) {
+ if (mode == MBEDTLS_KW_MODE_KWP) {
+ TEST_ASSERT(output_len == (size_t) in_len + 8 -
+ (in_len % 8) + 8);
+ } else {
+ TEST_ASSERT(output_len == (size_t) in_len + 8);
+ }
+ } else {
+ TEST_ASSERT(output_len == 0);
}
exit:
- mbedtls_free( ciphertext );
- mbedtls_free( plaintext );
- mbedtls_nist_kw_free( &ctx );
+ mbedtls_free(ciphertext);
+ mbedtls_free(plaintext);
+ mbedtls_nist_kw_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_AES_C */
-void nist_kw_ciphertext_lengths( int in_len, int out_len, int mode, int res )
+void nist_kw_ciphertext_lengths(int in_len, int out_len, int mode, int res)
{
mbedtls_nist_kw_context ctx;
unsigned char key[16];
@@ -206,111 +199,105 @@
int unwrap_ret;
size_t output_len = out_len;
- mbedtls_nist_kw_init( &ctx );
+ mbedtls_nist_kw_init(&ctx);
- memset( key, 0, sizeof( key ) );
+ memset(key, 0, sizeof(key));
- if( out_len != 0 )
- {
- plaintext = mbedtls_calloc( 1, output_len );
- TEST_ASSERT( plaintext != NULL );
+ if (out_len != 0) {
+ plaintext = mbedtls_calloc(1, output_len);
+ TEST_ASSERT(plaintext != NULL);
}
- if( in_len != 0 )
- {
- ciphertext = mbedtls_calloc( 1, in_len );
- TEST_ASSERT( ciphertext != NULL );
+ if (in_len != 0) {
+ ciphertext = mbedtls_calloc(1, in_len);
+ TEST_ASSERT(ciphertext != NULL);
}
- TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx, MBEDTLS_CIPHER_ID_AES,
- key, 8 * sizeof( key ), 0 ) == 0 );
- unwrap_ret = mbedtls_nist_kw_unwrap( &ctx, mode, ciphertext, in_len,
- plaintext, &output_len,
- output_len );
+ TEST_ASSERT(mbedtls_nist_kw_setkey(&ctx, MBEDTLS_CIPHER_ID_AES,
+ key, 8 * sizeof(key), 0) == 0);
+ unwrap_ret = mbedtls_nist_kw_unwrap(&ctx, mode, ciphertext, in_len,
+ plaintext, &output_len,
+ output_len);
- if( res == 0 )
- TEST_ASSERT( unwrap_ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED );
- else
- TEST_ASSERT( unwrap_ret == res );
+ if (res == 0) {
+ TEST_ASSERT(unwrap_ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED);
+ } else {
+ TEST_ASSERT(unwrap_ret == res);
+ }
- TEST_ASSERT( output_len == 0 );
+ TEST_ASSERT(output_len == 0);
exit:
- mbedtls_free( ciphertext );
- mbedtls_free( plaintext );
- mbedtls_nist_kw_free( &ctx );
+ mbedtls_free(ciphertext);
+ mbedtls_free(plaintext);
+ mbedtls_nist_kw_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_nist_kw_wrap( int cipher_id, int mode, data_t *key, data_t *msg,
- data_t *expected_result )
+void mbedtls_nist_kw_wrap(int cipher_id, int mode, data_t *key, data_t *msg,
+ data_t *expected_result)
{
unsigned char result[528];
mbedtls_nist_kw_context ctx;
size_t result_len, i, padlen;
- mbedtls_nist_kw_init( &ctx );
+ mbedtls_nist_kw_init(&ctx);
- memset( result, '+', sizeof( result ) );
+ memset(result, '+', sizeof(result));
- TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx, cipher_id,
- key->x, key->len * 8, 1 ) == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_setkey(&ctx, cipher_id,
+ key->x, key->len * 8, 1) == 0);
/* Test with input == output */
- TEST_ASSERT( mbedtls_nist_kw_wrap( &ctx, mode, msg->x, msg->len,
- result, &result_len, sizeof( result ) ) == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_wrap(&ctx, mode, msg->x, msg->len,
+ result, &result_len, sizeof(result)) == 0);
- TEST_ASSERT( result_len == expected_result->len );
+ TEST_ASSERT(result_len == expected_result->len);
- TEST_ASSERT( memcmp( expected_result->x, result, result_len ) == 0 );
+ TEST_ASSERT(memcmp(expected_result->x, result, result_len) == 0);
- padlen = ( msg->len % 8 != 0 ) ? 8 - (msg->len % 8 ) : 0;
+ padlen = (msg->len % 8 != 0) ? 8 - (msg->len % 8) : 0;
/* Check that the function didn't write beyond the end of the buffer. */
- for( i = msg->len + 8 + padlen; i < sizeof( result ); i++ )
- {
- TEST_ASSERT( result[i] == '+' );
+ for (i = msg->len + 8 + padlen; i < sizeof(result); i++) {
+ TEST_ASSERT(result[i] == '+');
}
exit:
- mbedtls_nist_kw_free( &ctx );
+ mbedtls_nist_kw_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_nist_kw_unwrap( int cipher_id, int mode, data_t *key, data_t *msg,
- data_t *expected_result, int expected_ret )
+void mbedtls_nist_kw_unwrap(int cipher_id, int mode, data_t *key, data_t *msg,
+ data_t *expected_result, int expected_ret)
{
unsigned char result[528];
mbedtls_nist_kw_context ctx;
size_t result_len, i;
- mbedtls_nist_kw_init( &ctx );
+ mbedtls_nist_kw_init(&ctx);
- memset( result, '+', sizeof( result ) );
+ memset(result, '+', sizeof(result));
- TEST_ASSERT( mbedtls_nist_kw_setkey( &ctx, cipher_id,
- key->x, key->len * 8, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_setkey(&ctx, cipher_id,
+ key->x, key->len * 8, 0) == 0);
/* Test with input == output */
- TEST_ASSERT( mbedtls_nist_kw_unwrap( &ctx, mode, msg->x, msg->len,
- result, &result_len, sizeof( result ) ) == expected_ret );
- if( expected_ret == 0 )
- {
- TEST_ASSERT( result_len == expected_result->len );
- TEST_ASSERT( memcmp( expected_result->x, result, result_len ) == 0 );
- }
- else
- {
- TEST_ASSERT( result_len == 0 );
+ TEST_ASSERT(mbedtls_nist_kw_unwrap(&ctx, mode, msg->x, msg->len,
+ result, &result_len, sizeof(result)) == expected_ret);
+ if (expected_ret == 0) {
+ TEST_ASSERT(result_len == expected_result->len);
+ TEST_ASSERT(memcmp(expected_result->x, result, result_len) == 0);
+ } else {
+ TEST_ASSERT(result_len == 0);
}
/* Check that the function didn't write beyond the end of the buffer. */
- for( i = msg->len - 8; i < sizeof( result ); i++ )
- {
- TEST_ASSERT( result[i] == '+' );
+ for (i = msg->len - 8; i < sizeof(result); i++) {
+ TEST_ASSERT(result[i] == '+');
}
exit:
- mbedtls_nist_kw_free( &ctx );
+ mbedtls_nist_kw_free(&ctx);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_oid.function b/tests/suites/test_suite_oid.function
index 9e8d437..fac5ed4 100644
--- a/tests/suites/test_suite_oid.function
+++ b/tests/suites/test_suite_oid.function
@@ -11,7 +11,7 @@
*/
/* BEGIN_CASE */
-void oid_get_certificate_policies( data_t *oid, char *result_str )
+void oid_get_certificate_policies(data_t *oid, char *result_str)
{
mbedtls_asn1_buf asn1_buf = { 0, 0, NULL };
int ret;
@@ -21,21 +21,18 @@
asn1_buf.p = oid->x;
asn1_buf.len = oid->len;
- ret = mbedtls_oid_get_certificate_policies( &asn1_buf, &desc );
- if( strlen( result_str ) == 0 )
- {
- TEST_ASSERT( ret == MBEDTLS_ERR_OID_NOT_FOUND );
- }
- else
- {
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( strcmp( ( char* )desc, result_str ) == 0 );
+ ret = mbedtls_oid_get_certificate_policies(&asn1_buf, &desc);
+ if (strlen(result_str) == 0) {
+ TEST_ASSERT(ret == MBEDTLS_ERR_OID_NOT_FOUND);
+ } else {
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(strcmp((char *) desc, result_str) == 0);
}
}
/* END_CASE */
/* BEGIN_CASE */
-void oid_get_extended_key_usage( data_t *oid, char *result_str )
+void oid_get_extended_key_usage(data_t *oid, char *result_str)
{
mbedtls_asn1_buf asn1_buf = { 0, 0, NULL };
int ret;
@@ -45,21 +42,18 @@
asn1_buf.p = oid->x;
asn1_buf.len = oid->len;
- ret = mbedtls_oid_get_extended_key_usage( &asn1_buf, &desc );
- if( strlen( result_str ) == 0 )
- {
- TEST_ASSERT( ret == MBEDTLS_ERR_OID_NOT_FOUND );
- }
- else
- {
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( strcmp( ( char * )desc, result_str ) == 0 );
+ ret = mbedtls_oid_get_extended_key_usage(&asn1_buf, &desc);
+ if (strlen(result_str) == 0) {
+ TEST_ASSERT(ret == MBEDTLS_ERR_OID_NOT_FOUND);
+ } else {
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(strcmp((char *) desc, result_str) == 0);
}
}
/* END_CASE */
/* BEGIN_CASE */
-void oid_get_x509_extension( data_t *oid, int exp_type )
+void oid_get_x509_extension(data_t *oid, int exp_type)
{
mbedtls_asn1_buf ext_oid = { 0, 0, NULL };
int ret;
@@ -69,21 +63,18 @@
ext_oid.p = oid->x;
ext_oid.len = oid->len;
- ret = mbedtls_oid_get_x509_ext_type( &ext_oid, &ext_type );
- if( exp_type == 0 )
- {
- TEST_ASSERT( ret == MBEDTLS_ERR_OID_NOT_FOUND );
- }
- else
- {
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( ext_type == exp_type );
+ ret = mbedtls_oid_get_x509_ext_type(&ext_oid, &ext_type);
+ if (exp_type == 0) {
+ TEST_ASSERT(ret == MBEDTLS_ERR_OID_NOT_FOUND);
+ } else {
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(ext_type == exp_type);
}
}
/* END_CASE */
/* BEGIN_CASE */
-void oid_get_md_alg_id( data_t *oid, int exp_md_id )
+void oid_get_md_alg_id(data_t *oid, int exp_md_id)
{
mbedtls_asn1_buf md_oid = { 0, 0, NULL };
int ret;
@@ -93,17 +84,14 @@
md_oid.p = oid->x;
md_oid.len = oid->len;
- ret = mbedtls_oid_get_md_alg( &md_oid, &md_id );
+ ret = mbedtls_oid_get_md_alg(&md_oid, &md_id);
- if( exp_md_id < 0 )
- {
- TEST_ASSERT( ret == MBEDTLS_ERR_OID_NOT_FOUND );
- TEST_ASSERT( md_id == 0);
- }
- else
- {
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( (mbedtls_md_type_t)exp_md_id == md_id );
+ if (exp_md_id < 0) {
+ TEST_ASSERT(ret == MBEDTLS_ERR_OID_NOT_FOUND);
+ TEST_ASSERT(md_id == 0);
+ } else {
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT((mbedtls_md_type_t) exp_md_id == md_id);
}
}
/* END_CASE */
diff --git a/tests/suites/test_suite_pem.function b/tests/suites/test_suite_pem.function
index 947f1fb..8aac3cf 100644
--- a/tests/suites/test_suite_pem.function
+++ b/tests/suites/test_suite_pem.function
@@ -6,48 +6,48 @@
/* END_HEADER */
/* BEGIN_CASE depends_on:MBEDTLS_PEM_WRITE_C */
-void mbedtls_pem_write_buffer( char * start, char * end, data_t * buf,
- char * result_str )
+void mbedtls_pem_write_buffer(char *start, char *end, data_t *buf,
+ char *result_str)
{
unsigned char *check_buf = NULL;
int ret;
size_t olen = 0, olen2 = 0;
- ret = mbedtls_pem_write_buffer( start, end, buf->x, buf->len, NULL, 0, &olen );
- TEST_ASSERT( ret == MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
+ ret = mbedtls_pem_write_buffer(start, end, buf->x, buf->len, NULL, 0, &olen);
+ TEST_ASSERT(ret == MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL);
- check_buf = (unsigned char *) mbedtls_calloc( 1, olen );
- TEST_ASSERT( check_buf != NULL );
+ check_buf = (unsigned char *) mbedtls_calloc(1, olen);
+ TEST_ASSERT(check_buf != NULL);
- ret = mbedtls_pem_write_buffer( start, end, buf->x, buf->len, check_buf, olen, &olen2 );
+ ret = mbedtls_pem_write_buffer(start, end, buf->x, buf->len, check_buf, olen, &olen2);
- TEST_ASSERT( olen2 <= olen );
- TEST_ASSERT( olen > strlen( (char*) result_str ) );
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( strncmp( (char *) check_buf, (char *) result_str, olen ) == 0 );
+ TEST_ASSERT(olen2 <= olen);
+ TEST_ASSERT(olen > strlen((char *) result_str));
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(strncmp((char *) check_buf, (char *) result_str, olen) == 0);
exit:
- mbedtls_free( check_buf );
+ mbedtls_free(check_buf);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PEM_PARSE_C:MBEDTLS_AES_C:MBEDTLS_DES_C:MBEDTLS_MD5_C:MBEDTLS_CIPHER_MODE_CBC */
-void mbedtls_pem_read_buffer( char *header, char *footer, char *data,
- char *pwd, int res )
+void mbedtls_pem_read_buffer(char *header, char *footer, char *data,
+ char *pwd, int res)
{
mbedtls_pem_context ctx;
int ret;
size_t use_len = 0;
- size_t pwd_len = strlen( pwd );
+ size_t pwd_len = strlen(pwd);
- mbedtls_pem_init( &ctx );
+ mbedtls_pem_init(&ctx);
- ret = mbedtls_pem_read_buffer( &ctx, header, footer, (unsigned char *)data,
- (unsigned char *)pwd, pwd_len, &use_len );
- TEST_ASSERT( ret == res );
+ ret = mbedtls_pem_read_buffer(&ctx, header, footer, (unsigned char *) data,
+ (unsigned char *) pwd, pwd_len, &use_len);
+ TEST_ASSERT(ret == res);
exit:
- mbedtls_pem_free( &ctx );
+ mbedtls_pem_free(&ctx);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_pk.function b/tests/suites/test_suite_pk.function
index 9cb90aa..57e95f0 100644
--- a/tests/suites/test_suite_pk.function
+++ b/tests/suites/test_suite_pk.function
@@ -29,59 +29,60 @@
* generation function.
* \return -1 if the key type is not recognized.
*/
-static int pk_genkey( mbedtls_pk_context *pk, int parameter )
+static int pk_genkey(mbedtls_pk_context *pk, int parameter)
{
((void) pk);
(void) parameter;
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME)
- if( mbedtls_pk_get_type( pk ) == MBEDTLS_PK_RSA )
- return mbedtls_rsa_gen_key( mbedtls_pk_rsa( *pk ),
- mbedtls_test_rnd_std_rand, NULL,
- parameter, 3 );
-#endif
-#if defined(MBEDTLS_ECP_C)
- if( mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECKEY ||
- mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECKEY_DH ||
- mbedtls_pk_get_type( pk ) == MBEDTLS_PK_ECDSA )
- {
- int ret;
- if( ( ret = mbedtls_ecp_group_load( &mbedtls_pk_ec( *pk )->grp,
- parameter ) ) != 0 )
- return( ret );
-
- return mbedtls_ecp_gen_keypair( &mbedtls_pk_ec( *pk )->grp,
- &mbedtls_pk_ec( *pk )->d,
- &mbedtls_pk_ec( *pk )->Q,
- mbedtls_test_rnd_std_rand, NULL );
+ if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_RSA) {
+ return mbedtls_rsa_gen_key(mbedtls_pk_rsa(*pk),
+ mbedtls_test_rnd_std_rand, NULL,
+ parameter, 3);
}
#endif
- return( -1 );
+#if defined(MBEDTLS_ECP_C)
+ if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_ECKEY ||
+ mbedtls_pk_get_type(pk) == MBEDTLS_PK_ECKEY_DH ||
+ mbedtls_pk_get_type(pk) == MBEDTLS_PK_ECDSA) {
+ int ret;
+ if ((ret = mbedtls_ecp_group_load(&mbedtls_pk_ec(*pk)->grp,
+ parameter)) != 0) {
+ return ret;
+ }
+
+ return mbedtls_ecp_gen_keypair(&mbedtls_pk_ec(*pk)->grp,
+ &mbedtls_pk_ec(*pk)->d,
+ &mbedtls_pk_ec(*pk)->Q,
+ mbedtls_test_rnd_std_rand, NULL);
+ }
+#endif
+ return -1;
}
#if defined(MBEDTLS_RSA_C)
-int mbedtls_rsa_decrypt_func( void *ctx, int mode, size_t *olen,
- const unsigned char *input, unsigned char *output,
- size_t output_max_len )
+int mbedtls_rsa_decrypt_func(void *ctx, int mode, size_t *olen,
+ const unsigned char *input, unsigned char *output,
+ size_t output_max_len)
{
- return( mbedtls_rsa_pkcs1_decrypt( (mbedtls_rsa_context *) ctx,
- mbedtls_test_rnd_std_rand, NULL, mode,
- olen, input, output, output_max_len ) );
+ return mbedtls_rsa_pkcs1_decrypt((mbedtls_rsa_context *) ctx,
+ mbedtls_test_rnd_std_rand, NULL, mode,
+ olen, input, output, output_max_len);
}
-int mbedtls_rsa_sign_func( void *ctx,
- int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
- int mode, mbedtls_md_type_t md_alg, unsigned int hashlen,
- const unsigned char *hash, unsigned char *sig )
+int mbedtls_rsa_sign_func(void *ctx,
+ int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
+ int mode, mbedtls_md_type_t md_alg, unsigned int hashlen,
+ const unsigned char *hash, unsigned char *sig)
{
((void) f_rng);
((void) p_rng);
- return( mbedtls_rsa_pkcs1_sign( (mbedtls_rsa_context *) ctx,
- mbedtls_test_rnd_std_rand, NULL, mode,
- md_alg, hashlen, hash, sig ) );
+ return mbedtls_rsa_pkcs1_sign((mbedtls_rsa_context *) ctx,
+ mbedtls_test_rnd_std_rand, NULL, mode,
+ md_alg, hashlen, hash, sig);
}
-size_t mbedtls_rsa_key_len_func( void *ctx )
+size_t mbedtls_rsa_key_len_func(void *ctx)
{
- return( ((const mbedtls_rsa_context *) ctx)->len );
+ return ((const mbedtls_rsa_context *) ctx)->len;
}
#endif /* MBEDTLS_RSA_C */
@@ -92,22 +93,22 @@
* or 0 if the key generation failed.
* The key uses NIST P-256 and is usable for signing with SHA-256.
*/
-mbedtls_svc_key_id_t pk_psa_genkey( void )
+mbedtls_svc_key_id_t pk_psa_genkey(void)
{
mbedtls_svc_key_id_t key;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
const psa_key_type_t type =
- PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_FAMILY_SECP_R1 );
+ PSA_KEY_TYPE_ECC_KEY_PAIR(PSA_ECC_FAMILY_SECP_R1);
const size_t bits = 256;
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
- psa_set_key_algorithm( &attributes, PSA_ALG_ECDSA(PSA_ALG_SHA_256) );
- psa_set_key_type( &attributes, type );
- psa_set_key_bits( &attributes, bits );
- PSA_ASSERT( psa_generate_key( &attributes, &key ) );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH);
+ psa_set_key_algorithm(&attributes, PSA_ALG_ECDSA(PSA_ALG_SHA_256));
+ psa_set_key_type(&attributes, type);
+ psa_set_key_bits(&attributes, bits);
+ PSA_ASSERT(psa_generate_key(&attributes, &key));
exit:
- return( key );
+ return key;
}
#endif /* MBEDTLS_USE_PSA_CRYPTO */
/* END_HEADER */
@@ -118,7 +119,7 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_ECDSA_C:MBEDTLS_ECP_DP_SECP256R1_ENABLED */
-void pk_psa_utils( )
+void pk_psa_utils()
{
mbedtls_pk_context pk, pk2;
mbedtls_svc_key_id_t key;
@@ -132,205 +133,206 @@
size_t len;
mbedtls_pk_debug_item dbg;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- mbedtls_pk_init( &pk );
- mbedtls_pk_init( &pk2 );
+ mbedtls_pk_init(&pk);
+ mbedtls_pk_init(&pk2);
- TEST_ASSERT( psa_crypto_init( ) == PSA_SUCCESS );
+ TEST_ASSERT(psa_crypto_init() == PSA_SUCCESS);
- TEST_ASSERT( mbedtls_pk_setup_opaque( &pk, MBEDTLS_SVC_KEY_ID_INIT ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_setup_opaque(&pk, MBEDTLS_SVC_KEY_ID_INIT) ==
+ MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- mbedtls_pk_free( &pk );
- mbedtls_pk_init( &pk );
+ mbedtls_pk_free(&pk);
+ mbedtls_pk_init(&pk);
key = pk_psa_genkey();
- if( mbedtls_svc_key_id_is_null( key ) )
+ if (mbedtls_svc_key_id_is_null(key)) {
goto exit;
+ }
- TEST_ASSERT( mbedtls_pk_setup_opaque( &pk, key ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup_opaque(&pk, key) == 0);
- TEST_ASSERT( mbedtls_pk_get_type( &pk ) == MBEDTLS_PK_OPAQUE );
- TEST_ASSERT( strcmp( mbedtls_pk_get_name( &pk), name ) == 0 );
+ TEST_ASSERT(mbedtls_pk_get_type(&pk) == MBEDTLS_PK_OPAQUE);
+ TEST_ASSERT(strcmp(mbedtls_pk_get_name(&pk), name) == 0);
- TEST_ASSERT( mbedtls_pk_get_bitlen( &pk ) == bitlen );
- TEST_ASSERT( mbedtls_pk_get_len( &pk ) == bitlen / 8 );
+ TEST_ASSERT(mbedtls_pk_get_bitlen(&pk) == bitlen);
+ TEST_ASSERT(mbedtls_pk_get_len(&pk) == bitlen / 8);
- TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECKEY ) == 1 );
- TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) == 1 );
- TEST_ASSERT( mbedtls_pk_can_do( &pk, MBEDTLS_PK_RSA ) == 0 );
+ TEST_ASSERT(mbedtls_pk_can_do(&pk, MBEDTLS_PK_ECKEY) == 1);
+ TEST_ASSERT(mbedtls_pk_can_do(&pk, MBEDTLS_PK_ECDSA) == 1);
+ TEST_ASSERT(mbedtls_pk_can_do(&pk, MBEDTLS_PK_RSA) == 0);
/* unsupported operations: verify, decrypt, encrypt */
- TEST_ASSERT( mbedtls_pk_verify( &pk, md_alg,
- b1, sizeof( b1), b2, sizeof( b2 ) )
- == MBEDTLS_ERR_PK_TYPE_MISMATCH );
- TEST_ASSERT( mbedtls_pk_decrypt( &pk, b1, sizeof( b1 ),
- b2, &len, sizeof( b2 ),
- NULL, NULL )
- == MBEDTLS_ERR_PK_TYPE_MISMATCH );
- TEST_ASSERT( mbedtls_pk_encrypt( &pk, b1, sizeof( b1 ),
- b2, &len, sizeof( b2 ),
- NULL, NULL )
- == MBEDTLS_ERR_PK_TYPE_MISMATCH );
+ TEST_ASSERT(mbedtls_pk_verify(&pk, md_alg,
+ b1, sizeof(b1), b2, sizeof(b2))
+ == MBEDTLS_ERR_PK_TYPE_MISMATCH);
+ TEST_ASSERT(mbedtls_pk_decrypt(&pk, b1, sizeof(b1),
+ b2, &len, sizeof(b2),
+ NULL, NULL)
+ == MBEDTLS_ERR_PK_TYPE_MISMATCH);
+ TEST_ASSERT(mbedtls_pk_encrypt(&pk, b1, sizeof(b1),
+ b2, &len, sizeof(b2),
+ NULL, NULL)
+ == MBEDTLS_ERR_PK_TYPE_MISMATCH);
/* unsupported functions: check_pair, debug */
- TEST_ASSERT( mbedtls_pk_setup( &pk2,
- mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == 0 );
- TEST_ASSERT( mbedtls_pk_check_pair( &pk, &pk2 )
- == MBEDTLS_ERR_PK_TYPE_MISMATCH );
- TEST_ASSERT( mbedtls_pk_debug( &pk, &dbg )
- == MBEDTLS_ERR_PK_TYPE_MISMATCH );
+ TEST_ASSERT(mbedtls_pk_setup(&pk2,
+ mbedtls_pk_info_from_type(MBEDTLS_PK_ECKEY)) == 0);
+ TEST_ASSERT(mbedtls_pk_check_pair(&pk, &pk2)
+ == MBEDTLS_ERR_PK_TYPE_MISMATCH);
+ TEST_ASSERT(mbedtls_pk_debug(&pk, &dbg)
+ == MBEDTLS_ERR_PK_TYPE_MISMATCH);
/* test that freeing the context does not destroy the key */
- mbedtls_pk_free( &pk );
- TEST_ASSERT( PSA_SUCCESS == psa_get_key_attributes( key, &attributes ) );
- TEST_ASSERT( PSA_SUCCESS == psa_destroy_key( key ) );
+ mbedtls_pk_free(&pk);
+ TEST_ASSERT(PSA_SUCCESS == psa_get_key_attributes(key, &attributes));
+ TEST_ASSERT(PSA_SUCCESS == psa_destroy_key(key));
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- mbedtls_pk_free( &pk ); /* redundant except upon error */
- mbedtls_pk_free( &pk2 );
- USE_PSA_DONE( );
+ mbedtls_pk_free(&pk); /* redundant except upon error */
+ mbedtls_pk_free(&pk2);
+ USE_PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void valid_parameters( )
+void valid_parameters()
{
mbedtls_pk_context pk;
unsigned char buf[1];
size_t len;
void *options = NULL;
- mbedtls_pk_init( &pk );
+ mbedtls_pk_init(&pk);
- TEST_VALID_PARAM( mbedtls_pk_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_pk_free(NULL));
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
- TEST_VALID_PARAM( mbedtls_pk_restart_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_pk_restart_free(NULL));
#endif
- TEST_ASSERT( mbedtls_pk_setup( &pk, NULL ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_setup(&pk, NULL) ==
+ MBEDTLS_ERR_PK_BAD_INPUT_DATA);
/* In informational functions, we accept NULL where a context pointer
* is expected because that's what the library has done forever.
* We do not document that NULL is accepted, so we may wish to change
* the behavior in a future version. */
- TEST_ASSERT( mbedtls_pk_get_bitlen( NULL ) == 0 );
- TEST_ASSERT( mbedtls_pk_get_len( NULL ) == 0 );
- TEST_ASSERT( mbedtls_pk_can_do( NULL, MBEDTLS_PK_NONE ) == 0 );
+ TEST_ASSERT(mbedtls_pk_get_bitlen(NULL) == 0);
+ TEST_ASSERT(mbedtls_pk_get_len(NULL) == 0);
+ TEST_ASSERT(mbedtls_pk_can_do(NULL, MBEDTLS_PK_NONE) == 0);
- TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
+ TEST_ASSERT(mbedtls_pk_sign_restartable(&pk,
+ MBEDTLS_MD_NONE,
+ NULL, 0,
+ buf, &len,
+ mbedtls_test_rnd_std_rand, NULL,
+ NULL) ==
+ MBEDTLS_ERR_PK_BAD_INPUT_DATA);
+
+ TEST_ASSERT(mbedtls_pk_sign_restartable(&pk,
+ MBEDTLS_MD_NONE,
+ NULL, 0,
+ buf, &len,
+ mbedtls_test_rnd_std_rand, NULL,
+ NULL) ==
+ MBEDTLS_ERR_PK_BAD_INPUT_DATA);
+
+ TEST_ASSERT(mbedtls_pk_sign(&pk,
+ MBEDTLS_MD_NONE,
+ NULL, 0,
+ buf, &len,
+ mbedtls_test_rnd_std_rand, NULL) ==
+ MBEDTLS_ERR_PK_BAD_INPUT_DATA);
+
+ TEST_ASSERT(mbedtls_pk_verify_restartable(&pk,
MBEDTLS_MD_NONE,
NULL, 0,
- buf, &len,
- mbedtls_test_rnd_std_rand, NULL,
- NULL ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ buf, sizeof(buf),
+ NULL) ==
+ MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_pk_sign_restartable( &pk,
- MBEDTLS_MD_NONE,
- NULL, 0,
- buf, &len,
- mbedtls_test_rnd_std_rand, NULL,
- NULL ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
- TEST_ASSERT( mbedtls_pk_sign( &pk,
+ TEST_ASSERT(mbedtls_pk_verify(&pk,
MBEDTLS_MD_NONE,
NULL, 0,
- buf, &len,
- mbedtls_test_rnd_std_rand, NULL ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ buf, sizeof(buf)) ==
+ MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_pk_verify_restartable( &pk,
- MBEDTLS_MD_NONE,
- NULL, 0,
- buf, sizeof( buf ),
- NULL ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_verify_ext(MBEDTLS_PK_NONE, options,
+ &pk,
+ MBEDTLS_MD_NONE,
+ NULL, 0,
+ buf, sizeof(buf)) ==
+ MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_pk_verify( &pk,
- MBEDTLS_MD_NONE,
- NULL, 0,
- buf, sizeof( buf ) ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_encrypt(&pk,
+ NULL, 0,
+ NULL, &len, 0,
+ mbedtls_test_rnd_std_rand, NULL) ==
+ MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
- &pk,
- MBEDTLS_MD_NONE,
- NULL, 0,
- buf, sizeof( buf ) ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
- TEST_ASSERT( mbedtls_pk_encrypt( &pk,
- NULL, 0,
- NULL, &len, 0,
- mbedtls_test_rnd_std_rand, NULL ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
-
- TEST_ASSERT( mbedtls_pk_decrypt( &pk,
- NULL, 0,
- NULL, &len, 0,
- mbedtls_test_rnd_std_rand, NULL ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_decrypt(&pk,
+ NULL, 0,
+ NULL, &len, 0,
+ mbedtls_test_rnd_std_rand, NULL) ==
+ MBEDTLS_ERR_PK_BAD_INPUT_DATA);
#if defined(MBEDTLS_PK_PARSE_C)
- TEST_ASSERT( mbedtls_pk_parse_key( &pk, NULL, 0, NULL, 1 ) ==
- MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
+ TEST_ASSERT(mbedtls_pk_parse_key(&pk, NULL, 0, NULL, 1) ==
+ MBEDTLS_ERR_PK_KEY_INVALID_FORMAT);
- TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, NULL, 0 ) ==
- MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
+ TEST_ASSERT(mbedtls_pk_parse_public_key(&pk, NULL, 0) ==
+ MBEDTLS_ERR_PK_KEY_INVALID_FORMAT);
#endif /* MBEDTLS_PK_PARSE_C */
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PK_WRITE_C */
-void valid_parameters_pkwrite( data_t *key_data )
+void valid_parameters_pkwrite(data_t *key_data)
{
mbedtls_pk_context pk;
/* For the write tests to be effective, we need a valid key pair. */
- mbedtls_pk_init( &pk );
- TEST_ASSERT( mbedtls_pk_parse_key( &pk,
- key_data->x, key_data->len,
- NULL, 0 ) == 0 );
+ mbedtls_pk_init(&pk);
+ TEST_ASSERT(mbedtls_pk_parse_key(&pk,
+ key_data->x, key_data->len,
+ NULL, 0) == 0);
- TEST_ASSERT( mbedtls_pk_write_key_der( &pk, NULL, 0 ) ==
- MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
+ TEST_ASSERT(mbedtls_pk_write_key_der(&pk, NULL, 0) ==
+ MBEDTLS_ERR_ASN1_BUF_TOO_SMALL);
- TEST_ASSERT( mbedtls_pk_write_pubkey_der( &pk, NULL, 0 ) ==
- MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
+ TEST_ASSERT(mbedtls_pk_write_pubkey_der(&pk, NULL, 0) ==
+ MBEDTLS_ERR_ASN1_BUF_TOO_SMALL);
#if defined(MBEDTLS_PEM_WRITE_C)
- TEST_ASSERT( mbedtls_pk_write_key_pem( &pk, NULL, 0 ) ==
- MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
+ TEST_ASSERT(mbedtls_pk_write_key_pem(&pk, NULL, 0) ==
+ MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL);
- TEST_ASSERT( mbedtls_pk_write_pubkey_pem( &pk, NULL, 0 ) ==
- MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL );
+ TEST_ASSERT(mbedtls_pk_write_pubkey_pem(&pk, NULL, 0) ==
+ MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL);
#endif /* MBEDTLS_PEM_WRITE_C */
exit:
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void invalid_parameters( )
+void invalid_parameters()
{
size_t len;
unsigned char *null_buf = NULL;
unsigned char buf[1];
unsigned char *p = buf;
- char str[1] = {0};
+ char str[1] = { 0 };
mbedtls_pk_context pk;
mbedtls_md_type_t valid_md = MBEDTLS_MD_SHA256;
void *options = buf;
@@ -339,253 +341,253 @@
(void) p;
(void) str;
- mbedtls_pk_init( &pk );
+ mbedtls_pk_init(&pk);
- TEST_INVALID_PARAM( mbedtls_pk_init( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_pk_init(NULL));
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
- TEST_INVALID_PARAM( mbedtls_pk_restart_init( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_pk_restart_init(NULL));
#endif
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_setup( NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_setup(NULL, NULL));
#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_setup_rsa_alt( NULL, buf,
- NULL, NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_setup_rsa_alt(NULL, buf,
+ NULL, NULL, NULL));
#endif
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_verify_restartable( NULL,
- MBEDTLS_MD_NONE,
- buf, sizeof( buf ),
- buf, sizeof( buf ),
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_verify_restartable( &pk,
- MBEDTLS_MD_NONE,
- NULL, sizeof( buf ),
- buf, sizeof( buf ),
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_verify_restartable( &pk,
- valid_md,
- NULL, 0,
- buf, sizeof( buf ),
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_verify_restartable( &pk,
- MBEDTLS_MD_NONE,
- buf, sizeof( buf ),
- NULL, sizeof( buf ),
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_verify_restartable(NULL,
+ MBEDTLS_MD_NONE,
+ buf, sizeof(buf),
+ buf, sizeof(buf),
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_verify_restartable(&pk,
+ MBEDTLS_MD_NONE,
+ NULL, sizeof(buf),
+ buf, sizeof(buf),
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_verify_restartable(&pk,
+ valid_md,
+ NULL, 0,
+ buf, sizeof(buf),
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_verify_restartable(&pk,
+ MBEDTLS_MD_NONE,
+ buf, sizeof(buf),
+ NULL, sizeof(buf),
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_verify( NULL,
- MBEDTLS_MD_NONE,
- buf, sizeof( buf ),
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_verify( &pk,
- MBEDTLS_MD_NONE,
- NULL, sizeof( buf ),
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_verify( &pk,
- valid_md,
- NULL, 0,
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_verify( &pk,
- MBEDTLS_MD_NONE,
- buf, sizeof( buf ),
- NULL, sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_verify(NULL,
+ MBEDTLS_MD_NONE,
+ buf, sizeof(buf),
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_verify(&pk,
+ MBEDTLS_MD_NONE,
+ NULL, sizeof(buf),
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_verify(&pk,
+ valid_md,
+ NULL, 0,
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_verify(&pk,
+ MBEDTLS_MD_NONE,
+ buf, sizeof(buf),
+ NULL, sizeof(buf)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
- NULL,
- MBEDTLS_MD_NONE,
- buf, sizeof( buf ),
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
- &pk,
- MBEDTLS_MD_NONE,
- NULL, sizeof( buf ),
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
- &pk,
- valid_md,
- NULL, 0,
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_verify_ext( MBEDTLS_PK_NONE, options,
- &pk,
- MBEDTLS_MD_NONE,
- buf, sizeof( buf ),
- NULL, sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_verify_ext(MBEDTLS_PK_NONE, options,
+ NULL,
+ MBEDTLS_MD_NONE,
+ buf, sizeof(buf),
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_verify_ext(MBEDTLS_PK_NONE, options,
+ &pk,
+ MBEDTLS_MD_NONE,
+ NULL, sizeof(buf),
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_verify_ext(MBEDTLS_PK_NONE, options,
+ &pk,
+ valid_md,
+ NULL, 0,
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_verify_ext(MBEDTLS_PK_NONE, options,
+ &pk,
+ MBEDTLS_MD_NONE,
+ buf, sizeof(buf),
+ NULL, sizeof(buf)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_sign_restartable( NULL, MBEDTLS_MD_NONE, buf, sizeof( buf ),
- buf, &len, mbedtls_test_rnd_std_rand,
- NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_sign_restartable(NULL, MBEDTLS_MD_NONE, buf, sizeof(buf),
+ buf, &len, mbedtls_test_rnd_std_rand,
+ NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_sign_restartable( &pk, MBEDTLS_MD_NONE, NULL, sizeof( buf ),
- buf, &len, mbedtls_test_rnd_std_rand,
- NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_sign_restartable(&pk, MBEDTLS_MD_NONE, NULL, sizeof(buf),
+ buf, &len, mbedtls_test_rnd_std_rand,
+ NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_sign_restartable( &pk, valid_md, NULL, 0, buf, &len,
- mbedtls_test_rnd_std_rand, NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_sign_restartable(&pk, valid_md, NULL, 0, buf, &len,
+ mbedtls_test_rnd_std_rand, NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_sign_restartable( &pk, MBEDTLS_MD_NONE, buf, sizeof( buf ),
- NULL, &len, mbedtls_test_rnd_std_rand,
- NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_sign_restartable(&pk, MBEDTLS_MD_NONE, buf, sizeof(buf),
+ NULL, &len, mbedtls_test_rnd_std_rand,
+ NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_sign( NULL, MBEDTLS_MD_NONE, buf, sizeof( buf ),
- buf, &len, mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_sign(NULL, MBEDTLS_MD_NONE, buf, sizeof(buf),
+ buf, &len, mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_sign( &pk, MBEDTLS_MD_NONE, NULL, sizeof( buf ),
- buf, &len, mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_sign(&pk, MBEDTLS_MD_NONE, NULL, sizeof(buf),
+ buf, &len, mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_sign( &pk, valid_md, NULL, 0, buf, &len,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_sign(&pk, valid_md, NULL, 0, buf, &len,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_sign( &pk, MBEDTLS_MD_NONE, buf, sizeof( buf ), NULL, &len,
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_sign(&pk, MBEDTLS_MD_NONE, buf, sizeof(buf), NULL, &len,
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_decrypt( NULL, buf, sizeof( buf ), buf, &len, sizeof( buf ),
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_decrypt(NULL, buf, sizeof(buf), buf, &len, sizeof(buf),
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_decrypt( &pk, NULL, sizeof( buf ), buf, &len, sizeof( buf ),
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_decrypt(&pk, NULL, sizeof(buf), buf, &len, sizeof(buf),
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_decrypt( &pk, buf, sizeof( buf ), NULL, &len, sizeof( buf ),
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_decrypt(&pk, buf, sizeof(buf), NULL, &len, sizeof(buf),
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_decrypt( &pk, buf, sizeof( buf ), buf, NULL, sizeof( buf ),
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_decrypt(&pk, buf, sizeof(buf), buf, NULL, sizeof(buf),
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_encrypt( NULL, buf, sizeof( buf ), buf, &len, sizeof( buf ),
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_encrypt(NULL, buf, sizeof(buf), buf, &len, sizeof(buf),
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_encrypt( &pk, NULL, sizeof( buf ), buf, &len, sizeof( buf ),
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_encrypt(&pk, NULL, sizeof(buf), buf, &len, sizeof(buf),
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_encrypt( &pk, buf, sizeof( buf ), NULL, &len, sizeof( buf ),
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_encrypt(&pk, buf, sizeof(buf), NULL, &len, sizeof(buf),
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_encrypt( &pk, buf, sizeof( buf ), buf, NULL, sizeof( buf ),
- mbedtls_test_rnd_std_rand, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_encrypt(&pk, buf, sizeof(buf), buf, NULL, sizeof(buf),
+ mbedtls_test_rnd_std_rand, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_check_pair( NULL, &pk ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_check_pair( &pk, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_check_pair(NULL, &pk));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_check_pair(&pk, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_debug( NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_debug(NULL, NULL));
#if defined(MBEDTLS_PK_PARSE_C)
#if defined(MBEDTLS_FS_IO)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_load_file( NULL, &p, &len ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_load_file( str, NULL, &len ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_load_file( str, &p, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_load_file(NULL, &p, &len));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_load_file(str, NULL, &len));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_load_file(str, &p, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_parse_keyfile( NULL, str, NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_parse_keyfile( &pk, NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_parse_keyfile(NULL, str, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_parse_keyfile(&pk, NULL, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_parse_public_keyfile( NULL, str ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_parse_public_keyfile( &pk, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_parse_public_keyfile(NULL, str));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_parse_public_keyfile(&pk, NULL));
#endif
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_parse_subpubkey( NULL, buf, &pk ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_parse_subpubkey( &null_buf, buf, &pk ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_parse_subpubkey( &p, NULL, &pk ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_parse_subpubkey( &p, buf, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_parse_subpubkey(NULL, buf, &pk));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_parse_subpubkey(&null_buf, buf, &pk));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_parse_subpubkey(&p, NULL, &pk));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_parse_subpubkey(&p, buf, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_parse_key( NULL,
- buf, sizeof( buf ),
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_parse_key( &pk,
- NULL, sizeof( buf ),
- buf, sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_parse_key(NULL,
+ buf, sizeof(buf),
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_parse_key(&pk,
+ NULL, sizeof(buf),
+ buf, sizeof(buf)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_parse_public_key( NULL,
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_parse_public_key( &pk,
- NULL, sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_parse_public_key(NULL,
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_parse_public_key(&pk,
+ NULL, sizeof(buf)));
#endif /* MBEDTLS_PK_PARSE_C */
#if defined(MBEDTLS_PK_WRITE_C)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_write_pubkey( NULL, p, &pk ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_write_pubkey( &null_buf, p, &pk ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_write_pubkey( &p, NULL, &pk ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_write_pubkey( &p, p, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_write_pubkey(NULL, p, &pk));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_write_pubkey(&null_buf, p, &pk));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_write_pubkey(&p, NULL, &pk));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_write_pubkey(&p, p, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_write_pubkey_der( NULL,
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_write_pubkey_der( &pk,
- NULL, sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_write_pubkey_der(NULL,
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_write_pubkey_der(&pk,
+ NULL, sizeof(buf)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_write_key_der( NULL,
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_write_key_der( &pk,
- NULL, sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_write_key_der(NULL,
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_write_key_der(&pk,
+ NULL, sizeof(buf)));
#if defined(MBEDTLS_PEM_WRITE_C)
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_write_pubkey_pem( NULL,
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_write_pubkey_pem( &pk,
- NULL, sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_write_pubkey_pem(NULL,
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_write_pubkey_pem(&pk,
+ NULL, sizeof(buf)));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_write_key_pem( NULL,
- buf, sizeof( buf ) ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_PK_BAD_INPUT_DATA,
- mbedtls_pk_write_key_pem( &pk,
- NULL, sizeof( buf ) ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_write_key_pem(NULL,
+ buf, sizeof(buf)));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_PK_BAD_INPUT_DATA,
+ mbedtls_pk_write_key_pem(&pk,
+ NULL, sizeof(buf)));
#endif /* MBEDTLS_PEM_WRITE_C */
#endif /* MBEDTLS_PK_WRITE_C */
@@ -593,60 +595,59 @@
/* END_CASE */
/* BEGIN_CASE */
-void pk_utils( int type, int parameter, int bitlen, int len, char * name )
+void pk_utils(int type, int parameter, int bitlen, int len, char *name)
{
mbedtls_pk_context pk;
- mbedtls_pk_init( &pk );
+ mbedtls_pk_init(&pk);
- TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
- TEST_ASSERT( pk_genkey( &pk, parameter ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(type)) == 0);
+ TEST_ASSERT(pk_genkey(&pk, parameter) == 0);
- TEST_ASSERT( (int) mbedtls_pk_get_type( &pk ) == type );
- TEST_ASSERT( mbedtls_pk_can_do( &pk, type ) );
- TEST_ASSERT( mbedtls_pk_get_bitlen( &pk ) == (unsigned) bitlen );
- TEST_ASSERT( mbedtls_pk_get_len( &pk ) == (unsigned) len );
- TEST_ASSERT( strcmp( mbedtls_pk_get_name( &pk), name ) == 0 );
+ TEST_ASSERT((int) mbedtls_pk_get_type(&pk) == type);
+ TEST_ASSERT(mbedtls_pk_can_do(&pk, type));
+ TEST_ASSERT(mbedtls_pk_get_bitlen(&pk) == (unsigned) bitlen);
+ TEST_ASSERT(mbedtls_pk_get_len(&pk) == (unsigned) len);
+ TEST_ASSERT(strcmp(mbedtls_pk_get_name(&pk), name) == 0);
exit:
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PK_PARSE_C:MBEDTLS_FS_IO */
-void mbedtls_pk_check_pair( char * pub_file, char * prv_file, int ret )
+void mbedtls_pk_check_pair(char *pub_file, char *prv_file, int ret)
{
mbedtls_pk_context pub, prv, alt;
- mbedtls_pk_init( &pub );
- mbedtls_pk_init( &prv );
- mbedtls_pk_init( &alt );
+ mbedtls_pk_init(&pub);
+ mbedtls_pk_init(&prv);
+ mbedtls_pk_init(&alt);
- TEST_ASSERT( mbedtls_pk_parse_public_keyfile( &pub, pub_file ) == 0 );
- TEST_ASSERT( mbedtls_pk_parse_keyfile( &prv, prv_file, NULL ) == 0 );
+ TEST_ASSERT(mbedtls_pk_parse_public_keyfile(&pub, pub_file) == 0);
+ TEST_ASSERT(mbedtls_pk_parse_keyfile(&prv, prv_file, NULL) == 0);
- TEST_ASSERT( mbedtls_pk_check_pair( &pub, &prv ) == ret );
+ TEST_ASSERT(mbedtls_pk_check_pair(&pub, &prv) == ret);
#if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
- if( mbedtls_pk_get_type( &prv ) == MBEDTLS_PK_RSA )
- {
- TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, mbedtls_pk_rsa( prv ),
- mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func,
- mbedtls_rsa_key_len_func ) == 0 );
- TEST_ASSERT( mbedtls_pk_check_pair( &pub, &alt ) == ret );
+ if (mbedtls_pk_get_type(&prv) == MBEDTLS_PK_RSA) {
+ TEST_ASSERT(mbedtls_pk_setup_rsa_alt(&alt, mbedtls_pk_rsa(prv),
+ mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func,
+ mbedtls_rsa_key_len_func) == 0);
+ TEST_ASSERT(mbedtls_pk_check_pair(&pub, &alt) == ret);
}
#endif
- mbedtls_pk_free( &pub );
- mbedtls_pk_free( &prv );
- mbedtls_pk_free( &alt );
+ mbedtls_pk_free(&pub);
+ mbedtls_pk_free(&prv);
+ mbedtls_pk_free(&alt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
-void pk_rsa_verify_test_vec( data_t * message_str, int digest, int mod,
- char * input_N, char * input_E,
- data_t * result_str, int result )
+void pk_rsa_verify_test_vec(data_t *message_str, int digest, int mod,
+ char *input_N, char *input_E,
+ data_t *result_str, int result)
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
mbedtls_rsa_context *rsa;
@@ -656,46 +657,49 @@
mbedtls_pk_restart_ctx ctx;
rs_ctx = &ctx;
- mbedtls_pk_restart_init( rs_ctx );
+ mbedtls_pk_restart_init(rs_ctx);
// this setting would ensure restart would happen if ECC was used
- mbedtls_ecp_set_max_ops( 1 );
+ mbedtls_ecp_set_max_ops(1);
#endif
- mbedtls_pk_init( &pk );
+ mbedtls_pk_init(&pk);
- memset( hash_result, 0x00, MBEDTLS_MD_MAX_SIZE );
+ memset(hash_result, 0x00, MBEDTLS_MD_MAX_SIZE);
- TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
- rsa = mbedtls_pk_rsa( pk );
+ TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
+ rsa = mbedtls_pk_rsa(pk);
rsa->len = mod / 8;
- TEST_ASSERT( mbedtls_test_read_mpi( &rsa->N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &rsa->E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&rsa->N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&rsa->E, input_E) == 0);
- if( mbedtls_md_info_from_type( digest ) != NULL )
- TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
+ if (mbedtls_md_info_from_type(digest) != NULL) {
+ TEST_ASSERT(mbedtls_md(mbedtls_md_info_from_type(digest), message_str->x, message_str->len,
+ hash_result) == 0);
+ }
- TEST_ASSERT( mbedtls_pk_verify( &pk, digest, hash_result, 0,
- result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
+ TEST_ASSERT(mbedtls_pk_verify(&pk, digest, hash_result, 0,
+ result_str->x, mbedtls_pk_get_len(&pk)) == result);
- TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, digest, hash_result, 0,
- result_str->x, mbedtls_pk_get_len( &pk ), rs_ctx ) == result );
+ TEST_ASSERT(mbedtls_pk_verify_restartable(&pk, digest, hash_result, 0,
+ result_str->x, mbedtls_pk_get_len(
+ &pk), rs_ctx) == result);
exit:
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
- mbedtls_pk_restart_free( rs_ctx );
+ mbedtls_pk_restart_free(rs_ctx);
#endif
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
-void pk_rsa_verify_ext_test_vec( data_t * message_str, int digest,
- int mod, char * input_N,
- char * input_E, data_t * result_str,
- int pk_type, int mgf1_hash_id,
- int salt_len, int result )
+void pk_rsa_verify_ext_test_vec(data_t *message_str, int digest,
+ int mod, char *input_N,
+ char *input_E, data_t *result_str,
+ int pk_type, int mgf1_hash_id,
+ int salt_len, int result)
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
mbedtls_rsa_context *rsa;
@@ -704,85 +708,79 @@
void *options;
size_t hash_len;
- mbedtls_pk_init( &pk );
+ mbedtls_pk_init(&pk);
- memset( hash_result, 0x00, sizeof( hash_result ) );
+ memset(hash_result, 0x00, sizeof(hash_result));
- TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
- rsa = mbedtls_pk_rsa( pk );
+ TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
+ rsa = mbedtls_pk_rsa(pk);
rsa->len = mod / 8;
- TEST_ASSERT( mbedtls_test_read_mpi( &rsa->N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &rsa->E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&rsa->N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&rsa->E, input_E) == 0);
- if( digest != MBEDTLS_MD_NONE )
- {
- TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ),
- message_str->x, message_str->len, hash_result ) == 0 );
+ if (digest != MBEDTLS_MD_NONE) {
+ TEST_ASSERT(mbedtls_md(mbedtls_md_info_from_type(digest),
+ message_str->x, message_str->len, hash_result) == 0);
hash_len = 0;
- }
- else
- {
- memcpy( hash_result, message_str->x, message_str->len );
+ } else {
+ memcpy(hash_result, message_str->x, message_str->len);
hash_len = message_str->len;
}
- if( mgf1_hash_id < 0 )
- {
+ if (mgf1_hash_id < 0) {
options = NULL;
- }
- else
- {
+ } else {
options = &pss_opts;
pss_opts.mgf1_hash_id = mgf1_hash_id;
pss_opts.expected_salt_len = salt_len;
}
- TEST_ASSERT( mbedtls_pk_verify_ext( pk_type, options, &pk,
- digest, hash_result, hash_len,
- result_str->x, mbedtls_pk_get_len( &pk ) ) == result );
+ TEST_ASSERT(mbedtls_pk_verify_ext(pk_type, options, &pk,
+ digest, hash_result, hash_len,
+ result_str->x, mbedtls_pk_get_len(&pk)) == result);
exit:
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECDSA_C */
-void pk_ec_test_vec( int type, int id, data_t * key, data_t * hash,
- data_t * sig, int ret )
+void pk_ec_test_vec(int type, int id, data_t *key, data_t *hash,
+ data_t *sig, int ret)
{
mbedtls_pk_context pk;
mbedtls_ecp_keypair *eckey;
- mbedtls_pk_init( &pk );
- USE_PSA_INIT( );
+ 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( mbedtls_pk_can_do( &pk, MBEDTLS_PK_ECDSA ) );
- eckey = mbedtls_pk_ec( pk );
+ TEST_ASSERT(mbedtls_pk_can_do(&pk, MBEDTLS_PK_ECDSA));
+ eckey = mbedtls_pk_ec(pk);
- TEST_ASSERT( mbedtls_ecp_group_load( &eckey->grp, id ) == 0 );
- TEST_ASSERT( mbedtls_ecp_point_read_binary( &eckey->grp, &eckey->Q,
- key->x, key->len ) == 0 );
+ TEST_ASSERT(mbedtls_ecp_group_load(&eckey->grp, id) == 0);
+ TEST_ASSERT(mbedtls_ecp_point_read_binary(&eckey->grp, &eckey->Q,
+ key->x, key->len) == 0);
// MBEDTLS_MD_NONE is used since it will be ignored.
- TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE,
- hash->x, hash->len, sig->x, sig->len ) == ret );
+ TEST_ASSERT(mbedtls_pk_verify(&pk, MBEDTLS_MD_NONE,
+ hash->x, hash->len, sig->x, sig->len) == ret);
exit:
- mbedtls_pk_free( &pk );
- USE_PSA_DONE( );
+ mbedtls_pk_free(&pk);
+ USE_PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ECP_RESTARTABLE:MBEDTLS_ECDSA_C:MBEDTLS_ECDSA_DETERMINISTIC */
-void pk_sign_verify_restart( int pk_type, int grp_id, char *d_str,
- char *QX_str, char *QY_str,
- int md_alg, char *msg, data_t *sig_check,
- int max_ops, int min_restart, int max_restart )
+void pk_sign_verify_restart(int pk_type, int grp_id, char *d_str,
+ char *QX_str, char *QY_str,
+ int md_alg, char *msg, data_t *sig_check,
+ int max_ops, int min_restart, int max_restart)
{
int ret, cnt_restart;
mbedtls_pk_restart_ctx rs_ctx;
@@ -792,94 +790,93 @@
size_t hlen, slen;
const mbedtls_md_info_t *md_info;
- mbedtls_pk_restart_init( &rs_ctx );
- mbedtls_pk_init( &prv );
- mbedtls_pk_init( &pub );
- memset( hash, 0, sizeof( hash ) );
- memset( sig, 0, sizeof( sig ) );
+ mbedtls_pk_restart_init(&rs_ctx);
+ mbedtls_pk_init(&prv);
+ mbedtls_pk_init(&pub);
+ memset(hash, 0, sizeof(hash));
+ memset(sig, 0, sizeof(sig));
- TEST_ASSERT( mbedtls_pk_setup( &prv, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
- TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( prv )->grp, grp_id ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &mbedtls_pk_ec( prv )->d, d_str ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup(&prv, mbedtls_pk_info_from_type(pk_type)) == 0);
+ TEST_ASSERT(mbedtls_ecp_group_load(&mbedtls_pk_ec(prv)->grp, grp_id) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&mbedtls_pk_ec(prv)->d, d_str) == 0);
- TEST_ASSERT( mbedtls_pk_setup( &pub, mbedtls_pk_info_from_type( pk_type ) ) == 0 );
- TEST_ASSERT( mbedtls_ecp_group_load( &mbedtls_pk_ec( pub )->grp, grp_id ) == 0 );
- TEST_ASSERT( mbedtls_ecp_point_read_string( &mbedtls_pk_ec( pub )->Q, 16, QX_str, QY_str ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup(&pub, mbedtls_pk_info_from_type(pk_type)) == 0);
+ TEST_ASSERT(mbedtls_ecp_group_load(&mbedtls_pk_ec(pub)->grp, grp_id) == 0);
+ TEST_ASSERT(mbedtls_ecp_point_read_string(&mbedtls_pk_ec(pub)->Q, 16, QX_str, QY_str) == 0);
- md_info = mbedtls_md_info_from_type( md_alg );
- TEST_ASSERT( md_info != NULL );
+ md_info = mbedtls_md_info_from_type(md_alg);
+ TEST_ASSERT(md_info != NULL);
- hlen = mbedtls_md_get_size( md_info );
- TEST_ASSERT( mbedtls_md( md_info,
- (const unsigned char *) msg, strlen( msg ),
- hash ) == 0 );
+ hlen = mbedtls_md_get_size(md_info);
+ TEST_ASSERT(mbedtls_md(md_info,
+ (const unsigned char *) msg, strlen(msg),
+ hash) == 0);
- mbedtls_ecp_set_max_ops( max_ops );
+ mbedtls_ecp_set_max_ops(max_ops);
- slen = sizeof( sig );
+ slen = sizeof(sig);
cnt_restart = 0;
do {
- ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
- sig, &slen, NULL, NULL, &rs_ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
+ ret = mbedtls_pk_sign_restartable(&prv, md_alg, hash, hlen,
+ sig, &slen, NULL, NULL, &rs_ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart);
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( slen == sig_check->len );
- TEST_ASSERT( memcmp( sig, sig_check->x, slen ) == 0 );
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(slen == sig_check->len);
+ TEST_ASSERT(memcmp(sig, sig_check->x, slen) == 0);
- TEST_ASSERT( cnt_restart >= min_restart );
- TEST_ASSERT( cnt_restart <= max_restart );
+ TEST_ASSERT(cnt_restart >= min_restart);
+ TEST_ASSERT(cnt_restart <= max_restart);
cnt_restart = 0;
do {
- ret = mbedtls_pk_verify_restartable( &pub, md_alg,
- hash, hlen, sig, slen, &rs_ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
+ ret = mbedtls_pk_verify_restartable(&pub, md_alg,
+ hash, hlen, sig, slen, &rs_ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart);
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( cnt_restart >= min_restart );
- TEST_ASSERT( cnt_restart <= max_restart );
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(cnt_restart >= min_restart);
+ TEST_ASSERT(cnt_restart <= max_restart);
hash[0]++;
do {
- ret = mbedtls_pk_verify_restartable( &pub, md_alg,
- hash, hlen, sig, slen, &rs_ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
- TEST_ASSERT( ret != 0 );
+ ret = mbedtls_pk_verify_restartable(&pub, md_alg,
+ hash, hlen, sig, slen, &rs_ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
+ TEST_ASSERT(ret != 0);
hash[0]--;
sig[0]++;
do {
- ret = mbedtls_pk_verify_restartable( &pub, md_alg,
- hash, hlen, sig, slen, &rs_ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
- TEST_ASSERT( ret != 0 );
+ ret = mbedtls_pk_verify_restartable(&pub, md_alg,
+ hash, hlen, sig, slen, &rs_ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
+ TEST_ASSERT(ret != 0);
sig[0]--;
/* Do we leak memory when aborting? try verify then sign
* This test only makes sense when we actually restart */
- if( min_restart > 0 )
- {
- ret = mbedtls_pk_verify_restartable( &pub, md_alg,
- hash, hlen, sig, slen, &rs_ctx );
- TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
- mbedtls_pk_restart_free( &rs_ctx );
+ if (min_restart > 0) {
+ ret = mbedtls_pk_verify_restartable(&pub, md_alg,
+ hash, hlen, sig, slen, &rs_ctx);
+ TEST_ASSERT(ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
+ mbedtls_pk_restart_free(&rs_ctx);
- slen = sizeof( sig );
- ret = mbedtls_pk_sign_restartable( &prv, md_alg, hash, hlen,
- sig, &slen, NULL, NULL, &rs_ctx );
- TEST_ASSERT( ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
+ slen = sizeof(sig);
+ ret = mbedtls_pk_sign_restartable(&prv, md_alg, hash, hlen,
+ sig, &slen, NULL, NULL, &rs_ctx);
+ TEST_ASSERT(ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
}
exit:
- mbedtls_pk_restart_free( &rs_ctx );
- mbedtls_pk_free( &prv );
- mbedtls_pk_free( &pub );
+ mbedtls_pk_restart_free(&rs_ctx);
+ mbedtls_pk_free(&prv);
+ mbedtls_pk_free(&pub);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
-void pk_sign_verify( int type, int parameter, int sign_ret, int verify_ret )
+void pk_sign_verify(int type, int parameter, int sign_ret, int verify_ret)
{
mbedtls_pk_context pk;
size_t sig_len, hash_len;
@@ -891,88 +888,88 @@
mbedtls_pk_restart_ctx ctx;
rs_ctx = &ctx;
- mbedtls_pk_restart_init( rs_ctx );
+ mbedtls_pk_restart_init(rs_ctx);
/* This value is large enough that the operation will complete in one run.
* See comments at the top of ecp_test_vect_restart in
* test_suite_ecp.function for estimates of operation counts. */
- mbedtls_ecp_set_max_ops( 42000 );
+ mbedtls_ecp_set_max_ops(42000);
#endif
- hash_len = mbedtls_md_get_size( mbedtls_md_info_from_type( md ) );
- ASSERT_ALLOC( hash, hash_len );
+ hash_len = mbedtls_md_get_size(mbedtls_md_info_from_type(md));
+ ASSERT_ALLOC(hash, hash_len);
- mbedtls_pk_init( &pk );
- USE_PSA_INIT( );
+ mbedtls_pk_init(&pk);
+ USE_PSA_INIT();
- memset( hash, 0x2a, hash_len );
- memset( sig, 0, sizeof sig );
+ memset(hash, 0x2a, hash_len);
+ memset(sig, 0, sizeof sig);
- TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( type ) ) == 0 );
- TEST_ASSERT( pk_genkey( &pk, parameter ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(type)) == 0);
+ TEST_ASSERT(pk_genkey(&pk, parameter) == 0);
- TEST_ASSERT( mbedtls_pk_sign_restartable( &pk, md,
- hash, hash_len, sig, &sig_len,
- mbedtls_test_rnd_std_rand, NULL, rs_ctx ) == sign_ret );
- if( sign_ret == 0 )
- TEST_ASSERT( sig_len <= MBEDTLS_PK_SIGNATURE_MAX_SIZE );
- else
+ TEST_ASSERT(mbedtls_pk_sign_restartable(&pk, md,
+ hash, hash_len, sig, &sig_len,
+ mbedtls_test_rnd_std_rand, NULL, rs_ctx) == sign_ret);
+ if (sign_ret == 0) {
+ TEST_ASSERT(sig_len <= MBEDTLS_PK_SIGNATURE_MAX_SIZE);
+ } else {
sig_len = MBEDTLS_PK_SIGNATURE_MAX_SIZE;
+ }
- TEST_ASSERT( mbedtls_pk_verify( &pk, md,
- hash, hash_len, sig, sig_len ) == verify_ret );
+ TEST_ASSERT(mbedtls_pk_verify(&pk, md,
+ hash, hash_len, sig, sig_len) == verify_ret);
- if( verify_ret == 0 )
- {
+ if (verify_ret == 0) {
hash[0]++;
- TEST_ASSERT( mbedtls_pk_verify( &pk, md,
- hash, hash_len, sig, sig_len ) != 0 );
+ TEST_ASSERT(mbedtls_pk_verify(&pk, md,
+ hash, hash_len, sig, sig_len) != 0);
hash[0]--;
sig[0]++;
- TEST_ASSERT( mbedtls_pk_verify( &pk, md,
- hash, hash_len, sig, sig_len ) != 0 );
+ TEST_ASSERT(mbedtls_pk_verify(&pk, md,
+ hash, hash_len, sig, sig_len) != 0);
sig[0]--;
}
- TEST_ASSERT( mbedtls_pk_sign( &pk, md, hash, hash_len,
- sig, &sig_len,
- mbedtls_test_rnd_std_rand,
- NULL ) == sign_ret );
- if( sign_ret == 0 )
- TEST_ASSERT( sig_len <= MBEDTLS_PK_SIGNATURE_MAX_SIZE );
- else
+ TEST_ASSERT(mbedtls_pk_sign(&pk, md, hash, hash_len,
+ sig, &sig_len,
+ mbedtls_test_rnd_std_rand,
+ NULL) == sign_ret);
+ if (sign_ret == 0) {
+ TEST_ASSERT(sig_len <= MBEDTLS_PK_SIGNATURE_MAX_SIZE);
+ } else {
sig_len = MBEDTLS_PK_SIGNATURE_MAX_SIZE;
+ }
- TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, md,
- hash, hash_len, sig, sig_len, rs_ctx ) == verify_ret );
+ TEST_ASSERT(mbedtls_pk_verify_restartable(&pk, md,
+ hash, hash_len, sig, sig_len, rs_ctx) == verify_ret);
- if( verify_ret == 0 )
- {
+ if (verify_ret == 0) {
hash[0]++;
- TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, md,
- hash, hash_len, sig, sig_len, rs_ctx ) != 0 );
+ TEST_ASSERT(mbedtls_pk_verify_restartable(&pk, md,
+ hash, hash_len, sig, sig_len, rs_ctx) != 0);
hash[0]--;
sig[0]++;
- TEST_ASSERT( mbedtls_pk_verify_restartable( &pk, md,
- hash, hash_len, sig, sig_len, rs_ctx ) != 0 );
+ TEST_ASSERT(mbedtls_pk_verify_restartable(&pk, md,
+ hash, hash_len, sig, sig_len, rs_ctx) != 0);
sig[0]--;
}
exit:
#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
- mbedtls_pk_restart_free( rs_ctx );
+ mbedtls_pk_restart_free(rs_ctx);
#endif
- mbedtls_pk_free( &pk );
- mbedtls_free( hash );
- USE_PSA_DONE( );
+ mbedtls_pk_free(&pk);
+ mbedtls_free(hash);
+ USE_PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
-void pk_rsa_encrypt_test_vec( data_t * message, int mod,
- char * input_N, char * input_E,
- data_t * result, int ret )
+void pk_rsa_encrypt_test_vec(data_t *message, int mod,
+ char *input_N, char *input_E,
+ data_t *result, int ret)
{
unsigned char output[300];
mbedtls_test_rnd_pseudo_info rnd_info;
@@ -980,34 +977,34 @@
mbedtls_pk_context pk;
size_t olen;
- memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
- memset( output, 0, sizeof( output ) );
+ memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
+ memset(output, 0, sizeof(output));
- mbedtls_pk_init( &pk );
- TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
- rsa = mbedtls_pk_rsa( pk );
+ mbedtls_pk_init(&pk);
+ TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
+ rsa = mbedtls_pk_rsa(pk);
rsa->len = mod / 8;
- TEST_ASSERT( mbedtls_test_read_mpi( &rsa->N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &rsa->E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&rsa->N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&rsa->E, input_E) == 0);
- TEST_ASSERT( mbedtls_pk_encrypt( &pk, message->x, message->len,
- output, &olen, sizeof( output ),
- mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
- TEST_ASSERT( olen == result->len );
- TEST_ASSERT( memcmp( output, result->x, olen ) == 0 );
+ TEST_ASSERT(mbedtls_pk_encrypt(&pk, message->x, message->len,
+ output, &olen, sizeof(output),
+ mbedtls_test_rnd_pseudo_rand, &rnd_info) == ret);
+ TEST_ASSERT(olen == result->len);
+ TEST_ASSERT(memcmp(output, result->x, olen) == 0);
exit:
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
-void pk_rsa_decrypt_test_vec( data_t * cipher, int mod,
- char * input_P, char * input_Q,
- char * input_N, char * input_E,
- data_t * clear, int ret )
+void pk_rsa_decrypt_test_vec(data_t *cipher, int mod,
+ char *input_P, char *input_Q,
+ char *input_N, char *input_E,
+ data_t *clear, int ret)
{
unsigned char output[256];
mbedtls_test_rnd_pseudo_info rnd_info;
@@ -1016,49 +1013,48 @@
mbedtls_pk_context pk;
size_t olen;
- mbedtls_pk_init( &pk );
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
- mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
+ mbedtls_pk_init(&pk);
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
+ mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
- memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
/* init pk-rsa context */
- TEST_ASSERT( mbedtls_pk_setup( &pk, mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
- rsa = mbedtls_pk_rsa( pk );
+ TEST_ASSERT(mbedtls_pk_setup(&pk, mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
+ rsa = mbedtls_pk_rsa(pk);
/* load public key */
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
/* load private key */
- TEST_ASSERT( mbedtls_test_read_mpi( &P, input_P ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Q, input_Q ) == 0 );
- TEST_ASSERT( mbedtls_rsa_import( rsa, &N, &P, &Q, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( rsa ) == (size_t) ( mod / 8 ) );
- TEST_ASSERT( mbedtls_rsa_complete( rsa ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
+ TEST_ASSERT(mbedtls_rsa_import(rsa, &N, &P, &Q, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(rsa) == (size_t) (mod / 8));
+ TEST_ASSERT(mbedtls_rsa_complete(rsa) == 0);
/* decryption test */
- memset( output, 0, sizeof( output ) );
+ memset(output, 0, sizeof(output));
olen = 0;
- TEST_ASSERT( mbedtls_pk_decrypt( &pk, cipher->x, cipher->len,
- output, &olen, sizeof( output ),
- mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
- if( ret == 0 )
- {
- TEST_ASSERT( olen == clear->len );
- TEST_ASSERT( memcmp( output, clear->x, olen ) == 0 );
+ TEST_ASSERT(mbedtls_pk_decrypt(&pk, cipher->x, cipher->len,
+ output, &olen, sizeof(output),
+ mbedtls_test_rnd_pseudo_rand, &rnd_info) == ret);
+ if (ret == 0) {
+ TEST_ASSERT(olen == clear->len);
+ TEST_ASSERT(memcmp(output, clear->x, olen) == 0);
}
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
- mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
- mbedtls_pk_free( &pk );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
+ mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE */
-void pk_ec_nocrypt( int type )
+void pk_ec_nocrypt(int type)
{
mbedtls_pk_context pk;
unsigned char output[100];
@@ -1067,65 +1063,66 @@
size_t olen = 0;
int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
- mbedtls_pk_init( &pk );
+ mbedtls_pk_init(&pk);
- memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
- memset( output, 0, sizeof( output ) );
- memset( input, 0, sizeof( input ) );
+ memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
+ memset(output, 0, sizeof(output));
+ memset(input, 0, sizeof(input));
- 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( mbedtls_pk_encrypt( &pk, input, sizeof( input ),
- output, &olen, sizeof( output ),
- mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
+ TEST_ASSERT(mbedtls_pk_encrypt(&pk, input, sizeof(input),
+ output, &olen, sizeof(output),
+ mbedtls_test_rnd_pseudo_rand, &rnd_info) == ret);
- TEST_ASSERT( mbedtls_pk_decrypt( &pk, input, sizeof( input ),
- output, &olen, sizeof( output ),
- mbedtls_test_rnd_pseudo_rand, &rnd_info ) == ret );
+ TEST_ASSERT(mbedtls_pk_decrypt(&pk, input, sizeof(input),
+ output, &olen, sizeof(output),
+ mbedtls_test_rnd_pseudo_rand, &rnd_info) == ret);
exit:
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RSA_C */
-void pk_rsa_overflow( )
+void pk_rsa_overflow()
{
mbedtls_pk_context pk;
size_t hash_len = SIZE_MAX, sig_len = SIZE_MAX;
unsigned char hash[50], sig[100];
- if( SIZE_MAX <= UINT_MAX )
+ if (SIZE_MAX <= UINT_MAX) {
return;
+ }
- memset( hash, 0x2a, sizeof hash );
- memset( sig, 0, sizeof sig );
+ memset(hash, 0x2a, sizeof hash);
+ memset(sig, 0, sizeof sig);
- mbedtls_pk_init( &pk );
+ mbedtls_pk_init(&pk);
- 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);
#if defined(MBEDTLS_PKCS1_V21)
- TEST_ASSERT( mbedtls_pk_verify_ext( MBEDTLS_PK_RSASSA_PSS, NULL, &pk,
- MBEDTLS_MD_NONE, hash, hash_len, sig, sig_len ) ==
- MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_verify_ext(MBEDTLS_PK_RSASSA_PSS, NULL, &pk,
+ MBEDTLS_MD_NONE, hash, hash_len, sig, sig_len) ==
+ MBEDTLS_ERR_PK_BAD_INPUT_DATA);
#endif /* MBEDTLS_PKCS1_V21 */
- TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_NONE, hash, hash_len,
- sig, sig_len ) == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_verify(&pk, MBEDTLS_MD_NONE, hash, hash_len,
+ sig, sig_len) == MBEDTLS_ERR_PK_BAD_INPUT_DATA);
- TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_NONE, hash, hash_len, sig,
- &sig_len, mbedtls_test_rnd_std_rand, NULL )
- == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_sign(&pk, MBEDTLS_MD_NONE, hash, hash_len, sig,
+ &sig_len, mbedtls_test_rnd_std_rand, NULL)
+ == MBEDTLS_ERR_PK_BAD_INPUT_DATA);
exit:
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RSA_C:MBEDTLS_PK_RSA_ALT_SUPPORT */
-void pk_rsa_alt( )
+void pk_rsa_alt()
{
/*
* An rsa_alt context can only do private operations (decrypt, sign).
@@ -1140,74 +1137,75 @@
size_t sig_len, ciph_len, test_len;
int ret = MBEDTLS_ERR_PK_TYPE_MISMATCH;
- mbedtls_rsa_init( &raw, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_NONE );
- mbedtls_pk_init( &rsa ); mbedtls_pk_init( &alt );
+ mbedtls_rsa_init(&raw, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_NONE);
+ mbedtls_pk_init(&rsa); mbedtls_pk_init(&alt);
- memset( hash, 0x2a, sizeof hash );
- memset( sig, 0, sizeof sig );
- memset( msg, 0x2a, sizeof msg );
- memset( ciph, 0, sizeof ciph );
- memset( test, 0, sizeof test );
+ memset(hash, 0x2a, sizeof hash);
+ memset(sig, 0, sizeof sig);
+ memset(msg, 0x2a, sizeof msg);
+ memset(ciph, 0, sizeof ciph);
+ memset(test, 0, sizeof test);
/* Initialize PK RSA context with random key */
- TEST_ASSERT( mbedtls_pk_setup( &rsa,
- mbedtls_pk_info_from_type( MBEDTLS_PK_RSA ) ) == 0 );
- TEST_ASSERT( pk_genkey( &rsa, RSA_KEY_SIZE ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup(&rsa,
+ mbedtls_pk_info_from_type(MBEDTLS_PK_RSA)) == 0);
+ TEST_ASSERT(pk_genkey(&rsa, RSA_KEY_SIZE) == 0);
/* Extract key to the raw rsa context */
- TEST_ASSERT( mbedtls_rsa_copy( &raw, mbedtls_pk_rsa( rsa ) ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_copy(&raw, mbedtls_pk_rsa(rsa)) == 0);
/* Initialize PK RSA_ALT context */
- TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &alt, (void *) &raw,
- mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func, mbedtls_rsa_key_len_func ) == 0 );
+ TEST_ASSERT(mbedtls_pk_setup_rsa_alt(&alt, (void *) &raw,
+ mbedtls_rsa_decrypt_func, mbedtls_rsa_sign_func,
+ mbedtls_rsa_key_len_func) == 0);
/* Test administrative functions */
- TEST_ASSERT( mbedtls_pk_can_do( &alt, MBEDTLS_PK_RSA ) );
- TEST_ASSERT( mbedtls_pk_get_bitlen( &alt ) == RSA_KEY_SIZE );
- TEST_ASSERT( mbedtls_pk_get_len( &alt ) == RSA_KEY_LEN );
- TEST_ASSERT( mbedtls_pk_get_type( &alt ) == MBEDTLS_PK_RSA_ALT );
- TEST_ASSERT( strcmp( mbedtls_pk_get_name( &alt ), "RSA-alt" ) == 0 );
+ TEST_ASSERT(mbedtls_pk_can_do(&alt, MBEDTLS_PK_RSA));
+ TEST_ASSERT(mbedtls_pk_get_bitlen(&alt) == RSA_KEY_SIZE);
+ TEST_ASSERT(mbedtls_pk_get_len(&alt) == RSA_KEY_LEN);
+ TEST_ASSERT(mbedtls_pk_get_type(&alt) == MBEDTLS_PK_RSA_ALT);
+ TEST_ASSERT(strcmp(mbedtls_pk_get_name(&alt), "RSA-alt") == 0);
/* Test signature */
#if SIZE_MAX > UINT_MAX
- TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, SIZE_MAX, sig,
- &sig_len, mbedtls_test_rnd_std_rand, NULL )
- == MBEDTLS_ERR_PK_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_pk_sign(&alt, MBEDTLS_MD_NONE, hash, SIZE_MAX, sig,
+ &sig_len, mbedtls_test_rnd_std_rand, NULL)
+ == MBEDTLS_ERR_PK_BAD_INPUT_DATA);
#endif /* SIZE_MAX > UINT_MAX */
- TEST_ASSERT( mbedtls_pk_sign( &alt, MBEDTLS_MD_NONE, hash, sizeof hash, sig,
- &sig_len, mbedtls_test_rnd_std_rand, NULL )
- == 0 );
- TEST_ASSERT( sig_len == RSA_KEY_LEN );
- TEST_ASSERT( mbedtls_pk_verify( &rsa, MBEDTLS_MD_NONE,
- hash, sizeof hash, sig, sig_len ) == 0 );
+ TEST_ASSERT(mbedtls_pk_sign(&alt, MBEDTLS_MD_NONE, hash, sizeof hash, sig,
+ &sig_len, mbedtls_test_rnd_std_rand, NULL)
+ == 0);
+ TEST_ASSERT(sig_len == RSA_KEY_LEN);
+ TEST_ASSERT(mbedtls_pk_verify(&rsa, MBEDTLS_MD_NONE,
+ hash, sizeof hash, sig, sig_len) == 0);
/* Test decrypt */
- TEST_ASSERT( mbedtls_pk_encrypt( &rsa, msg, sizeof msg,
- ciph, &ciph_len, sizeof ciph,
- mbedtls_test_rnd_std_rand, NULL ) == 0 );
- TEST_ASSERT( mbedtls_pk_decrypt( &alt, ciph, ciph_len,
- test, &test_len, sizeof test,
- mbedtls_test_rnd_std_rand, NULL ) == 0 );
- TEST_ASSERT( test_len == sizeof msg );
- TEST_ASSERT( memcmp( test, msg, test_len ) == 0 );
+ TEST_ASSERT(mbedtls_pk_encrypt(&rsa, msg, sizeof msg,
+ ciph, &ciph_len, sizeof ciph,
+ mbedtls_test_rnd_std_rand, NULL) == 0);
+ TEST_ASSERT(mbedtls_pk_decrypt(&alt, ciph, ciph_len,
+ test, &test_len, sizeof test,
+ mbedtls_test_rnd_std_rand, NULL) == 0);
+ TEST_ASSERT(test_len == sizeof msg);
+ TEST_ASSERT(memcmp(test, msg, test_len) == 0);
/* Test forbidden operations */
- TEST_ASSERT( mbedtls_pk_encrypt( &alt, msg, sizeof msg,
- ciph, &ciph_len, sizeof ciph,
- mbedtls_test_rnd_std_rand, NULL ) == ret );
- TEST_ASSERT( mbedtls_pk_verify( &alt, MBEDTLS_MD_NONE,
- hash, sizeof hash, sig, sig_len ) == ret );
- TEST_ASSERT( mbedtls_pk_debug( &alt, dbg_items ) == ret );
+ TEST_ASSERT(mbedtls_pk_encrypt(&alt, msg, sizeof msg,
+ ciph, &ciph_len, sizeof ciph,
+ mbedtls_test_rnd_std_rand, NULL) == ret);
+ TEST_ASSERT(mbedtls_pk_verify(&alt, MBEDTLS_MD_NONE,
+ hash, sizeof hash, sig, sig_len) == ret);
+ TEST_ASSERT(mbedtls_pk_debug(&alt, dbg_items) == ret);
exit:
- mbedtls_rsa_free( &raw );
- mbedtls_pk_free( &rsa ); mbedtls_pk_free( &alt );
+ mbedtls_rsa_free(&raw);
+ mbedtls_pk_free(&rsa); mbedtls_pk_free(&alt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C:MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_ECDSA_C */
-void pk_psa_sign( int grpid_arg,
- int psa_curve_arg, int expected_bits_arg )
+void pk_psa_sign(int grpid_arg,
+ int psa_curve_arg, int expected_bits_arg)
{
mbedtls_ecp_group_id grpid = grpid_arg;
mbedtls_pk_context pk;
@@ -1220,7 +1218,7 @@
int ret;
mbedtls_svc_key_id_t key_id;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- psa_key_type_t expected_type = PSA_KEY_TYPE_ECC_KEY_PAIR( psa_curve_arg );
+ psa_key_type_t expected_type = PSA_KEY_TYPE_ECC_KEY_PAIR(psa_curve_arg);
size_t expected_bits = expected_bits_arg;
/*
@@ -1231,69 +1229,69 @@
* - parse it to a PK context and verify the signature this way
*/
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* Create legacy EC public/private key in PK context. */
- mbedtls_pk_init( &pk );
- TEST_ASSERT( mbedtls_pk_setup( &pk,
- mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == 0 );
- TEST_ASSERT( mbedtls_ecp_gen_key( grpid,
- (mbedtls_ecp_keypair*) pk.pk_ctx,
- mbedtls_test_rnd_std_rand, NULL ) == 0 );
+ mbedtls_pk_init(&pk);
+ TEST_ASSERT(mbedtls_pk_setup(&pk,
+ mbedtls_pk_info_from_type(MBEDTLS_PK_ECKEY)) == 0);
+ TEST_ASSERT(mbedtls_ecp_gen_key(grpid,
+ (mbedtls_ecp_keypair *) pk.pk_ctx,
+ mbedtls_test_rnd_std_rand, NULL) == 0);
/* Export underlying public key for re-importing in a legacy context. */
- ret = mbedtls_pk_write_pubkey_der( &pk, pkey_legacy,
- sizeof( pkey_legacy ) );
- TEST_ASSERT( ret >= 0 );
+ ret = mbedtls_pk_write_pubkey_der(&pk, pkey_legacy,
+ sizeof(pkey_legacy));
+ TEST_ASSERT(ret >= 0);
klen_legacy = (size_t) ret;
/* mbedtls_pk_write_pubkey_der() writes backwards in the data buffer. */
- pkey_legacy_start = pkey_legacy + sizeof( pkey_legacy ) - klen_legacy;
+ pkey_legacy_start = pkey_legacy + sizeof(pkey_legacy) - klen_legacy;
/* Turn PK context into an opaque one. */
- TEST_ASSERT( mbedtls_pk_wrap_as_opaque( &pk, &key_id,
- PSA_ALG_SHA_256 ) == 0 );
+ TEST_ASSERT(mbedtls_pk_wrap_as_opaque(&pk, &key_id,
+ PSA_ALG_SHA_256) == 0);
- PSA_ASSERT( psa_get_key_attributes( key_id, &attributes ) );
- TEST_EQUAL( psa_get_key_type( &attributes ), expected_type );
- TEST_EQUAL( psa_get_key_bits( &attributes ), expected_bits );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ),
- PSA_KEY_LIFETIME_VOLATILE );
+ PSA_ASSERT(psa_get_key_attributes(key_id, &attributes));
+ TEST_EQUAL(psa_get_key_type(&attributes), expected_type);
+ TEST_EQUAL(psa_get_key_bits(&attributes), expected_bits);
+ TEST_EQUAL(psa_get_key_lifetime(&attributes),
+ PSA_KEY_LIFETIME_VOLATILE);
- memset( hash, 0x2a, sizeof hash );
- memset( sig, 0, sizeof sig );
+ memset(hash, 0x2a, sizeof hash);
+ memset(sig, 0, sizeof sig);
- TEST_ASSERT( mbedtls_pk_sign( &pk, MBEDTLS_MD_SHA256,
- hash, sizeof hash, sig, &sig_len,
- NULL, NULL ) == 0 );
+ TEST_ASSERT(mbedtls_pk_sign(&pk, MBEDTLS_MD_SHA256,
+ hash, sizeof hash, sig, &sig_len,
+ NULL, NULL) == 0);
/* Export underlying public key for re-importing in a psa context. */
- ret = mbedtls_pk_write_pubkey_der( &pk, pkey_psa,
- sizeof( pkey_psa ) );
- TEST_ASSERT( ret >= 0 );
+ ret = mbedtls_pk_write_pubkey_der(&pk, pkey_psa,
+ sizeof(pkey_psa));
+ TEST_ASSERT(ret >= 0);
klen_psa = (size_t) ret;
/* mbedtls_pk_write_pubkey_der() writes backwards in the data buffer. */
- pkey_psa_start = pkey_psa + sizeof( pkey_psa ) - klen_psa;
+ pkey_psa_start = pkey_psa + sizeof(pkey_psa) - klen_psa;
- TEST_ASSERT( klen_psa == klen_legacy );
- TEST_ASSERT( memcmp( pkey_psa_start, pkey_legacy_start, klen_psa ) == 0 );
+ TEST_ASSERT(klen_psa == klen_legacy);
+ TEST_ASSERT(memcmp(pkey_psa_start, pkey_legacy_start, klen_psa) == 0);
- mbedtls_pk_free( &pk );
- TEST_ASSERT( PSA_SUCCESS == psa_destroy_key( key_id ) );
+ mbedtls_pk_free(&pk);
+ TEST_ASSERT(PSA_SUCCESS == psa_destroy_key(key_id));
- mbedtls_pk_init( &pk );
- TEST_ASSERT( mbedtls_pk_parse_public_key( &pk, pkey_legacy_start,
- klen_legacy ) == 0 );
- TEST_ASSERT( mbedtls_pk_verify( &pk, MBEDTLS_MD_SHA256,
- hash, sizeof hash, sig, sig_len ) == 0 );
+ mbedtls_pk_init(&pk);
+ TEST_ASSERT(mbedtls_pk_parse_public_key(&pk, pkey_legacy_start,
+ klen_legacy) == 0);
+ TEST_ASSERT(mbedtls_pk_verify(&pk, MBEDTLS_MD_SHA256,
+ hash, sizeof hash, sig, sig_len) == 0);
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- mbedtls_pk_free( &pk );
- USE_PSA_DONE( );
+ mbedtls_pk_free(&pk);
+ USE_PSA_DONE();
}
/* END_CASE */
diff --git a/tests/suites/test_suite_pkcs12.function b/tests/suites/test_suite_pkcs12.function
index 385f86a..17d2ed7 100644
--- a/tests/suites/test_suite_pkcs12.function
+++ b/tests/suites/test_suite_pkcs12.function
@@ -2,10 +2,9 @@
#include "mbedtls/pkcs12.h"
#include "mbedtls/error.h"
-typedef enum
-{
- USE_NULL_INPUT = 0,
- USE_GIVEN_INPUT = 1,
+typedef enum {
+ USE_NULL_INPUT = 0,
+ USE_GIVEN_INPUT = 1,
} input_usage_method_t;
/* END_HEADER */
@@ -16,34 +15,36 @@
*/
/* BEGIN_CASE */
-void pkcs12_derive_key( int md_type, int key_size_arg,
- data_t *password_arg, int password_usage,
- data_t *salt_arg, int salt_usage,
- int iterations,
- data_t* expected_output, int expected_status )
+void pkcs12_derive_key(int md_type, int key_size_arg,
+ data_t *password_arg, int password_usage,
+ data_t *salt_arg, int salt_usage,
+ int iterations,
+ data_t *expected_output, int expected_status)
{
- unsigned char *output_data = NULL;
+ unsigned char *output_data = NULL;
- unsigned char *password = NULL;
- size_t password_len = 0;
- unsigned char *salt = NULL;
- size_t salt_len = 0;
- size_t key_size = key_size_arg;
+ unsigned char *password = NULL;
+ size_t password_len = 0;
+ unsigned char *salt = NULL;
+ size_t salt_len = 0;
+ size_t key_size = key_size_arg;
- if( password_usage == USE_GIVEN_INPUT )
- password = password_arg->x;
+ if (password_usage == USE_GIVEN_INPUT) {
+ password = password_arg->x;
+ }
- password_len = password_arg->len;
+ password_len = password_arg->len;
- if( salt_usage == USE_GIVEN_INPUT )
- salt = salt_arg->x;
+ if (salt_usage == USE_GIVEN_INPUT) {
+ salt = salt_arg->x;
+ }
- salt_len = salt_arg->len;
+ salt_len = salt_arg->len;
- ASSERT_ALLOC( output_data, key_size );
+ ASSERT_ALLOC(output_data, key_size);
- int ret = mbedtls_pkcs12_derivation( output_data,
+ int ret = mbedtls_pkcs12_derivation(output_data,
key_size,
password,
password_len,
@@ -51,18 +52,17 @@
salt_len,
md_type,
MBEDTLS_PKCS12_DERIVE_KEY,
- iterations );
+ iterations);
- TEST_EQUAL( ret, expected_status );
+ TEST_EQUAL(ret, expected_status);
- if( expected_status == 0 )
- {
- ASSERT_COMPARE( expected_output->x, expected_output->len,
- output_data, key_size );
- }
+ if (expected_status == 0) {
+ ASSERT_COMPARE(expected_output->x, expected_output->len,
+ output_data, key_size);
+ }
exit:
- mbedtls_free( output_data );
+ mbedtls_free(output_data);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_pkcs1_v15.function b/tests/suites/test_suite_pkcs1_v15.function
index 9fc4faa..83fc73a 100644
--- a/tests/suites/test_suite_pkcs1_v15.function
+++ b/tests/suites/test_suite_pkcs1_v15.function
@@ -9,10 +9,10 @@
*/
/* BEGIN_CASE */
-void pkcs1_rsaes_v15_encrypt( int mod, char * input_N,
- char * input_E, int hash,
- data_t * message_str, data_t * rnd_buf,
- data_t * result_str, int result )
+void pkcs1_rsaes_v15_encrypt(int mod, char *input_N,
+ char *input_E, int hash,
+ data_t *message_str, data_t *rnd_buf,
+ data_t *result_str, int result)
{
unsigned char output[128];
mbedtls_rsa_context ctx;
@@ -24,41 +24,41 @@
info.buf = rnd_buf->x;
info.length = rnd_buf->len;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
- mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, hash );
- memset( output, 0x00, sizeof( output ) );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
+ mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V15, hash);
+ memset(output, 0x00, sizeof(output));
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
- TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) ((mod + 7) / 8));
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
- if( message_str->len == 0 )
+ if (message_str->len == 0) {
message_str->x = NULL;
- TEST_ASSERT( mbedtls_rsa_pkcs1_encrypt( &ctx,
- &mbedtls_test_rnd_buffer_rand,
- &info, MBEDTLS_RSA_PUBLIC,
- message_str->len, message_str->x,
- output ) == result );
+ }
+ TEST_ASSERT(mbedtls_rsa_pkcs1_encrypt(&ctx,
+ &mbedtls_test_rnd_buffer_rand,
+ &info, MBEDTLS_RSA_PUBLIC,
+ message_str->len, message_str->x,
+ output) == result);
- if( result == 0 )
- {
- TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
- ctx.len, result_str->len ) == 0 );
+ if (result == 0) {
+ TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
+ ctx.len, result_str->len) == 0);
}
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void pkcs1_rsaes_v15_decrypt( int mod, char * input_P, char * input_Q,
- char * input_N, char * input_E, int hash,
- data_t * result_str, char * seed,
- data_t * message_str, int result )
+void pkcs1_rsaes_v15_decrypt(int mod, char *input_P, char *input_Q,
+ char *input_N, char *input_E, int hash,
+ data_t *result_str, char *seed,
+ data_t *message_str, int result)
{
unsigned char output[128];
mbedtls_rsa_context ctx;
@@ -67,60 +67,56 @@
mbedtls_mpi N, P, Q, E;
((void) seed);
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
- mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
- mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, hash );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
+ mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
+ mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V15, hash);
- memset( output, 0x00, sizeof( output ) );
- memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ memset(output, 0x00, sizeof(output));
+ memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
- TEST_ASSERT( mbedtls_test_read_mpi( &P, input_P ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Q, input_Q ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
- TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
- TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, &P, &Q, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) ((mod + 7) / 8));
+ TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
+ TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == 0);
- if( result_str->len == 0 )
- {
- TEST_ASSERT( mbedtls_rsa_pkcs1_decrypt( &ctx,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info,
- MBEDTLS_RSA_PRIVATE,
- &output_len, message_str->x,
- NULL, 0 ) == result );
- }
- else
- {
- TEST_ASSERT( mbedtls_rsa_pkcs1_decrypt( &ctx,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info, MBEDTLS_RSA_PRIVATE,
- &output_len, message_str->x,
- output, 1000 ) == result );
- if( result == 0 )
- {
- TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
- output_len,
- result_str->len) == 0 );
+ if (result_str->len == 0) {
+ TEST_ASSERT(mbedtls_rsa_pkcs1_decrypt(&ctx,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info,
+ MBEDTLS_RSA_PRIVATE,
+ &output_len, message_str->x,
+ NULL, 0) == result);
+ } else {
+ TEST_ASSERT(mbedtls_rsa_pkcs1_decrypt(&ctx,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info, MBEDTLS_RSA_PRIVATE,
+ &output_len, message_str->x,
+ output, 1000) == result);
+ if (result == 0) {
+ TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
+ output_len,
+ result_str->len) == 0);
}
}
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
- mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
+ mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void pkcs1_v15_decode( int mode,
- data_t *input,
- int expected_plaintext_length_arg,
- int output_size_arg,
- int expected_result )
+void pkcs1_v15_decode(int mode,
+ data_t *input,
+ int expected_plaintext_length_arg,
+ int output_size_arg,
+ int expected_result)
{
size_t expected_plaintext_length = expected_plaintext_length_arg;
size_t output_size = output_size_arg;
@@ -190,48 +186,46 @@
unsigned char final[128];
size_t output_length = 0x7EA0;
- memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
- mbedtls_mpi_init( &Nmpi ); mbedtls_mpi_init( &Empi );
- mbedtls_mpi_init( &Pmpi ); mbedtls_mpi_init( &Qmpi );
- mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, 0 );
+ memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
+ mbedtls_mpi_init(&Nmpi); mbedtls_mpi_init(&Empi);
+ mbedtls_mpi_init(&Pmpi); mbedtls_mpi_init(&Qmpi);
+ mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V15, 0);
- TEST_ASSERT( mbedtls_mpi_read_binary( &Nmpi, N, sizeof( N ) ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &Empi, E, sizeof( E ) ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &Pmpi, P, sizeof( P ) ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &Qmpi, Q, sizeof( Q ) ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_read_binary(&Nmpi, N, sizeof(N)) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&Empi, E, sizeof(E)) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&Pmpi, P, sizeof(P)) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&Qmpi, Q, sizeof(Q)) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &Nmpi, &Pmpi, &Qmpi,
- NULL, &Empi ) == 0 );
- TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &Nmpi, &Pmpi, &Qmpi,
+ NULL, &Empi) == 0);
+ TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
- TEST_ASSERT( input->len <= sizeof( N ) );
- memcpy( original, input->x, input->len );
- memset( original + input->len, 'd', sizeof( original ) - input->len );
- if( mode == MBEDTLS_RSA_PRIVATE )
- TEST_ASSERT( mbedtls_rsa_public( &ctx, original, intermediate ) == 0 );
- else
- TEST_ASSERT( mbedtls_rsa_private( &ctx, &mbedtls_test_rnd_pseudo_rand,
- &rnd_info, original,
- intermediate ) == 0 );
-
- memcpy( final, default_content, sizeof( final ) );
- TEST_ASSERT( mbedtls_rsa_pkcs1_decrypt( &ctx,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info, mode, &output_length,
- intermediate, final,
- output_size ) == expected_result );
- if( expected_result == 0 )
- {
- TEST_ASSERT( output_length == expected_plaintext_length );
- TEST_ASSERT( memcmp( original + sizeof( N ) - output_length,
- final,
- output_length ) == 0 );
+ TEST_ASSERT(input->len <= sizeof(N));
+ memcpy(original, input->x, input->len);
+ memset(original + input->len, 'd', sizeof(original) - input->len);
+ if (mode == MBEDTLS_RSA_PRIVATE) {
+ TEST_ASSERT(mbedtls_rsa_public(&ctx, original, intermediate) == 0);
+ } else {
+ TEST_ASSERT(mbedtls_rsa_private(&ctx, &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info, original,
+ intermediate) == 0);
}
- else if( expected_result == MBEDTLS_ERR_RSA_INVALID_PADDING ||
- expected_result == MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE )
- {
+
+ memcpy(final, default_content, sizeof(final));
+ TEST_ASSERT(mbedtls_rsa_pkcs1_decrypt(&ctx,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info, mode, &output_length,
+ intermediate, final,
+ output_size) == expected_result);
+ if (expected_result == 0) {
+ TEST_ASSERT(output_length == expected_plaintext_length);
+ TEST_ASSERT(memcmp(original + sizeof(N) - output_length,
+ final,
+ output_length) == 0);
+ } else if (expected_result == MBEDTLS_ERR_RSA_INVALID_PADDING ||
+ expected_result == MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE) {
size_t max_payload_length =
- output_size > sizeof( N ) - 11 ? sizeof( N ) - 11 : output_size;
+ output_size > sizeof(N) - 11 ? sizeof(N) - 11 : output_size;
size_t i;
size_t count = 0;
@@ -240,34 +234,36 @@
* implementation currently does. Alternative implementations
* may produce different output, so we only perform these precise
* checks when using the default implementation. */
- TEST_ASSERT( output_length == max_payload_length );
- for( i = 0; i < max_payload_length; i++ )
- TEST_ASSERT( final[i] == 0 );
+ TEST_ASSERT(output_length == max_payload_length);
+ for (i = 0; i < max_payload_length; i++) {
+ TEST_ASSERT(final[i] == 0);
+ }
#endif
/* Even in alternative implementations, the outputs must have
* changed, otherwise it indicates at least a timing vulnerability
* because no write to the outputs is performed in the bad case. */
- TEST_ASSERT( output_length != 0x7EA0 );
- for( i = 0; i < max_payload_length; i++ )
- count += ( final[i] == default_content[i] );
+ TEST_ASSERT(output_length != 0x7EA0);
+ for (i = 0; i < max_payload_length; i++) {
+ count += (final[i] == default_content[i]);
+ }
/* If more than 16 bytes are unchanged in final, that's evidence
* that final wasn't overwritten. */
- TEST_ASSERT( count < 16 );
+ TEST_ASSERT(count < 16);
}
exit:
- mbedtls_mpi_free( &Nmpi ); mbedtls_mpi_free( &Empi );
- mbedtls_mpi_free( &Pmpi ); mbedtls_mpi_free( &Qmpi );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&Nmpi); mbedtls_mpi_free(&Empi);
+ mbedtls_mpi_free(&Pmpi); mbedtls_mpi_free(&Qmpi);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void pkcs1_rsassa_v15_sign( int mod, char * input_P,
- char * input_Q, char * input_N,
- char * input_E, int digest, int hash,
- data_t * message_str, data_t * rnd_buf,
- data_t * result_str, int result )
+void pkcs1_rsassa_v15_sign(int mod, char *input_P,
+ char *input_Q, char *input_N,
+ char *input_E, int digest, int hash,
+ data_t *message_str, data_t *rnd_buf,
+ data_t *result_str, int result)
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
unsigned char output[128];
@@ -280,72 +276,76 @@
info.buf = rnd_buf->x;
info.length = rnd_buf->len;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
- mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
- mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, hash );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
+ mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
+ mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V15, hash);
- memset( hash_result, 0x00, sizeof( hash_result ) );
- memset( output, 0x00, sizeof( output ) );
+ memset(hash_result, 0x00, sizeof(hash_result));
+ memset(output, 0x00, sizeof(output));
- TEST_ASSERT( mbedtls_test_read_mpi( &P, input_P ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Q, input_Q ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
- TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
- TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, &P, &Q, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) ((mod + 7) / 8));
+ TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
+ TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == 0);
- if( mbedtls_md_info_from_type( digest ) != NULL )
- TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
+ if (mbedtls_md_info_from_type(digest) != NULL) {
+ TEST_ASSERT(mbedtls_md(mbedtls_md_info_from_type(digest), message_str->x, message_str->len,
+ hash_result) == 0);
+ }
- TEST_ASSERT( mbedtls_rsa_pkcs1_sign( &ctx, &mbedtls_test_rnd_buffer_rand,
- &info, MBEDTLS_RSA_PRIVATE, digest,
- 0, hash_result, output ) == result );
- if( result == 0 )
- {
+ TEST_ASSERT(mbedtls_rsa_pkcs1_sign(&ctx, &mbedtls_test_rnd_buffer_rand,
+ &info, MBEDTLS_RSA_PRIVATE, digest,
+ 0, hash_result, output) == result);
+ if (result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
- ctx.len, result_str->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
+ ctx.len, result_str->len) == 0);
}
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
- mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
+ mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void pkcs1_rsassa_v15_verify( int mod, char * input_N, char * input_E,
- int digest, int hash, data_t * message_str,
- char * salt, data_t * result_str, int result )
+void pkcs1_rsassa_v15_verify(int mod, char *input_N, char *input_E,
+ int digest, int hash, data_t *message_str,
+ char *salt, data_t *result_str, int result)
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
mbedtls_rsa_context ctx;
mbedtls_mpi N, E;
((void) salt);
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
- mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, hash );
- memset( hash_result, 0x00, sizeof( hash_result ) );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
+ mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V15, hash);
+ memset(hash_result, 0x00, sizeof(hash_result));
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
- TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) ((mod + 7) / 8));
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
- if( mbedtls_md_info_from_type( digest ) != NULL )
- TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
+ if (mbedtls_md_info_from_type(digest) != NULL) {
+ TEST_ASSERT(mbedtls_md(mbedtls_md_info_from_type(digest), message_str->x, message_str->len,
+ hash_result) == 0);
+ }
- TEST_ASSERT( mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC, digest, 0, hash_result, result_str->x ) == result );
+ TEST_ASSERT(mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC, digest, 0,
+ hash_result, result_str->x) == result);
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_pkcs1_v21.function b/tests/suites/test_suite_pkcs1_v21.function
index c23a4ad..bf99df6 100644
--- a/tests/suites/test_suite_pkcs1_v21.function
+++ b/tests/suites/test_suite_pkcs1_v21.function
@@ -9,9 +9,9 @@
*/
/* BEGIN_CASE */
-void pkcs1_rsaes_oaep_encrypt( int mod, data_t * input_N, data_t * input_E,
- int hash, data_t * message_str, data_t * rnd_buf,
- data_t * result_str, int result )
+void pkcs1_rsaes_oaep_encrypt(int mod, data_t *input_N, data_t *input_E,
+ int hash, data_t *message_str, data_t *rnd_buf,
+ data_t *result_str, int result)
{
unsigned char output[256];
mbedtls_rsa_context ctx;
@@ -23,39 +23,39 @@
info.buf = rnd_buf->x;
info.length = rnd_buf->len;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
- mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V21, hash );
- memset( output, 0x00, sizeof( output ) );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
+ mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V21, hash);
+ memset(output, 0x00, sizeof(output));
- TEST_ASSERT( mbedtls_mpi_read_binary( &N, input_N->x, input_N->len ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &E, input_E->x, input_E->len ) == 0 );
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
- TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_read_binary(&N, input_N->x, input_N->len) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&E, input_E->x, input_E->len) == 0);
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) ((mod + 7) / 8));
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
- if( message_str->len == 0 )
+ if (message_str->len == 0) {
message_str->x = NULL;
- TEST_ASSERT( mbedtls_rsa_pkcs1_encrypt( &ctx,
- &mbedtls_test_rnd_buffer_rand,
- &info, MBEDTLS_RSA_PUBLIC,
- message_str->len, message_str->x,
- output ) == result );
- if( result == 0 )
- {
- ASSERT_COMPARE( output, ctx.len, result_str->x, result_str->len );
+ }
+ TEST_ASSERT(mbedtls_rsa_pkcs1_encrypt(&ctx,
+ &mbedtls_test_rnd_buffer_rand,
+ &info, MBEDTLS_RSA_PUBLIC,
+ message_str->len, message_str->x,
+ output) == result);
+ if (result == 0) {
+ ASSERT_COMPARE(output, ctx.len, result_str->x, result_str->len);
}
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void pkcs1_rsaes_oaep_decrypt( int mod, data_t * input_P, data_t * input_Q,
- data_t * input_N, data_t * input_E, int hash,
- data_t * result_str, char * seed, data_t * message_str,
- int result )
+void pkcs1_rsaes_oaep_decrypt(int mod, data_t *input_P, data_t *input_Q,
+ data_t *input_N, data_t *input_E, int hash,
+ data_t *result_str, char *seed, data_t *message_str,
+ int result)
{
unsigned char output[64];
mbedtls_rsa_context ctx;
@@ -64,61 +64,57 @@
mbedtls_mpi N, P, Q, E;
((void) seed);
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
- mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
+ mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
- mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V21, hash );
+ mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V21, hash);
- memset( output, 0x00, sizeof( output ) );
- memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ memset(output, 0x00, sizeof(output));
+ memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
- TEST_ASSERT( mbedtls_mpi_read_binary( &P, input_P->x, input_P->len ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &Q, input_Q->x, input_Q->len ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &N, input_N->x, input_N->len ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &E, input_E->x, input_E->len ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_read_binary(&P, input_P->x, input_P->len) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&Q, input_Q->x, input_Q->len) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&N, input_N->x, input_N->len) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&E, input_E->x, input_E->len) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
- TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
- TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, &P, &Q, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) ((mod + 7) / 8));
+ TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
+ TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == 0);
- if( result_str->len == 0 )
- {
- TEST_ASSERT( mbedtls_rsa_pkcs1_decrypt( &ctx,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info,
- MBEDTLS_RSA_PRIVATE,
- &output_len, message_str->x,
- NULL, 0 ) == result );
- }
- else
- {
- TEST_ASSERT( mbedtls_rsa_pkcs1_decrypt( &ctx,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info,
- MBEDTLS_RSA_PRIVATE,
- &output_len, message_str->x,
- output,
- sizeof( output ) ) == result );
- if( result == 0 )
- {
- ASSERT_COMPARE( output, output_len, result_str->x, result_str->len );
+ if (result_str->len == 0) {
+ TEST_ASSERT(mbedtls_rsa_pkcs1_decrypt(&ctx,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info,
+ MBEDTLS_RSA_PRIVATE,
+ &output_len, message_str->x,
+ NULL, 0) == result);
+ } else {
+ TEST_ASSERT(mbedtls_rsa_pkcs1_decrypt(&ctx,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info,
+ MBEDTLS_RSA_PRIVATE,
+ &output_len, message_str->x,
+ output,
+ sizeof(output)) == result);
+ if (result == 0) {
+ ASSERT_COMPARE(output, output_len, result_str->x, result_str->len);
}
}
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
- mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
+ mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void pkcs1_rsassa_pss_sign( int mod, data_t * input_P, data_t * input_Q,
- data_t * input_N, data_t * input_E, int digest,
- int hash, data_t * message_str, data_t * rnd_buf,
- data_t * result_str, int fixed_salt_length,
- int result )
+void pkcs1_rsassa_pss_sign(int mod, data_t *input_P, data_t *input_Q,
+ data_t *input_N, data_t *input_E, int digest,
+ int hash, data_t *message_str, data_t *rnd_buf,
+ data_t *result_str, int fixed_salt_length,
+ int result)
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
unsigned char output[512];
@@ -131,136 +127,135 @@
info.buf = rnd_buf->x;
info.length = rnd_buf->len;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
- mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
- mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V21, hash );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
+ mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
+ mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V21, hash);
- memset( hash_result, 0x00, sizeof( hash_result ) );
- memset( output, 0x00, sizeof( output ) );
+ memset(hash_result, 0x00, sizeof(hash_result));
+ memset(output, 0x00, sizeof(output));
- TEST_ASSERT( mbedtls_mpi_read_binary( &P, input_P->x, input_P->len ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &Q, input_Q->x, input_Q->len ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &N, input_N->x, input_N->len ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &E, input_E->x, input_E->len ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_read_binary(&P, input_P->x, input_P->len) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&Q, input_Q->x, input_Q->len) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&N, input_N->x, input_N->len) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&E, input_E->x, input_E->len) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
- TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
- TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, &P, &Q, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) ((mod + 7) / 8));
+ TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
+ TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == 0);
- if( mbedtls_md_info_from_type( digest ) != NULL )
- TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
+ if (mbedtls_md_info_from_type(digest) != NULL) {
+ TEST_ASSERT(mbedtls_md(mbedtls_md_info_from_type(digest), message_str->x, message_str->len,
+ hash_result) == 0);
+ }
- if (fixed_salt_length == MBEDTLS_RSA_SALT_LEN_ANY)
- {
- TEST_ASSERT( mbedtls_rsa_pkcs1_sign( &ctx, &mbedtls_test_rnd_buffer_rand,
- &info, MBEDTLS_RSA_PRIVATE, digest, 0,
- hash_result, output ) == result );
- if( result == 0 )
- {
- ASSERT_COMPARE( output, ctx.len, result_str->x, result_str->len );
+ if (fixed_salt_length == MBEDTLS_RSA_SALT_LEN_ANY) {
+ TEST_ASSERT(mbedtls_rsa_pkcs1_sign(&ctx, &mbedtls_test_rnd_buffer_rand,
+ &info, MBEDTLS_RSA_PRIVATE, digest, 0,
+ hash_result, output) == result);
+ if (result == 0) {
+ ASSERT_COMPARE(output, ctx.len, result_str->x, result_str->len);
}
info.buf = rnd_buf->x;
info.length = rnd_buf->len;
}
- TEST_ASSERT( mbedtls_rsa_rsassa_pss_sign_ext( &ctx, &mbedtls_test_rnd_buffer_rand,
- &info, digest, 0, hash_result,
- fixed_salt_length, output ) == result );
- if( result == 0 )
- {
- ASSERT_COMPARE( output, ctx.len, result_str->x, result_str->len );
+ TEST_ASSERT(mbedtls_rsa_rsassa_pss_sign_ext(&ctx, &mbedtls_test_rnd_buffer_rand,
+ &info, digest, 0, hash_result,
+ fixed_salt_length, output) == result);
+ if (result == 0) {
+ ASSERT_COMPARE(output, ctx.len, result_str->x, result_str->len);
}
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
- mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
+ mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void pkcs1_rsassa_pss_verify( int mod, data_t * input_N, data_t * input_E,
- int digest, int hash, data_t * message_str,
- char * salt, data_t * result_str, int result )
+void pkcs1_rsassa_pss_verify(int mod, data_t *input_N, data_t *input_E,
+ int digest, int hash, data_t *message_str,
+ char *salt, data_t *result_str, int result)
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
mbedtls_rsa_context ctx;
mbedtls_mpi N, E;
((void) salt);
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
- mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V21, hash );
- memset( hash_result, 0x00, sizeof( hash_result ) );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
+ mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V21, hash);
+ memset(hash_result, 0x00, sizeof(hash_result));
- TEST_ASSERT( mbedtls_mpi_read_binary( &N, input_N->x, input_N->len ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &E, input_E->x, input_E->len ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_read_binary(&N, input_N->x, input_N->len) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&E, input_E->x, input_E->len) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
- TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) ((mod + 7) / 8));
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
- if( mbedtls_md_info_from_type( digest ) != NULL )
- TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
+ if (mbedtls_md_info_from_type(digest) != NULL) {
+ TEST_ASSERT(mbedtls_md(mbedtls_md_info_from_type(digest), message_str->x, message_str->len,
+ hash_result) == 0);
+ }
- TEST_ASSERT( mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC, digest, 0, hash_result, result_str->x ) == result );
+ TEST_ASSERT(mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC, digest, 0,
+ hash_result, result_str->x) == result);
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void pkcs1_rsassa_pss_verify_ext( int mod, data_t * input_N, data_t * input_E,
- int msg_digest_id, int ctx_hash,
- int mgf_hash, int salt_len,
- data_t * message_str,
- data_t * result_str, int result_simple,
- int result_full )
+void pkcs1_rsassa_pss_verify_ext(int mod, data_t *input_N, data_t *input_E,
+ int msg_digest_id, int ctx_hash,
+ int mgf_hash, int salt_len,
+ data_t *message_str,
+ data_t *result_str, int result_simple,
+ int result_full)
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
mbedtls_rsa_context ctx;
size_t hash_len;
mbedtls_mpi N, E;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
- mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V21, ctx_hash );
- memset( hash_result, 0x00, sizeof( hash_result ) );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
+ mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V21, ctx_hash);
+ memset(hash_result, 0x00, sizeof(hash_result));
- TEST_ASSERT( mbedtls_mpi_read_binary( &N, input_N->x, input_N->len ) == 0 );
- TEST_ASSERT( mbedtls_mpi_read_binary( &E, input_E->x, input_E->len ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_read_binary(&N, input_N->x, input_N->len) == 0);
+ TEST_ASSERT(mbedtls_mpi_read_binary(&E, input_E->x, input_E->len) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( ( mod + 7 ) / 8 ) );
- TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) ((mod + 7) / 8));
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
- if( msg_digest_id != MBEDTLS_MD_NONE )
- {
- TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( msg_digest_id ),
- message_str->x, message_str->len, hash_result ) == 0 );
+ if (msg_digest_id != MBEDTLS_MD_NONE) {
+ TEST_ASSERT(mbedtls_md(mbedtls_md_info_from_type(msg_digest_id),
+ message_str->x, message_str->len, hash_result) == 0);
hash_len = 0;
- }
- else
- {
- memcpy( hash_result, message_str->x, message_str->len );
+ } else {
+ memcpy(hash_result, message_str->x, message_str->len);
hash_len = message_str->len;
}
- TEST_ASSERT( mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC,
- msg_digest_id, hash_len, hash_result,
- result_str->x ) == result_simple );
+ TEST_ASSERT(mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC,
+ msg_digest_id, hash_len, hash_result,
+ result_str->x) == result_simple);
- TEST_ASSERT( mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC,
- msg_digest_id, hash_len, hash_result,
- mgf_hash, salt_len,
- result_str->x ) == result_full );
+ TEST_ASSERT(mbedtls_rsa_rsassa_pss_verify_ext(&ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC,
+ msg_digest_id, hash_len, hash_result,
+ mgf_hash, salt_len,
+ result_str->x) == result_full);
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_pkcs5.function b/tests/suites/test_suite_pkcs5.function
index 0b0c937..5d10da4 100644
--- a/tests/suites/test_suite_pkcs5.function
+++ b/tests/suites/test_suite_pkcs5.function
@@ -8,33 +8,33 @@
*/
/* BEGIN_CASE */
-void pbkdf2_hmac( int hash, data_t * pw_str, data_t * salt_str,
- int it_cnt, int key_len, data_t * result_key_string )
+void pbkdf2_hmac(int hash, data_t *pw_str, data_t *salt_str,
+ int it_cnt, int key_len, data_t *result_key_string)
{
mbedtls_md_context_t ctx;
const mbedtls_md_info_t *info;
unsigned char key[100];
- mbedtls_md_init( &ctx );
+ mbedtls_md_init(&ctx);
- info = mbedtls_md_info_from_type( hash );
- TEST_ASSERT( info != NULL );
- TEST_ASSERT( mbedtls_md_setup( &ctx, info, 1 ) == 0 );
- TEST_ASSERT( mbedtls_pkcs5_pbkdf2_hmac( &ctx, pw_str->x, pw_str->len, salt_str->x, salt_str->len,
- it_cnt, key_len, key ) == 0 );
+ info = mbedtls_md_info_from_type(hash);
+ TEST_ASSERT(info != NULL);
+ TEST_ASSERT(mbedtls_md_setup(&ctx, info, 1) == 0);
+ TEST_ASSERT(mbedtls_pkcs5_pbkdf2_hmac(&ctx, pw_str->x, pw_str->len, salt_str->x, salt_str->len,
+ it_cnt, key_len, key) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( key, result_key_string->x,
- key_len, result_key_string->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(key, result_key_string->x,
+ key_len, result_key_string->len) == 0);
exit:
- mbedtls_md_free( &ctx );
+ mbedtls_md_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ASN1_PARSE_C */
-void mbedtls_pkcs5_pbes2( int params_tag, data_t *params_hex, data_t *pw,
- data_t *data, int ref_ret, data_t *ref_out )
+void mbedtls_pkcs5_pbes2(int params_tag, data_t *params_hex, data_t *pw,
+ data_t *data, int ref_ret, data_t *ref_out)
{
int my_ret;
mbedtls_asn1_buf params;
@@ -44,23 +44,24 @@
params.p = params_hex->x;
params.len = params_hex->len;
- my_out = mbedtls_test_zero_alloc( ref_out->len );
+ my_out = mbedtls_test_zero_alloc(ref_out->len);
- my_ret = mbedtls_pkcs5_pbes2( ¶ms, MBEDTLS_PKCS5_DECRYPT,
- pw->x, pw->len, data->x, data->len, my_out );
- TEST_ASSERT( my_ret == ref_ret );
+ my_ret = mbedtls_pkcs5_pbes2(¶ms, MBEDTLS_PKCS5_DECRYPT,
+ pw->x, pw->len, data->x, data->len, my_out);
+ TEST_ASSERT(my_ret == ref_ret);
- if( ref_ret == 0 )
- TEST_ASSERT( memcmp( my_out, ref_out->x, ref_out->len ) == 0 );
+ if (ref_ret == 0) {
+ TEST_ASSERT(memcmp(my_out, ref_out->x, ref_out->len) == 0);
+ }
exit:
- mbedtls_free( my_out );
+ mbedtls_free(my_out);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void pkcs5_selftest( )
+void pkcs5_selftest()
{
- TEST_ASSERT( mbedtls_pkcs5_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_pkcs5_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_pkparse.function b/tests/suites/test_suite_pkparse.function
index 4650d33..f2f5e97 100644
--- a/tests/suites/test_suite_pkparse.function
+++ b/tests/suites/test_suite_pkparse.function
@@ -10,119 +10,116 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_RSA_C:MBEDTLS_FS_IO */
-void pk_parse_keyfile_rsa( char * key_file, char * password, int result )
+void pk_parse_keyfile_rsa(char *key_file, char *password, int result)
{
mbedtls_pk_context ctx;
int res;
char *pwd = password;
- mbedtls_pk_init( &ctx );
+ mbedtls_pk_init(&ctx);
- if( strcmp( pwd, "NULL" ) == 0 )
+ if (strcmp(pwd, "NULL") == 0) {
pwd = NULL;
+ }
- res = mbedtls_pk_parse_keyfile( &ctx, key_file, pwd );
+ res = mbedtls_pk_parse_keyfile(&ctx, key_file, pwd);
- TEST_ASSERT( res == result );
+ TEST_ASSERT(res == result);
- if( res == 0 )
- {
+ if (res == 0) {
mbedtls_rsa_context *rsa;
- TEST_ASSERT( mbedtls_pk_can_do( &ctx, MBEDTLS_PK_RSA ) );
- rsa = mbedtls_pk_rsa( ctx );
- TEST_ASSERT( mbedtls_rsa_check_privkey( rsa ) == 0 );
+ TEST_ASSERT(mbedtls_pk_can_do(&ctx, MBEDTLS_PK_RSA));
+ rsa = mbedtls_pk_rsa(ctx);
+ TEST_ASSERT(mbedtls_rsa_check_privkey(rsa) == 0);
}
exit:
- mbedtls_pk_free( &ctx );
+ mbedtls_pk_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_RSA_C:MBEDTLS_FS_IO */
-void pk_parse_public_keyfile_rsa( char * key_file, int result )
+void pk_parse_public_keyfile_rsa(char *key_file, int result)
{
mbedtls_pk_context ctx;
int res;
- mbedtls_pk_init( &ctx );
+ mbedtls_pk_init(&ctx);
- res = mbedtls_pk_parse_public_keyfile( &ctx, key_file );
+ res = mbedtls_pk_parse_public_keyfile(&ctx, key_file);
- TEST_ASSERT( res == result );
+ TEST_ASSERT(res == result);
- if( res == 0 )
- {
+ if (res == 0) {
mbedtls_rsa_context *rsa;
- TEST_ASSERT( mbedtls_pk_can_do( &ctx, MBEDTLS_PK_RSA ) );
- rsa = mbedtls_pk_rsa( ctx );
- TEST_ASSERT( mbedtls_rsa_check_pubkey( rsa ) == 0 );
+ TEST_ASSERT(mbedtls_pk_can_do(&ctx, MBEDTLS_PK_RSA));
+ rsa = mbedtls_pk_rsa(ctx);
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(rsa) == 0);
}
exit:
- mbedtls_pk_free( &ctx );
+ mbedtls_pk_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_ECP_C */
-void pk_parse_public_keyfile_ec( char * key_file, int result )
+void pk_parse_public_keyfile_ec(char *key_file, int result)
{
mbedtls_pk_context ctx;
int res;
- mbedtls_pk_init( &ctx );
+ mbedtls_pk_init(&ctx);
- res = mbedtls_pk_parse_public_keyfile( &ctx, key_file );
+ res = mbedtls_pk_parse_public_keyfile(&ctx, key_file);
- TEST_ASSERT( res == result );
+ TEST_ASSERT(res == result);
- if( res == 0 )
- {
+ if (res == 0) {
mbedtls_ecp_keypair *eckey;
- TEST_ASSERT( mbedtls_pk_can_do( &ctx, MBEDTLS_PK_ECKEY ) );
- eckey = mbedtls_pk_ec( ctx );
- TEST_ASSERT( mbedtls_ecp_check_pubkey( &eckey->grp, &eckey->Q ) == 0 );
+ TEST_ASSERT(mbedtls_pk_can_do(&ctx, MBEDTLS_PK_ECKEY));
+ eckey = mbedtls_pk_ec(ctx);
+ TEST_ASSERT(mbedtls_ecp_check_pubkey(&eckey->grp, &eckey->Q) == 0);
}
exit:
- mbedtls_pk_free( &ctx );
+ mbedtls_pk_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_ECP_C */
-void pk_parse_keyfile_ec( char * key_file, char * password, int result )
+void pk_parse_keyfile_ec(char *key_file, char *password, int result)
{
mbedtls_pk_context ctx;
int res;
- mbedtls_pk_init( &ctx );
+ mbedtls_pk_init(&ctx);
- res = mbedtls_pk_parse_keyfile( &ctx, key_file, password );
+ res = mbedtls_pk_parse_keyfile(&ctx, key_file, password);
- TEST_ASSERT( res == result );
+ TEST_ASSERT(res == result);
- if( res == 0 )
- {
+ if (res == 0) {
mbedtls_ecp_keypair *eckey;
- TEST_ASSERT( mbedtls_pk_can_do( &ctx, MBEDTLS_PK_ECKEY ) );
- eckey = mbedtls_pk_ec( ctx );
- TEST_ASSERT( mbedtls_ecp_check_privkey( &eckey->grp, &eckey->d ) == 0 );
+ TEST_ASSERT(mbedtls_pk_can_do(&ctx, MBEDTLS_PK_ECKEY));
+ eckey = mbedtls_pk_ec(ctx);
+ TEST_ASSERT(mbedtls_ecp_check_privkey(&eckey->grp, &eckey->d) == 0);
}
exit:
- mbedtls_pk_free( &ctx );
+ mbedtls_pk_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void pk_parse_key( data_t * buf, int result )
+void pk_parse_key(data_t *buf, int result)
{
mbedtls_pk_context pk;
- mbedtls_pk_init( &pk );
+ mbedtls_pk_init(&pk);
- TEST_ASSERT( mbedtls_pk_parse_key( &pk, buf->x, buf->len, NULL, 0 ) == result );
+ TEST_ASSERT(mbedtls_pk_parse_key(&pk, buf->x, buf->len, NULL, 0) == result);
exit:
- mbedtls_pk_free( &pk );
+ mbedtls_pk_free(&pk);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_pkwrite.function b/tests/suites/test_suite_pkwrite.function
index 2bad4ed..a49846b 100644
--- a/tests/suites/test_suite_pkwrite.function
+++ b/tests/suites/test_suite_pkwrite.function
@@ -10,7 +10,7 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_PEM_WRITE_C */
-void pk_write_pubkey_check( char * key_file )
+void pk_write_pubkey_check(char *key_file)
{
mbedtls_pk_context key;
unsigned char buf[5000];
@@ -19,38 +19,37 @@
FILE *f;
size_t ilen, pem_len, buf_index;
- memset( buf, 0, sizeof( buf ) );
- memset( check_buf, 0, sizeof( check_buf ) );
+ memset(buf, 0, sizeof(buf));
+ memset(check_buf, 0, sizeof(check_buf));
- mbedtls_pk_init( &key );
- TEST_ASSERT( mbedtls_pk_parse_public_keyfile( &key, key_file ) == 0 );
+ mbedtls_pk_init(&key);
+ TEST_ASSERT(mbedtls_pk_parse_public_keyfile(&key, key_file) == 0);
- ret = mbedtls_pk_write_pubkey_pem( &key, buf, sizeof( buf ));
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_pk_write_pubkey_pem(&key, buf, sizeof(buf));
+ TEST_ASSERT(ret == 0);
- pem_len = strlen( (char *) buf );
+ pem_len = strlen((char *) buf);
// check that the rest of the buffer remains clear
- for( buf_index = pem_len; buf_index < sizeof( buf ); ++buf_index )
- {
- TEST_ASSERT( buf[buf_index] == 0 );
+ for (buf_index = pem_len; buf_index < sizeof(buf); ++buf_index) {
+ TEST_ASSERT(buf[buf_index] == 0);
}
- f = fopen( key_file, "r" );
- TEST_ASSERT( f != NULL );
- ilen = fread( check_buf, 1, sizeof( check_buf ), f );
- fclose( f );
+ f = fopen(key_file, "r");
+ TEST_ASSERT(f != NULL);
+ ilen = fread(check_buf, 1, sizeof(check_buf), f);
+ fclose(f);
- TEST_ASSERT( ilen == pem_len );
- TEST_ASSERT( memcmp( (char *) buf, (char *) check_buf, ilen ) == 0 );
+ TEST_ASSERT(ilen == pem_len);
+ TEST_ASSERT(memcmp((char *) buf, (char *) check_buf, ilen) == 0);
exit:
- mbedtls_pk_free( &key );
+ mbedtls_pk_free(&key);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PEM_WRITE_C */
-void pk_write_key_check( char * key_file )
+void pk_write_key_check(char *key_file)
{
mbedtls_pk_context key;
unsigned char buf[5000];
@@ -59,32 +58,31 @@
FILE *f;
size_t ilen, pem_len, buf_index;
- memset( buf, 0, sizeof( buf ) );
- memset( check_buf, 0, sizeof( check_buf ) );
+ memset(buf, 0, sizeof(buf));
+ memset(check_buf, 0, sizeof(check_buf));
- mbedtls_pk_init( &key );
- TEST_ASSERT( mbedtls_pk_parse_keyfile( &key, key_file, NULL ) == 0 );
+ mbedtls_pk_init(&key);
+ TEST_ASSERT(mbedtls_pk_parse_keyfile(&key, key_file, NULL) == 0);
- ret = mbedtls_pk_write_key_pem( &key, buf, sizeof( buf ));
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_pk_write_key_pem(&key, buf, sizeof(buf));
+ TEST_ASSERT(ret == 0);
- pem_len = strlen( (char *) buf );
+ pem_len = strlen((char *) buf);
// check that the rest of the buffer remains clear
- for( buf_index = pem_len; buf_index < sizeof( buf ); ++buf_index )
- {
- TEST_ASSERT( buf[buf_index] == 0 );
+ for (buf_index = pem_len; buf_index < sizeof(buf); ++buf_index) {
+ TEST_ASSERT(buf[buf_index] == 0);
}
- f = fopen( key_file, "r" );
- TEST_ASSERT( f != NULL );
- ilen = fread( check_buf, 1, sizeof( check_buf ), f );
- fclose( f );
+ f = fopen(key_file, "r");
+ TEST_ASSERT(f != NULL);
+ ilen = fread(check_buf, 1, sizeof(check_buf), f);
+ fclose(f);
- TEST_ASSERT( ilen == strlen( (char *) buf ) );
- TEST_ASSERT( memcmp( (char *) buf, (char *) check_buf, ilen ) == 0 );
+ TEST_ASSERT(ilen == strlen((char *) buf));
+ TEST_ASSERT(memcmp((char *) buf, (char *) check_buf, ilen) == 0);
exit:
- mbedtls_pk_free( &key );
+ mbedtls_pk_free(&key);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_poly1305.function b/tests/suites/test_suite_poly1305.function
index 4b8995b..1a0e388 100644
--- a/tests/suites/test_suite_poly1305.function
+++ b/tests/suites/test_suite_poly1305.function
@@ -9,35 +9,35 @@
*/
/* BEGIN_CASE */
-void mbedtls_poly1305( data_t *key, data_t *expected_mac, data_t *src_str )
+void mbedtls_poly1305(data_t *key, data_t *expected_mac, data_t *src_str)
{
unsigned char mac[16]; /* size set by the standard */
mbedtls_poly1305_context ctx;
- memset( mac, 0x00, sizeof( mac ) );
+ memset(mac, 0x00, sizeof(mac));
/*
* Test the integrated API
*/
- TEST_ASSERT( mbedtls_poly1305_mac( key->x, src_str->x,
- src_str->len, mac ) == 0 );
+ TEST_ASSERT(mbedtls_poly1305_mac(key->x, src_str->x,
+ src_str->len, mac) == 0);
- ASSERT_COMPARE( mac, expected_mac->len,
- expected_mac->x, expected_mac->len );
+ ASSERT_COMPARE(mac, expected_mac->len,
+ expected_mac->x, expected_mac->len);
/*
* Test the streaming API
*/
- mbedtls_poly1305_init( &ctx );
+ mbedtls_poly1305_init(&ctx);
- TEST_ASSERT( mbedtls_poly1305_starts( &ctx, key->x ) == 0 );
+ TEST_ASSERT(mbedtls_poly1305_starts(&ctx, key->x) == 0);
- TEST_ASSERT( mbedtls_poly1305_update( &ctx, src_str->x, src_str->len ) == 0 );
+ TEST_ASSERT(mbedtls_poly1305_update(&ctx, src_str->x, src_str->len) == 0);
- TEST_ASSERT( mbedtls_poly1305_finish( &ctx, mac ) == 0 );
+ TEST_ASSERT(mbedtls_poly1305_finish(&ctx, mac) == 0);
- ASSERT_COMPARE( mac, expected_mac->len,
- expected_mac->x, expected_mac->len );
+ ASSERT_COMPARE(mac, expected_mac->len,
+ expected_mac->x, expected_mac->len);
/*
* Test the streaming API again, piecewise
@@ -45,37 +45,35 @@
/* Don't free/init the context, in order to test that starts() does the
* right thing. */
- if( src_str->len >= 1 )
- {
- TEST_ASSERT( mbedtls_poly1305_starts( &ctx, key->x ) == 0 );
+ if (src_str->len >= 1) {
+ TEST_ASSERT(mbedtls_poly1305_starts(&ctx, key->x) == 0);
- TEST_ASSERT( mbedtls_poly1305_update( &ctx, src_str->x, 1 ) == 0 );
- TEST_ASSERT( mbedtls_poly1305_update( &ctx, src_str->x + 1, src_str->len - 1 ) == 0 );
+ TEST_ASSERT(mbedtls_poly1305_update(&ctx, src_str->x, 1) == 0);
+ TEST_ASSERT(mbedtls_poly1305_update(&ctx, src_str->x + 1, src_str->len - 1) == 0);
- TEST_ASSERT( mbedtls_poly1305_finish( &ctx, mac ) == 0 );
+ TEST_ASSERT(mbedtls_poly1305_finish(&ctx, mac) == 0);
- ASSERT_COMPARE( mac, expected_mac->len,
- expected_mac->x, expected_mac->len );
+ ASSERT_COMPARE(mac, expected_mac->len,
+ expected_mac->x, expected_mac->len);
}
/*
* Again with more pieces
*/
- if( src_str->len >= 2 )
- {
- TEST_ASSERT( mbedtls_poly1305_starts( &ctx, key->x ) == 0 );
+ if (src_str->len >= 2) {
+ TEST_ASSERT(mbedtls_poly1305_starts(&ctx, key->x) == 0);
- TEST_ASSERT( mbedtls_poly1305_update( &ctx, src_str->x, 1 ) == 0 );
- TEST_ASSERT( mbedtls_poly1305_update( &ctx, src_str->x + 1, 1 ) == 0 );
- TEST_ASSERT( mbedtls_poly1305_update( &ctx, src_str->x + 2, src_str->len - 2 ) == 0 );
+ TEST_ASSERT(mbedtls_poly1305_update(&ctx, src_str->x, 1) == 0);
+ TEST_ASSERT(mbedtls_poly1305_update(&ctx, src_str->x + 1, 1) == 0);
+ TEST_ASSERT(mbedtls_poly1305_update(&ctx, src_str->x + 2, src_str->len - 2) == 0);
- TEST_ASSERT( mbedtls_poly1305_finish( &ctx, mac ) == 0 );
+ TEST_ASSERT(mbedtls_poly1305_finish(&ctx, mac) == 0);
- ASSERT_COMPARE( mac, expected_mac->len,
- expected_mac->x, expected_mac->len );
+ ASSERT_COMPARE(mac, expected_mac->len,
+ expected_mac->x, expected_mac->len);
}
- mbedtls_poly1305_free( &ctx );
+ mbedtls_poly1305_free(&ctx);
}
/* END_CASE */
@@ -85,33 +83,33 @@
unsigned char src[1];
unsigned char key[32];
unsigned char mac[16];
- size_t src_len = sizeof( src );
+ size_t src_len = sizeof(src);
mbedtls_poly1305_context ctx;
- TEST_INVALID_PARAM( mbedtls_poly1305_init( NULL ) );
- TEST_VALID_PARAM( mbedtls_poly1305_free( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_poly1305_init(NULL));
+ TEST_VALID_PARAM(mbedtls_poly1305_free(NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_poly1305_starts( NULL, key ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_poly1305_starts( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_poly1305_starts(NULL, key));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_poly1305_starts(&ctx, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_poly1305_update( NULL, src, 0 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_poly1305_update( &ctx, NULL, src_len ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_poly1305_update(NULL, src, 0));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_poly1305_update(&ctx, NULL, src_len));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_poly1305_finish( NULL, mac ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_poly1305_finish( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_poly1305_finish(NULL, mac));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_poly1305_finish(&ctx, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_poly1305_mac( NULL, src, 0, mac ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_poly1305_mac( key, NULL, src_len, mac ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
- mbedtls_poly1305_mac( key, src, 0, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_poly1305_mac(NULL, src, 0, mac));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_poly1305_mac(key, NULL, src_len, mac));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_POLY1305_BAD_INPUT_DATA,
+ mbedtls_poly1305_mac(key, src, 0, NULL));
exit:
return;
@@ -121,6 +119,6 @@
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
void poly1305_selftest()
{
- TEST_ASSERT( mbedtls_poly1305_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_poly1305_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto.function b/tests/suites/test_suite_psa_crypto.function
index 41183fd..214096c 100644
--- a/tests/suites/test_suite_psa_crypto.function
+++ b/tests/suites/test_suite_psa_crypto.function
@@ -22,8 +22,8 @@
/* Assert that an operation is (not) active.
* This serves as a proxy for checking if the operation is aborted. */
-#define ASSERT_OPERATION_IS_ACTIVE( operation ) TEST_ASSERT( operation.id != 0 )
-#define ASSERT_OPERATION_IS_INACTIVE( operation ) TEST_ASSERT( operation.id == 0 )
+#define ASSERT_OPERATION_IS_ACTIVE(operation) TEST_ASSERT(operation.id != 0)
+#define ASSERT_OPERATION_IS_INACTIVE(operation) TEST_ASSERT(operation.id == 0)
/** An invalid export length that will never be set by psa_export_key(). */
static const size_t INVALID_EXPORT_LENGTH = ~0U;
@@ -39,50 +39,54 @@
* \return 1 if the buffer is all-bits-zero.
* \return 0 if there is at least one nonzero byte.
*/
-static int mem_is_char( void *buffer, unsigned char c, size_t size )
+static int mem_is_char(void *buffer, unsigned char c, size_t size)
{
size_t i;
- for( i = 0; i < size; i++ )
- {
- if( ( (unsigned char *) buffer )[i] != c )
- return( 0 );
+ for (i = 0; i < size; i++) {
+ if (((unsigned char *) buffer)[i] != c) {
+ return 0;
+ }
}
- return( 1 );
+ return 1;
}
#if defined(MBEDTLS_ASN1_WRITE_C)
/* Write the ASN.1 INTEGER with the value 2^(bits-1)+x backwards from *p. */
-static int asn1_write_10x( unsigned char **p,
- unsigned char *start,
- size_t bits,
- unsigned char x )
+static int asn1_write_10x(unsigned char **p,
+ unsigned char *start,
+ size_t bits,
+ unsigned char x)
{
int ret;
int len = bits / 8 + 1;
- if( bits == 0 )
- return( MBEDTLS_ERR_ASN1_INVALID_DATA );
- if( bits <= 8 && x >= 1 << ( bits - 1 ) )
- return( MBEDTLS_ERR_ASN1_INVALID_DATA );
- if( *p < start || *p - start < (ptrdiff_t) len )
- return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
+ if (bits == 0) {
+ return MBEDTLS_ERR_ASN1_INVALID_DATA;
+ }
+ if (bits <= 8 && x >= 1 << (bits - 1)) {
+ return MBEDTLS_ERR_ASN1_INVALID_DATA;
+ }
+ if (*p < start || *p - start < (ptrdiff_t) len) {
+ return MBEDTLS_ERR_ASN1_BUF_TOO_SMALL;
+ }
*p -= len;
- ( *p )[len-1] = x;
- if( bits % 8 == 0 )
- ( *p )[1] |= 1;
- else
- ( *p )[0] |= 1 << ( bits % 8 );
- MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
- MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start,
- MBEDTLS_ASN1_INTEGER ) );
- return( len );
+ (*p)[len-1] = x;
+ if (bits % 8 == 0) {
+ (*p)[1] |= 1;
+ } else {
+ (*p)[0] |= 1 << (bits % 8);
+ }
+ MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(p, start, len));
+ MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(p, start,
+ MBEDTLS_ASN1_INTEGER));
+ return len;
}
-static int construct_fake_rsa_key( unsigned char *buffer,
- size_t buffer_size,
- unsigned char **p,
- size_t bits,
- int keypair )
+static int construct_fake_rsa_key(unsigned char *buffer,
+ size_t buffer_size,
+ unsigned char **p,
+ size_t bits,
+ int keypair)
{
- size_t half_bits = ( bits + 1 ) / 2;
+ size_t half_bits = (bits + 1) / 2;
int ret;
int len = 0;
/* Construct something that looks like a DER encoding of
@@ -103,134 +107,132 @@
* version, modulus and publicExponent.
*/
*p = buffer + buffer_size;
- if( keypair )
- {
- MBEDTLS_ASN1_CHK_ADD( len, /* pq */
- asn1_write_10x( p, buffer, half_bits, 1 ) );
- MBEDTLS_ASN1_CHK_ADD( len, /* dq */
- asn1_write_10x( p, buffer, half_bits, 1 ) );
- MBEDTLS_ASN1_CHK_ADD( len, /* dp */
- asn1_write_10x( p, buffer, half_bits, 1 ) );
- MBEDTLS_ASN1_CHK_ADD( len, /* q */
- asn1_write_10x( p, buffer, half_bits, 1 ) );
- MBEDTLS_ASN1_CHK_ADD( len, /* p != q to pass mbedtls sanity checks */
- asn1_write_10x( p, buffer, half_bits, 3 ) );
- MBEDTLS_ASN1_CHK_ADD( len, /* d */
- asn1_write_10x( p, buffer, bits, 1 ) );
+ if (keypair) {
+ MBEDTLS_ASN1_CHK_ADD(len, /* pq */
+ asn1_write_10x(p, buffer, half_bits, 1));
+ MBEDTLS_ASN1_CHK_ADD(len, /* dq */
+ asn1_write_10x(p, buffer, half_bits, 1));
+ MBEDTLS_ASN1_CHK_ADD(len, /* dp */
+ asn1_write_10x(p, buffer, half_bits, 1));
+ MBEDTLS_ASN1_CHK_ADD(len, /* q */
+ asn1_write_10x(p, buffer, half_bits, 1));
+ MBEDTLS_ASN1_CHK_ADD(len, /* p != q to pass mbedtls sanity checks */
+ asn1_write_10x(p, buffer, half_bits, 3));
+ MBEDTLS_ASN1_CHK_ADD(len, /* d */
+ asn1_write_10x(p, buffer, bits, 1));
}
- MBEDTLS_ASN1_CHK_ADD( len, /* e = 65537 */
- asn1_write_10x( p, buffer, 17, 1 ) );
- MBEDTLS_ASN1_CHK_ADD( len, /* n */
- asn1_write_10x( p, buffer, bits, 1 ) );
- if( keypair )
- MBEDTLS_ASN1_CHK_ADD( len, /* version = 0 */
- mbedtls_asn1_write_int( p, buffer, 0 ) );
- MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, buffer, len ) );
+ MBEDTLS_ASN1_CHK_ADD(len, /* e = 65537 */
+ asn1_write_10x(p, buffer, 17, 1));
+ MBEDTLS_ASN1_CHK_ADD(len, /* n */
+ asn1_write_10x(p, buffer, bits, 1));
+ if (keypair) {
+ MBEDTLS_ASN1_CHK_ADD(len, /* version = 0 */
+ mbedtls_asn1_write_int(p, buffer, 0));
+ }
+ MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(p, buffer, len));
{
const unsigned char tag =
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE;
- MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, buffer, tag ) );
+ MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(p, buffer, tag));
}
- return( len );
+ return len;
}
#endif /* MBEDTLS_ASN1_WRITE_C */
-int exercise_mac_setup( psa_key_type_t key_type,
- const unsigned char *key_bytes,
- size_t key_length,
- psa_algorithm_t alg,
- psa_mac_operation_t *operation,
- psa_status_t *status )
+int exercise_mac_setup(psa_key_type_t key_type,
+ const unsigned char *key_bytes,
+ size_t key_length,
+ psa_algorithm_t alg,
+ psa_mac_operation_t *operation,
+ psa_status_t *status)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
- PSA_ASSERT( psa_import_key( &attributes, key_bytes, key_length, &key ) );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
+ PSA_ASSERT(psa_import_key(&attributes, key_bytes, key_length, &key));
- *status = psa_mac_sign_setup( operation, key, alg );
+ *status = psa_mac_sign_setup(operation, key, alg);
/* Whether setup succeeded or failed, abort must succeed. */
- PSA_ASSERT( psa_mac_abort( operation ) );
+ PSA_ASSERT(psa_mac_abort(operation));
/* If setup failed, reproduce the failure, so that the caller can
* test the resulting state of the operation object. */
- if( *status != PSA_SUCCESS )
- {
- TEST_EQUAL( psa_mac_sign_setup( operation, key, alg ), *status );
+ if (*status != PSA_SUCCESS) {
+ TEST_EQUAL(psa_mac_sign_setup(operation, key, alg), *status);
}
- psa_destroy_key( key );
- return( 1 );
+ psa_destroy_key(key);
+ return 1;
exit:
- psa_destroy_key( key );
- return( 0 );
+ psa_destroy_key(key);
+ return 0;
}
-int exercise_cipher_setup( psa_key_type_t key_type,
- const unsigned char *key_bytes,
- size_t key_length,
- psa_algorithm_t alg,
- psa_cipher_operation_t *operation,
- psa_status_t *status )
+int exercise_cipher_setup(psa_key_type_t key_type,
+ const unsigned char *key_bytes,
+ size_t key_length,
+ psa_algorithm_t alg,
+ psa_cipher_operation_t *operation,
+ psa_status_t *status)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
- PSA_ASSERT( psa_import_key( &attributes, key_bytes, key_length, &key ) );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
+ PSA_ASSERT(psa_import_key(&attributes, key_bytes, key_length, &key));
- *status = psa_cipher_encrypt_setup( operation, key, alg );
+ *status = psa_cipher_encrypt_setup(operation, key, alg);
/* Whether setup succeeded or failed, abort must succeed. */
- PSA_ASSERT( psa_cipher_abort( operation ) );
+ PSA_ASSERT(psa_cipher_abort(operation));
/* If setup failed, reproduce the failure, so that the caller can
* test the resulting state of the operation object. */
- if( *status != PSA_SUCCESS )
- {
- TEST_EQUAL( psa_cipher_encrypt_setup( operation, key, alg ),
- *status );
+ if (*status != PSA_SUCCESS) {
+ TEST_EQUAL(psa_cipher_encrypt_setup(operation, key, alg),
+ *status);
}
- psa_destroy_key( key );
- return( 1 );
+ psa_destroy_key(key);
+ return 1;
exit:
- psa_destroy_key( key );
- return( 0 );
+ psa_destroy_key(key);
+ return 0;
}
-static int test_operations_on_invalid_key( mbedtls_svc_key_id_t key )
+static int test_operations_on_invalid_key(mbedtls_svc_key_id_t key)
{
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make( 1, 0x6964 );
+ mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make(1, 0x6964);
uint8_t buffer[1];
size_t length;
int ok = 0;
- psa_set_key_id( &attributes, key_id );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
- psa_set_key_algorithm( &attributes, PSA_ALG_CTR );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_AES );
- TEST_EQUAL( psa_get_key_attributes( key, &attributes ),
- PSA_ERROR_INVALID_HANDLE );
+ psa_set_key_id(&attributes, key_id);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT);
+ psa_set_key_algorithm(&attributes, PSA_ALG_CTR);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_AES);
+ TEST_EQUAL(psa_get_key_attributes(key, &attributes),
+ PSA_ERROR_INVALID_HANDLE);
TEST_EQUAL(
- MBEDTLS_SVC_KEY_ID_GET_KEY_ID( psa_get_key_id( &attributes ) ), 0 );
+ MBEDTLS_SVC_KEY_ID_GET_KEY_ID(psa_get_key_id(&attributes)), 0);
TEST_EQUAL(
- MBEDTLS_SVC_KEY_ID_GET_OWNER_ID( psa_get_key_id( &attributes ) ), 0 );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_type( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_bits( &attributes ), 0 );
+ MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(psa_get_key_id(&attributes)), 0);
+ TEST_EQUAL(psa_get_key_lifetime(&attributes), 0);
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes), 0);
+ TEST_EQUAL(psa_get_key_algorithm(&attributes), 0);
+ TEST_EQUAL(psa_get_key_type(&attributes), 0);
+ TEST_EQUAL(psa_get_key_bits(&attributes), 0);
- TEST_EQUAL( psa_export_key( key, buffer, sizeof( buffer ), &length ),
- PSA_ERROR_INVALID_HANDLE );
- TEST_EQUAL( psa_export_public_key( key,
- buffer, sizeof( buffer ), &length ),
- PSA_ERROR_INVALID_HANDLE );
+ TEST_EQUAL(psa_export_key(key, buffer, sizeof(buffer), &length),
+ PSA_ERROR_INVALID_HANDLE);
+ TEST_EQUAL(psa_export_public_key(key,
+ buffer, sizeof(buffer), &length),
+ PSA_ERROR_INVALID_HANDLE);
ok = 1;
@@ -239,34 +241,34 @@
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- return( ok );
+ return ok;
}
/* Assert that a key isn't reported as having a slot number. */
#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
-#define ASSERT_NO_SLOT_NUMBER( attributes ) \
+#define ASSERT_NO_SLOT_NUMBER(attributes) \
do \
{ \
psa_key_slot_number_t ASSERT_NO_SLOT_NUMBER_slot_number; \
- TEST_EQUAL( psa_get_key_slot_number( \
- attributes, \
- &ASSERT_NO_SLOT_NUMBER_slot_number ), \
- PSA_ERROR_INVALID_ARGUMENT ); \
+ TEST_EQUAL(psa_get_key_slot_number( \
+ attributes, \
+ &ASSERT_NO_SLOT_NUMBER_slot_number), \
+ PSA_ERROR_INVALID_ARGUMENT); \
} \
- while( 0 )
+ while (0)
#else /* MBEDTLS_PSA_CRYPTO_SE_C */
-#define ASSERT_NO_SLOT_NUMBER( attributes ) \
- ( (void) 0 )
+#define ASSERT_NO_SLOT_NUMBER(attributes) \
+ ((void) 0)
#endif /* MBEDTLS_PSA_CRYPTO_SE_C */
/* An overapproximation of the amount of storage needed for a key of the
* given type and with the given content. The API doesn't make it easy
* to find a good value for the size. The current implementation doesn't
* care about the value anyway. */
-#define KEY_BITS_FROM_DATA( type, data ) \
- ( data )->len
+#define KEY_BITS_FROM_DATA(type, data) \
+ (data)->len
typedef enum {
IMPORT_KEY = 0,
@@ -282,7 +284,7 @@
*/
/* BEGIN_CASE */
-void static_checks( )
+void static_checks()
{
size_t max_truncated_mac_size =
PSA_ALG_MAC_TRUNCATION_MASK >> PSA_MAC_TRUNCATION_OFFSET;
@@ -290,75 +292,75 @@
/* Check that the length for a truncated MAC always fits in the algorithm
* encoding. The shifted mask is the maximum truncated value. The
* untruncated algorithm may be one byte larger. */
- TEST_LE_U( PSA_MAC_MAX_SIZE, 1 + max_truncated_mac_size );
+ TEST_LE_U(PSA_MAC_MAX_SIZE, 1 + max_truncated_mac_size);
#if defined(MBEDTLS_TEST_DEPRECATED)
/* Check deprecated constants. */
- TEST_EQUAL( PSA_ERROR_UNKNOWN_ERROR, PSA_ERROR_GENERIC_ERROR );
- TEST_EQUAL( PSA_ERROR_OCCUPIED_SLOT, PSA_ERROR_ALREADY_EXISTS );
- TEST_EQUAL( PSA_ERROR_EMPTY_SLOT, PSA_ERROR_DOES_NOT_EXIST );
- TEST_EQUAL( PSA_ERROR_INSUFFICIENT_CAPACITY, PSA_ERROR_INSUFFICIENT_DATA );
- TEST_EQUAL( PSA_ERROR_TAMPERING_DETECTED, PSA_ERROR_CORRUPTION_DETECTED );
- TEST_EQUAL( PSA_KEY_USAGE_SIGN, PSA_KEY_USAGE_SIGN_HASH );
- TEST_EQUAL( PSA_KEY_USAGE_VERIFY, PSA_KEY_USAGE_VERIFY_HASH );
- TEST_EQUAL( PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE, PSA_SIGNATURE_MAX_SIZE );
+ TEST_EQUAL(PSA_ERROR_UNKNOWN_ERROR, PSA_ERROR_GENERIC_ERROR);
+ TEST_EQUAL(PSA_ERROR_OCCUPIED_SLOT, PSA_ERROR_ALREADY_EXISTS);
+ TEST_EQUAL(PSA_ERROR_EMPTY_SLOT, PSA_ERROR_DOES_NOT_EXIST);
+ TEST_EQUAL(PSA_ERROR_INSUFFICIENT_CAPACITY, PSA_ERROR_INSUFFICIENT_DATA);
+ TEST_EQUAL(PSA_ERROR_TAMPERING_DETECTED, PSA_ERROR_CORRUPTION_DETECTED);
+ TEST_EQUAL(PSA_KEY_USAGE_SIGN, PSA_KEY_USAGE_SIGN_HASH);
+ TEST_EQUAL(PSA_KEY_USAGE_VERIFY, PSA_KEY_USAGE_VERIFY_HASH);
+ TEST_EQUAL(PSA_ASYMMETRIC_SIGNATURE_MAX_SIZE, PSA_SIGNATURE_MAX_SIZE);
- TEST_EQUAL( PSA_ECC_CURVE_SECP160K1, PSA_ECC_FAMILY_SECP_K1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECP192K1, PSA_ECC_FAMILY_SECP_K1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECP224K1, PSA_ECC_FAMILY_SECP_K1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECP256K1, PSA_ECC_FAMILY_SECP_K1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECP160R1, PSA_ECC_FAMILY_SECP_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECP192R1, PSA_ECC_FAMILY_SECP_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECP224R1, PSA_ECC_FAMILY_SECP_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECP256R1, PSA_ECC_FAMILY_SECP_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECP384R1, PSA_ECC_FAMILY_SECP_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECP521R1, PSA_ECC_FAMILY_SECP_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECP160R2, PSA_ECC_FAMILY_SECP_R2 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT163K1, PSA_ECC_FAMILY_SECT_K1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT233K1, PSA_ECC_FAMILY_SECT_K1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT239K1, PSA_ECC_FAMILY_SECT_K1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT283K1, PSA_ECC_FAMILY_SECT_K1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT409K1, PSA_ECC_FAMILY_SECT_K1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT571K1, PSA_ECC_FAMILY_SECT_K1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT163R1, PSA_ECC_FAMILY_SECT_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT193R1, PSA_ECC_FAMILY_SECT_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT233R1, PSA_ECC_FAMILY_SECT_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT283R1, PSA_ECC_FAMILY_SECT_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT409R1, PSA_ECC_FAMILY_SECT_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT571R1, PSA_ECC_FAMILY_SECT_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT163R2, PSA_ECC_FAMILY_SECT_R2 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT193R2, PSA_ECC_FAMILY_SECT_R2 );
- TEST_EQUAL( PSA_ECC_CURVE_BRAINPOOL_P256R1, PSA_ECC_FAMILY_BRAINPOOL_P_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_BRAINPOOL_P384R1, PSA_ECC_FAMILY_BRAINPOOL_P_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_BRAINPOOL_P512R1, PSA_ECC_FAMILY_BRAINPOOL_P_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_CURVE25519, PSA_ECC_FAMILY_MONTGOMERY );
- TEST_EQUAL( PSA_ECC_CURVE_CURVE448, PSA_ECC_FAMILY_MONTGOMERY );
+ TEST_EQUAL(PSA_ECC_CURVE_SECP160K1, PSA_ECC_FAMILY_SECP_K1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECP192K1, PSA_ECC_FAMILY_SECP_K1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECP224K1, PSA_ECC_FAMILY_SECP_K1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECP256K1, PSA_ECC_FAMILY_SECP_K1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECP160R1, PSA_ECC_FAMILY_SECP_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECP192R1, PSA_ECC_FAMILY_SECP_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECP224R1, PSA_ECC_FAMILY_SECP_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECP256R1, PSA_ECC_FAMILY_SECP_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECP384R1, PSA_ECC_FAMILY_SECP_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECP521R1, PSA_ECC_FAMILY_SECP_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECP160R2, PSA_ECC_FAMILY_SECP_R2);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT163K1, PSA_ECC_FAMILY_SECT_K1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT233K1, PSA_ECC_FAMILY_SECT_K1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT239K1, PSA_ECC_FAMILY_SECT_K1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT283K1, PSA_ECC_FAMILY_SECT_K1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT409K1, PSA_ECC_FAMILY_SECT_K1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT571K1, PSA_ECC_FAMILY_SECT_K1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT163R1, PSA_ECC_FAMILY_SECT_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT193R1, PSA_ECC_FAMILY_SECT_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT233R1, PSA_ECC_FAMILY_SECT_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT283R1, PSA_ECC_FAMILY_SECT_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT409R1, PSA_ECC_FAMILY_SECT_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT571R1, PSA_ECC_FAMILY_SECT_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT163R2, PSA_ECC_FAMILY_SECT_R2);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT193R2, PSA_ECC_FAMILY_SECT_R2);
+ TEST_EQUAL(PSA_ECC_CURVE_BRAINPOOL_P256R1, PSA_ECC_FAMILY_BRAINPOOL_P_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_BRAINPOOL_P384R1, PSA_ECC_FAMILY_BRAINPOOL_P_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_BRAINPOOL_P512R1, PSA_ECC_FAMILY_BRAINPOOL_P_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_CURVE25519, PSA_ECC_FAMILY_MONTGOMERY);
+ TEST_EQUAL(PSA_ECC_CURVE_CURVE448, PSA_ECC_FAMILY_MONTGOMERY);
- TEST_EQUAL( PSA_ECC_CURVE_SECP_K1, PSA_ECC_FAMILY_SECP_K1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECP_R1, PSA_ECC_FAMILY_SECP_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECP_R2, PSA_ECC_FAMILY_SECP_R2 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT_K1, PSA_ECC_FAMILY_SECT_K1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT_R1, PSA_ECC_FAMILY_SECT_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_SECT_R2, PSA_ECC_FAMILY_SECT_R2 );
- TEST_EQUAL( PSA_ECC_CURVE_BRAINPOOL_P_R1, PSA_ECC_FAMILY_BRAINPOOL_P_R1 );
- TEST_EQUAL( PSA_ECC_CURVE_MONTGOMERY, PSA_ECC_FAMILY_MONTGOMERY );
+ TEST_EQUAL(PSA_ECC_CURVE_SECP_K1, PSA_ECC_FAMILY_SECP_K1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECP_R1, PSA_ECC_FAMILY_SECP_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECP_R2, PSA_ECC_FAMILY_SECP_R2);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT_K1, PSA_ECC_FAMILY_SECT_K1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT_R1, PSA_ECC_FAMILY_SECT_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_SECT_R2, PSA_ECC_FAMILY_SECT_R2);
+ TEST_EQUAL(PSA_ECC_CURVE_BRAINPOOL_P_R1, PSA_ECC_FAMILY_BRAINPOOL_P_R1);
+ TEST_EQUAL(PSA_ECC_CURVE_MONTGOMERY, PSA_ECC_FAMILY_MONTGOMERY);
- TEST_EQUAL( PSA_DH_GROUP_FFDHE2048, PSA_DH_FAMILY_RFC7919 );
- TEST_EQUAL( PSA_DH_GROUP_FFDHE3072, PSA_DH_FAMILY_RFC7919 );
- TEST_EQUAL( PSA_DH_GROUP_FFDHE4096, PSA_DH_FAMILY_RFC7919 );
- TEST_EQUAL( PSA_DH_GROUP_FFDHE6144, PSA_DH_FAMILY_RFC7919 );
- TEST_EQUAL( PSA_DH_GROUP_FFDHE8192, PSA_DH_FAMILY_RFC7919 );
+ TEST_EQUAL(PSA_DH_GROUP_FFDHE2048, PSA_DH_FAMILY_RFC7919);
+ TEST_EQUAL(PSA_DH_GROUP_FFDHE3072, PSA_DH_FAMILY_RFC7919);
+ TEST_EQUAL(PSA_DH_GROUP_FFDHE4096, PSA_DH_FAMILY_RFC7919);
+ TEST_EQUAL(PSA_DH_GROUP_FFDHE6144, PSA_DH_FAMILY_RFC7919);
+ TEST_EQUAL(PSA_DH_GROUP_FFDHE8192, PSA_DH_FAMILY_RFC7919);
- TEST_EQUAL( PSA_DH_GROUP_RFC7919, PSA_DH_FAMILY_RFC7919 );
- TEST_EQUAL( PSA_DH_GROUP_CUSTOM, PSA_DH_FAMILY_CUSTOM );
+ TEST_EQUAL(PSA_DH_GROUP_RFC7919, PSA_DH_FAMILY_RFC7919);
+ TEST_EQUAL(PSA_DH_GROUP_CUSTOM, PSA_DH_FAMILY_CUSTOM);
#endif
}
/* END_CASE */
/* BEGIN_CASE */
-void import_with_policy( int type_arg,
- int usage_arg, int alg_arg,
- int expected_status_arg )
+void import_with_policy(int type_arg,
+ int usage_arg, int alg_arg,
+ int expected_status_arg)
{
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -367,48 +369,49 @@
psa_key_usage_t usage = usage_arg;
psa_algorithm_t alg = alg_arg;
psa_status_t expected_status = expected_status_arg;
- const uint8_t key_material[16] = {0};
+ const uint8_t key_material[16] = { 0 };
psa_status_t status;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_type( &attributes, type );
- psa_set_key_usage_flags( &attributes, usage );
- psa_set_key_algorithm( &attributes, alg );
+ psa_set_key_type(&attributes, type);
+ psa_set_key_usage_flags(&attributes, usage);
+ psa_set_key_algorithm(&attributes, alg);
- status = psa_import_key( &attributes,
- key_material, sizeof( key_material ),
- &key );
- TEST_EQUAL( status, expected_status );
- if( status != PSA_SUCCESS )
+ status = psa_import_key(&attributes,
+ key_material, sizeof(key_material),
+ &key);
+ TEST_EQUAL(status, expected_status);
+ if (status != PSA_SUCCESS) {
goto exit;
+ }
- PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
- TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
- TEST_EQUAL( psa_get_key_usage_flags( &got_attributes ),
- mbedtls_test_update_key_usage_flags( usage ) );
- TEST_EQUAL( psa_get_key_algorithm( &got_attributes ), alg );
- ASSERT_NO_SLOT_NUMBER( &got_attributes );
+ PSA_ASSERT(psa_get_key_attributes(key, &got_attributes));
+ TEST_EQUAL(psa_get_key_type(&got_attributes), type);
+ TEST_EQUAL(psa_get_key_usage_flags(&got_attributes),
+ mbedtls_test_update_key_usage_flags(usage));
+ TEST_EQUAL(psa_get_key_algorithm(&got_attributes), alg);
+ ASSERT_NO_SLOT_NUMBER(&got_attributes);
- PSA_ASSERT( psa_destroy_key( key ) );
- test_operations_on_invalid_key( key );
+ PSA_ASSERT(psa_destroy_key(key));
+ test_operations_on_invalid_key(key);
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &got_attributes );
+ psa_reset_key_attributes(&got_attributes);
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void import_with_data( data_t *data, int type_arg,
- int attr_bits_arg,
- int expected_status_arg )
+void import_with_data(data_t *data, int type_arg,
+ int attr_bits_arg,
+ int expected_status_arg)
{
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -418,41 +421,43 @@
psa_status_t expected_status = expected_status_arg;
psa_status_t status;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_type( &attributes, type );
- psa_set_key_bits( &attributes, attr_bits );
+ psa_set_key_type(&attributes, type);
+ psa_set_key_bits(&attributes, attr_bits);
- status = psa_import_key( &attributes, data->x, data->len, &key );
- TEST_EQUAL( status, expected_status );
- if( status != PSA_SUCCESS )
+ status = psa_import_key(&attributes, data->x, data->len, &key);
+ TEST_EQUAL(status, expected_status);
+ if (status != PSA_SUCCESS) {
goto exit;
+ }
- PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
- TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
- if( attr_bits != 0 )
- TEST_EQUAL( attr_bits, psa_get_key_bits( &got_attributes ) );
- ASSERT_NO_SLOT_NUMBER( &got_attributes );
+ PSA_ASSERT(psa_get_key_attributes(key, &got_attributes));
+ TEST_EQUAL(psa_get_key_type(&got_attributes), type);
+ if (attr_bits != 0) {
+ TEST_EQUAL(attr_bits, psa_get_key_bits(&got_attributes));
+ }
+ ASSERT_NO_SLOT_NUMBER(&got_attributes);
- PSA_ASSERT( psa_destroy_key( key ) );
- test_operations_on_invalid_key( key );
+ PSA_ASSERT(psa_destroy_key(key));
+ test_operations_on_invalid_key(key);
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &got_attributes );
+ psa_reset_key_attributes(&got_attributes);
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
/* Construct and attempt to import a large unstructured key. */
-void import_large_key( int type_arg, int byte_size_arg,
- int expected_status_arg )
+void import_large_key(int type_arg, int byte_size_arg,
+ int expected_status_arg)
{
psa_key_type_t type = type_arg;
size_t byte_size = byte_size_arg;
@@ -466,31 +471,32 @@
/* Skip the test case if the target running the test cannot
* accommodate large keys due to heap size constraints */
- ASSERT_ALLOC_WEAK( buffer, buffer_size );
- memset( buffer, 'K', byte_size );
+ ASSERT_ALLOC_WEAK(buffer, buffer_size);
+ memset(buffer, 'K', byte_size);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* Try importing the key */
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
- psa_set_key_type( &attributes, type );
- status = psa_import_key( &attributes, buffer, byte_size, &key );
- TEST_ASSUME( status != PSA_ERROR_INSUFFICIENT_MEMORY );
- TEST_EQUAL( status, expected_status );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
+ psa_set_key_type(&attributes, type);
+ status = psa_import_key(&attributes, buffer, byte_size, &key);
+ TEST_ASSUME(status != PSA_ERROR_INSUFFICIENT_MEMORY);
+ TEST_EQUAL(status, expected_status);
- if( status == PSA_SUCCESS )
- {
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- TEST_EQUAL( psa_get_key_type( &attributes ), type );
- TEST_EQUAL( psa_get_key_bits( &attributes ),
- PSA_BYTES_TO_BITS( byte_size ) );
- ASSERT_NO_SLOT_NUMBER( &attributes );
- memset( buffer, 0, byte_size + 1 );
- PSA_ASSERT( psa_export_key( key, buffer, byte_size, &n ) );
- for( n = 0; n < byte_size; n++ )
- TEST_EQUAL( buffer[n], 'K' );
- for( n = byte_size; n < buffer_size; n++ )
- TEST_EQUAL( buffer[n], 0 );
+ if (status == PSA_SUCCESS) {
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ TEST_EQUAL(psa_get_key_type(&attributes), type);
+ TEST_EQUAL(psa_get_key_bits(&attributes),
+ PSA_BYTES_TO_BITS(byte_size));
+ ASSERT_NO_SLOT_NUMBER(&attributes);
+ memset(buffer, 0, byte_size + 1);
+ PSA_ASSERT(psa_export_key(key, buffer, byte_size, &n));
+ for (n = 0; n < byte_size; n++) {
+ TEST_EQUAL(buffer[n], 'K');
+ }
+ for (n = byte_size; n < buffer_size; n++) {
+ TEST_EQUAL(buffer[n], 0);
+ }
}
exit:
@@ -498,11 +504,11 @@
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- psa_destroy_key( key );
- PSA_DONE( );
- mbedtls_free( buffer );
+ psa_destroy_key(key);
+ PSA_DONE();
+ mbedtls_free(buffer);
}
/* END_CASE */
@@ -510,7 +516,7 @@
/* Import an RSA key with a valid structure (but not valid numbers
* inside, beyond having sensible size and parity). This is expected to
* fail for large keys. */
-void import_rsa_made_up( int bits_arg, int keypair, int expected_status_arg )
+void import_rsa_made_up(int bits_arg, int keypair, int expected_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
size_t bits = bits_arg;
@@ -519,43 +525,44 @@
psa_key_type_t type =
keypair ? PSA_KEY_TYPE_RSA_KEY_PAIR : PSA_KEY_TYPE_RSA_PUBLIC_KEY;
size_t buffer_size = /* Slight overapproximations */
- keypair ? bits * 9 / 16 + 80 : bits / 8 + 20;
+ keypair ? bits * 9 / 16 + 80 : bits / 8 + 20;
unsigned char *buffer = NULL;
unsigned char *p;
int ret;
size_t length;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
- ASSERT_ALLOC( buffer, buffer_size );
+ PSA_ASSERT(psa_crypto_init());
+ ASSERT_ALLOC(buffer, buffer_size);
- TEST_ASSERT( ( ret = construct_fake_rsa_key( buffer, buffer_size, &p,
- bits, keypair ) ) >= 0 );
+ TEST_ASSERT((ret = construct_fake_rsa_key(buffer, buffer_size, &p,
+ bits, keypair)) >= 0);
length = ret;
/* Try importing the key */
- psa_set_key_type( &attributes, type );
- status = psa_import_key( &attributes, p, length, &key );
- TEST_EQUAL( status, expected_status );
+ psa_set_key_type(&attributes, type);
+ status = psa_import_key(&attributes, p, length, &key);
+ TEST_EQUAL(status, expected_status);
- if( status == PSA_SUCCESS )
- PSA_ASSERT( psa_destroy_key( key ) );
+ if (status == PSA_SUCCESS) {
+ PSA_ASSERT(psa_destroy_key(key));
+ }
exit:
- mbedtls_free( buffer );
- PSA_DONE( );
+ mbedtls_free(buffer);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void import_export( data_t *data,
- int type_arg,
- int usage_arg, int alg_arg,
- int expected_bits,
- int export_size_delta,
- int expected_export_status_arg,
- /*whether reexport must give the original input exactly*/
- int canonical_input )
+void import_export(data_t *data,
+ int type_arg,
+ int usage_arg, int alg_arg,
+ int expected_bits,
+ int export_size_delta,
+ int expected_export_status_arg,
+ /*whether reexport must give the original input exactly*/
+ int canonical_input)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t type = type_arg;
@@ -571,39 +578,39 @@
psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
export_size = (ptrdiff_t) data->len + export_size_delta;
- ASSERT_ALLOC( exported, export_size );
- if( ! canonical_input )
- ASSERT_ALLOC( reexported, export_size );
- PSA_ASSERT( psa_crypto_init( ) );
+ ASSERT_ALLOC(exported, export_size);
+ if (!canonical_input) {
+ ASSERT_ALLOC(reexported, export_size);
+ }
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, usage_arg );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, type );
+ psa_set_key_usage_flags(&attributes, usage_arg);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, type);
/* Import the key */
- PSA_ASSERT( psa_import_key( &attributes, data->x, data->len, &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, data->x, data->len, &key));
/* Test the key information */
- PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
- TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
- TEST_EQUAL( psa_get_key_bits( &got_attributes ), (size_t) expected_bits );
- ASSERT_NO_SLOT_NUMBER( &got_attributes );
+ PSA_ASSERT(psa_get_key_attributes(key, &got_attributes));
+ TEST_EQUAL(psa_get_key_type(&got_attributes), type);
+ TEST_EQUAL(psa_get_key_bits(&got_attributes), (size_t) expected_bits);
+ ASSERT_NO_SLOT_NUMBER(&got_attributes);
/* Export the key */
- status = psa_export_key( key, exported, export_size, &exported_length );
- TEST_EQUAL( status, expected_export_status );
+ status = psa_export_key(key, exported, export_size, &exported_length);
+ TEST_EQUAL(status, expected_export_status);
/* The exported length must be set by psa_export_key() to a value between 0
* and export_size. On errors, the exported length must be 0. */
- TEST_ASSERT( exported_length != INVALID_EXPORT_LENGTH );
- TEST_ASSERT( status == PSA_SUCCESS || exported_length == 0 );
- TEST_LE_U( exported_length, export_size );
+ TEST_ASSERT(exported_length != INVALID_EXPORT_LENGTH);
+ TEST_ASSERT(status == PSA_SUCCESS || exported_length == 0);
+ TEST_LE_U(exported_length, export_size);
- TEST_ASSERT( mem_is_char( exported + exported_length, 0,
- export_size - exported_length ) );
- if( status != PSA_SUCCESS )
- {
- TEST_EQUAL( exported_length, 0 );
+ TEST_ASSERT(mem_is_char(exported + exported_length, 0,
+ export_size - exported_length));
+ if (status != PSA_SUCCESS) {
+ TEST_EQUAL(exported_length, 0);
goto destroy;
}
@@ -611,54 +618,54 @@
* this validates the canonical representations. For canonical inputs,
* this doesn't directly validate the implementation, but it still helps
* by cross-validating the test data with the sanity check code. */
- if( ! mbedtls_test_psa_exercise_key( key, usage_arg, 0 ) )
+ if (!mbedtls_test_psa_exercise_key(key, usage_arg, 0)) {
goto exit;
-
- if( canonical_input )
- ASSERT_COMPARE( data->x, data->len, exported, exported_length );
- else
- {
- mbedtls_svc_key_id_t key2 = MBEDTLS_SVC_KEY_ID_INIT;
- PSA_ASSERT( psa_import_key( &attributes, exported, exported_length,
- &key2 ) );
- PSA_ASSERT( psa_export_key( key2,
- reexported,
- export_size,
- &reexported_length ) );
- ASSERT_COMPARE( exported, exported_length,
- reexported, reexported_length );
- PSA_ASSERT( psa_destroy_key( key2 ) );
}
- TEST_ASSERT( exported_length <=
- PSA_EXPORT_KEY_OUTPUT_SIZE( type,
- psa_get_key_bits( &got_attributes ) ) );
- TEST_LE_U( exported_length, PSA_EXPORT_KEY_PAIR_MAX_SIZE );
+
+ if (canonical_input) {
+ ASSERT_COMPARE(data->x, data->len, exported, exported_length);
+ } else {
+ mbedtls_svc_key_id_t key2 = MBEDTLS_SVC_KEY_ID_INIT;
+ PSA_ASSERT(psa_import_key(&attributes, exported, exported_length,
+ &key2));
+ PSA_ASSERT(psa_export_key(key2,
+ reexported,
+ export_size,
+ &reexported_length));
+ ASSERT_COMPARE(exported, exported_length,
+ reexported, reexported_length);
+ PSA_ASSERT(psa_destroy_key(key2));
+ }
+ TEST_ASSERT(exported_length <=
+ PSA_EXPORT_KEY_OUTPUT_SIZE(type,
+ psa_get_key_bits(&got_attributes)));
+ TEST_LE_U(exported_length, PSA_EXPORT_KEY_PAIR_MAX_SIZE);
destroy:
/* Destroy the key */
- PSA_ASSERT( psa_destroy_key( key ) );
- test_operations_on_invalid_key( key );
+ PSA_ASSERT(psa_destroy_key(key));
+ test_operations_on_invalid_key(key);
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &got_attributes );
+ psa_reset_key_attributes(&got_attributes);
- mbedtls_free( exported );
- mbedtls_free( reexported );
- PSA_DONE( );
+ mbedtls_free(exported);
+ mbedtls_free(reexported);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void import_export_public_key( data_t *data,
- int type_arg, // key pair or public key
- int alg_arg,
- int export_size_delta,
- int expected_export_status_arg,
- data_t *expected_public_key )
+void import_export_public_key(data_t *data,
+ int type_arg, // key pair or public key
+ int alg_arg,
+ int export_size_delta,
+ int expected_export_status_arg,
+ data_t *expected_public_key)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t type = type_arg;
@@ -670,35 +677,34 @@
size_t exported_length = INVALID_EXPORT_LENGTH;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, type);
/* Import the key */
- PSA_ASSERT( psa_import_key( &attributes, data->x, data->len, &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, data->x, data->len, &key));
/* Export the public key */
- ASSERT_ALLOC( exported, export_size );
- status = psa_export_public_key( key,
- exported, export_size,
- &exported_length );
- TEST_EQUAL( status, expected_export_status );
- if( status == PSA_SUCCESS )
- {
- psa_key_type_t public_type = PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR( type );
+ ASSERT_ALLOC(exported, export_size);
+ status = psa_export_public_key(key,
+ exported, export_size,
+ &exported_length);
+ TEST_EQUAL(status, expected_export_status);
+ if (status == PSA_SUCCESS) {
+ psa_key_type_t public_type = PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(type);
size_t bits;
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- bits = psa_get_key_bits( &attributes );
- TEST_LE_U( expected_public_key->len,
- PSA_EXPORT_KEY_OUTPUT_SIZE( public_type, bits ) );
- TEST_LE_U( expected_public_key->len,
- PSA_EXPORT_PUBLIC_KEY_OUTPUT_SIZE( public_type, bits ) );
- TEST_LE_U( expected_public_key->len,
- PSA_EXPORT_PUBLIC_KEY_MAX_SIZE );
- ASSERT_COMPARE( expected_public_key->x, expected_public_key->len,
- exported, exported_length );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ bits = psa_get_key_bits(&attributes);
+ TEST_LE_U(expected_public_key->len,
+ PSA_EXPORT_KEY_OUTPUT_SIZE(public_type, bits));
+ TEST_LE_U(expected_public_key->len,
+ PSA_EXPORT_PUBLIC_KEY_OUTPUT_SIZE(public_type, bits));
+ TEST_LE_U(expected_public_key->len,
+ PSA_EXPORT_PUBLIC_KEY_MAX_SIZE);
+ ASSERT_COMPARE(expected_public_key->x, expected_public_key->len,
+ exported, exported_length);
}
exit:
@@ -706,67 +712,68 @@
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- mbedtls_free( exported );
- psa_destroy_key( key );
- PSA_DONE( );
+ mbedtls_free(exported);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void import_and_exercise_key( data_t *data,
- int type_arg,
- int bits_arg,
- int alg_arg )
+void import_and_exercise_key(data_t *data,
+ int type_arg,
+ int bits_arg,
+ int alg_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t type = type_arg;
size_t bits = bits_arg;
psa_algorithm_t alg = alg_arg;
- psa_key_usage_t usage = mbedtls_test_psa_usage_to_exercise( type, alg );
+ psa_key_usage_t usage = mbedtls_test_psa_usage_to_exercise(type, alg);
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, usage );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, type );
+ psa_set_key_usage_flags(&attributes, usage);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, type);
/* Import the key */
- PSA_ASSERT( psa_import_key( &attributes, data->x, data->len, &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, data->x, data->len, &key));
/* Test the key information */
- PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
- TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
- TEST_EQUAL( psa_get_key_bits( &got_attributes ), bits );
+ PSA_ASSERT(psa_get_key_attributes(key, &got_attributes));
+ TEST_EQUAL(psa_get_key_type(&got_attributes), type);
+ TEST_EQUAL(psa_get_key_bits(&got_attributes), bits);
/* Do something with the key according to its type and permitted usage. */
- if( ! mbedtls_test_psa_exercise_key( key, usage, alg ) )
+ if (!mbedtls_test_psa_exercise_key(key, usage, alg)) {
goto exit;
+ }
- PSA_ASSERT( psa_destroy_key( key ) );
- test_operations_on_invalid_key( key );
+ PSA_ASSERT(psa_destroy_key(key));
+ test_operations_on_invalid_key(key);
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &got_attributes );
+ psa_reset_key_attributes(&got_attributes);
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void effective_key_attributes( int type_arg, int expected_type_arg,
- int bits_arg, int expected_bits_arg,
- int usage_arg, int expected_usage_arg,
- int alg_arg, int expected_alg_arg )
+void effective_key_attributes(int type_arg, int expected_type_arg,
+ int bits_arg, int expected_bits_arg,
+ int usage_arg, int expected_usage_arg,
+ int alg_arg, int expected_alg_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = type_arg;
@@ -779,89 +786,89 @@
psa_key_usage_t expected_usage = expected_usage_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, usage );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
- psa_set_key_bits( &attributes, bits );
+ psa_set_key_usage_flags(&attributes, usage);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
+ psa_set_key_bits(&attributes, bits);
- PSA_ASSERT( psa_generate_key( &attributes, &key ) );
- psa_reset_key_attributes( &attributes );
+ PSA_ASSERT(psa_generate_key(&attributes, &key));
+ psa_reset_key_attributes(&attributes);
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- TEST_EQUAL( psa_get_key_type( &attributes ), expected_key_type );
- TEST_EQUAL( psa_get_key_bits( &attributes ), expected_bits );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ), expected_usage );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ), expected_alg );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ TEST_EQUAL(psa_get_key_type(&attributes), expected_key_type);
+ TEST_EQUAL(psa_get_key_bits(&attributes), expected_bits);
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes), expected_usage);
+ TEST_EQUAL(psa_get_key_algorithm(&attributes), expected_alg);
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void check_key_policy( int type_arg, int bits_arg,
- int usage_arg, int alg_arg )
+void check_key_policy(int type_arg, int bits_arg,
+ int usage_arg, int alg_arg)
{
- test_effective_key_attributes( type_arg, type_arg, bits_arg, bits_arg,
- usage_arg,
- mbedtls_test_update_key_usage_flags( usage_arg ),
- alg_arg, alg_arg );
+ test_effective_key_attributes(type_arg, type_arg, bits_arg, bits_arg,
+ usage_arg,
+ mbedtls_test_update_key_usage_flags(usage_arg),
+ alg_arg, alg_arg);
goto exit;
}
/* END_CASE */
/* BEGIN_CASE */
-void key_attributes_init( )
+void key_attributes_init()
{
/* Test each valid way of initializing the object, except for `= {0}`, as
* Clang 5 complains when `-Wmissing-field-initializers` is used, even
* though it's OK by the C standard. We could test for this, but we'd need
* to suppress the Clang warning for the test. */
- psa_key_attributes_t func = psa_key_attributes_init( );
+ psa_key_attributes_t func = psa_key_attributes_init();
psa_key_attributes_t init = PSA_KEY_ATTRIBUTES_INIT;
psa_key_attributes_t zero;
- memset( &zero, 0, sizeof( zero ) );
+ memset(&zero, 0, sizeof(zero));
- TEST_EQUAL( psa_get_key_lifetime( &func ), PSA_KEY_LIFETIME_VOLATILE );
- TEST_EQUAL( psa_get_key_lifetime( &init ), PSA_KEY_LIFETIME_VOLATILE );
- TEST_EQUAL( psa_get_key_lifetime( &zero ), PSA_KEY_LIFETIME_VOLATILE );
+ TEST_EQUAL(psa_get_key_lifetime(&func), PSA_KEY_LIFETIME_VOLATILE);
+ TEST_EQUAL(psa_get_key_lifetime(&init), PSA_KEY_LIFETIME_VOLATILE);
+ TEST_EQUAL(psa_get_key_lifetime(&zero), PSA_KEY_LIFETIME_VOLATILE);
- TEST_EQUAL( psa_get_key_type( &func ), 0 );
- TEST_EQUAL( psa_get_key_type( &init ), 0 );
- TEST_EQUAL( psa_get_key_type( &zero ), 0 );
+ TEST_EQUAL(psa_get_key_type(&func), 0);
+ TEST_EQUAL(psa_get_key_type(&init), 0);
+ TEST_EQUAL(psa_get_key_type(&zero), 0);
- TEST_EQUAL( psa_get_key_bits( &func ), 0 );
- TEST_EQUAL( psa_get_key_bits( &init ), 0 );
- TEST_EQUAL( psa_get_key_bits( &zero ), 0 );
+ TEST_EQUAL(psa_get_key_bits(&func), 0);
+ TEST_EQUAL(psa_get_key_bits(&init), 0);
+ TEST_EQUAL(psa_get_key_bits(&zero), 0);
- TEST_EQUAL( psa_get_key_usage_flags( &func ), 0 );
- TEST_EQUAL( psa_get_key_usage_flags( &init ), 0 );
- TEST_EQUAL( psa_get_key_usage_flags( &zero ), 0 );
+ TEST_EQUAL(psa_get_key_usage_flags(&func), 0);
+ TEST_EQUAL(psa_get_key_usage_flags(&init), 0);
+ TEST_EQUAL(psa_get_key_usage_flags(&zero), 0);
- TEST_EQUAL( psa_get_key_algorithm( &func ), 0 );
- TEST_EQUAL( psa_get_key_algorithm( &init ), 0 );
- TEST_EQUAL( psa_get_key_algorithm( &zero ), 0 );
+ TEST_EQUAL(psa_get_key_algorithm(&func), 0);
+ TEST_EQUAL(psa_get_key_algorithm(&init), 0);
+ TEST_EQUAL(psa_get_key_algorithm(&zero), 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void mac_key_policy( int policy_usage_arg,
- int policy_alg_arg,
- int key_type_arg,
- data_t *key_data,
- int exercise_alg_arg,
- int expected_status_sign_arg,
- int expected_status_verify_arg )
+void mac_key_policy(int policy_usage_arg,
+ int policy_alg_arg,
+ int key_type_arg,
+ data_t *key_data,
+ int exercise_alg_arg,
+ int expected_status_sign_arg,
+ int expected_status_verify_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -875,57 +882,58 @@
psa_status_t expected_status_verify = expected_status_verify_arg;
unsigned char mac[PSA_MAC_MAX_SIZE];
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, policy_usage );
- psa_set_key_algorithm( &attributes, policy_alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, policy_usage);
+ psa_set_key_algorithm(&attributes, policy_alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ),
- mbedtls_test_update_key_usage_flags( policy_usage ) );
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes),
+ mbedtls_test_update_key_usage_flags(policy_usage));
- status = psa_mac_sign_setup( &operation, key, exercise_alg );
- TEST_EQUAL( status, expected_status_sign );
+ status = psa_mac_sign_setup(&operation, key, exercise_alg);
+ TEST_EQUAL(status, expected_status_sign);
/* Calculate the MAC, one-shot case. */
- uint8_t input[128] = {0};
+ uint8_t input[128] = { 0 };
size_t mac_len;
- TEST_EQUAL( psa_mac_compute( key, exercise_alg,
- input, 128,
- mac, PSA_MAC_MAX_SIZE, &mac_len ),
- expected_status_sign );
+ TEST_EQUAL(psa_mac_compute(key, exercise_alg,
+ input, 128,
+ mac, PSA_MAC_MAX_SIZE, &mac_len),
+ expected_status_sign);
/* Verify correct MAC, one-shot case. */
- status = psa_mac_verify( key, exercise_alg, input, 128,
- mac, mac_len );
+ status = psa_mac_verify(key, exercise_alg, input, 128,
+ mac, mac_len);
- if( expected_status_sign != PSA_SUCCESS && expected_status_verify == PSA_SUCCESS )
- TEST_EQUAL( status, PSA_ERROR_INVALID_SIGNATURE );
- else
- TEST_EQUAL( status, expected_status_verify );
+ if (expected_status_sign != PSA_SUCCESS && expected_status_verify == PSA_SUCCESS) {
+ TEST_EQUAL(status, PSA_ERROR_INVALID_SIGNATURE);
+ } else {
+ TEST_EQUAL(status, expected_status_verify);
+ }
- psa_mac_abort( &operation );
+ psa_mac_abort(&operation);
- memset( mac, 0, sizeof( mac ) );
- status = psa_mac_verify_setup( &operation, key, exercise_alg );
- TEST_EQUAL( status, expected_status_verify );
+ memset(mac, 0, sizeof(mac));
+ status = psa_mac_verify_setup(&operation, key, exercise_alg);
+ TEST_EQUAL(status, expected_status_verify);
exit:
- psa_mac_abort( &operation );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_mac_abort(&operation);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_key_policy( int policy_usage_arg,
- int policy_alg,
- int key_type,
- data_t *key_data,
- int exercise_alg )
+void cipher_key_policy(int policy_usage_arg,
+ int policy_alg,
+ int key_type,
+ data_t *key_data,
+ int exercise_alg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -933,115 +941,119 @@
psa_key_usage_t policy_usage = policy_usage_arg;
psa_status_t status;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, policy_usage );
- psa_set_key_algorithm( &attributes, policy_alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, policy_usage);
+ psa_set_key_algorithm(&attributes, policy_alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
/* Check if no key usage flag implication is done */
- TEST_EQUAL( policy_usage,
- mbedtls_test_update_key_usage_flags( policy_usage ) );
+ TEST_EQUAL(policy_usage,
+ mbedtls_test_update_key_usage_flags(policy_usage));
- status = psa_cipher_encrypt_setup( &operation, key, exercise_alg );
- if( policy_alg == exercise_alg &&
- ( policy_usage & PSA_KEY_USAGE_ENCRYPT ) != 0 )
- PSA_ASSERT( status );
- else
- TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
- psa_cipher_abort( &operation );
+ status = psa_cipher_encrypt_setup(&operation, key, exercise_alg);
+ if (policy_alg == exercise_alg &&
+ (policy_usage & PSA_KEY_USAGE_ENCRYPT) != 0) {
+ PSA_ASSERT(status);
+ } else {
+ TEST_EQUAL(status, PSA_ERROR_NOT_PERMITTED);
+ }
+ psa_cipher_abort(&operation);
- status = psa_cipher_decrypt_setup( &operation, key, exercise_alg );
- if( policy_alg == exercise_alg &&
- ( policy_usage & PSA_KEY_USAGE_DECRYPT ) != 0 )
- PSA_ASSERT( status );
- else
- TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
+ status = psa_cipher_decrypt_setup(&operation, key, exercise_alg);
+ if (policy_alg == exercise_alg &&
+ (policy_usage & PSA_KEY_USAGE_DECRYPT) != 0) {
+ PSA_ASSERT(status);
+ } else {
+ TEST_EQUAL(status, PSA_ERROR_NOT_PERMITTED);
+ }
exit:
- psa_cipher_abort( &operation );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_cipher_abort(&operation);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void aead_key_policy( int policy_usage_arg,
- int policy_alg,
- int key_type,
- data_t *key_data,
- int nonce_length_arg,
- int tag_length_arg,
- int exercise_alg,
- int expected_status_arg )
+void aead_key_policy(int policy_usage_arg,
+ int policy_alg,
+ int key_type,
+ data_t *key_data,
+ int nonce_length_arg,
+ int tag_length_arg,
+ int exercise_alg,
+ int expected_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_usage_t policy_usage = policy_usage_arg;
psa_status_t status;
psa_status_t expected_status = expected_status_arg;
- unsigned char nonce[16] = {0};
+ unsigned char nonce[16] = { 0 };
size_t nonce_length = nonce_length_arg;
unsigned char tag[16];
size_t tag_length = tag_length_arg;
size_t output_length;
- TEST_LE_U( nonce_length, sizeof( nonce ) );
- TEST_LE_U( tag_length, sizeof( tag ) );
+ TEST_LE_U(nonce_length, sizeof(nonce));
+ TEST_LE_U(tag_length, sizeof(tag));
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, policy_usage );
- psa_set_key_algorithm( &attributes, policy_alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, policy_usage);
+ psa_set_key_algorithm(&attributes, policy_alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
/* Check if no key usage implication is done */
- TEST_EQUAL( policy_usage,
- mbedtls_test_update_key_usage_flags( policy_usage ) );
+ TEST_EQUAL(policy_usage,
+ mbedtls_test_update_key_usage_flags(policy_usage));
- status = psa_aead_encrypt( key, exercise_alg,
- nonce, nonce_length,
- NULL, 0,
- NULL, 0,
- tag, tag_length,
- &output_length );
- if( ( policy_usage & PSA_KEY_USAGE_ENCRYPT ) != 0 )
- TEST_EQUAL( status, expected_status );
- else
- TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
+ status = psa_aead_encrypt(key, exercise_alg,
+ nonce, nonce_length,
+ NULL, 0,
+ NULL, 0,
+ tag, tag_length,
+ &output_length);
+ if ((policy_usage & PSA_KEY_USAGE_ENCRYPT) != 0) {
+ TEST_EQUAL(status, expected_status);
+ } else {
+ TEST_EQUAL(status, PSA_ERROR_NOT_PERMITTED);
+ }
- memset( tag, 0, sizeof( tag ) );
- status = psa_aead_decrypt( key, exercise_alg,
- nonce, nonce_length,
- NULL, 0,
- tag, tag_length,
- NULL, 0,
- &output_length );
- if( ( policy_usage & PSA_KEY_USAGE_DECRYPT ) == 0 )
- TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
- else if( expected_status == PSA_SUCCESS )
- TEST_EQUAL( status, PSA_ERROR_INVALID_SIGNATURE );
- else
- TEST_EQUAL( status, expected_status );
+ memset(tag, 0, sizeof(tag));
+ status = psa_aead_decrypt(key, exercise_alg,
+ nonce, nonce_length,
+ NULL, 0,
+ tag, tag_length,
+ NULL, 0,
+ &output_length);
+ if ((policy_usage & PSA_KEY_USAGE_DECRYPT) == 0) {
+ TEST_EQUAL(status, PSA_ERROR_NOT_PERMITTED);
+ } else if (expected_status == PSA_SUCCESS) {
+ TEST_EQUAL(status, PSA_ERROR_INVALID_SIGNATURE);
+ } else {
+ TEST_EQUAL(status, expected_status);
+ }
exit:
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void asymmetric_encryption_key_policy( int policy_usage_arg,
- int policy_alg,
- int key_type,
- data_t *key_data,
- int exercise_alg )
+void asymmetric_encryption_key_policy(int policy_usage_arg,
+ int policy_alg,
+ int key_type,
+ data_t *key_data,
+ int exercise_alg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -1052,204 +1064,210 @@
unsigned char *buffer = NULL;
size_t output_length;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, policy_usage );
- psa_set_key_algorithm( &attributes, policy_alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, policy_usage);
+ psa_set_key_algorithm(&attributes, policy_alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
/* Check if no key usage implication is done */
- TEST_EQUAL( policy_usage,
- mbedtls_test_update_key_usage_flags( policy_usage ) );
+ TEST_EQUAL(policy_usage,
+ mbedtls_test_update_key_usage_flags(policy_usage));
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
- buffer_length = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE( key_type, key_bits,
- exercise_alg );
- ASSERT_ALLOC( buffer, buffer_length );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
+ buffer_length = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE(key_type, key_bits,
+ exercise_alg);
+ ASSERT_ALLOC(buffer, buffer_length);
- status = psa_asymmetric_encrypt( key, exercise_alg,
- NULL, 0,
- NULL, 0,
- buffer, buffer_length,
- &output_length );
- if( policy_alg == exercise_alg &&
- ( policy_usage & PSA_KEY_USAGE_ENCRYPT ) != 0 )
- PSA_ASSERT( status );
- else
- TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
+ status = psa_asymmetric_encrypt(key, exercise_alg,
+ NULL, 0,
+ NULL, 0,
+ buffer, buffer_length,
+ &output_length);
+ if (policy_alg == exercise_alg &&
+ (policy_usage & PSA_KEY_USAGE_ENCRYPT) != 0) {
+ PSA_ASSERT(status);
+ } else {
+ TEST_EQUAL(status, PSA_ERROR_NOT_PERMITTED);
+ }
- if( buffer_length != 0 )
- memset( buffer, 0, buffer_length );
- status = psa_asymmetric_decrypt( key, exercise_alg,
- buffer, buffer_length,
- NULL, 0,
- buffer, buffer_length,
- &output_length );
- if( policy_alg == exercise_alg &&
- ( policy_usage & PSA_KEY_USAGE_DECRYPT ) != 0 )
- TEST_EQUAL( status, PSA_ERROR_INVALID_PADDING );
- else
- TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
+ if (buffer_length != 0) {
+ memset(buffer, 0, buffer_length);
+ }
+ status = psa_asymmetric_decrypt(key, exercise_alg,
+ buffer, buffer_length,
+ NULL, 0,
+ buffer, buffer_length,
+ &output_length);
+ if (policy_alg == exercise_alg &&
+ (policy_usage & PSA_KEY_USAGE_DECRYPT) != 0) {
+ TEST_EQUAL(status, PSA_ERROR_INVALID_PADDING);
+ } else {
+ TEST_EQUAL(status, PSA_ERROR_NOT_PERMITTED);
+ }
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- psa_destroy_key( key );
- PSA_DONE( );
- mbedtls_free( buffer );
+ psa_destroy_key(key);
+ PSA_DONE();
+ mbedtls_free(buffer);
}
/* END_CASE */
/* BEGIN_CASE */
-void asymmetric_signature_key_policy( int policy_usage_arg,
- int policy_alg,
- int key_type,
- data_t *key_data,
- int exercise_alg,
- int payload_length_arg,
- int expected_usage_arg )
+void asymmetric_signature_key_policy(int policy_usage_arg,
+ int policy_alg,
+ int key_type,
+ data_t *key_data,
+ int exercise_alg,
+ int payload_length_arg,
+ int expected_usage_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_usage_t policy_usage = policy_usage_arg;
psa_key_usage_t expected_usage = expected_usage_arg;
psa_status_t status;
- unsigned char payload[PSA_HASH_MAX_SIZE] = {1};
+ unsigned char payload[PSA_HASH_MAX_SIZE] = { 1 };
/* If `payload_length_arg > 0`, `exercise_alg` is supposed to be
* compatible with the policy and `payload_length_arg` is supposed to be
* a valid input length to sign. If `payload_length_arg <= 0`,
* `exercise_alg` is supposed to be forbidden by the policy. */
int compatible_alg = payload_length_arg > 0;
size_t payload_length = compatible_alg ? payload_length_arg : 0;
- unsigned char signature[PSA_SIGNATURE_MAX_SIZE] = {0};
+ unsigned char signature[PSA_SIGNATURE_MAX_SIZE] = { 0 };
size_t signature_length;
/* Check if all implicit usage flags are deployed
in the expected usage flags. */
- TEST_EQUAL( expected_usage,
- mbedtls_test_update_key_usage_flags( policy_usage ) );
+ TEST_EQUAL(expected_usage,
+ mbedtls_test_update_key_usage_flags(policy_usage));
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, policy_usage );
- psa_set_key_algorithm( &attributes, policy_alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, policy_usage);
+ psa_set_key_algorithm(&attributes, policy_alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ), expected_usage );
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes), expected_usage);
- status = psa_sign_hash( key, exercise_alg,
- payload, payload_length,
- signature, sizeof( signature ),
- &signature_length );
- if( compatible_alg && ( expected_usage & PSA_KEY_USAGE_SIGN_HASH ) != 0 )
- PSA_ASSERT( status );
- else
- TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
+ status = psa_sign_hash(key, exercise_alg,
+ payload, payload_length,
+ signature, sizeof(signature),
+ &signature_length);
+ if (compatible_alg && (expected_usage & PSA_KEY_USAGE_SIGN_HASH) != 0) {
+ PSA_ASSERT(status);
+ } else {
+ TEST_EQUAL(status, PSA_ERROR_NOT_PERMITTED);
+ }
- memset( signature, 0, sizeof( signature ) );
- status = psa_verify_hash( key, exercise_alg,
- payload, payload_length,
- signature, sizeof( signature ) );
- if( compatible_alg && ( expected_usage & PSA_KEY_USAGE_VERIFY_HASH ) != 0 )
- TEST_EQUAL( status, PSA_ERROR_INVALID_SIGNATURE );
- else
- TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
+ memset(signature, 0, sizeof(signature));
+ status = psa_verify_hash(key, exercise_alg,
+ payload, payload_length,
+ signature, sizeof(signature));
+ if (compatible_alg && (expected_usage & PSA_KEY_USAGE_VERIFY_HASH) != 0) {
+ TEST_EQUAL(status, PSA_ERROR_INVALID_SIGNATURE);
+ } else {
+ TEST_EQUAL(status, PSA_ERROR_NOT_PERMITTED);
+ }
- if( PSA_ALG_IS_SIGN_HASH( exercise_alg ) &&
- PSA_ALG_IS_HASH( PSA_ALG_SIGN_GET_HASH( exercise_alg ) ) )
- {
- status = psa_sign_message( key, exercise_alg,
- payload, payload_length,
- signature, sizeof( signature ),
- &signature_length );
- if( compatible_alg && ( expected_usage & PSA_KEY_USAGE_SIGN_MESSAGE ) != 0 )
- PSA_ASSERT( status );
- else
- TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
+ if (PSA_ALG_IS_SIGN_HASH(exercise_alg) &&
+ PSA_ALG_IS_HASH(PSA_ALG_SIGN_GET_HASH(exercise_alg))) {
+ status = psa_sign_message(key, exercise_alg,
+ payload, payload_length,
+ signature, sizeof(signature),
+ &signature_length);
+ if (compatible_alg && (expected_usage & PSA_KEY_USAGE_SIGN_MESSAGE) != 0) {
+ PSA_ASSERT(status);
+ } else {
+ TEST_EQUAL(status, PSA_ERROR_NOT_PERMITTED);
+ }
- memset( signature, 0, sizeof( signature ) );
- status = psa_verify_message( key, exercise_alg,
- payload, payload_length,
- signature, sizeof( signature ) );
- if( compatible_alg && ( expected_usage & PSA_KEY_USAGE_VERIFY_MESSAGE ) != 0 )
- TEST_EQUAL( status, PSA_ERROR_INVALID_SIGNATURE );
- else
- TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
+ memset(signature, 0, sizeof(signature));
+ status = psa_verify_message(key, exercise_alg,
+ payload, payload_length,
+ signature, sizeof(signature));
+ if (compatible_alg && (expected_usage & PSA_KEY_USAGE_VERIFY_MESSAGE) != 0) {
+ TEST_EQUAL(status, PSA_ERROR_INVALID_SIGNATURE);
+ } else {
+ TEST_EQUAL(status, PSA_ERROR_NOT_PERMITTED);
+ }
}
exit:
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void derive_key_policy( int policy_usage,
- int policy_alg,
- int key_type,
- data_t *key_data,
- int exercise_alg )
+void derive_key_policy(int policy_usage,
+ int policy_alg,
+ int key_type,
+ data_t *key_data,
+ int exercise_alg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
psa_status_t status;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, policy_usage );
- psa_set_key_algorithm( &attributes, policy_alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, policy_usage);
+ psa_set_key_algorithm(&attributes, policy_alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- PSA_ASSERT( psa_key_derivation_setup( &operation, exercise_alg ) );
+ PSA_ASSERT(psa_key_derivation_setup(&operation, exercise_alg));
- if( PSA_ALG_IS_TLS12_PRF( exercise_alg ) ||
- PSA_ALG_IS_TLS12_PSK_TO_MS( exercise_alg ) )
- {
- PSA_ASSERT( psa_key_derivation_input_bytes(
- &operation,
- PSA_KEY_DERIVATION_INPUT_SEED,
- (const uint8_t*) "", 0) );
+ if (PSA_ALG_IS_TLS12_PRF(exercise_alg) ||
+ PSA_ALG_IS_TLS12_PSK_TO_MS(exercise_alg)) {
+ PSA_ASSERT(psa_key_derivation_input_bytes(
+ &operation,
+ PSA_KEY_DERIVATION_INPUT_SEED,
+ (const uint8_t *) "", 0));
}
- status = psa_key_derivation_input_key( &operation,
- PSA_KEY_DERIVATION_INPUT_SECRET,
- key );
+ status = psa_key_derivation_input_key(&operation,
+ PSA_KEY_DERIVATION_INPUT_SECRET,
+ key);
- if( policy_alg == exercise_alg &&
- ( policy_usage & PSA_KEY_USAGE_DERIVE ) != 0 )
- PSA_ASSERT( status );
- else
- TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
+ if (policy_alg == exercise_alg &&
+ (policy_usage & PSA_KEY_USAGE_DERIVE) != 0) {
+ PSA_ASSERT(status);
+ } else {
+ TEST_EQUAL(status, PSA_ERROR_NOT_PERMITTED);
+ }
exit:
- psa_key_derivation_abort( &operation );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_key_derivation_abort(&operation);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void agreement_key_policy( int policy_usage,
- int policy_alg,
- int key_type_arg,
- data_t *key_data,
- int exercise_alg,
- int expected_status_arg )
+void agreement_key_policy(int policy_usage,
+ int policy_alg,
+ int key_type_arg,
+ data_t *key_data,
+ int exercise_alg,
+ int expected_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -1258,30 +1276,30 @@
psa_status_t status;
psa_status_t expected_status = expected_status_arg;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, policy_usage );
- psa_set_key_algorithm( &attributes, policy_alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, policy_usage);
+ psa_set_key_algorithm(&attributes, policy_alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- PSA_ASSERT( psa_key_derivation_setup( &operation, exercise_alg ) );
- status = mbedtls_test_psa_key_agreement_with_self( &operation, key );
+ PSA_ASSERT(psa_key_derivation_setup(&operation, exercise_alg));
+ status = mbedtls_test_psa_key_agreement_with_self(&operation, key);
- TEST_EQUAL( status, expected_status );
+ TEST_EQUAL(status, expected_status);
exit:
- psa_key_derivation_abort( &operation );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_key_derivation_abort(&operation);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void key_policy_alg2( int key_type_arg, data_t *key_data,
- int usage_arg, int alg_arg, int alg2_arg )
+void key_policy_alg2(int key_type_arg, data_t *key_data,
+ int usage_arg, int alg_arg, int alg2_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -1291,46 +1309,48 @@
psa_algorithm_t alg = alg_arg;
psa_algorithm_t alg2 = alg2_arg;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, usage );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_enrollment_algorithm( &attributes, alg2 );
- psa_set_key_type( &attributes, key_type );
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ psa_set_key_usage_flags(&attributes, usage);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_enrollment_algorithm(&attributes, alg2);
+ psa_set_key_type(&attributes, key_type);
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
/* Update the usage flags to obtain implicit usage flags */
- usage = mbedtls_test_update_key_usage_flags( usage );
- PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
- TEST_EQUAL( psa_get_key_usage_flags( &got_attributes ), usage );
- TEST_EQUAL( psa_get_key_algorithm( &got_attributes ), alg );
- TEST_EQUAL( psa_get_key_enrollment_algorithm( &got_attributes ), alg2 );
+ usage = mbedtls_test_update_key_usage_flags(usage);
+ PSA_ASSERT(psa_get_key_attributes(key, &got_attributes));
+ TEST_EQUAL(psa_get_key_usage_flags(&got_attributes), usage);
+ TEST_EQUAL(psa_get_key_algorithm(&got_attributes), alg);
+ TEST_EQUAL(psa_get_key_enrollment_algorithm(&got_attributes), alg2);
- if( ! mbedtls_test_psa_exercise_key( key, usage, alg ) )
+ if (!mbedtls_test_psa_exercise_key(key, usage, alg)) {
goto exit;
- if( ! mbedtls_test_psa_exercise_key( key, usage, alg2 ) )
+ }
+ if (!mbedtls_test_psa_exercise_key(key, usage, alg2)) {
goto exit;
+ }
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &got_attributes );
+ psa_reset_key_attributes(&got_attributes);
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void raw_agreement_key_policy( int policy_usage,
- int policy_alg,
- int key_type_arg,
- data_t *key_data,
- int exercise_alg,
- int expected_status_arg )
+void raw_agreement_key_policy(int policy_usage,
+ int policy_alg,
+ int key_type_arg,
+ data_t *key_data,
+ int exercise_alg,
+ int expected_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -1339,35 +1359,35 @@
psa_status_t status;
psa_status_t expected_status = expected_status_arg;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, policy_usage );
- psa_set_key_algorithm( &attributes, policy_alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, policy_usage);
+ psa_set_key_algorithm(&attributes, policy_alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- status = mbedtls_test_psa_raw_key_agreement_with_self( exercise_alg, key );
+ status = mbedtls_test_psa_raw_key_agreement_with_self(exercise_alg, key);
- TEST_EQUAL( status, expected_status );
+ TEST_EQUAL(status, expected_status);
exit:
- psa_key_derivation_abort( &operation );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_key_derivation_abort(&operation);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void copy_success( int source_usage_arg,
- int source_alg_arg, int source_alg2_arg,
- int type_arg, data_t *material,
- int copy_attributes,
- int target_usage_arg,
- int target_alg_arg, int target_alg2_arg,
- int expected_usage_arg,
- int expected_alg_arg, int expected_alg2_arg )
+void copy_success(int source_usage_arg,
+ int source_alg_arg, int source_alg2_arg,
+ int type_arg, data_t *material,
+ int copy_attributes,
+ int target_usage_arg,
+ int target_alg_arg, int target_alg2_arg,
+ int expected_usage_arg,
+ int expected_alg_arg, int expected_alg2_arg)
{
psa_key_attributes_t source_attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_attributes_t target_attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -1378,195 +1398,199 @@
mbedtls_svc_key_id_t target_key = MBEDTLS_SVC_KEY_ID_INIT;
uint8_t *export_buffer = NULL;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* Prepare the source key. */
- psa_set_key_usage_flags( &source_attributes, source_usage_arg );
- psa_set_key_algorithm( &source_attributes, source_alg_arg );
- psa_set_key_enrollment_algorithm( &source_attributes, source_alg2_arg );
- psa_set_key_type( &source_attributes, type_arg );
- PSA_ASSERT( psa_import_key( &source_attributes,
- material->x, material->len,
- &source_key ) );
- PSA_ASSERT( psa_get_key_attributes( source_key, &source_attributes ) );
+ psa_set_key_usage_flags(&source_attributes, source_usage_arg);
+ psa_set_key_algorithm(&source_attributes, source_alg_arg);
+ psa_set_key_enrollment_algorithm(&source_attributes, source_alg2_arg);
+ psa_set_key_type(&source_attributes, type_arg);
+ PSA_ASSERT(psa_import_key(&source_attributes,
+ material->x, material->len,
+ &source_key));
+ PSA_ASSERT(psa_get_key_attributes(source_key, &source_attributes));
/* Prepare the target attributes. */
- if( copy_attributes )
- {
+ if (copy_attributes) {
target_attributes = source_attributes;
/* Set volatile lifetime to reset the key identifier to 0. */
- psa_set_key_lifetime( &target_attributes, PSA_KEY_LIFETIME_VOLATILE );
+ psa_set_key_lifetime(&target_attributes, PSA_KEY_LIFETIME_VOLATILE);
}
- if( target_usage_arg != -1 )
- psa_set_key_usage_flags( &target_attributes, target_usage_arg );
- if( target_alg_arg != -1 )
- psa_set_key_algorithm( &target_attributes, target_alg_arg );
- if( target_alg2_arg != -1 )
- psa_set_key_enrollment_algorithm( &target_attributes, target_alg2_arg );
+ if (target_usage_arg != -1) {
+ psa_set_key_usage_flags(&target_attributes, target_usage_arg);
+ }
+ if (target_alg_arg != -1) {
+ psa_set_key_algorithm(&target_attributes, target_alg_arg);
+ }
+ if (target_alg2_arg != -1) {
+ psa_set_key_enrollment_algorithm(&target_attributes, target_alg2_arg);
+ }
/* Copy the key. */
- PSA_ASSERT( psa_copy_key( source_key,
- &target_attributes, &target_key ) );
+ PSA_ASSERT(psa_copy_key(source_key,
+ &target_attributes, &target_key));
/* Destroy the source to ensure that this doesn't affect the target. */
- PSA_ASSERT( psa_destroy_key( source_key ) );
+ PSA_ASSERT(psa_destroy_key(source_key));
/* Test that the target slot has the expected content and policy. */
- PSA_ASSERT( psa_get_key_attributes( target_key, &target_attributes ) );
- TEST_EQUAL( psa_get_key_type( &source_attributes ),
- psa_get_key_type( &target_attributes ) );
- TEST_EQUAL( psa_get_key_bits( &source_attributes ),
- psa_get_key_bits( &target_attributes ) );
- TEST_EQUAL( expected_usage, psa_get_key_usage_flags( &target_attributes ) );
- TEST_EQUAL( expected_alg, psa_get_key_algorithm( &target_attributes ) );
- TEST_EQUAL( expected_alg2,
- psa_get_key_enrollment_algorithm( &target_attributes ) );
- if( expected_usage & PSA_KEY_USAGE_EXPORT )
- {
+ PSA_ASSERT(psa_get_key_attributes(target_key, &target_attributes));
+ TEST_EQUAL(psa_get_key_type(&source_attributes),
+ psa_get_key_type(&target_attributes));
+ TEST_EQUAL(psa_get_key_bits(&source_attributes),
+ psa_get_key_bits(&target_attributes));
+ TEST_EQUAL(expected_usage, psa_get_key_usage_flags(&target_attributes));
+ TEST_EQUAL(expected_alg, psa_get_key_algorithm(&target_attributes));
+ TEST_EQUAL(expected_alg2,
+ psa_get_key_enrollment_algorithm(&target_attributes));
+ if (expected_usage & PSA_KEY_USAGE_EXPORT) {
size_t length;
- ASSERT_ALLOC( export_buffer, material->len );
- PSA_ASSERT( psa_export_key( target_key, export_buffer,
- material->len, &length ) );
- ASSERT_COMPARE( material->x, material->len,
- export_buffer, length );
+ ASSERT_ALLOC(export_buffer, material->len);
+ PSA_ASSERT(psa_export_key(target_key, export_buffer,
+ material->len, &length));
+ ASSERT_COMPARE(material->x, material->len,
+ 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)) {
goto exit;
- if( ! mbedtls_test_psa_exercise_key( target_key, expected_usage, expected_alg2 ) )
+ }
+ if (!mbedtls_test_psa_exercise_key(target_key, expected_usage, expected_alg2)) {
goto exit;
+ }
- PSA_ASSERT( psa_destroy_key( target_key ) );
+ PSA_ASSERT(psa_destroy_key(target_key));
exit:
/*
* Source and target key attributes may have been returned by
* psa_get_key_attributes() thus reset them as required.
*/
- psa_reset_key_attributes( &source_attributes );
- psa_reset_key_attributes( &target_attributes );
+ psa_reset_key_attributes(&source_attributes);
+ psa_reset_key_attributes(&target_attributes);
- PSA_DONE( );
- mbedtls_free( export_buffer );
+ PSA_DONE();
+ mbedtls_free(export_buffer);
}
/* END_CASE */
/* BEGIN_CASE */
-void copy_fail( int source_usage_arg,
- int source_alg_arg, int source_alg2_arg,
- int type_arg, data_t *material,
- int target_type_arg, int target_bits_arg,
- int target_usage_arg,
- int target_alg_arg, int target_alg2_arg,
- int target_id_arg, int target_lifetime_arg,
- int expected_status_arg )
+void copy_fail(int source_usage_arg,
+ int source_alg_arg, int source_alg2_arg,
+ int type_arg, data_t *material,
+ int target_type_arg, int target_bits_arg,
+ int target_usage_arg,
+ int target_alg_arg, int target_alg2_arg,
+ int target_id_arg, int target_lifetime_arg,
+ int expected_status_arg)
{
psa_key_attributes_t source_attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_attributes_t target_attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_svc_key_id_t source_key = MBEDTLS_SVC_KEY_ID_INIT;
mbedtls_svc_key_id_t target_key = MBEDTLS_SVC_KEY_ID_INIT;
- mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make( 1, target_id_arg );
+ mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make(1, target_id_arg);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* Prepare the source key. */
- psa_set_key_usage_flags( &source_attributes, source_usage_arg );
- psa_set_key_algorithm( &source_attributes, source_alg_arg );
- psa_set_key_enrollment_algorithm( &source_attributes, source_alg2_arg );
- psa_set_key_type( &source_attributes, type_arg );
- PSA_ASSERT( psa_import_key( &source_attributes,
- material->x, material->len,
- &source_key ) );
+ psa_set_key_usage_flags(&source_attributes, source_usage_arg);
+ psa_set_key_algorithm(&source_attributes, source_alg_arg);
+ psa_set_key_enrollment_algorithm(&source_attributes, source_alg2_arg);
+ psa_set_key_type(&source_attributes, type_arg);
+ PSA_ASSERT(psa_import_key(&source_attributes,
+ material->x, material->len,
+ &source_key));
/* Prepare the target attributes. */
- psa_set_key_id( &target_attributes, key_id );
- psa_set_key_lifetime( &target_attributes, target_lifetime_arg );
- psa_set_key_type( &target_attributes, target_type_arg );
- psa_set_key_bits( &target_attributes, target_bits_arg );
- psa_set_key_usage_flags( &target_attributes, target_usage_arg );
- psa_set_key_algorithm( &target_attributes, target_alg_arg );
- psa_set_key_enrollment_algorithm( &target_attributes, target_alg2_arg );
+ psa_set_key_id(&target_attributes, key_id);
+ psa_set_key_lifetime(&target_attributes, target_lifetime_arg);
+ psa_set_key_type(&target_attributes, target_type_arg);
+ psa_set_key_bits(&target_attributes, target_bits_arg);
+ psa_set_key_usage_flags(&target_attributes, target_usage_arg);
+ psa_set_key_algorithm(&target_attributes, target_alg_arg);
+ psa_set_key_enrollment_algorithm(&target_attributes, target_alg2_arg);
/* Try to copy the key. */
- TEST_EQUAL( psa_copy_key( source_key,
- &target_attributes, &target_key ),
- expected_status_arg );
+ TEST_EQUAL(psa_copy_key(source_key,
+ &target_attributes, &target_key),
+ expected_status_arg);
- PSA_ASSERT( psa_destroy_key( source_key ) );
+ PSA_ASSERT(psa_destroy_key(source_key));
exit:
- psa_reset_key_attributes( &source_attributes );
- psa_reset_key_attributes( &target_attributes );
- PSA_DONE( );
+ psa_reset_key_attributes(&source_attributes);
+ psa_reset_key_attributes(&target_attributes);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void hash_operation_init( )
+void hash_operation_init()
{
const uint8_t input[1] = { 0 };
/* Test each valid way of initializing the object, except for `= {0}`, as
* Clang 5 complains when `-Wmissing-field-initializers` is used, even
* though it's OK by the C standard. We could test for this, but we'd need
* to suppress the Clang warning for the test. */
- psa_hash_operation_t func = psa_hash_operation_init( );
+ psa_hash_operation_t func = psa_hash_operation_init();
psa_hash_operation_t init = PSA_HASH_OPERATION_INIT;
psa_hash_operation_t zero;
- memset( &zero, 0, sizeof( zero ) );
+ memset(&zero, 0, sizeof(zero));
/* A freshly-initialized hash operation should not be usable. */
- TEST_EQUAL( psa_hash_update( &func, input, sizeof( input ) ),
- PSA_ERROR_BAD_STATE );
- TEST_EQUAL( psa_hash_update( &init, input, sizeof( input ) ),
- PSA_ERROR_BAD_STATE );
- TEST_EQUAL( psa_hash_update( &zero, input, sizeof( input ) ),
- PSA_ERROR_BAD_STATE );
+ TEST_EQUAL(psa_hash_update(&func, input, sizeof(input)),
+ PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(psa_hash_update(&init, input, sizeof(input)),
+ PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(psa_hash_update(&zero, input, sizeof(input)),
+ PSA_ERROR_BAD_STATE);
/* A default hash operation should be abortable without error. */
- PSA_ASSERT( psa_hash_abort( &func ) );
- PSA_ASSERT( psa_hash_abort( &init ) );
- PSA_ASSERT( psa_hash_abort( &zero ) );
+ PSA_ASSERT(psa_hash_abort(&func));
+ PSA_ASSERT(psa_hash_abort(&init));
+ PSA_ASSERT(psa_hash_abort(&zero));
}
/* END_CASE */
/* BEGIN_CASE */
-void hash_setup( int alg_arg,
- int expected_status_arg )
+void hash_setup(int alg_arg,
+ int expected_status_arg)
{
psa_algorithm_t alg = alg_arg;
psa_status_t expected_status = expected_status_arg;
psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
psa_status_t status;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- status = psa_hash_setup( &operation, alg );
- TEST_EQUAL( status, expected_status );
+ status = psa_hash_setup(&operation, alg);
+ TEST_EQUAL(status, expected_status);
/* Whether setup succeeded or failed, abort must succeed. */
- PSA_ASSERT( psa_hash_abort( &operation ) );
+ PSA_ASSERT(psa_hash_abort(&operation));
/* If setup failed, reproduce the failure, so as to
* test the resulting state of the operation object. */
- if( status != PSA_SUCCESS )
- TEST_EQUAL( psa_hash_setup( &operation, alg ), status );
+ if (status != PSA_SUCCESS) {
+ TEST_EQUAL(psa_hash_setup(&operation, alg), status);
+ }
/* Now the operation object should be reusable. */
#if defined(KNOWN_SUPPORTED_HASH_ALG)
- PSA_ASSERT( psa_hash_setup( &operation, KNOWN_SUPPORTED_HASH_ALG ) );
- PSA_ASSERT( psa_hash_abort( &operation ) );
+ PSA_ASSERT(psa_hash_setup(&operation, KNOWN_SUPPORTED_HASH_ALG));
+ PSA_ASSERT(psa_hash_abort(&operation));
#endif
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void hash_compute_fail( int alg_arg, data_t *input,
- int output_size_arg, int expected_status_arg )
+void hash_compute_fail(int alg_arg, data_t *input,
+ int output_size_arg, int expected_status_arg)
{
psa_algorithm_t alg = alg_arg;
uint8_t *output = NULL;
@@ -1575,100 +1599,99 @@
psa_status_t expected_status = expected_status_arg;
psa_status_t status;
- ASSERT_ALLOC( output, output_size );
+ ASSERT_ALLOC(output, output_size);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- status = psa_hash_compute( alg, input->x, input->len,
- output, output_size, &output_length );
- TEST_EQUAL( status, expected_status );
- TEST_LE_U( output_length, output_size );
+ status = psa_hash_compute(alg, input->x, input->len,
+ output, output_size, &output_length);
+ TEST_EQUAL(status, expected_status);
+ TEST_LE_U(output_length, output_size);
exit:
- mbedtls_free( output );
- PSA_DONE( );
+ mbedtls_free(output);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void hash_compare_fail( int alg_arg, data_t *input,
- data_t *reference_hash,
- int expected_status_arg )
+void hash_compare_fail(int alg_arg, data_t *input,
+ data_t *reference_hash,
+ int expected_status_arg)
{
psa_algorithm_t alg = alg_arg;
psa_status_t expected_status = expected_status_arg;
psa_status_t status;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- status = psa_hash_compare( alg, input->x, input->len,
- reference_hash->x, reference_hash->len );
- TEST_EQUAL( status, expected_status );
+ status = psa_hash_compare(alg, input->x, input->len,
+ reference_hash->x, reference_hash->len);
+ TEST_EQUAL(status, expected_status);
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void hash_compute_compare( int alg_arg, data_t *input,
- data_t *expected_output )
+void hash_compute_compare(int alg_arg, data_t *input,
+ data_t *expected_output)
{
psa_algorithm_t alg = alg_arg;
uint8_t output[PSA_HASH_MAX_SIZE + 1];
size_t output_length = INVALID_EXPORT_LENGTH;
size_t i;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* Compute with tight buffer */
- PSA_ASSERT( psa_hash_compute( alg, input->x, input->len,
- output, PSA_HASH_LENGTH( alg ),
- &output_length ) );
- TEST_EQUAL( output_length, PSA_HASH_LENGTH( alg ) );
- ASSERT_COMPARE( output, output_length,
- expected_output->x, expected_output->len );
+ PSA_ASSERT(psa_hash_compute(alg, input->x, input->len,
+ output, PSA_HASH_LENGTH(alg),
+ &output_length));
+ TEST_EQUAL(output_length, PSA_HASH_LENGTH(alg));
+ ASSERT_COMPARE(output, output_length,
+ expected_output->x, expected_output->len);
/* Compute with larger buffer */
- PSA_ASSERT( psa_hash_compute( alg, input->x, input->len,
- output, sizeof( output ),
- &output_length ) );
- TEST_EQUAL( output_length, PSA_HASH_LENGTH( alg ) );
- ASSERT_COMPARE( output, output_length,
- expected_output->x, expected_output->len );
+ PSA_ASSERT(psa_hash_compute(alg, input->x, input->len,
+ output, sizeof(output),
+ &output_length));
+ TEST_EQUAL(output_length, PSA_HASH_LENGTH(alg));
+ ASSERT_COMPARE(output, output_length,
+ expected_output->x, expected_output->len);
/* Compare with correct hash */
- PSA_ASSERT( psa_hash_compare( alg, input->x, input->len,
- output, output_length ) );
+ PSA_ASSERT(psa_hash_compare(alg, input->x, input->len,
+ output, output_length));
/* Compare with trailing garbage */
- TEST_EQUAL( psa_hash_compare( alg, input->x, input->len,
- output, output_length + 1 ),
- PSA_ERROR_INVALID_SIGNATURE );
+ TEST_EQUAL(psa_hash_compare(alg, input->x, input->len,
+ output, output_length + 1),
+ PSA_ERROR_INVALID_SIGNATURE);
/* Compare with truncated hash */
- TEST_EQUAL( psa_hash_compare( alg, input->x, input->len,
- output, output_length - 1 ),
- PSA_ERROR_INVALID_SIGNATURE );
+ TEST_EQUAL(psa_hash_compare(alg, input->x, input->len,
+ output, output_length - 1),
+ PSA_ERROR_INVALID_SIGNATURE);
/* Compare with corrupted value */
- for( i = 0; i < output_length; i++ )
- {
- mbedtls_test_set_step( i );
+ for (i = 0; i < output_length; i++) {
+ mbedtls_test_set_step(i);
output[i] ^= 1;
- TEST_EQUAL( psa_hash_compare( alg, input->x, input->len,
- output, output_length ),
- PSA_ERROR_INVALID_SIGNATURE );
+ TEST_EQUAL(psa_hash_compare(alg, input->x, input->len,
+ output, output_length),
+ PSA_ERROR_INVALID_SIGNATURE);
output[i] ^= 1;
}
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
-void hash_bad_order( )
+void hash_bad_order()
{
psa_algorithm_t alg = PSA_ALG_SHA_256;
unsigned char input[] = "";
@@ -1676,103 +1699,104 @@
const unsigned char valid_hash[] = {
0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8,
0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c,
- 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55 };
+ 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55
+ };
unsigned char hash[sizeof(valid_hash)] = { 0 };
size_t hash_len;
psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* Call setup twice in a row. */
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
- ASSERT_OPERATION_IS_ACTIVE( operation );
- TEST_EQUAL( psa_hash_setup( &operation, alg ),
- PSA_ERROR_BAD_STATE );
- ASSERT_OPERATION_IS_INACTIVE( operation );
- PSA_ASSERT( psa_hash_abort( &operation ) );
- ASSERT_OPERATION_IS_INACTIVE( operation );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
+ ASSERT_OPERATION_IS_ACTIVE(operation);
+ TEST_EQUAL(psa_hash_setup(&operation, alg),
+ PSA_ERROR_BAD_STATE);
+ ASSERT_OPERATION_IS_INACTIVE(operation);
+ PSA_ASSERT(psa_hash_abort(&operation));
+ ASSERT_OPERATION_IS_INACTIVE(operation);
/* Call update without calling setup beforehand. */
- TEST_EQUAL( psa_hash_update( &operation, input, sizeof( input ) ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_hash_abort( &operation ) );
+ TEST_EQUAL(psa_hash_update(&operation, input, sizeof(input)),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_hash_abort(&operation));
/* Check that update calls abort on error. */
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
operation.id = UINT_MAX;
- ASSERT_OPERATION_IS_ACTIVE( operation );
- TEST_EQUAL( psa_hash_update( &operation, input, sizeof( input ) ),
- PSA_ERROR_BAD_STATE );
- ASSERT_OPERATION_IS_INACTIVE( operation );
- PSA_ASSERT( psa_hash_abort( &operation ) );
- ASSERT_OPERATION_IS_INACTIVE( operation );
+ ASSERT_OPERATION_IS_ACTIVE(operation);
+ TEST_EQUAL(psa_hash_update(&operation, input, sizeof(input)),
+ PSA_ERROR_BAD_STATE);
+ ASSERT_OPERATION_IS_INACTIVE(operation);
+ PSA_ASSERT(psa_hash_abort(&operation));
+ ASSERT_OPERATION_IS_INACTIVE(operation);
/* Call update after finish. */
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
- PSA_ASSERT( psa_hash_finish( &operation,
- hash, sizeof( hash ), &hash_len ) );
- TEST_EQUAL( psa_hash_update( &operation, input, sizeof( input ) ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_hash_abort( &operation ) );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
+ PSA_ASSERT(psa_hash_finish(&operation,
+ hash, sizeof(hash), &hash_len));
+ TEST_EQUAL(psa_hash_update(&operation, input, sizeof(input)),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_hash_abort(&operation));
/* Call verify without calling setup beforehand. */
- TEST_EQUAL( psa_hash_verify( &operation,
- valid_hash, sizeof( valid_hash ) ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_hash_abort( &operation ) );
+ TEST_EQUAL(psa_hash_verify(&operation,
+ valid_hash, sizeof(valid_hash)),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_hash_abort(&operation));
/* Call verify after finish. */
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
- PSA_ASSERT( psa_hash_finish( &operation,
- hash, sizeof( hash ), &hash_len ) );
- TEST_EQUAL( psa_hash_verify( &operation,
- valid_hash, sizeof( valid_hash ) ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_hash_abort( &operation ) );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
+ PSA_ASSERT(psa_hash_finish(&operation,
+ hash, sizeof(hash), &hash_len));
+ TEST_EQUAL(psa_hash_verify(&operation,
+ valid_hash, sizeof(valid_hash)),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_hash_abort(&operation));
/* Call verify twice in a row. */
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
- ASSERT_OPERATION_IS_ACTIVE( operation );
- PSA_ASSERT( psa_hash_verify( &operation,
- valid_hash, sizeof( valid_hash ) ) );
- ASSERT_OPERATION_IS_INACTIVE( operation );
- TEST_EQUAL( psa_hash_verify( &operation,
- valid_hash, sizeof( valid_hash ) ),
- PSA_ERROR_BAD_STATE );
- ASSERT_OPERATION_IS_INACTIVE( operation );
- PSA_ASSERT( psa_hash_abort( &operation ) );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
+ ASSERT_OPERATION_IS_ACTIVE(operation);
+ PSA_ASSERT(psa_hash_verify(&operation,
+ valid_hash, sizeof(valid_hash)));
+ ASSERT_OPERATION_IS_INACTIVE(operation);
+ TEST_EQUAL(psa_hash_verify(&operation,
+ valid_hash, sizeof(valid_hash)),
+ PSA_ERROR_BAD_STATE);
+ ASSERT_OPERATION_IS_INACTIVE(operation);
+ PSA_ASSERT(psa_hash_abort(&operation));
/* Call finish without calling setup beforehand. */
- TEST_EQUAL( psa_hash_finish( &operation,
- hash, sizeof( hash ), &hash_len ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_hash_abort( &operation ) );
+ TEST_EQUAL(psa_hash_finish(&operation,
+ hash, sizeof(hash), &hash_len),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_hash_abort(&operation));
/* Call finish twice in a row. */
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
- PSA_ASSERT( psa_hash_finish( &operation,
- hash, sizeof( hash ), &hash_len ) );
- TEST_EQUAL( psa_hash_finish( &operation,
- hash, sizeof( hash ), &hash_len ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_hash_abort( &operation ) );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
+ PSA_ASSERT(psa_hash_finish(&operation,
+ hash, sizeof(hash), &hash_len));
+ TEST_EQUAL(psa_hash_finish(&operation,
+ hash, sizeof(hash), &hash_len),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_hash_abort(&operation));
/* Call finish after calling verify. */
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
- PSA_ASSERT( psa_hash_verify( &operation,
- valid_hash, sizeof( valid_hash ) ) );
- TEST_EQUAL( psa_hash_finish( &operation,
- hash, sizeof( hash ), &hash_len ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_hash_abort( &operation ) );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
+ PSA_ASSERT(psa_hash_verify(&operation,
+ valid_hash, sizeof(valid_hash)));
+ TEST_EQUAL(psa_hash_finish(&operation,
+ hash, sizeof(hash), &hash_len),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_hash_abort(&operation));
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
-void hash_verify_bad_args( )
+void hash_verify_bad_args()
{
psa_algorithm_t alg = PSA_ALG_SHA_256;
/* SHA-256 hash of an empty string with 2 extra bytes (0xaa and 0xbb)
@@ -1780,60 +1804,61 @@
unsigned char hash[] = {
0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8,
0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c,
- 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55, 0xaa, 0xbb };
- size_t expected_size = PSA_HASH_LENGTH( alg );
+ 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55, 0xaa, 0xbb
+ };
+ size_t expected_size = PSA_HASH_LENGTH(alg);
psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* psa_hash_verify with a smaller hash than expected */
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
- ASSERT_OPERATION_IS_ACTIVE( operation );
- TEST_EQUAL( psa_hash_verify( &operation, hash, expected_size - 1 ),
- PSA_ERROR_INVALID_SIGNATURE );
- ASSERT_OPERATION_IS_INACTIVE( operation );
- PSA_ASSERT( psa_hash_abort( &operation ) );
- ASSERT_OPERATION_IS_INACTIVE( operation );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
+ ASSERT_OPERATION_IS_ACTIVE(operation);
+ TEST_EQUAL(psa_hash_verify(&operation, hash, expected_size - 1),
+ PSA_ERROR_INVALID_SIGNATURE);
+ ASSERT_OPERATION_IS_INACTIVE(operation);
+ PSA_ASSERT(psa_hash_abort(&operation));
+ ASSERT_OPERATION_IS_INACTIVE(operation);
/* psa_hash_verify with a non-matching hash */
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
- TEST_EQUAL( psa_hash_verify( &operation, hash + 1, expected_size ),
- PSA_ERROR_INVALID_SIGNATURE );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
+ TEST_EQUAL(psa_hash_verify(&operation, hash + 1, expected_size),
+ PSA_ERROR_INVALID_SIGNATURE);
/* psa_hash_verify with a hash longer than expected */
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
- TEST_EQUAL( psa_hash_verify( &operation, hash, sizeof( hash ) ),
- PSA_ERROR_INVALID_SIGNATURE );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
+ TEST_EQUAL(psa_hash_verify(&operation, hash, sizeof(hash)),
+ PSA_ERROR_INVALID_SIGNATURE);
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
-void hash_finish_bad_args( )
+void hash_finish_bad_args()
{
psa_algorithm_t alg = PSA_ALG_SHA_256;
unsigned char hash[PSA_HASH_MAX_SIZE];
- size_t expected_size = PSA_HASH_LENGTH( alg );
+ size_t expected_size = PSA_HASH_LENGTH(alg);
psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
size_t hash_len;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* psa_hash_finish with a smaller hash buffer than expected */
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
- TEST_EQUAL( psa_hash_finish( &operation,
- hash, expected_size - 1, &hash_len ),
- PSA_ERROR_BUFFER_TOO_SMALL );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
+ TEST_EQUAL(psa_hash_finish(&operation,
+ hash, expected_size - 1, &hash_len),
+ PSA_ERROR_BUFFER_TOO_SMALL);
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
-void hash_clone_source_state( )
+void hash_clone_source_state()
{
psa_algorithm_t alg = PSA_ALG_SHA_256;
unsigned char hash[PSA_HASH_MAX_SIZE];
@@ -1844,41 +1869,41 @@
psa_hash_operation_t op_aborted = PSA_HASH_OPERATION_INIT;
size_t hash_len;
- PSA_ASSERT( psa_crypto_init( ) );
- PSA_ASSERT( psa_hash_setup( &op_source, alg ) );
+ PSA_ASSERT(psa_crypto_init());
+ PSA_ASSERT(psa_hash_setup(&op_source, alg));
- PSA_ASSERT( psa_hash_setup( &op_setup, alg ) );
- PSA_ASSERT( psa_hash_setup( &op_finished, alg ) );
- PSA_ASSERT( psa_hash_finish( &op_finished,
- hash, sizeof( hash ), &hash_len ) );
- PSA_ASSERT( psa_hash_setup( &op_aborted, alg ) );
- PSA_ASSERT( psa_hash_abort( &op_aborted ) );
+ PSA_ASSERT(psa_hash_setup(&op_setup, alg));
+ PSA_ASSERT(psa_hash_setup(&op_finished, alg));
+ PSA_ASSERT(psa_hash_finish(&op_finished,
+ hash, sizeof(hash), &hash_len));
+ PSA_ASSERT(psa_hash_setup(&op_aborted, alg));
+ PSA_ASSERT(psa_hash_abort(&op_aborted));
- TEST_EQUAL( psa_hash_clone( &op_source, &op_setup ),
- PSA_ERROR_BAD_STATE );
+ TEST_EQUAL(psa_hash_clone(&op_source, &op_setup),
+ PSA_ERROR_BAD_STATE);
- PSA_ASSERT( psa_hash_clone( &op_source, &op_init ) );
- PSA_ASSERT( psa_hash_finish( &op_init,
- hash, sizeof( hash ), &hash_len ) );
- PSA_ASSERT( psa_hash_clone( &op_source, &op_finished ) );
- PSA_ASSERT( psa_hash_finish( &op_finished,
- hash, sizeof( hash ), &hash_len ) );
- PSA_ASSERT( psa_hash_clone( &op_source, &op_aborted ) );
- PSA_ASSERT( psa_hash_finish( &op_aborted,
- hash, sizeof( hash ), &hash_len ) );
+ PSA_ASSERT(psa_hash_clone(&op_source, &op_init));
+ PSA_ASSERT(psa_hash_finish(&op_init,
+ hash, sizeof(hash), &hash_len));
+ PSA_ASSERT(psa_hash_clone(&op_source, &op_finished));
+ PSA_ASSERT(psa_hash_finish(&op_finished,
+ hash, sizeof(hash), &hash_len));
+ PSA_ASSERT(psa_hash_clone(&op_source, &op_aborted));
+ PSA_ASSERT(psa_hash_finish(&op_aborted,
+ hash, sizeof(hash), &hash_len));
exit:
- psa_hash_abort( &op_source );
- psa_hash_abort( &op_init );
- psa_hash_abort( &op_setup );
- psa_hash_abort( &op_finished );
- psa_hash_abort( &op_aborted );
- PSA_DONE( );
+ psa_hash_abort(&op_source);
+ psa_hash_abort(&op_init);
+ psa_hash_abort(&op_setup);
+ psa_hash_abort(&op_finished);
+ psa_hash_abort(&op_aborted);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:PSA_WANT_ALG_SHA_256 */
-void hash_clone_target_state( )
+void hash_clone_target_state()
{
psa_algorithm_t alg = PSA_ALG_SHA_256;
unsigned char hash[PSA_HASH_MAX_SIZE];
@@ -1889,37 +1914,37 @@
psa_hash_operation_t op_target = PSA_HASH_OPERATION_INIT;
size_t hash_len;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- PSA_ASSERT( psa_hash_setup( &op_setup, alg ) );
- PSA_ASSERT( psa_hash_setup( &op_finished, alg ) );
- PSA_ASSERT( psa_hash_finish( &op_finished,
- hash, sizeof( hash ), &hash_len ) );
- PSA_ASSERT( psa_hash_setup( &op_aborted, alg ) );
- PSA_ASSERT( psa_hash_abort( &op_aborted ) );
+ PSA_ASSERT(psa_hash_setup(&op_setup, alg));
+ PSA_ASSERT(psa_hash_setup(&op_finished, alg));
+ PSA_ASSERT(psa_hash_finish(&op_finished,
+ hash, sizeof(hash), &hash_len));
+ PSA_ASSERT(psa_hash_setup(&op_aborted, alg));
+ PSA_ASSERT(psa_hash_abort(&op_aborted));
- PSA_ASSERT( psa_hash_clone( &op_setup, &op_target ) );
- PSA_ASSERT( psa_hash_finish( &op_target,
- hash, sizeof( hash ), &hash_len ) );
+ PSA_ASSERT(psa_hash_clone(&op_setup, &op_target));
+ PSA_ASSERT(psa_hash_finish(&op_target,
+ hash, sizeof(hash), &hash_len));
- TEST_EQUAL( psa_hash_clone( &op_init, &op_target ), PSA_ERROR_BAD_STATE );
- TEST_EQUAL( psa_hash_clone( &op_finished, &op_target ),
- PSA_ERROR_BAD_STATE );
- TEST_EQUAL( psa_hash_clone( &op_aborted, &op_target ),
- PSA_ERROR_BAD_STATE );
+ TEST_EQUAL(psa_hash_clone(&op_init, &op_target), PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(psa_hash_clone(&op_finished, &op_target),
+ PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(psa_hash_clone(&op_aborted, &op_target),
+ PSA_ERROR_BAD_STATE);
exit:
- psa_hash_abort( &op_target );
- psa_hash_abort( &op_init );
- psa_hash_abort( &op_setup );
- psa_hash_abort( &op_finished );
- psa_hash_abort( &op_aborted );
- PSA_DONE( );
+ psa_hash_abort(&op_target);
+ psa_hash_abort(&op_init);
+ psa_hash_abort(&op_setup);
+ psa_hash_abort(&op_finished);
+ psa_hash_abort(&op_aborted);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void mac_operation_init( )
+void mac_operation_init()
{
const uint8_t input[1] = { 0 };
@@ -1927,35 +1952,35 @@
* Clang 5 complains when `-Wmissing-field-initializers` is used, even
* though it's OK by the C standard. We could test for this, but we'd need
* to suppress the Clang warning for the test. */
- psa_mac_operation_t func = psa_mac_operation_init( );
+ psa_mac_operation_t func = psa_mac_operation_init();
psa_mac_operation_t init = PSA_MAC_OPERATION_INIT;
psa_mac_operation_t zero;
- memset( &zero, 0, sizeof( zero ) );
+ memset(&zero, 0, sizeof(zero));
/* A freshly-initialized MAC operation should not be usable. */
- TEST_EQUAL( psa_mac_update( &func,
- input, sizeof( input ) ),
- PSA_ERROR_BAD_STATE );
- TEST_EQUAL( psa_mac_update( &init,
- input, sizeof( input ) ),
- PSA_ERROR_BAD_STATE );
- TEST_EQUAL( psa_mac_update( &zero,
- input, sizeof( input ) ),
- PSA_ERROR_BAD_STATE );
+ TEST_EQUAL(psa_mac_update(&func,
+ input, sizeof(input)),
+ PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(psa_mac_update(&init,
+ input, sizeof(input)),
+ PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(psa_mac_update(&zero,
+ input, sizeof(input)),
+ PSA_ERROR_BAD_STATE);
/* A default MAC operation should be abortable without error. */
- PSA_ASSERT( psa_mac_abort( &func ) );
- PSA_ASSERT( psa_mac_abort( &init ) );
- PSA_ASSERT( psa_mac_abort( &zero ) );
+ PSA_ASSERT(psa_mac_abort(&func));
+ PSA_ASSERT(psa_mac_abort(&init));
+ PSA_ASSERT(psa_mac_abort(&zero));
}
/* END_CASE */
/* BEGIN_CASE */
-void mac_setup( int key_type_arg,
- data_t *key,
- int alg_arg,
- int expected_status_arg )
+void mac_setup(int key_type_arg,
+ data_t *key,
+ int alg_arg,
+ int expected_status_arg)
{
psa_key_type_t key_type = key_type_arg;
psa_algorithm_t alg = alg_arg;
@@ -1966,31 +1991,33 @@
const uint8_t smoke_test_key_data[16] = "kkkkkkkkkkkkkkkk";
#endif
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- if( ! exercise_mac_setup( key_type, key->x, key->len, alg,
- &operation, &status ) )
+ if (!exercise_mac_setup(key_type, key->x, key->len, alg,
+ &operation, &status)) {
goto exit;
- TEST_EQUAL( status, expected_status );
+ }
+ TEST_EQUAL(status, expected_status);
/* The operation object should be reusable. */
#if defined(KNOWN_SUPPORTED_MAC_ALG)
- if( ! exercise_mac_setup( KNOWN_SUPPORTED_MAC_KEY_TYPE,
- smoke_test_key_data,
- sizeof( smoke_test_key_data ),
- KNOWN_SUPPORTED_MAC_ALG,
- &operation, &status ) )
+ if (!exercise_mac_setup(KNOWN_SUPPORTED_MAC_KEY_TYPE,
+ smoke_test_key_data,
+ sizeof(smoke_test_key_data),
+ KNOWN_SUPPORTED_MAC_ALG,
+ &operation, &status)) {
goto exit;
- TEST_EQUAL( status, PSA_SUCCESS );
+ }
+ TEST_EQUAL(status, PSA_SUCCESS);
#endif
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:PSA_WANT_KEY_TYPE_HMAC:PSA_WANT_ALG_HMAC:PSA_WANT_ALG_SHA_256 */
-void mac_bad_order( )
+void mac_bad_order()
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = PSA_KEY_TYPE_HMAC;
@@ -1998,7 +2025,8 @@
const uint8_t key_data[] = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
- 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa };
+ 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa
+ };
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
uint8_t sign_mac[PSA_MAC_MAX_SIZE + 10] = { 0 };
@@ -2007,119 +2035,120 @@
const uint8_t verify_mac[] = {
0x74, 0x65, 0x93, 0x8c, 0xeb, 0x1d, 0xb3, 0x76, 0x5a, 0x38, 0xe7, 0xdd,
0x85, 0xc5, 0xad, 0x4f, 0x07, 0xe7, 0xd5, 0xb2, 0x64, 0xf0, 0x1a, 0x1a,
- 0x2c, 0xf9, 0x18, 0xca, 0x59, 0x7e, 0x5d, 0xf6 };
+ 0x2c, 0xf9, 0x18, 0xca, 0x59, 0x7e, 0x5d, 0xf6
+ };
- PSA_ASSERT( psa_crypto_init( ) );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ PSA_ASSERT(psa_crypto_init());
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data, sizeof( key_data ),
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data, sizeof(key_data),
+ &key));
/* Call update without calling setup beforehand. */
- TEST_EQUAL( psa_mac_update( &operation, input, sizeof( input ) ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_mac_abort( &operation ) );
+ TEST_EQUAL(psa_mac_update(&operation, input, sizeof(input)),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_mac_abort(&operation));
/* Call sign finish without calling setup beforehand. */
- TEST_EQUAL( psa_mac_sign_finish( &operation, sign_mac, sizeof( sign_mac ),
- &sign_mac_length),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_mac_abort( &operation ) );
+ TEST_EQUAL(psa_mac_sign_finish(&operation, sign_mac, sizeof(sign_mac),
+ &sign_mac_length),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_mac_abort(&operation));
/* Call verify finish without calling setup beforehand. */
- TEST_EQUAL( psa_mac_verify_finish( &operation,
- verify_mac, sizeof( verify_mac ) ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_mac_abort( &operation ) );
+ TEST_EQUAL(psa_mac_verify_finish(&operation,
+ verify_mac, sizeof(verify_mac)),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_mac_abort(&operation));
/* Call setup twice in a row. */
- PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
- ASSERT_OPERATION_IS_ACTIVE( operation );
- TEST_EQUAL( psa_mac_sign_setup( &operation, key, alg ),
- PSA_ERROR_BAD_STATE );
- ASSERT_OPERATION_IS_INACTIVE( operation );
- PSA_ASSERT( psa_mac_abort( &operation ) );
- ASSERT_OPERATION_IS_INACTIVE( operation );
+ PSA_ASSERT(psa_mac_sign_setup(&operation, key, alg));
+ ASSERT_OPERATION_IS_ACTIVE(operation);
+ TEST_EQUAL(psa_mac_sign_setup(&operation, key, alg),
+ PSA_ERROR_BAD_STATE);
+ ASSERT_OPERATION_IS_INACTIVE(operation);
+ PSA_ASSERT(psa_mac_abort(&operation));
+ ASSERT_OPERATION_IS_INACTIVE(operation);
/* Call update after sign finish. */
- PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
- PSA_ASSERT( psa_mac_sign_finish( &operation,
- sign_mac, sizeof( sign_mac ),
- &sign_mac_length ) );
- TEST_EQUAL( psa_mac_update( &operation, input, sizeof( input ) ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_mac_abort( &operation ) );
+ PSA_ASSERT(psa_mac_sign_setup(&operation, key, alg));
+ PSA_ASSERT(psa_mac_update(&operation, input, sizeof(input)));
+ PSA_ASSERT(psa_mac_sign_finish(&operation,
+ sign_mac, sizeof(sign_mac),
+ &sign_mac_length));
+ TEST_EQUAL(psa_mac_update(&operation, input, sizeof(input)),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_mac_abort(&operation));
/* Call update after verify finish. */
- PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
- PSA_ASSERT( psa_mac_verify_finish( &operation,
- verify_mac, sizeof( verify_mac ) ) );
- TEST_EQUAL( psa_mac_update( &operation, input, sizeof( input ) ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_mac_abort( &operation ) );
+ PSA_ASSERT(psa_mac_verify_setup(&operation, key, alg));
+ PSA_ASSERT(psa_mac_update(&operation, input, sizeof(input)));
+ PSA_ASSERT(psa_mac_verify_finish(&operation,
+ verify_mac, sizeof(verify_mac)));
+ TEST_EQUAL(psa_mac_update(&operation, input, sizeof(input)),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_mac_abort(&operation));
/* Call sign finish twice in a row. */
- PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
- PSA_ASSERT( psa_mac_sign_finish( &operation,
- sign_mac, sizeof( sign_mac ),
- &sign_mac_length ) );
- TEST_EQUAL( psa_mac_sign_finish( &operation,
- sign_mac, sizeof( sign_mac ),
- &sign_mac_length ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_mac_abort( &operation ) );
+ PSA_ASSERT(psa_mac_sign_setup(&operation, key, alg));
+ PSA_ASSERT(psa_mac_update(&operation, input, sizeof(input)));
+ PSA_ASSERT(psa_mac_sign_finish(&operation,
+ sign_mac, sizeof(sign_mac),
+ &sign_mac_length));
+ TEST_EQUAL(psa_mac_sign_finish(&operation,
+ sign_mac, sizeof(sign_mac),
+ &sign_mac_length),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_mac_abort(&operation));
/* Call verify finish twice in a row. */
- PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
- PSA_ASSERT( psa_mac_verify_finish( &operation,
- verify_mac, sizeof( verify_mac ) ) );
- TEST_EQUAL( psa_mac_verify_finish( &operation,
- verify_mac, sizeof( verify_mac ) ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_mac_abort( &operation ) );
+ PSA_ASSERT(psa_mac_verify_setup(&operation, key, alg));
+ PSA_ASSERT(psa_mac_update(&operation, input, sizeof(input)));
+ PSA_ASSERT(psa_mac_verify_finish(&operation,
+ verify_mac, sizeof(verify_mac)));
+ TEST_EQUAL(psa_mac_verify_finish(&operation,
+ verify_mac, sizeof(verify_mac)),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_mac_abort(&operation));
/* Setup sign but try verify. */
- PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
- ASSERT_OPERATION_IS_ACTIVE( operation );
- TEST_EQUAL( psa_mac_verify_finish( &operation,
- verify_mac, sizeof( verify_mac ) ),
- PSA_ERROR_BAD_STATE );
- ASSERT_OPERATION_IS_INACTIVE( operation );
- PSA_ASSERT( psa_mac_abort( &operation ) );
- ASSERT_OPERATION_IS_INACTIVE( operation );
+ PSA_ASSERT(psa_mac_sign_setup(&operation, key, alg));
+ PSA_ASSERT(psa_mac_update(&operation, input, sizeof(input)));
+ ASSERT_OPERATION_IS_ACTIVE(operation);
+ TEST_EQUAL(psa_mac_verify_finish(&operation,
+ verify_mac, sizeof(verify_mac)),
+ PSA_ERROR_BAD_STATE);
+ ASSERT_OPERATION_IS_INACTIVE(operation);
+ PSA_ASSERT(psa_mac_abort(&operation));
+ ASSERT_OPERATION_IS_INACTIVE(operation);
/* Setup verify but try sign. */
- PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_mac_update( &operation, input, sizeof( input ) ) );
- ASSERT_OPERATION_IS_ACTIVE( operation );
- TEST_EQUAL( psa_mac_sign_finish( &operation,
- sign_mac, sizeof( sign_mac ),
- &sign_mac_length ),
- PSA_ERROR_BAD_STATE );
- ASSERT_OPERATION_IS_INACTIVE( operation );
- PSA_ASSERT( psa_mac_abort( &operation ) );
- ASSERT_OPERATION_IS_INACTIVE( operation );
+ PSA_ASSERT(psa_mac_verify_setup(&operation, key, alg));
+ PSA_ASSERT(psa_mac_update(&operation, input, sizeof(input)));
+ ASSERT_OPERATION_IS_ACTIVE(operation);
+ TEST_EQUAL(psa_mac_sign_finish(&operation,
+ sign_mac, sizeof(sign_mac),
+ &sign_mac_length),
+ PSA_ERROR_BAD_STATE);
+ ASSERT_OPERATION_IS_INACTIVE(operation);
+ PSA_ASSERT(psa_mac_abort(&operation));
+ ASSERT_OPERATION_IS_INACTIVE(operation);
- PSA_ASSERT( psa_destroy_key( key ) );
+ PSA_ASSERT(psa_destroy_key(key));
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void mac_sign( int key_type_arg,
- data_t *key_data,
- int alg_arg,
- data_t *input,
- data_t *expected_mac )
+void mac_sign(int key_type_arg,
+ data_t *key_data,
+ int alg_arg,
+ data_t *input,
+ data_t *expected_mac)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -2128,7 +2157,7 @@
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
uint8_t *actual_mac = NULL;
size_t mac_buffer_size =
- PSA_MAC_LENGTH( key_type, PSA_BYTES_TO_BITS( key_data->len ), alg );
+ PSA_MAC_LENGTH(key_type, PSA_BYTES_TO_BITS(key_data->len), alg);
size_t mac_length = 0;
const size_t output_sizes_to_test[] = {
0,
@@ -2138,76 +2167,74 @@
expected_mac->len + 1,
};
- TEST_LE_U( mac_buffer_size, PSA_MAC_MAX_SIZE );
+ TEST_LE_U(mac_buffer_size, PSA_MAC_MAX_SIZE);
/* We expect PSA_MAC_LENGTH to be exact. */
- TEST_ASSERT( expected_mac->len == mac_buffer_size );
+ TEST_ASSERT(expected_mac->len == mac_buffer_size);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- for( size_t i = 0; i < ARRAY_LENGTH( output_sizes_to_test ); i++ )
- {
+ for (size_t i = 0; i < ARRAY_LENGTH(output_sizes_to_test); i++) {
const size_t output_size = output_sizes_to_test[i];
psa_status_t expected_status =
- ( output_size >= expected_mac->len ? PSA_SUCCESS :
- PSA_ERROR_BUFFER_TOO_SMALL );
+ (output_size >= expected_mac->len ? PSA_SUCCESS :
+ PSA_ERROR_BUFFER_TOO_SMALL);
- mbedtls_test_set_step( output_size );
- ASSERT_ALLOC( actual_mac, output_size );
+ mbedtls_test_set_step(output_size);
+ ASSERT_ALLOC(actual_mac, output_size);
/* Calculate the MAC, one-shot case. */
- TEST_EQUAL( psa_mac_compute( key, alg,
- input->x, input->len,
- actual_mac, output_size, &mac_length ),
- expected_status );
- if( expected_status == PSA_SUCCESS )
- {
- ASSERT_COMPARE( expected_mac->x, expected_mac->len,
- actual_mac, mac_length );
+ TEST_EQUAL(psa_mac_compute(key, alg,
+ input->x, input->len,
+ actual_mac, output_size, &mac_length),
+ expected_status);
+ if (expected_status == PSA_SUCCESS) {
+ ASSERT_COMPARE(expected_mac->x, expected_mac->len,
+ actual_mac, mac_length);
}
- if( output_size > 0 )
- memset( actual_mac, 0, output_size );
+ if (output_size > 0) {
+ memset(actual_mac, 0, output_size);
+ }
/* Calculate the MAC, multi-part case. */
- PSA_ASSERT( psa_mac_sign_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_mac_update( &operation,
- input->x, input->len ) );
- TEST_EQUAL( psa_mac_sign_finish( &operation,
- actual_mac, output_size,
- &mac_length ),
- expected_status );
- PSA_ASSERT( psa_mac_abort( &operation ) );
+ PSA_ASSERT(psa_mac_sign_setup(&operation, key, alg));
+ PSA_ASSERT(psa_mac_update(&operation,
+ input->x, input->len));
+ TEST_EQUAL(psa_mac_sign_finish(&operation,
+ actual_mac, output_size,
+ &mac_length),
+ expected_status);
+ PSA_ASSERT(psa_mac_abort(&operation));
- if( expected_status == PSA_SUCCESS )
- {
- ASSERT_COMPARE( expected_mac->x, expected_mac->len,
- actual_mac, mac_length );
+ if (expected_status == PSA_SUCCESS) {
+ ASSERT_COMPARE(expected_mac->x, expected_mac->len,
+ actual_mac, mac_length);
}
- mbedtls_free( actual_mac );
+ mbedtls_free(actual_mac);
actual_mac = NULL;
}
exit:
- psa_mac_abort( &operation );
- psa_destroy_key( key );
- PSA_DONE( );
- mbedtls_free( actual_mac );
+ psa_mac_abort(&operation);
+ psa_destroy_key(key);
+ PSA_DONE();
+ mbedtls_free(actual_mac);
}
/* END_CASE */
/* BEGIN_CASE */
-void mac_verify( int key_type_arg,
- data_t *key_data,
- int alg_arg,
- data_t *input,
- data_t *expected_mac )
+void mac_verify(int key_type_arg,
+ data_t *key_data,
+ int alg_arg,
+ data_t *input,
+ data_t *expected_mac)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -2216,93 +2243,92 @@
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
uint8_t *perturbed_mac = NULL;
- TEST_LE_U( expected_mac->len, PSA_MAC_MAX_SIZE );
+ TEST_LE_U(expected_mac->len, PSA_MAC_MAX_SIZE);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
/* Verify correct MAC, one-shot case. */
- PSA_ASSERT( psa_mac_verify( key, alg, input->x, input->len,
- expected_mac->x, expected_mac->len ) );
+ PSA_ASSERT(psa_mac_verify(key, alg, input->x, input->len,
+ expected_mac->x, expected_mac->len));
/* Verify correct MAC, multi-part case. */
- PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_mac_update( &operation,
- input->x, input->len ) );
- PSA_ASSERT( psa_mac_verify_finish( &operation,
- expected_mac->x,
- expected_mac->len ) );
+ PSA_ASSERT(psa_mac_verify_setup(&operation, key, alg));
+ PSA_ASSERT(psa_mac_update(&operation,
+ input->x, input->len));
+ PSA_ASSERT(psa_mac_verify_finish(&operation,
+ expected_mac->x,
+ expected_mac->len));
/* Test a MAC that's too short, one-shot case. */
- TEST_EQUAL( psa_mac_verify( key, alg,
- input->x, input->len,
- expected_mac->x,
- expected_mac->len - 1 ),
- PSA_ERROR_INVALID_SIGNATURE );
+ TEST_EQUAL(psa_mac_verify(key, alg,
+ input->x, input->len,
+ expected_mac->x,
+ expected_mac->len - 1),
+ PSA_ERROR_INVALID_SIGNATURE);
/* Test a MAC that's too short, multi-part case. */
- PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_mac_update( &operation,
- input->x, input->len ) );
- TEST_EQUAL( psa_mac_verify_finish( &operation,
- expected_mac->x,
- expected_mac->len - 1 ),
- PSA_ERROR_INVALID_SIGNATURE );
+ PSA_ASSERT(psa_mac_verify_setup(&operation, key, alg));
+ PSA_ASSERT(psa_mac_update(&operation,
+ input->x, input->len));
+ TEST_EQUAL(psa_mac_verify_finish(&operation,
+ expected_mac->x,
+ expected_mac->len - 1),
+ PSA_ERROR_INVALID_SIGNATURE);
/* Test a MAC that's too long, one-shot case. */
- ASSERT_ALLOC( 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,
- perturbed_mac, expected_mac->len + 1 ),
- PSA_ERROR_INVALID_SIGNATURE );
+ ASSERT_ALLOC(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,
+ perturbed_mac, expected_mac->len + 1),
+ PSA_ERROR_INVALID_SIGNATURE);
/* Test a MAC that's too long, multi-part case. */
- PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_mac_update( &operation,
- input->x, input->len ) );
- TEST_EQUAL( psa_mac_verify_finish( &operation,
- perturbed_mac,
- expected_mac->len + 1 ),
- PSA_ERROR_INVALID_SIGNATURE );
+ PSA_ASSERT(psa_mac_verify_setup(&operation, key, alg));
+ PSA_ASSERT(psa_mac_update(&operation,
+ input->x, input->len));
+ TEST_EQUAL(psa_mac_verify_finish(&operation,
+ perturbed_mac,
+ expected_mac->len + 1),
+ PSA_ERROR_INVALID_SIGNATURE);
/* Test changing one byte. */
- for( size_t i = 0; i < expected_mac->len; i++ )
- {
- mbedtls_test_set_step( i );
+ for (size_t i = 0; i < expected_mac->len; i++) {
+ mbedtls_test_set_step(i);
perturbed_mac[i] ^= 1;
- TEST_EQUAL( psa_mac_verify( key, alg,
- input->x, input->len,
- perturbed_mac, expected_mac->len ),
- PSA_ERROR_INVALID_SIGNATURE );
+ TEST_EQUAL(psa_mac_verify(key, alg,
+ input->x, input->len,
+ perturbed_mac, expected_mac->len),
+ PSA_ERROR_INVALID_SIGNATURE);
- PSA_ASSERT( psa_mac_verify_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_mac_update( &operation,
- input->x, input->len ) );
- TEST_EQUAL( psa_mac_verify_finish( &operation,
- perturbed_mac,
- expected_mac->len ),
- PSA_ERROR_INVALID_SIGNATURE );
+ PSA_ASSERT(psa_mac_verify_setup(&operation, key, alg));
+ PSA_ASSERT(psa_mac_update(&operation,
+ input->x, input->len));
+ TEST_EQUAL(psa_mac_verify_finish(&operation,
+ perturbed_mac,
+ expected_mac->len),
+ PSA_ERROR_INVALID_SIGNATURE);
perturbed_mac[i] ^= 1;
}
exit:
- psa_mac_abort( &operation );
- psa_destroy_key( key );
- PSA_DONE( );
- mbedtls_free( perturbed_mac );
+ psa_mac_abort(&operation);
+ psa_destroy_key(key);
+ PSA_DONE();
+ mbedtls_free(perturbed_mac);
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_operation_init( )
+void cipher_operation_init()
{
const uint8_t input[1] = { 0 };
unsigned char output[1] = { 0 };
@@ -2311,41 +2337,41 @@
* Clang 5 complains when `-Wmissing-field-initializers` is used, even
* though it's OK by the C standard. We could test for this, but we'd need
* to suppress the Clang warning for the test. */
- psa_cipher_operation_t func = psa_cipher_operation_init( );
+ psa_cipher_operation_t func = psa_cipher_operation_init();
psa_cipher_operation_t init = PSA_CIPHER_OPERATION_INIT;
psa_cipher_operation_t zero;
- memset( &zero, 0, sizeof( zero ) );
+ memset(&zero, 0, sizeof(zero));
/* A freshly-initialized cipher operation should not be usable. */
- TEST_EQUAL( psa_cipher_update( &func,
- input, sizeof( input ),
- output, sizeof( output ),
- &output_length ),
- PSA_ERROR_BAD_STATE );
- TEST_EQUAL( psa_cipher_update( &init,
- input, sizeof( input ),
- output, sizeof( output ),
- &output_length ),
- PSA_ERROR_BAD_STATE );
- TEST_EQUAL( psa_cipher_update( &zero,
- input, sizeof( input ),
- output, sizeof( output ),
- &output_length ),
- PSA_ERROR_BAD_STATE );
+ TEST_EQUAL(psa_cipher_update(&func,
+ input, sizeof(input),
+ output, sizeof(output),
+ &output_length),
+ PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(psa_cipher_update(&init,
+ input, sizeof(input),
+ output, sizeof(output),
+ &output_length),
+ PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(psa_cipher_update(&zero,
+ input, sizeof(input),
+ output, sizeof(output),
+ &output_length),
+ PSA_ERROR_BAD_STATE);
/* A default cipher operation should be abortable without error. */
- PSA_ASSERT( psa_cipher_abort( &func ) );
- PSA_ASSERT( psa_cipher_abort( &init ) );
- PSA_ASSERT( psa_cipher_abort( &zero ) );
+ PSA_ASSERT(psa_cipher_abort(&func));
+ PSA_ASSERT(psa_cipher_abort(&init));
+ PSA_ASSERT(psa_cipher_abort(&zero));
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_setup( int key_type_arg,
- data_t *key,
- int alg_arg,
- int expected_status_arg )
+void cipher_setup(int key_type_arg,
+ data_t *key,
+ int alg_arg,
+ int expected_status_arg)
{
psa_key_type_t key_type = key_type_arg;
psa_algorithm_t alg = alg_arg;
@@ -2356,32 +2382,34 @@
const uint8_t smoke_test_key_data[16] = "kkkkkkkkkkkkkkkk";
#endif
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- if( ! exercise_cipher_setup( key_type, key->x, key->len, alg,
- &operation, &status ) )
+ if (!exercise_cipher_setup(key_type, key->x, key->len, alg,
+ &operation, &status)) {
goto exit;
- TEST_EQUAL( status, expected_status );
+ }
+ TEST_EQUAL(status, expected_status);
/* The operation object should be reusable. */
#if defined(KNOWN_SUPPORTED_CIPHER_ALG)
- if( ! exercise_cipher_setup( KNOWN_SUPPORTED_CIPHER_KEY_TYPE,
- smoke_test_key_data,
- sizeof( smoke_test_key_data ),
- KNOWN_SUPPORTED_CIPHER_ALG,
- &operation, &status ) )
+ if (!exercise_cipher_setup(KNOWN_SUPPORTED_CIPHER_KEY_TYPE,
+ smoke_test_key_data,
+ sizeof(smoke_test_key_data),
+ KNOWN_SUPPORTED_CIPHER_ALG,
+ &operation, &status)) {
goto exit;
- TEST_EQUAL( status, PSA_SUCCESS );
+ }
+ TEST_EQUAL(status, PSA_SUCCESS);
#endif
exit:
- psa_cipher_abort( &operation );
- PSA_DONE( );
+ psa_cipher_abort(&operation);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:PSA_WANT_KEY_TYPE_AES:PSA_WANT_ALG_CBC_PKCS7 */
-void cipher_bad_order( )
+void cipher_bad_order()
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = PSA_KEY_TYPE_AES;
@@ -2391,173 +2419,175 @@
unsigned char iv[PSA_BLOCK_CIPHER_BLOCK_LENGTH(PSA_KEY_TYPE_AES)] = { 0 };
const uint8_t key_data[] = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
- 0xaa, 0xaa, 0xaa, 0xaa };
+ 0xaa, 0xaa, 0xaa, 0xaa
+ };
const uint8_t text[] = {
0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
- 0xbb, 0xbb, 0xbb, 0xbb };
+ 0xbb, 0xbb, 0xbb, 0xbb
+ };
uint8_t buffer[PSA_BLOCK_CIPHER_BLOCK_LENGTH(PSA_KEY_TYPE_AES)] = { 0 };
size_t length = 0;
- PSA_ASSERT( psa_crypto_init( ) );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
- PSA_ASSERT( psa_import_key( &attributes, key_data, sizeof( key_data ),
- &key ) );
+ PSA_ASSERT(psa_crypto_init());
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
+ PSA_ASSERT(psa_import_key(&attributes, key_data, sizeof(key_data),
+ &key));
/* Call encrypt setup twice in a row. */
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
- ASSERT_OPERATION_IS_ACTIVE( operation );
- TEST_EQUAL( psa_cipher_encrypt_setup( &operation, key, alg ),
- PSA_ERROR_BAD_STATE );
- ASSERT_OPERATION_IS_INACTIVE( operation );
- PSA_ASSERT( psa_cipher_abort( &operation ) );
- ASSERT_OPERATION_IS_INACTIVE( operation );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
+ ASSERT_OPERATION_IS_ACTIVE(operation);
+ TEST_EQUAL(psa_cipher_encrypt_setup(&operation, key, alg),
+ PSA_ERROR_BAD_STATE);
+ ASSERT_OPERATION_IS_INACTIVE(operation);
+ PSA_ASSERT(psa_cipher_abort(&operation));
+ ASSERT_OPERATION_IS_INACTIVE(operation);
/* Call decrypt setup twice in a row. */
- PSA_ASSERT( psa_cipher_decrypt_setup( &operation, key, alg ) );
- ASSERT_OPERATION_IS_ACTIVE( operation );
- TEST_EQUAL( psa_cipher_decrypt_setup( &operation, key, alg ),
- PSA_ERROR_BAD_STATE );
- ASSERT_OPERATION_IS_INACTIVE( operation );
- PSA_ASSERT( psa_cipher_abort( &operation ) );
- ASSERT_OPERATION_IS_INACTIVE( operation );
+ PSA_ASSERT(psa_cipher_decrypt_setup(&operation, key, alg));
+ ASSERT_OPERATION_IS_ACTIVE(operation);
+ TEST_EQUAL(psa_cipher_decrypt_setup(&operation, key, alg),
+ PSA_ERROR_BAD_STATE);
+ ASSERT_OPERATION_IS_INACTIVE(operation);
+ PSA_ASSERT(psa_cipher_abort(&operation));
+ ASSERT_OPERATION_IS_INACTIVE(operation);
/* Generate an IV without calling setup beforehand. */
- TEST_EQUAL( psa_cipher_generate_iv( &operation,
- buffer, sizeof( buffer ),
- &length ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_cipher_abort( &operation ) );
+ TEST_EQUAL(psa_cipher_generate_iv(&operation,
+ buffer, sizeof(buffer),
+ &length),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_cipher_abort(&operation));
/* Generate an IV twice in a row. */
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_cipher_generate_iv( &operation,
- buffer, sizeof( buffer ),
- &length ) );
- ASSERT_OPERATION_IS_ACTIVE( operation );
- TEST_EQUAL( psa_cipher_generate_iv( &operation,
- buffer, sizeof( buffer ),
- &length ),
- PSA_ERROR_BAD_STATE );
- ASSERT_OPERATION_IS_INACTIVE( operation );
- PSA_ASSERT( psa_cipher_abort( &operation ) );
- ASSERT_OPERATION_IS_INACTIVE( operation );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
+ PSA_ASSERT(psa_cipher_generate_iv(&operation,
+ buffer, sizeof(buffer),
+ &length));
+ ASSERT_OPERATION_IS_ACTIVE(operation);
+ TEST_EQUAL(psa_cipher_generate_iv(&operation,
+ buffer, sizeof(buffer),
+ &length),
+ PSA_ERROR_BAD_STATE);
+ ASSERT_OPERATION_IS_INACTIVE(operation);
+ PSA_ASSERT(psa_cipher_abort(&operation));
+ ASSERT_OPERATION_IS_INACTIVE(operation);
/* Generate an IV after it's already set. */
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_cipher_set_iv( &operation,
- iv, sizeof( iv ) ) );
- TEST_EQUAL( psa_cipher_generate_iv( &operation,
- buffer, sizeof( buffer ),
- &length ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_cipher_abort( &operation ) );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
+ PSA_ASSERT(psa_cipher_set_iv(&operation,
+ iv, sizeof(iv)));
+ TEST_EQUAL(psa_cipher_generate_iv(&operation,
+ buffer, sizeof(buffer),
+ &length),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_cipher_abort(&operation));
/* Set an IV without calling setup beforehand. */
- TEST_EQUAL( psa_cipher_set_iv( &operation,
- iv, sizeof( iv ) ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_cipher_abort( &operation ) );
+ TEST_EQUAL(psa_cipher_set_iv(&operation,
+ iv, sizeof(iv)),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_cipher_abort(&operation));
/* Set an IV after it's already set. */
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_cipher_set_iv( &operation,
- iv, sizeof( iv ) ) );
- ASSERT_OPERATION_IS_ACTIVE( operation );
- TEST_EQUAL( psa_cipher_set_iv( &operation,
- iv, sizeof( iv ) ),
- PSA_ERROR_BAD_STATE );
- ASSERT_OPERATION_IS_INACTIVE( operation );
- PSA_ASSERT( psa_cipher_abort( &operation ) );
- ASSERT_OPERATION_IS_INACTIVE( operation );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
+ PSA_ASSERT(psa_cipher_set_iv(&operation,
+ iv, sizeof(iv)));
+ ASSERT_OPERATION_IS_ACTIVE(operation);
+ TEST_EQUAL(psa_cipher_set_iv(&operation,
+ iv, sizeof(iv)),
+ PSA_ERROR_BAD_STATE);
+ ASSERT_OPERATION_IS_INACTIVE(operation);
+ PSA_ASSERT(psa_cipher_abort(&operation));
+ ASSERT_OPERATION_IS_INACTIVE(operation);
/* Set an IV after it's already generated. */
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_cipher_generate_iv( &operation,
- buffer, sizeof( buffer ),
- &length ) );
- TEST_EQUAL( psa_cipher_set_iv( &operation,
- iv, sizeof( iv ) ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_cipher_abort( &operation ) );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
+ PSA_ASSERT(psa_cipher_generate_iv(&operation,
+ buffer, sizeof(buffer),
+ &length));
+ TEST_EQUAL(psa_cipher_set_iv(&operation,
+ iv, sizeof(iv)),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_cipher_abort(&operation));
/* Call update without calling setup beforehand. */
- TEST_EQUAL( psa_cipher_update( &operation,
- text, sizeof( text ),
- buffer, sizeof( buffer ),
- &length ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_cipher_abort( &operation ) );
+ TEST_EQUAL(psa_cipher_update(&operation,
+ text, sizeof(text),
+ buffer, sizeof(buffer),
+ &length),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_cipher_abort(&operation));
/* Call update without an IV where an IV is required. */
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
- ASSERT_OPERATION_IS_ACTIVE( operation );
- TEST_EQUAL( psa_cipher_update( &operation,
- text, sizeof( text ),
- buffer, sizeof( buffer ),
- &length ),
- PSA_ERROR_BAD_STATE );
- ASSERT_OPERATION_IS_INACTIVE( operation );
- PSA_ASSERT( psa_cipher_abort( &operation ) );
- ASSERT_OPERATION_IS_INACTIVE( operation );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
+ ASSERT_OPERATION_IS_ACTIVE(operation);
+ TEST_EQUAL(psa_cipher_update(&operation,
+ text, sizeof(text),
+ buffer, sizeof(buffer),
+ &length),
+ PSA_ERROR_BAD_STATE);
+ ASSERT_OPERATION_IS_INACTIVE(operation);
+ PSA_ASSERT(psa_cipher_abort(&operation));
+ ASSERT_OPERATION_IS_INACTIVE(operation);
/* Call update after finish. */
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_cipher_set_iv( &operation,
- iv, sizeof( iv ) ) );
- PSA_ASSERT( psa_cipher_finish( &operation,
- buffer, sizeof( buffer ), &length ) );
- TEST_EQUAL( psa_cipher_update( &operation,
- text, sizeof( text ),
- buffer, sizeof( buffer ),
- &length ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_cipher_abort( &operation ) );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
+ PSA_ASSERT(psa_cipher_set_iv(&operation,
+ iv, sizeof(iv)));
+ PSA_ASSERT(psa_cipher_finish(&operation,
+ buffer, sizeof(buffer), &length));
+ TEST_EQUAL(psa_cipher_update(&operation,
+ text, sizeof(text),
+ buffer, sizeof(buffer),
+ &length),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_cipher_abort(&operation));
/* Call finish without calling setup beforehand. */
- TEST_EQUAL( psa_cipher_finish( &operation,
- buffer, sizeof( buffer ), &length ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_cipher_abort( &operation ) );
+ TEST_EQUAL(psa_cipher_finish(&operation,
+ buffer, sizeof(buffer), &length),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_cipher_abort(&operation));
/* Call finish without an IV where an IV is required. */
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
/* Not calling update means we are encrypting an empty buffer, which is OK
* for cipher modes with padding. */
- ASSERT_OPERATION_IS_ACTIVE( operation );
- TEST_EQUAL( psa_cipher_finish( &operation,
- buffer, sizeof( buffer ), &length ),
- PSA_ERROR_BAD_STATE );
- ASSERT_OPERATION_IS_INACTIVE( operation );
- PSA_ASSERT( psa_cipher_abort( &operation ) );
- ASSERT_OPERATION_IS_INACTIVE( operation );
+ ASSERT_OPERATION_IS_ACTIVE(operation);
+ TEST_EQUAL(psa_cipher_finish(&operation,
+ buffer, sizeof(buffer), &length),
+ PSA_ERROR_BAD_STATE);
+ ASSERT_OPERATION_IS_INACTIVE(operation);
+ PSA_ASSERT(psa_cipher_abort(&operation));
+ ASSERT_OPERATION_IS_INACTIVE(operation);
/* Call finish twice in a row. */
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_cipher_set_iv( &operation,
- iv, sizeof( iv ) ) );
- PSA_ASSERT( psa_cipher_finish( &operation,
- buffer, sizeof( buffer ), &length ) );
- TEST_EQUAL( psa_cipher_finish( &operation,
- buffer, sizeof( buffer ), &length ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_cipher_abort( &operation ) );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
+ PSA_ASSERT(psa_cipher_set_iv(&operation,
+ iv, sizeof(iv)));
+ PSA_ASSERT(psa_cipher_finish(&operation,
+ buffer, sizeof(buffer), &length));
+ TEST_EQUAL(psa_cipher_finish(&operation,
+ buffer, sizeof(buffer), &length),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_cipher_abort(&operation));
- PSA_ASSERT( psa_destroy_key( key ) );
+ PSA_ASSERT(psa_destroy_key(key));
exit:
- psa_cipher_abort( &operation );
- PSA_DONE( );
+ psa_cipher_abort(&operation);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_encrypt_fail( int alg_arg,
- int key_type_arg,
- data_t *key_data,
- data_t *input,
- int expected_status_arg )
+void cipher_encrypt_fail(int alg_arg,
+ int key_type_arg,
+ data_t *key_data,
+ data_t *input,
+ int expected_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_status_t status;
@@ -2569,37 +2599,36 @@
size_t output_length = 0;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- if ( PSA_ERROR_BAD_STATE != expected_status )
- {
- PSA_ASSERT( psa_crypto_init( ) );
+ if (PSA_ERROR_BAD_STATE != expected_status) {
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- output_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg,
- input->len );
- ASSERT_ALLOC( output, output_buffer_size );
+ output_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE(key_type, alg,
+ input->len);
+ ASSERT_ALLOC(output, output_buffer_size);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
}
- status = psa_cipher_encrypt( key, alg, input->x, input->len, output,
- output_buffer_size, &output_length );
+ status = psa_cipher_encrypt(key, alg, input->x, input->len, output,
+ output_buffer_size, &output_length);
- TEST_EQUAL( status, expected_status );
+ TEST_EQUAL(status, expected_status);
exit:
- mbedtls_free( output );
- psa_destroy_key( key );
- PSA_DONE( );
+ mbedtls_free(output);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_alg_without_iv( int alg_arg, int key_type_arg, data_t *key_data,
- data_t *plaintext, data_t *ciphertext )
+void cipher_alg_without_iv(int alg_arg, int key_type_arg, data_t *key_data,
+ data_t *plaintext, data_t *ciphertext)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -2611,110 +2640,110 @@
size_t output_length, length;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* Validate size macros */
- TEST_LE_U( ciphertext->len,
- PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, plaintext->len ) );
- TEST_LE_U( PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, plaintext->len ),
- PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE( plaintext->len ) );
- TEST_LE_U( plaintext->len,
- PSA_CIPHER_DECRYPT_OUTPUT_SIZE( key_type, alg, ciphertext->len ) );
- TEST_LE_U( PSA_CIPHER_DECRYPT_OUTPUT_SIZE( key_type, alg, ciphertext->len ),
- PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE( ciphertext->len ) );
+ TEST_LE_U(ciphertext->len,
+ PSA_CIPHER_ENCRYPT_OUTPUT_SIZE(key_type, alg, plaintext->len));
+ TEST_LE_U(PSA_CIPHER_ENCRYPT_OUTPUT_SIZE(key_type, alg, plaintext->len),
+ PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE(plaintext->len));
+ TEST_LE_U(plaintext->len,
+ PSA_CIPHER_DECRYPT_OUTPUT_SIZE(key_type, alg, ciphertext->len));
+ TEST_LE_U(PSA_CIPHER_DECRYPT_OUTPUT_SIZE(key_type, alg, ciphertext->len),
+ PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE(ciphertext->len));
/* Set up key and output buffer */
- psa_set_key_usage_flags( &attributes,
- PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
- output_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg,
- plaintext->len );
- ASSERT_ALLOC( output, output_buffer_size );
+ psa_set_key_usage_flags(&attributes,
+ PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+ output_buffer_size = PSA_CIPHER_ENCRYPT_OUTPUT_SIZE(key_type, alg,
+ plaintext->len);
+ ASSERT_ALLOC(output, output_buffer_size);
/* set_iv() is not allowed */
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
- TEST_EQUAL( psa_cipher_set_iv( &operation, iv, sizeof( iv ) ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_cipher_decrypt_setup( &operation, key, alg ) );
- TEST_EQUAL( psa_cipher_set_iv( &operation, iv, sizeof( iv ) ),
- PSA_ERROR_BAD_STATE );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
+ TEST_EQUAL(psa_cipher_set_iv(&operation, iv, sizeof(iv)),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_cipher_decrypt_setup(&operation, key, alg));
+ TEST_EQUAL(psa_cipher_set_iv(&operation, iv, sizeof(iv)),
+ PSA_ERROR_BAD_STATE);
/* generate_iv() is not allowed */
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
- TEST_EQUAL( psa_cipher_generate_iv( &operation, iv, sizeof( iv ),
- &length ),
- PSA_ERROR_BAD_STATE );
- PSA_ASSERT( psa_cipher_decrypt_setup( &operation, key, alg ) );
- TEST_EQUAL( psa_cipher_generate_iv( &operation, iv, sizeof( iv ),
- &length ),
- PSA_ERROR_BAD_STATE );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
+ TEST_EQUAL(psa_cipher_generate_iv(&operation, iv, sizeof(iv),
+ &length),
+ PSA_ERROR_BAD_STATE);
+ PSA_ASSERT(psa_cipher_decrypt_setup(&operation, key, alg));
+ TEST_EQUAL(psa_cipher_generate_iv(&operation, iv, sizeof(iv),
+ &length),
+ PSA_ERROR_BAD_STATE);
/* Multipart encryption */
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
output_length = 0;
length = ~0;
- PSA_ASSERT( psa_cipher_update( &operation,
- plaintext->x, plaintext->len,
- output, output_buffer_size,
- &length ) );
- TEST_LE_U( length, output_buffer_size );
+ PSA_ASSERT(psa_cipher_update(&operation,
+ plaintext->x, plaintext->len,
+ output, output_buffer_size,
+ &length));
+ TEST_LE_U(length, output_buffer_size);
output_length += length;
- PSA_ASSERT( psa_cipher_finish( &operation,
- mbedtls_buffer_offset( output, output_length ),
- output_buffer_size - output_length,
- &length ) );
+ PSA_ASSERT(psa_cipher_finish(&operation,
+ mbedtls_buffer_offset(output, output_length),
+ output_buffer_size - output_length,
+ &length));
output_length += length;
- ASSERT_COMPARE( ciphertext->x, ciphertext->len,
- output, output_length );
+ ASSERT_COMPARE(ciphertext->x, ciphertext->len,
+ output, output_length);
/* Multipart encryption */
- PSA_ASSERT( psa_cipher_decrypt_setup( &operation, key, alg ) );
+ PSA_ASSERT(psa_cipher_decrypt_setup(&operation, key, alg));
output_length = 0;
length = ~0;
- PSA_ASSERT( psa_cipher_update( &operation,
- ciphertext->x, ciphertext->len,
- output, output_buffer_size,
- &length ) );
- TEST_LE_U( length, output_buffer_size );
+ PSA_ASSERT(psa_cipher_update(&operation,
+ ciphertext->x, ciphertext->len,
+ output, output_buffer_size,
+ &length));
+ TEST_LE_U(length, output_buffer_size);
output_length += length;
- PSA_ASSERT( psa_cipher_finish( &operation,
- mbedtls_buffer_offset( output, output_length ),
- output_buffer_size - output_length,
- &length ) );
+ PSA_ASSERT(psa_cipher_finish(&operation,
+ mbedtls_buffer_offset(output, output_length),
+ output_buffer_size - output_length,
+ &length));
output_length += length;
- ASSERT_COMPARE( plaintext->x, plaintext->len,
- output, output_length );
+ ASSERT_COMPARE(plaintext->x, plaintext->len,
+ output, output_length);
/* One-shot encryption */
output_length = ~0;
- PSA_ASSERT( psa_cipher_encrypt( key, alg, plaintext->x, plaintext->len,
- output, output_buffer_size,
- &output_length ) );
- ASSERT_COMPARE( ciphertext->x, ciphertext->len,
- output, output_length );
+ PSA_ASSERT(psa_cipher_encrypt(key, alg, plaintext->x, plaintext->len,
+ output, output_buffer_size,
+ &output_length));
+ ASSERT_COMPARE(ciphertext->x, ciphertext->len,
+ output, output_length);
/* One-shot decryption */
output_length = ~0;
- PSA_ASSERT( psa_cipher_decrypt( key, alg, ciphertext->x, ciphertext->len,
- output, output_buffer_size,
- &output_length ) );
- ASSERT_COMPARE( plaintext->x, plaintext->len,
- output, output_length );
+ PSA_ASSERT(psa_cipher_decrypt(key, alg, ciphertext->x, ciphertext->len,
+ output, output_buffer_size,
+ &output_length));
+ ASSERT_COMPARE(plaintext->x, plaintext->len,
+ output, output_length);
exit:
- mbedtls_free( output );
- psa_cipher_abort( &operation );
- psa_destroy_key( key );
- PSA_DONE( );
+ mbedtls_free(output);
+ psa_cipher_abort(&operation);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_bad_key( int alg_arg, int key_type_arg, data_t *key_data )
+void cipher_bad_key(int alg_arg, int key_type_arg, data_t *key_data)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_algorithm_t alg = alg_arg;
@@ -2723,46 +2752,46 @@
psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
psa_status_t status;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
/* Usage of either of these two size macros would cause divide by zero
* with incorrect key types previously. Input length should be irrelevant
* here. */
- TEST_EQUAL( PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, 16 ),
- 0 );
- TEST_EQUAL( PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, 16 ), 0 );
+ TEST_EQUAL(PSA_CIPHER_ENCRYPT_OUTPUT_SIZE(key_type, alg, 16),
+ 0);
+ TEST_EQUAL(PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type, alg, 16), 0);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
/* Should fail due to invalid alg type (to support invalid key type).
* Encrypt or decrypt will end up in the same place. */
- status = psa_cipher_encrypt_setup( &operation, key, alg );
+ status = psa_cipher_encrypt_setup(&operation, key, alg);
- TEST_EQUAL( status, PSA_ERROR_INVALID_ARGUMENT );
+ TEST_EQUAL(status, PSA_ERROR_INVALID_ARGUMENT);
exit:
- psa_cipher_abort( &operation );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_cipher_abort(&operation);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_encrypt_validation( int alg_arg,
- int key_type_arg,
- data_t *key_data,
- data_t *input )
+void cipher_encrypt_validation(int alg_arg,
+ int key_type_arg,
+ data_t *key_data,
+ data_t *input)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
psa_algorithm_t alg = alg_arg;
- size_t iv_size = PSA_CIPHER_IV_LENGTH ( key_type, alg );
+ size_t iv_size = PSA_CIPHER_IV_LENGTH(key_type, alg);
unsigned char *output1 = NULL;
size_t output1_buffer_size = 0;
size_t output1_length = 0;
@@ -2773,74 +2802,74 @@
psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- 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 );
- ASSERT_ALLOC( output1, output1_buffer_size );
- ASSERT_ALLOC( output2, output2_buffer_size );
+ 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);
+ ASSERT_ALLOC(output1, output1_buffer_size);
+ ASSERT_ALLOC(output2, output2_buffer_size);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
/* The one-shot cipher encryption uses generated iv so validating
the output is not possible. Validating with multipart encryption. */
- PSA_ASSERT( psa_cipher_encrypt( key, alg, input->x, input->len, output1,
- output1_buffer_size, &output1_length ) );
- TEST_LE_U( output1_length,
- PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, input->len ) );
- TEST_LE_U( output1_length,
- PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE( input->len ) );
+ PSA_ASSERT(psa_cipher_encrypt(key, alg, input->x, input->len, output1,
+ output1_buffer_size, &output1_length));
+ TEST_LE_U(output1_length,
+ PSA_CIPHER_ENCRYPT_OUTPUT_SIZE(key_type, alg, input->len));
+ TEST_LE_U(output1_length,
+ PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE(input->len));
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
- PSA_ASSERT( psa_cipher_set_iv( &operation, output1, iv_size ) );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
+ PSA_ASSERT(psa_cipher_set_iv(&operation, output1, iv_size));
- PSA_ASSERT( psa_cipher_update( &operation,
- input->x, input->len,
- output2, output2_buffer_size,
- &function_output_length ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, input->len ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( input->len ) );
+ PSA_ASSERT(psa_cipher_update(&operation,
+ input->x, input->len,
+ output2, output2_buffer_size,
+ &function_output_length));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type, alg, input->len));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE(input->len));
output2_length += function_output_length;
- PSA_ASSERT( psa_cipher_finish( &operation,
- output2 + output2_length,
- output2_buffer_size - output2_length,
- &function_output_length ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
+ PSA_ASSERT(psa_cipher_finish(&operation,
+ output2 + output2_length,
+ output2_buffer_size - output2_length,
+ &function_output_length));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_FINISH_OUTPUT_SIZE(key_type, alg));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE);
output2_length += function_output_length;
- PSA_ASSERT( psa_cipher_abort( &operation ) );
- ASSERT_COMPARE( output1 + iv_size, output1_length - iv_size,
- output2, output2_length );
+ PSA_ASSERT(psa_cipher_abort(&operation));
+ ASSERT_COMPARE(output1 + iv_size, output1_length - iv_size,
+ output2, output2_length);
exit:
- psa_cipher_abort( &operation );
- mbedtls_free( output1 );
- mbedtls_free( output2 );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_cipher_abort(&operation);
+ mbedtls_free(output1);
+ mbedtls_free(output2);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_encrypt_multipart( int alg_arg, int key_type_arg,
- data_t *key_data, data_t *iv,
- data_t *input,
- int first_part_size_arg,
- int output1_length_arg, int output2_length_arg,
- data_t *expected_output,
- int expected_status_arg )
+void cipher_encrypt_multipart(int alg_arg, int key_type_arg,
+ data_t *key_data, data_t *iv,
+ data_t *input,
+ int first_part_size_arg,
+ int output1_length_arg, int output2_length_arg,
+ data_t *expected_output,
+ int expected_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -2857,92 +2886,89 @@
psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
- if( iv->len > 0 )
- {
- PSA_ASSERT( psa_cipher_set_iv( &operation, iv->x, iv->len ) );
+ if (iv->len > 0) {
+ PSA_ASSERT(psa_cipher_set_iv(&operation, iv->x, iv->len));
}
- output_buffer_size = PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, input->len ) +
- PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg );
- ASSERT_ALLOC( output, output_buffer_size );
+ output_buffer_size = PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type, alg, input->len) +
+ PSA_CIPHER_FINISH_OUTPUT_SIZE(key_type, alg);
+ ASSERT_ALLOC(output, output_buffer_size);
- TEST_LE_U( first_part_size, input->len );
- PSA_ASSERT( psa_cipher_update( &operation, input->x, first_part_size,
- output, output_buffer_size,
- &function_output_length ) );
- TEST_ASSERT( function_output_length == output1_length );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, first_part_size ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( first_part_size) );
+ TEST_LE_U(first_part_size, input->len);
+ PSA_ASSERT(psa_cipher_update(&operation, input->x, first_part_size,
+ output, output_buffer_size,
+ &function_output_length));
+ TEST_ASSERT(function_output_length == output1_length);
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type, alg, first_part_size));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE(first_part_size));
total_output_length += function_output_length;
- if( first_part_size < input->len )
- {
- PSA_ASSERT( psa_cipher_update( &operation,
- input->x + first_part_size,
- input->len - first_part_size,
- ( output_buffer_size == 0 ? NULL :
- output + total_output_length ),
- output_buffer_size - total_output_length,
- &function_output_length ) );
- TEST_ASSERT( function_output_length == output2_length );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type,
- alg,
- input->len - first_part_size ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( input->len ) );
+ if (first_part_size < input->len) {
+ PSA_ASSERT(psa_cipher_update(&operation,
+ input->x + first_part_size,
+ input->len - first_part_size,
+ (output_buffer_size == 0 ? NULL :
+ output + total_output_length),
+ output_buffer_size - total_output_length,
+ &function_output_length));
+ TEST_ASSERT(function_output_length == output2_length);
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type,
+ alg,
+ input->len - first_part_size));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE(input->len));
total_output_length += function_output_length;
}
- status = psa_cipher_finish( &operation,
- ( output_buffer_size == 0 ? NULL :
- output + total_output_length ),
- output_buffer_size - total_output_length,
- &function_output_length );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
+ status = psa_cipher_finish(&operation,
+ (output_buffer_size == 0 ? NULL :
+ output + total_output_length),
+ output_buffer_size - total_output_length,
+ &function_output_length);
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_FINISH_OUTPUT_SIZE(key_type, alg));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE);
total_output_length += function_output_length;
- TEST_EQUAL( status, expected_status );
+ TEST_EQUAL(status, expected_status);
- if( expected_status == PSA_SUCCESS )
- {
- PSA_ASSERT( psa_cipher_abort( &operation ) );
+ if (expected_status == PSA_SUCCESS) {
+ PSA_ASSERT(psa_cipher_abort(&operation));
- ASSERT_COMPARE( expected_output->x, expected_output->len,
- output, total_output_length );
+ ASSERT_COMPARE(expected_output->x, expected_output->len,
+ output, total_output_length);
}
exit:
- psa_cipher_abort( &operation );
- mbedtls_free( output );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_cipher_abort(&operation);
+ mbedtls_free(output);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_decrypt_multipart( int alg_arg, int key_type_arg,
- data_t *key_data, data_t *iv,
- data_t *input,
- int first_part_size_arg,
- int output1_length_arg, int output2_length_arg,
- data_t *expected_output,
- int expected_status_arg )
+void cipher_decrypt_multipart(int alg_arg, int key_type_arg,
+ data_t *key_data, data_t *iv,
+ data_t *input,
+ int first_part_size_arg,
+ int output1_length_arg, int output2_length_arg,
+ data_t *expected_output,
+ int expected_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -2959,202 +2985,196 @@
psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- PSA_ASSERT( psa_cipher_decrypt_setup( &operation, key, alg ) );
+ PSA_ASSERT(psa_cipher_decrypt_setup(&operation, key, alg));
- if( iv->len > 0 )
- {
- PSA_ASSERT( psa_cipher_set_iv( &operation, iv->x, iv->len ) );
+ if (iv->len > 0) {
+ PSA_ASSERT(psa_cipher_set_iv(&operation, iv->x, iv->len));
}
- output_buffer_size = PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, input->len ) +
- PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg );
- ASSERT_ALLOC( output, output_buffer_size );
+ output_buffer_size = PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type, alg, input->len) +
+ PSA_CIPHER_FINISH_OUTPUT_SIZE(key_type, alg);
+ ASSERT_ALLOC(output, output_buffer_size);
- TEST_LE_U( first_part_size, input->len );
- PSA_ASSERT( psa_cipher_update( &operation,
- input->x, first_part_size,
- output, output_buffer_size,
- &function_output_length ) );
- TEST_ASSERT( function_output_length == output1_length );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, first_part_size ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( first_part_size ) );
+ TEST_LE_U(first_part_size, input->len);
+ PSA_ASSERT(psa_cipher_update(&operation,
+ input->x, first_part_size,
+ output, output_buffer_size,
+ &function_output_length));
+ TEST_ASSERT(function_output_length == output1_length);
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type, alg, first_part_size));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE(first_part_size));
total_output_length += function_output_length;
- if( first_part_size < input->len )
- {
- PSA_ASSERT( psa_cipher_update( &operation,
- input->x + first_part_size,
- input->len - first_part_size,
- ( output_buffer_size == 0 ? NULL :
- output + total_output_length ),
- output_buffer_size - total_output_length,
- &function_output_length ) );
- TEST_ASSERT( function_output_length == output2_length );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type,
- alg,
- input->len - first_part_size ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( input->len ) );
+ if (first_part_size < input->len) {
+ PSA_ASSERT(psa_cipher_update(&operation,
+ input->x + first_part_size,
+ input->len - first_part_size,
+ (output_buffer_size == 0 ? NULL :
+ output + total_output_length),
+ output_buffer_size - total_output_length,
+ &function_output_length));
+ TEST_ASSERT(function_output_length == output2_length);
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type,
+ alg,
+ input->len - first_part_size));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE(input->len));
total_output_length += function_output_length;
}
- status = psa_cipher_finish( &operation,
- ( output_buffer_size == 0 ? NULL :
- output + total_output_length ),
- output_buffer_size - total_output_length,
- &function_output_length );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
+ status = psa_cipher_finish(&operation,
+ (output_buffer_size == 0 ? NULL :
+ output + total_output_length),
+ output_buffer_size - total_output_length,
+ &function_output_length);
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_FINISH_OUTPUT_SIZE(key_type, alg));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE);
total_output_length += function_output_length;
- TEST_EQUAL( status, expected_status );
+ TEST_EQUAL(status, expected_status);
- if( expected_status == PSA_SUCCESS )
- {
- PSA_ASSERT( psa_cipher_abort( &operation ) );
+ if (expected_status == PSA_SUCCESS) {
+ PSA_ASSERT(psa_cipher_abort(&operation));
- ASSERT_COMPARE( expected_output->x, expected_output->len,
- output, total_output_length );
+ ASSERT_COMPARE(expected_output->x, expected_output->len,
+ output, total_output_length);
}
exit:
- psa_cipher_abort( &operation );
- mbedtls_free( output );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_cipher_abort(&operation);
+ mbedtls_free(output);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_decrypt_fail( int alg_arg,
+void cipher_decrypt_fail(int alg_arg,
+ int key_type_arg,
+ data_t *key_data,
+ data_t *iv,
+ data_t *input_arg,
+ int expected_status_arg)
+{
+ mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
+ psa_status_t status;
+ psa_key_type_t key_type = key_type_arg;
+ psa_algorithm_t alg = alg_arg;
+ psa_status_t expected_status = expected_status_arg;
+ unsigned char *input = NULL;
+ size_t input_buffer_size = 0;
+ unsigned char *output = NULL;
+ size_t output_buffer_size = 0;
+ size_t output_length = 0;
+ psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
+
+ if (PSA_ERROR_BAD_STATE != expected_status) {
+ PSA_ASSERT(psa_crypto_init());
+
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
+
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+ }
+
+ /* 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) {
+ ASSERT_ALLOC(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);
+ ASSERT_ALLOC(output, output_buffer_size);
+
+ status = psa_cipher_decrypt(key, alg, input, input_buffer_size, output,
+ output_buffer_size, &output_length);
+ TEST_EQUAL(status, expected_status);
+
+exit:
+ mbedtls_free(input);
+ mbedtls_free(output);
+ psa_destroy_key(key);
+ PSA_DONE();
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void cipher_decrypt(int alg_arg,
+ int key_type_arg,
+ data_t *key_data,
+ data_t *iv,
+ data_t *input_arg,
+ data_t *expected_output)
+{
+ mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
+ psa_key_type_t key_type = key_type_arg;
+ psa_algorithm_t alg = alg_arg;
+ unsigned char *input = NULL;
+ size_t input_buffer_size = 0;
+ unsigned char *output = NULL;
+ size_t output_buffer_size = 0;
+ size_t output_length = 0;
+ psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
+
+ PSA_ASSERT(psa_crypto_init());
+
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
+
+ /* 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) {
+ ASSERT_ALLOC(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);
+ ASSERT_ALLOC(output, output_buffer_size);
+
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+
+ PSA_ASSERT(psa_cipher_decrypt(key, alg, input, input_buffer_size, output,
+ output_buffer_size, &output_length));
+ TEST_LE_U(output_length,
+ PSA_CIPHER_DECRYPT_OUTPUT_SIZE(key_type, alg, input_buffer_size));
+ TEST_LE_U(output_length,
+ PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE(input_buffer_size));
+
+ ASSERT_COMPARE(expected_output->x, expected_output->len,
+ output, output_length);
+exit:
+ mbedtls_free(input);
+ mbedtls_free(output);
+ psa_destroy_key(key);
+ PSA_DONE();
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void cipher_verify_output(int alg_arg,
int key_type_arg,
data_t *key_data,
- data_t *iv,
- data_t *input_arg,
- int expected_status_arg )
-{
- mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
- psa_status_t status;
- psa_key_type_t key_type = key_type_arg;
- psa_algorithm_t alg = alg_arg;
- psa_status_t expected_status = expected_status_arg;
- unsigned char *input = NULL;
- size_t input_buffer_size = 0;
- unsigned char *output = NULL;
- size_t output_buffer_size = 0;
- size_t output_length = 0;
- psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-
- if ( PSA_ERROR_BAD_STATE != expected_status )
- {
- PSA_ASSERT( psa_crypto_init( ) );
-
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
-
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
- }
-
- /* 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 )
- {
- ASSERT_ALLOC( 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 );
- ASSERT_ALLOC( output, output_buffer_size );
-
- status = psa_cipher_decrypt( key, alg, input, input_buffer_size, output,
- output_buffer_size, &output_length );
- TEST_EQUAL( status, expected_status );
-
-exit:
- mbedtls_free( input );
- mbedtls_free( output );
- psa_destroy_key( key );
- PSA_DONE( );
-}
-/* END_CASE */
-
-/* BEGIN_CASE */
-void cipher_decrypt( int alg_arg,
- int key_type_arg,
- data_t *key_data,
- data_t *iv,
- data_t *input_arg,
- data_t *expected_output )
-{
- mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
- psa_key_type_t key_type = key_type_arg;
- psa_algorithm_t alg = alg_arg;
- unsigned char *input = NULL;
- size_t input_buffer_size = 0;
- unsigned char *output = NULL;
- size_t output_buffer_size = 0;
- size_t output_length = 0;
- psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-
- PSA_ASSERT( psa_crypto_init( ) );
-
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
-
- /* 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 )
- {
- ASSERT_ALLOC( 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 );
- ASSERT_ALLOC( output, output_buffer_size );
-
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
-
- PSA_ASSERT( psa_cipher_decrypt( key, alg, input, input_buffer_size, output,
- output_buffer_size, &output_length ) );
- TEST_LE_U( output_length,
- PSA_CIPHER_DECRYPT_OUTPUT_SIZE( key_type, alg, input_buffer_size ) );
- TEST_LE_U( output_length,
- PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE( input_buffer_size ) );
-
- ASSERT_COMPARE( expected_output->x, expected_output->len,
- output, output_length );
-exit:
- mbedtls_free( input );
- mbedtls_free( output );
- psa_destroy_key( key );
- PSA_DONE( );
-}
-/* END_CASE */
-
-/* BEGIN_CASE */
-void cipher_verify_output( int alg_arg,
- int key_type_arg,
- data_t *key_data,
- data_t *input )
+ data_t *input)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -3167,58 +3187,58 @@
size_t output2_length = 0;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- 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 );
- ASSERT_ALLOC( output1, output1_size );
+ 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);
+ ASSERT_ALLOC(output1, output1_size);
- PSA_ASSERT( psa_cipher_encrypt( key, alg, input->x, input->len,
- output1, output1_size,
- &output1_length ) );
- TEST_LE_U( output1_length,
- PSA_CIPHER_ENCRYPT_OUTPUT_SIZE( key_type, alg, input->len ) );
- TEST_LE_U( output1_length,
- PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE( input->len ) );
+ PSA_ASSERT(psa_cipher_encrypt(key, alg, input->x, input->len,
+ output1, output1_size,
+ &output1_length));
+ TEST_LE_U(output1_length,
+ PSA_CIPHER_ENCRYPT_OUTPUT_SIZE(key_type, alg, input->len));
+ TEST_LE_U(output1_length,
+ PSA_CIPHER_ENCRYPT_OUTPUT_MAX_SIZE(input->len));
output2_size = output1_length;
- ASSERT_ALLOC( output2, output2_size );
+ ASSERT_ALLOC(output2, output2_size);
- PSA_ASSERT( psa_cipher_decrypt( key, alg, output1, output1_length,
- output2, output2_size,
- &output2_length ) );
- TEST_LE_U( output2_length,
- PSA_CIPHER_DECRYPT_OUTPUT_SIZE( key_type, alg, output1_length ) );
- TEST_LE_U( output2_length,
- PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE( output1_length ) );
+ PSA_ASSERT(psa_cipher_decrypt(key, alg, output1, output1_length,
+ output2, output2_size,
+ &output2_length));
+ TEST_LE_U(output2_length,
+ PSA_CIPHER_DECRYPT_OUTPUT_SIZE(key_type, alg, output1_length));
+ TEST_LE_U(output2_length,
+ PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE(output1_length));
- ASSERT_COMPARE( input->x, input->len, output2, output2_length );
+ ASSERT_COMPARE(input->x, input->len, output2, output2_length);
exit:
- mbedtls_free( output1 );
- mbedtls_free( output2 );
- psa_destroy_key( key );
- PSA_DONE( );
+ mbedtls_free(output1);
+ mbedtls_free(output2);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_verify_output_multipart( int alg_arg,
- int key_type_arg,
- data_t *key_data,
- data_t *input,
- int first_part_size_arg )
+void cipher_verify_output_multipart(int alg_arg,
+ int key_type_arg,
+ data_t *key_data,
+ data_t *input,
+ int first_part_size_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
psa_algorithm_t alg = alg_arg;
size_t first_part_size = first_part_size_arg;
- unsigned char iv[16] = {0};
+ unsigned char iv[16] = { 0 };
size_t iv_size = 16;
size_t iv_length = 0;
unsigned char *output1 = NULL;
@@ -3232,132 +3252,130 @@
psa_cipher_operation_t operation2 = PSA_CIPHER_OPERATION_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation1, key, alg ) );
- PSA_ASSERT( psa_cipher_decrypt_setup( &operation2, key, alg ) );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation1, key, alg));
+ PSA_ASSERT(psa_cipher_decrypt_setup(&operation2, key, alg));
- if( alg != PSA_ALG_ECB_NO_PADDING )
- {
- PSA_ASSERT( psa_cipher_generate_iv( &operation1,
- iv, iv_size,
- &iv_length ) );
+ if (alg != PSA_ALG_ECB_NO_PADDING) {
+ PSA_ASSERT(psa_cipher_generate_iv(&operation1,
+ iv, iv_size,
+ &iv_length));
}
- 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 ) );
- ASSERT_ALLOC( output1, output1_buffer_size );
+ 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));
+ ASSERT_ALLOC(output1, output1_buffer_size);
- TEST_LE_U( first_part_size, input->len );
+ TEST_LE_U(first_part_size, input->len);
- PSA_ASSERT( psa_cipher_update( &operation1, input->x, first_part_size,
- output1, output1_buffer_size,
- &function_output_length ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, first_part_size ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( first_part_size ) );
+ PSA_ASSERT(psa_cipher_update(&operation1, input->x, first_part_size,
+ output1, output1_buffer_size,
+ &function_output_length));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type, alg, first_part_size));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE(first_part_size));
output1_length += function_output_length;
- PSA_ASSERT( psa_cipher_update( &operation1,
- input->x + first_part_size,
- input->len - first_part_size,
- output1, output1_buffer_size,
- &function_output_length ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type,
- alg,
- input->len - first_part_size ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( input->len - first_part_size ) );
+ PSA_ASSERT(psa_cipher_update(&operation1,
+ input->x + first_part_size,
+ input->len - first_part_size,
+ output1, output1_buffer_size,
+ &function_output_length));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type,
+ alg,
+ input->len - first_part_size));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE(input->len - first_part_size));
output1_length += function_output_length;
- PSA_ASSERT( psa_cipher_finish( &operation1,
- output1 + output1_length,
- output1_buffer_size - output1_length,
- &function_output_length ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
+ PSA_ASSERT(psa_cipher_finish(&operation1,
+ output1 + output1_length,
+ output1_buffer_size - output1_length,
+ &function_output_length));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_FINISH_OUTPUT_SIZE(key_type, alg));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE);
output1_length += function_output_length;
- PSA_ASSERT( psa_cipher_abort( &operation1 ) );
+ PSA_ASSERT(psa_cipher_abort(&operation1));
output2_buffer_size = output1_length;
- TEST_LE_U( output2_buffer_size,
- PSA_CIPHER_DECRYPT_OUTPUT_SIZE( key_type, alg, output1_length ) );
- TEST_LE_U( output2_buffer_size,
- PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE( output1_length ) );
- ASSERT_ALLOC( output2, output2_buffer_size );
+ TEST_LE_U(output2_buffer_size,
+ PSA_CIPHER_DECRYPT_OUTPUT_SIZE(key_type, alg, output1_length));
+ TEST_LE_U(output2_buffer_size,
+ PSA_CIPHER_DECRYPT_OUTPUT_MAX_SIZE(output1_length));
+ ASSERT_ALLOC(output2, output2_buffer_size);
- if( iv_length > 0 )
- {
- PSA_ASSERT( psa_cipher_set_iv( &operation2,
- iv, iv_length ) );
+ if (iv_length > 0) {
+ PSA_ASSERT(psa_cipher_set_iv(&operation2,
+ iv, iv_length));
}
- PSA_ASSERT( psa_cipher_update( &operation2, output1, first_part_size,
- output2, output2_buffer_size,
- &function_output_length ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type, alg, first_part_size ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( first_part_size ) );
+ PSA_ASSERT(psa_cipher_update(&operation2, output1, first_part_size,
+ output2, output2_buffer_size,
+ &function_output_length));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type, alg, first_part_size));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE(first_part_size));
output2_length += function_output_length;
- PSA_ASSERT( psa_cipher_update( &operation2,
- output1 + first_part_size,
- output1_length - first_part_size,
- output2, output2_buffer_size,
- &function_output_length ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_SIZE( key_type,
- alg,
- output1_length - first_part_size ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE( output1_length - first_part_size ) );
+ PSA_ASSERT(psa_cipher_update(&operation2,
+ output1 + first_part_size,
+ output1_length - first_part_size,
+ output2, output2_buffer_size,
+ &function_output_length));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_SIZE(key_type,
+ alg,
+ output1_length - first_part_size));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_UPDATE_OUTPUT_MAX_SIZE(output1_length - first_part_size));
output2_length += function_output_length;
- PSA_ASSERT( psa_cipher_finish( &operation2,
- output2 + output2_length,
- output2_buffer_size - output2_length,
- &function_output_length ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_FINISH_OUTPUT_SIZE( key_type, alg ) );
- TEST_LE_U( function_output_length,
- PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE );
+ PSA_ASSERT(psa_cipher_finish(&operation2,
+ output2 + output2_length,
+ output2_buffer_size - output2_length,
+ &function_output_length));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_FINISH_OUTPUT_SIZE(key_type, alg));
+ TEST_LE_U(function_output_length,
+ PSA_CIPHER_FINISH_OUTPUT_MAX_SIZE);
output2_length += function_output_length;
- PSA_ASSERT( psa_cipher_abort( &operation2 ) );
+ PSA_ASSERT(psa_cipher_abort(&operation2));
- ASSERT_COMPARE( input->x, input->len, output2, output2_length );
+ ASSERT_COMPARE(input->x, input->len, output2, output2_length);
exit:
- psa_cipher_abort( &operation1 );
- psa_cipher_abort( &operation2 );
- mbedtls_free( output1 );
- mbedtls_free( output2 );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_cipher_abort(&operation1);
+ psa_cipher_abort(&operation2);
+ mbedtls_free(output1);
+ mbedtls_free(output2);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void aead_encrypt_decrypt( int key_type_arg, data_t *key_data,
- int alg_arg,
- data_t *nonce,
- data_t *additional_data,
- data_t *input_data,
- int expected_result_arg )
+void aead_encrypt_decrypt(int key_type_arg, data_t *key_data,
+ int alg_arg,
+ data_t *nonce,
+ data_t *additional_data,
+ data_t *input_data,
+ int expected_result_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -3372,90 +3390,87 @@
psa_status_t expected_result = expected_result_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
- output_size = input_data->len + PSA_AEAD_TAG_LENGTH( key_type, key_bits,
- alg );
+ output_size = input_data->len + PSA_AEAD_TAG_LENGTH(key_type, key_bits,
+ alg);
/* For all currently defined algorithms, PSA_AEAD_ENCRYPT_OUTPUT_SIZE
* should be exact. */
- if( expected_result != PSA_ERROR_INVALID_ARGUMENT &&
- expected_result != PSA_ERROR_NOT_SUPPORTED )
- {
- TEST_EQUAL( output_size,
- PSA_AEAD_ENCRYPT_OUTPUT_SIZE( key_type, alg, input_data->len ) );
- TEST_ASSERT( output_size <=
- PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
+ if (expected_result != PSA_ERROR_INVALID_ARGUMENT &&
+ expected_result != PSA_ERROR_NOT_SUPPORTED) {
+ TEST_EQUAL(output_size,
+ PSA_AEAD_ENCRYPT_OUTPUT_SIZE(key_type, alg, input_data->len));
+ TEST_ASSERT(output_size <=
+ PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE(input_data->len));
}
- ASSERT_ALLOC( output_data, output_size );
+ ASSERT_ALLOC(output_data, output_size);
- status = psa_aead_encrypt( key, alg,
- nonce->x, nonce->len,
- additional_data->x,
- additional_data->len,
- input_data->x, input_data->len,
- output_data, output_size,
- &output_length );
+ status = psa_aead_encrypt(key, alg,
+ nonce->x, nonce->len,
+ additional_data->x,
+ additional_data->len,
+ input_data->x, input_data->len,
+ output_data, output_size,
+ &output_length);
/* If the operation is not supported, just skip and not fail in case the
* encryption involves a common limitation of cryptography hardwares and
* an alternative implementation. */
- if( status == PSA_ERROR_NOT_SUPPORTED )
- {
- MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
- MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
+ if (status == PSA_ERROR_NOT_SUPPORTED) {
+ MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192(key_type, key_data->len * 8);
+ MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE(alg, nonce->len);
}
- TEST_EQUAL( status, expected_result );
+ TEST_EQUAL(status, expected_result);
- if( PSA_SUCCESS == expected_result )
- {
- ASSERT_ALLOC( output_data2, output_length );
+ if (PSA_SUCCESS == expected_result) {
+ ASSERT_ALLOC(output_data2, output_length);
/* For all currently defined algorithms, PSA_AEAD_DECRYPT_OUTPUT_SIZE
* should be exact. */
- TEST_EQUAL( input_data->len,
- PSA_AEAD_DECRYPT_OUTPUT_SIZE( key_type, alg, output_length ) );
+ TEST_EQUAL(input_data->len,
+ PSA_AEAD_DECRYPT_OUTPUT_SIZE(key_type, alg, output_length));
- TEST_ASSERT( input_data->len <=
- PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE( output_length ) );
+ TEST_ASSERT(input_data->len <=
+ PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE(output_length));
- TEST_EQUAL( psa_aead_decrypt( key, alg,
- nonce->x, nonce->len,
- additional_data->x,
- additional_data->len,
- output_data, output_length,
- output_data2, output_length,
- &output_length2 ),
- expected_result );
+ TEST_EQUAL(psa_aead_decrypt(key, alg,
+ nonce->x, nonce->len,
+ additional_data->x,
+ additional_data->len,
+ output_data, output_length,
+ output_data2, output_length,
+ &output_length2),
+ expected_result);
- ASSERT_COMPARE( input_data->x, input_data->len,
- output_data2, output_length2 );
+ ASSERT_COMPARE(input_data->x, input_data->len,
+ output_data2, output_length2);
}
exit:
- psa_destroy_key( key );
- mbedtls_free( output_data );
- mbedtls_free( output_data2 );
- PSA_DONE( );
+ psa_destroy_key(key);
+ mbedtls_free(output_data);
+ mbedtls_free(output_data2);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void aead_encrypt( int key_type_arg, data_t *key_data,
- int alg_arg,
- data_t *nonce,
- data_t *additional_data,
- data_t *input_data,
- data_t *expected_result )
+void aead_encrypt(int key_type_arg, data_t *key_data,
+ int alg_arg,
+ data_t *nonce,
+ data_t *additional_data,
+ data_t *input_data,
+ data_t *expected_result)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -3467,62 +3482,61 @@
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_status_t status = PSA_ERROR_GENERIC_ERROR;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
- output_size = input_data->len + PSA_AEAD_TAG_LENGTH( key_type, key_bits,
- alg );
+ output_size = input_data->len + PSA_AEAD_TAG_LENGTH(key_type, key_bits,
+ alg);
/* For all currently defined algorithms, PSA_AEAD_ENCRYPT_OUTPUT_SIZE
* should be exact. */
- TEST_EQUAL( output_size,
- PSA_AEAD_ENCRYPT_OUTPUT_SIZE( key_type, alg, input_data->len ) );
- TEST_ASSERT( output_size <=
- PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
- ASSERT_ALLOC( output_data, output_size );
+ TEST_EQUAL(output_size,
+ PSA_AEAD_ENCRYPT_OUTPUT_SIZE(key_type, alg, input_data->len));
+ TEST_ASSERT(output_size <=
+ PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE(input_data->len));
+ ASSERT_ALLOC(output_data, output_size);
- status = psa_aead_encrypt( key, alg,
- nonce->x, nonce->len,
- additional_data->x, additional_data->len,
- input_data->x, input_data->len,
- output_data, output_size,
- &output_length );
+ status = psa_aead_encrypt(key, alg,
+ nonce->x, nonce->len,
+ additional_data->x, additional_data->len,
+ input_data->x, input_data->len,
+ output_data, output_size,
+ &output_length);
/* If the operation is not supported, just skip and not fail in case the
* encryption involves a common limitation of cryptography hardwares and
* an alternative implementation. */
- if( status == PSA_ERROR_NOT_SUPPORTED )
- {
- MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
- MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
+ if (status == PSA_ERROR_NOT_SUPPORTED) {
+ MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192(key_type, key_data->len * 8);
+ MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE(alg, nonce->len);
}
- PSA_ASSERT( status );
- ASSERT_COMPARE( expected_result->x, expected_result->len,
- output_data, output_length );
+ PSA_ASSERT(status);
+ ASSERT_COMPARE(expected_result->x, expected_result->len,
+ output_data, output_length);
exit:
- psa_destroy_key( key );
- mbedtls_free( output_data );
- PSA_DONE( );
+ psa_destroy_key(key);
+ mbedtls_free(output_data);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void aead_decrypt( int key_type_arg, data_t *key_data,
- int alg_arg,
- data_t *nonce,
- data_t *additional_data,
- data_t *input_data,
- data_t *expected_data,
- int expected_result_arg )
+void aead_decrypt(int key_type_arg, data_t *key_data,
+ int alg_arg,
+ data_t *nonce,
+ data_t *additional_data,
+ data_t *input_data,
+ data_t *expected_data,
+ int expected_result_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -3535,75 +3549,74 @@
psa_status_t expected_result = expected_result_arg;
psa_status_t status = PSA_ERROR_GENERIC_ERROR;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
- output_size = input_data->len - PSA_AEAD_TAG_LENGTH( key_type, key_bits,
- alg );
- if( expected_result != PSA_ERROR_INVALID_ARGUMENT &&
- expected_result != PSA_ERROR_NOT_SUPPORTED )
- {
+ output_size = input_data->len - PSA_AEAD_TAG_LENGTH(key_type, key_bits,
+ alg);
+ if (expected_result != PSA_ERROR_INVALID_ARGUMENT &&
+ expected_result != PSA_ERROR_NOT_SUPPORTED) {
/* For all currently defined algorithms, PSA_AEAD_DECRYPT_OUTPUT_SIZE
* should be exact. */
- TEST_EQUAL( output_size,
- PSA_AEAD_DECRYPT_OUTPUT_SIZE( key_type, alg, input_data->len ) );
- TEST_ASSERT( output_size <=
- PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
+ TEST_EQUAL(output_size,
+ PSA_AEAD_DECRYPT_OUTPUT_SIZE(key_type, alg, input_data->len));
+ TEST_ASSERT(output_size <=
+ PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE(input_data->len));
}
- ASSERT_ALLOC( output_data, output_size );
+ ASSERT_ALLOC(output_data, output_size);
- status = psa_aead_decrypt( key, alg,
- nonce->x, nonce->len,
- additional_data->x,
- additional_data->len,
- input_data->x, input_data->len,
- output_data, output_size,
- &output_length );
+ status = psa_aead_decrypt(key, alg,
+ nonce->x, nonce->len,
+ additional_data->x,
+ additional_data->len,
+ input_data->x, input_data->len,
+ output_data, output_size,
+ &output_length);
/* If the operation is not supported, just skip and not fail in case the
* decryption involves a common limitation of cryptography hardwares and
* an alternative implementation. */
- if( status == PSA_ERROR_NOT_SUPPORTED )
- {
- MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192( key_type, key_data->len * 8 );
- MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE( alg, nonce->len );
+ if (status == PSA_ERROR_NOT_SUPPORTED) {
+ MBEDTLS_TEST_PSA_SKIP_IF_ALT_AES_192(key_type, key_data->len * 8);
+ MBEDTLS_TEST_PSA_SKIP_IF_ALT_GCM_NOT_12BYTES_NONCE(alg, nonce->len);
}
- TEST_EQUAL( status, expected_result );
+ TEST_EQUAL(status, expected_result);
- if( expected_result == PSA_SUCCESS )
- ASSERT_COMPARE( expected_data->x, expected_data->len,
- output_data, output_length );
+ if (expected_result == PSA_SUCCESS) {
+ ASSERT_COMPARE(expected_data->x, expected_data->len,
+ output_data, output_length);
+ }
exit:
- psa_destroy_key( key );
- mbedtls_free( output_data );
- PSA_DONE( );
+ psa_destroy_key(key);
+ mbedtls_free(output_data);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void signature_size( int type_arg,
- int bits,
- int alg_arg,
- int expected_size_arg )
+void signature_size(int type_arg,
+ int bits,
+ int alg_arg,
+ int expected_size_arg)
{
psa_key_type_t type = type_arg;
psa_algorithm_t alg = alg_arg;
- size_t actual_size = PSA_SIGN_OUTPUT_SIZE( type, bits, alg );
+ size_t actual_size = PSA_SIGN_OUTPUT_SIZE(type, bits, alg);
- TEST_EQUAL( actual_size, (size_t) expected_size_arg );
+ TEST_EQUAL(actual_size, (size_t) expected_size_arg);
#if defined(MBEDTLS_TEST_DEPRECATED)
- TEST_EQUAL( actual_size,
- PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE( type, bits, alg ) );
+ TEST_EQUAL(actual_size,
+ PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE(type, bits, alg));
#endif /* MBEDTLS_TEST_DEPRECATED */
exit:
@@ -3612,9 +3625,9 @@
/* END_CASE */
/* BEGIN_CASE */
-void sign_hash_deterministic( int key_type_arg, data_t *key_data,
- int alg_arg, data_t *input_data,
- data_t *output_data )
+void sign_hash_deterministic(int key_type_arg, data_t *key_data,
+ int alg_arg, data_t *input_data,
+ data_t *output_data)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -3625,43 +3638,43 @@
size_t signature_length = 0xdeadbeef;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
/* Allocate a buffer which has the size advertised by the
* library. */
- 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 );
- ASSERT_ALLOC( signature, signature_size );
+ 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);
+ ASSERT_ALLOC(signature, signature_size);
/* Perform the signature. */
- PSA_ASSERT( psa_sign_hash( key, alg,
- input_data->x, input_data->len,
- signature, signature_size,
- &signature_length ) );
+ PSA_ASSERT(psa_sign_hash(key, alg,
+ input_data->x, input_data->len,
+ signature, signature_size,
+ &signature_length));
/* Verify that the signature is what is expected. */
- ASSERT_COMPARE( output_data->x, output_data->len,
- signature, signature_length );
+ ASSERT_COMPARE(output_data->x, output_data->len,
+ signature, signature_length);
#if defined(MBEDTLS_TEST_DEPRECATED)
- memset( signature, 0, signature_size );
+ memset(signature, 0, signature_size);
signature_length = INVALID_EXPORT_LENGTH;
- PSA_ASSERT( psa_asymmetric_sign( key, alg,
- input_data->x, input_data->len,
- signature, signature_size,
- &signature_length ) );
- ASSERT_COMPARE( output_data->x, output_data->len,
- signature, signature_length );
+ PSA_ASSERT(psa_asymmetric_sign(key, alg,
+ input_data->x, input_data->len,
+ signature, signature_size,
+ &signature_length));
+ ASSERT_COMPARE(output_data->x, output_data->len,
+ signature, signature_length);
#endif /* MBEDTLS_TEST_DEPRECATED */
exit:
@@ -3669,18 +3682,18 @@
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- psa_destroy_key( key );
- mbedtls_free( signature );
- PSA_DONE( );
+ psa_destroy_key(key);
+ mbedtls_free(signature);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void sign_hash_fail( int key_type_arg, data_t *key_data,
- int alg_arg, data_t *input_data,
- int signature_size_arg, int expected_status_arg )
+void sign_hash_fail(int key_type_arg, data_t *key_data,
+ int alg_arg, data_t *input_data,
+ int signature_size_arg, int expected_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -3692,49 +3705,49 @@
size_t signature_length = 0xdeadbeef;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- ASSERT_ALLOC( signature, signature_size );
+ ASSERT_ALLOC(signature, signature_size);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- actual_status = psa_sign_hash( key, alg,
- input_data->x, input_data->len,
- signature, signature_size,
- &signature_length );
- TEST_EQUAL( actual_status, expected_status );
+ actual_status = psa_sign_hash(key, alg,
+ input_data->x, input_data->len,
+ signature, signature_size,
+ &signature_length);
+ TEST_EQUAL(actual_status, expected_status);
/* The value of *signature_length is unspecified on error, but
* whatever it is, it should be less than signature_size, so that
* if the caller tries to read *signature_length bytes without
* checking the error code then they don't overflow a buffer. */
- TEST_LE_U( signature_length, signature_size );
+ TEST_LE_U(signature_length, signature_size);
#if defined(MBEDTLS_TEST_DEPRECATED)
signature_length = INVALID_EXPORT_LENGTH;
- TEST_EQUAL( psa_asymmetric_sign( key, alg,
- input_data->x, input_data->len,
- signature, signature_size,
- &signature_length ),
- expected_status );
- TEST_LE_U( signature_length, signature_size );
+ TEST_EQUAL(psa_asymmetric_sign(key, alg,
+ input_data->x, input_data->len,
+ signature, signature_size,
+ &signature_length),
+ expected_status);
+ TEST_LE_U(signature_length, signature_size);
#endif /* MBEDTLS_TEST_DEPRECATED */
exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- mbedtls_free( signature );
- PSA_DONE( );
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ mbedtls_free(signature);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void sign_verify_hash( int key_type_arg, data_t *key_data,
- int alg_arg, data_t *input_data )
+void sign_verify_hash(int key_type_arg, data_t *key_data,
+ int alg_arg, data_t *input_data)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -3745,49 +3758,48 @@
size_t signature_length = 0xdeadbeef;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
/* Allocate a buffer which has the size advertised by the
* library. */
- 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 );
- ASSERT_ALLOC( signature, signature_size );
+ 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);
+ ASSERT_ALLOC(signature, signature_size);
/* Perform the signature. */
- PSA_ASSERT( psa_sign_hash( key, alg,
- input_data->x, input_data->len,
- signature, signature_size,
- &signature_length ) );
+ PSA_ASSERT(psa_sign_hash(key, alg,
+ input_data->x, input_data->len,
+ signature, signature_size,
+ &signature_length));
/* Check that the signature length looks sensible. */
- TEST_LE_U( signature_length, signature_size );
- TEST_ASSERT( signature_length > 0 );
+ TEST_LE_U(signature_length, signature_size);
+ TEST_ASSERT(signature_length > 0);
/* Use the library to verify that the signature is correct. */
- PSA_ASSERT( psa_verify_hash( key, alg,
- input_data->x, input_data->len,
- signature, signature_length ) );
+ PSA_ASSERT(psa_verify_hash(key, alg,
+ input_data->x, input_data->len,
+ signature, signature_length));
- if( input_data->len != 0 )
- {
+ if (input_data->len != 0) {
/* Flip a bit in the input and verify that the signature is now
* detected as invalid. Flip a bit at the beginning, not at the end,
* because ECDSA may ignore the last few bits of the input. */
input_data->x[0] ^= 1;
- TEST_EQUAL( psa_verify_hash( key, alg,
- input_data->x, input_data->len,
- signature, signature_length ),
- PSA_ERROR_INVALID_SIGNATURE );
+ TEST_EQUAL(psa_verify_hash(key, alg,
+ input_data->x, input_data->len,
+ signature, signature_length),
+ PSA_ERROR_INVALID_SIGNATURE);
}
exit:
@@ -3795,59 +3807,59 @@
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- psa_destroy_key( key );
- mbedtls_free( signature );
- PSA_DONE( );
+ psa_destroy_key(key);
+ mbedtls_free(signature);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void verify_hash( int key_type_arg, data_t *key_data,
- int alg_arg, data_t *hash_data,
- data_t *signature_data )
+void verify_hash(int key_type_arg, data_t *key_data,
+ int alg_arg, data_t *hash_data,
+ data_t *signature_data)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
psa_algorithm_t alg = alg_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- TEST_LE_U( signature_data->len, PSA_SIGNATURE_MAX_SIZE );
+ TEST_LE_U(signature_data->len, PSA_SIGNATURE_MAX_SIZE);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- PSA_ASSERT( psa_verify_hash( key, alg,
- hash_data->x, hash_data->len,
- signature_data->x, signature_data->len ) );
+ PSA_ASSERT(psa_verify_hash(key, alg,
+ hash_data->x, hash_data->len,
+ signature_data->x, signature_data->len));
#if defined(MBEDTLS_TEST_DEPRECATED)
- PSA_ASSERT( psa_asymmetric_verify( key, alg,
- hash_data->x, hash_data->len,
- signature_data->x,
- signature_data->len ) );
+ PSA_ASSERT(psa_asymmetric_verify(key, alg,
+ hash_data->x, hash_data->len,
+ signature_data->x,
+ signature_data->len));
#endif /* MBEDTLS_TEST_DEPRECATED */
exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void verify_hash_fail( int key_type_arg, data_t *key_data,
- int alg_arg, data_t *hash_data,
- data_t *signature_data,
- int expected_status_arg )
+void verify_hash_fail(int key_type_arg, data_t *key_data,
+ int alg_arg, data_t *hash_data,
+ data_t *signature_data,
+ int expected_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -3856,40 +3868,40 @@
psa_status_t expected_status = expected_status_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- actual_status = psa_verify_hash( key, alg,
- hash_data->x, hash_data->len,
- signature_data->x, signature_data->len );
- TEST_EQUAL( actual_status, expected_status );
+ actual_status = psa_verify_hash(key, alg,
+ hash_data->x, hash_data->len,
+ signature_data->x, signature_data->len);
+ TEST_EQUAL(actual_status, expected_status);
#if defined(MBEDTLS_TEST_DEPRECATED)
- TEST_EQUAL( psa_asymmetric_verify( key, alg,
- hash_data->x, hash_data->len,
- signature_data->x, signature_data->len ),
- expected_status );
+ TEST_EQUAL(psa_asymmetric_verify(key, alg,
+ hash_data->x, hash_data->len,
+ signature_data->x, signature_data->len),
+ expected_status);
#endif /* MBEDTLS_TEST_DEPRECATED */
exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void sign_message_deterministic( int key_type_arg,
- data_t *key_data,
- int alg_arg,
- data_t *input_data,
- data_t *output_data )
+void sign_message_deterministic(int key_type_arg,
+ data_t *key_data,
+ int alg_arg,
+ data_t *input_data,
+ data_t *output_data)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -3900,231 +3912,230 @@
size_t signature_length = 0xdeadbeef;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_MESSAGE );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_MESSAGE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
- 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 );
- ASSERT_ALLOC( signature, signature_size );
+ 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);
+ ASSERT_ALLOC(signature, signature_size);
- PSA_ASSERT( psa_sign_message( key, alg,
- input_data->x, input_data->len,
- signature, signature_size,
- &signature_length ) );
+ PSA_ASSERT(psa_sign_message(key, alg,
+ input_data->x, input_data->len,
+ signature, signature_size,
+ &signature_length));
- ASSERT_COMPARE( output_data->x, output_data->len,
- signature, signature_length );
+ ASSERT_COMPARE(output_data->x, output_data->len,
+ signature, signature_length);
exit:
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- psa_destroy_key( key );
- mbedtls_free( signature );
- PSA_DONE( );
+ psa_destroy_key(key);
+ mbedtls_free(signature);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void sign_message_fail( int key_type_arg,
+void sign_message_fail(int key_type_arg,
+ data_t *key_data,
+ int alg_arg,
+ data_t *input_data,
+ int signature_size_arg,
+ int expected_status_arg)
+{
+ mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
+ psa_key_type_t key_type = key_type_arg;
+ psa_algorithm_t alg = alg_arg;
+ size_t signature_size = signature_size_arg;
+ psa_status_t actual_status;
+ psa_status_t expected_status = expected_status_arg;
+ unsigned char *signature = NULL;
+ size_t signature_length = 0xdeadbeef;
+ psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
+
+ ASSERT_ALLOC(signature, signature_size);
+
+ PSA_ASSERT(psa_crypto_init());
+
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_MESSAGE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
+
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+
+ actual_status = psa_sign_message(key, alg,
+ input_data->x, input_data->len,
+ signature, signature_size,
+ &signature_length);
+ TEST_EQUAL(actual_status, expected_status);
+ /* The value of *signature_length is unspecified on error, but
+ * whatever it is, it should be less than signature_size, so that
+ * if the caller tries to read *signature_length bytes without
+ * checking the error code then they don't overflow a buffer. */
+ TEST_LE_U(signature_length, signature_size);
+
+exit:
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ mbedtls_free(signature);
+ PSA_DONE();
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void sign_verify_message(int key_type_arg,
+ data_t *key_data,
+ int alg_arg,
+ data_t *input_data)
+{
+ mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
+ psa_key_type_t key_type = key_type_arg;
+ psa_algorithm_t alg = alg_arg;
+ size_t key_bits;
+ unsigned char *signature = NULL;
+ size_t signature_size;
+ size_t signature_length = 0xdeadbeef;
+ psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
+
+ PSA_ASSERT(psa_crypto_init());
+
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_MESSAGE |
+ PSA_KEY_USAGE_VERIFY_MESSAGE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
+
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
+
+ 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);
+ ASSERT_ALLOC(signature, signature_size);
+
+ PSA_ASSERT(psa_sign_message(key, alg,
+ input_data->x, input_data->len,
+ signature, signature_size,
+ &signature_length));
+ TEST_LE_U(signature_length, signature_size);
+ TEST_ASSERT(signature_length > 0);
+
+ PSA_ASSERT(psa_verify_message(key, alg,
+ input_data->x, input_data->len,
+ signature, signature_length));
+
+ if (input_data->len != 0) {
+ /* Flip a bit in the input and verify that the signature is now
+ * detected as invalid. Flip a bit at the beginning, not at the end,
+ * because ECDSA may ignore the last few bits of the input. */
+ input_data->x[0] ^= 1;
+ TEST_EQUAL(psa_verify_message(key, alg,
+ input_data->x, input_data->len,
+ signature, signature_length),
+ PSA_ERROR_INVALID_SIGNATURE);
+ }
+
+exit:
+ psa_reset_key_attributes(&attributes);
+
+ psa_destroy_key(key);
+ mbedtls_free(signature);
+ PSA_DONE();
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void verify_message(int key_type_arg,
+ data_t *key_data,
+ int alg_arg,
+ data_t *input_data,
+ data_t *signature_data)
+{
+ mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
+ psa_key_type_t key_type = key_type_arg;
+ psa_algorithm_t alg = alg_arg;
+ psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
+
+ TEST_LE_U(signature_data->len, PSA_SIGNATURE_MAX_SIZE);
+
+ PSA_ASSERT(psa_crypto_init());
+
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_MESSAGE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
+
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+
+ PSA_ASSERT(psa_verify_message(key, alg,
+ input_data->x, input_data->len,
+ signature_data->x, signature_data->len));
+
+exit:
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ PSA_DONE();
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void verify_message_fail(int key_type_arg,
+ data_t *key_data,
+ int alg_arg,
+ data_t *hash_data,
+ data_t *signature_data,
+ int expected_status_arg)
+{
+ mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
+ psa_key_type_t key_type = key_type_arg;
+ psa_algorithm_t alg = alg_arg;
+ psa_status_t actual_status;
+ psa_status_t expected_status = expected_status_arg;
+ psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
+
+ PSA_ASSERT(psa_crypto_init());
+
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_MESSAGE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
+
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+
+ actual_status = psa_verify_message(key, alg,
+ hash_data->x, hash_data->len,
+ signature_data->x,
+ signature_data->len);
+ TEST_EQUAL(actual_status, expected_status);
+
+exit:
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ PSA_DONE();
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void asymmetric_encrypt(int key_type_arg,
data_t *key_data,
int alg_arg,
data_t *input_data,
- int signature_size_arg,
- int expected_status_arg )
-{
- mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
- psa_key_type_t key_type = key_type_arg;
- psa_algorithm_t alg = alg_arg;
- size_t signature_size = signature_size_arg;
- psa_status_t actual_status;
- psa_status_t expected_status = expected_status_arg;
- unsigned char *signature = NULL;
- size_t signature_length = 0xdeadbeef;
- psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-
- ASSERT_ALLOC( signature, signature_size );
-
- PSA_ASSERT( psa_crypto_init( ) );
-
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_MESSAGE );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
-
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
-
- actual_status = psa_sign_message( key, alg,
- input_data->x, input_data->len,
- signature, signature_size,
- &signature_length );
- TEST_EQUAL( actual_status, expected_status );
- /* The value of *signature_length is unspecified on error, but
- * whatever it is, it should be less than signature_size, so that
- * if the caller tries to read *signature_length bytes without
- * checking the error code then they don't overflow a buffer. */
- TEST_LE_U( signature_length, signature_size );
-
-exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- mbedtls_free( signature );
- PSA_DONE( );
-}
-/* END_CASE */
-
-/* BEGIN_CASE */
-void sign_verify_message( int key_type_arg,
- data_t *key_data,
- int alg_arg,
- data_t *input_data )
-{
- mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
- psa_key_type_t key_type = key_type_arg;
- psa_algorithm_t alg = alg_arg;
- size_t key_bits;
- unsigned char *signature = NULL;
- size_t signature_size;
- size_t signature_length = 0xdeadbeef;
- psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-
- PSA_ASSERT( psa_crypto_init( ) );
-
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_MESSAGE |
- PSA_KEY_USAGE_VERIFY_MESSAGE );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
-
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
-
- 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 );
- ASSERT_ALLOC( signature, signature_size );
-
- PSA_ASSERT( psa_sign_message( key, alg,
- input_data->x, input_data->len,
- signature, signature_size,
- &signature_length ) );
- TEST_LE_U( signature_length, signature_size );
- TEST_ASSERT( signature_length > 0 );
-
- PSA_ASSERT( psa_verify_message( key, alg,
- input_data->x, input_data->len,
- signature, signature_length ) );
-
- if( input_data->len != 0 )
- {
- /* Flip a bit in the input and verify that the signature is now
- * detected as invalid. Flip a bit at the beginning, not at the end,
- * because ECDSA may ignore the last few bits of the input. */
- input_data->x[0] ^= 1;
- TEST_EQUAL( psa_verify_message( key, alg,
- input_data->x, input_data->len,
- signature, signature_length ),
- PSA_ERROR_INVALID_SIGNATURE );
- }
-
-exit:
- psa_reset_key_attributes( &attributes );
-
- psa_destroy_key( key );
- mbedtls_free( signature );
- PSA_DONE( );
-}
-/* END_CASE */
-
-/* BEGIN_CASE */
-void verify_message( int key_type_arg,
- data_t *key_data,
- int alg_arg,
- data_t *input_data,
- data_t *signature_data )
-{
- mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
- psa_key_type_t key_type = key_type_arg;
- psa_algorithm_t alg = alg_arg;
- psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-
- TEST_LE_U( signature_data->len, PSA_SIGNATURE_MAX_SIZE );
-
- PSA_ASSERT( psa_crypto_init( ) );
-
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_MESSAGE );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
-
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
-
- PSA_ASSERT( psa_verify_message( key, alg,
- input_data->x, input_data->len,
- signature_data->x, signature_data->len ) );
-
-exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- PSA_DONE( );
-}
-/* END_CASE */
-
-/* BEGIN_CASE */
-void verify_message_fail( int key_type_arg,
- data_t *key_data,
- int alg_arg,
- data_t *hash_data,
- data_t *signature_data,
- int expected_status_arg )
-{
- mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
- psa_key_type_t key_type = key_type_arg;
- psa_algorithm_t alg = alg_arg;
- psa_status_t actual_status;
- psa_status_t expected_status = expected_status_arg;
- psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
-
- PSA_ASSERT( psa_crypto_init( ) );
-
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_MESSAGE );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
-
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
-
- actual_status = psa_verify_message( key, alg,
- hash_data->x, hash_data->len,
- signature_data->x,
- signature_data->len );
- TEST_EQUAL( actual_status, expected_status );
-
-exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- PSA_DONE( );
-}
-/* END_CASE */
-
-/* BEGIN_CASE */
-void asymmetric_encrypt( int key_type_arg,
- data_t *key_data,
- int alg_arg,
- data_t *input_data,
- data_t *label,
- int expected_output_length_arg,
- int expected_status_arg )
+ data_t *label,
+ int expected_output_length_arg,
+ int expected_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -4138,46 +4149,46 @@
psa_status_t expected_status = expected_status_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* Import the key */
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
/* Determine the maximum output length */
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
- output_size = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE( key_type, key_bits, alg );
- TEST_LE_U( output_size, PSA_ASYMMETRIC_ENCRYPT_OUTPUT_MAX_SIZE );
- ASSERT_ALLOC( output, output_size );
+ output_size = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE(key_type, key_bits, alg);
+ TEST_LE_U(output_size, PSA_ASYMMETRIC_ENCRYPT_OUTPUT_MAX_SIZE);
+ ASSERT_ALLOC(output, output_size);
/* Encrypt the input */
- actual_status = psa_asymmetric_encrypt( key, alg,
- input_data->x, input_data->len,
- label->x, label->len,
- output, output_size,
- &output_length );
- TEST_EQUAL( actual_status, expected_status );
- TEST_EQUAL( output_length, expected_output_length );
+ actual_status = psa_asymmetric_encrypt(key, alg,
+ input_data->x, input_data->len,
+ label->x, label->len,
+ output, output_size,
+ &output_length);
+ TEST_EQUAL(actual_status, expected_status);
+ TEST_EQUAL(output_length, expected_output_length);
/* If the label is empty, the test framework puts a non-null pointer
* in label->x. Test that a null pointer works as well. */
- if( label->len == 0 )
- {
+ if (label->len == 0) {
output_length = ~0;
- if( output_size != 0 )
- memset( output, 0, output_size );
- actual_status = psa_asymmetric_encrypt( key, alg,
- input_data->x, input_data->len,
- NULL, label->len,
- output, output_size,
- &output_length );
- TEST_EQUAL( actual_status, expected_status );
- TEST_EQUAL( output_length, expected_output_length );
+ if (output_size != 0) {
+ memset(output, 0, output_size);
+ }
+ actual_status = psa_asymmetric_encrypt(key, alg,
+ input_data->x, input_data->len,
+ NULL, label->len,
+ output, output_size,
+ &output_length);
+ TEST_EQUAL(actual_status, expected_status);
+ TEST_EQUAL(output_length, expected_output_length);
}
exit:
@@ -4185,20 +4196,20 @@
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- psa_destroy_key( key );
- mbedtls_free( output );
- PSA_DONE( );
+ psa_destroy_key(key);
+ mbedtls_free(output);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void asymmetric_encrypt_decrypt( int key_type_arg,
- data_t *key_data,
- int alg_arg,
- data_t *input_data,
- data_t *label )
+void asymmetric_encrypt_decrypt(int key_type_arg,
+ data_t *key_data,
+ int alg_arg,
+ data_t *input_data,
+ data_t *label)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -4212,70 +4223,70 @@
size_t output2_length = ~0;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
/* Determine the maximum ciphertext length */
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
- output_size = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE( key_type, key_bits, alg );
- TEST_LE_U( output_size, PSA_ASYMMETRIC_ENCRYPT_OUTPUT_MAX_SIZE );
- ASSERT_ALLOC( output, output_size );
+ output_size = PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE(key_type, key_bits, alg);
+ TEST_LE_U(output_size, PSA_ASYMMETRIC_ENCRYPT_OUTPUT_MAX_SIZE);
+ ASSERT_ALLOC(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 );
- ASSERT_ALLOC( output2, output2_size );
+ 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);
+ ASSERT_ALLOC(output2, output2_size);
/* We test encryption by checking that encrypt-then-decrypt gives back
* the original plaintext because of the non-optional random
* part of encryption process which prevents using fixed vectors. */
- PSA_ASSERT( psa_asymmetric_encrypt( key, alg,
- input_data->x, input_data->len,
- label->x, label->len,
- output, output_size,
- &output_length ) );
+ PSA_ASSERT(psa_asymmetric_encrypt(key, alg,
+ input_data->x, input_data->len,
+ label->x, label->len,
+ output, output_size,
+ &output_length));
/* We don't know what ciphertext length to expect, but check that
* it looks sensible. */
- TEST_LE_U( output_length, output_size );
+ TEST_LE_U(output_length, output_size);
- PSA_ASSERT( psa_asymmetric_decrypt( key, alg,
- output, output_length,
- label->x, label->len,
- output2, output2_size,
- &output2_length ) );
- ASSERT_COMPARE( input_data->x, input_data->len,
- output2, output2_length );
+ PSA_ASSERT(psa_asymmetric_decrypt(key, alg,
+ output, output_length,
+ label->x, label->len,
+ output2, output2_size,
+ &output2_length));
+ ASSERT_COMPARE(input_data->x, input_data->len,
+ output2, output2_length);
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- psa_destroy_key( key );
- mbedtls_free( output );
- mbedtls_free( output2 );
- PSA_DONE( );
+ psa_destroy_key(key);
+ mbedtls_free(output);
+ mbedtls_free(output2);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void asymmetric_decrypt( int key_type_arg,
- data_t *key_data,
- int alg_arg,
- data_t *input_data,
- data_t *label,
- data_t *expected_data )
+void asymmetric_decrypt(int key_type_arg,
+ data_t *key_data,
+ int alg_arg,
+ data_t *input_data,
+ data_t *label,
+ data_t *expected_data)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -4286,65 +4297,65 @@
size_t output_length = ~0;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
/* 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 );
- ASSERT_ALLOC( output, output_size );
+ output_size = PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE(key_type, key_bits, alg);
+ TEST_LE_U(output_size, PSA_ASYMMETRIC_DECRYPT_OUTPUT_MAX_SIZE);
+ ASSERT_ALLOC(output, output_size);
- PSA_ASSERT( psa_asymmetric_decrypt( key, alg,
- input_data->x, input_data->len,
- label->x, label->len,
- output,
- output_size,
- &output_length ) );
- ASSERT_COMPARE( expected_data->x, expected_data->len,
- output, output_length );
+ PSA_ASSERT(psa_asymmetric_decrypt(key, alg,
+ input_data->x, input_data->len,
+ label->x, label->len,
+ output,
+ output_size,
+ &output_length));
+ ASSERT_COMPARE(expected_data->x, expected_data->len,
+ output, output_length);
/* If the label is empty, the test framework puts a non-null pointer
* in label->x. Test that a null pointer works as well. */
- if( label->len == 0 )
- {
+ if (label->len == 0) {
output_length = ~0;
- if( output_size != 0 )
- memset( output, 0, output_size );
- PSA_ASSERT( psa_asymmetric_decrypt( key, alg,
- input_data->x, input_data->len,
- NULL, label->len,
- output,
- output_size,
- &output_length ) );
- ASSERT_COMPARE( expected_data->x, expected_data->len,
- output, output_length );
+ if (output_size != 0) {
+ memset(output, 0, output_size);
+ }
+ PSA_ASSERT(psa_asymmetric_decrypt(key, alg,
+ input_data->x, input_data->len,
+ NULL, label->len,
+ output,
+ output_size,
+ &output_length));
+ ASSERT_COMPARE(expected_data->x, expected_data->len,
+ output, output_length);
}
exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- mbedtls_free( output );
- PSA_DONE( );
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ mbedtls_free(output);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void asymmetric_decrypt_fail( int key_type_arg,
- data_t *key_data,
- int alg_arg,
- data_t *input_data,
- data_t *label,
- int output_size_arg,
- int expected_status_arg )
+void asymmetric_decrypt_fail(int key_type_arg,
+ data_t *key_data,
+ int alg_arg,
+ data_t *input_data,
+ data_t *label,
+ int output_size_arg,
+ int expected_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -4356,135 +4367,135 @@
psa_status_t expected_status = expected_status_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- ASSERT_ALLOC( output, output_size );
+ ASSERT_ALLOC(output, output_size);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- actual_status = psa_asymmetric_decrypt( key, alg,
- input_data->x, input_data->len,
- label->x, label->len,
- output, output_size,
- &output_length );
- TEST_EQUAL( actual_status, expected_status );
- TEST_LE_U( output_length, output_size );
+ actual_status = psa_asymmetric_decrypt(key, alg,
+ input_data->x, input_data->len,
+ label->x, label->len,
+ output, output_size,
+ &output_length);
+ TEST_EQUAL(actual_status, expected_status);
+ TEST_LE_U(output_length, output_size);
/* If the label is empty, the test framework puts a non-null pointer
* in label->x. Test that a null pointer works as well. */
- if( label->len == 0 )
- {
+ if (label->len == 0) {
output_length = ~0;
- if( output_size != 0 )
- memset( output, 0, output_size );
- actual_status = psa_asymmetric_decrypt( key, alg,
- input_data->x, input_data->len,
- NULL, label->len,
- output, output_size,
- &output_length );
- TEST_EQUAL( actual_status, expected_status );
- TEST_LE_U( output_length, output_size );
+ if (output_size != 0) {
+ memset(output, 0, output_size);
+ }
+ actual_status = psa_asymmetric_decrypt(key, alg,
+ input_data->x, input_data->len,
+ NULL, label->len,
+ output, output_size,
+ &output_length);
+ TEST_EQUAL(actual_status, expected_status);
+ TEST_LE_U(output_length, output_size);
}
exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- mbedtls_free( output );
- PSA_DONE( );
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ mbedtls_free(output);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void key_derivation_init( )
+void key_derivation_init()
{
/* Test each valid way of initializing the object, except for `= {0}`, as
* Clang 5 complains when `-Wmissing-field-initializers` is used, even
* though it's OK by the C standard. We could test for this, but we'd need
* to suppress the Clang warning for the test. */
size_t capacity;
- psa_key_derivation_operation_t func = psa_key_derivation_operation_init( );
+ psa_key_derivation_operation_t func = psa_key_derivation_operation_init();
psa_key_derivation_operation_t init = PSA_KEY_DERIVATION_OPERATION_INIT;
psa_key_derivation_operation_t zero;
- memset( &zero, 0, sizeof( zero ) );
+ memset(&zero, 0, sizeof(zero));
/* A default operation should not be able to report its capacity. */
- TEST_EQUAL( psa_key_derivation_get_capacity( &func, &capacity ),
- PSA_ERROR_BAD_STATE );
- TEST_EQUAL( psa_key_derivation_get_capacity( &init, &capacity ),
- PSA_ERROR_BAD_STATE );
- TEST_EQUAL( psa_key_derivation_get_capacity( &zero, &capacity ),
- PSA_ERROR_BAD_STATE );
+ TEST_EQUAL(psa_key_derivation_get_capacity(&func, &capacity),
+ PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(psa_key_derivation_get_capacity(&init, &capacity),
+ PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(psa_key_derivation_get_capacity(&zero, &capacity),
+ PSA_ERROR_BAD_STATE);
/* A default operation should be abortable without error. */
- PSA_ASSERT( psa_key_derivation_abort(&func) );
- PSA_ASSERT( psa_key_derivation_abort(&init) );
- PSA_ASSERT( psa_key_derivation_abort(&zero) );
+ PSA_ASSERT(psa_key_derivation_abort(&func));
+ PSA_ASSERT(psa_key_derivation_abort(&init));
+ PSA_ASSERT(psa_key_derivation_abort(&zero));
}
/* END_CASE */
/* BEGIN_CASE */
-void derive_setup( int alg_arg, int expected_status_arg )
+void derive_setup(int alg_arg, int expected_status_arg)
{
psa_algorithm_t alg = alg_arg;
psa_status_t expected_status = expected_status_arg;
psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- TEST_EQUAL( psa_key_derivation_setup( &operation, alg ),
- expected_status );
+ TEST_EQUAL(psa_key_derivation_setup(&operation, alg),
+ expected_status);
exit:
- psa_key_derivation_abort( &operation );
- PSA_DONE( );
+ psa_key_derivation_abort(&operation);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void derive_set_capacity( int alg_arg, int capacity_arg,
- int expected_status_arg )
+void derive_set_capacity(int alg_arg, int capacity_arg,
+ int expected_status_arg)
{
psa_algorithm_t alg = alg_arg;
size_t capacity = capacity_arg;
psa_status_t expected_status = expected_status_arg;
psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
+ PSA_ASSERT(psa_key_derivation_setup(&operation, alg));
- TEST_EQUAL( psa_key_derivation_set_capacity( &operation, capacity ),
- expected_status );
+ TEST_EQUAL(psa_key_derivation_set_capacity(&operation, capacity),
+ expected_status);
exit:
- psa_key_derivation_abort( &operation );
- PSA_DONE( );
+ psa_key_derivation_abort(&operation);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void derive_input( int alg_arg,
- int step_arg1, int key_type_arg1, data_t *input1,
- int expected_status_arg1,
- int step_arg2, int key_type_arg2, data_t *input2,
- int expected_status_arg2,
- int step_arg3, int key_type_arg3, data_t *input3,
- int expected_status_arg3,
- int output_key_type_arg, int expected_output_status_arg )
+void derive_input(int alg_arg,
+ int step_arg1, int key_type_arg1, data_t *input1,
+ int expected_status_arg1,
+ int step_arg2, int key_type_arg2, data_t *input2,
+ int expected_status_arg2,
+ int step_arg3, int key_type_arg3, data_t *input3,
+ int expected_status_arg3,
+ int output_key_type_arg, int expected_output_status_arg)
{
psa_algorithm_t alg = alg_arg;
- psa_key_derivation_step_t steps[] = {step_arg1, step_arg2, step_arg3};
- psa_key_type_t key_types[] = {key_type_arg1, key_type_arg2, key_type_arg3};
- psa_status_t expected_statuses[] = {expected_status_arg1,
- expected_status_arg2,
- expected_status_arg3};
- data_t *inputs[] = {input1, input2, input3};
+ psa_key_derivation_step_t steps[] = { step_arg1, step_arg2, step_arg3 };
+ psa_key_type_t key_types[] = { key_type_arg1, key_type_arg2, key_type_arg3 };
+ psa_status_t expected_statuses[] = { expected_status_arg1,
+ expected_status_arg2,
+ expected_status_arg3 };
+ data_t *inputs[] = { input1, input2, input3 };
mbedtls_svc_key_id_t keys[] = { MBEDTLS_SVC_KEY_ID_INIT,
MBEDTLS_SVC_KEY_ID_INIT,
MBEDTLS_SVC_KEY_ID_INIT };
@@ -4496,179 +4507,169 @@
psa_status_t expected_output_status = expected_output_status_arg;
psa_status_t actual_output_status;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
- psa_set_key_algorithm( &attributes, alg );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DERIVE);
+ psa_set_key_algorithm(&attributes, alg);
- PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
+ PSA_ASSERT(psa_key_derivation_setup(&operation, alg));
- for( i = 0; i < ARRAY_LENGTH( steps ); i++ )
- {
- mbedtls_test_set_step( i );
- if( steps[i] == 0 )
- {
+ for (i = 0; i < ARRAY_LENGTH(steps); i++) {
+ mbedtls_test_set_step(i);
+ if (steps[i] == 0) {
/* Skip this step */
- }
- else if( key_types[i] != PSA_KEY_TYPE_NONE )
- {
- psa_set_key_type( &attributes, key_types[i] );
- PSA_ASSERT( psa_import_key( &attributes,
- inputs[i]->x, inputs[i]->len,
- &keys[i] ) );
- if( PSA_KEY_TYPE_IS_KEY_PAIR( key_types[i] ) &&
- steps[i] == PSA_KEY_DERIVATION_INPUT_SECRET )
- {
+ } else if (key_types[i] != PSA_KEY_TYPE_NONE) {
+ psa_set_key_type(&attributes, key_types[i]);
+ PSA_ASSERT(psa_import_key(&attributes,
+ inputs[i]->x, inputs[i]->len,
+ &keys[i]));
+ if (PSA_KEY_TYPE_IS_KEY_PAIR(key_types[i]) &&
+ steps[i] == PSA_KEY_DERIVATION_INPUT_SECRET) {
// When taking a private key as secret input, use key agreement
// to add the shared secret to the derivation
- TEST_EQUAL( mbedtls_test_psa_key_agreement_with_self(
- &operation, keys[i] ),
- expected_statuses[i] );
+ TEST_EQUAL(mbedtls_test_psa_key_agreement_with_self(
+ &operation, keys[i]),
+ expected_statuses[i]);
+ } else {
+ TEST_EQUAL(psa_key_derivation_input_key(&operation, steps[i],
+ keys[i]),
+ expected_statuses[i]);
}
- else
- {
- TEST_EQUAL( psa_key_derivation_input_key( &operation, steps[i],
- keys[i] ),
- expected_statuses[i] );
- }
- }
- else
- {
- TEST_EQUAL( psa_key_derivation_input_bytes(
- &operation, steps[i],
- inputs[i]->x, inputs[i]->len ),
- expected_statuses[i] );
+ } else {
+ TEST_EQUAL(psa_key_derivation_input_bytes(
+ &operation, steps[i],
+ inputs[i]->x, inputs[i]->len),
+ expected_statuses[i]);
}
}
- if( output_key_type != PSA_KEY_TYPE_NONE )
- {
- psa_reset_key_attributes( &attributes );
- psa_set_key_type( &attributes, output_key_type );
- psa_set_key_bits( &attributes, 8 );
+ if (output_key_type != PSA_KEY_TYPE_NONE) {
+ psa_reset_key_attributes(&attributes);
+ psa_set_key_type(&attributes, output_key_type);
+ psa_set_key_bits(&attributes, 8);
actual_output_status =
- psa_key_derivation_output_key( &attributes, &operation,
- &output_key );
- }
- else
- {
+ psa_key_derivation_output_key(&attributes, &operation,
+ &output_key);
+ } else {
uint8_t buffer[1];
actual_output_status =
- psa_key_derivation_output_bytes( &operation,
- buffer, sizeof( buffer ) );
+ psa_key_derivation_output_bytes(&operation,
+ buffer, sizeof(buffer));
}
- TEST_EQUAL( actual_output_status, expected_output_status );
+ TEST_EQUAL(actual_output_status, expected_output_status);
exit:
- psa_key_derivation_abort( &operation );
- for( i = 0; i < ARRAY_LENGTH( keys ); i++ )
- psa_destroy_key( keys[i] );
- psa_destroy_key( output_key );
- PSA_DONE( );
+ psa_key_derivation_abort(&operation);
+ for (i = 0; i < ARRAY_LENGTH(keys); i++) {
+ psa_destroy_key(keys[i]);
+ }
+ psa_destroy_key(output_key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void derive_over_capacity( int alg_arg )
+void derive_over_capacity(int alg_arg)
{
psa_algorithm_t alg = alg_arg;
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
size_t key_type = PSA_KEY_TYPE_DERIVE;
psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
unsigned char input1[] = "Input 1";
- size_t input1_length = sizeof( input1 );
+ size_t input1_length = sizeof(input1);
unsigned char input2[] = "Input 2";
- size_t input2_length = sizeof( input2 );
+ size_t input2_length = sizeof(input2);
uint8_t buffer[42];
- size_t capacity = sizeof( buffer );
+ size_t capacity = sizeof(buffer);
const uint8_t key_data[22] = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
- 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b};
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DERIVE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes,
- key_data, sizeof( key_data ),
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes,
+ key_data, sizeof(key_data),
+ &key));
/* valid key derivation */
- if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, key, alg,
- input1, input1_length,
- input2, input2_length,
- capacity ) )
+ if (!mbedtls_test_psa_setup_key_derivation_wrap(&operation, key, alg,
+ input1, input1_length,
+ input2, input2_length,
+ capacity)) {
goto exit;
+ }
/* state of operation shouldn't allow additional generation */
- TEST_EQUAL( psa_key_derivation_setup( &operation, alg ),
- PSA_ERROR_BAD_STATE );
+ TEST_EQUAL(psa_key_derivation_setup(&operation, alg),
+ PSA_ERROR_BAD_STATE);
- PSA_ASSERT( psa_key_derivation_output_bytes( &operation, buffer, capacity ) );
+ PSA_ASSERT(psa_key_derivation_output_bytes(&operation, buffer, capacity));
- TEST_EQUAL( psa_key_derivation_output_bytes( &operation, buffer, capacity ),
- PSA_ERROR_INSUFFICIENT_DATA );
+ TEST_EQUAL(psa_key_derivation_output_bytes(&operation, buffer, capacity),
+ PSA_ERROR_INSUFFICIENT_DATA);
exit:
- psa_key_derivation_abort( &operation );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_key_derivation_abort(&operation);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void derive_actions_without_setup( )
+void derive_actions_without_setup()
{
uint8_t output_buffer[16];
size_t buffer_size = 16;
size_t capacity = 0;
psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
- TEST_ASSERT( psa_key_derivation_output_bytes( &operation,
- output_buffer, buffer_size )
- == PSA_ERROR_BAD_STATE );
+ TEST_ASSERT(psa_key_derivation_output_bytes(&operation,
+ output_buffer, buffer_size)
+ == PSA_ERROR_BAD_STATE);
- TEST_ASSERT( psa_key_derivation_get_capacity( &operation, &capacity )
- == PSA_ERROR_BAD_STATE );
+ TEST_ASSERT(psa_key_derivation_get_capacity(&operation, &capacity)
+ == PSA_ERROR_BAD_STATE);
- PSA_ASSERT( psa_key_derivation_abort( &operation ) );
+ PSA_ASSERT(psa_key_derivation_abort(&operation));
- TEST_ASSERT( psa_key_derivation_output_bytes( &operation,
- output_buffer, buffer_size )
- == PSA_ERROR_BAD_STATE );
+ TEST_ASSERT(psa_key_derivation_output_bytes(&operation,
+ output_buffer, buffer_size)
+ == PSA_ERROR_BAD_STATE);
- TEST_ASSERT( psa_key_derivation_get_capacity( &operation, &capacity )
- == PSA_ERROR_BAD_STATE );
+ TEST_ASSERT(psa_key_derivation_get_capacity(&operation, &capacity)
+ == PSA_ERROR_BAD_STATE);
exit:
- psa_key_derivation_abort( &operation );
+ psa_key_derivation_abort(&operation);
}
/* END_CASE */
/* BEGIN_CASE */
-void derive_output( int alg_arg,
- int step1_arg, data_t *input1,
- int step2_arg, data_t *input2,
- int step3_arg, data_t *input3,
- int requested_capacity_arg,
- data_t *expected_output1,
- data_t *expected_output2 )
+void derive_output(int alg_arg,
+ int step1_arg, data_t *input1,
+ int step2_arg, data_t *input2,
+ int step3_arg, data_t *input3,
+ int requested_capacity_arg,
+ data_t *expected_output1,
+ data_t *expected_output2)
{
psa_algorithm_t alg = alg_arg;
- psa_key_derivation_step_t steps[] = {step1_arg, step2_arg, step3_arg};
- data_t *inputs[] = {input1, input2, input3};
+ psa_key_derivation_step_t steps[] = { step1_arg, step2_arg, step3_arg };
+ data_t *inputs[] = { input1, input2, input3 };
mbedtls_svc_key_id_t keys[] = { MBEDTLS_SVC_KEY_ID_INIT,
MBEDTLS_SVC_KEY_ID_INIT,
MBEDTLS_SVC_KEY_ID_INIT };
size_t requested_capacity = requested_capacity_arg;
psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
uint8_t *expected_outputs[2] =
- {expected_output1->x, expected_output2->x};
+ { expected_output1->x, expected_output2->x };
size_t output_sizes[2] =
- {expected_output1->len, expected_output2->len};
+ { expected_output1->len, expected_output2->len };
size_t output_buffer_size = 0;
uint8_t *output_buffer = NULL;
size_t expected_capacity;
@@ -4677,107 +4678,103 @@
psa_status_t status;
size_t i;
- for( i = 0; i < ARRAY_LENGTH( expected_outputs ); i++ )
- {
- if( output_sizes[i] > output_buffer_size )
+ for (i = 0; i < ARRAY_LENGTH(expected_outputs); i++) {
+ if (output_sizes[i] > output_buffer_size) {
output_buffer_size = output_sizes[i];
- if( output_sizes[i] == 0 )
+ }
+ if (output_sizes[i] == 0) {
expected_outputs[i] = NULL;
+ }
}
- ASSERT_ALLOC( output_buffer, output_buffer_size );
- PSA_ASSERT( psa_crypto_init( ) );
+ ASSERT_ALLOC(output_buffer, output_buffer_size);
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_DERIVE );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DERIVE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_DERIVE);
/* Extraction phase. */
- PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
- PSA_ASSERT( psa_key_derivation_set_capacity( &operation,
- requested_capacity ) );
- for( i = 0; i < ARRAY_LENGTH( steps ); i++ )
- {
- switch( steps[i] )
- {
+ PSA_ASSERT(psa_key_derivation_setup(&operation, alg));
+ PSA_ASSERT(psa_key_derivation_set_capacity(&operation,
+ requested_capacity));
+ for (i = 0; i < ARRAY_LENGTH(steps); i++) {
+ switch (steps[i]) {
case 0:
break;
case PSA_KEY_DERIVATION_INPUT_SECRET:
- PSA_ASSERT( psa_import_key( &attributes,
- inputs[i]->x, inputs[i]->len,
- &keys[i] ) );
+ PSA_ASSERT(psa_import_key(&attributes,
+ inputs[i]->x, inputs[i]->len,
+ &keys[i]));
- if ( PSA_ALG_IS_TLS12_PSK_TO_MS( alg ) )
- {
- PSA_ASSERT( psa_get_key_attributes( keys[i], &attributes ) );
- TEST_ASSERT( PSA_BITS_TO_BYTES( psa_get_key_bits( &attributes ) ) <=
- PSA_TLS12_PSK_TO_MS_PSK_MAX_SIZE );
+ if (PSA_ALG_IS_TLS12_PSK_TO_MS(alg)) {
+ PSA_ASSERT(psa_get_key_attributes(keys[i], &attributes));
+ TEST_ASSERT(PSA_BITS_TO_BYTES(psa_get_key_bits(&attributes)) <=
+ PSA_TLS12_PSK_TO_MS_PSK_MAX_SIZE);
}
- PSA_ASSERT( psa_key_derivation_input_key(
- &operation, steps[i], keys[i] ) );
+ PSA_ASSERT(psa_key_derivation_input_key(
+ &operation, steps[i], keys[i]));
break;
default:
- PSA_ASSERT( psa_key_derivation_input_bytes(
- &operation, steps[i],
- inputs[i]->x, inputs[i]->len ) );
+ PSA_ASSERT(psa_key_derivation_input_bytes(
+ &operation, steps[i],
+ inputs[i]->x, inputs[i]->len));
break;
}
}
- PSA_ASSERT( psa_key_derivation_get_capacity( &operation,
- ¤t_capacity ) );
- TEST_EQUAL( current_capacity, requested_capacity );
+ PSA_ASSERT(psa_key_derivation_get_capacity(&operation,
+ ¤t_capacity));
+ TEST_EQUAL(current_capacity, requested_capacity);
expected_capacity = requested_capacity;
/* Expansion phase. */
- for( i = 0; i < ARRAY_LENGTH( expected_outputs ); i++ )
- {
+ for (i = 0; i < ARRAY_LENGTH(expected_outputs); i++) {
/* Read some bytes. */
- status = psa_key_derivation_output_bytes( &operation,
- output_buffer, output_sizes[i] );
- if( expected_capacity == 0 && output_sizes[i] == 0 )
- {
+ status = psa_key_derivation_output_bytes(&operation,
+ output_buffer, output_sizes[i]);
+ if (expected_capacity == 0 && output_sizes[i] == 0) {
/* Reading 0 bytes when 0 bytes are available can go either way. */
- TEST_ASSERT( status == PSA_SUCCESS ||
- status == PSA_ERROR_INSUFFICIENT_DATA );
+ TEST_ASSERT(status == PSA_SUCCESS ||
+ status == PSA_ERROR_INSUFFICIENT_DATA);
continue;
- }
- else if( expected_capacity == 0 ||
- output_sizes[i] > expected_capacity )
- {
+ } else if (expected_capacity == 0 ||
+ output_sizes[i] > expected_capacity) {
/* Capacity exceeded. */
- TEST_EQUAL( status, PSA_ERROR_INSUFFICIENT_DATA );
+ TEST_EQUAL(status, PSA_ERROR_INSUFFICIENT_DATA);
expected_capacity = 0;
continue;
}
/* Success. Check the read data. */
- PSA_ASSERT( status );
- if( output_sizes[i] != 0 )
- ASSERT_COMPARE( output_buffer, output_sizes[i],
- expected_outputs[i], output_sizes[i] );
+ PSA_ASSERT(status);
+ if (output_sizes[i] != 0) {
+ ASSERT_COMPARE(output_buffer, output_sizes[i],
+ expected_outputs[i], output_sizes[i]);
+ }
/* Check the operation status. */
expected_capacity -= output_sizes[i];
- PSA_ASSERT( psa_key_derivation_get_capacity( &operation,
- ¤t_capacity ) );
- TEST_EQUAL( expected_capacity, current_capacity );
+ PSA_ASSERT(psa_key_derivation_get_capacity(&operation,
+ ¤t_capacity));
+ TEST_EQUAL(expected_capacity, current_capacity);
}
- PSA_ASSERT( psa_key_derivation_abort( &operation ) );
+ PSA_ASSERT(psa_key_derivation_abort(&operation));
exit:
- mbedtls_free( output_buffer );
- psa_key_derivation_abort( &operation );
- for( i = 0; i < ARRAY_LENGTH( keys ); i++ )
- psa_destroy_key( keys[i] );
- PSA_DONE( );
+ mbedtls_free(output_buffer);
+ psa_key_derivation_abort(&operation);
+ for (i = 0; i < ARRAY_LENGTH(keys); i++) {
+ psa_destroy_key(keys[i]);
+ }
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void derive_full( int alg_arg,
- data_t *key_data,
- data_t *input1,
- data_t *input2,
- int requested_capacity_arg )
+void derive_full(int alg_arg,
+ data_t *key_data,
+ data_t *input1,
+ data_t *input2,
+ int requested_capacity_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_algorithm_t alg = alg_arg;
@@ -4788,62 +4785,63 @@
size_t current_capacity;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_DERIVE );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DERIVE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_DERIVE);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, key, alg,
- input1->x, input1->len,
- input2->x, input2->len,
- requested_capacity ) )
+ if (!mbedtls_test_psa_setup_key_derivation_wrap(&operation, key, alg,
+ input1->x, input1->len,
+ input2->x, input2->len,
+ requested_capacity)) {
goto exit;
+ }
- PSA_ASSERT( psa_key_derivation_get_capacity( &operation,
- ¤t_capacity ) );
- TEST_EQUAL( current_capacity, expected_capacity );
+ PSA_ASSERT(psa_key_derivation_get_capacity(&operation,
+ ¤t_capacity));
+ TEST_EQUAL(current_capacity, expected_capacity);
/* Expansion phase. */
- while( current_capacity > 0 )
- {
- size_t read_size = sizeof( output_buffer );
- if( read_size > current_capacity )
+ while (current_capacity > 0) {
+ size_t read_size = sizeof(output_buffer);
+ if (read_size > current_capacity) {
read_size = current_capacity;
- PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
- output_buffer,
- read_size ) );
+ }
+ PSA_ASSERT(psa_key_derivation_output_bytes(&operation,
+ output_buffer,
+ read_size));
expected_capacity -= read_size;
- PSA_ASSERT( psa_key_derivation_get_capacity( &operation,
- ¤t_capacity ) );
- TEST_EQUAL( current_capacity, expected_capacity );
+ PSA_ASSERT(psa_key_derivation_get_capacity(&operation,
+ ¤t_capacity));
+ TEST_EQUAL(current_capacity, expected_capacity);
}
/* Check that the operation refuses to go over capacity. */
- TEST_EQUAL( psa_key_derivation_output_bytes( &operation, output_buffer, 1 ),
- PSA_ERROR_INSUFFICIENT_DATA );
+ TEST_EQUAL(psa_key_derivation_output_bytes(&operation, output_buffer, 1),
+ PSA_ERROR_INSUFFICIENT_DATA);
- PSA_ASSERT( psa_key_derivation_abort( &operation ) );
+ PSA_ASSERT(psa_key_derivation_abort(&operation));
exit:
- psa_key_derivation_abort( &operation );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_key_derivation_abort(&operation);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void derive_key_exercise( int alg_arg,
- data_t *key_data,
- data_t *input1,
- data_t *input2,
- int derived_type_arg,
- int derived_bits_arg,
- int derived_usage_arg,
- int derived_alg_arg )
+void derive_key_exercise(int alg_arg,
+ data_t *key_data,
+ data_t *input1,
+ data_t *input2,
+ int derived_type_arg,
+ int derived_bits_arg,
+ int derived_usage_arg,
+ int derived_alg_arg)
{
mbedtls_svc_key_id_t base_key = MBEDTLS_SVC_KEY_ID_INIT;
mbedtls_svc_key_id_t derived_key = MBEDTLS_SVC_KEY_ID_INIT;
@@ -4852,63 +4850,65 @@
size_t derived_bits = derived_bits_arg;
psa_key_usage_t derived_usage = derived_usage_arg;
psa_algorithm_t derived_alg = derived_alg_arg;
- size_t capacity = PSA_BITS_TO_BYTES( derived_bits );
+ size_t capacity = PSA_BITS_TO_BYTES(derived_bits);
psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_DERIVE );
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &base_key ) );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DERIVE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_DERIVE);
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &base_key));
/* Derive a key. */
- if ( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, base_key, alg,
- input1->x, input1->len,
- input2->x, input2->len,
- capacity ) )
+ if (!mbedtls_test_psa_setup_key_derivation_wrap(&operation, base_key, alg,
+ input1->x, input1->len,
+ input2->x, input2->len,
+ capacity)) {
goto exit;
+ }
- psa_set_key_usage_flags( &attributes, derived_usage );
- psa_set_key_algorithm( &attributes, derived_alg );
- psa_set_key_type( &attributes, derived_type );
- psa_set_key_bits( &attributes, derived_bits );
- PSA_ASSERT( psa_key_derivation_output_key( &attributes, &operation,
- &derived_key ) );
+ psa_set_key_usage_flags(&attributes, derived_usage);
+ psa_set_key_algorithm(&attributes, derived_alg);
+ psa_set_key_type(&attributes, derived_type);
+ psa_set_key_bits(&attributes, derived_bits);
+ PSA_ASSERT(psa_key_derivation_output_key(&attributes, &operation,
+ &derived_key));
/* Test the key information */
- PSA_ASSERT( psa_get_key_attributes( derived_key, &got_attributes ) );
- TEST_EQUAL( psa_get_key_type( &got_attributes ), derived_type );
- TEST_EQUAL( psa_get_key_bits( &got_attributes ), derived_bits );
+ PSA_ASSERT(psa_get_key_attributes(derived_key, &got_attributes));
+ TEST_EQUAL(psa_get_key_type(&got_attributes), derived_type);
+ TEST_EQUAL(psa_get_key_bits(&got_attributes), derived_bits);
/* Exercise the derived key. */
- if( ! mbedtls_test_psa_exercise_key( derived_key, derived_usage, derived_alg ) )
+ if (!mbedtls_test_psa_exercise_key(derived_key, derived_usage, derived_alg)) {
goto exit;
+ }
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &got_attributes );
+ psa_reset_key_attributes(&got_attributes);
- psa_key_derivation_abort( &operation );
- psa_destroy_key( base_key );
- psa_destroy_key( derived_key );
- PSA_DONE( );
+ psa_key_derivation_abort(&operation);
+ psa_destroy_key(base_key);
+ psa_destroy_key(derived_key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void derive_key_export( int alg_arg,
- data_t *key_data,
- data_t *input1,
- data_t *input2,
- int bytes1_arg,
- int bytes2_arg )
+void derive_key_export(int alg_arg,
+ data_t *key_data,
+ data_t *input1,
+ data_t *input2,
+ int bytes1_arg,
+ int bytes2_arg)
{
mbedtls_svc_key_id_t base_key = MBEDTLS_SVC_KEY_ID_INIT;
mbedtls_svc_key_id_t derived_key = MBEDTLS_SVC_KEY_ID_INIT;
@@ -4923,74 +4923,76 @@
psa_key_attributes_t derived_attributes = PSA_KEY_ATTRIBUTES_INIT;
size_t length;
- ASSERT_ALLOC( output_buffer, capacity );
- ASSERT_ALLOC( export_buffer, capacity );
- PSA_ASSERT( psa_crypto_init( ) );
+ ASSERT_ALLOC(output_buffer, capacity);
+ ASSERT_ALLOC(export_buffer, capacity);
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &base_attributes, PSA_KEY_USAGE_DERIVE );
- psa_set_key_algorithm( &base_attributes, alg );
- psa_set_key_type( &base_attributes, PSA_KEY_TYPE_DERIVE );
- PSA_ASSERT( psa_import_key( &base_attributes, key_data->x, key_data->len,
- &base_key ) );
+ psa_set_key_usage_flags(&base_attributes, PSA_KEY_USAGE_DERIVE);
+ psa_set_key_algorithm(&base_attributes, alg);
+ psa_set_key_type(&base_attributes, PSA_KEY_TYPE_DERIVE);
+ PSA_ASSERT(psa_import_key(&base_attributes, key_data->x, key_data->len,
+ &base_key));
/* Derive some material and output it. */
- if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, base_key, alg,
- input1->x, input1->len,
- input2->x, input2->len,
- capacity ) )
+ if (!mbedtls_test_psa_setup_key_derivation_wrap(&operation, base_key, alg,
+ input1->x, input1->len,
+ input2->x, input2->len,
+ capacity)) {
goto exit;
+ }
- PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
- output_buffer,
- capacity ) );
- PSA_ASSERT( psa_key_derivation_abort( &operation ) );
+ PSA_ASSERT(psa_key_derivation_output_bytes(&operation,
+ output_buffer,
+ capacity));
+ PSA_ASSERT(psa_key_derivation_abort(&operation));
/* Derive the same output again, but this time store it in key objects. */
- if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, base_key, alg,
- input1->x, input1->len,
- input2->x, input2->len,
- capacity ) )
+ if (!mbedtls_test_psa_setup_key_derivation_wrap(&operation, base_key, alg,
+ input1->x, input1->len,
+ input2->x, input2->len,
+ capacity)) {
goto exit;
+ }
- psa_set_key_usage_flags( &derived_attributes, PSA_KEY_USAGE_EXPORT );
- psa_set_key_algorithm( &derived_attributes, 0 );
- psa_set_key_type( &derived_attributes, PSA_KEY_TYPE_RAW_DATA );
- psa_set_key_bits( &derived_attributes, PSA_BYTES_TO_BITS( bytes1 ) );
- PSA_ASSERT( psa_key_derivation_output_key( &derived_attributes, &operation,
- &derived_key ) );
- PSA_ASSERT( psa_export_key( derived_key,
- export_buffer, bytes1,
- &length ) );
- TEST_EQUAL( length, bytes1 );
- PSA_ASSERT( psa_destroy_key( derived_key ) );
- psa_set_key_bits( &derived_attributes, PSA_BYTES_TO_BITS( bytes2 ) );
- PSA_ASSERT( psa_key_derivation_output_key( &derived_attributes, &operation,
- &derived_key ) );
- PSA_ASSERT( psa_export_key( derived_key,
- export_buffer + bytes1, bytes2,
- &length ) );
- TEST_EQUAL( length, bytes2 );
+ psa_set_key_usage_flags(&derived_attributes, PSA_KEY_USAGE_EXPORT);
+ psa_set_key_algorithm(&derived_attributes, 0);
+ psa_set_key_type(&derived_attributes, PSA_KEY_TYPE_RAW_DATA);
+ psa_set_key_bits(&derived_attributes, PSA_BYTES_TO_BITS(bytes1));
+ PSA_ASSERT(psa_key_derivation_output_key(&derived_attributes, &operation,
+ &derived_key));
+ PSA_ASSERT(psa_export_key(derived_key,
+ export_buffer, bytes1,
+ &length));
+ TEST_EQUAL(length, bytes1);
+ PSA_ASSERT(psa_destroy_key(derived_key));
+ psa_set_key_bits(&derived_attributes, PSA_BYTES_TO_BITS(bytes2));
+ PSA_ASSERT(psa_key_derivation_output_key(&derived_attributes, &operation,
+ &derived_key));
+ PSA_ASSERT(psa_export_key(derived_key,
+ export_buffer + bytes1, bytes2,
+ &length));
+ TEST_EQUAL(length, bytes2);
/* Compare the outputs from the two runs. */
- ASSERT_COMPARE( output_buffer, bytes1 + bytes2,
- export_buffer, capacity );
+ ASSERT_COMPARE(output_buffer, bytes1 + bytes2,
+ export_buffer, capacity);
exit:
- mbedtls_free( output_buffer );
- mbedtls_free( export_buffer );
- psa_key_derivation_abort( &operation );
- psa_destroy_key( base_key );
- psa_destroy_key( derived_key );
- PSA_DONE( );
+ mbedtls_free(output_buffer);
+ mbedtls_free(export_buffer);
+ psa_key_derivation_abort(&operation);
+ psa_destroy_key(base_key);
+ psa_destroy_key(derived_key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void derive_key( int alg_arg,
- data_t *key_data, data_t *input1, data_t *input2,
- int type_arg, int bits_arg,
- int expected_status_arg,
- int is_large_output )
+void derive_key(int alg_arg,
+ data_t *key_data, data_t *input1, data_t *input2,
+ int type_arg, int bits_arg,
+ int expected_status_arg,
+ int is_large_output)
{
mbedtls_svc_key_id_t base_key = MBEDTLS_SVC_KEY_ID_INIT;
mbedtls_svc_key_id_t derived_key = MBEDTLS_SVC_KEY_ID_INIT;
@@ -5002,46 +5004,48 @@
psa_key_attributes_t base_attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_attributes_t derived_attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &base_attributes, PSA_KEY_USAGE_DERIVE );
- psa_set_key_algorithm( &base_attributes, alg );
- psa_set_key_type( &base_attributes, PSA_KEY_TYPE_DERIVE );
- PSA_ASSERT( psa_import_key( &base_attributes, key_data->x, key_data->len,
- &base_key ) );
+ psa_set_key_usage_flags(&base_attributes, PSA_KEY_USAGE_DERIVE);
+ psa_set_key_algorithm(&base_attributes, alg);
+ psa_set_key_type(&base_attributes, PSA_KEY_TYPE_DERIVE);
+ PSA_ASSERT(psa_import_key(&base_attributes, key_data->x, key_data->len,
+ &base_key));
- if( !mbedtls_test_psa_setup_key_derivation_wrap( &operation, base_key, alg,
- input1->x, input1->len,
- input2->x, input2->len,
- SIZE_MAX ) )
+ if (!mbedtls_test_psa_setup_key_derivation_wrap(&operation, base_key, alg,
+ input1->x, input1->len,
+ input2->x, input2->len,
+ SIZE_MAX)) {
goto exit;
+ }
- psa_set_key_usage_flags( &derived_attributes, PSA_KEY_USAGE_EXPORT );
- psa_set_key_algorithm( &derived_attributes, 0 );
- psa_set_key_type( &derived_attributes, type );
- psa_set_key_bits( &derived_attributes, bits );
+ psa_set_key_usage_flags(&derived_attributes, PSA_KEY_USAGE_EXPORT);
+ psa_set_key_algorithm(&derived_attributes, 0);
+ psa_set_key_type(&derived_attributes, type);
+ psa_set_key_bits(&derived_attributes, bits);
psa_status_t status =
- psa_key_derivation_output_key( &derived_attributes,
- &operation,
- &derived_key );
- if( is_large_output > 0 )
- TEST_ASSUME( status != PSA_ERROR_INSUFFICIENT_MEMORY );
- TEST_EQUAL( status, expected_status );
+ psa_key_derivation_output_key(&derived_attributes,
+ &operation,
+ &derived_key);
+ if (is_large_output > 0) {
+ TEST_ASSUME(status != PSA_ERROR_INSUFFICIENT_MEMORY);
+ }
+ TEST_EQUAL(status, expected_status);
exit:
- psa_key_derivation_abort( &operation );
- psa_destroy_key( base_key );
- psa_destroy_key( derived_key );
- PSA_DONE( );
+ psa_key_derivation_abort(&operation);
+ psa_destroy_key(base_key);
+ psa_destroy_key(derived_key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void key_agreement_setup( int alg_arg,
- int our_key_type_arg, int our_key_alg_arg,
- data_t *our_key_data, data_t *peer_key_data,
- int expected_status_arg )
+void key_agreement_setup(int alg_arg,
+ int our_key_type_arg, int our_key_alg_arg,
+ data_t *our_key_data, data_t *peer_key_data,
+ int expected_status_arg)
{
mbedtls_svc_key_id_t our_key = MBEDTLS_SVC_KEY_ID_INIT;
psa_algorithm_t alg = alg_arg;
@@ -5052,45 +5056,42 @@
psa_status_t expected_status = expected_status_arg;
psa_status_t status;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
- psa_set_key_algorithm( &attributes, our_key_alg );
- psa_set_key_type( &attributes, our_key_type );
- PSA_ASSERT( psa_import_key( &attributes,
- our_key_data->x, our_key_data->len,
- &our_key ) );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DERIVE);
+ psa_set_key_algorithm(&attributes, our_key_alg);
+ psa_set_key_type(&attributes, our_key_type);
+ PSA_ASSERT(psa_import_key(&attributes,
+ our_key_data->x, our_key_data->len,
+ &our_key));
/* The tests currently include inputs that should fail at either step.
* Test cases that fail at the setup step should be changed to call
* key_derivation_setup instead, and this function should be renamed
* to key_agreement_fail. */
- status = psa_key_derivation_setup( &operation, alg );
- if( status == PSA_SUCCESS )
- {
- TEST_EQUAL( psa_key_derivation_key_agreement(
- &operation, PSA_KEY_DERIVATION_INPUT_SECRET,
- our_key,
- peer_key_data->x, peer_key_data->len ),
- expected_status );
- }
- else
- {
- TEST_ASSERT( status == expected_status );
+ status = psa_key_derivation_setup(&operation, alg);
+ if (status == PSA_SUCCESS) {
+ TEST_EQUAL(psa_key_derivation_key_agreement(
+ &operation, PSA_KEY_DERIVATION_INPUT_SECRET,
+ our_key,
+ peer_key_data->x, peer_key_data->len),
+ expected_status);
+ } else {
+ TEST_ASSERT(status == expected_status);
}
exit:
- psa_key_derivation_abort( &operation );
- psa_destroy_key( our_key );
- PSA_DONE( );
+ psa_key_derivation_abort(&operation);
+ psa_destroy_key(our_key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void raw_key_agreement( int alg_arg,
- int our_key_type_arg, data_t *our_key_data,
- data_t *peer_key_data,
- data_t *expected_output )
+void raw_key_agreement(int alg_arg,
+ int our_key_type_arg, data_t *our_key_data,
+ data_t *peer_key_data,
+ data_t *expected_output)
{
mbedtls_svc_key_id_t our_key = MBEDTLS_SVC_KEY_ID_INIT;
psa_algorithm_t alg = alg_arg;
@@ -5100,72 +5101,72 @@
size_t output_length = ~0;
size_t key_bits;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, our_key_type );
- PSA_ASSERT( psa_import_key( &attributes,
- our_key_data->x, our_key_data->len,
- &our_key ) );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DERIVE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, our_key_type);
+ PSA_ASSERT(psa_import_key(&attributes,
+ our_key_data->x, our_key_data->len,
+ &our_key));
- PSA_ASSERT( psa_get_key_attributes( our_key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
+ PSA_ASSERT(psa_get_key_attributes(our_key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
/* Validate size macros */
- TEST_LE_U( expected_output->len,
- PSA_RAW_KEY_AGREEMENT_OUTPUT_SIZE( our_key_type, key_bits ) );
- TEST_LE_U( PSA_RAW_KEY_AGREEMENT_OUTPUT_SIZE( our_key_type, key_bits ),
- PSA_RAW_KEY_AGREEMENT_OUTPUT_MAX_SIZE );
+ TEST_LE_U(expected_output->len,
+ PSA_RAW_KEY_AGREEMENT_OUTPUT_SIZE(our_key_type, key_bits));
+ TEST_LE_U(PSA_RAW_KEY_AGREEMENT_OUTPUT_SIZE(our_key_type, key_bits),
+ PSA_RAW_KEY_AGREEMENT_OUTPUT_MAX_SIZE);
/* Good case with exact output size */
- ASSERT_ALLOC( 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,
- &output_length ) );
- ASSERT_COMPARE( output, output_length,
- expected_output->x, expected_output->len );
- mbedtls_free( output );
+ ASSERT_ALLOC(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,
+ &output_length));
+ ASSERT_COMPARE(output, output_length,
+ expected_output->x, expected_output->len);
+ mbedtls_free(output);
output = NULL;
output_length = ~0;
/* Larger buffer */
- ASSERT_ALLOC( 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,
- &output_length ) );
- ASSERT_COMPARE( output, output_length,
- expected_output->x, expected_output->len );
- mbedtls_free( output );
+ ASSERT_ALLOC(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,
+ &output_length));
+ ASSERT_COMPARE(output, output_length,
+ expected_output->x, expected_output->len);
+ mbedtls_free(output);
output = NULL;
output_length = ~0;
/* Buffer too small */
- ASSERT_ALLOC( 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,
- &output_length ),
- PSA_ERROR_BUFFER_TOO_SMALL );
+ ASSERT_ALLOC(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,
+ &output_length),
+ PSA_ERROR_BUFFER_TOO_SMALL);
/* Not required by the spec, but good robustness */
- TEST_LE_U( output_length, expected_output->len - 1 );
- mbedtls_free( output );
+ TEST_LE_U(output_length, expected_output->len - 1);
+ mbedtls_free(output);
output = NULL;
exit:
- mbedtls_free( output );
- psa_destroy_key( our_key );
- PSA_DONE( );
+ mbedtls_free(output);
+ psa_destroy_key(our_key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void key_agreement_capacity( int alg_arg,
- int our_key_type_arg, data_t *our_key_data,
- data_t *peer_key_data,
- int expected_capacity_arg )
+void key_agreement_capacity(int alg_arg,
+ int our_key_type_arg, data_t *our_key_data,
+ data_t *peer_key_data,
+ int expected_capacity_arg)
{
mbedtls_svc_key_id_t our_key = MBEDTLS_SVC_KEY_ID_INIT;
psa_algorithm_t alg = alg_arg;
@@ -5175,57 +5176,55 @@
size_t actual_capacity;
unsigned char output[16];
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, our_key_type );
- PSA_ASSERT( psa_import_key( &attributes,
- our_key_data->x, our_key_data->len,
- &our_key ) );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DERIVE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, our_key_type);
+ PSA_ASSERT(psa_import_key(&attributes,
+ our_key_data->x, our_key_data->len,
+ &our_key));
- PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
- PSA_ASSERT( psa_key_derivation_key_agreement(
- &operation,
- PSA_KEY_DERIVATION_INPUT_SECRET, our_key,
- peer_key_data->x, peer_key_data->len ) );
- if( PSA_ALG_IS_HKDF( PSA_ALG_KEY_AGREEMENT_GET_KDF( alg ) ) )
- {
+ PSA_ASSERT(psa_key_derivation_setup(&operation, alg));
+ PSA_ASSERT(psa_key_derivation_key_agreement(
+ &operation,
+ PSA_KEY_DERIVATION_INPUT_SECRET, our_key,
+ peer_key_data->x, peer_key_data->len));
+ if (PSA_ALG_IS_HKDF(PSA_ALG_KEY_AGREEMENT_GET_KDF(alg))) {
/* The test data is for info="" */
- PSA_ASSERT( psa_key_derivation_input_bytes( &operation,
- PSA_KEY_DERIVATION_INPUT_INFO,
- NULL, 0 ) );
+ PSA_ASSERT(psa_key_derivation_input_bytes(&operation,
+ PSA_KEY_DERIVATION_INPUT_INFO,
+ NULL, 0));
}
/* Test the advertised capacity. */
- PSA_ASSERT( psa_key_derivation_get_capacity(
- &operation, &actual_capacity ) );
- TEST_EQUAL( actual_capacity, (size_t) expected_capacity_arg );
+ PSA_ASSERT(psa_key_derivation_get_capacity(
+ &operation, &actual_capacity));
+ TEST_EQUAL(actual_capacity, (size_t) expected_capacity_arg);
/* Test the actual capacity by reading the output. */
- while( actual_capacity > sizeof( output ) )
- {
- PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
- output, sizeof( output ) ) );
- actual_capacity -= sizeof( output );
+ while (actual_capacity > sizeof(output)) {
+ PSA_ASSERT(psa_key_derivation_output_bytes(&operation,
+ output, sizeof(output)));
+ actual_capacity -= sizeof(output);
}
- PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
- output, actual_capacity ) );
- TEST_EQUAL( psa_key_derivation_output_bytes( &operation, output, 1 ),
- PSA_ERROR_INSUFFICIENT_DATA );
+ PSA_ASSERT(psa_key_derivation_output_bytes(&operation,
+ output, actual_capacity));
+ TEST_EQUAL(psa_key_derivation_output_bytes(&operation, output, 1),
+ PSA_ERROR_INSUFFICIENT_DATA);
exit:
- psa_key_derivation_abort( &operation );
- psa_destroy_key( our_key );
- PSA_DONE( );
+ psa_key_derivation_abort(&operation);
+ psa_destroy_key(our_key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void key_agreement_output( int alg_arg,
- int our_key_type_arg, data_t *our_key_data,
- data_t *peer_key_data,
- data_t *expected_output1, data_t *expected_output2 )
+void key_agreement_output(int alg_arg,
+ int our_key_type_arg, data_t *our_key_data,
+ data_t *peer_key_data,
+ data_t *expected_output1, data_t *expected_output2)
{
mbedtls_svc_key_id_t our_key = MBEDTLS_SVC_KEY_ID_INIT;
psa_algorithm_t alg = alg_arg;
@@ -5234,55 +5233,53 @@
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
uint8_t *actual_output = NULL;
- ASSERT_ALLOC( actual_output, MAX( expected_output1->len,
- expected_output2->len ) );
+ ASSERT_ALLOC(actual_output, MAX(expected_output1->len,
+ expected_output2->len));
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DERIVE );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, our_key_type );
- PSA_ASSERT( psa_import_key( &attributes,
- our_key_data->x, our_key_data->len,
- &our_key ) );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DERIVE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, our_key_type);
+ PSA_ASSERT(psa_import_key(&attributes,
+ our_key_data->x, our_key_data->len,
+ &our_key));
- PSA_ASSERT( psa_key_derivation_setup( &operation, alg ) );
- PSA_ASSERT( psa_key_derivation_key_agreement(
- &operation,
- PSA_KEY_DERIVATION_INPUT_SECRET, our_key,
- peer_key_data->x, peer_key_data->len ) );
- if( PSA_ALG_IS_HKDF( PSA_ALG_KEY_AGREEMENT_GET_KDF( alg ) ) )
- {
+ PSA_ASSERT(psa_key_derivation_setup(&operation, alg));
+ PSA_ASSERT(psa_key_derivation_key_agreement(
+ &operation,
+ PSA_KEY_DERIVATION_INPUT_SECRET, our_key,
+ peer_key_data->x, peer_key_data->len));
+ if (PSA_ALG_IS_HKDF(PSA_ALG_KEY_AGREEMENT_GET_KDF(alg))) {
/* The test data is for info="" */
- PSA_ASSERT( psa_key_derivation_input_bytes( &operation,
- PSA_KEY_DERIVATION_INPUT_INFO,
- NULL, 0 ) );
+ PSA_ASSERT(psa_key_derivation_input_bytes(&operation,
+ PSA_KEY_DERIVATION_INPUT_INFO,
+ NULL, 0));
}
- PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
- actual_output,
- expected_output1->len ) );
- ASSERT_COMPARE( actual_output, expected_output1->len,
- expected_output1->x, expected_output1->len );
- if( expected_output2->len != 0 )
- {
- PSA_ASSERT( psa_key_derivation_output_bytes( &operation,
- actual_output,
- expected_output2->len ) );
- ASSERT_COMPARE( actual_output, expected_output2->len,
- expected_output2->x, expected_output2->len );
+ PSA_ASSERT(psa_key_derivation_output_bytes(&operation,
+ actual_output,
+ expected_output1->len));
+ ASSERT_COMPARE(actual_output, expected_output1->len,
+ expected_output1->x, expected_output1->len);
+ if (expected_output2->len != 0) {
+ PSA_ASSERT(psa_key_derivation_output_bytes(&operation,
+ actual_output,
+ expected_output2->len));
+ ASSERT_COMPARE(actual_output, expected_output2->len,
+ expected_output2->x, expected_output2->len);
}
exit:
- psa_key_derivation_abort( &operation );
- psa_destroy_key( our_key );
- PSA_DONE( );
- mbedtls_free( actual_output );
+ psa_key_derivation_abort(&operation);
+ psa_destroy_key(our_key);
+ PSA_DONE();
+ mbedtls_free(actual_output);
}
/* END_CASE */
/* BEGIN_CASE */
-void generate_random( int bytes_arg )
+void generate_random(int bytes_arg)
{
size_t bytes = bytes_arg;
unsigned char *output = NULL;
@@ -5290,51 +5287,50 @@
size_t i;
unsigned run;
- TEST_ASSERT( bytes_arg >= 0 );
+ TEST_ASSERT(bytes_arg >= 0);
- ASSERT_ALLOC( output, bytes );
- ASSERT_ALLOC( changed, bytes );
+ ASSERT_ALLOC(output, bytes);
+ ASSERT_ALLOC(changed, bytes);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* Run several times, to ensure that every output byte will be
* nonzero at least once with overwhelming probability
* (2^(-8*number_of_runs)). */
- for( run = 0; run < 10; run++ )
- {
- if( bytes != 0 )
- memset( output, 0, bytes );
- PSA_ASSERT( psa_generate_random( output, bytes ) );
+ for (run = 0; run < 10; run++) {
+ if (bytes != 0) {
+ memset(output, 0, bytes);
+ }
+ PSA_ASSERT(psa_generate_random(output, bytes));
- for( i = 0; i < bytes; i++ )
- {
- if( output[i] != 0 )
+ for (i = 0; i < bytes; i++) {
+ if (output[i] != 0) {
++changed[i];
+ }
}
}
/* Check that every byte was changed to nonzero at least once. This
* validates that psa_generate_random is overwriting every byte of
* the output buffer. */
- for( i = 0; i < bytes; i++ )
- {
- TEST_ASSERT( changed[i] != 0 );
+ for (i = 0; i < bytes; i++) {
+ TEST_ASSERT(changed[i] != 0);
}
exit:
- PSA_DONE( );
- mbedtls_free( output );
- mbedtls_free( changed );
+ PSA_DONE();
+ mbedtls_free(output);
+ mbedtls_free(changed);
}
/* END_CASE */
/* BEGIN_CASE */
-void generate_key( int type_arg,
- int bits_arg,
- int usage_arg,
- int alg_arg,
- int expected_status_arg,
- int is_large_key )
+void generate_key(int type_arg,
+ int bits_arg,
+ int usage_arg,
+ int alg_arg,
+ int expected_status_arg,
+ int is_large_key)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t type = type_arg;
@@ -5345,47 +5341,50 @@
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_attributes_t got_attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, usage );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, type );
- psa_set_key_bits( &attributes, bits );
+ psa_set_key_usage_flags(&attributes, usage);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, type);
+ psa_set_key_bits(&attributes, bits);
/* Generate a key */
- psa_status_t status = psa_generate_key( &attributes, &key );
+ psa_status_t status = psa_generate_key(&attributes, &key);
- if( is_large_key > 0 )
- TEST_ASSUME( status != PSA_ERROR_INSUFFICIENT_MEMORY );
- TEST_EQUAL( status , expected_status );
- if( expected_status != PSA_SUCCESS )
+ if (is_large_key > 0) {
+ TEST_ASSUME(status != PSA_ERROR_INSUFFICIENT_MEMORY);
+ }
+ TEST_EQUAL(status, expected_status);
+ if (expected_status != PSA_SUCCESS) {
goto exit;
+ }
/* Test the key information */
- PSA_ASSERT( psa_get_key_attributes( key, &got_attributes ) );
- TEST_EQUAL( psa_get_key_type( &got_attributes ), type );
- TEST_EQUAL( psa_get_key_bits( &got_attributes ), bits );
+ PSA_ASSERT(psa_get_key_attributes(key, &got_attributes));
+ TEST_EQUAL(psa_get_key_type(&got_attributes), type);
+ TEST_EQUAL(psa_get_key_bits(&got_attributes), bits);
/* Do something with the key according to its type and permitted usage. */
- if( ! mbedtls_test_psa_exercise_key( key, usage, alg ) )
+ if (!mbedtls_test_psa_exercise_key(key, usage, alg)) {
goto exit;
+ }
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &got_attributes );
+ psa_reset_key_attributes(&got_attributes);
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:PSA_WANT_KEY_TYPE_RSA_KEY_PAIR:PSA_WANT_ALG_RSA_PKCS1V15_CRYPT:PSA_WANT_ALG_RSA_PKCS1V15_SIGN:MBEDTLS_GENPRIME */
-void generate_key_rsa( int bits_arg,
- data_t *e_arg,
- int expected_status_arg )
+void generate_key_rsa(int bits_arg,
+ data_t *e_arg,
+ int expected_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t type = PSA_KEY_TYPE_RSA_KEY_PAIR;
@@ -5396,56 +5395,58 @@
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
uint8_t *exported = NULL;
size_t exported_size =
- PSA_EXPORT_KEY_OUTPUT_SIZE( PSA_KEY_TYPE_RSA_PUBLIC_KEY, bits );
+ PSA_EXPORT_KEY_OUTPUT_SIZE(PSA_KEY_TYPE_RSA_PUBLIC_KEY, bits);
size_t exported_length = SIZE_MAX;
uint8_t *e_read_buffer = NULL;
int is_default_public_exponent = 0;
- size_t e_read_size = PSA_KEY_DOMAIN_PARAMETERS_SIZE( type, bits );
+ size_t e_read_size = PSA_KEY_DOMAIN_PARAMETERS_SIZE(type, bits);
size_t e_read_length = SIZE_MAX;
- if( e_arg->len == 0 ||
- ( e_arg->len == 3 &&
- e_arg->x[0] == 1 && e_arg->x[1] == 0 && e_arg->x[2] == 1 ) )
- {
+ if (e_arg->len == 0 ||
+ (e_arg->len == 3 &&
+ e_arg->x[0] == 1 && e_arg->x[1] == 0 && e_arg->x[2] == 1)) {
is_default_public_exponent = 1;
e_read_size = 0;
}
- ASSERT_ALLOC( e_read_buffer, e_read_size );
- ASSERT_ALLOC( exported, exported_size );
+ ASSERT_ALLOC(e_read_buffer, e_read_size);
+ ASSERT_ALLOC(exported, exported_size);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, usage );
- psa_set_key_algorithm( &attributes, alg );
- PSA_ASSERT( psa_set_key_domain_parameters( &attributes, type,
- e_arg->x, e_arg->len ) );
- psa_set_key_bits( &attributes, bits );
+ psa_set_key_usage_flags(&attributes, usage);
+ psa_set_key_algorithm(&attributes, alg);
+ PSA_ASSERT(psa_set_key_domain_parameters(&attributes, type,
+ e_arg->x, e_arg->len));
+ psa_set_key_bits(&attributes, bits);
/* Generate a key */
- TEST_EQUAL( psa_generate_key( &attributes, &key ), expected_status );
- if( expected_status != PSA_SUCCESS )
+ TEST_EQUAL(psa_generate_key(&attributes, &key), expected_status);
+ if (expected_status != PSA_SUCCESS) {
goto exit;
+ }
/* Test the key information */
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- TEST_EQUAL( psa_get_key_type( &attributes ), type );
- TEST_EQUAL( psa_get_key_bits( &attributes ), bits );
- PSA_ASSERT( psa_get_key_domain_parameters( &attributes,
- e_read_buffer, e_read_size,
- &e_read_length ) );
- if( is_default_public_exponent )
- TEST_EQUAL( e_read_length, 0 );
- else
- ASSERT_COMPARE( e_read_buffer, e_read_length, e_arg->x, e_arg->len );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ TEST_EQUAL(psa_get_key_type(&attributes), type);
+ TEST_EQUAL(psa_get_key_bits(&attributes), bits);
+ PSA_ASSERT(psa_get_key_domain_parameters(&attributes,
+ e_read_buffer, e_read_size,
+ &e_read_length));
+ if (is_default_public_exponent) {
+ TEST_EQUAL(e_read_length, 0);
+ } else {
+ ASSERT_COMPARE(e_read_buffer, e_read_length, e_arg->x, e_arg->len);
+ }
/* Do something with the key according to its type and permitted usage. */
- if( ! mbedtls_test_psa_exercise_key( key, usage, alg ) )
+ if (!mbedtls_test_psa_exercise_key(key, usage, alg)) {
goto exit;
+ }
/* Export the key and check the public exponent. */
- PSA_ASSERT( psa_export_public_key( key,
- exported, exported_size,
- &exported_length ) );
+ PSA_ASSERT(psa_export_public_key(key,
+ exported, exported_size,
+ &exported_length));
{
uint8_t *p = exported;
uint8_t *end = exported + exported_length;
@@ -5454,26 +5455,24 @@
* modulus INTEGER, -- n
* publicExponent INTEGER } -- e
*/
- TEST_EQUAL( 0, mbedtls_asn1_get_tag( &p, end, &len,
- MBEDTLS_ASN1_SEQUENCE |
- MBEDTLS_ASN1_CONSTRUCTED ) );
- TEST_ASSERT( mbedtls_test_asn1_skip_integer( &p, end, bits, bits, 1 ) );
- TEST_EQUAL( 0, mbedtls_asn1_get_tag( &p, end, &len,
- MBEDTLS_ASN1_INTEGER ) );
- if( len >= 1 && p[0] == 0 )
- {
+ TEST_EQUAL(0, mbedtls_asn1_get_tag(&p, end, &len,
+ MBEDTLS_ASN1_SEQUENCE |
+ MBEDTLS_ASN1_CONSTRUCTED));
+ TEST_ASSERT(mbedtls_test_asn1_skip_integer(&p, end, bits, bits, 1));
+ TEST_EQUAL(0, mbedtls_asn1_get_tag(&p, end, &len,
+ MBEDTLS_ASN1_INTEGER));
+ if (len >= 1 && p[0] == 0) {
++p;
--len;
}
- if( e_arg->len == 0 )
- {
- TEST_EQUAL( len, 3 );
- TEST_EQUAL( p[0], 1 );
- TEST_EQUAL( p[1], 0 );
- TEST_EQUAL( p[2], 1 );
+ if (e_arg->len == 0) {
+ TEST_EQUAL(len, 3);
+ TEST_EQUAL(p[0], 1);
+ TEST_EQUAL(p[1], 0);
+ TEST_EQUAL(p[2], 1);
+ } else {
+ ASSERT_COMPARE(p, len, e_arg->x, e_arg->len);
}
- else
- ASSERT_COMPARE( p, len, e_arg->x, e_arg->len );
}
exit:
@@ -5481,22 +5480,22 @@
* Key attributes may have been returned by psa_get_key_attributes() or
* set by psa_set_key_domain_parameters() thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- psa_destroy_key( key );
- PSA_DONE( );
- mbedtls_free( e_read_buffer );
- mbedtls_free( exported );
+ psa_destroy_key(key);
+ PSA_DONE();
+ mbedtls_free(e_read_buffer);
+ mbedtls_free(exported);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_STORAGE_C */
-void persistent_key_load_key_from_storage( data_t *data,
- int type_arg, int bits_arg,
- int usage_flags_arg, int alg_arg,
- int generation_method )
+void persistent_key_load_key_from_storage(data_t *data,
+ int type_arg, int bits_arg,
+ int usage_flags_arg, int alg_arg,
+ int generation_method)
{
- mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make( 1, 1 );
+ mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make(1, 1);
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
mbedtls_svc_key_id_t base_key = MBEDTLS_SVC_KEY_ID_INIT;
@@ -5507,130 +5506,128 @@
psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
unsigned char *first_export = NULL;
unsigned char *second_export = NULL;
- size_t export_size = PSA_EXPORT_KEY_OUTPUT_SIZE( type, bits );
+ size_t export_size = PSA_EXPORT_KEY_OUTPUT_SIZE(type, bits);
size_t first_exported_length;
size_t second_exported_length;
- if( usage_flags & PSA_KEY_USAGE_EXPORT )
- {
- ASSERT_ALLOC( first_export, export_size );
- ASSERT_ALLOC( second_export, export_size );
+ if (usage_flags & PSA_KEY_USAGE_EXPORT) {
+ ASSERT_ALLOC(first_export, export_size);
+ ASSERT_ALLOC(second_export, export_size);
}
- PSA_ASSERT( psa_crypto_init() );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_id( &attributes, key_id );
- psa_set_key_usage_flags( &attributes, usage_flags );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, type );
- psa_set_key_bits( &attributes, bits );
+ psa_set_key_id(&attributes, key_id);
+ psa_set_key_usage_flags(&attributes, usage_flags);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, type);
+ psa_set_key_bits(&attributes, bits);
- switch( generation_method )
- {
+ switch (generation_method) {
case IMPORT_KEY:
/* Import the key */
- PSA_ASSERT( psa_import_key( &attributes, data->x, data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, data->x, data->len,
+ &key));
break;
case GENERATE_KEY:
/* Generate a key */
- PSA_ASSERT( psa_generate_key( &attributes, &key ) );
+ PSA_ASSERT(psa_generate_key(&attributes, &key));
break;
case DERIVE_KEY:
#if defined(PSA_WANT_ALG_HKDF) && defined(PSA_WANT_ALG_SHA_256)
- {
- /* Create base key */
- psa_algorithm_t derive_alg = PSA_ALG_HKDF( PSA_ALG_SHA_256 );
- psa_key_attributes_t base_attributes = PSA_KEY_ATTRIBUTES_INIT;
- psa_set_key_usage_flags( &base_attributes,
- PSA_KEY_USAGE_DERIVE );
- psa_set_key_algorithm( &base_attributes, derive_alg );
- psa_set_key_type( &base_attributes, PSA_KEY_TYPE_DERIVE );
- PSA_ASSERT( psa_import_key( &base_attributes,
- data->x, data->len,
- &base_key ) );
- /* Derive a key. */
- PSA_ASSERT( psa_key_derivation_setup( &operation, derive_alg ) );
- PSA_ASSERT( psa_key_derivation_input_key(
- &operation,
- PSA_KEY_DERIVATION_INPUT_SECRET, base_key ) );
- PSA_ASSERT( psa_key_derivation_input_bytes(
- &operation, PSA_KEY_DERIVATION_INPUT_INFO,
- NULL, 0 ) );
- PSA_ASSERT( psa_key_derivation_output_key( &attributes,
- &operation,
- &key ) );
- PSA_ASSERT( psa_key_derivation_abort( &operation ) );
- PSA_ASSERT( psa_destroy_key( base_key ) );
- base_key = MBEDTLS_SVC_KEY_ID_INIT;
- }
+ {
+ /* Create base key */
+ psa_algorithm_t derive_alg = PSA_ALG_HKDF(PSA_ALG_SHA_256);
+ psa_key_attributes_t base_attributes = PSA_KEY_ATTRIBUTES_INIT;
+ psa_set_key_usage_flags(&base_attributes,
+ PSA_KEY_USAGE_DERIVE);
+ psa_set_key_algorithm(&base_attributes, derive_alg);
+ psa_set_key_type(&base_attributes, PSA_KEY_TYPE_DERIVE);
+ PSA_ASSERT(psa_import_key(&base_attributes,
+ data->x, data->len,
+ &base_key));
+ /* Derive a key. */
+ PSA_ASSERT(psa_key_derivation_setup(&operation, derive_alg));
+ PSA_ASSERT(psa_key_derivation_input_key(
+ &operation,
+ PSA_KEY_DERIVATION_INPUT_SECRET, base_key));
+ PSA_ASSERT(psa_key_derivation_input_bytes(
+ &operation, PSA_KEY_DERIVATION_INPUT_INFO,
+ NULL, 0));
+ PSA_ASSERT(psa_key_derivation_output_key(&attributes,
+ &operation,
+ &key));
+ PSA_ASSERT(psa_key_derivation_abort(&operation));
+ PSA_ASSERT(psa_destroy_key(base_key));
+ base_key = MBEDTLS_SVC_KEY_ID_INIT;
+ }
#else
- TEST_ASSUME( ! "KDF not supported in this configuration" );
+ TEST_ASSUME(!"KDF not supported in this configuration");
#endif
break;
default:
- TEST_ASSERT( ! "generation_method not implemented in test" );
+ TEST_ASSERT(!"generation_method not implemented in test");
break;
}
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
/* Export the key if permitted by the key policy. */
- if( usage_flags & PSA_KEY_USAGE_EXPORT )
- {
- PSA_ASSERT( psa_export_key( key,
- first_export, export_size,
- &first_exported_length ) );
- if( generation_method == IMPORT_KEY )
- ASSERT_COMPARE( data->x, data->len,
- first_export, first_exported_length );
+ if (usage_flags & PSA_KEY_USAGE_EXPORT) {
+ PSA_ASSERT(psa_export_key(key,
+ first_export, export_size,
+ &first_exported_length));
+ if (generation_method == IMPORT_KEY) {
+ ASSERT_COMPARE(data->x, data->len,
+ first_export, first_exported_length);
+ }
}
/* Shutdown and restart */
- PSA_ASSERT( psa_purge_key( key ) );
+ PSA_ASSERT(psa_purge_key(key));
PSA_DONE();
- PSA_ASSERT( psa_crypto_init() );
+ PSA_ASSERT(psa_crypto_init());
/* Check key slot still contains key data */
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- TEST_ASSERT( mbedtls_svc_key_id_equal(
- psa_get_key_id( &attributes ), key_id ) );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ),
- PSA_KEY_LIFETIME_PERSISTENT );
- TEST_EQUAL( psa_get_key_type( &attributes ), type );
- TEST_EQUAL( psa_get_key_bits( &attributes ), bits );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ),
- mbedtls_test_update_key_usage_flags( usage_flags ) );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ), alg );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ TEST_ASSERT(mbedtls_svc_key_id_equal(
+ psa_get_key_id(&attributes), key_id));
+ TEST_EQUAL(psa_get_key_lifetime(&attributes),
+ PSA_KEY_LIFETIME_PERSISTENT);
+ TEST_EQUAL(psa_get_key_type(&attributes), type);
+ TEST_EQUAL(psa_get_key_bits(&attributes), bits);
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes),
+ mbedtls_test_update_key_usage_flags(usage_flags));
+ TEST_EQUAL(psa_get_key_algorithm(&attributes), alg);
/* Export the key again if permitted by the key policy. */
- if( usage_flags & PSA_KEY_USAGE_EXPORT )
- {
- PSA_ASSERT( psa_export_key( key,
- second_export, export_size,
- &second_exported_length ) );
- ASSERT_COMPARE( first_export, first_exported_length,
- second_export, second_exported_length );
+ if (usage_flags & PSA_KEY_USAGE_EXPORT) {
+ PSA_ASSERT(psa_export_key(key,
+ second_export, export_size,
+ &second_exported_length));
+ ASSERT_COMPARE(first_export, first_exported_length,
+ second_export, second_exported_length);
}
/* Do something with the key according to its type and permitted usage. */
- if( ! mbedtls_test_psa_exercise_key( key, usage_flags, alg ) )
+ if (!mbedtls_test_psa_exercise_key(key, usage_flags, alg)) {
goto exit;
+ }
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- mbedtls_free( first_export );
- mbedtls_free( second_export );
- psa_key_derivation_abort( &operation );
- psa_destroy_key( base_key );
- psa_destroy_key( key );
+ mbedtls_free(first_export);
+ mbedtls_free(second_export);
+ psa_key_derivation_abort(&operation);
+ psa_destroy_key(base_key);
+ psa_destroy_key(key);
PSA_DONE();
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto_attributes.function b/tests/suites/test_suite_psa_crypto_attributes.function
index ce34fae..c933cb7 100644
--- a/tests/suites/test_suite_psa_crypto_attributes.function
+++ b/tests/suites/test_suite_psa_crypto_attributes.function
@@ -8,12 +8,12 @@
*/
/* BEGIN_CASE */
-void attributes_set_get( int owner_id_arg, int id_arg, int lifetime_arg,
- int usage_flags_arg, int alg_arg,
- int type_arg, int bits_arg )
+void attributes_set_get(int owner_id_arg, int id_arg, int lifetime_arg,
+ int usage_flags_arg, int alg_arg,
+ int type_arg, int bits_arg)
{
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( owner_id_arg, id_arg );
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(owner_id_arg, id_arg);
psa_key_lifetime_t lifetime = lifetime_arg;
psa_key_usage_t usage_flags = usage_flags_arg;
psa_algorithm_t alg = alg_arg;
@@ -21,109 +21,112 @@
size_t bits = bits_arg;
TEST_EQUAL(
- MBEDTLS_SVC_KEY_ID_GET_KEY_ID( psa_get_key_id( &attributes ) ), 0 );
+ MBEDTLS_SVC_KEY_ID_GET_KEY_ID(psa_get_key_id(&attributes)), 0);
TEST_EQUAL(
- MBEDTLS_SVC_KEY_ID_GET_OWNER_ID( psa_get_key_id( &attributes ) ), 0 );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_type( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_bits( &attributes ), 0 );
+ MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(psa_get_key_id(&attributes)), 0);
+ TEST_EQUAL(psa_get_key_lifetime(&attributes), 0);
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes), 0);
+ TEST_EQUAL(psa_get_key_algorithm(&attributes), 0);
+ TEST_EQUAL(psa_get_key_type(&attributes), 0);
+ TEST_EQUAL(psa_get_key_bits(&attributes), 0);
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_usage_flags( &attributes, usage_flags );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, type );
- psa_set_key_bits( &attributes, bits );
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_usage_flags(&attributes, usage_flags);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, type);
+ psa_set_key_bits(&attributes, bits);
- TEST_ASSERT( mbedtls_svc_key_id_equal(
- psa_get_key_id( &attributes ), id ) );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ), lifetime );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ), usage_flags );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ), alg );
- TEST_EQUAL( psa_get_key_type( &attributes ), type );
- TEST_EQUAL( psa_get_key_bits( &attributes ), bits );
+ TEST_ASSERT(mbedtls_svc_key_id_equal(
+ psa_get_key_id(&attributes), id));
+ TEST_EQUAL(psa_get_key_lifetime(&attributes), lifetime);
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes), usage_flags);
+ TEST_EQUAL(psa_get_key_algorithm(&attributes), alg);
+ TEST_EQUAL(psa_get_key_type(&attributes), type);
+ TEST_EQUAL(psa_get_key_bits(&attributes), bits);
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
TEST_EQUAL(
- MBEDTLS_SVC_KEY_ID_GET_KEY_ID( psa_get_key_id( &attributes ) ), 0 );
+ MBEDTLS_SVC_KEY_ID_GET_KEY_ID(psa_get_key_id(&attributes)), 0);
TEST_EQUAL(
- MBEDTLS_SVC_KEY_ID_GET_OWNER_ID( psa_get_key_id( &attributes ) ), 0 );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_type( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_bits( &attributes ), 0 );
+ MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(psa_get_key_id(&attributes)), 0);
+ TEST_EQUAL(psa_get_key_lifetime(&attributes), 0);
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes), 0);
+ TEST_EQUAL(psa_get_key_algorithm(&attributes), 0);
+ TEST_EQUAL(psa_get_key_type(&attributes), 0);
+ TEST_EQUAL(psa_get_key_bits(&attributes), 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void persistence_attributes( int id1_arg, int owner_id1_arg, int lifetime_arg,
- int id2_arg, int owner_id2_arg,
- int expected_id_arg, int expected_owner_id_arg,
- int expected_lifetime_arg )
+void persistence_attributes(int id1_arg, int owner_id1_arg, int lifetime_arg,
+ int id2_arg, int owner_id2_arg,
+ int expected_id_arg, int expected_owner_id_arg,
+ int expected_lifetime_arg)
{
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_svc_key_id_t id1 =
- mbedtls_svc_key_id_make( owner_id1_arg, id1_arg );
+ mbedtls_svc_key_id_make(owner_id1_arg, id1_arg);
psa_key_lifetime_t lifetime = lifetime_arg;
mbedtls_svc_key_id_t id2 =
- mbedtls_svc_key_id_make( owner_id2_arg, id2_arg );
+ mbedtls_svc_key_id_make(owner_id2_arg, id2_arg);
mbedtls_svc_key_id_t expected_id =
- mbedtls_svc_key_id_make( expected_owner_id_arg, expected_id_arg );
+ mbedtls_svc_key_id_make(expected_owner_id_arg, expected_id_arg);
psa_key_lifetime_t expected_lifetime = expected_lifetime_arg;
- if( id1_arg != -1 )
- psa_set_key_id( &attributes, id1 );
- if( lifetime_arg != -1 )
- psa_set_key_lifetime( &attributes, lifetime );
- if( id2_arg != -1 )
- psa_set_key_id( &attributes, id2 );
+ if (id1_arg != -1) {
+ psa_set_key_id(&attributes, id1);
+ }
+ if (lifetime_arg != -1) {
+ psa_set_key_lifetime(&attributes, lifetime);
+ }
+ if (id2_arg != -1) {
+ psa_set_key_id(&attributes, id2);
+ }
- TEST_ASSERT( mbedtls_svc_key_id_equal(
- psa_get_key_id( &attributes ), expected_id ) );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ), expected_lifetime );
+ TEST_ASSERT(mbedtls_svc_key_id_equal(
+ psa_get_key_id(&attributes), expected_id));
+ TEST_EQUAL(psa_get_key_lifetime(&attributes), expected_lifetime);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_SE_C */
-void slot_number_attribute( )
+void slot_number_attribute()
{
psa_key_slot_number_t slot_number = 0xdeadbeef;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
/* Initially, there is no slot number. */
- TEST_EQUAL( psa_get_key_slot_number( &attributes, &slot_number ),
- PSA_ERROR_INVALID_ARGUMENT );
+ TEST_EQUAL(psa_get_key_slot_number(&attributes, &slot_number),
+ PSA_ERROR_INVALID_ARGUMENT);
/* Test setting a slot number. */
- psa_set_key_slot_number( &attributes, 0 );
- PSA_ASSERT( psa_get_key_slot_number( &attributes, &slot_number ) );
- TEST_EQUAL( slot_number, 0 );
+ psa_set_key_slot_number(&attributes, 0);
+ PSA_ASSERT(psa_get_key_slot_number(&attributes, &slot_number));
+ TEST_EQUAL(slot_number, 0);
/* Test changing the slot number. */
- psa_set_key_slot_number( &attributes, 42 );
- PSA_ASSERT( psa_get_key_slot_number( &attributes, &slot_number ) );
- TEST_EQUAL( slot_number, 42 );
+ psa_set_key_slot_number(&attributes, 42);
+ PSA_ASSERT(psa_get_key_slot_number(&attributes, &slot_number));
+ TEST_EQUAL(slot_number, 42);
/* Test clearing the slot number. */
- psa_clear_key_slot_number( &attributes );
- TEST_EQUAL( psa_get_key_slot_number( &attributes, &slot_number ),
- PSA_ERROR_INVALID_ARGUMENT );
+ psa_clear_key_slot_number(&attributes);
+ TEST_EQUAL(psa_get_key_slot_number(&attributes, &slot_number),
+ PSA_ERROR_INVALID_ARGUMENT);
/* Clearing again should have no effect. */
- psa_clear_key_slot_number( &attributes );
- TEST_EQUAL( psa_get_key_slot_number( &attributes, &slot_number ),
- PSA_ERROR_INVALID_ARGUMENT );
+ psa_clear_key_slot_number(&attributes);
+ TEST_EQUAL(psa_get_key_slot_number(&attributes, &slot_number),
+ PSA_ERROR_INVALID_ARGUMENT);
/* Test that reset clears the slot number. */
- psa_set_key_slot_number( &attributes, 42 );
- PSA_ASSERT( psa_get_key_slot_number( &attributes, &slot_number ) );
- TEST_EQUAL( slot_number, 42 );
- psa_reset_key_attributes( &attributes );
- TEST_EQUAL( psa_get_key_slot_number( &attributes, &slot_number ),
- PSA_ERROR_INVALID_ARGUMENT );
+ psa_set_key_slot_number(&attributes, 42);
+ PSA_ASSERT(psa_get_key_slot_number(&attributes, &slot_number));
+ TEST_EQUAL(slot_number, 42);
+ psa_reset_key_attributes(&attributes);
+ TEST_EQUAL(psa_get_key_slot_number(&attributes, &slot_number),
+ PSA_ERROR_INVALID_ARGUMENT);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto_driver_wrappers.function b/tests/suites/test_suite_psa_crypto_driver_wrappers.function
index 27d50b2..953b9ff 100644
--- a/tests/suites/test_suite_psa_crypto_driver_wrappers.function
+++ b/tests/suites/test_suite_psa_crypto_driver_wrappers.function
@@ -8,14 +8,14 @@
*/
/* BEGIN_CASE */
-void sign_hash( int key_type_arg,
- int alg_arg,
- int force_status_arg,
- data_t *key_input,
- data_t *data_input,
- data_t *expected_output,
- int fake_output,
- int expected_status_arg )
+void sign_hash(int key_type_arg,
+ int alg_arg,
+ int force_status_arg,
+ data_t *key_input,
+ data_t *data_input,
+ data_t *expected_output,
+ int fake_output,
+ int expected_status_arg)
{
psa_status_t force_status = force_status_arg;
psa_status_t expected_status = expected_status_arg;
@@ -31,18 +31,17 @@
mbedtls_test_driver_signature_sign_hooks =
mbedtls_test_driver_signature_hooks_init();
- PSA_ASSERT( psa_crypto_init( ) );
- psa_set_key_type( &attributes,
- key_type );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_import_key( &attributes,
- key_input->x, key_input->len,
- &key );
+ PSA_ASSERT(psa_crypto_init());
+ psa_set_key_type(&attributes,
+ key_type);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_import_key(&attributes,
+ key_input->x, key_input->len,
+ &key);
mbedtls_test_driver_signature_sign_hooks.forced_status = force_status;
- if( fake_output == 1 )
- {
+ if (fake_output == 1) {
mbedtls_test_driver_signature_sign_hooks.forced_output =
expected_output->x;
mbedtls_test_driver_signature_sign_hooks.forced_output_length =
@@ -51,104 +50,100 @@
/* Allocate a buffer which has the size advertized by the
* library. */
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
- signature_size = PSA_SIGN_OUTPUT_SIZE( key_type, key_bits, alg );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
+ signature_size = PSA_SIGN_OUTPUT_SIZE(key_type, key_bits, alg);
- TEST_ASSERT( signature_size != 0 );
- TEST_ASSERT( signature_size <= PSA_SIGNATURE_MAX_SIZE );
- ASSERT_ALLOC( signature, signature_size );
+ TEST_ASSERT(signature_size != 0);
+ TEST_ASSERT(signature_size <= PSA_SIGNATURE_MAX_SIZE);
+ ASSERT_ALLOC(signature, signature_size);
- actual_status = psa_sign_hash( key, alg,
- data_input->x, data_input->len,
- signature, signature_size,
- &signature_length );
- TEST_EQUAL( actual_status, expected_status );
- if( expected_status == PSA_SUCCESS )
- {
- ASSERT_COMPARE( signature, signature_length,
- expected_output->x, expected_output->len );
+ actual_status = psa_sign_hash(key, alg,
+ data_input->x, data_input->len,
+ signature, signature_size,
+ &signature_length);
+ TEST_EQUAL(actual_status, expected_status);
+ if (expected_status == PSA_SUCCESS) {
+ ASSERT_COMPARE(signature, signature_length,
+ 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);
exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- mbedtls_free( signature );
- PSA_DONE( );
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ mbedtls_free(signature);
+ PSA_DONE();
mbedtls_test_driver_signature_sign_hooks =
mbedtls_test_driver_signature_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void verify_hash( int key_type_arg,
- int key_type_public_arg,
+void verify_hash(int key_type_arg,
+ int key_type_public_arg,
+ int alg_arg,
+ int force_status_arg,
+ int register_public_key,
+ data_t *key_input,
+ data_t *data_input,
+ data_t *signature_input,
+ int expected_status_arg)
+{
+ psa_status_t force_status = force_status_arg;
+ psa_status_t expected_status = expected_status_arg;
+ psa_algorithm_t alg = alg_arg;
+ psa_key_type_t key_type = key_type_arg;
+ psa_key_type_t key_type_public = key_type_public_arg;
+ mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
+ psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
+ psa_status_t actual_status;
+ mbedtls_test_driver_signature_verify_hooks =
+ mbedtls_test_driver_signature_hooks_init();
+
+ PSA_ASSERT(psa_crypto_init());
+ if (register_public_key) {
+ psa_set_key_type(&attributes, key_type_public);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_import_key(&attributes,
+ key_input->x, key_input->len,
+ &key);
+ } else {
+ psa_set_key_type(&attributes, key_type);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_import_key(&attributes,
+ key_input->x, key_input->len,
+ &key);
+ }
+
+ mbedtls_test_driver_signature_verify_hooks.forced_status = force_status;
+
+ actual_status = psa_verify_hash(key, alg,
+ data_input->x, data_input->len,
+ signature_input->x, signature_input->len);
+ TEST_EQUAL(actual_status, expected_status);
+ TEST_EQUAL(mbedtls_test_driver_signature_verify_hooks.hits, 1);
+
+exit:
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ PSA_DONE();
+ mbedtls_test_driver_signature_verify_hooks =
+ mbedtls_test_driver_signature_hooks_init();
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void sign_message(int key_type_arg,
int alg_arg,
int force_status_arg,
- int register_public_key,
data_t *key_input,
data_t *data_input,
- data_t *signature_input,
- int expected_status_arg )
-{
- psa_status_t force_status = force_status_arg;
- psa_status_t expected_status = expected_status_arg;
- psa_algorithm_t alg = alg_arg;
- psa_key_type_t key_type = key_type_arg;
- psa_key_type_t key_type_public = key_type_public_arg;
- mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
- psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- psa_status_t actual_status;
- mbedtls_test_driver_signature_verify_hooks =
- mbedtls_test_driver_signature_hooks_init();
-
- PSA_ASSERT( psa_crypto_init( ) );
- if( register_public_key )
- {
- psa_set_key_type( &attributes, key_type_public );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_import_key( &attributes,
- key_input->x, key_input->len,
- &key );
- }
- else
- {
- psa_set_key_type( &attributes, key_type );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_import_key( &attributes,
- key_input->x, key_input->len,
- &key );
- }
-
- mbedtls_test_driver_signature_verify_hooks.forced_status = force_status;
-
- actual_status = psa_verify_hash( key, alg,
- data_input->x, data_input->len,
- signature_input->x, signature_input->len );
- TEST_EQUAL( actual_status, expected_status );
- TEST_EQUAL( mbedtls_test_driver_signature_verify_hooks.hits, 1 );
-
-exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- PSA_DONE( );
- mbedtls_test_driver_signature_verify_hooks =
- mbedtls_test_driver_signature_hooks_init();
-}
-/* END_CASE */
-
-/* BEGIN_CASE */
-void sign_message( int key_type_arg,
- int alg_arg,
- int force_status_arg,
- data_t *key_input,
- data_t *data_input,
- data_t *expected_output,
- int fake_output,
- int expected_status_arg )
+ data_t *expected_output,
+ int fake_output,
+ int expected_status_arg)
{
psa_status_t force_status = force_status_arg;
psa_status_t expected_status = expected_status_arg;
@@ -164,17 +159,16 @@
mbedtls_test_driver_signature_sign_hooks =
mbedtls_test_driver_signature_hooks_init();
- PSA_ASSERT( psa_crypto_init( ) );
- psa_set_key_type( &attributes, key_type );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_MESSAGE );
- psa_set_key_algorithm( &attributes, alg );
- psa_import_key( &attributes,
- key_input->x, key_input->len,
- &key );
+ PSA_ASSERT(psa_crypto_init());
+ psa_set_key_type(&attributes, key_type);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_MESSAGE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_import_key(&attributes,
+ key_input->x, key_input->len,
+ &key);
mbedtls_test_driver_signature_sign_hooks.forced_status = force_status;
- if( fake_output == 1 )
- {
+ if (fake_output == 1) {
mbedtls_test_driver_signature_sign_hooks.forced_output =
expected_output->x;
mbedtls_test_driver_signature_sign_hooks.forced_output_length =
@@ -183,48 +177,47 @@
/* Allocate a buffer which has the size advertized by the
* library. */
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
- signature_size = PSA_SIGN_OUTPUT_SIZE( key_type, key_bits, alg );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
+ signature_size = PSA_SIGN_OUTPUT_SIZE(key_type, key_bits, alg);
- TEST_ASSERT( signature_size != 0 );
- TEST_ASSERT( signature_size <= PSA_SIGNATURE_MAX_SIZE );
- ASSERT_ALLOC( signature, signature_size );
+ TEST_ASSERT(signature_size != 0);
+ TEST_ASSERT(signature_size <= PSA_SIGNATURE_MAX_SIZE);
+ ASSERT_ALLOC(signature, signature_size);
- actual_status = psa_sign_message( key, alg,
- data_input->x, data_input->len,
- signature, signature_size,
- &signature_length );
- TEST_EQUAL( actual_status, expected_status );
- if( expected_status == PSA_SUCCESS )
- {
- ASSERT_COMPARE( signature, signature_length,
- expected_output->x, expected_output->len );
+ actual_status = psa_sign_message(key, alg,
+ data_input->x, data_input->len,
+ signature, signature_size,
+ &signature_length);
+ TEST_EQUAL(actual_status, expected_status);
+ if (expected_status == PSA_SUCCESS) {
+ ASSERT_COMPARE(signature, signature_length,
+ expected_output->x, expected_output->len);
}
/* In the builtin algorithm the driver is called twice. */
- TEST_EQUAL( mbedtls_test_driver_signature_sign_hooks.hits,
- force_status == PSA_ERROR_NOT_SUPPORTED ? 2 : 1 );
+ TEST_EQUAL(mbedtls_test_driver_signature_sign_hooks.hits,
+ force_status == PSA_ERROR_NOT_SUPPORTED ? 2 : 1);
exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- mbedtls_free( signature );
- PSA_DONE( );
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ mbedtls_free(signature);
+ PSA_DONE();
mbedtls_test_driver_signature_sign_hooks =
mbedtls_test_driver_signature_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void verify_message( int key_type_arg,
- int key_type_public_arg,
- int alg_arg,
- int force_status_arg,
- int register_public_key,
- data_t *key_input,
- data_t *data_input,
- data_t *signature_input,
- int expected_status_arg )
+void verify_message(int key_type_arg,
+ int key_type_public_arg,
+ int alg_arg,
+ int force_status_arg,
+ int register_public_key,
+ data_t *key_input,
+ data_t *data_input,
+ data_t *signature_input,
+ int expected_status_arg)
{
psa_status_t force_status = force_status_arg;
psa_status_t expected_status = expected_status_arg;
@@ -237,131 +230,123 @@
mbedtls_test_driver_signature_verify_hooks =
mbedtls_test_driver_signature_hooks_init();
- PSA_ASSERT( psa_crypto_init( ) );
- if( register_public_key )
- {
- psa_set_key_type( &attributes, key_type_public );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_MESSAGE );
- psa_set_key_algorithm( &attributes, alg );
- psa_import_key( &attributes,
- key_input->x, key_input->len,
- &key );
- }
- else
- {
- psa_set_key_type( &attributes, key_type );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_MESSAGE );
- psa_set_key_algorithm( &attributes, alg );
- psa_import_key( &attributes,
- key_input->x, key_input->len,
- &key );
+ PSA_ASSERT(psa_crypto_init());
+ if (register_public_key) {
+ psa_set_key_type(&attributes, key_type_public);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_MESSAGE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_import_key(&attributes,
+ key_input->x, key_input->len,
+ &key);
+ } else {
+ psa_set_key_type(&attributes, key_type);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_MESSAGE);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_import_key(&attributes,
+ key_input->x, key_input->len,
+ &key);
}
mbedtls_test_driver_signature_verify_hooks.forced_status = force_status;
- actual_status = psa_verify_message( key, alg,
- data_input->x, data_input->len,
- signature_input->x, signature_input->len );
- TEST_EQUAL( actual_status, expected_status );
+ actual_status = psa_verify_message(key, alg,
+ data_input->x, data_input->len,
+ signature_input->x, signature_input->len);
+ TEST_EQUAL(actual_status, expected_status);
/* In the builtin algorithm the driver is called twice. */
- TEST_EQUAL( mbedtls_test_driver_signature_verify_hooks.hits,
- force_status == PSA_ERROR_NOT_SUPPORTED ? 2 : 1 );
+ TEST_EQUAL(mbedtls_test_driver_signature_verify_hooks.hits,
+ force_status == PSA_ERROR_NOT_SUPPORTED ? 2 : 1);
exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ PSA_DONE();
mbedtls_test_driver_signature_verify_hooks =
mbedtls_test_driver_signature_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE depends_on:PSA_WANT_ALG_ECDSA:PSA_WANT_ECC_SECP_R1_256 */
-void generate_key( int force_status_arg,
- data_t *fake_output,
- int expected_status_arg )
+void generate_key(int force_status_arg,
+ data_t *fake_output,
+ int expected_status_arg)
{
psa_status_t force_status = force_status_arg;
psa_status_t expected_status = expected_status_arg;
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- psa_algorithm_t alg = PSA_ALG_ECDSA( PSA_ALG_SHA_256 );
+ psa_algorithm_t alg = PSA_ALG_ECDSA(PSA_ALG_SHA_256);
const uint8_t *expected_output = NULL;
size_t expected_output_length = 0;
psa_status_t actual_status;
- uint8_t actual_output[PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE(256)] = {0};
+ uint8_t actual_output[PSA_KEY_EXPORT_ECC_KEY_PAIR_MAX_SIZE(256)] = { 0 };
size_t actual_output_length;
mbedtls_test_driver_key_management_hooks =
mbedtls_test_driver_key_management_hooks_init();
- psa_set_key_type( &attributes,
- PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_FAMILY_SECP_R1 ) );
- psa_set_key_bits( &attributes, 256 );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_EXPORT );
- psa_set_key_algorithm( &attributes, alg );
+ psa_set_key_type(&attributes,
+ PSA_KEY_TYPE_ECC_KEY_PAIR(PSA_ECC_FAMILY_SECP_R1));
+ psa_set_key_bits(&attributes, 256);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_EXPORT);
+ psa_set_key_algorithm(&attributes, alg);
- if( fake_output->len > 0 )
- {
+ if (fake_output->len > 0) {
expected_output =
mbedtls_test_driver_key_management_hooks.forced_output =
- fake_output->x;
+ fake_output->x;
expected_output_length =
mbedtls_test_driver_key_management_hooks.forced_output_length =
- fake_output->len;
+ fake_output->len;
}
mbedtls_test_driver_key_management_hooks.hits = 0;
mbedtls_test_driver_key_management_hooks.forced_status = force_status;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- actual_status = psa_generate_key( &attributes, &key );
- TEST_EQUAL( mbedtls_test_driver_key_management_hooks.hits, 1 );
- TEST_EQUAL( actual_status, expected_status );
+ actual_status = psa_generate_key(&attributes, &key);
+ TEST_EQUAL(mbedtls_test_driver_key_management_hooks.hits, 1);
+ TEST_EQUAL(actual_status, expected_status);
- if( actual_status == PSA_SUCCESS )
- {
- psa_export_key( key, actual_output, sizeof(actual_output), &actual_output_length );
+ if (actual_status == PSA_SUCCESS) {
+ psa_export_key(key, actual_output, sizeof(actual_output), &actual_output_length);
- if( fake_output->len > 0 )
- {
- ASSERT_COMPARE( actual_output, actual_output_length,
- expected_output, expected_output_length );
- }
- else
- {
+ if (fake_output->len > 0) {
+ ASSERT_COMPARE(actual_output, actual_output_length,
+ expected_output, expected_output_length);
+ } else {
size_t zeroes = 0;
- for( size_t i = 0; i < sizeof(actual_output); i++ )
- {
- if( actual_output[i] == 0)
+ for (size_t i = 0; i < sizeof(actual_output); i++) {
+ if (actual_output[i] == 0) {
zeroes++;
+ }
}
- TEST_ASSERT( zeroes != sizeof(actual_output) );
+ TEST_ASSERT(zeroes != sizeof(actual_output));
}
}
exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ PSA_DONE();
mbedtls_test_driver_key_management_hooks =
mbedtls_test_driver_key_management_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void validate_key( int force_status_arg,
- int location,
- int owner_id_arg,
- int id_arg,
- int key_type_arg,
- data_t *key_input,
- int expected_status_arg )
+void validate_key(int force_status_arg,
+ int location,
+ int owner_id_arg,
+ int id_arg,
+ int key_type_arg,
+ data_t *key_input,
+ int expected_status_arg)
{
psa_key_lifetime_t lifetime =
- PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION( \
- PSA_KEY_PERSISTENCE_DEFAULT, location);
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( owner_id_arg, id_arg );
+ PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION( \
+ PSA_KEY_PERSISTENCE_DEFAULT, location);
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(owner_id_arg, id_arg);
psa_status_t force_status = force_status_arg;
psa_status_t expected_status = expected_status_arg;
psa_key_type_t key_type = key_type_arg;
@@ -371,38 +356,38 @@
mbedtls_test_driver_key_management_hooks =
mbedtls_test_driver_key_management_hooks_init();
- psa_set_key_id( &attributes, id );
- psa_set_key_type( &attributes,
- key_type );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_bits( &attributes, 0 );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
+ psa_set_key_id(&attributes, id);
+ psa_set_key_type(&attributes,
+ key_type);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_bits(&attributes, 0);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
mbedtls_test_driver_key_management_hooks.forced_status = force_status;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- actual_status = psa_import_key( &attributes, key_input->x, key_input->len, &key );
- TEST_EQUAL( mbedtls_test_driver_key_management_hooks.hits, 1 );
- TEST_EQUAL( actual_status, expected_status );
- TEST_EQUAL( mbedtls_test_driver_key_management_hooks.location, location );
+ actual_status = psa_import_key(&attributes, key_input->x, key_input->len, &key);
+ TEST_EQUAL(mbedtls_test_driver_key_management_hooks.hits, 1);
+ TEST_EQUAL(actual_status, expected_status);
+ TEST_EQUAL(mbedtls_test_driver_key_management_hooks.location, location);
exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ PSA_DONE();
mbedtls_test_driver_key_management_hooks =
mbedtls_test_driver_key_management_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void export_key( int force_status_arg,
- data_t *fake_output,
- int key_in_type_arg,
- data_t *key_in,
- int key_out_type_arg,
- data_t *expected_output,
- int expected_status_arg )
+void export_key(int force_status_arg,
+ data_t *fake_output,
+ int key_in_type_arg,
+ data_t *key_in,
+ int key_out_type_arg,
+ data_t *expected_output,
+ int expected_status_arg)
{
psa_status_t force_status = force_status_arg;
psa_status_t expected_status = expected_status_arg;
@@ -413,30 +398,27 @@
const uint8_t *expected_output_ptr = NULL;
size_t expected_output_length = 0;
psa_status_t actual_status;
- uint8_t actual_output[PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(256)] = {0};
+ uint8_t actual_output[PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(256)] = { 0 };
size_t actual_output_length;
mbedtls_test_driver_key_management_hooks =
mbedtls_test_driver_key_management_hooks_init();
- psa_set_key_type( &attributes, input_key_type );
- psa_set_key_bits( &attributes, 256 );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
+ psa_set_key_type(&attributes, input_key_type);
+ psa_set_key_bits(&attributes, 256);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
- PSA_ASSERT( psa_crypto_init( ) );
- PSA_ASSERT( psa_import_key( &attributes, key_in->x, key_in->len, &handle ) );
+ PSA_ASSERT(psa_crypto_init());
+ PSA_ASSERT(psa_import_key(&attributes, key_in->x, key_in->len, &handle));
- if( fake_output->len > 0 )
- {
+ if (fake_output->len > 0) {
expected_output_ptr =
mbedtls_test_driver_key_management_hooks.forced_output =
- fake_output->x;
+ fake_output->x;
expected_output_length =
mbedtls_test_driver_key_management_hooks.forced_output_length =
- fake_output->len;
- }
- else
- {
+ fake_output->len;
+ } else {
expected_output_ptr = expected_output->x;
expected_output_length = expected_output->len;
}
@@ -444,40 +426,47 @@
mbedtls_test_driver_key_management_hooks.hits = 0;
mbedtls_test_driver_key_management_hooks.forced_status = force_status;
- if( PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY( output_key_type ) )
- actual_status = psa_export_public_key( handle, actual_output, sizeof(actual_output), &actual_output_length );
- else
- actual_status = psa_export_key( handle, actual_output, sizeof(actual_output), &actual_output_length );
- TEST_EQUAL( actual_status, expected_status );
+ if (PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(output_key_type)) {
+ actual_status = psa_export_public_key(handle,
+ actual_output,
+ sizeof(actual_output),
+ &actual_output_length);
+ } else {
+ actual_status = psa_export_key(handle,
+ actual_output,
+ sizeof(actual_output),
+ &actual_output_length);
+ }
+ TEST_EQUAL(actual_status, expected_status);
- if( PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY( output_key_type ) &&
- !PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY( input_key_type ) )
- TEST_EQUAL( mbedtls_test_driver_key_management_hooks.hits, 1 );
+ if (PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(output_key_type) &&
+ !PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(input_key_type)) {
+ TEST_EQUAL(mbedtls_test_driver_key_management_hooks.hits, 1);
+ }
- if( actual_status == PSA_SUCCESS )
- {
- ASSERT_COMPARE( actual_output, actual_output_length,
- expected_output_ptr, expected_output_length );
+ if (actual_status == PSA_SUCCESS) {
+ ASSERT_COMPARE(actual_output, actual_output_length,
+ expected_output_ptr, expected_output_length);
}
exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( handle );
- PSA_DONE( );
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(handle);
+ PSA_DONE();
mbedtls_test_driver_key_management_hooks =
mbedtls_test_driver_key_management_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_encrypt_validation( int alg_arg,
- int key_type_arg,
- data_t *key_data,
- data_t *input )
+void cipher_encrypt_validation(int alg_arg,
+ int key_type_arg,
+ data_t *key_data,
+ data_t *input)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
psa_algorithm_t alg = alg_arg;
- size_t iv_size = PSA_CIPHER_IV_LENGTH ( key_type, alg );
+ size_t iv_size = PSA_CIPHER_IV_LENGTH(key_type, alg);
unsigned char *output1 = NULL;
size_t output1_buffer_size = 0;
size_t output1_length = 0;
@@ -489,81 +478,81 @@
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- 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 );
- ASSERT_ALLOC( output1, output1_buffer_size );
- ASSERT_ALLOC( output2, output2_buffer_size );
+ 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);
+ ASSERT_ALLOC(output1, output1_buffer_size);
+ ASSERT_ALLOC(output2, output2_buffer_size);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- PSA_ASSERT( psa_cipher_encrypt( key, alg, input->x, input->len, output1,
- output1_buffer_size, &output1_length ) );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+ PSA_ASSERT(psa_cipher_encrypt(key, alg, input->x, input->len, output1,
+ output1_buffer_size, &output1_length));
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
mbedtls_test_driver_cipher_hooks.hits = 0;
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
mbedtls_test_driver_cipher_hooks.hits = 0;
- PSA_ASSERT( psa_cipher_set_iv( &operation, output1, iv_size ) );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+ PSA_ASSERT(psa_cipher_set_iv(&operation, output1, iv_size));
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
mbedtls_test_driver_cipher_hooks.hits = 0;
- PSA_ASSERT( psa_cipher_update( &operation,
- input->x, input->len,
- output2, output2_buffer_size,
- &function_output_length ) );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+ PSA_ASSERT(psa_cipher_update(&operation,
+ input->x, input->len,
+ output2, output2_buffer_size,
+ &function_output_length));
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
mbedtls_test_driver_cipher_hooks.hits = 0;
output2_length += function_output_length;
- PSA_ASSERT( psa_cipher_finish( &operation,
- output2 + output2_length,
- output2_buffer_size - output2_length,
- &function_output_length ) );
+ PSA_ASSERT(psa_cipher_finish(&operation,
+ output2 + output2_length,
+ output2_buffer_size - output2_length,
+ &function_output_length));
/* Finish will have called abort as well, so expecting two hits here */
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 2 );
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 2);
mbedtls_test_driver_cipher_hooks.hits = 0;
output2_length += function_output_length;
- PSA_ASSERT( psa_cipher_abort( &operation ) );
+ PSA_ASSERT(psa_cipher_abort(&operation));
// driver function should've been called as part of the finish() core routine
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
- ASSERT_COMPARE( output1 + iv_size, output1_length - iv_size,
- output2, output2_length );
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0);
+ ASSERT_COMPARE(output1 + iv_size, output1_length - iv_size,
+ output2, output2_length);
exit:
- psa_cipher_abort( &operation );
- mbedtls_free( output1 );
- mbedtls_free( output2 );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_cipher_abort(&operation);
+ mbedtls_free(output1);
+ mbedtls_free(output2);
+ psa_destroy_key(key);
+ PSA_DONE();
mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_encrypt_multipart( int alg_arg,
- int key_type_arg,
- data_t *key_data,
- data_t *iv,
- data_t *input,
- int first_part_size_arg,
- int output1_length_arg,
- int output2_length_arg,
- data_t *expected_output,
- int mock_output_arg,
- int force_status_arg,
- int expected_status_arg )
+void cipher_encrypt_multipart(int alg_arg,
+ int key_type_arg,
+ data_t *key_data,
+ data_t *iv,
+ data_t *input,
+ int first_part_size_arg,
+ int output1_length_arg,
+ int output2_length_arg,
+ data_t *expected_output,
+ int mock_output_arg,
+ int force_status_arg,
+ int expected_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -585,247 +574,239 @@
/* Test operation initialization */
mbedtls_psa_cipher_operation_t mbedtls_operation =
- MBEDTLS_PSA_CIPHER_OPERATION_INIT;
+ MBEDTLS_PSA_CIPHER_OPERATION_INIT;
mbedtls_transparent_test_driver_cipher_operation_t transparent_operation =
- MBEDTLS_TRANSPARENT_TEST_DRIVER_CIPHER_OPERATION_INIT;
+ MBEDTLS_TRANSPARENT_TEST_DRIVER_CIPHER_OPERATION_INIT;
mbedtls_opaque_test_driver_cipher_operation_t opaque_operation =
- MBEDTLS_OPAQUE_TEST_DRIVER_CIPHER_OPERATION_INIT;
+ MBEDTLS_OPAQUE_TEST_DRIVER_CIPHER_OPERATION_INIT;
operation.ctx.mbedtls_ctx = mbedtls_operation;
operation.ctx.transparent_test_driver_ctx = transparent_operation;
operation.ctx.opaque_test_driver_ctx = opaque_operation;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- PSA_ASSERT( psa_cipher_encrypt_setup( &operation, key, alg ) );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+ PSA_ASSERT(psa_cipher_encrypt_setup(&operation, key, alg));
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
mbedtls_test_driver_cipher_hooks.hits = 0;
- PSA_ASSERT( psa_cipher_set_iv( &operation, iv->x, iv->len ) );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 1 : 0 ) );
+ PSA_ASSERT(psa_cipher_set_iv(&operation, iv->x, iv->len));
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, (force_status == PSA_SUCCESS ? 1 : 0));
mbedtls_test_driver_cipher_hooks.hits = 0;
- output_buffer_size = ( (size_t) input->len +
- PSA_BLOCK_CIPHER_BLOCK_LENGTH( key_type ) );
- ASSERT_ALLOC( output, output_buffer_size );
+ output_buffer_size = ((size_t) input->len +
+ PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type));
+ ASSERT_ALLOC(output, output_buffer_size);
- if( mock_output_arg )
- {
+ if (mock_output_arg) {
mbedtls_test_driver_cipher_hooks.forced_output = expected_output->x;
mbedtls_test_driver_cipher_hooks.forced_output_length = expected_output->len;
}
- TEST_ASSERT( first_part_size <= input->len );
- PSA_ASSERT( psa_cipher_update( &operation, input->x, first_part_size,
- output, output_buffer_size,
- &function_output_length ) );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 1 : 0 ) );
+ TEST_ASSERT(first_part_size <= input->len);
+ PSA_ASSERT(psa_cipher_update(&operation, input->x, first_part_size,
+ output, output_buffer_size,
+ &function_output_length));
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, (force_status == PSA_SUCCESS ? 1 : 0));
mbedtls_test_driver_cipher_hooks.hits = 0;
- TEST_ASSERT( function_output_length == output1_length );
+ TEST_ASSERT(function_output_length == output1_length);
total_output_length += function_output_length;
- if( first_part_size < input->len )
- {
- PSA_ASSERT( psa_cipher_update( &operation,
- input->x + first_part_size,
- input->len - first_part_size,
- output + total_output_length,
- output_buffer_size - total_output_length,
- &function_output_length ) );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+ if (first_part_size < input->len) {
+ PSA_ASSERT(psa_cipher_update(&operation,
+ input->x + first_part_size,
+ input->len - first_part_size,
+ output + total_output_length,
+ output_buffer_size - total_output_length,
+ &function_output_length));
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
mbedtls_test_driver_cipher_hooks.hits = 0;
- TEST_ASSERT( function_output_length == output2_length );
+ TEST_ASSERT(function_output_length == output2_length);
total_output_length += function_output_length;
}
- if( mock_output_arg )
- {
+ if (mock_output_arg) {
mbedtls_test_driver_cipher_hooks.forced_output = NULL;
mbedtls_test_driver_cipher_hooks.forced_output_length = 0;
}
- status = psa_cipher_finish( &operation,
- output + total_output_length,
- output_buffer_size - total_output_length,
- &function_output_length );
- /* Finish will have called abort as well, so expecting two hits here */
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 2 : 0 ) );
- mbedtls_test_driver_cipher_hooks.hits = 0 ;
- total_output_length += function_output_length;
- TEST_EQUAL( status, expected_status );
-
- if( expected_status == PSA_SUCCESS )
- {
- PSA_ASSERT( psa_cipher_abort( &operation ) );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
-
- ASSERT_COMPARE( expected_output->x, expected_output->len,
- output, total_output_length );
- }
-
-exit:
- psa_cipher_abort( &operation );
- mbedtls_free( output );
- psa_destroy_key( key );
- PSA_DONE( );
- mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
-}
-/* END_CASE */
-
-/* BEGIN_CASE */
-void cipher_decrypt_multipart( int alg_arg,
- int key_type_arg,
- data_t *key_data,
- data_t *iv,
- data_t *input,
- int first_part_size_arg,
- int output1_length_arg,
- int output2_length_arg,
- data_t *expected_output,
- int mock_output_arg,
- int force_status_arg,
- int expected_status_arg )
-{
- mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
- psa_key_type_t key_type = key_type_arg;
- psa_algorithm_t alg = alg_arg;
- psa_status_t status;
- psa_status_t expected_status = expected_status_arg;
- psa_status_t force_status = force_status_arg;
- size_t first_part_size = first_part_size_arg;
- size_t output1_length = output1_length_arg;
- size_t output2_length = output2_length_arg;
- unsigned char *output = NULL;
- size_t output_buffer_size = 0;
- size_t function_output_length = 0;
- size_t total_output_length = 0;
- psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
- psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
- mbedtls_test_driver_cipher_hooks.forced_status = force_status;
-
- /* Test operation initialization */
- mbedtls_psa_cipher_operation_t mbedtls_operation =
- MBEDTLS_PSA_CIPHER_OPERATION_INIT;
-
- mbedtls_transparent_test_driver_cipher_operation_t transparent_operation =
- MBEDTLS_TRANSPARENT_TEST_DRIVER_CIPHER_OPERATION_INIT;
-
- mbedtls_opaque_test_driver_cipher_operation_t opaque_operation =
- MBEDTLS_OPAQUE_TEST_DRIVER_CIPHER_OPERATION_INIT;
-
- operation.ctx.mbedtls_ctx = mbedtls_operation;
- operation.ctx.transparent_test_driver_ctx = transparent_operation;
- operation.ctx.opaque_test_driver_ctx = opaque_operation;
-
- PSA_ASSERT( psa_crypto_init( ) );
-
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
-
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
-
- PSA_ASSERT( psa_cipher_decrypt_setup( &operation, key, alg ) );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
- mbedtls_test_driver_cipher_hooks.hits = 0;
-
- PSA_ASSERT( psa_cipher_set_iv( &operation, iv->x, iv->len ) );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 1 : 0 ) );
- mbedtls_test_driver_cipher_hooks.hits = 0;
-
- output_buffer_size = ( (size_t) input->len +
- PSA_BLOCK_CIPHER_BLOCK_LENGTH( key_type ) );
- ASSERT_ALLOC( output, output_buffer_size );
-
- if( mock_output_arg )
- {
- mbedtls_test_driver_cipher_hooks.forced_output = expected_output->x;
- mbedtls_test_driver_cipher_hooks.forced_output_length = expected_output->len;
- }
-
- TEST_ASSERT( first_part_size <= input->len );
- PSA_ASSERT( psa_cipher_update( &operation,
- input->x, first_part_size,
- output, output_buffer_size,
- &function_output_length ) );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 1 : 0 ) );
- mbedtls_test_driver_cipher_hooks.hits = 0;
-
- TEST_ASSERT( function_output_length == output1_length );
- total_output_length += function_output_length;
-
- if( first_part_size < input->len )
- {
- PSA_ASSERT( psa_cipher_update( &operation,
- input->x + first_part_size,
- input->len - first_part_size,
- output + total_output_length,
- output_buffer_size - total_output_length,
- &function_output_length ) );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 1 : 0 ) );
- mbedtls_test_driver_cipher_hooks.hits = 0;
-
- TEST_ASSERT( function_output_length == output2_length );
- total_output_length += function_output_length;
- }
-
- if( mock_output_arg )
- {
- mbedtls_test_driver_cipher_hooks.forced_output = NULL;
- mbedtls_test_driver_cipher_hooks.forced_output_length = 0;
- }
-
- status = psa_cipher_finish( &operation,
+ status = psa_cipher_finish(&operation,
output + total_output_length,
output_buffer_size - total_output_length,
- &function_output_length );
+ &function_output_length);
/* Finish will have called abort as well, so expecting two hits here */
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, ( force_status == PSA_SUCCESS ? 2 : 0 ) );
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, (force_status == PSA_SUCCESS ? 2 : 0));
mbedtls_test_driver_cipher_hooks.hits = 0;
total_output_length += function_output_length;
- TEST_EQUAL( status, expected_status );
+ TEST_EQUAL(status, expected_status);
- if( expected_status == PSA_SUCCESS )
- {
- PSA_ASSERT( psa_cipher_abort( &operation ) );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
+ if (expected_status == PSA_SUCCESS) {
+ PSA_ASSERT(psa_cipher_abort(&operation));
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0);
- ASSERT_COMPARE( expected_output->x, expected_output->len,
- output, total_output_length );
+ ASSERT_COMPARE(expected_output->x, expected_output->len,
+ output, total_output_length);
}
exit:
- psa_cipher_abort( &operation );
- mbedtls_free( output );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_cipher_abort(&operation);
+ mbedtls_free(output);
+ psa_destroy_key(key);
+ PSA_DONE();
mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_decrypt( int alg_arg,
- int key_type_arg,
- data_t *key_data,
- data_t *iv,
- data_t *input_arg,
- data_t *expected_output,
- int mock_output_arg,
- int force_status_arg,
- int expected_status_arg )
+void cipher_decrypt_multipart(int alg_arg,
+ int key_type_arg,
+ data_t *key_data,
+ data_t *iv,
+ data_t *input,
+ int first_part_size_arg,
+ int output1_length_arg,
+ int output2_length_arg,
+ data_t *expected_output,
+ int mock_output_arg,
+ int force_status_arg,
+ int expected_status_arg)
+{
+ mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
+ psa_key_type_t key_type = key_type_arg;
+ psa_algorithm_t alg = alg_arg;
+ psa_status_t status;
+ psa_status_t expected_status = expected_status_arg;
+ psa_status_t force_status = force_status_arg;
+ size_t first_part_size = first_part_size_arg;
+ size_t output1_length = output1_length_arg;
+ size_t output2_length = output2_length_arg;
+ unsigned char *output = NULL;
+ size_t output_buffer_size = 0;
+ size_t function_output_length = 0;
+ size_t total_output_length = 0;
+ psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
+ psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
+ mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
+ mbedtls_test_driver_cipher_hooks.forced_status = force_status;
+
+ /* Test operation initialization */
+ mbedtls_psa_cipher_operation_t mbedtls_operation =
+ MBEDTLS_PSA_CIPHER_OPERATION_INIT;
+
+ mbedtls_transparent_test_driver_cipher_operation_t transparent_operation =
+ MBEDTLS_TRANSPARENT_TEST_DRIVER_CIPHER_OPERATION_INIT;
+
+ mbedtls_opaque_test_driver_cipher_operation_t opaque_operation =
+ MBEDTLS_OPAQUE_TEST_DRIVER_CIPHER_OPERATION_INIT;
+
+ operation.ctx.mbedtls_ctx = mbedtls_operation;
+ operation.ctx.transparent_test_driver_ctx = transparent_operation;
+ operation.ctx.opaque_test_driver_ctx = opaque_operation;
+
+ PSA_ASSERT(psa_crypto_init());
+
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
+
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+
+ PSA_ASSERT(psa_cipher_decrypt_setup(&operation, key, alg));
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
+ mbedtls_test_driver_cipher_hooks.hits = 0;
+
+ PSA_ASSERT(psa_cipher_set_iv(&operation, iv->x, iv->len));
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, (force_status == PSA_SUCCESS ? 1 : 0));
+ mbedtls_test_driver_cipher_hooks.hits = 0;
+
+ output_buffer_size = ((size_t) input->len +
+ PSA_BLOCK_CIPHER_BLOCK_LENGTH(key_type));
+ ASSERT_ALLOC(output, output_buffer_size);
+
+ if (mock_output_arg) {
+ mbedtls_test_driver_cipher_hooks.forced_output = expected_output->x;
+ mbedtls_test_driver_cipher_hooks.forced_output_length = expected_output->len;
+ }
+
+ TEST_ASSERT(first_part_size <= input->len);
+ PSA_ASSERT(psa_cipher_update(&operation,
+ input->x, first_part_size,
+ output, output_buffer_size,
+ &function_output_length));
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, (force_status == PSA_SUCCESS ? 1 : 0));
+ mbedtls_test_driver_cipher_hooks.hits = 0;
+
+ TEST_ASSERT(function_output_length == output1_length);
+ total_output_length += function_output_length;
+
+ if (first_part_size < input->len) {
+ PSA_ASSERT(psa_cipher_update(&operation,
+ input->x + first_part_size,
+ input->len - first_part_size,
+ output + total_output_length,
+ output_buffer_size - total_output_length,
+ &function_output_length));
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, (force_status == PSA_SUCCESS ? 1 : 0));
+ mbedtls_test_driver_cipher_hooks.hits = 0;
+
+ TEST_ASSERT(function_output_length == output2_length);
+ total_output_length += function_output_length;
+ }
+
+ if (mock_output_arg) {
+ mbedtls_test_driver_cipher_hooks.forced_output = NULL;
+ mbedtls_test_driver_cipher_hooks.forced_output_length = 0;
+ }
+
+ status = psa_cipher_finish(&operation,
+ output + total_output_length,
+ output_buffer_size - total_output_length,
+ &function_output_length);
+ /* Finish will have called abort as well, so expecting two hits here */
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, (force_status == PSA_SUCCESS ? 2 : 0));
+ mbedtls_test_driver_cipher_hooks.hits = 0;
+ total_output_length += function_output_length;
+ TEST_EQUAL(status, expected_status);
+
+ if (expected_status == PSA_SUCCESS) {
+ PSA_ASSERT(psa_cipher_abort(&operation));
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0);
+
+ ASSERT_COMPARE(expected_output->x, expected_output->len,
+ output, total_output_length);
+ }
+
+exit:
+ psa_cipher_abort(&operation);
+ mbedtls_free(output);
+ psa_destroy_key(key);
+ PSA_DONE();
+ mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void cipher_decrypt(int alg_arg,
+ int key_type_arg,
+ data_t *key_data,
+ data_t *iv,
+ data_t *input_arg,
+ data_t *expected_output,
+ int mock_output_arg,
+ int force_status_arg,
+ int expected_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_status_t status;
@@ -842,59 +823,56 @@
mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
mbedtls_test_driver_cipher_hooks.forced_status = force_status;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
/* 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 )
- {
- ASSERT_ALLOC( input, input_buffer_size );
- memcpy( input, iv->x, iv->len );
- memcpy( input + iv->len, input_arg->x, input_arg->len );
+ input_buffer_size = ((size_t) input_arg->len + (size_t) iv->len);
+ if (input_buffer_size > 0) {
+ ASSERT_ALLOC(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 );
- ASSERT_ALLOC( output, output_buffer_size );
+ output_buffer_size = PSA_CIPHER_DECRYPT_OUTPUT_SIZE(key_type, alg, input_buffer_size);
+ ASSERT_ALLOC(output, output_buffer_size);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- if( mock_output_arg )
- {
+ if (mock_output_arg) {
mbedtls_test_driver_cipher_hooks.forced_output = expected_output->x;
mbedtls_test_driver_cipher_hooks.forced_output_length = expected_output->len;
}
- status = psa_cipher_decrypt( key, alg, input, input_buffer_size, output,
- output_buffer_size, &output_length );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
+ status = psa_cipher_decrypt(key, alg, input, input_buffer_size, output,
+ output_buffer_size, &output_length);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
mbedtls_test_driver_cipher_hooks.hits = 0;
- TEST_EQUAL( status, expected_status );
+ TEST_EQUAL(status, expected_status);
- if( expected_status == PSA_SUCCESS )
- {
- ASSERT_COMPARE( expected_output->x, expected_output->len,
- output, output_length );
+ if (expected_status == PSA_SUCCESS) {
+ ASSERT_COMPARE(expected_output->x, expected_output->len,
+ output, output_length);
}
exit:
- mbedtls_free( input );
- mbedtls_free( output );
- psa_destroy_key( key );
- PSA_DONE( );
+ mbedtls_free(input);
+ mbedtls_free(output);
+ psa_destroy_key(key);
+ PSA_DONE();
mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_entry_points( int alg_arg, int key_type_arg,
- data_t *key_data, data_t *iv,
- data_t *input )
+void cipher_entry_points(int alg_arg, int key_type_arg,
+ data_t *key_data, data_t *iv,
+ data_t *input)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_status_t status;
@@ -907,17 +885,17 @@
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
- ASSERT_ALLOC( output, input->len + 16 );
+ ASSERT_ALLOC(output, input->len + 16);
output_buffer_size = input->len + 16;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
/*
* Test encrypt failure
@@ -926,195 +904,195 @@
*/
status = psa_cipher_encrypt(
key, alg, input->x, input->len,
- output, output_buffer_size, &function_output_length );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
- TEST_EQUAL( status, PSA_SUCCESS );
+ output, output_buffer_size, &function_output_length);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
+ TEST_EQUAL(status, PSA_SUCCESS);
mbedtls_test_driver_cipher_hooks.hits = 0;
mbedtls_test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
/* Set the output buffer in a given state. */
- for( size_t i = 0; i < output_buffer_size; i++ )
+ for (size_t i = 0; i < output_buffer_size; i++) {
output[i] = 0xa5;
+ }
status = psa_cipher_encrypt(
key, alg, input->x, input->len,
- output, output_buffer_size, &function_output_length );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
- TEST_EQUAL( status, PSA_ERROR_GENERIC_ERROR );
+ output, output_buffer_size, &function_output_length);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
+ TEST_EQUAL(status, PSA_ERROR_GENERIC_ERROR);
/*
* Check that the output buffer is still in the same state.
* This will fail if the output buffer is used by the core to pass the IV
* it generated to the driver (and is not restored).
*/
- for( size_t i = 0; i < output_buffer_size; i++ )
- {
- TEST_EQUAL( output[i], 0xa5 );
+ for (size_t i = 0; i < output_buffer_size; i++) {
+ TEST_EQUAL(output[i], 0xa5);
}
mbedtls_test_driver_cipher_hooks.hits = 0;
/* Test setup call, encrypt */
mbedtls_test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
- status = psa_cipher_encrypt_setup( &operation, key, alg );
+ status = psa_cipher_encrypt_setup(&operation, key, alg);
/* When setup fails, it shouldn't call any further entry points */
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
- TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
+ TEST_EQUAL(status, mbedtls_test_driver_cipher_hooks.forced_status);
mbedtls_test_driver_cipher_hooks.hits = 0;
- status = psa_cipher_set_iv( &operation, iv->x, iv->len );
- TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
+ status = psa_cipher_set_iv(&operation, iv->x, iv->len);
+ TEST_EQUAL(status, PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0);
/* Test setup call failure, decrypt */
- status = psa_cipher_decrypt_setup( &operation, key, alg );
+ status = psa_cipher_decrypt_setup(&operation, key, alg);
/* When setup fails, it shouldn't call any further entry points */
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
- TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
+ TEST_EQUAL(status, mbedtls_test_driver_cipher_hooks.forced_status);
mbedtls_test_driver_cipher_hooks.hits = 0;
- status = psa_cipher_set_iv( &operation, iv->x, iv->len );
- TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
+ status = psa_cipher_set_iv(&operation, iv->x, iv->len);
+ TEST_EQUAL(status, PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0);
/* Test IV setting failure */
mbedtls_test_driver_cipher_hooks.forced_status = PSA_SUCCESS;
- status = psa_cipher_encrypt_setup( &operation, key, alg );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
- TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+ status = psa_cipher_encrypt_setup(&operation, key, alg);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
+ TEST_EQUAL(status, mbedtls_test_driver_cipher_hooks.forced_status);
mbedtls_test_driver_cipher_hooks.hits = 0;
mbedtls_test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
- status = psa_cipher_set_iv( &operation, iv->x, iv->len );
+ status = psa_cipher_set_iv(&operation, iv->x, iv->len);
/* When setting the IV fails, it should call abort too */
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 2 );
- TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 2);
+ TEST_EQUAL(status, mbedtls_test_driver_cipher_hooks.forced_status);
/* Failure should prevent further operations from executing on the driver */
mbedtls_test_driver_cipher_hooks.hits = 0;
- status = psa_cipher_update( &operation,
- input->x, input->len,
- output, output_buffer_size,
- &function_output_length );
- TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
- psa_cipher_abort( &operation );
+ status = psa_cipher_update(&operation,
+ input->x, input->len,
+ output, output_buffer_size,
+ &function_output_length);
+ TEST_EQUAL(status, PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0);
+ psa_cipher_abort(&operation);
/* Test IV generation failure */
mbedtls_test_driver_cipher_hooks.forced_status = PSA_SUCCESS;
- status = psa_cipher_encrypt_setup( &operation, key, alg );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
- TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+ status = psa_cipher_encrypt_setup(&operation, key, alg);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
+ TEST_EQUAL(status, mbedtls_test_driver_cipher_hooks.forced_status);
mbedtls_test_driver_cipher_hooks.hits = 0;
mbedtls_test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
/* Set the output buffer in a given state. */
- for( size_t i = 0; i < 16; i++ )
+ for (size_t i = 0; i < 16; i++) {
output[i] = 0xa5;
+ }
- status = psa_cipher_generate_iv( &operation, output, 16, &function_output_length );
+ status = psa_cipher_generate_iv(&operation, output, 16, &function_output_length);
/* When generating the IV fails, it should call abort too */
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 2 );
- TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 2);
+ TEST_EQUAL(status, mbedtls_test_driver_cipher_hooks.forced_status);
/*
* Check that the output buffer is still in the same state.
* This will fail if the output buffer is used by the core to pass the IV
* it generated to the driver (and is not restored).
*/
- for( size_t i = 0; i < 16; i++ )
- {
- TEST_EQUAL( output[i], 0xa5 );
+ for (size_t i = 0; i < 16; i++) {
+ TEST_EQUAL(output[i], 0xa5);
}
/* Failure should prevent further operations from executing on the driver */
mbedtls_test_driver_cipher_hooks.hits = 0;
- status = psa_cipher_update( &operation,
- input->x, input->len,
- output, output_buffer_size,
- &function_output_length );
- TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
- psa_cipher_abort( &operation );
+ status = psa_cipher_update(&operation,
+ input->x, input->len,
+ output, output_buffer_size,
+ &function_output_length);
+ TEST_EQUAL(status, PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0);
+ psa_cipher_abort(&operation);
/* Test update failure */
mbedtls_test_driver_cipher_hooks.forced_status = PSA_SUCCESS;
- status = psa_cipher_encrypt_setup( &operation, key, alg );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
- TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+ status = psa_cipher_encrypt_setup(&operation, key, alg);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
+ TEST_EQUAL(status, mbedtls_test_driver_cipher_hooks.forced_status);
mbedtls_test_driver_cipher_hooks.hits = 0;
- status = psa_cipher_set_iv( &operation, iv->x, iv->len );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
- TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+ status = psa_cipher_set_iv(&operation, iv->x, iv->len);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
+ TEST_EQUAL(status, mbedtls_test_driver_cipher_hooks.forced_status);
mbedtls_test_driver_cipher_hooks.hits = 0;
mbedtls_test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
- status = psa_cipher_update( &operation,
- input->x, input->len,
- output, output_buffer_size,
- &function_output_length );
+ status = psa_cipher_update(&operation,
+ input->x, input->len,
+ output, output_buffer_size,
+ &function_output_length);
/* When the update call fails, it should call abort too */
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 2 );
- TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 2);
+ TEST_EQUAL(status, mbedtls_test_driver_cipher_hooks.forced_status);
/* Failure should prevent further operations from executing on the driver */
mbedtls_test_driver_cipher_hooks.hits = 0;
- status = psa_cipher_update( &operation,
- input->x, input->len,
- output, output_buffer_size,
- &function_output_length );
- TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
- psa_cipher_abort( &operation );
+ status = psa_cipher_update(&operation,
+ input->x, input->len,
+ output, output_buffer_size,
+ &function_output_length);
+ TEST_EQUAL(status, PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0);
+ psa_cipher_abort(&operation);
/* Test finish failure */
mbedtls_test_driver_cipher_hooks.forced_status = PSA_SUCCESS;
- status = psa_cipher_encrypt_setup( &operation, key, alg );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
- TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+ status = psa_cipher_encrypt_setup(&operation, key, alg);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
+ TEST_EQUAL(status, mbedtls_test_driver_cipher_hooks.forced_status);
mbedtls_test_driver_cipher_hooks.hits = 0;
- status = psa_cipher_set_iv( &operation, iv->x, iv->len );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
- TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+ status = psa_cipher_set_iv(&operation, iv->x, iv->len);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
+ TEST_EQUAL(status, mbedtls_test_driver_cipher_hooks.forced_status);
mbedtls_test_driver_cipher_hooks.hits = 0;
- status = psa_cipher_update( &operation,
- input->x, input->len,
- output, output_buffer_size,
- &function_output_length );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 1 );
- TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+ status = psa_cipher_update(&operation,
+ input->x, input->len,
+ output, output_buffer_size,
+ &function_output_length);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 1);
+ TEST_EQUAL(status, mbedtls_test_driver_cipher_hooks.forced_status);
mbedtls_test_driver_cipher_hooks.hits = 0;
mbedtls_test_driver_cipher_hooks.forced_status = PSA_ERROR_GENERIC_ERROR;
- status = psa_cipher_finish( &operation,
- output + function_output_length,
- output_buffer_size - function_output_length,
- &function_output_length );
+ status = psa_cipher_finish(&operation,
+ output + function_output_length,
+ output_buffer_size - function_output_length,
+ &function_output_length);
/* When the finish call fails, it should call abort too */
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 2 );
- TEST_EQUAL( status, mbedtls_test_driver_cipher_hooks.forced_status );
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 2);
+ TEST_EQUAL(status, mbedtls_test_driver_cipher_hooks.forced_status);
/* Failure should prevent further operations from executing on the driver */
mbedtls_test_driver_cipher_hooks.hits = 0;
- status = psa_cipher_update( &operation,
- input->x, input->len,
- output, output_buffer_size,
- &function_output_length );
- TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
- TEST_EQUAL( mbedtls_test_driver_cipher_hooks.hits, 0 );
- psa_cipher_abort( &operation );
+ status = psa_cipher_update(&operation,
+ input->x, input->len,
+ output, output_buffer_size,
+ &function_output_length);
+ TEST_EQUAL(status, PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(mbedtls_test_driver_cipher_hooks.hits, 0);
+ psa_cipher_abort(&operation);
exit:
- psa_cipher_abort( &operation );
- mbedtls_free( output );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_cipher_abort(&operation);
+ mbedtls_free(output);
+ psa_destroy_key(key);
+ PSA_DONE();
mbedtls_test_driver_cipher_hooks = mbedtls_test_driver_cipher_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void aead_encrypt( int key_type_arg, data_t *key_data,
- int alg_arg,
- data_t *nonce,
- data_t *additional_data,
- data_t *input_data,
- data_t *expected_result,
- int forced_status_arg )
+void aead_encrypt(int key_type_arg, data_t *key_data,
+ int alg_arg,
+ data_t *nonce,
+ data_t *additional_data,
+ data_t *input_data,
+ data_t *expected_result,
+ int forced_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -1128,62 +1106,61 @@
psa_status_t status = PSA_ERROR_GENERIC_ERROR;
mbedtls_test_driver_aead_hooks = mbedtls_test_driver_aead_hooks_init();
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_ENCRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
- output_size = input_data->len + PSA_AEAD_TAG_LENGTH( key_type, key_bits,
- alg );
+ output_size = input_data->len + PSA_AEAD_TAG_LENGTH(key_type, key_bits,
+ alg);
/* For all currently defined algorithms, PSA_AEAD_ENCRYPT_OUTPUT_SIZE
* should be exact. */
- TEST_EQUAL( output_size,
- PSA_AEAD_ENCRYPT_OUTPUT_SIZE( key_type, alg, input_data->len ) );
- TEST_ASSERT( output_size <=
- PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE( input_data->len ) );
- ASSERT_ALLOC( output_data, output_size );
+ TEST_EQUAL(output_size,
+ PSA_AEAD_ENCRYPT_OUTPUT_SIZE(key_type, alg, input_data->len));
+ TEST_ASSERT(output_size <=
+ PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE(input_data->len));
+ ASSERT_ALLOC(output_data, output_size);
mbedtls_test_driver_aead_hooks.forced_status = forced_status;
- status = psa_aead_encrypt( key, alg,
- nonce->x, nonce->len,
- additional_data->x, additional_data->len,
- input_data->x, input_data->len,
- output_data, output_size,
- &output_length );
- TEST_EQUAL( mbedtls_test_driver_aead_hooks.hits, 1 );
- TEST_EQUAL( mbedtls_test_driver_aead_hooks.driver_status, forced_status );
+ status = psa_aead_encrypt(key, alg,
+ nonce->x, nonce->len,
+ additional_data->x, additional_data->len,
+ input_data->x, input_data->len,
+ output_data, output_size,
+ &output_length);
+ TEST_EQUAL(mbedtls_test_driver_aead_hooks.hits, 1);
+ TEST_EQUAL(mbedtls_test_driver_aead_hooks.driver_status, forced_status);
- TEST_EQUAL( status, ( forced_status == PSA_ERROR_NOT_SUPPORTED ) ?
- PSA_SUCCESS : forced_status );
+ TEST_EQUAL(status, (forced_status == PSA_ERROR_NOT_SUPPORTED) ?
+ PSA_SUCCESS : forced_status);
- if( status == PSA_SUCCESS )
- {
- ASSERT_COMPARE( expected_result->x, expected_result->len,
- output_data, output_length );
+ if (status == PSA_SUCCESS) {
+ ASSERT_COMPARE(expected_result->x, expected_result->len,
+ output_data, output_length);
}
exit:
- psa_destroy_key( key );
- mbedtls_free( output_data );
- PSA_DONE( );
+ psa_destroy_key(key);
+ mbedtls_free(output_data);
+ PSA_DONE();
mbedtls_test_driver_aead_hooks = mbedtls_test_driver_aead_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void aead_decrypt( int key_type_arg, data_t *key_data,
- int alg_arg,
- data_t *nonce,
- data_t *additional_data,
- data_t *input_data,
- data_t *expected_data,
- int forced_status_arg )
+void aead_decrypt(int key_type_arg, data_t *key_data,
+ int alg_arg,
+ data_t *nonce,
+ data_t *additional_data,
+ data_t *input_data,
+ data_t *expected_data,
+ int forced_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -1197,56 +1174,55 @@
psa_status_t status = PSA_ERROR_GENERIC_ERROR;
mbedtls_test_driver_aead_hooks = mbedtls_test_driver_aead_hooks_init();
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- key_bits = psa_get_key_bits( &attributes );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ key_bits = psa_get_key_bits(&attributes);
- output_size = input_data->len - PSA_AEAD_TAG_LENGTH( key_type, key_bits,
- alg );
- ASSERT_ALLOC( output_data, output_size );
+ output_size = input_data->len - PSA_AEAD_TAG_LENGTH(key_type, key_bits,
+ alg);
+ ASSERT_ALLOC(output_data, output_size);
mbedtls_test_driver_aead_hooks.forced_status = forced_status;
- status = psa_aead_decrypt( key, alg,
- nonce->x, nonce->len,
- additional_data->x,
- additional_data->len,
- input_data->x, input_data->len,
- output_data, output_size,
- &output_length );
- TEST_EQUAL( mbedtls_test_driver_aead_hooks.hits, 1 );
- TEST_EQUAL( mbedtls_test_driver_aead_hooks.driver_status, forced_status );
+ status = psa_aead_decrypt(key, alg,
+ nonce->x, nonce->len,
+ additional_data->x,
+ additional_data->len,
+ input_data->x, input_data->len,
+ output_data, output_size,
+ &output_length);
+ TEST_EQUAL(mbedtls_test_driver_aead_hooks.hits, 1);
+ TEST_EQUAL(mbedtls_test_driver_aead_hooks.driver_status, forced_status);
- TEST_EQUAL( status, ( forced_status == PSA_ERROR_NOT_SUPPORTED ) ?
- PSA_SUCCESS : forced_status );
+ TEST_EQUAL(status, (forced_status == PSA_ERROR_NOT_SUPPORTED) ?
+ PSA_SUCCESS : forced_status);
- if( status == PSA_SUCCESS )
- {
- ASSERT_COMPARE( expected_data->x, expected_data->len,
- output_data, output_length );
+ if (status == PSA_SUCCESS) {
+ ASSERT_COMPARE(expected_data->x, expected_data->len,
+ output_data, output_length);
}
exit:
- psa_destroy_key( key );
- mbedtls_free( output_data );
- PSA_DONE( );
+ psa_destroy_key(key);
+ mbedtls_free(output_data);
+ PSA_DONE();
mbedtls_test_driver_aead_hooks = mbedtls_test_driver_aead_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void mac_sign( int key_type_arg,
- data_t *key_data,
- int alg_arg,
- data_t *input,
- data_t *expected_mac,
- int forced_status_arg )
+void mac_sign(int key_type_arg,
+ data_t *key_data,
+ int alg_arg,
+ data_t *input,
+ data_t *expected_mac,
+ int forced_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -1255,125 +1231,124 @@
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
uint8_t *actual_mac = NULL;
size_t mac_buffer_size =
- PSA_MAC_LENGTH( key_type, PSA_BYTES_TO_BITS( key_data->len ), alg );
+ PSA_MAC_LENGTH(key_type, PSA_BYTES_TO_BITS(key_data->len), alg);
size_t mac_length = 0;
psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
psa_status_t forced_status = forced_status_arg;
mbedtls_test_driver_mac_hooks = mbedtls_test_driver_mac_hooks_init();
- TEST_ASSERT( mac_buffer_size <= PSA_MAC_MAX_SIZE );
+ TEST_ASSERT(mac_buffer_size <= PSA_MAC_MAX_SIZE);
/* We expect PSA_MAC_LENGTH to be exact. */
- TEST_ASSERT( expected_mac->len == mac_buffer_size );
+ TEST_ASSERT(expected_mac->len == mac_buffer_size);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
- ASSERT_ALLOC( actual_mac, mac_buffer_size );
+ ASSERT_ALLOC(actual_mac, mac_buffer_size);
mbedtls_test_driver_mac_hooks.forced_status = forced_status;
/*
* Calculate the MAC, one-shot case.
*/
- status = psa_mac_compute( key, alg,
- input->x, input->len,
- actual_mac, mac_buffer_size,
- &mac_length );
+ status = psa_mac_compute(key, alg,
+ input->x, input->len,
+ actual_mac, mac_buffer_size,
+ &mac_length);
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 1 );
- if( forced_status == PSA_SUCCESS ||
- forced_status == PSA_ERROR_NOT_SUPPORTED )
- {
- PSA_ASSERT( status );
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 1);
+ if (forced_status == PSA_SUCCESS ||
+ forced_status == PSA_ERROR_NOT_SUPPORTED) {
+ PSA_ASSERT(status);
+ } else {
+ TEST_EQUAL(forced_status, status);
}
- else
- TEST_EQUAL( forced_status, status );
- if( mac_buffer_size > 0 )
- memset( actual_mac, 0, mac_buffer_size );
+ if (mac_buffer_size > 0) {
+ memset(actual_mac, 0, mac_buffer_size);
+ }
mbedtls_test_driver_mac_hooks = mbedtls_test_driver_mac_hooks_init();
mbedtls_test_driver_mac_hooks.forced_status = forced_status;
/*
* Calculate the MAC, multipart case.
*/
- status = psa_mac_sign_setup( &operation, key, alg );
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 1 );
+ status = psa_mac_sign_setup(&operation, key, alg);
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 1);
- if( forced_status == PSA_SUCCESS ||
- forced_status == PSA_ERROR_NOT_SUPPORTED )
- {
- PSA_ASSERT( status );
- }
- else
- TEST_EQUAL( forced_status, status );
-
- status = psa_mac_update( &operation,
- input->x, input->len );
- if( forced_status == PSA_SUCCESS )
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 2 );
- else
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 1 );
- if( forced_status == PSA_SUCCESS ||
- forced_status == PSA_ERROR_NOT_SUPPORTED )
- {
- PSA_ASSERT( status );
- }
- else
- TEST_EQUAL( PSA_ERROR_BAD_STATE, status );
-
- status = psa_mac_sign_finish( &operation,
- actual_mac, mac_buffer_size,
- &mac_length );
- if( forced_status == PSA_SUCCESS )
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 4 );
- else
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 1 );
-
- if( forced_status == PSA_SUCCESS ||
- forced_status == PSA_ERROR_NOT_SUPPORTED )
- {
- PSA_ASSERT( status );
- }
- else
- TEST_EQUAL( PSA_ERROR_BAD_STATE, status );
-
- PSA_ASSERT( psa_mac_abort( &operation ) );
- if( forced_status == PSA_SUCCESS )
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 4 );
- else
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 1 );
-
- if( forced_status == PSA_SUCCESS )
- {
- ASSERT_COMPARE( expected_mac->x, expected_mac->len,
- actual_mac, mac_length );
+ if (forced_status == PSA_SUCCESS ||
+ forced_status == PSA_ERROR_NOT_SUPPORTED) {
+ PSA_ASSERT(status);
+ } else {
+ TEST_EQUAL(forced_status, status);
}
- mbedtls_free( actual_mac );
+ status = psa_mac_update(&operation,
+ input->x, input->len);
+ if (forced_status == PSA_SUCCESS) {
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 2);
+ } else {
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 1);
+ }
+ if (forced_status == PSA_SUCCESS ||
+ forced_status == PSA_ERROR_NOT_SUPPORTED) {
+ PSA_ASSERT(status);
+ } else {
+ TEST_EQUAL(PSA_ERROR_BAD_STATE, status);
+ }
+
+ status = psa_mac_sign_finish(&operation,
+ actual_mac, mac_buffer_size,
+ &mac_length);
+ if (forced_status == PSA_SUCCESS) {
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 4);
+ } else {
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 1);
+ }
+
+ if (forced_status == PSA_SUCCESS ||
+ forced_status == PSA_ERROR_NOT_SUPPORTED) {
+ PSA_ASSERT(status);
+ } else {
+ TEST_EQUAL(PSA_ERROR_BAD_STATE, status);
+ }
+
+ PSA_ASSERT(psa_mac_abort(&operation));
+ if (forced_status == PSA_SUCCESS) {
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 4);
+ } else {
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 1);
+ }
+
+ if (forced_status == PSA_SUCCESS) {
+ ASSERT_COMPARE(expected_mac->x, expected_mac->len,
+ actual_mac, mac_length);
+ }
+
+ mbedtls_free(actual_mac);
actual_mac = NULL;
exit:
- psa_mac_abort( &operation );
- psa_destroy_key( key );
- PSA_DONE( );
- mbedtls_free( actual_mac );
+ psa_mac_abort(&operation);
+ psa_destroy_key(key);
+ PSA_DONE();
+ mbedtls_free(actual_mac);
mbedtls_test_driver_mac_hooks = mbedtls_test_driver_mac_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void mac_verify( int key_type_arg,
- data_t *key_data,
- int alg_arg,
- data_t *input,
- data_t *expected_mac,
- int forced_status_arg )
+void mac_verify(int key_type_arg,
+ data_t *key_data,
+ int alg_arg,
+ data_t *input,
+ data_t *expected_mac,
+ int forced_status_arg)
{
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t key_type = key_type_arg;
@@ -1384,33 +1359,32 @@
psa_status_t forced_status = forced_status_arg;
mbedtls_test_driver_mac_hooks = mbedtls_test_driver_mac_hooks_init();
- TEST_ASSERT( expected_mac->len <= PSA_MAC_MAX_SIZE );
+ TEST_ASSERT(expected_mac->len <= PSA_MAC_MAX_SIZE);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, key_type );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, key_type);
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
mbedtls_test_driver_mac_hooks.forced_status = forced_status;
/*
* Verify the MAC, one-shot case.
*/
- status = psa_mac_verify( key, alg,
- input->x, input->len,
- expected_mac->x, expected_mac->len );
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 1 );
- if( forced_status == PSA_SUCCESS ||
- forced_status == PSA_ERROR_NOT_SUPPORTED )
- {
- PSA_ASSERT( status );
+ status = psa_mac_verify(key, alg,
+ input->x, input->len,
+ expected_mac->x, expected_mac->len);
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 1);
+ if (forced_status == PSA_SUCCESS ||
+ forced_status == PSA_ERROR_NOT_SUPPORTED) {
+ PSA_ASSERT(status);
+ } else {
+ TEST_EQUAL(forced_status, status);
}
- else
- TEST_EQUAL( forced_status, status );
mbedtls_test_driver_mac_hooks = mbedtls_test_driver_mac_hooks_init();
mbedtls_test_driver_mac_hooks.forced_status = forced_status;
@@ -1418,70 +1392,70 @@
/*
* Verify the MAC, multi-part case.
*/
- status = psa_mac_verify_setup( &operation, key, alg );
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 1 );
+ status = psa_mac_verify_setup(&operation, key, alg);
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 1);
- if( forced_status == PSA_SUCCESS ||
- forced_status == PSA_ERROR_NOT_SUPPORTED )
- {
- PSA_ASSERT( status );
+ if (forced_status == PSA_SUCCESS ||
+ forced_status == PSA_ERROR_NOT_SUPPORTED) {
+ PSA_ASSERT(status);
+ } else {
+ TEST_EQUAL(forced_status, status);
}
- else
- TEST_EQUAL( forced_status, status );
- status = psa_mac_update( &operation,
- input->x, input->len );
- if( forced_status == PSA_SUCCESS )
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 2 );
- else
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 1 );
-
- if( forced_status == PSA_SUCCESS ||
- forced_status == PSA_ERROR_NOT_SUPPORTED )
- {
- PSA_ASSERT( status );
+ status = psa_mac_update(&operation,
+ input->x, input->len);
+ if (forced_status == PSA_SUCCESS) {
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 2);
+ } else {
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 1);
}
- else
- TEST_EQUAL( PSA_ERROR_BAD_STATE, status );
- status = psa_mac_verify_finish( &operation,
- expected_mac->x,
- expected_mac->len );
- if( forced_status == PSA_SUCCESS )
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 4 );
- else
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 1 );
-
- if( forced_status == PSA_SUCCESS ||
- forced_status == PSA_ERROR_NOT_SUPPORTED )
- {
- PSA_ASSERT( status );
+ if (forced_status == PSA_SUCCESS ||
+ forced_status == PSA_ERROR_NOT_SUPPORTED) {
+ PSA_ASSERT(status);
+ } else {
+ TEST_EQUAL(PSA_ERROR_BAD_STATE, status);
}
- else
- TEST_EQUAL( PSA_ERROR_BAD_STATE, status );
+
+ status = psa_mac_verify_finish(&operation,
+ expected_mac->x,
+ expected_mac->len);
+ if (forced_status == PSA_SUCCESS) {
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 4);
+ } else {
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 1);
+ }
+
+ if (forced_status == PSA_SUCCESS ||
+ forced_status == PSA_ERROR_NOT_SUPPORTED) {
+ PSA_ASSERT(status);
+ } else {
+ TEST_EQUAL(PSA_ERROR_BAD_STATE, status);
+ }
- PSA_ASSERT( psa_mac_abort( &operation ) );
- if( forced_status == PSA_SUCCESS )
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 4 );
- else
- TEST_EQUAL( mbedtls_test_driver_mac_hooks.hits, 1 );
+ PSA_ASSERT(psa_mac_abort(&operation));
+ if (forced_status == PSA_SUCCESS) {
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 4);
+ } else {
+ TEST_EQUAL(mbedtls_test_driver_mac_hooks.hits, 1);
+ }
exit:
- psa_mac_abort( &operation );
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_mac_abort(&operation);
+ psa_destroy_key(key);
+ PSA_DONE();
mbedtls_test_driver_mac_hooks = mbedtls_test_driver_mac_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE depends_on:PSA_CRYPTO_DRIVER_TEST:MBEDTLS_PSA_CRYPTO_DRIVERS:MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS */
-void builtin_key_export( int builtin_key_id_arg,
- int builtin_key_type_arg,
- int builtin_key_bits_arg,
- int builtin_key_algorithm_arg,
- data_t *expected_output,
- int expected_status_arg )
+void builtin_key_export(int builtin_key_id_arg,
+ int builtin_key_type_arg,
+ int builtin_key_bits_arg,
+ int builtin_key_algorithm_arg,
+ data_t *expected_output,
+ int expected_status_arg)
{
psa_key_id_t builtin_key_id = (psa_key_id_t) builtin_key_id_arg;
psa_key_type_t builtin_key_type = (psa_key_type_t) builtin_key_type_arg;
@@ -1490,51 +1464,49 @@
psa_status_t expected_status = expected_status_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- mbedtls_svc_key_id_t key = mbedtls_svc_key_id_make( 0, builtin_key_id );
- uint8_t* output_buffer = NULL;
+ mbedtls_svc_key_id_t key = mbedtls_svc_key_id_make(0, builtin_key_id);
+ uint8_t *output_buffer = NULL;
size_t output_size = 0;
psa_status_t actual_status;
- PSA_ASSERT( psa_crypto_init( ) );
- ASSERT_ALLOC( output_buffer, expected_output->len );
+ PSA_ASSERT(psa_crypto_init());
+ ASSERT_ALLOC(output_buffer, expected_output->len);
- actual_status = psa_export_key( key, output_buffer, expected_output->len, &output_size );
+ actual_status = psa_export_key(key, output_buffer, expected_output->len, &output_size);
- if( expected_status == PSA_SUCCESS )
- {
- PSA_ASSERT( actual_status );
- TEST_EQUAL( output_size, expected_output->len );
- ASSERT_COMPARE( output_buffer, output_size,
- expected_output->x, expected_output->len );
+ if (expected_status == PSA_SUCCESS) {
+ PSA_ASSERT(actual_status);
+ TEST_EQUAL(output_size, expected_output->len);
+ ASSERT_COMPARE(output_buffer, output_size,
+ expected_output->x, expected_output->len);
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- TEST_EQUAL( psa_get_key_bits( &attributes ), builtin_key_bits );
- TEST_EQUAL( psa_get_key_type( &attributes ), builtin_key_type );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ), builtin_key_alg );
- }
- else
- {
- if( actual_status != expected_status )
- fprintf( stderr, "Expected %d but got %d\n", expected_status, actual_status );
- TEST_EQUAL( actual_status, expected_status );
- TEST_EQUAL( output_size, 0 );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ TEST_EQUAL(psa_get_key_bits(&attributes), builtin_key_bits);
+ TEST_EQUAL(psa_get_key_type(&attributes), builtin_key_type);
+ TEST_EQUAL(psa_get_key_algorithm(&attributes), builtin_key_alg);
+ } else {
+ if (actual_status != expected_status) {
+ fprintf(stderr, "Expected %d but got %d\n", expected_status, actual_status);
+ }
+ TEST_EQUAL(actual_status, expected_status);
+ TEST_EQUAL(output_size, 0);
}
exit:
- mbedtls_free( output_buffer );
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- PSA_DONE( );
+ mbedtls_free(output_buffer);
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:PSA_CRYPTO_DRIVER_TEST:MBEDTLS_PSA_CRYPTO_DRIVERS:MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS */
-void builtin_pubkey_export( int builtin_key_id_arg,
- int builtin_key_type_arg,
- int builtin_key_bits_arg,
- int builtin_key_algorithm_arg,
- data_t *expected_output,
- int expected_status_arg )
+void builtin_pubkey_export(int builtin_key_id_arg,
+ int builtin_key_type_arg,
+ int builtin_key_bits_arg,
+ int builtin_key_algorithm_arg,
+ data_t *expected_output,
+ int expected_status_arg)
{
psa_key_id_t builtin_key_id = (psa_key_id_t) builtin_key_id_arg;
psa_key_type_t builtin_key_type = (psa_key_type_t) builtin_key_type_arg;
@@ -1543,47 +1515,44 @@
psa_status_t expected_status = expected_status_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- mbedtls_svc_key_id_t key = mbedtls_svc_key_id_make( 0, builtin_key_id );
- uint8_t* output_buffer = NULL;
+ mbedtls_svc_key_id_t key = mbedtls_svc_key_id_make(0, builtin_key_id);
+ uint8_t *output_buffer = NULL;
size_t output_size = 0;
psa_status_t actual_status;
- PSA_ASSERT( psa_crypto_init( ) );
- ASSERT_ALLOC( output_buffer, expected_output->len );
+ PSA_ASSERT(psa_crypto_init());
+ ASSERT_ALLOC(output_buffer, expected_output->len);
- actual_status = psa_export_public_key( key, output_buffer, expected_output->len, &output_size );
+ actual_status = psa_export_public_key(key, output_buffer, expected_output->len, &output_size);
- if( expected_status == PSA_SUCCESS )
- {
- PSA_ASSERT( actual_status );
- TEST_EQUAL( output_size, expected_output->len );
- ASSERT_COMPARE( output_buffer, output_size,
- expected_output->x, expected_output->len );
+ if (expected_status == PSA_SUCCESS) {
+ PSA_ASSERT(actual_status);
+ TEST_EQUAL(output_size, expected_output->len);
+ ASSERT_COMPARE(output_buffer, output_size,
+ expected_output->x, expected_output->len);
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- TEST_EQUAL( psa_get_key_bits( &attributes ), builtin_key_bits );
- TEST_EQUAL( psa_get_key_type( &attributes ), builtin_key_type );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ), builtin_key_alg );
- }
- else
- {
- TEST_EQUAL( actual_status, expected_status );
- TEST_EQUAL( output_size, 0 );
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ TEST_EQUAL(psa_get_key_bits(&attributes), builtin_key_bits);
+ TEST_EQUAL(psa_get_key_type(&attributes), builtin_key_type);
+ TEST_EQUAL(psa_get_key_algorithm(&attributes), builtin_key_alg);
+ } else {
+ TEST_EQUAL(actual_status, expected_status);
+ TEST_EQUAL(output_size, 0);
}
exit:
- mbedtls_free( output_buffer );
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key );
- PSA_DONE( );
+ mbedtls_free(output_buffer);
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void hash_compute( int alg_arg,
- data_t *input, data_t *hash,
- int forced_status_arg,
- int expected_status_arg )
+void hash_compute(int alg_arg,
+ data_t *input, data_t *hash,
+ int forced_status_arg,
+ int expected_status_arg)
{
psa_algorithm_t alg = alg_arg;
psa_status_t forced_status = forced_status_arg;
@@ -1594,79 +1563,77 @@
mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
mbedtls_test_driver_hash_hooks.forced_status = forced_status;
- PSA_ASSERT( psa_crypto_init( ) );
- ASSERT_ALLOC( output, PSA_HASH_LENGTH( alg ) );
+ PSA_ASSERT(psa_crypto_init());
+ ASSERT_ALLOC(output, PSA_HASH_LENGTH(alg));
- TEST_EQUAL( psa_hash_compute( alg, input->x, input->len,
- output, PSA_HASH_LENGTH( alg ),
- &output_length ), expected_status );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 1 );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
+ TEST_EQUAL(psa_hash_compute(alg, input->x, input->len,
+ output, PSA_HASH_LENGTH(alg),
+ &output_length), expected_status);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits, 1);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.driver_status, forced_status);
- if( expected_status == PSA_SUCCESS )
- {
- ASSERT_COMPARE( output, output_length, hash->x, hash->len );
+ if (expected_status == PSA_SUCCESS) {
+ ASSERT_COMPARE(output, output_length, hash->x, hash->len);
}
exit:
- mbedtls_free( output );
- PSA_DONE( );
+ mbedtls_free(output);
+ PSA_DONE();
mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void hash_multipart_setup( int alg_arg,
+void hash_multipart_setup(int alg_arg,
+ data_t *input, data_t *hash,
+ int forced_status_arg,
+ int expected_status_arg)
+{
+ psa_algorithm_t alg = alg_arg;
+ psa_status_t forced_status = forced_status_arg;
+ psa_status_t expected_status = expected_status_arg;
+ unsigned char *output = NULL;
+ psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
+ size_t output_length;
+
+ mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
+ ASSERT_ALLOC(output, PSA_HASH_LENGTH(alg));
+
+ PSA_ASSERT(psa_crypto_init());
+
+ mbedtls_test_driver_hash_hooks.forced_status = forced_status;
+ TEST_EQUAL(psa_hash_setup(&operation, alg), expected_status);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits, 1);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.driver_status, forced_status);
+
+ if (expected_status == PSA_SUCCESS) {
+ PSA_ASSERT(psa_hash_update(&operation, input->x, input->len));
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits,
+ forced_status == PSA_ERROR_NOT_SUPPORTED ? 1 : 2);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.driver_status, forced_status);
+
+ PSA_ASSERT(psa_hash_finish(&operation,
+ output, PSA_HASH_LENGTH(alg),
+ &output_length));
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits,
+ forced_status == PSA_ERROR_NOT_SUPPORTED ? 1 : 4);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.driver_status, forced_status);
+
+ ASSERT_COMPARE(output, output_length, hash->x, hash->len);
+ }
+
+exit:
+ psa_hash_abort(&operation);
+ mbedtls_free(output);
+ PSA_DONE();
+ mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
+}
+/* END_CASE */
+
+/* BEGIN_CASE */
+void hash_multipart_update(int alg_arg,
data_t *input, data_t *hash,
- int forced_status_arg,
- int expected_status_arg )
-{
- psa_algorithm_t alg = alg_arg;
- psa_status_t forced_status = forced_status_arg;
- psa_status_t expected_status = expected_status_arg;
- unsigned char *output = NULL;
- psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
- size_t output_length;
-
- mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
- ASSERT_ALLOC( output, PSA_HASH_LENGTH( alg ) );
-
- PSA_ASSERT( psa_crypto_init( ) );
-
- mbedtls_test_driver_hash_hooks.forced_status = forced_status;
- TEST_EQUAL( psa_hash_setup( &operation, alg ), expected_status );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 1 );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
-
- if( expected_status == PSA_SUCCESS )
- {
- PSA_ASSERT( psa_hash_update( &operation, input->x, input->len ) );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits,
- forced_status == PSA_ERROR_NOT_SUPPORTED ? 1 : 2 );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
-
- PSA_ASSERT( psa_hash_finish( &operation,
- output, PSA_HASH_LENGTH( alg ),
- &output_length ) );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits,
- forced_status == PSA_ERROR_NOT_SUPPORTED ? 1 : 4 );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
-
- ASSERT_COMPARE( output, output_length, hash->x, hash->len );
- }
-
-exit:
- psa_hash_abort( &operation );
- mbedtls_free( output );
- PSA_DONE( );
- mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
-}
-/* END_CASE */
-
-/* BEGIN_CASE */
-void hash_multipart_update( int alg_arg,
- data_t *input, data_t *hash,
- int forced_status_arg )
+ int forced_status_arg)
{
psa_algorithm_t alg = alg_arg;
psa_status_t forced_status = forced_status_arg;
@@ -1675,54 +1642,53 @@
size_t output_length;
mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
- ASSERT_ALLOC( output, PSA_HASH_LENGTH( alg ) );
+ ASSERT_ALLOC(output, PSA_HASH_LENGTH(alg));
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/*
* Update inactive operation, the driver shouldn't be called.
*/
- TEST_EQUAL( psa_hash_update( &operation, input->x, input->len ),
- PSA_ERROR_BAD_STATE );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 0 );
+ TEST_EQUAL(psa_hash_update(&operation, input->x, input->len),
+ PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits, 0);
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 1 );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits, 1);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS);
mbedtls_test_driver_hash_hooks.forced_status = forced_status;
- TEST_EQUAL( psa_hash_update( &operation, input->x, input->len ),
- forced_status );
+ TEST_EQUAL(psa_hash_update(&operation, input->x, input->len),
+ forced_status);
/* One or two more calls to the driver interface: update or update + abort */
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits,
- forced_status == PSA_SUCCESS ? 2 : 3 );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits,
+ forced_status == PSA_SUCCESS ? 2 : 3);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.driver_status, forced_status);
- if( forced_status == PSA_SUCCESS )
- {
+ if (forced_status == PSA_SUCCESS) {
mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
- PSA_ASSERT( psa_hash_finish( &operation,
- output, PSA_HASH_LENGTH( alg ),
- &output_length ) );
+ PSA_ASSERT(psa_hash_finish(&operation,
+ output, PSA_HASH_LENGTH(alg),
+ &output_length));
/* Two calls to the driver interface: update + abort */
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 2 );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS );
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits, 2);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS);
- ASSERT_COMPARE( output, output_length, hash->x, hash->len );
+ ASSERT_COMPARE(output, output_length, hash->x, hash->len);
}
exit:
- psa_hash_abort( &operation );
- mbedtls_free( output );
- PSA_DONE( );
+ psa_hash_abort(&operation);
+ mbedtls_free(output);
+ PSA_DONE();
mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void hash_multipart_finish( int alg_arg,
- data_t *input, data_t *hash,
- int forced_status_arg )
+void hash_multipart_finish(int alg_arg,
+ data_t *input, data_t *hash,
+ int forced_status_arg)
{
psa_algorithm_t alg = alg_arg;
psa_status_t forced_status = forced_status_arg;
@@ -1731,50 +1697,51 @@
size_t output_length;
mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
- ASSERT_ALLOC( output, PSA_HASH_LENGTH( alg ) );
+ ASSERT_ALLOC(output, PSA_HASH_LENGTH(alg));
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/*
* Finish inactive operation, the driver shouldn't be called.
*/
- TEST_EQUAL( psa_hash_finish( &operation, output, PSA_HASH_LENGTH( alg ),
- &output_length ),
- PSA_ERROR_BAD_STATE );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 0 );
+ TEST_EQUAL(psa_hash_finish(&operation, output, PSA_HASH_LENGTH(alg),
+ &output_length),
+ PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits, 0);
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 1 );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits, 1);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS);
- PSA_ASSERT( psa_hash_update( &operation, input->x, input->len ) );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 2 );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS );
+ PSA_ASSERT(psa_hash_update(&operation, input->x, input->len));
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits, 2);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS);
mbedtls_test_driver_hash_hooks.forced_status = forced_status;
- TEST_EQUAL( psa_hash_finish( &operation,
- output, PSA_HASH_LENGTH( alg ),
- &output_length ),
- forced_status );
+ TEST_EQUAL(psa_hash_finish(&operation,
+ output, PSA_HASH_LENGTH(alg),
+ &output_length),
+ forced_status);
/* Two more calls to the driver interface: finish + abort */
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 4 );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits, 4);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.driver_status, forced_status);
- if( forced_status == PSA_SUCCESS )
- ASSERT_COMPARE( output, output_length, hash->x, hash->len );
+ if (forced_status == PSA_SUCCESS) {
+ ASSERT_COMPARE(output, output_length, hash->x, hash->len);
+ }
exit:
- psa_hash_abort( &operation );
- mbedtls_free( output );
- PSA_DONE( );
+ psa_hash_abort(&operation);
+ mbedtls_free(output);
+ PSA_DONE();
mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
}
/* END_CASE */
/* BEGIN_CASE */
-void hash_clone( int alg_arg,
- data_t *input, data_t *hash,
- int forced_status_arg )
+void hash_clone(int alg_arg,
+ data_t *input, data_t *hash,
+ int forced_status_arg)
{
psa_algorithm_t alg = alg_arg;
psa_status_t forced_status = forced_status_arg;
@@ -1784,50 +1751,49 @@
size_t output_length;
mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
- ASSERT_ALLOC( output, PSA_HASH_LENGTH( alg ) );
+ ASSERT_ALLOC(output, PSA_HASH_LENGTH(alg));
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/*
* Clone inactive operation, the driver shouldn't be called.
*/
- TEST_EQUAL( psa_hash_clone( &source_operation, &target_operation ),
- PSA_ERROR_BAD_STATE );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 0 );
+ TEST_EQUAL(psa_hash_clone(&source_operation, &target_operation),
+ PSA_ERROR_BAD_STATE);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits, 0);
- PSA_ASSERT( psa_hash_setup( &source_operation, alg ) );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 1 );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS );
+ PSA_ASSERT(psa_hash_setup(&source_operation, alg));
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits, 1);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS);
mbedtls_test_driver_hash_hooks.forced_status = forced_status;
- TEST_EQUAL( psa_hash_clone( &source_operation, &target_operation ),
- forced_status );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits,
- forced_status == PSA_SUCCESS ? 2 : 3 );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, forced_status );
+ TEST_EQUAL(psa_hash_clone(&source_operation, &target_operation),
+ forced_status);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits,
+ forced_status == PSA_SUCCESS ? 2 : 3);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.driver_status, forced_status);
- if( forced_status == PSA_SUCCESS )
- {
+ if (forced_status == PSA_SUCCESS) {
mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
- PSA_ASSERT( psa_hash_update( &target_operation,
- input->x, input->len ) );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 1 );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS );
+ PSA_ASSERT(psa_hash_update(&target_operation,
+ input->x, input->len));
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits, 1);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS);
- PSA_ASSERT( psa_hash_finish( &target_operation,
- output, PSA_HASH_LENGTH( alg ),
- &output_length ) );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.hits, 3 );
- TEST_EQUAL( mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS );
+ PSA_ASSERT(psa_hash_finish(&target_operation,
+ output, PSA_HASH_LENGTH(alg),
+ &output_length));
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.hits, 3);
+ TEST_EQUAL(mbedtls_test_driver_hash_hooks.driver_status, PSA_SUCCESS);
- ASSERT_COMPARE( output, output_length, hash->x, hash->len );
+ ASSERT_COMPARE(output, output_length, hash->x, hash->len);
}
exit:
- psa_hash_abort( &source_operation );
- psa_hash_abort( &target_operation );
- mbedtls_free( output );
- PSA_DONE( );
+ psa_hash_abort(&source_operation);
+ psa_hash_abort(&target_operation);
+ mbedtls_free(output);
+ PSA_DONE();
mbedtls_test_driver_hash_hooks = mbedtls_test_driver_hash_hooks_init();
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto_entropy.function b/tests/suites/test_suite_psa_crypto_entropy.function
index 4dcbb36..26ce0d3 100644
--- a/tests/suites/test_suite_psa_crypto_entropy.function
+++ b/tests/suites/test_suite_psa_crypto_entropy.function
@@ -8,7 +8,8 @@
#include "mbedtls/entropy_poll.h"
/* Calculating the minimum allowed entropy size in bytes */
-#define MBEDTLS_PSA_INJECT_ENTROPY_MIN_SIZE MAX(MBEDTLS_ENTROPY_MIN_PLATFORM, MBEDTLS_ENTROPY_BLOCK_SIZE)
+#define MBEDTLS_PSA_INJECT_ENTROPY_MIN_SIZE MAX(MBEDTLS_ENTROPY_MIN_PLATFORM, \
+ MBEDTLS_ENTROPY_BLOCK_SIZE)
#if defined(MBEDTLS_PSA_INJECT_ENTROPY)
@@ -22,15 +23,16 @@
* to do this (it would be a security risk if such a function was ever
* accessible in production), implement this functionality in a white-box
* manner. */
-psa_status_t remove_seed_file( void )
+psa_status_t remove_seed_file(void)
{
#if defined(MBEDTLS_PSA_ITS_FILE_C)
- if( remove( "00000000ffffff52.psa_its" ) == 0 )
- return( PSA_SUCCESS );
- else
- return( PSA_ERROR_DOES_NOT_EXIST );
+ if (remove("00000000ffffff52.psa_its") == 0) {
+ return PSA_SUCCESS;
+ } else {
+ return PSA_ERROR_DOES_NOT_EXIST;
+ }
#else
- return( psa_its_remove( PSA_CRYPTO_ITS_RANDOM_SEED_UID ) );
+ return psa_its_remove(PSA_CRYPTO_ITS_RANDOM_SEED_UID);
#endif
}
@@ -39,44 +41,44 @@
/* END_HEADER */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */
-void external_rng_failure_generate( )
+void external_rng_failure_generate()
{
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- psa_set_key_type( &attributes, PSA_KEY_TYPE_DERIVE );
- psa_set_key_bits( &attributes, 128 );
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_DERIVE);
+ psa_set_key_bits(&attributes, 128);
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
uint8_t output[1];
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- PSA_ASSERT( psa_generate_random( output, sizeof( output ) ) );
- PSA_ASSERT( psa_generate_key( &attributes, &key ) );
- PSA_ASSERT( psa_destroy_key( key ) );
+ PSA_ASSERT(psa_generate_random(output, sizeof(output)));
+ PSA_ASSERT(psa_generate_key(&attributes, &key));
+ PSA_ASSERT(psa_destroy_key(key));
- mbedtls_test_disable_insecure_external_rng( );
- TEST_EQUAL( PSA_ERROR_INSUFFICIENT_ENTROPY,
- psa_generate_random( output, sizeof( output ) ) );
- TEST_EQUAL( PSA_ERROR_INSUFFICIENT_ENTROPY,
- psa_generate_key( &attributes, &key ) );
+ mbedtls_test_disable_insecure_external_rng();
+ TEST_EQUAL(PSA_ERROR_INSUFFICIENT_ENTROPY,
+ psa_generate_random(output, sizeof(output)));
+ TEST_EQUAL(PSA_ERROR_INSUFFICIENT_ENTROPY,
+ psa_generate_key(&attributes, &key));
exit:
- psa_destroy_key( key );
- PSA_DONE( );
+ psa_destroy_key(key);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */
-void external_rng_failure_sign( int key_type, data_t *key_data, int alg,
- int input_size_arg )
+void external_rng_failure_sign(int key_type, data_t *key_data, int alg,
+ int input_size_arg)
{
/* This test case is only expected to pass if the signature mechanism
* requires randomness, either because it is a randomized signature
* or because the implementation uses blinding. */
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- psa_set_key_type( &attributes, key_type );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
- psa_set_key_algorithm( &attributes, alg );
+ psa_set_key_type(&attributes, key_type);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH);
+ psa_set_key_algorithm(&attributes, alg);
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
size_t input_size = input_size_arg;
uint8_t *input = NULL;
@@ -84,43 +86,43 @@
size_t signature_size = PSA_SIGNATURE_MAX_SIZE;
size_t signature_length;
- ASSERT_ALLOC( input, input_size );
- ASSERT_ALLOC( signature, signature_size );
+ ASSERT_ALLOC(input, input_size);
+ ASSERT_ALLOC(signature, signature_size);
- PSA_ASSERT( psa_crypto_init( ) );
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
- PSA_ASSERT( psa_sign_hash( key, alg,
- input, input_size,
- signature, signature_size,
- &signature_length ) );
- PSA_ASSERT( psa_destroy_key( key ) );
+ PSA_ASSERT(psa_crypto_init());
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+ PSA_ASSERT(psa_sign_hash(key, alg,
+ input, input_size,
+ signature, signature_size,
+ &signature_length));
+ PSA_ASSERT(psa_destroy_key(key));
- mbedtls_test_disable_insecure_external_rng( );
+ mbedtls_test_disable_insecure_external_rng();
/* Import the key again, because for RSA Mbed TLS caches blinding values
* in the key object and this could perturb the test. */
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
- TEST_EQUAL( PSA_ERROR_INSUFFICIENT_ENTROPY,
- psa_sign_hash( key, alg,
- input, input_size,
- signature, signature_size,
- &signature_length ) );
- PSA_ASSERT( psa_destroy_key( key ) );
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+ TEST_EQUAL(PSA_ERROR_INSUFFICIENT_ENTROPY,
+ psa_sign_hash(key, alg,
+ input, input_size,
+ signature, signature_size,
+ &signature_length));
+ PSA_ASSERT(psa_destroy_key(key));
exit:
- psa_destroy_key( key );
- PSA_DONE( );
- mbedtls_free( input );
- mbedtls_free( signature );
+ psa_destroy_key(key);
+ PSA_DONE();
+ mbedtls_free(input);
+ mbedtls_free(signature);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_INJECT_ENTROPY */
-void validate_entropy_seed_injection( int seed_length_a,
- int expected_status_a,
- int seed_length_b,
- int expected_status_b )
+void validate_entropy_seed_injection(int seed_length_a,
+ int expected_status_a,
+ int seed_length_b,
+ int expected_status_b)
{
psa_status_t status;
uint8_t output[32] = { 0 };
@@ -128,68 +130,63 @@
uint8_t *seed = NULL;
int i;
int seed_size;
- if( seed_length_a > seed_length_b )
- {
+ if (seed_length_a > seed_length_b) {
seed_size = seed_length_a;
- }
- else
- {
+ } else {
seed_size = seed_length_b;
}
- ASSERT_ALLOC( seed, seed_size );
+ ASSERT_ALLOC(seed, seed_size);
/* fill seed with some data */
- for( i = 0; i < seed_size; ++i )
- {
+ for (i = 0; i < seed_size; ++i) {
seed[i] = i;
}
- status = remove_seed_file( );
- TEST_ASSERT( ( status == PSA_SUCCESS ) ||
- ( status == PSA_ERROR_DOES_NOT_EXIST ) );
- status = mbedtls_psa_inject_entropy( seed, seed_length_a );
- TEST_EQUAL( status, expected_status_a );
- status = mbedtls_psa_inject_entropy( seed, seed_length_b );
- TEST_EQUAL( status, expected_status_b );
- PSA_ASSERT( psa_crypto_init( ) );
- PSA_ASSERT( psa_generate_random( output,
- sizeof( output ) ) );
- TEST_ASSERT( memcmp( output, zeros, sizeof( output ) ) != 0 );
+ status = remove_seed_file();
+ TEST_ASSERT((status == PSA_SUCCESS) ||
+ (status == PSA_ERROR_DOES_NOT_EXIST));
+ status = mbedtls_psa_inject_entropy(seed, seed_length_a);
+ TEST_EQUAL(status, expected_status_a);
+ status = mbedtls_psa_inject_entropy(seed, seed_length_b);
+ TEST_EQUAL(status, expected_status_b);
+ PSA_ASSERT(psa_crypto_init());
+ PSA_ASSERT(psa_generate_random(output,
+ sizeof(output)));
+ TEST_ASSERT(memcmp(output, zeros, sizeof(output)) != 0);
exit:
- mbedtls_free( seed );
- remove_seed_file( );
- PSA_DONE( );
+ mbedtls_free(seed);
+ remove_seed_file();
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_INJECT_ENTROPY */
-void run_entropy_inject_with_crypto_init( )
+void run_entropy_inject_with_crypto_init()
{
psa_status_t status;
size_t i;
uint8_t seed[MBEDTLS_PSA_INJECT_ENTROPY_MIN_SIZE] = { 0 };
/* fill seed with some data */
- for( i = 0; i < sizeof( seed ); ++i )
- {
+ for (i = 0; i < sizeof(seed); ++i) {
seed[i] = i;
}
- status = remove_seed_file( );
- TEST_ASSERT( ( status == PSA_SUCCESS ) ||
- ( status == PSA_ERROR_DOES_NOT_EXIST ) );
- status = mbedtls_psa_inject_entropy( seed, sizeof( seed ) );
- PSA_ASSERT( status );
- status = remove_seed_file( );
- TEST_EQUAL( status, PSA_SUCCESS );
- status = psa_crypto_init( );
- TEST_EQUAL( status, PSA_ERROR_INSUFFICIENT_ENTROPY );
- status = mbedtls_psa_inject_entropy( seed, sizeof( seed ) );
- PSA_ASSERT( status );
- status = psa_crypto_init( );
- PSA_ASSERT( status );
- PSA_DONE( );
+ status = remove_seed_file();
+ TEST_ASSERT((status == PSA_SUCCESS) ||
+ (status == PSA_ERROR_DOES_NOT_EXIST));
+ status = mbedtls_psa_inject_entropy(seed, sizeof(seed));
+ PSA_ASSERT(status);
+ status = remove_seed_file();
+ TEST_EQUAL(status, PSA_SUCCESS);
+ status = psa_crypto_init();
+ TEST_EQUAL(status, PSA_ERROR_INSUFFICIENT_ENTROPY);
+ status = mbedtls_psa_inject_entropy(seed, sizeof(seed));
+ PSA_ASSERT(status);
+ status = psa_crypto_init();
+ PSA_ASSERT(status);
+ PSA_DONE();
/* The seed is written by nv_seed callback functions therefore the injection will fail */
- status = mbedtls_psa_inject_entropy( seed, sizeof( seed ) );
- TEST_EQUAL( status, PSA_ERROR_NOT_PERMITTED );
+ status = mbedtls_psa_inject_entropy(seed, sizeof(seed));
+ TEST_EQUAL(status, PSA_ERROR_NOT_PERMITTED);
exit:
- remove_seed_file( );
- PSA_DONE( );
+ remove_seed_file();
+ PSA_DONE();
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto_generate_key.function b/tests/suites/test_suite_psa_crypto_generate_key.function
index 6dc6043..366e09b 100644
--- a/tests/suites/test_suite_psa_crypto_generate_key.function
+++ b/tests/suites/test_suite_psa_crypto_generate_key.function
@@ -3,7 +3,7 @@
#include "psa/crypto.h"
#include "test/psa_crypto_helpers.h"
-#define INVALID_KEY_ID mbedtls_svc_key_id_make( 0, 0xfedcba98 )
+#define INVALID_KEY_ID mbedtls_svc_key_id_make(0, 0xfedcba98)
/* END_HEADER */
@@ -13,7 +13,7 @@
*/
/* BEGIN_CASE */
-void generate_key( int key_type_arg, int bits_arg, int expected_status_arg)
+void generate_key(int key_type_arg, int bits_arg, int expected_status_arg)
{
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_svc_key_id_t key_id = INVALID_KEY_ID;
@@ -23,27 +23,26 @@
size_t bits = bits_arg;
psa_status_t expected_status = expected_status_arg;
- PSA_ASSERT( psa_crypto_init( ) );
- psa_set_key_type( &attributes, key_type );
- psa_set_key_bits( &attributes, bits );
- TEST_EQUAL( psa_generate_key( &attributes, &key_id ),
- expected_status );
+ PSA_ASSERT(psa_crypto_init());
+ psa_set_key_type(&attributes, key_type);
+ psa_set_key_bits(&attributes, bits);
+ TEST_EQUAL(psa_generate_key(&attributes, &key_id),
+ expected_status);
// Verify attributes of the created key on success
- if ( expected_status == PSA_SUCCESS )
- {
+ if (expected_status == PSA_SUCCESS) {
psa_reset_key_attributes(&attributes);
- PSA_ASSERT( psa_get_key_attributes( key_id, &attributes ) );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ), PSA_KEY_LIFETIME_VOLATILE );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_type( &attributes ), key_type );
- TEST_EQUAL( psa_get_key_bits( &attributes ), bits );
+ PSA_ASSERT(psa_get_key_attributes(key_id, &attributes));
+ TEST_EQUAL(psa_get_key_lifetime(&attributes), PSA_KEY_LIFETIME_VOLATILE);
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes), 0);
+ TEST_EQUAL(psa_get_key_algorithm(&attributes), 0);
+ TEST_EQUAL(psa_get_key_type(&attributes), key_type);
+ TEST_EQUAL(psa_get_key_bits(&attributes), bits);
}
exit:
psa_reset_key_attributes(&attributes);
- psa_destroy_key( key_id );
- PSA_DONE( );
+ psa_destroy_key(key_id);
+ PSA_DONE();
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto_hash.function b/tests/suites/test_suite_psa_crypto_hash.function
index b0da2bf..f12541d 100644
--- a/tests/suites/test_suite_psa_crypto_hash.function
+++ b/tests/suites/test_suite_psa_crypto_hash.function
@@ -10,54 +10,54 @@
*/
/* BEGIN_CASE */
-void hash_finish( int alg_arg, data_t *input, data_t *expected_hash )
+void hash_finish(int alg_arg, data_t *input, data_t *expected_hash)
{
psa_algorithm_t alg = alg_arg;
unsigned char actual_hash[PSA_HASH_MAX_SIZE];
size_t actual_hash_length;
psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
- PSA_ASSERT( psa_hash_update( &operation,
- input->x, input->len ) );
- PSA_ASSERT( psa_hash_finish( &operation,
- actual_hash, sizeof( actual_hash ),
- &actual_hash_length ) );
- ASSERT_COMPARE( expected_hash->x, expected_hash->len,
- actual_hash, actual_hash_length );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
+ PSA_ASSERT(psa_hash_update(&operation,
+ input->x, input->len));
+ PSA_ASSERT(psa_hash_finish(&operation,
+ actual_hash, sizeof(actual_hash),
+ &actual_hash_length));
+ ASSERT_COMPARE(expected_hash->x, expected_hash->len,
+ actual_hash, actual_hash_length);
exit:
- psa_hash_abort( &operation );
- PSA_DONE( );
+ psa_hash_abort(&operation);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void hash_verify( int alg_arg, data_t *input, data_t *expected_hash )
+void hash_verify(int alg_arg, data_t *input, data_t *expected_hash)
{
psa_algorithm_t alg = alg_arg;
psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
- PSA_ASSERT( psa_hash_update( &operation,
- input->x,
- input->len ) );
- PSA_ASSERT( psa_hash_verify( &operation,
- expected_hash->x,
- expected_hash->len ) );
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
+ PSA_ASSERT(psa_hash_update(&operation,
+ input->x,
+ input->len));
+ PSA_ASSERT(psa_hash_verify(&operation,
+ expected_hash->x,
+ expected_hash->len));
exit:
- psa_hash_abort( &operation );
- PSA_DONE( );
+ psa_hash_abort(&operation);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void hash_multi_part( int alg_arg, data_t *input, data_t *expected_hash )
+void hash_multi_part(int alg_arg, data_t *input, data_t *expected_hash)
{
psa_algorithm_t alg = alg_arg;
unsigned char actual_hash[PSA_HASH_MAX_SIZE];
@@ -66,37 +66,36 @@
psa_hash_operation_t operation2 = PSA_HASH_OPERATION_INIT;
uint32_t len = 0;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- do
- {
- memset( actual_hash, 0, sizeof( actual_hash ) );
- PSA_ASSERT( psa_hash_setup( &operation, alg ) );
+ do {
+ memset(actual_hash, 0, sizeof(actual_hash));
+ PSA_ASSERT(psa_hash_setup(&operation, alg));
- PSA_ASSERT( psa_hash_update( &operation,
- input->x, len ) );
- PSA_ASSERT( psa_hash_clone( &operation, &operation2 ) );
- PSA_ASSERT( psa_hash_update( &operation,
- input->x + len, input->len - len ) );
- PSA_ASSERT( psa_hash_update( &operation2,
- input->x + len, input->len - len ) );
+ PSA_ASSERT(psa_hash_update(&operation,
+ input->x, len));
+ PSA_ASSERT(psa_hash_clone(&operation, &operation2));
+ PSA_ASSERT(psa_hash_update(&operation,
+ input->x + len, input->len - len));
+ PSA_ASSERT(psa_hash_update(&operation2,
+ input->x + len, input->len - len));
- PSA_ASSERT( psa_hash_finish( &operation,
- actual_hash, sizeof( actual_hash ),
- &actual_hash_length ) );
- ASSERT_COMPARE( expected_hash->x, expected_hash->len,
- actual_hash, actual_hash_length );
+ PSA_ASSERT(psa_hash_finish(&operation,
+ actual_hash, sizeof(actual_hash),
+ &actual_hash_length));
+ ASSERT_COMPARE(expected_hash->x, expected_hash->len,
+ actual_hash, actual_hash_length);
- PSA_ASSERT( psa_hash_finish( &operation2,
- actual_hash, sizeof( actual_hash ),
- &actual_hash_length ) );
- ASSERT_COMPARE( expected_hash->x, expected_hash->len,
- actual_hash, actual_hash_length );
- } while( len++ != input->len );
+ PSA_ASSERT(psa_hash_finish(&operation2,
+ actual_hash, sizeof(actual_hash),
+ &actual_hash_length));
+ ASSERT_COMPARE(expected_hash->x, expected_hash->len,
+ actual_hash, actual_hash_length);
+ } while (len++ != input->len);
exit:
- psa_hash_abort( &operation );
- psa_hash_abort( &operation2 );
- PSA_DONE( );
+ psa_hash_abort(&operation);
+ psa_hash_abort(&operation2);
+ PSA_DONE();
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto_init.function b/tests/suites/test_suite_psa_crypto_init.function
index 40efb87..7345ad1 100644
--- a/tests/suites/test_suite_psa_crypto_init.function
+++ b/tests/suites/test_suite_psa_crypto_init.function
@@ -17,7 +17,7 @@
* half the entropy length. For SHA-256, SHA-384 or SHA-512, the
* entropy length is 256 per the documentation of mbedtls_hmac_drbg_seed(),
* and PSA crypto doesn't support other hashes for HMAC_DRBG. */
-#define ENTROPY_NONCE_LEN ( 256 / 2 )
+#define ENTROPY_NONCE_LEN (256 / 2)
#else
/* PSA crypto uses the CTR_DRBG module. In some configurations, it needs
* to read from the entropy source twice: once for the initial entropy
@@ -28,28 +28,29 @@
#if !defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)
-typedef struct
-{
+typedef struct {
size_t threshold; /* Minimum bytes to make mbedtls_entropy_func happy */
size_t max_steps;
size_t *length_sequence;
size_t step;
} fake_entropy_state_t;
-static int fake_entropy_source( void *state_arg,
- unsigned char *output, size_t len,
- size_t *olen )
+static int fake_entropy_source(void *state_arg,
+ unsigned char *output, size_t len,
+ size_t *olen)
{
fake_entropy_state_t *state = state_arg;
size_t i;
- if( state->step >= state->max_steps )
- return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
+ if (state->step >= state->max_steps) {
+ return MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
+ }
- *olen = MIN( len, state->length_sequence[state->step] );
- for( i = 0; i < *olen; i++ )
+ *olen = MIN(len, state->length_sequence[state->step]);
+ for (i = 0; i < *olen; i++) {
output[i] = i;
+ }
++state->step;
- return( 0 );
+ return 0;
}
#define ENTROPY_SOURCE_PLATFORM 0x00000001
@@ -64,69 +65,71 @@
/* This is a modified version of mbedtls_entropy_init() from entropy.c
* which chooses entropy sources dynamically. */
-static void custom_entropy_init( mbedtls_entropy_context *ctx )
+static void custom_entropy_init(mbedtls_entropy_context *ctx)
{
ctx->source_count = 0;
- memset( ctx->source, 0, sizeof( ctx->source ) );
+ memset(ctx->source, 0, sizeof(ctx->source));
#if defined(MBEDTLS_THREADING_C)
- mbedtls_mutex_init( &ctx->mutex );
+ mbedtls_mutex_init(&ctx->mutex);
#endif
ctx->accumulator_started = 0;
#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
- mbedtls_sha512_init( &ctx->accumulator );
+ mbedtls_sha512_init(&ctx->accumulator);
#else
- mbedtls_sha256_init( &ctx->accumulator );
+ mbedtls_sha256_init(&ctx->accumulator);
#endif
#if defined(MBEDTLS_HAVEGE_C)
- mbedtls_havege_init( &ctx->havege_data );
+ mbedtls_havege_init(&ctx->havege_data);
#endif
#if !defined(MBEDTLS_NO_PLATFORM_ENTROPY)
- if( custom_entropy_sources_mask & ENTROPY_SOURCE_PLATFORM )
- mbedtls_entropy_add_source( ctx, mbedtls_platform_entropy_poll, NULL,
- MBEDTLS_ENTROPY_MIN_PLATFORM,
- MBEDTLS_ENTROPY_SOURCE_STRONG );
+ if (custom_entropy_sources_mask & ENTROPY_SOURCE_PLATFORM) {
+ mbedtls_entropy_add_source(ctx, mbedtls_platform_entropy_poll, NULL,
+ MBEDTLS_ENTROPY_MIN_PLATFORM,
+ MBEDTLS_ENTROPY_SOURCE_STRONG);
+ }
#endif
#if defined(MBEDTLS_TIMING_C)
- if( custom_entropy_sources_mask & ENTROPY_SOURCE_TIMING )
- mbedtls_entropy_add_source( ctx, mbedtls_hardclock_poll, NULL,
- MBEDTLS_ENTROPY_MIN_HARDCLOCK,
- MBEDTLS_ENTROPY_SOURCE_WEAK );
+ if (custom_entropy_sources_mask & ENTROPY_SOURCE_TIMING) {
+ mbedtls_entropy_add_source(ctx, mbedtls_hardclock_poll, NULL,
+ MBEDTLS_ENTROPY_MIN_HARDCLOCK,
+ MBEDTLS_ENTROPY_SOURCE_WEAK);
+ }
#endif
#if defined(MBEDTLS_HAVEGE_C)
- if( custom_entropy_sources_mask & ENTROPY_SOURCE_HAVEGE )
- mbedtls_entropy_add_source( ctx, mbedtls_havege_poll, &ctx->havege_data,
- MBEDTLS_ENTROPY_MIN_HAVEGE,
- MBEDTLS_ENTROPY_SOURCE_STRONG );
+ if (custom_entropy_sources_mask & ENTROPY_SOURCE_HAVEGE) {
+ mbedtls_entropy_add_source(ctx, mbedtls_havege_poll, &ctx->havege_data,
+ MBEDTLS_ENTROPY_MIN_HAVEGE,
+ MBEDTLS_ENTROPY_SOURCE_STRONG);
+ }
#endif
#if defined(MBEDTLS_ENTROPY_HARDWARE_ALT)
- if( custom_entropy_sources_mask & ENTROPY_SOURCE_HARDWARE )
- mbedtls_entropy_add_source( ctx, mbedtls_hardware_poll, NULL,
- MBEDTLS_ENTROPY_MIN_HARDWARE,
- MBEDTLS_ENTROPY_SOURCE_STRONG );
+ if (custom_entropy_sources_mask & ENTROPY_SOURCE_HARDWARE) {
+ mbedtls_entropy_add_source(ctx, mbedtls_hardware_poll, NULL,
+ MBEDTLS_ENTROPY_MIN_HARDWARE,
+ MBEDTLS_ENTROPY_SOURCE_STRONG);
+ }
#endif
#if defined(MBEDTLS_ENTROPY_NV_SEED)
- if( custom_entropy_sources_mask & ENTROPY_SOURCE_NV_SEED )
- {
- mbedtls_entropy_add_source( ctx, mbedtls_nv_seed_poll, NULL,
- MBEDTLS_ENTROPY_BLOCK_SIZE,
- MBEDTLS_ENTROPY_SOURCE_STRONG );
+ if (custom_entropy_sources_mask & ENTROPY_SOURCE_NV_SEED) {
+ mbedtls_entropy_add_source(ctx, mbedtls_nv_seed_poll, NULL,
+ MBEDTLS_ENTROPY_BLOCK_SIZE,
+ MBEDTLS_ENTROPY_SOURCE_STRONG);
ctx->initial_entropy_run = 0;
- }
- else
- {
+ } else {
/* Skip the NV seed even though it's compiled in. */
ctx->initial_entropy_run = 1;
}
#endif
- if( custom_entropy_sources_mask & ENTROPY_SOURCE_FAKE )
- mbedtls_entropy_add_source( ctx,
- fake_entropy_source, &fake_entropy_state,
- fake_entropy_state.threshold,
- MBEDTLS_ENTROPY_SOURCE_STRONG );
+ if (custom_entropy_sources_mask & ENTROPY_SOURCE_FAKE) {
+ mbedtls_entropy_add_source(ctx,
+ fake_entropy_source, &fake_entropy_state,
+ fake_entropy_state.threshold,
+ MBEDTLS_ENTROPY_SOURCE_STRONG);
+ }
}
#endif /* !defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG) */
@@ -139,109 +142,106 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:!MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */
-void create_nv_seed( )
+void create_nv_seed()
{
static unsigned char seed[ENTROPY_MIN_NV_SEED_SIZE];
- TEST_ASSERT( mbedtls_nv_seed_write( seed, sizeof( seed ) ) >= 0 );
+ TEST_ASSERT(mbedtls_nv_seed_write(seed, sizeof(seed)) >= 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void init_deinit( int count )
+void init_deinit(int count)
{
psa_status_t status;
int i;
- for( i = 0; i < count; i++ )
- {
- status = psa_crypto_init( );
- PSA_ASSERT( status );
- status = psa_crypto_init( );
- PSA_ASSERT( status );
- PSA_DONE( );
+ for (i = 0; i < count; i++) {
+ status = psa_crypto_init();
+ PSA_ASSERT(status);
+ status = psa_crypto_init();
+ PSA_ASSERT(status);
+ PSA_DONE();
}
}
/* END_CASE */
/* BEGIN_CASE */
-void deinit_without_init( int count )
+void deinit_without_init(int count)
{
int i;
- for( i = 0; i < count; i++ )
- {
- PSA_ASSERT( psa_crypto_init( ) );
- PSA_DONE( );
+ for (i = 0; i < count; i++) {
+ PSA_ASSERT(psa_crypto_init());
+ PSA_DONE();
}
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void validate_module_init_generate_random( int count )
+void validate_module_init_generate_random(int count)
{
psa_status_t status;
uint8_t random[10] = { 0 };
int i;
- for( i = 0; i < count; i++ )
- {
- status = psa_crypto_init( );
- PSA_ASSERT( status );
- PSA_DONE( );
+ for (i = 0; i < count; i++) {
+ status = psa_crypto_init();
+ PSA_ASSERT(status);
+ PSA_DONE();
}
- status = psa_generate_random( random, sizeof( random ) );
- TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
+ status = psa_generate_random(random, sizeof(random));
+ TEST_EQUAL(status, PSA_ERROR_BAD_STATE);
}
/* END_CASE */
/* BEGIN_CASE */
-void validate_module_init_key_based( int count )
+void validate_module_init_key_based(int count)
{
psa_status_t status;
uint8_t data[10] = { 0 };
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- mbedtls_svc_key_id_t key = mbedtls_svc_key_id_make( 0xdead, 0xdead );
+ mbedtls_svc_key_id_t key = mbedtls_svc_key_id_make(0xdead, 0xdead);
int i;
- for( i = 0; i < count; i++ )
- {
- status = psa_crypto_init( );
- PSA_ASSERT( status );
- PSA_DONE( );
+ for (i = 0; i < count; i++) {
+ status = psa_crypto_init();
+ PSA_ASSERT(status);
+ PSA_DONE();
}
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
- status = psa_import_key( &attributes, data, sizeof( data ), &key );
- TEST_EQUAL( status, PSA_ERROR_BAD_STATE );
- TEST_ASSERT( mbedtls_svc_key_id_is_null( key ) );
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
+ status = psa_import_key(&attributes, data, sizeof(data), &key);
+ TEST_EQUAL(status, PSA_ERROR_BAD_STATE);
+ TEST_ASSERT(mbedtls_svc_key_id_is_null(key));
}
/* END_CASE */
/* BEGIN_CASE depends_on:!MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */
-void custom_entropy_sources( int sources_arg, int expected_init_status_arg )
+void custom_entropy_sources(int sources_arg, int expected_init_status_arg)
{
psa_status_t expected_init_status = expected_init_status_arg;
uint8_t random[10] = { 0 };
custom_entropy_sources_mask = sources_arg;
- PSA_ASSERT( mbedtls_psa_crypto_configure_entropy_sources(
- custom_entropy_init, mbedtls_entropy_free ) );
+ PSA_ASSERT(mbedtls_psa_crypto_configure_entropy_sources(
+ custom_entropy_init, mbedtls_entropy_free));
- TEST_EQUAL( psa_crypto_init( ), expected_init_status );
- if( expected_init_status != PSA_SUCCESS )
+ TEST_EQUAL(psa_crypto_init(), expected_init_status);
+ if (expected_init_status != PSA_SUCCESS) {
goto exit;
+ }
- PSA_ASSERT( psa_generate_random( random, sizeof( random ) ) );
+ PSA_ASSERT(psa_generate_random(random, sizeof(random)));
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:!MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */
-void fake_entropy_source( int threshold,
- int amount1,
- int amount2,
- int amount3,
- int amount4,
- int expected_init_status_arg )
+void fake_entropy_source(int threshold,
+ int amount1,
+ int amount2,
+ int amount3,
+ int amount4,
+ int expected_init_status_arg)
{
psa_status_t expected_init_status = expected_init_status_arg;
uint8_t random[10] = { 0 };
@@ -250,55 +250,61 @@
fake_entropy_state.threshold = threshold;
fake_entropy_state.step = 0;
fake_entropy_state.max_steps = 0;
- if( amount1 >= 0 )
+ if (amount1 >= 0) {
lengths[fake_entropy_state.max_steps++] = amount1;
- if( amount2 >= 0 )
+ }
+ if (amount2 >= 0) {
lengths[fake_entropy_state.max_steps++] = amount2;
- if( amount3 >= 0 )
+ }
+ if (amount3 >= 0) {
lengths[fake_entropy_state.max_steps++] = amount3;
- if( amount4 >= 0 )
+ }
+ if (amount4 >= 0) {
lengths[fake_entropy_state.max_steps++] = amount4;
+ }
fake_entropy_state.length_sequence = lengths;
custom_entropy_sources_mask = ENTROPY_SOURCE_FAKE;
- PSA_ASSERT( mbedtls_psa_crypto_configure_entropy_sources(
- custom_entropy_init, mbedtls_entropy_free ) );
+ PSA_ASSERT(mbedtls_psa_crypto_configure_entropy_sources(
+ custom_entropy_init, mbedtls_entropy_free));
- TEST_EQUAL( psa_crypto_init( ), expected_init_status );
- if( expected_init_status != PSA_SUCCESS )
+ TEST_EQUAL(psa_crypto_init(), expected_init_status);
+ if (expected_init_status != PSA_SUCCESS) {
goto exit;
+ }
- PSA_ASSERT( psa_generate_random( random, sizeof( random ) ) );
+ PSA_ASSERT(psa_generate_random(random, sizeof(random)));
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_NV_SEED:!MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */
-void entropy_from_nv_seed( int seed_size_arg,
- int expected_init_status_arg )
+void entropy_from_nv_seed(int seed_size_arg,
+ int expected_init_status_arg)
{
psa_status_t expected_init_status = expected_init_status_arg;
uint8_t random[10] = { 0 };
uint8_t *seed = NULL;
size_t seed_size = seed_size_arg;
- ASSERT_ALLOC( seed, seed_size );
- TEST_ASSERT( mbedtls_nv_seed_write( seed, seed_size ) >= 0 );
+ ASSERT_ALLOC(seed, seed_size);
+ TEST_ASSERT(mbedtls_nv_seed_write(seed, seed_size) >= 0);
custom_entropy_sources_mask = ENTROPY_SOURCE_NV_SEED;
- PSA_ASSERT( mbedtls_psa_crypto_configure_entropy_sources(
- custom_entropy_init, mbedtls_entropy_free ) );
+ PSA_ASSERT(mbedtls_psa_crypto_configure_entropy_sources(
+ custom_entropy_init, mbedtls_entropy_free));
- TEST_EQUAL( psa_crypto_init( ), expected_init_status );
- if( expected_init_status != PSA_SUCCESS )
+ TEST_EQUAL(psa_crypto_init(), expected_init_status);
+ if (expected_init_status != PSA_SUCCESS) {
goto exit;
+ }
- PSA_ASSERT( psa_generate_random( random, sizeof( random ) ) );
+ PSA_ASSERT(psa_generate_random(random, sizeof(random)));
exit:
- mbedtls_free( seed );
- PSA_DONE( );
+ mbedtls_free(seed);
+ PSA_DONE();
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto_metadata.function b/tests/suites/test_suite_psa_crypto_metadata.function
index f2ba16a..47d60c1 100644
--- a/tests/suites/test_suite_psa_crypto_metadata.function
+++ b/tests/suites/test_suite_psa_crypto_metadata.function
@@ -16,56 +16,56 @@
* category test macros, which are hard-coded in each
* category-specific function. The name of the flag is the name of the
* classification macro without the PSA_ prefix. */
-#define ALG_IS_VENDOR_DEFINED ( 1u << 0 )
-#define ALG_IS_HMAC ( 1u << 1 )
-#define ALG_IS_BLOCK_CIPHER_MAC ( 1u << 2 )
-#define ALG_IS_STREAM_CIPHER ( 1u << 3 )
-#define ALG_IS_RSA_PKCS1V15_SIGN ( 1u << 4 )
-#define ALG_IS_RSA_PSS ( 1u << 5 )
-#define ALG_IS_RSA_PSS_ANY_SALT ( 1u << 6 )
-#define ALG_IS_RSA_PSS_STANDARD_SALT ( 1u << 7 )
-#define ALG_IS_DSA ( 1u << 8 )
-#define ALG_DSA_IS_DETERMINISTIC ( 1u << 9 )
-#define ALG_IS_DETERMINISTIC_DSA ( 1u << 10 )
-#define ALG_IS_RANDOMIZED_DSA ( 1u << 11 )
-#define ALG_IS_ECDSA ( 1u << 12 )
-#define ALG_ECDSA_IS_DETERMINISTIC ( 1u << 13 )
-#define ALG_IS_DETERMINISTIC_ECDSA ( 1u << 14 )
-#define ALG_IS_RANDOMIZED_ECDSA ( 1u << 15 )
-#define ALG_IS_HASH_EDDSA ( 1u << 16 )
-#define ALG_IS_SIGN_HASH ( 1u << 17 )
-#define ALG_IS_HASH_AND_SIGN ( 1u << 18 )
-#define ALG_IS_RSA_OAEP ( 1u << 19 )
-#define ALG_IS_HKDF ( 1u << 20 )
-#define ALG_IS_FFDH ( 1u << 21 )
-#define ALG_IS_ECDH ( 1u << 22 )
-#define ALG_IS_WILDCARD ( 1u << 23 )
-#define ALG_IS_RAW_KEY_AGREEMENT ( 1u << 24 )
-#define ALG_IS_AEAD_ON_BLOCK_CIPHER ( 1u << 25 )
-#define ALG_IS_TLS12_PRF ( 1u << 26 )
-#define ALG_IS_TLS12_PSK_TO_MS ( 1u << 27 )
-#define ALG_FLAG_MASK_PLUS_ONE ( 1u << 28 ) /* must be last! */
+#define ALG_IS_VENDOR_DEFINED (1u << 0)
+#define ALG_IS_HMAC (1u << 1)
+#define ALG_IS_BLOCK_CIPHER_MAC (1u << 2)
+#define ALG_IS_STREAM_CIPHER (1u << 3)
+#define ALG_IS_RSA_PKCS1V15_SIGN (1u << 4)
+#define ALG_IS_RSA_PSS (1u << 5)
+#define ALG_IS_RSA_PSS_ANY_SALT (1u << 6)
+#define ALG_IS_RSA_PSS_STANDARD_SALT (1u << 7)
+#define ALG_IS_DSA (1u << 8)
+#define ALG_DSA_IS_DETERMINISTIC (1u << 9)
+#define ALG_IS_DETERMINISTIC_DSA (1u << 10)
+#define ALG_IS_RANDOMIZED_DSA (1u << 11)
+#define ALG_IS_ECDSA (1u << 12)
+#define ALG_ECDSA_IS_DETERMINISTIC (1u << 13)
+#define ALG_IS_DETERMINISTIC_ECDSA (1u << 14)
+#define ALG_IS_RANDOMIZED_ECDSA (1u << 15)
+#define ALG_IS_HASH_EDDSA (1u << 16)
+#define ALG_IS_SIGN_HASH (1u << 17)
+#define ALG_IS_HASH_AND_SIGN (1u << 18)
+#define ALG_IS_RSA_OAEP (1u << 19)
+#define ALG_IS_HKDF (1u << 20)
+#define ALG_IS_FFDH (1u << 21)
+#define ALG_IS_ECDH (1u << 22)
+#define ALG_IS_WILDCARD (1u << 23)
+#define ALG_IS_RAW_KEY_AGREEMENT (1u << 24)
+#define ALG_IS_AEAD_ON_BLOCK_CIPHER (1u << 25)
+#define ALG_IS_TLS12_PRF (1u << 26)
+#define ALG_IS_TLS12_PSK_TO_MS (1u << 27)
+#define ALG_FLAG_MASK_PLUS_ONE (1u << 28) /* must be last! */
/* Flags for key type classification macros. There is a flag for every
* key type classification macro PSA_KEY_TYPE_IS_xxx except for some that
* are tested as derived from other macros. The name of the flag is
* the name of the classification macro without the PSA_ prefix. */
-#define KEY_TYPE_IS_VENDOR_DEFINED ( 1u << 0 )
-#define KEY_TYPE_IS_UNSTRUCTURED ( 1u << 1 )
-#define KEY_TYPE_IS_PUBLIC_KEY ( 1u << 2 )
-#define KEY_TYPE_IS_KEY_PAIR ( 1u << 3 )
-#define KEY_TYPE_IS_RSA ( 1u << 4 )
-#define KEY_TYPE_IS_DSA ( 1u << 5 )
-#define KEY_TYPE_IS_ECC ( 1u << 6 )
-#define KEY_TYPE_IS_DH ( 1u << 7 )
-#define KEY_TYPE_FLAG_MASK_PLUS_ONE ( 1u << 8 ) /* must be last! */
+#define KEY_TYPE_IS_VENDOR_DEFINED (1u << 0)
+#define KEY_TYPE_IS_UNSTRUCTURED (1u << 1)
+#define KEY_TYPE_IS_PUBLIC_KEY (1u << 2)
+#define KEY_TYPE_IS_KEY_PAIR (1u << 3)
+#define KEY_TYPE_IS_RSA (1u << 4)
+#define KEY_TYPE_IS_DSA (1u << 5)
+#define KEY_TYPE_IS_ECC (1u << 6)
+#define KEY_TYPE_IS_DH (1u << 7)
+#define KEY_TYPE_FLAG_MASK_PLUS_ONE (1u << 8) /* must be last! */
/* Flags for lifetime classification macros. There is a flag for every
* lifetime classification macro PSA_KEY_LIFETIME_IS_xxx. The name of the
* flag is the name of the classification macro without the PSA_ prefix. */
-#define KEY_LIFETIME_IS_VOLATILE ( 1u << 0 )
-#define KEY_LIFETIME_IS_READ_ONLY ( 1u << 1 )
-#define KEY_LIFETIME_FLAG_MASK_PLUS_ONE ( 1u << 2 ) /* must be last! */
+#define KEY_LIFETIME_IS_VOLATILE (1u << 0)
+#define KEY_LIFETIME_IS_READ_ONLY (1u << 1)
+#define KEY_LIFETIME_FLAG_MASK_PLUS_ONE (1u << 2) /* must be last! */
/* Check that in the value of flags, the bit flag (which should be a macro
* expanding to a number of the form 1 << k) is set if and only if
@@ -78,19 +78,19 @@
* Unconditionally mask flag into the ambient variable
* classification_flags_tested.
*/
-#define TEST_CLASSIFICATION_MACRO( cond, flag, alg, flags ) \
+#define TEST_CLASSIFICATION_MACRO(cond, flag, alg, flags) \
do \
{ \
- if( cond ) \
+ if (cond) \
{ \
- if( ( flags ) & ( flag ) ) \
- TEST_ASSERT( PSA_##flag( alg ) ); \
+ if ((flags) & (flag)) \
+ TEST_ASSERT(PSA_##flag(alg)); \
else \
- TEST_ASSERT( ! PSA_##flag( alg ) ); \
+ TEST_ASSERT(!PSA_##flag(alg)); \
} \
- classification_flags_tested |= ( flag ); \
+ classification_flags_tested |= (flag); \
} \
- while( 0 )
+ while (0)
/* Check the parity of value.
*
@@ -104,134 +104,134 @@
* The expected parity is even so that 0 is considered a valid encoding.
*
* Return a nonzero value if value has even parity and 0 otherwise. */
-int has_even_parity( uint32_t value )
+int has_even_parity(uint32_t value)
{
value ^= value >> 16;
value ^= value >> 8;
value ^= value >> 4;
- return( 0x9669 & 1 << ( value & 0xf ) );
+ return 0x9669 & 1 << (value & 0xf);
}
-#define TEST_PARITY( value ) \
- TEST_ASSERT( has_even_parity( value ) )
+#define TEST_PARITY(value) \
+ TEST_ASSERT(has_even_parity(value))
-void algorithm_classification( psa_algorithm_t alg, unsigned flags )
+void algorithm_classification(psa_algorithm_t alg, unsigned flags)
{
unsigned classification_flags_tested = 0;
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_VENDOR_DEFINED, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_HMAC, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_BLOCK_CIPHER_MAC, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_STREAM_CIPHER, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_RSA_PKCS1V15_SIGN, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_RSA_PSS, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_RSA_PSS_ANY_SALT, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_RSA_PSS_STANDARD_SALT, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_DSA, alg, flags );
- TEST_CLASSIFICATION_MACRO( PSA_ALG_IS_DSA( alg ),
- ALG_DSA_IS_DETERMINISTIC, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_DETERMINISTIC_DSA, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_RANDOMIZED_DSA, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_ECDSA, alg, flags );
- TEST_CLASSIFICATION_MACRO( PSA_ALG_IS_ECDSA( alg ),
- ALG_ECDSA_IS_DETERMINISTIC, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_DETERMINISTIC_ECDSA, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_RANDOMIZED_ECDSA, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_HASH_EDDSA, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_SIGN_HASH, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_HASH_AND_SIGN, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_RSA_OAEP, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_HKDF, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_WILDCARD, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_ECDH, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_FFDH, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_RAW_KEY_AGREEMENT, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_AEAD_ON_BLOCK_CIPHER, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_TLS12_PRF, alg, flags );
- TEST_CLASSIFICATION_MACRO( 1, ALG_IS_TLS12_PSK_TO_MS, alg, flags );
- TEST_EQUAL( classification_flags_tested, ALG_FLAG_MASK_PLUS_ONE - 1 );
-exit: ;
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_VENDOR_DEFINED, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_HMAC, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_BLOCK_CIPHER_MAC, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_STREAM_CIPHER, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_RSA_PKCS1V15_SIGN, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_RSA_PSS, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_RSA_PSS_ANY_SALT, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_RSA_PSS_STANDARD_SALT, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_DSA, alg, flags);
+ TEST_CLASSIFICATION_MACRO(PSA_ALG_IS_DSA(alg),
+ ALG_DSA_IS_DETERMINISTIC, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_DETERMINISTIC_DSA, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_RANDOMIZED_DSA, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_ECDSA, alg, flags);
+ TEST_CLASSIFICATION_MACRO(PSA_ALG_IS_ECDSA(alg),
+ ALG_ECDSA_IS_DETERMINISTIC, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_DETERMINISTIC_ECDSA, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_RANDOMIZED_ECDSA, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_HASH_EDDSA, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_SIGN_HASH, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_HASH_AND_SIGN, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_RSA_OAEP, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_HKDF, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_WILDCARD, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_ECDH, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_FFDH, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_RAW_KEY_AGREEMENT, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_AEAD_ON_BLOCK_CIPHER, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_TLS12_PRF, alg, flags);
+ TEST_CLASSIFICATION_MACRO(1, ALG_IS_TLS12_PSK_TO_MS, alg, flags);
+ TEST_EQUAL(classification_flags_tested, ALG_FLAG_MASK_PLUS_ONE - 1);
+exit:;
}
-void key_type_classification( psa_key_type_t type, unsigned flags )
+void key_type_classification(psa_key_type_t type, unsigned flags)
{
unsigned classification_flags_tested = 0;
/* Macros tested based on the test case parameter */
- TEST_CLASSIFICATION_MACRO( 1, KEY_TYPE_IS_VENDOR_DEFINED, type, flags );
- TEST_CLASSIFICATION_MACRO( 1, KEY_TYPE_IS_UNSTRUCTURED, type, flags );
- TEST_CLASSIFICATION_MACRO( 1, KEY_TYPE_IS_PUBLIC_KEY, type, flags );
- TEST_CLASSIFICATION_MACRO( 1, KEY_TYPE_IS_KEY_PAIR, type, flags );
- TEST_CLASSIFICATION_MACRO( 1, KEY_TYPE_IS_RSA, type, flags );
- TEST_CLASSIFICATION_MACRO( 1, KEY_TYPE_IS_DSA, type, flags );
- TEST_CLASSIFICATION_MACRO( 1, KEY_TYPE_IS_ECC, type, flags );
- TEST_CLASSIFICATION_MACRO( 1, KEY_TYPE_IS_DH, type, flags );
- TEST_EQUAL( classification_flags_tested, KEY_TYPE_FLAG_MASK_PLUS_ONE - 1 );
+ TEST_CLASSIFICATION_MACRO(1, KEY_TYPE_IS_VENDOR_DEFINED, type, flags);
+ TEST_CLASSIFICATION_MACRO(1, KEY_TYPE_IS_UNSTRUCTURED, type, flags);
+ TEST_CLASSIFICATION_MACRO(1, KEY_TYPE_IS_PUBLIC_KEY, type, flags);
+ TEST_CLASSIFICATION_MACRO(1, KEY_TYPE_IS_KEY_PAIR, type, flags);
+ TEST_CLASSIFICATION_MACRO(1, KEY_TYPE_IS_RSA, type, flags);
+ TEST_CLASSIFICATION_MACRO(1, KEY_TYPE_IS_DSA, type, flags);
+ TEST_CLASSIFICATION_MACRO(1, KEY_TYPE_IS_ECC, type, flags);
+ TEST_CLASSIFICATION_MACRO(1, KEY_TYPE_IS_DH, type, flags);
+ TEST_EQUAL(classification_flags_tested, KEY_TYPE_FLAG_MASK_PLUS_ONE - 1);
/* Macros with derived semantics */
- TEST_EQUAL( PSA_KEY_TYPE_IS_ASYMMETRIC( type ),
- ( PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ||
- PSA_KEY_TYPE_IS_KEY_PAIR( type ) ) );
- TEST_EQUAL( PSA_KEY_TYPE_IS_ECC_KEY_PAIR( type ),
- ( PSA_KEY_TYPE_IS_ECC( type ) &&
- PSA_KEY_TYPE_IS_KEY_PAIR( type ) ) );
- TEST_EQUAL( PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY( type ),
- ( PSA_KEY_TYPE_IS_ECC( type ) &&
- PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ) );
- TEST_EQUAL( PSA_KEY_TYPE_IS_DH_KEY_PAIR( type ),
- ( PSA_KEY_TYPE_IS_DH( type ) &&
- PSA_KEY_TYPE_IS_KEY_PAIR( type ) ) );
- TEST_EQUAL( PSA_KEY_TYPE_IS_DH_PUBLIC_KEY( type ),
- ( PSA_KEY_TYPE_IS_DH( type ) &&
- PSA_KEY_TYPE_IS_PUBLIC_KEY( type ) ) );
+ TEST_EQUAL(PSA_KEY_TYPE_IS_ASYMMETRIC(type),
+ (PSA_KEY_TYPE_IS_PUBLIC_KEY(type) ||
+ PSA_KEY_TYPE_IS_KEY_PAIR(type)));
+ TEST_EQUAL(PSA_KEY_TYPE_IS_ECC_KEY_PAIR(type),
+ (PSA_KEY_TYPE_IS_ECC(type) &&
+ PSA_KEY_TYPE_IS_KEY_PAIR(type)));
+ TEST_EQUAL(PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(type),
+ (PSA_KEY_TYPE_IS_ECC(type) &&
+ PSA_KEY_TYPE_IS_PUBLIC_KEY(type)));
+ TEST_EQUAL(PSA_KEY_TYPE_IS_DH_KEY_PAIR(type),
+ (PSA_KEY_TYPE_IS_DH(type) &&
+ PSA_KEY_TYPE_IS_KEY_PAIR(type)));
+ TEST_EQUAL(PSA_KEY_TYPE_IS_DH_PUBLIC_KEY(type),
+ (PSA_KEY_TYPE_IS_DH(type) &&
+ PSA_KEY_TYPE_IS_PUBLIC_KEY(type)));
- TEST_PARITY( type );
+ TEST_PARITY(type);
-exit: ;
+exit:;
}
-void mac_algorithm_core( psa_algorithm_t alg, int classification_flags,
- psa_key_type_t key_type, size_t key_bits,
- size_t length )
+void mac_algorithm_core(psa_algorithm_t alg, int classification_flags,
+ psa_key_type_t key_type, size_t key_bits,
+ size_t length)
{
/* Algorithm classification */
- TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
- TEST_ASSERT( PSA_ALG_IS_MAC( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
- algorithm_classification( alg, classification_flags );
+ TEST_ASSERT(!PSA_ALG_IS_HASH(alg));
+ TEST_ASSERT(PSA_ALG_IS_MAC(alg));
+ TEST_ASSERT(!PSA_ALG_IS_CIPHER(alg));
+ TEST_ASSERT(!PSA_ALG_IS_AEAD(alg));
+ TEST_ASSERT(!PSA_ALG_IS_SIGN(alg));
+ TEST_ASSERT(!PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg));
+ TEST_ASSERT(!PSA_ALG_IS_KEY_AGREEMENT(alg));
+ TEST_ASSERT(!PSA_ALG_IS_KEY_DERIVATION(alg));
+ algorithm_classification(alg, classification_flags);
/* Length */
- TEST_EQUAL( length, PSA_MAC_LENGTH( key_type, key_bits, alg ) );
+ TEST_EQUAL(length, PSA_MAC_LENGTH(key_type, key_bits, alg));
#if defined(MBEDTLS_TEST_HOOKS) && defined(MBEDTLS_PSA_CRYPTO_C)
- PSA_ASSERT( psa_mac_key_can_do( alg, key_type ) );
+ PSA_ASSERT(psa_mac_key_can_do(alg, key_type));
#endif
-exit: ;
+exit:;
}
-void aead_algorithm_core( psa_algorithm_t alg, int classification_flags,
- psa_key_type_t key_type, size_t key_bits,
- size_t tag_length )
+void aead_algorithm_core(psa_algorithm_t alg, int classification_flags,
+ psa_key_type_t key_type, size_t key_bits,
+ size_t tag_length)
{
/* Algorithm classification */
- TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
- TEST_ASSERT( PSA_ALG_IS_AEAD( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
- algorithm_classification( alg, classification_flags );
+ TEST_ASSERT(!PSA_ALG_IS_HASH(alg));
+ TEST_ASSERT(!PSA_ALG_IS_MAC(alg));
+ TEST_ASSERT(!PSA_ALG_IS_CIPHER(alg));
+ TEST_ASSERT(PSA_ALG_IS_AEAD(alg));
+ TEST_ASSERT(!PSA_ALG_IS_SIGN(alg));
+ TEST_ASSERT(!PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg));
+ TEST_ASSERT(!PSA_ALG_IS_KEY_AGREEMENT(alg));
+ TEST_ASSERT(!PSA_ALG_IS_KEY_DERIVATION(alg));
+ algorithm_classification(alg, classification_flags);
/* Tag length */
- TEST_EQUAL( tag_length, PSA_AEAD_TAG_LENGTH( key_type, key_bits, alg ) );
+ TEST_EQUAL(tag_length, PSA_AEAD_TAG_LENGTH(key_type, key_bits, alg));
-exit: ;
+exit:;
}
/* END_HEADER */
@@ -242,52 +242,52 @@
*/
/* BEGIN_CASE */
-void hash_algorithm( int alg_arg, int length_arg )
+void hash_algorithm(int alg_arg, int length_arg)
{
psa_algorithm_t alg = alg_arg;
size_t length = length_arg;
- psa_algorithm_t hmac_alg = PSA_ALG_HMAC( alg );
- psa_algorithm_t rsa_pkcs1v15_sign_alg = PSA_ALG_RSA_PKCS1V15_SIGN( alg );
- psa_algorithm_t rsa_pss_alg = PSA_ALG_RSA_PSS( alg );
- psa_algorithm_t dsa_alg = PSA_ALG_DSA( alg );
- psa_algorithm_t deterministic_dsa_alg = PSA_ALG_DETERMINISTIC_DSA( alg );
- psa_algorithm_t ecdsa_alg = PSA_ALG_ECDSA( alg );
- psa_algorithm_t deterministic_ecdsa_alg = PSA_ALG_DETERMINISTIC_ECDSA( alg );
- psa_algorithm_t rsa_oaep_alg = PSA_ALG_RSA_OAEP( alg );
- psa_algorithm_t hkdf_alg = PSA_ALG_HKDF( alg );
+ psa_algorithm_t hmac_alg = PSA_ALG_HMAC(alg);
+ psa_algorithm_t rsa_pkcs1v15_sign_alg = PSA_ALG_RSA_PKCS1V15_SIGN(alg);
+ psa_algorithm_t rsa_pss_alg = PSA_ALG_RSA_PSS(alg);
+ psa_algorithm_t dsa_alg = PSA_ALG_DSA(alg);
+ psa_algorithm_t deterministic_dsa_alg = PSA_ALG_DETERMINISTIC_DSA(alg);
+ psa_algorithm_t ecdsa_alg = PSA_ALG_ECDSA(alg);
+ psa_algorithm_t deterministic_ecdsa_alg = PSA_ALG_DETERMINISTIC_ECDSA(alg);
+ psa_algorithm_t rsa_oaep_alg = PSA_ALG_RSA_OAEP(alg);
+ psa_algorithm_t hkdf_alg = PSA_ALG_HKDF(alg);
/* Algorithm classification */
- TEST_ASSERT( PSA_ALG_IS_HASH( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
- algorithm_classification( alg, 0 );
+ TEST_ASSERT(PSA_ALG_IS_HASH(alg));
+ TEST_ASSERT(!PSA_ALG_IS_MAC(alg));
+ TEST_ASSERT(!PSA_ALG_IS_CIPHER(alg));
+ TEST_ASSERT(!PSA_ALG_IS_AEAD(alg));
+ TEST_ASSERT(!PSA_ALG_IS_SIGN(alg));
+ TEST_ASSERT(!PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg));
+ TEST_ASSERT(!PSA_ALG_IS_KEY_AGREEMENT(alg));
+ TEST_ASSERT(!PSA_ALG_IS_KEY_DERIVATION(alg));
+ algorithm_classification(alg, 0);
/* Dependent algorithms */
- TEST_EQUAL( PSA_ALG_HMAC_GET_HASH( hmac_alg ), alg );
- TEST_EQUAL( PSA_ALG_SIGN_GET_HASH( rsa_pkcs1v15_sign_alg ), alg );
- TEST_EQUAL( PSA_ALG_SIGN_GET_HASH( rsa_pss_alg ), alg );
- TEST_EQUAL( PSA_ALG_SIGN_GET_HASH( dsa_alg ), alg );
- TEST_EQUAL( PSA_ALG_SIGN_GET_HASH( deterministic_dsa_alg ), alg );
- TEST_EQUAL( PSA_ALG_SIGN_GET_HASH( ecdsa_alg ), alg );
- TEST_EQUAL( PSA_ALG_SIGN_GET_HASH( deterministic_ecdsa_alg ), alg );
- TEST_EQUAL( PSA_ALG_RSA_OAEP_GET_HASH( rsa_oaep_alg ), alg );
- TEST_EQUAL( PSA_ALG_HKDF_GET_HASH( hkdf_alg ), alg );
+ TEST_EQUAL(PSA_ALG_HMAC_GET_HASH(hmac_alg), alg);
+ TEST_EQUAL(PSA_ALG_SIGN_GET_HASH(rsa_pkcs1v15_sign_alg), alg);
+ TEST_EQUAL(PSA_ALG_SIGN_GET_HASH(rsa_pss_alg), alg);
+ TEST_EQUAL(PSA_ALG_SIGN_GET_HASH(dsa_alg), alg);
+ TEST_EQUAL(PSA_ALG_SIGN_GET_HASH(deterministic_dsa_alg), alg);
+ TEST_EQUAL(PSA_ALG_SIGN_GET_HASH(ecdsa_alg), alg);
+ TEST_EQUAL(PSA_ALG_SIGN_GET_HASH(deterministic_ecdsa_alg), alg);
+ TEST_EQUAL(PSA_ALG_RSA_OAEP_GET_HASH(rsa_oaep_alg), alg);
+ TEST_EQUAL(PSA_ALG_HKDF_GET_HASH(hkdf_alg), alg);
/* Hash length */
- TEST_EQUAL( length, PSA_HASH_LENGTH( alg ) );
- TEST_ASSERT( length <= PSA_HASH_MAX_SIZE );
+ TEST_EQUAL(length, PSA_HASH_LENGTH(alg));
+ TEST_ASSERT(length <= PSA_HASH_MAX_SIZE);
}
/* END_CASE */
/* BEGIN_CASE */
-void mac_algorithm( int alg_arg, int classification_flags,
- int length_arg,
- int key_type_arg, int key_bits_arg )
+void mac_algorithm(int alg_arg, int classification_flags,
+ int length_arg,
+ int key_type_arg, int key_bits_arg)
{
psa_algorithm_t alg = alg_arg;
size_t length = length_arg;
@@ -295,127 +295,124 @@
size_t key_type = key_type_arg;
size_t key_bits = key_bits_arg;
- mac_algorithm_core( alg, classification_flags,
- key_type, key_bits, length );
- TEST_EQUAL( PSA_ALG_FULL_LENGTH_MAC( alg ), alg );
- TEST_ASSERT( length <= PSA_MAC_MAX_SIZE );
+ mac_algorithm_core(alg, classification_flags,
+ key_type, key_bits, length);
+ TEST_EQUAL(PSA_ALG_FULL_LENGTH_MAC(alg), alg);
+ TEST_ASSERT(length <= PSA_MAC_MAX_SIZE);
/* Truncated versions */
- for( n = 1; n <= length; n++ )
- {
- psa_algorithm_t truncated_alg = PSA_ALG_TRUNCATED_MAC( alg, n );
- mac_algorithm_core( truncated_alg, classification_flags,
- key_type, key_bits, n );
- TEST_EQUAL( PSA_ALG_FULL_LENGTH_MAC( truncated_alg ), alg );
+ for (n = 1; n <= length; n++) {
+ psa_algorithm_t truncated_alg = PSA_ALG_TRUNCATED_MAC(alg, n);
+ mac_algorithm_core(truncated_alg, classification_flags,
+ key_type, key_bits, n);
+ TEST_EQUAL(PSA_ALG_FULL_LENGTH_MAC(truncated_alg), alg);
/* Check that calling PSA_ALG_TRUNCATED_MAC twice gives the length
* of the outer truncation (even if the outer length is smaller than
* the inner length). */
- TEST_EQUAL( PSA_ALG_TRUNCATED_MAC( truncated_alg, 1 ),
- PSA_ALG_TRUNCATED_MAC( alg, 1 ) );
- TEST_EQUAL( PSA_ALG_TRUNCATED_MAC( truncated_alg, length - 1 ),
- PSA_ALG_TRUNCATED_MAC( alg, length - 1) );
- TEST_EQUAL( PSA_ALG_TRUNCATED_MAC( truncated_alg, length ),
- PSA_ALG_TRUNCATED_MAC( alg, length ) );
+ TEST_EQUAL(PSA_ALG_TRUNCATED_MAC(truncated_alg, 1),
+ PSA_ALG_TRUNCATED_MAC(alg, 1));
+ TEST_EQUAL(PSA_ALG_TRUNCATED_MAC(truncated_alg, length - 1),
+ PSA_ALG_TRUNCATED_MAC(alg, length - 1));
+ TEST_EQUAL(PSA_ALG_TRUNCATED_MAC(truncated_alg, length),
+ PSA_ALG_TRUNCATED_MAC(alg, length));
/* Check that calling PSA_ALG_TRUNCATED_MAC on an algorithm
* earlier constructed with PSA_ALG_AT_LEAST_THIS_LENGTH_MAC gives the
* length of the outer truncation (even if the outer length is smaller
* than the inner length). */
- TEST_EQUAL( PSA_ALG_TRUNCATED_MAC(
- PSA_ALG_AT_LEAST_THIS_LENGTH_MAC( truncated_alg, n ), 1 ),
- PSA_ALG_TRUNCATED_MAC( alg, 1 ) );
- TEST_EQUAL( PSA_ALG_TRUNCATED_MAC(
- PSA_ALG_AT_LEAST_THIS_LENGTH_MAC( truncated_alg, n ), length - 1 ),
- PSA_ALG_TRUNCATED_MAC( alg, length - 1) );
- TEST_EQUAL( PSA_ALG_TRUNCATED_MAC(
- PSA_ALG_AT_LEAST_THIS_LENGTH_MAC( truncated_alg, n ), length ),
- PSA_ALG_TRUNCATED_MAC( alg, length ) );
+ TEST_EQUAL(PSA_ALG_TRUNCATED_MAC(
+ PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(truncated_alg, n), 1),
+ PSA_ALG_TRUNCATED_MAC(alg, 1));
+ TEST_EQUAL(PSA_ALG_TRUNCATED_MAC(
+ PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(truncated_alg, n), length - 1),
+ PSA_ALG_TRUNCATED_MAC(alg, length - 1));
+ TEST_EQUAL(PSA_ALG_TRUNCATED_MAC(
+ PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(truncated_alg, n), length),
+ PSA_ALG_TRUNCATED_MAC(alg, length));
}
/* At-leat-this-length versions */
- for( n = 1; n <= length; n++ )
- {
- psa_algorithm_t policy_alg = PSA_ALG_AT_LEAST_THIS_LENGTH_MAC( alg, n );
- mac_algorithm_core( policy_alg, classification_flags | ALG_IS_WILDCARD,
- key_type, key_bits, n );
- TEST_EQUAL( PSA_ALG_FULL_LENGTH_MAC( policy_alg ), alg );
+ for (n = 1; n <= length; n++) {
+ psa_algorithm_t policy_alg = PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(alg, n);
+ mac_algorithm_core(policy_alg, classification_flags | ALG_IS_WILDCARD,
+ key_type, key_bits, n);
+ TEST_EQUAL(PSA_ALG_FULL_LENGTH_MAC(policy_alg), alg);
/* Check that calling PSA_ALG_AT_LEAST_THIS_LENGTH_MAC twice gives the
* length of the outer truncation (even if the outer length is smaller
* than the inner length). */
- TEST_EQUAL( PSA_ALG_AT_LEAST_THIS_LENGTH_MAC( policy_alg, 1 ),
- PSA_ALG_AT_LEAST_THIS_LENGTH_MAC( alg, 1 ) );
- TEST_EQUAL( PSA_ALG_AT_LEAST_THIS_LENGTH_MAC( policy_alg, length - 1 ),
- PSA_ALG_AT_LEAST_THIS_LENGTH_MAC( alg, length - 1) );
- TEST_EQUAL( PSA_ALG_AT_LEAST_THIS_LENGTH_MAC( policy_alg, length ),
- PSA_ALG_AT_LEAST_THIS_LENGTH_MAC( alg, length ) );
+ TEST_EQUAL(PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(policy_alg, 1),
+ PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(alg, 1));
+ TEST_EQUAL(PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(policy_alg, length - 1),
+ PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(alg, length - 1));
+ TEST_EQUAL(PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(policy_alg, length),
+ PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(alg, length));
/* Check that calling PSA_ALG_AT_LEAST_THIS_LENGTH_MAC on an algorithm
* earlier constructed with PSA_ALG_TRUNCATED_MAC gives the length of
* the outer truncation (even if the outer length is smaller than the
* inner length). */
- TEST_EQUAL( PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(
- PSA_ALG_TRUNCATED_MAC( policy_alg, n ), 1),
- PSA_ALG_AT_LEAST_THIS_LENGTH_MAC( alg, 1 ) );
- TEST_EQUAL( PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(
- PSA_ALG_TRUNCATED_MAC( policy_alg, n ), length - 1 ),
- PSA_ALG_AT_LEAST_THIS_LENGTH_MAC( alg, length - 1) );
- TEST_EQUAL( PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(
- PSA_ALG_TRUNCATED_MAC( policy_alg, n ), length ),
- PSA_ALG_AT_LEAST_THIS_LENGTH_MAC( alg, length ) );
+ TEST_EQUAL(PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(
+ PSA_ALG_TRUNCATED_MAC(policy_alg, n), 1),
+ PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(alg, 1));
+ TEST_EQUAL(PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(
+ PSA_ALG_TRUNCATED_MAC(policy_alg, n), length - 1),
+ PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(alg, length - 1));
+ TEST_EQUAL(PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(
+ PSA_ALG_TRUNCATED_MAC(policy_alg, n), length),
+ PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(alg, length));
}
}
/* END_CASE */
/* BEGIN_CASE */
-void hmac_algorithm( int alg_arg,
- int length_arg,
- int block_size_arg )
+void hmac_algorithm(int alg_arg,
+ int length_arg,
+ int block_size_arg)
{
psa_algorithm_t alg = alg_arg;
- psa_algorithm_t hash_alg = PSA_ALG_HMAC_GET_HASH( alg );
+ psa_algorithm_t hash_alg = PSA_ALG_HMAC_GET_HASH(alg);
size_t block_size = block_size_arg;
size_t length = length_arg;
size_t n;
- TEST_ASSERT( PSA_ALG_IS_HASH( hash_alg ) );
- TEST_EQUAL( PSA_ALG_HMAC( hash_alg ), alg );
+ TEST_ASSERT(PSA_ALG_IS_HASH(hash_alg));
+ TEST_EQUAL(PSA_ALG_HMAC(hash_alg), alg);
- TEST_ASSERT( block_size == PSA_HASH_BLOCK_LENGTH( alg ) );
- TEST_ASSERT( block_size <= PSA_HMAC_MAX_HASH_BLOCK_SIZE );
+ TEST_ASSERT(block_size == PSA_HASH_BLOCK_LENGTH(alg));
+ TEST_ASSERT(block_size <= PSA_HMAC_MAX_HASH_BLOCK_SIZE);
- test_mac_algorithm( alg_arg, ALG_IS_HMAC, length,
- PSA_KEY_TYPE_HMAC, PSA_BYTES_TO_BITS( length ) );
+ test_mac_algorithm(alg_arg, ALG_IS_HMAC, length,
+ PSA_KEY_TYPE_HMAC, PSA_BYTES_TO_BITS(length));
- for( n = 1; n <= length; n++ )
- {
- psa_algorithm_t truncated_alg = PSA_ALG_TRUNCATED_MAC( alg, n );
- TEST_EQUAL( PSA_ALG_HMAC_GET_HASH( truncated_alg ), hash_alg );
+ for (n = 1; n <= length; n++) {
+ psa_algorithm_t truncated_alg = PSA_ALG_TRUNCATED_MAC(alg, n);
+ TEST_EQUAL(PSA_ALG_HMAC_GET_HASH(truncated_alg), hash_alg);
}
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_algorithm( int alg_arg, int classification_flags )
+void cipher_algorithm(int alg_arg, int classification_flags)
{
psa_algorithm_t alg = alg_arg;
/* Algorithm classification */
- TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
- TEST_ASSERT( PSA_ALG_IS_CIPHER( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
- algorithm_classification( alg, classification_flags );
+ TEST_ASSERT(!PSA_ALG_IS_HASH(alg));
+ TEST_ASSERT(!PSA_ALG_IS_MAC(alg));
+ TEST_ASSERT(PSA_ALG_IS_CIPHER(alg));
+ TEST_ASSERT(!PSA_ALG_IS_AEAD(alg));
+ TEST_ASSERT(!PSA_ALG_IS_SIGN(alg));
+ TEST_ASSERT(!PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg));
+ TEST_ASSERT(!PSA_ALG_IS_KEY_AGREEMENT(alg));
+ TEST_ASSERT(!PSA_ALG_IS_KEY_DERIVATION(alg));
+ algorithm_classification(alg, classification_flags);
}
/* END_CASE */
/* BEGIN_CASE */
-void aead_algorithm( int alg_arg, int classification_flags,
- int tag_length_arg,
- int key_type_arg, int key_bits_arg )
+void aead_algorithm(int alg_arg, int classification_flags,
+ int tag_length_arg,
+ int key_type_arg, int key_bits_arg)
{
psa_algorithm_t alg = alg_arg;
size_t tag_length = tag_length_arg;
@@ -423,102 +420,101 @@
psa_key_type_t key_type = key_type_arg;
size_t key_bits = key_bits_arg;
- aead_algorithm_core( alg, classification_flags,
- key_type, key_bits, tag_length );
+ aead_algorithm_core(alg, classification_flags,
+ key_type, key_bits, tag_length);
/* Truncated versions */
- for( n = 1; n <= tag_length; n++ )
- {
- psa_algorithm_t truncated_alg = PSA_ALG_AEAD_WITH_SHORTENED_TAG( alg, n );
- aead_algorithm_core( truncated_alg, classification_flags,
- key_type, key_bits, n );
- TEST_EQUAL( PSA_ALG_AEAD_WITH_DEFAULT_LENGTH_TAG( truncated_alg ),
- alg );
+ for (n = 1; n <= tag_length; n++) {
+ psa_algorithm_t truncated_alg = PSA_ALG_AEAD_WITH_SHORTENED_TAG(alg, n);
+ aead_algorithm_core(truncated_alg, classification_flags,
+ key_type, key_bits, n);
+ TEST_EQUAL(PSA_ALG_AEAD_WITH_DEFAULT_LENGTH_TAG(truncated_alg),
+ alg);
/* Check that calling PSA_ALG_AEAD_WITH_SHORTENED_TAG twice gives
* the length of the outer truncation (even if the outer length is
* smaller than the inner length). */
- TEST_EQUAL( PSA_ALG_AEAD_WITH_SHORTENED_TAG( truncated_alg, 1 ),
- PSA_ALG_AEAD_WITH_SHORTENED_TAG( alg, 1 ) );
- TEST_EQUAL( PSA_ALG_AEAD_WITH_SHORTENED_TAG( truncated_alg, tag_length - 1 ),
- PSA_ALG_AEAD_WITH_SHORTENED_TAG( alg, tag_length - 1) );
- TEST_EQUAL( PSA_ALG_AEAD_WITH_SHORTENED_TAG( truncated_alg, tag_length ),
- PSA_ALG_AEAD_WITH_SHORTENED_TAG( alg, tag_length ) );
+ TEST_EQUAL(PSA_ALG_AEAD_WITH_SHORTENED_TAG(truncated_alg, 1),
+ PSA_ALG_AEAD_WITH_SHORTENED_TAG(alg, 1));
+ TEST_EQUAL(PSA_ALG_AEAD_WITH_SHORTENED_TAG(truncated_alg, tag_length - 1),
+ PSA_ALG_AEAD_WITH_SHORTENED_TAG(alg, tag_length - 1));
+ TEST_EQUAL(PSA_ALG_AEAD_WITH_SHORTENED_TAG(truncated_alg, tag_length),
+ PSA_ALG_AEAD_WITH_SHORTENED_TAG(alg, tag_length));
/* Check that calling PSA_ALG_AEAD_WITH_SHORTENED_TAG on an algorithm
* earlier constructed with PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG
* gives the length of the outer truncation (even if the outer length is
* smaller than the inner length). */
- TEST_EQUAL( PSA_ALG_AEAD_WITH_SHORTENED_TAG(
- PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG( truncated_alg, n ), 1 ),
- PSA_ALG_AEAD_WITH_SHORTENED_TAG( alg, 1 ) );
- TEST_EQUAL( PSA_ALG_AEAD_WITH_SHORTENED_TAG(
- PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG( truncated_alg, n ), tag_length - 1 ),
- PSA_ALG_AEAD_WITH_SHORTENED_TAG( alg, tag_length - 1) );
- TEST_EQUAL( PSA_ALG_AEAD_WITH_SHORTENED_TAG(
- PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG( truncated_alg, n ), tag_length ),
- PSA_ALG_AEAD_WITH_SHORTENED_TAG( alg, tag_length ) );
+ TEST_EQUAL(PSA_ALG_AEAD_WITH_SHORTENED_TAG(
+ PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(truncated_alg, n), 1),
+ PSA_ALG_AEAD_WITH_SHORTENED_TAG(alg, 1));
+ TEST_EQUAL(PSA_ALG_AEAD_WITH_SHORTENED_TAG(
+ PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(truncated_alg,
+ n), tag_length - 1),
+ PSA_ALG_AEAD_WITH_SHORTENED_TAG(alg, tag_length - 1));
+ TEST_EQUAL(PSA_ALG_AEAD_WITH_SHORTENED_TAG(
+ PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(truncated_alg, n), tag_length),
+ PSA_ALG_AEAD_WITH_SHORTENED_TAG(alg, tag_length));
}
/* At-leat-this-length versions */
- for( n = 1; n <= tag_length; n++ )
- {
- psa_algorithm_t policy_alg = PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG( alg, n );
- aead_algorithm_core( policy_alg, classification_flags | ALG_IS_WILDCARD,
- key_type, key_bits, n );
- TEST_EQUAL( PSA_ALG_AEAD_WITH_DEFAULT_LENGTH_TAG( policy_alg ),
- alg );
+ for (n = 1; n <= tag_length; n++) {
+ psa_algorithm_t policy_alg = PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(alg, n);
+ aead_algorithm_core(policy_alg, classification_flags | ALG_IS_WILDCARD,
+ key_type, key_bits, n);
+ TEST_EQUAL(PSA_ALG_AEAD_WITH_DEFAULT_LENGTH_TAG(policy_alg),
+ alg);
/* Check that calling PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG twice
* gives the length of the outer truncation (even if the outer length is
* smaller than the inner length). */
- TEST_EQUAL( PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG( policy_alg, 1 ),
- PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG( alg, 1 ) );
- TEST_EQUAL( PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG( policy_alg, tag_length - 1 ),
- PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG( alg, tag_length - 1) );
- TEST_EQUAL( PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG( policy_alg, tag_length ),
- PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG( alg, tag_length ) );
+ TEST_EQUAL(PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(policy_alg, 1),
+ PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(alg, 1));
+ TEST_EQUAL(PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(policy_alg, tag_length - 1),
+ PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(alg, tag_length - 1));
+ TEST_EQUAL(PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(policy_alg, tag_length),
+ PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(alg, tag_length));
/* Check that calling PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG on an
* algorithm earlier constructed with PSA_ALG_AEAD_WITH_SHORTENED_TAG
* gives the length of the outer truncation (even if the outer length is
* smaller than the inner length). */
- TEST_EQUAL( PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(
- PSA_ALG_AEAD_WITH_SHORTENED_TAG( policy_alg, n ), 1),
- PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG( alg, 1 ) );
- TEST_EQUAL( PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(
- PSA_ALG_AEAD_WITH_SHORTENED_TAG( policy_alg, n ), tag_length - 1 ),
- PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG( alg, tag_length - 1) );
- TEST_EQUAL( PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(
- PSA_ALG_AEAD_WITH_SHORTENED_TAG( policy_alg, n ), tag_length ),
- PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG( alg, tag_length ) );
+ TEST_EQUAL(PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(
+ PSA_ALG_AEAD_WITH_SHORTENED_TAG(policy_alg, n), 1),
+ PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(alg, 1));
+ TEST_EQUAL(PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(
+ PSA_ALG_AEAD_WITH_SHORTENED_TAG(policy_alg, n), tag_length - 1),
+ PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(alg, tag_length - 1));
+ TEST_EQUAL(PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(
+ PSA_ALG_AEAD_WITH_SHORTENED_TAG(policy_alg, n), tag_length),
+ PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(alg, tag_length));
}
}
/* END_CASE */
/* BEGIN_CASE */
-void asymmetric_signature_algorithm( int alg_arg, int classification_flags )
+void asymmetric_signature_algorithm(int alg_arg, int classification_flags)
{
psa_algorithm_t alg = alg_arg;
/* Algorithm classification */
- TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
- TEST_ASSERT( PSA_ALG_IS_SIGN( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
- algorithm_classification( alg, classification_flags );
+ TEST_ASSERT(!PSA_ALG_IS_HASH(alg));
+ TEST_ASSERT(!PSA_ALG_IS_MAC(alg));
+ TEST_ASSERT(!PSA_ALG_IS_CIPHER(alg));
+ TEST_ASSERT(!PSA_ALG_IS_AEAD(alg));
+ TEST_ASSERT(PSA_ALG_IS_SIGN(alg));
+ TEST_ASSERT(!PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg));
+ TEST_ASSERT(!PSA_ALG_IS_KEY_AGREEMENT(alg));
+ TEST_ASSERT(!PSA_ALG_IS_KEY_DERIVATION(alg));
+ algorithm_classification(alg, classification_flags);
}
/* END_CASE */
/* BEGIN_CASE */
-void asymmetric_signature_wildcard( int alg_arg, int classification_flags )
+void asymmetric_signature_wildcard(int alg_arg, int classification_flags)
{
classification_flags |= ALG_IS_WILDCARD;
classification_flags |= ALG_IS_SIGN_HASH;
classification_flags |= ALG_IS_HASH_AND_SIGN;
- test_asymmetric_signature_algorithm( alg_arg, classification_flags );
+ test_asymmetric_signature_algorithm(alg_arg, classification_flags);
/* Any failure of this test function comes from
* asymmetric_signature_algorithm. Pacify -Werror=unused-label. */
goto exit;
@@ -526,175 +522,173 @@
/* END_CASE */
/* BEGIN_CASE */
-void asymmetric_encryption_algorithm( int alg_arg, int classification_flags )
+void asymmetric_encryption_algorithm(int alg_arg, int classification_flags)
{
psa_algorithm_t alg = alg_arg;
/* Algorithm classification */
- TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
- TEST_ASSERT( PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
- algorithm_classification( alg, classification_flags );
+ TEST_ASSERT(!PSA_ALG_IS_HASH(alg));
+ TEST_ASSERT(!PSA_ALG_IS_MAC(alg));
+ TEST_ASSERT(!PSA_ALG_IS_CIPHER(alg));
+ TEST_ASSERT(!PSA_ALG_IS_AEAD(alg));
+ TEST_ASSERT(!PSA_ALG_IS_SIGN(alg));
+ TEST_ASSERT(PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg));
+ TEST_ASSERT(!PSA_ALG_IS_KEY_AGREEMENT(alg));
+ TEST_ASSERT(!PSA_ALG_IS_KEY_DERIVATION(alg));
+ algorithm_classification(alg, classification_flags);
}
/* END_CASE */
/* BEGIN_CASE */
-void key_derivation_algorithm( int alg_arg, int classification_flags )
+void key_derivation_algorithm(int alg_arg, int classification_flags)
{
psa_algorithm_t alg = alg_arg;
- psa_algorithm_t ecdh_alg = PSA_ALG_KEY_AGREEMENT( PSA_ALG_ECDH, alg );
- psa_algorithm_t ffdh_alg = PSA_ALG_KEY_AGREEMENT( PSA_ALG_FFDH, alg );
+ psa_algorithm_t ecdh_alg = PSA_ALG_KEY_AGREEMENT(PSA_ALG_ECDH, alg);
+ psa_algorithm_t ffdh_alg = PSA_ALG_KEY_AGREEMENT(PSA_ALG_FFDH, alg);
/* Algorithm classification */
- TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_KEY_AGREEMENT( alg ) );
- TEST_ASSERT( PSA_ALG_IS_KEY_DERIVATION( alg ) );
- algorithm_classification( alg, classification_flags );
+ TEST_ASSERT(!PSA_ALG_IS_HASH(alg));
+ TEST_ASSERT(!PSA_ALG_IS_MAC(alg));
+ TEST_ASSERT(!PSA_ALG_IS_CIPHER(alg));
+ TEST_ASSERT(!PSA_ALG_IS_AEAD(alg));
+ TEST_ASSERT(!PSA_ALG_IS_SIGN(alg));
+ TEST_ASSERT(!PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg));
+ TEST_ASSERT(!PSA_ALG_IS_KEY_AGREEMENT(alg));
+ TEST_ASSERT(PSA_ALG_IS_KEY_DERIVATION(alg));
+ algorithm_classification(alg, classification_flags);
/* Check combinations with key agreements */
- TEST_ASSERT( PSA_ALG_IS_KEY_AGREEMENT( ecdh_alg ) );
- TEST_ASSERT( PSA_ALG_IS_KEY_AGREEMENT( ffdh_alg ) );
- TEST_EQUAL( PSA_ALG_KEY_AGREEMENT_GET_KDF( ecdh_alg ), alg );
- TEST_EQUAL( PSA_ALG_KEY_AGREEMENT_GET_KDF( ffdh_alg ), alg );
+ TEST_ASSERT(PSA_ALG_IS_KEY_AGREEMENT(ecdh_alg));
+ TEST_ASSERT(PSA_ALG_IS_KEY_AGREEMENT(ffdh_alg));
+ TEST_EQUAL(PSA_ALG_KEY_AGREEMENT_GET_KDF(ecdh_alg), alg);
+ TEST_EQUAL(PSA_ALG_KEY_AGREEMENT_GET_KDF(ffdh_alg), alg);
}
/* END_CASE */
/* BEGIN_CASE */
-void key_agreement_algorithm( int alg_arg, int classification_flags,
- int ka_alg_arg, int kdf_alg_arg )
+void key_agreement_algorithm(int alg_arg, int classification_flags,
+ int ka_alg_arg, int kdf_alg_arg)
{
psa_algorithm_t alg = alg_arg;
- psa_algorithm_t actual_ka_alg = PSA_ALG_KEY_AGREEMENT_GET_BASE( alg );
+ psa_algorithm_t actual_ka_alg = PSA_ALG_KEY_AGREEMENT_GET_BASE(alg);
psa_algorithm_t expected_ka_alg = ka_alg_arg;
- psa_algorithm_t actual_kdf_alg = PSA_ALG_KEY_AGREEMENT_GET_KDF( alg );
+ psa_algorithm_t actual_kdf_alg = PSA_ALG_KEY_AGREEMENT_GET_KDF(alg);
psa_algorithm_t expected_kdf_alg = kdf_alg_arg;
/* Algorithm classification */
- TEST_ASSERT( ! PSA_ALG_IS_HASH( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_MAC( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_CIPHER( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_AEAD( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_SIGN( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_ASYMMETRIC_ENCRYPTION( alg ) );
- TEST_ASSERT( PSA_ALG_IS_KEY_AGREEMENT( alg ) );
- TEST_ASSERT( ! PSA_ALG_IS_KEY_DERIVATION( alg ) );
- algorithm_classification( alg, classification_flags );
+ TEST_ASSERT(!PSA_ALG_IS_HASH(alg));
+ TEST_ASSERT(!PSA_ALG_IS_MAC(alg));
+ TEST_ASSERT(!PSA_ALG_IS_CIPHER(alg));
+ TEST_ASSERT(!PSA_ALG_IS_AEAD(alg));
+ TEST_ASSERT(!PSA_ALG_IS_SIGN(alg));
+ TEST_ASSERT(!PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg));
+ TEST_ASSERT(PSA_ALG_IS_KEY_AGREEMENT(alg));
+ TEST_ASSERT(!PSA_ALG_IS_KEY_DERIVATION(alg));
+ algorithm_classification(alg, classification_flags);
/* Shared secret derivation properties */
- TEST_EQUAL( actual_ka_alg, expected_ka_alg );
- TEST_EQUAL( actual_kdf_alg, expected_kdf_alg );
+ TEST_EQUAL(actual_ka_alg, expected_ka_alg);
+ TEST_EQUAL(actual_kdf_alg, expected_kdf_alg);
}
/* END_CASE */
/* BEGIN_CASE */
-void key_type( int type_arg, int classification_flags )
+void key_type(int type_arg, int classification_flags)
{
psa_key_type_t type = type_arg;
- key_type_classification( type, classification_flags );
+ key_type_classification(type, classification_flags);
/* For asymmetric types, check the corresponding pair/public type */
- if( classification_flags & KEY_TYPE_IS_PUBLIC_KEY )
- {
- psa_key_type_t pair_type = PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY( type );
- TEST_EQUAL( PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR( pair_type ), type );
- key_type_classification( pair_type,
- ( classification_flags
- & ~KEY_TYPE_IS_PUBLIC_KEY )
- | KEY_TYPE_IS_KEY_PAIR );
- TEST_EQUAL( PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR( type ), type );
+ if (classification_flags & KEY_TYPE_IS_PUBLIC_KEY) {
+ psa_key_type_t pair_type = PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY(type);
+ TEST_EQUAL(PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(pair_type), type);
+ key_type_classification(pair_type,
+ (classification_flags
+ & ~KEY_TYPE_IS_PUBLIC_KEY)
+ | KEY_TYPE_IS_KEY_PAIR);
+ TEST_EQUAL(PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(type), type);
}
- if( classification_flags & KEY_TYPE_IS_KEY_PAIR )
- {
- psa_key_type_t public_type = PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR( type );
- TEST_EQUAL( PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY( public_type ), type );
- key_type_classification( public_type,
- ( classification_flags
- & ~KEY_TYPE_IS_KEY_PAIR )
- | KEY_TYPE_IS_PUBLIC_KEY );
- TEST_EQUAL( PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY( type ), type );
+ if (classification_flags & KEY_TYPE_IS_KEY_PAIR) {
+ psa_key_type_t public_type = PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(type);
+ TEST_EQUAL(PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY(public_type), type);
+ key_type_classification(public_type,
+ (classification_flags
+ & ~KEY_TYPE_IS_KEY_PAIR)
+ | KEY_TYPE_IS_PUBLIC_KEY);
+ TEST_EQUAL(PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY(type), type);
}
}
/* END_CASE */
/* BEGIN_CASE */
-void block_cipher_key_type( int type_arg, int block_size_arg )
+void block_cipher_key_type(int type_arg, int block_size_arg)
{
psa_key_type_t type = type_arg;
size_t block_size = block_size_arg;
- test_key_type( type_arg, KEY_TYPE_IS_UNSTRUCTURED );
+ test_key_type(type_arg, KEY_TYPE_IS_UNSTRUCTURED);
- TEST_EQUAL( type & PSA_KEY_TYPE_CATEGORY_MASK,
- PSA_KEY_TYPE_CATEGORY_SYMMETRIC );
- TEST_EQUAL( PSA_BLOCK_CIPHER_BLOCK_LENGTH( type ), block_size );
+ TEST_EQUAL(type & PSA_KEY_TYPE_CATEGORY_MASK,
+ PSA_KEY_TYPE_CATEGORY_SYMMETRIC);
+ TEST_EQUAL(PSA_BLOCK_CIPHER_BLOCK_LENGTH(type), block_size);
/* Check that the block size is a power of 2. This is required, at least,
- for PSA_ROUND_UP_TO_MULTIPLE(block_size, length) in crypto_sizes.h. */
- TEST_ASSERT( ( ( block_size - 1 ) & block_size ) == 0 );
+ for PSA_ROUND_UP_TO_MULTIPLE(block_size, length) in crypto_sizes.h. */
+ TEST_ASSERT(((block_size - 1) & block_size) == 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void stream_cipher_key_type( int type_arg )
+void stream_cipher_key_type(int type_arg)
{
psa_key_type_t type = type_arg;
- test_key_type( type_arg, KEY_TYPE_IS_UNSTRUCTURED );
+ test_key_type(type_arg, KEY_TYPE_IS_UNSTRUCTURED);
- TEST_EQUAL( type & PSA_KEY_TYPE_CATEGORY_MASK,
- PSA_KEY_TYPE_CATEGORY_SYMMETRIC );
- TEST_EQUAL( PSA_BLOCK_CIPHER_BLOCK_LENGTH( type ), 1 );
+ TEST_EQUAL(type & PSA_KEY_TYPE_CATEGORY_MASK,
+ PSA_KEY_TYPE_CATEGORY_SYMMETRIC);
+ TEST_EQUAL(PSA_BLOCK_CIPHER_BLOCK_LENGTH(type), 1);
}
/* END_CASE */
/* BEGIN_CASE depends_on:PSA_KEY_TYPE_ECC_PUBLIC_KEY:PSA_KEY_TYPE_ECC_KEY_PAIR */
-void ecc_key_family( int curve_arg )
+void ecc_key_family(int curve_arg)
{
psa_ecc_family_t curve = curve_arg;
- psa_key_type_t public_type = PSA_KEY_TYPE_ECC_PUBLIC_KEY( curve );
- psa_key_type_t pair_type = PSA_KEY_TYPE_ECC_KEY_PAIR( curve );
+ psa_key_type_t public_type = PSA_KEY_TYPE_ECC_PUBLIC_KEY(curve);
+ psa_key_type_t pair_type = PSA_KEY_TYPE_ECC_KEY_PAIR(curve);
- TEST_PARITY( curve );
+ TEST_PARITY(curve);
- test_key_type( public_type, KEY_TYPE_IS_ECC | KEY_TYPE_IS_PUBLIC_KEY );
- test_key_type( pair_type, KEY_TYPE_IS_ECC | KEY_TYPE_IS_KEY_PAIR );
+ test_key_type(public_type, KEY_TYPE_IS_ECC | KEY_TYPE_IS_PUBLIC_KEY);
+ test_key_type(pair_type, KEY_TYPE_IS_ECC | KEY_TYPE_IS_KEY_PAIR);
- TEST_EQUAL( PSA_KEY_TYPE_ECC_GET_FAMILY( public_type ), curve );
- TEST_EQUAL( PSA_KEY_TYPE_ECC_GET_FAMILY( pair_type ), curve );
+ TEST_EQUAL(PSA_KEY_TYPE_ECC_GET_FAMILY(public_type), curve);
+ TEST_EQUAL(PSA_KEY_TYPE_ECC_GET_FAMILY(pair_type), curve);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_DHM_C */
-void dh_key_family( int group_arg )
+void dh_key_family(int group_arg)
{
psa_dh_family_t group = group_arg;
- psa_key_type_t public_type = PSA_KEY_TYPE_DH_PUBLIC_KEY( group );
- psa_key_type_t pair_type = PSA_KEY_TYPE_DH_KEY_PAIR( group );
+ psa_key_type_t public_type = PSA_KEY_TYPE_DH_PUBLIC_KEY(group);
+ psa_key_type_t pair_type = PSA_KEY_TYPE_DH_KEY_PAIR(group);
- TEST_PARITY( group );
+ TEST_PARITY(group);
- test_key_type( public_type, KEY_TYPE_IS_DH | KEY_TYPE_IS_PUBLIC_KEY );
- test_key_type( pair_type, KEY_TYPE_IS_DH | KEY_TYPE_IS_KEY_PAIR );
+ test_key_type(public_type, KEY_TYPE_IS_DH | KEY_TYPE_IS_PUBLIC_KEY);
+ test_key_type(pair_type, KEY_TYPE_IS_DH | KEY_TYPE_IS_KEY_PAIR);
- TEST_EQUAL( PSA_KEY_TYPE_DH_GET_FAMILY( public_type ), group );
- TEST_EQUAL( PSA_KEY_TYPE_DH_GET_FAMILY( pair_type ), group );
+ TEST_EQUAL(PSA_KEY_TYPE_DH_GET_FAMILY(public_type), group);
+ TEST_EQUAL(PSA_KEY_TYPE_DH_GET_FAMILY(pair_type), group);
}
/* END_CASE */
/* BEGIN_CASE */
-void lifetime( int lifetime_arg, int classification_flags,
- int persistence_arg, int location_arg )
+void lifetime(int lifetime_arg, int classification_flags,
+ int persistence_arg, int location_arg)
{
psa_key_lifetime_t lifetime = lifetime_arg;
psa_key_persistence_t persistence = persistence_arg;
@@ -702,12 +696,12 @@
unsigned flags = classification_flags;
unsigned classification_flags_tested = 0;
- TEST_CLASSIFICATION_MACRO( 1, KEY_LIFETIME_IS_VOLATILE, lifetime, flags );
- TEST_CLASSIFICATION_MACRO( 1, KEY_LIFETIME_IS_READ_ONLY, lifetime, flags );
- TEST_EQUAL( classification_flags_tested,
- KEY_LIFETIME_FLAG_MASK_PLUS_ONE - 1 );
+ TEST_CLASSIFICATION_MACRO(1, KEY_LIFETIME_IS_VOLATILE, lifetime, flags);
+ TEST_CLASSIFICATION_MACRO(1, KEY_LIFETIME_IS_READ_ONLY, lifetime, flags);
+ TEST_EQUAL(classification_flags_tested,
+ KEY_LIFETIME_FLAG_MASK_PLUS_ONE - 1);
- TEST_EQUAL( PSA_KEY_LIFETIME_GET_PERSISTENCE( lifetime ), persistence );
- TEST_EQUAL( PSA_KEY_LIFETIME_GET_LOCATION( lifetime ), location );
+ TEST_EQUAL(PSA_KEY_LIFETIME_GET_PERSISTENCE(lifetime), persistence);
+ TEST_EQUAL(PSA_KEY_LIFETIME_GET_LOCATION(lifetime), location);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto_not_supported.function b/tests/suites/test_suite_psa_crypto_not_supported.function
index e3253d8..e5e66f4 100644
--- a/tests/suites/test_suite_psa_crypto_not_supported.function
+++ b/tests/suites/test_suite_psa_crypto_not_supported.function
@@ -3,7 +3,7 @@
#include "psa/crypto.h"
#include "test/psa_crypto_helpers.h"
-#define INVALID_KEY_ID mbedtls_svc_key_id_make( 0, 0xfedcba98 )
+#define INVALID_KEY_ID mbedtls_svc_key_id_make(0, 0xfedcba98)
/* END_HEADER */
@@ -13,40 +13,40 @@
*/
/* BEGIN_CASE */
-void import_not_supported( int key_type, data_t *key_material )
+void import_not_supported(int key_type, data_t *key_material)
{
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_svc_key_id_t key_id = INVALID_KEY_ID;
- PSA_ASSERT( psa_crypto_init( ) );
- psa_set_key_type( &attributes, key_type );
- TEST_EQUAL( psa_import_key( &attributes,
- key_material->x, key_material->len,
- &key_id ),
- PSA_ERROR_NOT_SUPPORTED );
- TEST_ASSERT( mbedtls_svc_key_id_equal( key_id, MBEDTLS_SVC_KEY_ID_INIT ) );
+ PSA_ASSERT(psa_crypto_init());
+ psa_set_key_type(&attributes, key_type);
+ TEST_EQUAL(psa_import_key(&attributes,
+ key_material->x, key_material->len,
+ &key_id),
+ PSA_ERROR_NOT_SUPPORTED);
+ TEST_ASSERT(mbedtls_svc_key_id_equal(key_id, MBEDTLS_SVC_KEY_ID_INIT));
exit:
- psa_destroy_key( key_id );
- PSA_DONE( );
+ psa_destroy_key(key_id);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void generate_not_supported( int key_type, int bits )
+void generate_not_supported(int key_type, int bits)
{
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_svc_key_id_t key_id = INVALID_KEY_ID;
- PSA_ASSERT( psa_crypto_init( ) );
- psa_set_key_type( &attributes, key_type );
- psa_set_key_bits( &attributes, bits );
- TEST_EQUAL( psa_generate_key( &attributes, &key_id ),
- PSA_ERROR_NOT_SUPPORTED );
- TEST_ASSERT( mbedtls_svc_key_id_equal( key_id, MBEDTLS_SVC_KEY_ID_INIT ) );
+ PSA_ASSERT(psa_crypto_init());
+ psa_set_key_type(&attributes, key_type);
+ psa_set_key_bits(&attributes, bits);
+ TEST_EQUAL(psa_generate_key(&attributes, &key_id),
+ PSA_ERROR_NOT_SUPPORTED);
+ TEST_ASSERT(mbedtls_svc_key_id_equal(key_id, MBEDTLS_SVC_KEY_ID_INIT));
exit:
- psa_destroy_key( key_id );
- PSA_DONE( );
+ psa_destroy_key(key_id);
+ PSA_DONE();
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto_op_fail.function b/tests/suites/test_suite_psa_crypto_op_fail.function
index 1138e74..0d5d538 100644
--- a/tests/suites/test_suite_psa_crypto_op_fail.function
+++ b/tests/suites/test_suite_psa_crypto_op_fail.function
@@ -3,19 +3,18 @@
#include "psa/crypto.h"
#include "test/psa_crypto_helpers.h"
-static int test_equal_status( const char *test,
- int line_no, const char* filename,
- psa_status_t value1,
- psa_status_t value2 )
+static int test_equal_status(const char *test,
+ int line_no, const char *filename,
+ psa_status_t value1,
+ psa_status_t value2)
{
- if( ( value1 == PSA_ERROR_INVALID_ARGUMENT &&
- value2 == PSA_ERROR_NOT_SUPPORTED ) ||
- ( value1 == PSA_ERROR_NOT_SUPPORTED &&
- value2 == PSA_ERROR_INVALID_ARGUMENT ) )
- {
- return( 1 );
+ if ((value1 == PSA_ERROR_INVALID_ARGUMENT &&
+ value2 == PSA_ERROR_NOT_SUPPORTED) ||
+ (value1 == PSA_ERROR_NOT_SUPPORTED &&
+ value2 == PSA_ERROR_INVALID_ARGUMENT)) {
+ return 1;
}
- return( mbedtls_test_equal( test, line_no, filename, value1, value2 ) );
+ return mbedtls_test_equal(test, line_no, filename, value1, value2);
}
/** Like #TEST_EQUAL, but expects #psa_status_t values and treats
@@ -28,12 +27,12 @@
* run, it would be better to clarify the expectations and reconcile the
* library and the test case generator.
*/
-#define TEST_STATUS( expr1, expr2 ) \
+#define TEST_STATUS(expr1, expr2) \
do { \
- if( ! test_equal_status( #expr1 " == " #expr2, __LINE__, __FILE__, \
- expr1, expr2 ) ) \
- goto exit; \
- } while( 0 )
+ if (!test_equal_status( #expr1 " == " #expr2, __LINE__, __FILE__, \
+ expr1, expr2)) \
+ goto exit; \
+ } while (0)
/* END_HEADER */
@@ -43,35 +42,35 @@
*/
/* BEGIN_CASE */
-void hash_fail( int alg_arg, int expected_status_arg )
+void hash_fail(int alg_arg, int expected_status_arg)
{
psa_status_t expected_status = expected_status_arg;
psa_algorithm_t alg = alg_arg;
psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
- uint8_t input[1] = {'A'};
- uint8_t output[PSA_HASH_MAX_SIZE] = {0};
+ uint8_t input[1] = { 'A' };
+ uint8_t output[PSA_HASH_MAX_SIZE] = { 0 };
size_t length = SIZE_MAX;
- PSA_INIT( );
+ PSA_INIT();
- TEST_EQUAL( expected_status,
- psa_hash_setup( &operation, alg ) );
- TEST_EQUAL( expected_status,
- psa_hash_compute( alg, input, sizeof( input ),
- output, sizeof( output ), &length ) );
- TEST_EQUAL( expected_status,
- psa_hash_compare( alg, input, sizeof( input ),
- output, sizeof( output ) ) );
+ TEST_EQUAL(expected_status,
+ psa_hash_setup(&operation, alg));
+ TEST_EQUAL(expected_status,
+ psa_hash_compute(alg, input, sizeof(input),
+ output, sizeof(output), &length));
+ TEST_EQUAL(expected_status,
+ psa_hash_compare(alg, input, sizeof(input),
+ output, sizeof(output)));
exit:
- psa_hash_abort( &operation );
- PSA_DONE( );
+ psa_hash_abort(&operation);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void mac_fail( int key_type_arg, data_t *key_data,
- int alg_arg, int expected_status_arg )
+void mac_fail(int key_type_arg, data_t *key_data,
+ int alg_arg, int expected_status_arg)
{
psa_status_t expected_status = expected_status_arg;
psa_key_type_t key_type = key_type_arg;
@@ -79,45 +78,45 @@
psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
- uint8_t input[1] = {'A'};
- uint8_t output[PSA_MAC_MAX_SIZE] = {0};
+ uint8_t input[1] = { 'A' };
+ uint8_t output[PSA_MAC_MAX_SIZE] = { 0 };
size_t length = SIZE_MAX;
- PSA_INIT( );
+ PSA_INIT();
- psa_set_key_type( &attributes, key_type );
- psa_set_key_usage_flags( &attributes,
- PSA_KEY_USAGE_SIGN_HASH |
- PSA_KEY_USAGE_VERIFY_HASH );
- psa_set_key_algorithm( &attributes, alg );
- PSA_ASSERT( psa_import_key( &attributes,
- key_data->x, key_data->len,
- &key_id ) );
+ psa_set_key_type(&attributes, key_type);
+ psa_set_key_usage_flags(&attributes,
+ PSA_KEY_USAGE_SIGN_HASH |
+ PSA_KEY_USAGE_VERIFY_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ PSA_ASSERT(psa_import_key(&attributes,
+ key_data->x, key_data->len,
+ &key_id));
- TEST_STATUS( expected_status,
- psa_mac_sign_setup( &operation, key_id, alg ) );
- TEST_STATUS( expected_status,
- psa_mac_verify_setup( &operation, key_id, alg ) );
- TEST_STATUS( expected_status,
- psa_mac_compute( key_id, alg,
- input, sizeof( input ),
- output, sizeof( output ), &length ) );
- TEST_STATUS( expected_status,
- psa_mac_verify( key_id, alg,
- input, sizeof( input ),
- output, sizeof( output ) ) );
+ TEST_STATUS(expected_status,
+ psa_mac_sign_setup(&operation, key_id, alg));
+ TEST_STATUS(expected_status,
+ psa_mac_verify_setup(&operation, key_id, alg));
+ TEST_STATUS(expected_status,
+ psa_mac_compute(key_id, alg,
+ input, sizeof(input),
+ output, sizeof(output), &length));
+ TEST_STATUS(expected_status,
+ psa_mac_verify(key_id, alg,
+ input, sizeof(input),
+ output, sizeof(output)));
exit:
- psa_mac_abort( &operation );
- psa_destroy_key( key_id );
- psa_reset_key_attributes( &attributes );
- PSA_DONE( );
+ psa_mac_abort(&operation);
+ psa_destroy_key(key_id);
+ psa_reset_key_attributes(&attributes);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void cipher_fail( int key_type_arg, data_t *key_data,
- int alg_arg, int expected_status_arg )
+void cipher_fail(int key_type_arg, data_t *key_data,
+ int alg_arg, int expected_status_arg)
{
psa_status_t expected_status = expected_status_arg;
psa_key_type_t key_type = key_type_arg;
@@ -125,45 +124,45 @@
psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
- uint8_t input[1] = {'A'};
- uint8_t output[64] = {0};
+ uint8_t input[1] = { 'A' };
+ uint8_t output[64] = { 0 };
size_t length = SIZE_MAX;
- PSA_INIT( );
+ PSA_INIT();
- psa_set_key_type( &attributes, key_type );
- psa_set_key_usage_flags( &attributes,
- PSA_KEY_USAGE_ENCRYPT |
- PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- PSA_ASSERT( psa_import_key( &attributes,
- key_data->x, key_data->len,
- &key_id ) );
+ psa_set_key_type(&attributes, key_type);
+ psa_set_key_usage_flags(&attributes,
+ PSA_KEY_USAGE_ENCRYPT |
+ PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ PSA_ASSERT(psa_import_key(&attributes,
+ key_data->x, key_data->len,
+ &key_id));
- TEST_STATUS( expected_status,
- psa_cipher_encrypt_setup( &operation, key_id, alg ) );
- TEST_STATUS( expected_status,
- psa_cipher_decrypt_setup( &operation, key_id, alg ) );
- TEST_STATUS( expected_status,
- psa_cipher_encrypt( key_id, alg,
- input, sizeof( input ),
- output, sizeof( output ), &length ) );
- TEST_STATUS( expected_status,
- psa_cipher_decrypt( key_id, alg,
- input, sizeof( input ),
- output, sizeof( output ), &length ) );
+ TEST_STATUS(expected_status,
+ psa_cipher_encrypt_setup(&operation, key_id, alg));
+ TEST_STATUS(expected_status,
+ psa_cipher_decrypt_setup(&operation, key_id, alg));
+ TEST_STATUS(expected_status,
+ psa_cipher_encrypt(key_id, alg,
+ input, sizeof(input),
+ output, sizeof(output), &length));
+ TEST_STATUS(expected_status,
+ psa_cipher_decrypt(key_id, alg,
+ input, sizeof(input),
+ output, sizeof(output), &length));
exit:
- psa_cipher_abort( &operation );
- psa_destroy_key( key_id );
- psa_reset_key_attributes( &attributes );
- PSA_DONE( );
+ psa_cipher_abort(&operation);
+ psa_destroy_key(key_id);
+ psa_reset_key_attributes(&attributes);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void aead_fail( int key_type_arg, data_t *key_data,
- int alg_arg, int expected_status_arg )
+void aead_fail(int key_type_arg, data_t *key_data,
+ int alg_arg, int expected_status_arg)
{
psa_status_t expected_status = expected_status_arg;
psa_key_type_t key_type = key_type_arg;
@@ -171,214 +170,212 @@
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
uint8_t input[16] = "ABCDEFGHIJKLMNO";
- uint8_t output[64] = {0};
+ uint8_t output[64] = { 0 };
size_t length = SIZE_MAX;
- PSA_INIT( );
+ PSA_INIT();
- psa_set_key_type( &attributes, key_type );
- psa_set_key_usage_flags( &attributes,
- PSA_KEY_USAGE_ENCRYPT |
- PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- PSA_ASSERT( psa_import_key( &attributes,
- key_data->x, key_data->len,
- &key_id ) );
+ psa_set_key_type(&attributes, key_type);
+ psa_set_key_usage_flags(&attributes,
+ PSA_KEY_USAGE_ENCRYPT |
+ PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ PSA_ASSERT(psa_import_key(&attributes,
+ key_data->x, key_data->len,
+ &key_id));
- TEST_STATUS( expected_status,
- psa_aead_encrypt( key_id, alg,
- input, sizeof( input ),
- NULL, 0, input, sizeof( input ),
- output, sizeof( output ), &length ) );
- TEST_STATUS( expected_status,
- psa_aead_decrypt( key_id, alg,
- input, sizeof( input ),
- NULL, 0, input, sizeof( input ),
- output, sizeof( output ), &length ) );
+ TEST_STATUS(expected_status,
+ psa_aead_encrypt(key_id, alg,
+ input, sizeof(input),
+ NULL, 0, input, sizeof(input),
+ output, sizeof(output), &length));
+ TEST_STATUS(expected_status,
+ psa_aead_decrypt(key_id, alg,
+ input, sizeof(input),
+ NULL, 0, input, sizeof(input),
+ output, sizeof(output), &length));
exit:
- psa_destroy_key( key_id );
- psa_reset_key_attributes( &attributes );
- PSA_DONE( );
+ psa_destroy_key(key_id);
+ psa_reset_key_attributes(&attributes);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void sign_fail( int key_type_arg, data_t *key_data,
- int alg_arg, int private_only,
- int expected_status_arg )
+void sign_fail(int key_type_arg, data_t *key_data,
+ int alg_arg, int private_only,
+ int expected_status_arg)
{
psa_status_t expected_status = expected_status_arg;
psa_key_type_t key_type = key_type_arg;
psa_algorithm_t alg = alg_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
- uint8_t input[1] = {'A'};
- uint8_t output[PSA_SIGNATURE_MAX_SIZE] = {0};
+ uint8_t input[1] = { 'A' };
+ uint8_t output[PSA_SIGNATURE_MAX_SIZE] = { 0 };
size_t length = SIZE_MAX;
- PSA_INIT( );
+ PSA_INIT();
- psa_set_key_type( &attributes, key_type );
- psa_set_key_usage_flags( &attributes,
- PSA_KEY_USAGE_SIGN_HASH |
- PSA_KEY_USAGE_VERIFY_HASH );
- psa_set_key_algorithm( &attributes, alg );
- PSA_ASSERT( psa_import_key( &attributes,
- key_data->x, key_data->len,
- &key_id ) );
+ psa_set_key_type(&attributes, key_type);
+ psa_set_key_usage_flags(&attributes,
+ PSA_KEY_USAGE_SIGN_HASH |
+ PSA_KEY_USAGE_VERIFY_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ PSA_ASSERT(psa_import_key(&attributes,
+ key_data->x, key_data->len,
+ &key_id));
- TEST_STATUS( expected_status,
- psa_sign_hash( key_id, alg,
- input, sizeof( input ),
- output, sizeof( output ), &length ) );
- if( ! private_only )
- {
+ TEST_STATUS(expected_status,
+ psa_sign_hash(key_id, alg,
+ input, sizeof(input),
+ output, sizeof(output), &length));
+ if (!private_only) {
/* Determine a plausible signature size to avoid an INVALID_SIGNATURE
* error based on this. */
- PSA_ASSERT( psa_get_key_attributes( key_id, &attributes ) );
- size_t key_bits = psa_get_key_bits( &attributes );
- size_t output_length = sizeof( output );
- if( PSA_KEY_TYPE_IS_RSA( key_type ) )
- output_length = PSA_BITS_TO_BYTES( key_bits );
- else if( PSA_KEY_TYPE_IS_ECC( key_type ) )
- output_length = 2 * PSA_BITS_TO_BYTES( key_bits );
- TEST_ASSERT( output_length <= sizeof( output ) );
- TEST_STATUS( expected_status,
- psa_verify_hash( key_id, alg,
- input, sizeof( input ),
- output, output_length ) );
+ PSA_ASSERT(psa_get_key_attributes(key_id, &attributes));
+ size_t key_bits = psa_get_key_bits(&attributes);
+ size_t output_length = sizeof(output);
+ if (PSA_KEY_TYPE_IS_RSA(key_type)) {
+ output_length = PSA_BITS_TO_BYTES(key_bits);
+ } else if (PSA_KEY_TYPE_IS_ECC(key_type)) {
+ output_length = 2 * PSA_BITS_TO_BYTES(key_bits);
+ }
+ TEST_ASSERT(output_length <= sizeof(output));
+ TEST_STATUS(expected_status,
+ psa_verify_hash(key_id, alg,
+ input, sizeof(input),
+ output, output_length));
}
exit:
- psa_destroy_key( key_id );
- psa_reset_key_attributes( &attributes );
- PSA_DONE( );
+ psa_destroy_key(key_id);
+ psa_reset_key_attributes(&attributes);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void asymmetric_encryption_fail( int key_type_arg, data_t *key_data,
- int alg_arg, int private_only,
- int expected_status_arg )
+void asymmetric_encryption_fail(int key_type_arg, data_t *key_data,
+ int alg_arg, int private_only,
+ int expected_status_arg)
{
psa_status_t expected_status = expected_status_arg;
psa_key_type_t key_type = key_type_arg;
psa_algorithm_t alg = alg_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
- uint8_t plaintext[PSA_ASYMMETRIC_DECRYPT_OUTPUT_MAX_SIZE] = {0};
- uint8_t ciphertext[PSA_ASYMMETRIC_ENCRYPT_OUTPUT_MAX_SIZE] = {0};
+ uint8_t plaintext[PSA_ASYMMETRIC_DECRYPT_OUTPUT_MAX_SIZE] = { 0 };
+ uint8_t ciphertext[PSA_ASYMMETRIC_ENCRYPT_OUTPUT_MAX_SIZE] = { 0 };
size_t length = SIZE_MAX;
- PSA_INIT( );
+ PSA_INIT();
- psa_set_key_type( &attributes, key_type );
- psa_set_key_usage_flags( &attributes,
- PSA_KEY_USAGE_ENCRYPT |
- PSA_KEY_USAGE_DECRYPT );
- psa_set_key_algorithm( &attributes, alg );
- PSA_ASSERT( psa_import_key( &attributes,
- key_data->x, key_data->len,
- &key_id ) );
+ psa_set_key_type(&attributes, key_type);
+ psa_set_key_usage_flags(&attributes,
+ PSA_KEY_USAGE_ENCRYPT |
+ PSA_KEY_USAGE_DECRYPT);
+ psa_set_key_algorithm(&attributes, alg);
+ PSA_ASSERT(psa_import_key(&attributes,
+ key_data->x, key_data->len,
+ &key_id));
- if( ! private_only )
- {
- TEST_STATUS( expected_status,
- psa_asymmetric_encrypt( key_id, alg,
- plaintext, 1,
- NULL, 0,
- ciphertext, sizeof( ciphertext ),
- &length ) );
+ if (!private_only) {
+ TEST_STATUS(expected_status,
+ psa_asymmetric_encrypt(key_id, alg,
+ plaintext, 1,
+ NULL, 0,
+ ciphertext, sizeof(ciphertext),
+ &length));
}
- TEST_STATUS( expected_status,
- psa_asymmetric_decrypt( key_id, alg,
- ciphertext, sizeof( ciphertext ),
- NULL, 0,
- plaintext, sizeof( plaintext ),
- &length ) );
+ TEST_STATUS(expected_status,
+ psa_asymmetric_decrypt(key_id, alg,
+ ciphertext, sizeof(ciphertext),
+ NULL, 0,
+ plaintext, sizeof(plaintext),
+ &length));
exit:
- psa_destroy_key( key_id );
- psa_reset_key_attributes( &attributes );
- PSA_DONE( );
+ psa_destroy_key(key_id);
+ psa_reset_key_attributes(&attributes);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void key_derivation_fail( int alg_arg, int expected_status_arg )
+void key_derivation_fail(int alg_arg, int expected_status_arg)
{
psa_status_t expected_status = expected_status_arg;
psa_algorithm_t alg = alg_arg;
psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
- PSA_INIT( );
+ PSA_INIT();
- TEST_EQUAL( expected_status,
- psa_key_derivation_setup( &operation, alg ) );
+ TEST_EQUAL(expected_status,
+ psa_key_derivation_setup(&operation, alg));
exit:
- psa_key_derivation_abort( &operation );
- PSA_DONE( );
+ psa_key_derivation_abort(&operation);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void key_agreement_fail( int key_type_arg, data_t *key_data,
- int alg_arg, int private_only,
- int expected_status_arg )
+void key_agreement_fail(int key_type_arg, data_t *key_data,
+ int alg_arg, int private_only,
+ int expected_status_arg)
{
psa_status_t expected_status = expected_status_arg;
psa_key_type_t key_type = key_type_arg;
psa_algorithm_t alg = alg_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
- uint8_t public_key[PSA_EXPORT_PUBLIC_KEY_MAX_SIZE] = {0};
+ uint8_t public_key[PSA_EXPORT_PUBLIC_KEY_MAX_SIZE] = { 0 };
size_t public_key_length = SIZE_MAX;
- uint8_t output[PSA_SIGNATURE_MAX_SIZE] = {0};
+ uint8_t output[PSA_SIGNATURE_MAX_SIZE] = { 0 };
size_t length = SIZE_MAX;
psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
- PSA_INIT( );
+ PSA_INIT();
- psa_set_key_type( &attributes, key_type );
- psa_set_key_usage_flags( &attributes,
- PSA_KEY_USAGE_DERIVE );
- psa_set_key_algorithm( &attributes, alg );
- PSA_ASSERT( psa_import_key( &attributes,
- key_data->x, key_data->len,
- &key_id ) );
- if( PSA_KEY_TYPE_IS_KEY_PAIR( key_type ) ||
- PSA_KEY_TYPE_IS_PUBLIC_KEY( key_type ) )
- {
- PSA_ASSERT( psa_export_public_key( key_id,
- public_key, sizeof( public_key ),
- &public_key_length ) );
+ psa_set_key_type(&attributes, key_type);
+ psa_set_key_usage_flags(&attributes,
+ PSA_KEY_USAGE_DERIVE);
+ psa_set_key_algorithm(&attributes, alg);
+ PSA_ASSERT(psa_import_key(&attributes,
+ key_data->x, key_data->len,
+ &key_id));
+ if (PSA_KEY_TYPE_IS_KEY_PAIR(key_type) ||
+ PSA_KEY_TYPE_IS_PUBLIC_KEY(key_type)) {
+ PSA_ASSERT(psa_export_public_key(key_id,
+ public_key, sizeof(public_key),
+ &public_key_length));
}
- TEST_STATUS( expected_status,
- psa_raw_key_agreement( alg, key_id,
- public_key, public_key_length,
- output, sizeof( output ), &length ) );
+ TEST_STATUS(expected_status,
+ psa_raw_key_agreement(alg, key_id,
+ public_key, public_key_length,
+ output, sizeof(output), &length));
#if defined(PSA_WANT_ALG_HKDF) && defined(PSA_WANT_ALG_SHA_256)
- PSA_ASSERT( psa_key_derivation_setup( &operation,
- PSA_ALG_HKDF( PSA_ALG_SHA_256 ) ) );
- TEST_STATUS( expected_status,
- psa_key_derivation_key_agreement(
- &operation,
- PSA_KEY_DERIVATION_INPUT_SECRET,
- key_id,
- public_key, public_key_length ) );
+ PSA_ASSERT(psa_key_derivation_setup(&operation,
+ PSA_ALG_HKDF(PSA_ALG_SHA_256)));
+ TEST_STATUS(expected_status,
+ psa_key_derivation_key_agreement(
+ &operation,
+ PSA_KEY_DERIVATION_INPUT_SECRET,
+ key_id,
+ public_key, public_key_length));
#endif
/* There are no public-key operations. */
(void) private_only;
exit:
- psa_key_derivation_abort( &operation );
- psa_destroy_key( key_id );
- psa_reset_key_attributes( &attributes );
- PSA_DONE( );
+ psa_key_derivation_abort(&operation);
+ psa_destroy_key(key_id);
+ psa_reset_key_attributes(&attributes);
+ PSA_DONE();
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto_persistent_key.function b/tests/suites/test_suite_psa_crypto_persistent_key.function
index 08db34a..db99d79 100644
--- a/tests/suites/test_suite_psa_crypto_persistent_key.function
+++ b/tests/suites/test_suite_psa_crypto_persistent_key.function
@@ -20,7 +20,7 @@
#include "mbedtls/md.h"
#define PSA_KEY_STORAGE_MAGIC_HEADER "PSA\0KEY"
-#define PSA_KEY_STORAGE_MAGIC_HEADER_LENGTH ( sizeof( PSA_KEY_STORAGE_MAGIC_HEADER ) )
+#define PSA_KEY_STORAGE_MAGIC_HEADER_LENGTH (sizeof(PSA_KEY_STORAGE_MAGIC_HEADER))
/* Enforce the storage format for keys. The storage format is not a public
* documented interface, but it must be preserved between versions so that
@@ -29,9 +29,9 @@
typedef struct {
uint8_t magic[PSA_KEY_STORAGE_MAGIC_HEADER_LENGTH];
uint8_t version[4];
- uint8_t lifetime[sizeof( psa_key_lifetime_t )];
+ uint8_t lifetime[sizeof(psa_key_lifetime_t)];
uint8_t type[4];
- uint8_t policy[sizeof( psa_key_policy_t )];
+ uint8_t policy[sizeof(psa_key_policy_t)];
uint8_t data_len[4];
uint8_t key_data[];
} psa_persistent_key_storage_format;
@@ -44,223 +44,222 @@
*/
/* BEGIN_CASE */
-void format_storage_data_check( data_t *key_data,
- data_t *expected_file_data,
- int key_lifetime, int key_type, int key_bits,
- int key_usage, int key_alg, int key_alg2 )
+void format_storage_data_check(data_t *key_data,
+ data_t *expected_file_data,
+ int key_lifetime, int key_type, int key_bits,
+ int key_usage, int key_alg, int key_alg2)
{
uint8_t *file_data = NULL;
size_t file_data_length =
- key_data->len + sizeof( psa_persistent_key_storage_format );
+ key_data->len + sizeof(psa_persistent_key_storage_format);
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- psa_set_key_lifetime( &attributes, key_lifetime );
- psa_set_key_type( &attributes, key_type );
- psa_set_key_bits( &attributes, key_bits );
- psa_set_key_usage_flags( &attributes, key_usage );
- psa_set_key_algorithm( &attributes, key_alg );
- psa_set_key_enrollment_algorithm( &attributes, key_alg2 );
+ psa_set_key_lifetime(&attributes, key_lifetime);
+ psa_set_key_type(&attributes, key_type);
+ psa_set_key_bits(&attributes, key_bits);
+ psa_set_key_usage_flags(&attributes, key_usage);
+ psa_set_key_algorithm(&attributes, key_alg);
+ psa_set_key_enrollment_algorithm(&attributes, key_alg2);
- ASSERT_ALLOC( file_data, file_data_length );
- psa_format_key_data_for_storage( key_data->x, key_data->len,
- &attributes.core,
- file_data );
+ ASSERT_ALLOC(file_data, file_data_length);
+ psa_format_key_data_for_storage(key_data->x, key_data->len,
+ &attributes.core,
+ file_data);
- ASSERT_COMPARE( expected_file_data->x, expected_file_data->len,
- file_data, file_data_length );
+ ASSERT_COMPARE(expected_file_data->x, expected_file_data->len,
+ file_data, file_data_length);
exit:
- mbedtls_free( file_data );
+ mbedtls_free(file_data);
}
/* END_CASE */
/* BEGIN_CASE */
-void parse_storage_data_check( data_t *file_data,
- data_t *expected_key_data,
- int expected_key_lifetime,
- int expected_key_type,
- int expected_key_bits,
- int expected_key_usage,
- int expected_key_alg,
- int expected_key_alg2,
- int expected_status )
+void parse_storage_data_check(data_t *file_data,
+ data_t *expected_key_data,
+ int expected_key_lifetime,
+ int expected_key_type,
+ int expected_key_bits,
+ int expected_key_usage,
+ int expected_key_alg,
+ int expected_key_alg2,
+ int expected_status)
{
uint8_t *key_data = NULL;
size_t key_data_length = 0;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_status_t status;
- status = psa_parse_key_data_from_storage( file_data->x, file_data->len,
- &key_data, &key_data_length,
- &attributes.core );
+ status = psa_parse_key_data_from_storage(file_data->x, file_data->len,
+ &key_data, &key_data_length,
+ &attributes.core);
- TEST_EQUAL( status, expected_status );
- if( status != PSA_SUCCESS )
+ TEST_EQUAL(status, expected_status);
+ if (status != PSA_SUCCESS) {
goto exit;
+ }
- TEST_EQUAL( psa_get_key_lifetime( &attributes ),
- (psa_key_type_t) expected_key_lifetime );
- TEST_EQUAL( psa_get_key_type( &attributes ),
- (psa_key_type_t) expected_key_type );
- TEST_EQUAL( psa_get_key_bits( &attributes ),
- (psa_key_bits_t) expected_key_bits );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ),
- (uint32_t) expected_key_usage );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ),
- (uint32_t) expected_key_alg );
- TEST_EQUAL( psa_get_key_enrollment_algorithm( &attributes ),
- (uint32_t) expected_key_alg2 );
- ASSERT_COMPARE( expected_key_data->x, expected_key_data->len,
- key_data, key_data_length );
+ TEST_EQUAL(psa_get_key_lifetime(&attributes),
+ (psa_key_type_t) expected_key_lifetime);
+ TEST_EQUAL(psa_get_key_type(&attributes),
+ (psa_key_type_t) expected_key_type);
+ TEST_EQUAL(psa_get_key_bits(&attributes),
+ (psa_key_bits_t) expected_key_bits);
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes),
+ (uint32_t) expected_key_usage);
+ TEST_EQUAL(psa_get_key_algorithm(&attributes),
+ (uint32_t) expected_key_alg);
+ TEST_EQUAL(psa_get_key_enrollment_algorithm(&attributes),
+ (uint32_t) expected_key_alg2);
+ ASSERT_COMPARE(expected_key_data->x, expected_key_data->len,
+ key_data, key_data_length);
exit:
- mbedtls_free( key_data );
+ mbedtls_free(key_data);
}
/* END_CASE */
/* BEGIN_CASE */
-void save_large_persistent_key( int data_length_arg, int expected_status )
+void save_large_persistent_key(int data_length_arg, int expected_status)
{
- mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make( 1, 42 );
+ mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make(1, 42);
uint8_t *data = NULL;
size_t data_length = data_length_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- ASSERT_ALLOC( data, data_length );
+ ASSERT_ALLOC(data, data_length);
- PSA_ASSERT( psa_crypto_init() );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_id( &attributes, key_id );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
+ psa_set_key_id(&attributes, key_id);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
- TEST_EQUAL( psa_import_key( &attributes, data, data_length, &key_id ),
- expected_status );
+ TEST_EQUAL(psa_import_key(&attributes, data, data_length, &key_id),
+ expected_status);
- if( expected_status == PSA_SUCCESS )
- PSA_ASSERT( psa_destroy_key( key_id ) );
+ if (expected_status == PSA_SUCCESS) {
+ PSA_ASSERT(psa_destroy_key(key_id));
+ }
exit:
- mbedtls_free( data );
+ mbedtls_free(data);
PSA_DONE();
- psa_destroy_persistent_key( key_id );
+ psa_destroy_persistent_key(key_id);
}
/* END_CASE */
/* BEGIN_CASE */
-void persistent_key_destroy( int owner_id_arg, int key_id_arg, int restart,
- int first_type_arg, data_t *first_data,
- int second_type_arg, data_t *second_data )
+void persistent_key_destroy(int owner_id_arg, int key_id_arg, int restart,
+ int first_type_arg, data_t *first_data,
+ int second_type_arg, data_t *second_data)
{
mbedtls_svc_key_id_t key_id =
- mbedtls_svc_key_id_make( owner_id_arg, key_id_arg );
+ mbedtls_svc_key_id_make(owner_id_arg, key_id_arg);
mbedtls_svc_key_id_t returned_key_id = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_type_t first_type = (psa_key_type_t) first_type_arg;
psa_key_type_t second_type = (psa_key_type_t) second_type_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init() );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_id( &attributes, key_id );
- psa_set_key_type( &attributes, first_type );
+ psa_set_key_id(&attributes, key_id);
+ psa_set_key_type(&attributes, first_type);
- PSA_ASSERT( psa_import_key( &attributes, first_data->x, first_data->len,
- &returned_key_id ) );
+ PSA_ASSERT(psa_import_key(&attributes, first_data->x, first_data->len,
+ &returned_key_id));
- if( restart )
- {
- psa_close_key( key_id );
+ if (restart) {
+ psa_close_key(key_id);
PSA_DONE();
- PSA_ASSERT( psa_crypto_init() );
+ PSA_ASSERT(psa_crypto_init());
}
- TEST_EQUAL( psa_is_key_present_in_storage( key_id ), 1 );
+ TEST_EQUAL(psa_is_key_present_in_storage(key_id), 1);
/* Destroy the key */
- PSA_ASSERT( psa_destroy_key( key_id ) );
+ PSA_ASSERT(psa_destroy_key(key_id));
/* Check key slot storage is removed */
- TEST_EQUAL( psa_is_key_present_in_storage( key_id ), 0 );
+ TEST_EQUAL(psa_is_key_present_in_storage(key_id), 0);
/* Shutdown and restart */
PSA_DONE();
- PSA_ASSERT( psa_crypto_init() );
+ PSA_ASSERT(psa_crypto_init());
/* Create another key in the same slot */
- psa_set_key_id( &attributes, key_id );
- psa_set_key_type( &attributes, second_type );
- PSA_ASSERT( psa_import_key( &attributes, second_data->x, second_data->len,
- &returned_key_id ) );
+ psa_set_key_id(&attributes, key_id);
+ psa_set_key_type(&attributes, second_type);
+ PSA_ASSERT(psa_import_key(&attributes, second_data->x, second_data->len,
+ &returned_key_id));
- PSA_ASSERT( psa_destroy_key( key_id ) );
+ PSA_ASSERT(psa_destroy_key(key_id));
exit:
PSA_DONE();
- psa_destroy_persistent_key( key_id );
+ psa_destroy_persistent_key(key_id);
}
/* END_CASE */
/* BEGIN_CASE */
-void persistent_key_import( int owner_id_arg, int key_id_arg, int type_arg,
- data_t *data, int restart, int expected_status )
+void persistent_key_import(int owner_id_arg, int key_id_arg, int type_arg,
+ data_t *data, int restart, int expected_status)
{
mbedtls_svc_key_id_t key_id =
- mbedtls_svc_key_id_make( owner_id_arg, key_id_arg );
+ mbedtls_svc_key_id_make(owner_id_arg, key_id_arg);
mbedtls_svc_key_id_t returned_key_id;
psa_key_type_t type = (psa_key_type_t) type_arg;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_crypto_init() );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_id( &attributes, key_id );
- psa_set_key_type( &attributes, type );
- TEST_EQUAL( psa_import_key( &attributes, data->x, data->len, &returned_key_id ),
- expected_status );
+ psa_set_key_id(&attributes, key_id);
+ psa_set_key_type(&attributes, type);
+ TEST_EQUAL(psa_import_key(&attributes, data->x, data->len, &returned_key_id),
+ expected_status);
- if( expected_status != PSA_SUCCESS )
- {
- TEST_ASSERT( mbedtls_svc_key_id_is_null( returned_key_id ) );
- TEST_EQUAL( psa_is_key_present_in_storage( key_id ), 0 );
+ if (expected_status != PSA_SUCCESS) {
+ TEST_ASSERT(mbedtls_svc_key_id_is_null(returned_key_id));
+ TEST_EQUAL(psa_is_key_present_in_storage(key_id), 0);
goto exit;
}
- TEST_ASSERT( mbedtls_svc_key_id_equal( returned_key_id, key_id ) );
+ TEST_ASSERT(mbedtls_svc_key_id_equal(returned_key_id, key_id));
- if( restart )
- {
- PSA_ASSERT( psa_purge_key( key_id ) );
+ if (restart) {
+ PSA_ASSERT(psa_purge_key(key_id));
PSA_DONE();
- PSA_ASSERT( psa_crypto_init() );
+ PSA_ASSERT(psa_crypto_init());
}
- psa_reset_key_attributes( &attributes );
- PSA_ASSERT( psa_get_key_attributes( key_id, &attributes ) );
- TEST_ASSERT( mbedtls_svc_key_id_equal( psa_get_key_id( &attributes ),
- key_id ) );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ),
- PSA_KEY_LIFETIME_PERSISTENT );
- TEST_EQUAL( psa_get_key_type( &attributes ), type );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ), 0 );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ), 0 );
+ psa_reset_key_attributes(&attributes);
+ PSA_ASSERT(psa_get_key_attributes(key_id, &attributes));
+ TEST_ASSERT(mbedtls_svc_key_id_equal(psa_get_key_id(&attributes),
+ key_id));
+ TEST_EQUAL(psa_get_key_lifetime(&attributes),
+ PSA_KEY_LIFETIME_PERSISTENT);
+ TEST_EQUAL(psa_get_key_type(&attributes), type);
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes), 0);
+ TEST_EQUAL(psa_get_key_algorithm(&attributes), 0);
- PSA_ASSERT( psa_destroy_key( key_id ) );
+ PSA_ASSERT(psa_destroy_key(key_id));
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- psa_destroy_persistent_key( key_id );
+ psa_destroy_persistent_key(key_id);
PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void import_export_persistent_key( data_t *data, int type_arg,
- int expected_bits,
- int restart, int key_not_exist )
+void import_export_persistent_key(data_t *data, int type_arg,
+ int expected_bits,
+ int restart, int key_not_exist)
{
- mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make( 1, 42 );
+ mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make(1, 42);
psa_key_type_t type = (psa_key_type_t) type_arg;
mbedtls_svc_key_id_t returned_key_id = MBEDTLS_SVC_KEY_ID_INIT;
unsigned char *exported = NULL;
@@ -268,78 +267,76 @@
size_t exported_length;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- ASSERT_ALLOC( exported, export_size );
+ ASSERT_ALLOC(exported, export_size);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_id( &attributes, key_id );
- psa_set_key_type( &attributes, type );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
+ psa_set_key_id(&attributes, key_id);
+ psa_set_key_type(&attributes, type);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
/* Import the key */
- PSA_ASSERT( psa_import_key( &attributes, data->x, data->len,
- &returned_key_id ) );
+ PSA_ASSERT(psa_import_key(&attributes, data->x, data->len,
+ &returned_key_id));
- if( restart )
- {
- PSA_ASSERT( psa_purge_key( key_id ) );
+ if (restart) {
+ PSA_ASSERT(psa_purge_key(key_id));
PSA_DONE();
- PSA_ASSERT( psa_crypto_init() );
+ PSA_ASSERT(psa_crypto_init());
}
/* Test the key information */
- psa_reset_key_attributes( &attributes );
- PSA_ASSERT( psa_get_key_attributes( key_id, &attributes ) );
- TEST_ASSERT( mbedtls_svc_key_id_equal(
- psa_get_key_id( &attributes ), key_id ) );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ),
- PSA_KEY_LIFETIME_PERSISTENT );
- TEST_EQUAL( psa_get_key_type( &attributes ), type );
- TEST_EQUAL( psa_get_key_bits( &attributes ), (size_t) expected_bits );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ), PSA_KEY_USAGE_EXPORT );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ), 0 );
+ psa_reset_key_attributes(&attributes);
+ PSA_ASSERT(psa_get_key_attributes(key_id, &attributes));
+ TEST_ASSERT(mbedtls_svc_key_id_equal(
+ psa_get_key_id(&attributes), key_id));
+ TEST_EQUAL(psa_get_key_lifetime(&attributes),
+ PSA_KEY_LIFETIME_PERSISTENT);
+ TEST_EQUAL(psa_get_key_type(&attributes), type);
+ TEST_EQUAL(psa_get_key_bits(&attributes), (size_t) expected_bits);
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes), PSA_KEY_USAGE_EXPORT);
+ TEST_EQUAL(psa_get_key_algorithm(&attributes), 0);
- TEST_EQUAL( psa_is_key_present_in_storage( key_id ), 1 );
+ TEST_EQUAL(psa_is_key_present_in_storage(key_id), 1);
- if( key_not_exist )
- {
- psa_destroy_persistent_key( key_id );
+ if (key_not_exist) {
+ psa_destroy_persistent_key(key_id);
}
/* Export the key */
- PSA_ASSERT( psa_export_key( key_id, exported, export_size,
- &exported_length ) );
+ PSA_ASSERT(psa_export_key(key_id, exported, export_size,
+ &exported_length));
- ASSERT_COMPARE( data->x, data->len, exported, exported_length );
+ ASSERT_COMPARE(data->x, data->len, exported, exported_length);
/* Destroy the key */
- PSA_ASSERT( psa_destroy_key( key_id ) );
- TEST_EQUAL( psa_is_key_present_in_storage( key_id ), 0 );
+ PSA_ASSERT(psa_destroy_key(key_id));
+ TEST_EQUAL(psa_is_key_present_in_storage(key_id), 0);
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- mbedtls_free( exported );
- PSA_DONE( );
- psa_destroy_persistent_key( key_id );
+ mbedtls_free(exported);
+ PSA_DONE();
+ psa_destroy_persistent_key(key_id);
}
/* END_CASE */
/* BEGIN_CASE */
-void destroy_nonexistent( int id_arg, int expected_status_arg )
+void destroy_nonexistent(int id_arg, int expected_status_arg)
{
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, id_arg );
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, id_arg);
psa_status_t expected_status = expected_status_arg;
- PSA_INIT( );
+ PSA_INIT();
- TEST_EQUAL( expected_status, psa_destroy_key( id ) );
+ TEST_EQUAL(expected_status, psa_destroy_key(id));
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto_se_driver_hal.function b/tests/suites/test_suite_psa_crypto_se_driver_hal.function
index c96b988..aeced54 100644
--- a/tests/suites/test_suite_psa_crypto_se_driver_hal.function
+++ b/tests/suites/test_suite_psa_crypto_se_driver_hal.function
@@ -24,16 +24,16 @@
/** The location and lifetime used for tests that use a single driver. */
#define TEST_DRIVER_LOCATION 1
#define TEST_SE_PERSISTENT_LIFETIME \
- ( PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION( \
- PSA_KEY_PERSISTENCE_DEFAULT, TEST_DRIVER_LOCATION ) )
+ (PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION( \
+ PSA_KEY_PERSISTENCE_DEFAULT, TEST_DRIVER_LOCATION))
#define TEST_SE_VOLATILE_LIFETIME \
- ( PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION( \
- PSA_KEY_PERSISTENCE_VOLATILE, TEST_DRIVER_LOCATION ) )
+ (PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION( \
+ PSA_KEY_PERSISTENCE_VOLATILE, TEST_DRIVER_LOCATION))
/** The driver detected a condition that shouldn't happen.
* This is probably a bug in the library. */
-#define PSA_ERROR_DETECTED_BY_DRIVER ((psa_status_t)( -500 ))
+#define PSA_ERROR_DETECTED_BY_DRIVER ((psa_status_t) (-500))
/** Like #TEST_ASSERT for use in a driver method, with no cleanup.
*
@@ -41,14 +41,14 @@
*
* Use this macro to assert on guarantees provided by the core.
*/
-#define DRIVER_ASSERT_RETURN( TEST ) \
+#define DRIVER_ASSERT_RETURN(TEST) \
do { \
- if( ! (TEST) ) \
- { \
- mbedtls_test_fail( #TEST, __LINE__, __FILE__ ); \
- return( PSA_ERROR_DETECTED_BY_DRIVER ); \
- } \
- } while( 0 )
+ if (!(TEST)) \
+ { \
+ mbedtls_test_fail( #TEST, __LINE__, __FILE__); \
+ return PSA_ERROR_DETECTED_BY_DRIVER; \
+ } \
+ } while (0)
/** Like #TEST_ASSERT for use in a driver method, with cleanup.
*
@@ -57,15 +57,15 @@
*
* Use this macro to assert on guarantees provided by the core.
*/
-#define DRIVER_ASSERT( TEST ) \
+#define DRIVER_ASSERT(TEST) \
do { \
- if( ! (TEST) ) \
- { \
- mbedtls_test_fail( #TEST, __LINE__, __FILE__ ); \
- status = PSA_ERROR_DETECTED_BY_DRIVER; \
- goto exit; \
- } \
- } while( 0 )
+ if (!(TEST)) \
+ { \
+ mbedtls_test_fail( #TEST, __LINE__, __FILE__); \
+ status = PSA_ERROR_DETECTED_BY_DRIVER; \
+ goto exit; \
+ } \
+ } while (0)
/** Like #PSA_ASSERT for a PSA API call that calls a driver underneath.
*
@@ -78,17 +78,17 @@
* case, the test driver code is expected to have called mbedtls_test_fail()
* already, so we make sure not to overwrite the failure information.
*/
-#define PSA_ASSERT_VIA_DRIVER( expr, expected_status ) \
+#define PSA_ASSERT_VIA_DRIVER(expr, expected_status) \
do { \
- psa_status_t PSA_ASSERT_VIA_DRIVER_status = ( expr ); \
- if( PSA_ASSERT_VIA_DRIVER_status == PSA_ERROR_DETECTED_BY_DRIVER ) \
- goto exit; \
- if( PSA_ASSERT_VIA_DRIVER_status != ( expected_status ) ) \
+ psa_status_t PSA_ASSERT_VIA_DRIVER_status = (expr); \
+ if (PSA_ASSERT_VIA_DRIVER_status == PSA_ERROR_DETECTED_BY_DRIVER) \
+ goto exit; \
+ if (PSA_ASSERT_VIA_DRIVER_status != (expected_status)) \
{ \
- mbedtls_test_fail( #expr, __LINE__, __FILE__ ); \
+ mbedtls_test_fail( #expr, __LINE__, __FILE__); \
goto exit; \
} \
- } while( 0 )
+ } while (0)
@@ -97,20 +97,21 @@
/****************************************************************/
/* Return the exact bit size given a curve family and a byte length. */
-static size_t ecc_curve_bits( psa_ecc_family_t curve, size_t data_length )
+static size_t ecc_curve_bits(psa_ecc_family_t curve, size_t data_length)
{
- switch( curve )
- {
+ switch (curve) {
case PSA_ECC_FAMILY_SECP_R1:
- if( data_length == PSA_BYTES_TO_BITS( 521 ) )
- return( 521 );
+ if (data_length == PSA_BYTES_TO_BITS(521)) {
+ return 521;
+ }
break;
case PSA_ECC_FAMILY_MONTGOMERY:
- if( data_length == PSA_BYTES_TO_BITS( 255 ) )
- return( 255 );
+ if (data_length == PSA_BYTES_TO_BITS(255)) {
+ return 255;
+ }
}
/* If not listed above, assume a multiple of 8 bits. */
- return( PSA_BYTES_TO_BITS( data_length ) );
+ return PSA_BYTES_TO_BITS(data_length);
}
@@ -118,8 +119,7 @@
/* Miscellaneous driver methods */
/****************************************************************/
-typedef struct
-{
+typedef struct {
psa_key_slot_number_t slot_number;
psa_key_creation_method_t method;
psa_status_t status;
@@ -132,50 +132,52 @@
void *persistent_data,
const psa_key_attributes_t *attributes,
psa_key_creation_method_t method,
- psa_key_slot_number_t slot_number )
+ psa_key_slot_number_t slot_number)
{
(void) context;
(void) persistent_data;
(void) attributes;
- DRIVER_ASSERT_RETURN( slot_number ==
- validate_slot_number_directions.slot_number );
- DRIVER_ASSERT_RETURN( method ==
- validate_slot_number_directions.method );
- return( validate_slot_number_directions.status );
+ DRIVER_ASSERT_RETURN(slot_number ==
+ validate_slot_number_directions.slot_number);
+ DRIVER_ASSERT_RETURN(method ==
+ validate_slot_number_directions.method);
+ return validate_slot_number_directions.status;
}
/* Allocate slot numbers with a monotonic counter. */
static psa_key_slot_number_t shadow_counter;
-static void counter_reset( void )
+static void counter_reset(void)
{
shadow_counter = 0;
}
-static psa_status_t counter_allocate( psa_drv_se_context_t *context,
- void *persistent_data,
- const psa_key_attributes_t *attributes,
- psa_key_creation_method_t method,
- psa_key_slot_number_t *slot_number )
+static psa_status_t counter_allocate(psa_drv_se_context_t *context,
+ void *persistent_data,
+ const psa_key_attributes_t *attributes,
+ psa_key_creation_method_t method,
+ psa_key_slot_number_t *slot_number)
{
psa_key_slot_number_t *p_counter = persistent_data;
(void) attributes;
(void) method;
- if( context->persistent_data_size != sizeof( psa_key_slot_number_t ) )
- return( PSA_ERROR_DETECTED_BY_DRIVER );
+ if (context->persistent_data_size != sizeof(psa_key_slot_number_t)) {
+ return PSA_ERROR_DETECTED_BY_DRIVER;
+ }
++*p_counter;
- if( *p_counter == 0 )
- return( PSA_ERROR_INSUFFICIENT_STORAGE );
+ if (*p_counter == 0) {
+ return PSA_ERROR_INSUFFICIENT_STORAGE;
+ }
shadow_counter = *p_counter;
*slot_number = *p_counter;
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
/* Null import: do nothing, but pretend it worked. */
-static psa_status_t null_import( psa_drv_se_context_t *context,
- psa_key_slot_number_t slot_number,
- const psa_key_attributes_t *attributes,
- const uint8_t *data,
- size_t data_length,
- size_t *bits )
+static psa_status_t null_import(psa_drv_se_context_t *context,
+ psa_key_slot_number_t slot_number,
+ const psa_key_attributes_t *attributes,
+ const uint8_t *data,
+ size_t data_length,
+ size_t *bits)
{
(void) context;
(void) slot_number;
@@ -183,41 +185,40 @@
(void) data;
/* We're supposed to return a key size. Return one that's correct for
* plain data keys. */
- *bits = PSA_BYTES_TO_BITS( data_length );
- return( PSA_SUCCESS );
+ *bits = PSA_BYTES_TO_BITS(data_length);
+ return PSA_SUCCESS;
}
/* Null generate: do nothing, but pretend it worked. */
-static psa_status_t null_generate( psa_drv_se_context_t *context,
- psa_key_slot_number_t slot_number,
- const psa_key_attributes_t *attributes,
- uint8_t *pubkey,
- size_t pubkey_size,
- size_t *pubkey_length )
+static psa_status_t null_generate(psa_drv_se_context_t *context,
+ psa_key_slot_number_t slot_number,
+ const psa_key_attributes_t *attributes,
+ uint8_t *pubkey,
+ size_t pubkey_size,
+ size_t *pubkey_length)
{
(void) context;
(void) slot_number;
(void) attributes;
- DRIVER_ASSERT_RETURN( *pubkey_length == 0 );
- if( ! PSA_KEY_TYPE_IS_KEY_PAIR( psa_get_key_type( attributes ) ) )
- {
- DRIVER_ASSERT_RETURN( pubkey == NULL );
- DRIVER_ASSERT_RETURN( pubkey_size == 0 );
+ DRIVER_ASSERT_RETURN(*pubkey_length == 0);
+ if (!PSA_KEY_TYPE_IS_KEY_PAIR(psa_get_key_type(attributes))) {
+ DRIVER_ASSERT_RETURN(pubkey == NULL);
+ DRIVER_ASSERT_RETURN(pubkey_size == 0);
}
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
/* Null destroy: do nothing, but pretend it worked. */
-static psa_status_t null_destroy( psa_drv_se_context_t *context,
- void *persistent_data,
- psa_key_slot_number_t slot_number )
+static psa_status_t null_destroy(psa_drv_se_context_t *context,
+ void *persistent_data,
+ psa_key_slot_number_t slot_number)
{
(void) context;
(void) persistent_data;
(void) slot_number;
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
@@ -227,8 +228,7 @@
/****************************************************************/
#define RAM_MAX_KEY_SIZE 64
-typedef struct
-{
+typedef struct {
psa_key_lifetime_t lifetime;
psa_key_type_t type;
size_t bits;
@@ -244,9 +244,9 @@
static uint8_t ram_min_slot = 0;
-static void ram_slots_reset( void )
+static void ram_slots_reset(void)
{
- memset( ram_slots, 0, sizeof( ram_slots ) );
+ memset(ram_slots, 0, sizeof(ram_slots));
ram_min_slot = 0;
ram_shadow_slot_usage = 0;
}
@@ -259,168 +259,165 @@
* in the test case function's cleanup code) and it might be wrong
* (if slot_number is invalid).
*/
-static psa_status_t ram_create_common( psa_drv_se_context_t *context,
- psa_key_slot_number_t slot_number,
- const psa_key_attributes_t *attributes,
- size_t required_storage )
+static psa_status_t ram_create_common(psa_drv_se_context_t *context,
+ psa_key_slot_number_t slot_number,
+ const psa_key_attributes_t *attributes,
+ size_t required_storage)
{
(void) context;
- DRIVER_ASSERT_RETURN( slot_number < ARRAY_LENGTH( ram_slots ) );
+ DRIVER_ASSERT_RETURN(slot_number < ARRAY_LENGTH(ram_slots));
- ram_slots[slot_number].lifetime = psa_get_key_lifetime( attributes );
- ram_slots[slot_number].type = psa_get_key_type( attributes );
- ram_slots[slot_number].bits = psa_get_key_bits( attributes );
+ ram_slots[slot_number].lifetime = psa_get_key_lifetime(attributes);
+ ram_slots[slot_number].type = psa_get_key_type(attributes);
+ ram_slots[slot_number].bits = psa_get_key_bits(attributes);
- if( required_storage > sizeof( ram_slots[slot_number].content ) )
- {
- memset( &ram_slots[slot_number], 0, sizeof( ram_slots[slot_number] ) );
- return( PSA_ERROR_INSUFFICIENT_STORAGE );
+ if (required_storage > sizeof(ram_slots[slot_number].content)) {
+ memset(&ram_slots[slot_number], 0, sizeof(ram_slots[slot_number]));
+ return PSA_ERROR_INSUFFICIENT_STORAGE;
}
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
/* This function does everything except actually generating key material.
* After calling it, you must copy the desired key material to
* ram_slots[slot_number].content. */
-static psa_status_t ram_fake_generate( psa_drv_se_context_t *context,
- psa_key_slot_number_t slot_number,
- const psa_key_attributes_t *attributes,
- uint8_t *pubkey,
- size_t pubkey_size,
- size_t *pubkey_length )
+static psa_status_t ram_fake_generate(psa_drv_se_context_t *context,
+ psa_key_slot_number_t slot_number,
+ const psa_key_attributes_t *attributes,
+ uint8_t *pubkey,
+ size_t pubkey_size,
+ size_t *pubkey_length)
{
psa_status_t status;
size_t required_storage =
- PSA_EXPORT_KEY_OUTPUT_SIZE( psa_get_key_type( attributes ),
- psa_get_key_bits( attributes ) );
+ PSA_EXPORT_KEY_OUTPUT_SIZE(psa_get_key_type(attributes),
+ psa_get_key_bits(attributes));
- DRIVER_ASSERT_RETURN( *pubkey_length == 0 );
- if( ! PSA_KEY_TYPE_IS_KEY_PAIR( psa_get_key_type( attributes ) ) )
- {
- DRIVER_ASSERT_RETURN( pubkey == NULL );
- DRIVER_ASSERT_RETURN( pubkey_size == 0 );
+ DRIVER_ASSERT_RETURN(*pubkey_length == 0);
+ if (!PSA_KEY_TYPE_IS_KEY_PAIR(psa_get_key_type(attributes))) {
+ DRIVER_ASSERT_RETURN(pubkey == NULL);
+ DRIVER_ASSERT_RETURN(pubkey_size == 0);
}
- status = ram_create_common( context, slot_number, attributes,
- required_storage );
- return( status );
+ status = ram_create_common(context, slot_number, attributes,
+ required_storage);
+ return status;
}
-static psa_status_t ram_import( psa_drv_se_context_t *context,
- psa_key_slot_number_t slot_number,
- const psa_key_attributes_t *attributes,
- const uint8_t *data,
- size_t data_length,
- size_t *bits )
+static psa_status_t ram_import(psa_drv_se_context_t *context,
+ psa_key_slot_number_t slot_number,
+ const psa_key_attributes_t *attributes,
+ const uint8_t *data,
+ size_t data_length,
+ size_t *bits)
{
- psa_key_type_t type = psa_get_key_type( attributes );
- psa_status_t status = ram_create_common( context, slot_number, attributes,
- data_length );
- if( status != PSA_SUCCESS )
- return( status );
+ psa_key_type_t type = psa_get_key_type(attributes);
+ psa_status_t status = ram_create_common(context, slot_number, attributes,
+ data_length);
+ if (status != PSA_SUCCESS) {
+ return status;
+ }
/* The RAM driver only works for certain key types: raw keys,
* and ECC key pairs. This is true in particular of the bit-size
* calculation here. */
- if( PSA_KEY_TYPE_IS_UNSTRUCTURED( type ) )
- *bits = PSA_BYTES_TO_BITS( data_length );
- else if ( PSA_KEY_TYPE_IS_ECC_KEY_PAIR( type ) )
- {
- *bits = ecc_curve_bits( PSA_KEY_TYPE_ECC_GET_FAMILY( type ), data_length );
- if( *bits == 0 )
- return( PSA_ERROR_DETECTED_BY_DRIVER );
- }
- else
- {
- memset( &ram_slots[slot_number], 0, sizeof( ram_slots[slot_number] ) );
- return( PSA_ERROR_NOT_SUPPORTED );
+ if (PSA_KEY_TYPE_IS_UNSTRUCTURED(type)) {
+ *bits = PSA_BYTES_TO_BITS(data_length);
+ } else if (PSA_KEY_TYPE_IS_ECC_KEY_PAIR(type)) {
+ *bits = ecc_curve_bits(PSA_KEY_TYPE_ECC_GET_FAMILY(type), data_length);
+ if (*bits == 0) {
+ return PSA_ERROR_DETECTED_BY_DRIVER;
+ }
+ } else {
+ memset(&ram_slots[slot_number], 0, sizeof(ram_slots[slot_number]));
+ return PSA_ERROR_NOT_SUPPORTED;
}
ram_slots[slot_number].bits = *bits;
- memcpy( ram_slots[slot_number].content, data, data_length );
+ memcpy(ram_slots[slot_number].content, data, data_length);
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
-static psa_status_t ram_export( psa_drv_se_context_t *context,
- psa_key_slot_number_t slot_number,
- uint8_t *data,
- size_t data_size,
- size_t *data_length )
+static psa_status_t ram_export(psa_drv_se_context_t *context,
+ psa_key_slot_number_t slot_number,
+ uint8_t *data,
+ size_t data_size,
+ size_t *data_length)
{
size_t actual_size;
(void) context;
- DRIVER_ASSERT_RETURN( slot_number < ARRAY_LENGTH( ram_slots ) );
- actual_size = PSA_BITS_TO_BYTES( ram_slots[slot_number].bits );
- if( actual_size > data_size )
- return( PSA_ERROR_BUFFER_TOO_SMALL );
+ DRIVER_ASSERT_RETURN(slot_number < ARRAY_LENGTH(ram_slots));
+ actual_size = PSA_BITS_TO_BYTES(ram_slots[slot_number].bits);
+ if (actual_size > data_size) {
+ return PSA_ERROR_BUFFER_TOO_SMALL;
+ }
*data_length = actual_size;
- memcpy( data, ram_slots[slot_number].content, actual_size );
- return( PSA_SUCCESS );
+ memcpy(data, ram_slots[slot_number].content, actual_size);
+ return PSA_SUCCESS;
}
-static psa_status_t ram_export_public( psa_drv_se_context_t *context,
- psa_key_slot_number_t slot_number,
- uint8_t *data,
- size_t data_size,
- size_t *data_length )
+static psa_status_t ram_export_public(psa_drv_se_context_t *context,
+ psa_key_slot_number_t slot_number,
+ uint8_t *data,
+ size_t data_size,
+ size_t *data_length)
{
psa_status_t status;
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
(void) context;
- DRIVER_ASSERT_RETURN( slot_number < ARRAY_LENGTH( ram_slots ) );
+ DRIVER_ASSERT_RETURN(slot_number < ARRAY_LENGTH(ram_slots));
DRIVER_ASSERT_RETURN(
- PSA_KEY_TYPE_IS_KEY_PAIR( ram_slots[slot_number].type ) );
+ PSA_KEY_TYPE_IS_KEY_PAIR(ram_slots[slot_number].type));
- psa_set_key_type( &attributes, ram_slots[slot_number].type );
- status = psa_import_key( &attributes,
- ram_slots[slot_number].content,
- PSA_BITS_TO_BYTES( ram_slots[slot_number].bits ),
- &key );
- if( status != PSA_SUCCESS )
- return( status );
- status = psa_export_public_key( key, data, data_size, data_length );
- psa_destroy_key( key );
- return( PSA_SUCCESS );
+ psa_set_key_type(&attributes, ram_slots[slot_number].type);
+ status = psa_import_key(&attributes,
+ ram_slots[slot_number].content,
+ PSA_BITS_TO_BYTES(ram_slots[slot_number].bits),
+ &key);
+ if (status != PSA_SUCCESS) {
+ return status;
+ }
+ status = psa_export_public_key(key, data, data_size, data_length);
+ psa_destroy_key(key);
+ return PSA_SUCCESS;
}
-static psa_status_t ram_destroy( psa_drv_se_context_t *context,
- void *persistent_data,
- psa_key_slot_number_t slot_number )
+static psa_status_t ram_destroy(psa_drv_se_context_t *context,
+ void *persistent_data,
+ psa_key_slot_number_t slot_number)
{
ram_slot_usage_t *slot_usage = persistent_data;
- DRIVER_ASSERT_RETURN( context->persistent_data_size == sizeof( ram_slot_usage_t ) );
- DRIVER_ASSERT_RETURN( slot_number < ARRAY_LENGTH( ram_slots ) );
- memset( &ram_slots[slot_number], 0, sizeof( ram_slots[slot_number] ) );
- *slot_usage &= ~(ram_slot_usage_t)( 1 << slot_number );
+ DRIVER_ASSERT_RETURN(context->persistent_data_size == sizeof(ram_slot_usage_t));
+ DRIVER_ASSERT_RETURN(slot_number < ARRAY_LENGTH(ram_slots));
+ memset(&ram_slots[slot_number], 0, sizeof(ram_slots[slot_number]));
+ *slot_usage &= ~(ram_slot_usage_t) (1 << slot_number);
ram_shadow_slot_usage = *slot_usage;
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
-static psa_status_t ram_allocate( psa_drv_se_context_t *context,
- void *persistent_data,
- const psa_key_attributes_t *attributes,
- psa_key_creation_method_t method,
- psa_key_slot_number_t *slot_number )
+static psa_status_t ram_allocate(psa_drv_se_context_t *context,
+ void *persistent_data,
+ const psa_key_attributes_t *attributes,
+ psa_key_creation_method_t method,
+ psa_key_slot_number_t *slot_number)
{
ram_slot_usage_t *slot_usage = persistent_data;
(void) attributes;
(void) method;
- DRIVER_ASSERT_RETURN( context->persistent_data_size == sizeof( ram_slot_usage_t ) );
- for( *slot_number = ram_min_slot;
- *slot_number < ARRAY_LENGTH( ram_slots );
- ++( *slot_number ) )
- {
- if( ! ( *slot_usage & 1 << *slot_number ) )
- {
+ DRIVER_ASSERT_RETURN(context->persistent_data_size == sizeof(ram_slot_usage_t));
+ for (*slot_number = ram_min_slot;
+ *slot_number < ARRAY_LENGTH(ram_slots);
+ ++(*slot_number)) {
+ if (!(*slot_usage & 1 << *slot_number)) {
ram_shadow_slot_usage = *slot_usage;
- return( PSA_SUCCESS );
+ return PSA_SUCCESS;
}
}
- return( PSA_ERROR_INSUFFICIENT_STORAGE );
+ return PSA_ERROR_INSUFFICIENT_STORAGE;
}
static psa_status_t ram_validate_slot_number(
@@ -428,25 +425,26 @@
void *persistent_data,
const psa_key_attributes_t *attributes,
psa_key_creation_method_t method,
- psa_key_slot_number_t slot_number )
+ psa_key_slot_number_t slot_number)
{
(void) context;
(void) persistent_data;
(void) attributes;
(void) method;
- if( slot_number >= ARRAY_LENGTH( ram_slots ) )
- return( PSA_ERROR_INVALID_ARGUMENT );
- return( PSA_SUCCESS );
+ if (slot_number >= ARRAY_LENGTH(ram_slots)) {
+ return PSA_ERROR_INVALID_ARGUMENT;
+ }
+ return PSA_SUCCESS;
}
-static psa_status_t ram_sign( psa_drv_se_context_t *context,
- psa_key_slot_number_t slot_number,
- psa_algorithm_t alg,
- const uint8_t *hash,
- size_t hash_length,
- uint8_t *signature,
- size_t signature_size,
- size_t *signature_length )
+static psa_status_t ram_sign(psa_drv_se_context_t *context,
+ psa_key_slot_number_t slot_number,
+ psa_algorithm_t alg,
+ const uint8_t *hash,
+ size_t hash_length,
+ uint8_t *signature,
+ size_t signature_size,
+ size_t *signature_length)
{
ram_slot_t *slot;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -454,32 +452,32 @@
psa_status_t status = PSA_ERROR_GENERIC_ERROR;
(void) context;
- DRIVER_ASSERT_RETURN( slot_number < ARRAY_LENGTH( ram_slots ) );
+ DRIVER_ASSERT_RETURN(slot_number < ARRAY_LENGTH(ram_slots));
slot = &ram_slots[slot_number];
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, slot->type );
- DRIVER_ASSERT( psa_import_key( &attributes,
- slot->content,
- PSA_BITS_TO_BYTES( slot->bits ),
- &key ) == PSA_SUCCESS );
- status = psa_sign_hash( key, alg,
- hash, hash_length,
- signature, signature_size, signature_length );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, slot->type);
+ DRIVER_ASSERT(psa_import_key(&attributes,
+ slot->content,
+ PSA_BITS_TO_BYTES(slot->bits),
+ &key) == PSA_SUCCESS);
+ status = psa_sign_hash(key, alg,
+ hash, hash_length,
+ signature, signature_size, signature_length);
exit:
- psa_destroy_key( key );
- return( status );
+ psa_destroy_key(key);
+ return status;
}
-static psa_status_t ram_verify( psa_drv_se_context_t *context,
- psa_key_slot_number_t slot_number,
- psa_algorithm_t alg,
- const uint8_t *hash,
- size_t hash_length,
- const uint8_t *signature,
- size_t signature_length )
+static psa_status_t ram_verify(psa_drv_se_context_t *context,
+ psa_key_slot_number_t slot_number,
+ psa_algorithm_t alg,
+ const uint8_t *hash,
+ size_t hash_length,
+ const uint8_t *signature,
+ size_t signature_length)
{
ram_slot_t *slot;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -487,24 +485,24 @@
psa_status_t status = PSA_ERROR_GENERIC_ERROR;
(void) context;
- DRIVER_ASSERT_RETURN( slot_number < ARRAY_LENGTH( ram_slots ) );
+ DRIVER_ASSERT_RETURN(slot_number < ARRAY_LENGTH(ram_slots));
slot = &ram_slots[slot_number];
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, slot->type );
- DRIVER_ASSERT( psa_import_key( &attributes,
- slot->content,
- PSA_BITS_TO_BYTES( slot->bits ),
- &key ) ==
- PSA_SUCCESS );
- status = psa_verify_hash( key, alg,
- hash, hash_length,
- signature, signature_length );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_HASH);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, slot->type);
+ DRIVER_ASSERT(psa_import_key(&attributes,
+ slot->content,
+ PSA_BITS_TO_BYTES(slot->bits),
+ &key) ==
+ PSA_SUCCESS);
+ status = psa_verify_hash(key, alg,
+ hash, hash_length,
+ signature, signature_length);
exit:
- psa_destroy_key( key );
- return( status );
+ psa_destroy_key(key);
+ return status;
}
@@ -512,8 +510,7 @@
/* Other test helper functions */
/****************************************************************/
-typedef enum
-{
+typedef enum {
SIGN_IN_SOFTWARE_AND_PARALLEL_CREATION,
SIGN_IN_DRIVER_AND_PARALLEL_CREATION,
SIGN_IN_DRIVER_THEN_EXPORT_PUBLIC,
@@ -523,54 +520,49 @@
* are consistent with the attributes used when creating the key. */
static int check_key_attributes(
mbedtls_svc_key_id_t key,
- const psa_key_attributes_t *reference_attributes )
+ const psa_key_attributes_t *reference_attributes)
{
int ok = 0;
psa_key_attributes_t actual_attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_ASSERT( psa_get_key_attributes( key, &actual_attributes ) );
+ PSA_ASSERT(psa_get_key_attributes(key, &actual_attributes));
- TEST_ASSERT( mbedtls_svc_key_id_equal(
- psa_get_key_id( &actual_attributes ),
- psa_get_key_id( reference_attributes ) ) );
- TEST_EQUAL( psa_get_key_lifetime( &actual_attributes ),
- psa_get_key_lifetime( reference_attributes ) );
- TEST_EQUAL( psa_get_key_type( &actual_attributes ),
- psa_get_key_type( reference_attributes ) );
- TEST_EQUAL( psa_get_key_usage_flags( &actual_attributes ),
- psa_get_key_usage_flags( reference_attributes ) );
- TEST_EQUAL( psa_get_key_algorithm( &actual_attributes ),
- psa_get_key_algorithm( reference_attributes ) );
- TEST_EQUAL( psa_get_key_enrollment_algorithm( &actual_attributes ),
- psa_get_key_enrollment_algorithm( reference_attributes ) );
- if( psa_get_key_bits( reference_attributes ) != 0 )
- {
- TEST_EQUAL( psa_get_key_bits( &actual_attributes ),
- psa_get_key_bits( reference_attributes ) );
+ TEST_ASSERT(mbedtls_svc_key_id_equal(
+ psa_get_key_id(&actual_attributes),
+ psa_get_key_id(reference_attributes)));
+ TEST_EQUAL(psa_get_key_lifetime(&actual_attributes),
+ psa_get_key_lifetime(reference_attributes));
+ TEST_EQUAL(psa_get_key_type(&actual_attributes),
+ psa_get_key_type(reference_attributes));
+ TEST_EQUAL(psa_get_key_usage_flags(&actual_attributes),
+ psa_get_key_usage_flags(reference_attributes));
+ TEST_EQUAL(psa_get_key_algorithm(&actual_attributes),
+ psa_get_key_algorithm(reference_attributes));
+ TEST_EQUAL(psa_get_key_enrollment_algorithm(&actual_attributes),
+ psa_get_key_enrollment_algorithm(reference_attributes));
+ if (psa_get_key_bits(reference_attributes) != 0) {
+ TEST_EQUAL(psa_get_key_bits(&actual_attributes),
+ psa_get_key_bits(reference_attributes));
}
{
psa_key_slot_number_t actual_slot_number = 0xdeadbeef;
psa_key_slot_number_t desired_slot_number = 0xb90cc011;
psa_key_lifetime_t lifetime =
- psa_get_key_lifetime( &actual_attributes );
- psa_status_t status = psa_get_key_slot_number( &actual_attributes,
- &actual_slot_number );
- if( PSA_KEY_LIFETIME_GET_LOCATION( lifetime ) < MIN_DRIVER_LOCATION )
- {
+ psa_get_key_lifetime(&actual_attributes);
+ psa_status_t status = psa_get_key_slot_number(&actual_attributes,
+ &actual_slot_number);
+ if (PSA_KEY_LIFETIME_GET_LOCATION(lifetime) < MIN_DRIVER_LOCATION) {
/* The key is not in a secure element. */
- TEST_EQUAL( status, PSA_ERROR_INVALID_ARGUMENT );
- }
- else
- {
+ TEST_EQUAL(status, PSA_ERROR_INVALID_ARGUMENT);
+ } else {
/* The key is in a secure element. If it had been created
* in a specific slot, check that it is reported there. */
- PSA_ASSERT( status );
- status = psa_get_key_slot_number( reference_attributes,
- &desired_slot_number );
- if( status == PSA_SUCCESS )
- {
- TEST_EQUAL( desired_slot_number, actual_slot_number );
+ PSA_ASSERT(status);
+ status = psa_get_key_slot_number(reference_attributes,
+ &desired_slot_number);
+ if (status == PSA_SUCCESS) {
+ TEST_EQUAL(desired_slot_number, actual_slot_number);
}
}
}
@@ -581,64 +573,64 @@
* Actual key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &actual_attributes );
+ psa_reset_key_attributes(&actual_attributes);
- return( ok );
+ return ok;
}
/* Get the file UID corresponding to the specified location.
* If this changes, the storage format version must change.
* See psa_get_se_driver_its_file_uid() in psa_crypto_se.c.
*/
-psa_storage_uid_t file_uid_for_location( psa_key_location_t location )
+psa_storage_uid_t file_uid_for_location(psa_key_location_t location)
{
- if( location > PSA_MAX_SE_LOCATION )
- return( 0 );
- return( 0xfffffe00 + location );
+ if (location > PSA_MAX_SE_LOCATION) {
+ return 0;
+ }
+ return 0xfffffe00 + location;
}
/* Check that the persistent data of a driver has its expected content. */
-static int check_persistent_data( psa_key_location_t location,
- const void *expected_data,
- size_t size )
+static int check_persistent_data(psa_key_location_t location,
+ const void *expected_data,
+ size_t size)
{
- psa_storage_uid_t uid = file_uid_for_location( location );
+ psa_storage_uid_t uid = file_uid_for_location(location);
struct psa_storage_info_t info;
uint8_t *loaded = NULL;
int ok = 0;
- PSA_ASSERT( psa_its_get_info( uid, &info ) );
- ASSERT_ALLOC( loaded, info.size );
- PSA_ASSERT( psa_its_get( uid, 0, info.size, loaded, NULL ) );
- ASSERT_COMPARE( expected_data, size, loaded, info.size );
+ PSA_ASSERT(psa_its_get_info(uid, &info));
+ ASSERT_ALLOC(loaded, info.size);
+ PSA_ASSERT(psa_its_get(uid, 0, info.size, loaded, NULL));
+ ASSERT_COMPARE(expected_data, size, loaded, info.size);
ok = 1;
exit:
- mbedtls_free( loaded );
- return( ok );
+ mbedtls_free(loaded);
+ return ok;
}
/* Check that no persistent data exists for the given location. */
-static int check_no_persistent_data( psa_key_location_t location )
+static int check_no_persistent_data(psa_key_location_t location)
{
- psa_storage_uid_t uid = file_uid_for_location( location );
+ psa_storage_uid_t uid = file_uid_for_location(location);
struct psa_storage_info_t info;
int ok = 0;
- TEST_EQUAL( psa_its_get_info( uid, &info ), PSA_ERROR_DOES_NOT_EXIST );
+ TEST_EQUAL(psa_its_get_info(uid, &info), PSA_ERROR_DOES_NOT_EXIST);
ok = 1;
exit:
- return( ok );
+ return ok;
}
/* Check that a function's return status is "smoke-free", i.e. that
* it's an acceptable error code when calling an API function that operates
* on a key with potentially bogus parameters. */
-static int is_status_smoke_free( psa_status_t status )
+static int is_status_smoke_free(psa_status_t status)
{
- switch( status )
- {
+ switch (status) {
case PSA_SUCCESS:
case PSA_ERROR_NOT_SUPPORTED:
case PSA_ERROR_NOT_PERMITTED:
@@ -646,19 +638,19 @@
case PSA_ERROR_INVALID_ARGUMENT:
case PSA_ERROR_INVALID_SIGNATURE:
case PSA_ERROR_INVALID_PADDING:
- return( 1 );
+ return 1;
default:
- return( 0 );
+ return 0;
}
}
-#define SMOKE_ASSERT( expr ) \
- TEST_ASSERT( is_status_smoke_free( expr ) )
+#define SMOKE_ASSERT(expr) \
+ TEST_ASSERT(is_status_smoke_free(expr))
/* Smoke test a key. There are mostly no wrong answers here since we pass
* mostly bogus parameters: the goal is to ensure that there is no memory
* corruption or crash. This test function is most useful when run under
* an environment with sanity checks such as ASan or MSan. */
-static int smoke_test_key( mbedtls_svc_key_id_t key )
+static int smoke_test_key(mbedtls_svc_key_id_t key)
{
int ok = 0;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -672,88 +664,88 @@
size_t length;
mbedtls_svc_key_id_t key2 = MBEDTLS_SVC_KEY_ID_INIT;
- SMOKE_ASSERT( psa_get_key_attributes( key, &attributes ) );
+ SMOKE_ASSERT(psa_get_key_attributes(key, &attributes));
- SMOKE_ASSERT( psa_export_key( key,
- buffer, sizeof( buffer ), &length ) );
- SMOKE_ASSERT( psa_export_public_key( key,
- buffer, sizeof( buffer ), &length ) );
+ SMOKE_ASSERT(psa_export_key(key,
+ buffer, sizeof(buffer), &length));
+ SMOKE_ASSERT(psa_export_public_key(key,
+ buffer, sizeof(buffer), &length));
- SMOKE_ASSERT( psa_copy_key( key, &attributes, &key2 ) );
- if( ! mbedtls_svc_key_id_is_null( key2 ) )
- PSA_ASSERT( psa_destroy_key( key2 ) );
+ SMOKE_ASSERT(psa_copy_key(key, &attributes, &key2));
+ if (!mbedtls_svc_key_id_is_null(key2)) {
+ PSA_ASSERT(psa_destroy_key(key2));
+ }
- SMOKE_ASSERT( psa_mac_sign_setup( &mac_operation, key, PSA_ALG_CMAC ) );
- PSA_ASSERT( psa_mac_abort( &mac_operation ) );
- SMOKE_ASSERT( psa_mac_verify_setup( &mac_operation, key,
- PSA_ALG_HMAC( PSA_ALG_SHA_256 ) ) );
- PSA_ASSERT( psa_mac_abort( &mac_operation ) );
+ SMOKE_ASSERT(psa_mac_sign_setup(&mac_operation, key, PSA_ALG_CMAC));
+ PSA_ASSERT(psa_mac_abort(&mac_operation));
+ SMOKE_ASSERT(psa_mac_verify_setup(&mac_operation, key,
+ PSA_ALG_HMAC(PSA_ALG_SHA_256)));
+ PSA_ASSERT(psa_mac_abort(&mac_operation));
- SMOKE_ASSERT( psa_cipher_encrypt_setup( &cipher_operation, key,
- PSA_ALG_CTR ) );
- PSA_ASSERT( psa_cipher_abort( &cipher_operation ) );
- SMOKE_ASSERT( psa_cipher_decrypt_setup( &cipher_operation, key,
- PSA_ALG_CTR ) );
- PSA_ASSERT( psa_cipher_abort( &cipher_operation ) );
+ SMOKE_ASSERT(psa_cipher_encrypt_setup(&cipher_operation, key,
+ PSA_ALG_CTR));
+ PSA_ASSERT(psa_cipher_abort(&cipher_operation));
+ SMOKE_ASSERT(psa_cipher_decrypt_setup(&cipher_operation, key,
+ PSA_ALG_CTR));
+ PSA_ASSERT(psa_cipher_abort(&cipher_operation));
- SMOKE_ASSERT( psa_aead_encrypt( key, PSA_ALG_CCM,
- buffer, sizeof( buffer ),
- NULL, 0,
- buffer, sizeof( buffer),
- buffer, sizeof( buffer), &length ) );
- SMOKE_ASSERT( psa_aead_decrypt( key, PSA_ALG_CCM,
- buffer, sizeof( buffer ),
- NULL, 0,
- buffer, sizeof( buffer),
- buffer, sizeof( buffer), &length ) );
+ SMOKE_ASSERT(psa_aead_encrypt(key, PSA_ALG_CCM,
+ buffer, sizeof(buffer),
+ NULL, 0,
+ buffer, sizeof(buffer),
+ buffer, sizeof(buffer), &length));
+ SMOKE_ASSERT(psa_aead_decrypt(key, PSA_ALG_CCM,
+ buffer, sizeof(buffer),
+ NULL, 0,
+ buffer, sizeof(buffer),
+ buffer, sizeof(buffer), &length));
- SMOKE_ASSERT( psa_sign_hash( key, PSA_ALG_ECDSA_ANY,
+ SMOKE_ASSERT(psa_sign_hash(key, PSA_ALG_ECDSA_ANY,
+ buffer, 32,
+ buffer, sizeof(buffer), &length));
+ SMOKE_ASSERT(psa_verify_hash(key, PSA_ALG_ECDSA_ANY,
buffer, 32,
- buffer, sizeof( buffer ), &length ) );
- SMOKE_ASSERT( psa_verify_hash( key, PSA_ALG_ECDSA_ANY,
- buffer, 32,
- buffer, sizeof( buffer ) ) );
+ buffer, sizeof(buffer)));
- SMOKE_ASSERT( psa_asymmetric_encrypt( key, PSA_ALG_RSA_PKCS1V15_CRYPT,
- buffer, 10, NULL, 0,
- buffer, sizeof( buffer ), &length ) );
- SMOKE_ASSERT( psa_asymmetric_decrypt( key, PSA_ALG_RSA_PKCS1V15_CRYPT,
- buffer, sizeof( buffer ), NULL, 0,
- buffer, sizeof( buffer ), &length ) );
+ SMOKE_ASSERT(psa_asymmetric_encrypt(key, PSA_ALG_RSA_PKCS1V15_CRYPT,
+ buffer, 10, NULL, 0,
+ buffer, sizeof(buffer), &length));
+ SMOKE_ASSERT(psa_asymmetric_decrypt(key, PSA_ALG_RSA_PKCS1V15_CRYPT,
+ buffer, sizeof(buffer), NULL, 0,
+ buffer, sizeof(buffer), &length));
#if defined(MBEDTLS_SHA256_C)
/* Try the key in a plain key derivation. */
- PSA_ASSERT( psa_key_derivation_setup( &derivation_operation,
- PSA_ALG_HKDF( PSA_ALG_SHA_256 ) ) );
- PSA_ASSERT( psa_key_derivation_input_bytes( &derivation_operation,
- PSA_KEY_DERIVATION_INPUT_SALT,
- NULL, 0 ) );
- SMOKE_ASSERT( psa_key_derivation_input_key( &derivation_operation,
- PSA_KEY_DERIVATION_INPUT_SECRET,
- key ) );
- PSA_ASSERT( psa_key_derivation_abort( &derivation_operation ) );
+ PSA_ASSERT(psa_key_derivation_setup(&derivation_operation,
+ PSA_ALG_HKDF(PSA_ALG_SHA_256)));
+ PSA_ASSERT(psa_key_derivation_input_bytes(&derivation_operation,
+ PSA_KEY_DERIVATION_INPUT_SALT,
+ NULL, 0));
+ SMOKE_ASSERT(psa_key_derivation_input_key(&derivation_operation,
+ PSA_KEY_DERIVATION_INPUT_SECRET,
+ key));
+ PSA_ASSERT(psa_key_derivation_abort(&derivation_operation));
/* If the key is asymmetric, try it in a key agreement, both as
* part of a derivation operation and standalone. */
- if( psa_export_public_key( key, buffer, sizeof( buffer ), &length ) ==
- PSA_SUCCESS )
- {
+ if (psa_export_public_key(key, buffer, sizeof(buffer), &length) ==
+ PSA_SUCCESS) {
psa_algorithm_t alg =
- PSA_ALG_KEY_AGREEMENT( PSA_ALG_ECDH,
- PSA_ALG_HKDF( PSA_ALG_SHA_256 ) );
- PSA_ASSERT( psa_key_derivation_setup( &derivation_operation, alg ) );
- PSA_ASSERT( psa_key_derivation_input_bytes(
- &derivation_operation, PSA_KEY_DERIVATION_INPUT_SALT,
- NULL, 0 ) );
- SMOKE_ASSERT( psa_key_derivation_key_agreement(
- &derivation_operation,
- PSA_KEY_DERIVATION_INPUT_SECRET,
- key, buffer, length ) );
- PSA_ASSERT( psa_key_derivation_abort( &derivation_operation ) );
+ PSA_ALG_KEY_AGREEMENT(PSA_ALG_ECDH,
+ PSA_ALG_HKDF(PSA_ALG_SHA_256));
+ PSA_ASSERT(psa_key_derivation_setup(&derivation_operation, alg));
+ PSA_ASSERT(psa_key_derivation_input_bytes(
+ &derivation_operation, PSA_KEY_DERIVATION_INPUT_SALT,
+ NULL, 0));
+ SMOKE_ASSERT(psa_key_derivation_key_agreement(
+ &derivation_operation,
+ PSA_KEY_DERIVATION_INPUT_SECRET,
+ key, buffer, length));
+ PSA_ASSERT(psa_key_derivation_abort(&derivation_operation));
- SMOKE_ASSERT( psa_raw_key_agreement(
- alg, key, buffer, length,
- buffer, sizeof( buffer ), &length ) );
+ SMOKE_ASSERT(psa_raw_key_agreement(
+ alg, key, buffer, length,
+ buffer, sizeof(buffer), &length));
}
#endif /* MBEDTLS_SHA256_C */
@@ -764,22 +756,23 @@
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- return( ok );
+ return ok;
}
-static void psa_purge_storage( void )
+static void psa_purge_storage(void)
{
/* The generic code in mbedtls_test_psa_purge_key_storage()
* (which is called by PSA_DONE()) doesn't take care of things that are
* specific to dynamic secure elements. */
psa_key_location_t location;
/* Purge the transaction file. */
- psa_crypto_stop_transaction( );
+ psa_crypto_stop_transaction();
/* Purge driver persistent data. */
- for( location = 0; location < PSA_MAX_SE_LOCATION; location++ )
- psa_destroy_se_persistent_data( location );
+ for (location = 0; location < PSA_MAX_SE_LOCATION; location++) {
+ psa_destroy_se_persistent_data(location);
+ }
}
/* END_HEADER */
@@ -790,205 +783,207 @@
*/
/* BEGIN_CASE */
-void register_one( int location, int version, int expected_status_arg )
+void register_one(int location, int version, int expected_status_arg)
{
psa_status_t expected_status = expected_status_arg;
psa_drv_se_t driver;
- memset( &driver, 0, sizeof( driver ) );
+ memset(&driver, 0, sizeof(driver));
driver.hal_version = version;
- TEST_EQUAL( psa_register_se_driver( location, &driver ),
- expected_status );
+ TEST_EQUAL(psa_register_se_driver(location, &driver),
+ expected_status);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void register_twice( int count )
+void register_twice(int count)
{
psa_drv_se_t driver;
psa_key_location_t location;
psa_key_location_t max = MIN_DRIVER_LOCATION + count;
- memset( &driver, 0, sizeof( driver ) );
+ memset(&driver, 0, sizeof(driver));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
- for( location = MIN_DRIVER_LOCATION; location < max; location++ )
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- for( location = MIN_DRIVER_LOCATION; location < max; location++ )
- TEST_EQUAL( psa_register_se_driver( location, &driver ),
- PSA_ERROR_ALREADY_EXISTS );
+ for (location = MIN_DRIVER_LOCATION; location < max; location++) {
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ }
+ for (location = MIN_DRIVER_LOCATION; location < max; location++) {
+ TEST_EQUAL(psa_register_se_driver(location, &driver),
+ PSA_ERROR_ALREADY_EXISTS);
+ }
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void register_max( )
+void register_max()
{
psa_drv_se_t driver;
psa_key_location_t location;
psa_key_location_t max = MIN_DRIVER_LOCATION + PSA_MAX_SE_DRIVERS;
- memset( &driver, 0, sizeof( driver ) );
+ memset(&driver, 0, sizeof(driver));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
- for( location = MIN_DRIVER_LOCATION; location < max; location++ )
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
+ for (location = MIN_DRIVER_LOCATION; location < max; location++) {
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ }
- TEST_EQUAL( psa_register_se_driver( location, &driver ),
- PSA_ERROR_INSUFFICIENT_MEMORY );
+ TEST_EQUAL(psa_register_se_driver(location, &driver),
+ PSA_ERROR_INSUFFICIENT_MEMORY);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void key_creation_import_export( int lifetime_arg, int min_slot, int restart )
+void key_creation_import_export(int lifetime_arg, int min_slot, int restart)
{
psa_drv_se_t driver;
psa_drv_se_key_management_t key_management;
psa_key_lifetime_t lifetime = (psa_key_lifetime_t) lifetime_arg;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
mbedtls_svc_key_id_t returned_id = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_handle_t handle;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- const uint8_t key_material[3] = {0xfa, 0xca, 0xde};
- uint8_t exported[sizeof( key_material )];
+ const uint8_t key_material[3] = { 0xfa, 0xca, 0xde };
+ uint8_t exported[sizeof(key_material)];
size_t exported_length;
- TEST_USES_KEY_ID( id );
+ TEST_USES_KEY_ID(id);
- memset( &driver, 0, sizeof( driver ) );
- memset( &key_management, 0, sizeof( key_management ) );
+ memset(&driver, 0, sizeof(driver));
+ memset(&key_management, 0, sizeof(key_management));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
driver.key_management = &key_management;
- driver.persistent_data_size = sizeof( ram_slot_usage_t );
+ driver.persistent_data_size = sizeof(ram_slot_usage_t);
key_management.p_allocate = ram_allocate;
key_management.p_import = ram_import;
key_management.p_destroy = ram_destroy;
key_management.p_export = ram_export;
ram_min_slot = min_slot;
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
/* Create a key. */
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
- PSA_ASSERT( psa_import_key( &attributes,
- key_material, sizeof( key_material ),
- &returned_id ) );
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
+ PSA_ASSERT(psa_import_key(&attributes,
+ key_material, sizeof(key_material),
+ &returned_id));
- if( PSA_KEY_LIFETIME_IS_VOLATILE( lifetime ) )
- {
+ if (PSA_KEY_LIFETIME_IS_VOLATILE(lifetime)) {
/* For volatile keys, check no persistent data was created */
- if( ! check_no_persistent_data( location ) )
+ if (!check_no_persistent_data(location)) {
goto exit;
- }
- else
- {
+ }
+ } else {
/* For persistent keys, check persistent data */
- if( ! check_persistent_data( location,
- &ram_shadow_slot_usage,
- sizeof( ram_shadow_slot_usage ) ) )
+ if (!check_persistent_data(location,
+ &ram_shadow_slot_usage,
+ sizeof(ram_shadow_slot_usage))) {
goto exit;
+ }
}
/* Test that the key was created in the expected slot. */
- TEST_EQUAL( ram_slots[min_slot].type, PSA_KEY_TYPE_RAW_DATA );
+ TEST_EQUAL(ram_slots[min_slot].type, PSA_KEY_TYPE_RAW_DATA);
/* Maybe restart, to check that the information is saved correctly. */
- if( restart )
- {
- mbedtls_psa_crypto_free( );
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
+ if (restart) {
+ mbedtls_psa_crypto_free();
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
- if( PSA_KEY_LIFETIME_IS_VOLATILE( lifetime ) )
- {
+ if (PSA_KEY_LIFETIME_IS_VOLATILE(lifetime)) {
/* Check that the PSA core has no knowledge of the volatile key */
- TEST_ASSERT( psa_open_key( returned_id, &handle ) ==
- PSA_ERROR_DOES_NOT_EXIST );
+ TEST_ASSERT(psa_open_key(returned_id, &handle) ==
+ PSA_ERROR_DOES_NOT_EXIST);
/* Drop data from our mockup driver */
ram_slots_reset();
ram_min_slot = min_slot;
/* Re-import key */
- PSA_ASSERT( psa_import_key( &attributes,
- key_material, sizeof( key_material ),
- &returned_id ) );
- }
- else
- {
+ PSA_ASSERT(psa_import_key(&attributes,
+ key_material, sizeof(key_material),
+ &returned_id));
+ } else {
/* Check the persistent key file */
- if( ! check_persistent_data( location,
- &ram_shadow_slot_usage,
- sizeof( ram_shadow_slot_usage ) ) )
+ if (!check_persistent_data(location,
+ &ram_shadow_slot_usage,
+ sizeof(ram_shadow_slot_usage))) {
goto exit;
+ }
}
}
/* Test that the key was created in the expected slot. */
- TEST_EQUAL( ram_slots[min_slot].type, PSA_KEY_TYPE_RAW_DATA );
+ TEST_EQUAL(ram_slots[min_slot].type, PSA_KEY_TYPE_RAW_DATA);
/* Test the key attributes, including the reported slot number. */
- psa_set_key_bits( &attributes,
- PSA_BYTES_TO_BITS( sizeof( key_material ) ) );
- psa_set_key_slot_number( &attributes, min_slot );
+ psa_set_key_bits(&attributes,
+ PSA_BYTES_TO_BITS(sizeof(key_material)));
+ psa_set_key_slot_number(&attributes, min_slot);
- if( PSA_KEY_LIFETIME_IS_VOLATILE( lifetime ) )
+ if (PSA_KEY_LIFETIME_IS_VOLATILE(lifetime)) {
attributes.core.id = returned_id;
- else
- psa_set_key_id( &attributes, returned_id );
+ } else {
+ psa_set_key_id(&attributes, returned_id);
+ }
- if( ! check_key_attributes( returned_id, &attributes ) )
+ if (!check_key_attributes(returned_id, &attributes)) {
goto exit;
+ }
/* Test the key data. */
- PSA_ASSERT( psa_export_key( returned_id,
- exported, sizeof( exported ),
- &exported_length ) );
- ASSERT_COMPARE( key_material, sizeof( key_material ),
- exported, exported_length );
+ PSA_ASSERT(psa_export_key(returned_id,
+ exported, sizeof(exported),
+ &exported_length));
+ ASSERT_COMPARE(key_material, sizeof(key_material),
+ exported, exported_length);
- PSA_ASSERT( psa_destroy_key( returned_id ) );
- if( ! check_persistent_data( location,
- &ram_shadow_slot_usage,
- sizeof( ram_shadow_slot_usage ) ) )
+ PSA_ASSERT(psa_destroy_key(returned_id));
+ if (!check_persistent_data(location,
+ &ram_shadow_slot_usage,
+ sizeof(ram_shadow_slot_usage))) {
goto exit;
- TEST_EQUAL( psa_open_key( returned_id, &handle ),
- PSA_ERROR_DOES_NOT_EXIST );
+ }
+ TEST_EQUAL(psa_open_key(returned_id, &handle),
+ PSA_ERROR_DOES_NOT_EXIST);
/* Test that the key has been erased from the designated slot. */
- TEST_EQUAL( ram_slots[min_slot].type, 0 );
+ TEST_EQUAL(ram_slots[min_slot].type, 0);
exit:
- PSA_DONE( );
- ram_slots_reset( );
- psa_purge_storage( );
+ PSA_DONE();
+ ram_slots_reset();
+ psa_purge_storage();
}
/* END_CASE */
/* BEGIN_CASE */
-void key_creation_in_chosen_slot( int slot_arg,
- int restart,
- int expected_status_arg )
+void key_creation_in_chosen_slot(int slot_arg,
+ int restart,
+ int expected_status_arg)
{
psa_key_slot_number_t wanted_slot = slot_arg;
psa_status_t expected_status = expected_status_arg;
@@ -996,200 +991,208 @@
psa_drv_se_t driver;
psa_drv_se_key_management_t key_management;
psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
mbedtls_svc_key_id_t returned_id;
psa_key_handle_t handle;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- const uint8_t key_material[3] = {0xfa, 0xca, 0xde};
+ const uint8_t key_material[3] = { 0xfa, 0xca, 0xde };
- TEST_USES_KEY_ID( id );
+ TEST_USES_KEY_ID(id);
- memset( &driver, 0, sizeof( driver ) );
- memset( &key_management, 0, sizeof( key_management ) );
+ memset(&driver, 0, sizeof(driver));
+ memset(&key_management, 0, sizeof(key_management));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
driver.key_management = &key_management;
- driver.persistent_data_size = sizeof( ram_slot_usage_t );
+ driver.persistent_data_size = sizeof(ram_slot_usage_t);
key_management.p_validate_slot_number = ram_validate_slot_number;
key_management.p_import = ram_import;
key_management.p_destroy = ram_destroy;
key_management.p_export = ram_export;
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
/* Create a key. */
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
- psa_set_key_slot_number( &attributes, wanted_slot );
- status = psa_import_key( &attributes,
- key_material, sizeof( key_material ),
- &returned_id );
- TEST_EQUAL( status, expected_status );
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
+ psa_set_key_slot_number(&attributes, wanted_slot);
+ status = psa_import_key(&attributes,
+ key_material, sizeof(key_material),
+ &returned_id);
+ TEST_EQUAL(status, expected_status);
- if( status != PSA_SUCCESS )
+ if (status != PSA_SUCCESS) {
goto exit;
- if( ! check_persistent_data( location,
- &ram_shadow_slot_usage,
- sizeof( ram_shadow_slot_usage ) ) )
+ }
+ if (!check_persistent_data(location,
+ &ram_shadow_slot_usage,
+ sizeof(ram_shadow_slot_usage))) {
goto exit;
+ }
/* Maybe restart, to check that the information is saved correctly. */
- if( restart )
- {
- mbedtls_psa_crypto_free( );
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
- if( ! check_persistent_data( location,
- &ram_shadow_slot_usage,
- sizeof( ram_shadow_slot_usage ) ) )
+ if (restart) {
+ mbedtls_psa_crypto_free();
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
+ if (!check_persistent_data(location,
+ &ram_shadow_slot_usage,
+ sizeof(ram_shadow_slot_usage))) {
goto exit;
+ }
}
/* Test that the key was created in the expected slot. */
- TEST_EQUAL( ram_slots[wanted_slot].type, PSA_KEY_TYPE_RAW_DATA );
+ TEST_EQUAL(ram_slots[wanted_slot].type, PSA_KEY_TYPE_RAW_DATA);
/* Test that the key is reported with the correct attributes,
* including the expected slot. */
- PSA_ASSERT( psa_get_key_attributes( id, &attributes ) );
+ PSA_ASSERT(psa_get_key_attributes(id, &attributes));
- PSA_ASSERT( psa_destroy_key( id ) );
- if( ! check_persistent_data( location,
- &ram_shadow_slot_usage,
- sizeof( ram_shadow_slot_usage ) ) )
+ PSA_ASSERT(psa_destroy_key(id));
+ if (!check_persistent_data(location,
+ &ram_shadow_slot_usage,
+ sizeof(ram_shadow_slot_usage))) {
goto exit;
- TEST_EQUAL( psa_open_key( id, &handle ), PSA_ERROR_DOES_NOT_EXIST );
+ }
+ TEST_EQUAL(psa_open_key(id, &handle), PSA_ERROR_DOES_NOT_EXIST);
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- PSA_DONE( );
- ram_slots_reset( );
- psa_purge_storage( );
+ PSA_DONE();
+ ram_slots_reset();
+ psa_purge_storage();
}
/* END_CASE */
/* BEGIN_CASE */
-void import_key_smoke( int type_arg, int alg_arg,
- data_t *key_material )
+void import_key_smoke(int type_arg, int alg_arg,
+ data_t *key_material)
{
psa_key_type_t type = type_arg;
psa_algorithm_t alg = alg_arg;
psa_drv_se_t driver;
psa_drv_se_key_management_t key_management;
psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
mbedtls_svc_key_id_t returned_id;
psa_key_handle_t handle;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- TEST_USES_KEY_ID( id );
+ TEST_USES_KEY_ID(id);
- memset( &driver, 0, sizeof( driver ) );
- memset( &key_management, 0, sizeof( key_management ) );
+ memset(&driver, 0, sizeof(driver));
+ memset(&key_management, 0, sizeof(key_management));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
driver.key_management = &key_management;
- driver.persistent_data_size = sizeof( psa_key_slot_number_t );
+ driver.persistent_data_size = sizeof(psa_key_slot_number_t);
key_management.p_allocate = counter_allocate;
key_management.p_import = null_import;
key_management.p_destroy = null_destroy;
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
/* Create a key. */
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_usage_flags( &attributes,
- PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH |
- PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT |
- PSA_KEY_USAGE_EXPORT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, type );
- PSA_ASSERT( psa_import_key( &attributes,
- key_material->x, key_material->len,
- &returned_id ) );
- if( ! check_persistent_data( location,
- &shadow_counter, sizeof( shadow_counter ) ) )
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_usage_flags(&attributes,
+ PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH |
+ PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT |
+ PSA_KEY_USAGE_EXPORT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, type);
+ PSA_ASSERT(psa_import_key(&attributes,
+ key_material->x, key_material->len,
+ &returned_id));
+ if (!check_persistent_data(location,
+ &shadow_counter, sizeof(shadow_counter))) {
goto exit;
+ }
/* Do stuff with the key. */
- if( ! smoke_test_key( id ) )
+ if (!smoke_test_key(id)) {
goto exit;
+ }
/* Restart and try again. */
- mbedtls_psa_crypto_free( );
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
- if( ! check_persistent_data( location,
- &shadow_counter, sizeof( shadow_counter ) ) )
+ mbedtls_psa_crypto_free();
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
+ if (!check_persistent_data(location,
+ &shadow_counter, sizeof(shadow_counter))) {
goto exit;
- if( ! smoke_test_key( id ) )
+ }
+ if (!smoke_test_key(id)) {
goto exit;
+ }
/* We're done. */
- PSA_ASSERT( psa_destroy_key( id ) );
- if( ! check_persistent_data( location,
- &shadow_counter, sizeof( shadow_counter ) ) )
+ PSA_ASSERT(psa_destroy_key(id));
+ if (!check_persistent_data(location,
+ &shadow_counter, sizeof(shadow_counter))) {
goto exit;
- TEST_EQUAL( psa_open_key( id, &handle ), PSA_ERROR_DOES_NOT_EXIST );
+ }
+ TEST_EQUAL(psa_open_key(id, &handle), PSA_ERROR_DOES_NOT_EXIST);
exit:
- PSA_DONE( );
- counter_reset( );
- psa_purge_storage( );
+ PSA_DONE();
+ counter_reset();
+ psa_purge_storage();
}
/* END_CASE */
/* BEGIN_CASE */
-void generate_key_not_supported( int type_arg, int bits_arg )
+void generate_key_not_supported(int type_arg, int bits_arg)
{
psa_key_type_t type = type_arg;
size_t bits = bits_arg;
psa_drv_se_t driver;
psa_drv_se_key_management_t key_management;
psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
mbedtls_svc_key_id_t returned_id;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- TEST_USES_KEY_ID( id );
+ TEST_USES_KEY_ID(id);
- memset( &driver, 0, sizeof( driver ) );
- memset( &key_management, 0, sizeof( key_management ) );
+ memset(&driver, 0, sizeof(driver));
+ memset(&key_management, 0, sizeof(key_management));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
driver.key_management = &key_management;
- driver.persistent_data_size = sizeof( psa_key_slot_number_t );
+ driver.persistent_data_size = sizeof(psa_key_slot_number_t);
key_management.p_allocate = counter_allocate;
/* No p_generate method */
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_type( &attributes, type );
- psa_set_key_bits( &attributes, bits );
- TEST_EQUAL( psa_generate_key( &attributes, &returned_id ),
- PSA_ERROR_NOT_SUPPORTED );
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_type(&attributes, type);
+ psa_set_key_bits(&attributes, bits);
+ TEST_EQUAL(psa_generate_key(&attributes, &returned_id),
+ PSA_ERROR_NOT_SUPPORTED);
exit:
- PSA_DONE( );
- counter_reset( );
- psa_purge_storage( );
+ PSA_DONE();
+ counter_reset();
+ psa_purge_storage();
}
/* END_CASE */
/* BEGIN_CASE */
-void generate_key_smoke( int type_arg, int bits_arg, int alg_arg )
+void generate_key_smoke(int type_arg, int bits_arg, int alg_arg)
{
psa_key_type_t type = type_arg;
psa_key_bits_t bits = bits_arg;
@@ -1197,88 +1200,93 @@
psa_drv_se_t driver;
psa_drv_se_key_management_t key_management;
psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
mbedtls_svc_key_id_t returned_id;
psa_key_handle_t handle;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- TEST_USES_KEY_ID( id );
+ TEST_USES_KEY_ID(id);
- memset( &driver, 0, sizeof( driver ) );
- memset( &key_management, 0, sizeof( key_management ) );
+ memset(&driver, 0, sizeof(driver));
+ memset(&key_management, 0, sizeof(key_management));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
driver.key_management = &key_management;
- driver.persistent_data_size = sizeof( psa_key_slot_number_t );
+ driver.persistent_data_size = sizeof(psa_key_slot_number_t);
key_management.p_allocate = counter_allocate;
key_management.p_generate = null_generate;
key_management.p_destroy = null_destroy;
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
/* Create a key. */
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_usage_flags( &attributes,
- PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH |
- PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT |
- PSA_KEY_USAGE_EXPORT );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, type );
- psa_set_key_bits( &attributes, bits );
- PSA_ASSERT( psa_generate_key( &attributes, &returned_id ) );
- if( ! check_persistent_data( location,
- &shadow_counter, sizeof( shadow_counter ) ) )
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_usage_flags(&attributes,
+ PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH |
+ PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT |
+ PSA_KEY_USAGE_EXPORT);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, type);
+ psa_set_key_bits(&attributes, bits);
+ PSA_ASSERT(psa_generate_key(&attributes, &returned_id));
+ if (!check_persistent_data(location,
+ &shadow_counter, sizeof(shadow_counter))) {
goto exit;
+ }
/* Do stuff with the key. */
- if( ! smoke_test_key( id ) )
+ if (!smoke_test_key(id)) {
goto exit;
+ }
/* Restart and try again. */
- mbedtls_psa_crypto_free( );
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
- if( ! check_persistent_data( location,
- &shadow_counter, sizeof( shadow_counter ) ) )
+ mbedtls_psa_crypto_free();
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
+ if (!check_persistent_data(location,
+ &shadow_counter, sizeof(shadow_counter))) {
goto exit;
- if( ! smoke_test_key( id ) )
+ }
+ if (!smoke_test_key(id)) {
goto exit;
+ }
/* We're done. */
- PSA_ASSERT( psa_destroy_key( id ) );
- if( ! check_persistent_data( location,
- &shadow_counter, sizeof( shadow_counter ) ) )
+ PSA_ASSERT(psa_destroy_key(id));
+ if (!check_persistent_data(location,
+ &shadow_counter, sizeof(shadow_counter))) {
goto exit;
- TEST_EQUAL( psa_open_key( id, &handle ), PSA_ERROR_DOES_NOT_EXIST );
+ }
+ TEST_EQUAL(psa_open_key(id, &handle), PSA_ERROR_DOES_NOT_EXIST);
exit:
- PSA_DONE( );
- counter_reset( );
- psa_purge_storage( );
+ PSA_DONE();
+ counter_reset();
+ psa_purge_storage();
}
/* END_CASE */
/* BEGIN_CASE */
-void sign_verify( int flow,
- int type_arg, int alg_arg,
- int bits_arg, data_t *key_material,
- data_t *input )
+void sign_verify(int flow,
+ int type_arg, int alg_arg,
+ int bits_arg, data_t *key_material,
+ data_t *input)
{
psa_key_type_t type = type_arg;
psa_algorithm_t alg = alg_arg;
size_t bits = bits_arg;
/* Pass bits=0 to import, bits>0 to fake-generate */
- int generating = ( bits != 0 );
+ int generating = (bits != 0);
psa_drv_se_t driver;
psa_drv_se_key_management_t key_management;
psa_drv_se_asymmetric_t asymmetric;
psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
mbedtls_svc_key_id_t returned_id;
mbedtls_svc_key_id_t sw_key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t sw_attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -1286,23 +1294,23 @@
uint8_t signature[PSA_SIGNATURE_MAX_SIZE];
size_t signature_length;
- TEST_USES_KEY_ID( id );
+ TEST_USES_KEY_ID(id);
- memset( &driver, 0, sizeof( driver ) );
- memset( &key_management, 0, sizeof( key_management ) );
- memset( &asymmetric, 0, sizeof( asymmetric ) );
+ memset(&driver, 0, sizeof(driver));
+ memset(&key_management, 0, sizeof(key_management));
+ memset(&asymmetric, 0, sizeof(asymmetric));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
driver.key_management = &key_management;
driver.asymmetric = &asymmetric;
- driver.persistent_data_size = sizeof( ram_slot_usage_t );
+ driver.persistent_data_size = sizeof(ram_slot_usage_t);
key_management.p_allocate = ram_allocate;
key_management.p_destroy = ram_destroy;
- if( generating )
+ if (generating) {
key_management.p_generate = ram_fake_generate;
- else
+ } else {
key_management.p_import = ram_import;
- switch( flow )
- {
+ }
+ switch (flow) {
case SIGN_IN_SOFTWARE_AND_PARALLEL_CREATION:
break;
case SIGN_IN_DRIVER_AND_PARALLEL_CREATION:
@@ -1313,208 +1321,206 @@
key_management.p_export_public = ram_export_public;
break;
default:
- TEST_ASSERT( ! "unsupported flow (should be SIGN_IN_xxx)" );
+ TEST_ASSERT(!"unsupported flow (should be SIGN_IN_xxx)");
break;
}
asymmetric.p_verify = ram_verify;
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
/* Prepare to create two keys with the same key material: a transparent
* key, and one that goes through the driver. */
- psa_set_key_usage_flags( &sw_attributes,
- PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH );
- psa_set_key_algorithm( &sw_attributes, alg );
- psa_set_key_type( &sw_attributes, type );
+ psa_set_key_usage_flags(&sw_attributes,
+ PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH);
+ psa_set_key_algorithm(&sw_attributes, alg);
+ psa_set_key_type(&sw_attributes, type);
drv_attributes = sw_attributes;
- psa_set_key_id( &drv_attributes, id );
- psa_set_key_lifetime( &drv_attributes, lifetime );
+ psa_set_key_id(&drv_attributes, id);
+ psa_set_key_lifetime(&drv_attributes, lifetime);
/* Create the key in the driver. */
- if( generating )
- {
- psa_set_key_bits( &drv_attributes, bits );
- PSA_ASSERT( psa_generate_key( &drv_attributes, &returned_id ) );
+ if (generating) {
+ psa_set_key_bits(&drv_attributes, bits);
+ PSA_ASSERT(psa_generate_key(&drv_attributes, &returned_id));
/* Since we called a generate method that does not actually
* generate material, store the desired result of generation in
* the mock secure element storage. */
- PSA_ASSERT( psa_get_key_attributes( id, &drv_attributes ) );
- TEST_EQUAL( key_material->len, PSA_BITS_TO_BYTES( bits ) );
- memcpy( ram_slots[ram_min_slot].content, key_material->x,
- key_material->len );
- }
- else
- {
- PSA_ASSERT( psa_import_key( &drv_attributes,
- key_material->x, key_material->len,
- &returned_id ) );
+ PSA_ASSERT(psa_get_key_attributes(id, &drv_attributes));
+ TEST_EQUAL(key_material->len, PSA_BITS_TO_BYTES(bits));
+ memcpy(ram_slots[ram_min_slot].content, key_material->x,
+ key_material->len);
+ } else {
+ PSA_ASSERT(psa_import_key(&drv_attributes,
+ key_material->x, key_material->len,
+ &returned_id));
}
/* Either import the same key in software, or export the driver's
* public key and import that. */
- switch( flow )
- {
+ switch (flow) {
case SIGN_IN_SOFTWARE_AND_PARALLEL_CREATION:
case SIGN_IN_DRIVER_AND_PARALLEL_CREATION:
- PSA_ASSERT( psa_import_key( &sw_attributes,
- key_material->x, key_material->len,
- &sw_key ) );
+ PSA_ASSERT(psa_import_key(&sw_attributes,
+ key_material->x, key_material->len,
+ &sw_key));
break;
case SIGN_IN_DRIVER_THEN_EXPORT_PUBLIC:
{
- uint8_t public_key[PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE( PSA_VENDOR_ECC_MAX_CURVE_BITS )];
+ uint8_t public_key[PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(PSA_VENDOR_ECC_MAX_CURVE_BITS)
+ ];
size_t public_key_length;
- PSA_ASSERT( psa_export_public_key( id,
- public_key, sizeof( public_key ),
- &public_key_length ) );
- psa_set_key_type( &sw_attributes,
- PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR( type ) );
- PSA_ASSERT( psa_import_key( &sw_attributes,
- public_key, public_key_length,
- &sw_key ) );
+ PSA_ASSERT(psa_export_public_key(id,
+ public_key, sizeof(public_key),
+ &public_key_length));
+ psa_set_key_type(&sw_attributes,
+ PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(type));
+ PSA_ASSERT(psa_import_key(&sw_attributes,
+ public_key, public_key_length,
+ &sw_key));
break;
}
}
/* Sign with the chosen key. */
- switch( flow )
- {
+ switch (flow) {
case SIGN_IN_DRIVER_AND_PARALLEL_CREATION:
case SIGN_IN_DRIVER_THEN_EXPORT_PUBLIC:
PSA_ASSERT_VIA_DRIVER(
- psa_sign_hash( id, alg,
- input->x, input->len,
- signature, sizeof( signature ),
- &signature_length ),
- PSA_SUCCESS );
+ psa_sign_hash(id, alg,
+ input->x, input->len,
+ signature, sizeof(signature),
+ &signature_length),
+ PSA_SUCCESS);
break;
case SIGN_IN_SOFTWARE_AND_PARALLEL_CREATION:
- PSA_ASSERT( psa_sign_hash( sw_key, alg,
- input->x, input->len,
- signature, sizeof( signature ),
- &signature_length ) );
+ PSA_ASSERT(psa_sign_hash(sw_key, alg,
+ input->x, input->len,
+ signature, sizeof(signature),
+ &signature_length));
break;
}
/* Verify with both keys. */
- PSA_ASSERT( psa_verify_hash( sw_key, alg,
- input->x, input->len,
- signature, signature_length ) );
+ PSA_ASSERT(psa_verify_hash(sw_key, alg,
+ input->x, input->len,
+ signature, signature_length));
PSA_ASSERT_VIA_DRIVER(
- psa_verify_hash( id, alg,
- input->x, input->len,
- signature, signature_length ),
- PSA_SUCCESS );
+ psa_verify_hash(id, alg,
+ input->x, input->len,
+ signature, signature_length),
+ PSA_SUCCESS);
/* Change the signature and verify again. */
signature[0] ^= 1;
- TEST_EQUAL( psa_verify_hash( sw_key, alg,
- input->x, input->len,
- signature, signature_length ),
- PSA_ERROR_INVALID_SIGNATURE );
+ TEST_EQUAL(psa_verify_hash(sw_key, alg,
+ input->x, input->len,
+ signature, signature_length),
+ PSA_ERROR_INVALID_SIGNATURE);
PSA_ASSERT_VIA_DRIVER(
- psa_verify_hash( id, alg,
- input->x, input->len,
- signature, signature_length ),
- PSA_ERROR_INVALID_SIGNATURE );
+ psa_verify_hash(id, alg,
+ input->x, input->len,
+ signature, signature_length),
+ PSA_ERROR_INVALID_SIGNATURE);
exit:
/*
* Driver key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &drv_attributes );
+ psa_reset_key_attributes(&drv_attributes);
- psa_destroy_key( id );
- psa_destroy_key( sw_key );
- PSA_DONE( );
- ram_slots_reset( );
- psa_purge_storage( );
+ psa_destroy_key(id);
+ psa_destroy_key(sw_key);
+ PSA_DONE();
+ ram_slots_reset();
+ psa_purge_storage();
}
/* END_CASE */
/* BEGIN_CASE */
-void register_key_smoke_test( int lifetime_arg,
- int owner_id_arg,
- int id_arg,
- int validate,
- int expected_status_arg )
+void register_key_smoke_test(int lifetime_arg,
+ int owner_id_arg,
+ int id_arg,
+ int validate,
+ int expected_status_arg)
{
psa_key_lifetime_t lifetime = lifetime_arg;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
psa_status_t expected_status = expected_status_arg;
psa_drv_se_t driver;
psa_drv_se_key_management_t key_management;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( owner_id_arg, id_arg );
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(owner_id_arg, id_arg);
psa_key_handle_t handle;
size_t bit_size = 48;
psa_key_slot_number_t wanted_slot = 0x123456789;
psa_status_t status;
- TEST_USES_KEY_ID( id );
+ TEST_USES_KEY_ID(id);
- memset( &driver, 0, sizeof( driver ) );
+ memset(&driver, 0, sizeof(driver));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
- memset( &key_management, 0, sizeof( key_management ) );
+ memset(&key_management, 0, sizeof(key_management));
driver.key_management = &key_management;
key_management.p_destroy = null_destroy;
- if( validate >= 0 )
- {
+ if (validate >= 0) {
key_management.p_validate_slot_number = validate_slot_number_as_directed;
validate_slot_number_directions.slot_number = wanted_slot;
validate_slot_number_directions.method = PSA_KEY_CREATION_REGISTER;
validate_slot_number_directions.status =
- ( validate > 0 ? PSA_SUCCESS : PSA_ERROR_NOT_PERMITTED );
+ (validate > 0 ? PSA_SUCCESS : PSA_ERROR_NOT_PERMITTED);
}
- mbedtls_test_set_step( 1 );
- PSA_ASSERT( psa_register_se_driver( MIN_DRIVER_LOCATION, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
+ mbedtls_test_set_step(1);
+ PSA_ASSERT(psa_register_se_driver(MIN_DRIVER_LOCATION, &driver));
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
- psa_set_key_bits( &attributes, bit_size );
- psa_set_key_slot_number( &attributes, wanted_slot );
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
+ psa_set_key_bits(&attributes, bit_size);
+ psa_set_key_slot_number(&attributes, wanted_slot);
- status = mbedtls_psa_register_se_key( &attributes );
- TEST_EQUAL( status, expected_status );
+ status = mbedtls_psa_register_se_key(&attributes);
+ TEST_EQUAL(status, expected_status);
- if( status != PSA_SUCCESS )
+ if (status != PSA_SUCCESS) {
goto exit;
+ }
/* Test that the key exists and has the expected attributes. */
- if( ! check_key_attributes( id, &attributes ) )
+ if (!check_key_attributes(id, &attributes)) {
goto exit;
+ }
#if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER)
mbedtls_svc_key_id_t invalid_id =
- mbedtls_svc_key_id_make( owner_id_arg + 1, id_arg );
- TEST_EQUAL( psa_open_key( invalid_id, &handle ), PSA_ERROR_DOES_NOT_EXIST );
+ mbedtls_svc_key_id_make(owner_id_arg + 1, id_arg);
+ TEST_EQUAL(psa_open_key(invalid_id, &handle), PSA_ERROR_DOES_NOT_EXIST);
#endif
- PSA_ASSERT( psa_purge_key( id ) );
+ PSA_ASSERT(psa_purge_key(id));
/* Restart and try again. */
- mbedtls_test_set_step( 2 );
- PSA_SESSION_DONE( );
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
- if( ! check_key_attributes( id, &attributes ) )
+ mbedtls_test_set_step(2);
+ PSA_SESSION_DONE();
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
+ if (!check_key_attributes(id, &attributes)) {
goto exit;
+ }
/* This time, destroy the key. */
- PSA_ASSERT( psa_destroy_key( id ) );
- TEST_EQUAL( psa_open_key( id, &handle ), PSA_ERROR_DOES_NOT_EXIST );
+ PSA_ASSERT(psa_destroy_key(id));
+ TEST_EQUAL(psa_open_key(id, &handle), PSA_ERROR_DOES_NOT_EXIST);
exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( id );
- PSA_DONE( );
- psa_purge_storage( );
- memset( &validate_slot_number_directions, 0,
- sizeof( validate_slot_number_directions ) );
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(id);
+ PSA_DONE();
+ psa_purge_storage();
+ memset(&validate_slot_number_directions, 0,
+ sizeof(validate_slot_number_directions));
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto_se_driver_hal_mocks.function b/tests/suites/test_suite_psa_crypto_se_driver_hal_mocks.function
index 12c58eb..6f28f93 100644
--- a/tests/suites/test_suite_psa_crypto_se_driver_hal_mocks.function
+++ b/tests/suites/test_suite_psa_crypto_se_driver_hal_mocks.function
@@ -7,18 +7,16 @@
/** The location and lifetime used for tests that use a single driver. */
#define TEST_DRIVER_LOCATION 1
#define TEST_SE_PERSISTENT_LIFETIME \
- ( PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION( \
- PSA_KEY_PERSISTENCE_DEFAULT, TEST_DRIVER_LOCATION ) )
+ (PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION( \
+ PSA_KEY_PERSISTENCE_DEFAULT, TEST_DRIVER_LOCATION))
-static struct
-{
+static struct {
uint16_t called;
psa_key_location_t location;
psa_status_t return_value;
} mock_init_data;
-static struct
-{
+static struct {
uint16_t called;
psa_key_slot_number_t key_slot;
psa_key_attributes_t attributes;
@@ -26,8 +24,7 @@
psa_status_t return_value;
} mock_generate_data;
-static struct
-{
+static struct {
uint16_t called;
psa_key_slot_number_t key_slot;
psa_key_attributes_t attributes;
@@ -36,24 +33,21 @@
psa_status_t return_value;
} mock_import_data;
-static struct
-{
+static struct {
uint16_t called;
psa_key_slot_number_t slot_number;
size_t data_size;
psa_status_t return_value;
} mock_export_data;
-static struct
-{
+static struct {
uint16_t called;
psa_key_slot_number_t slot_number;
size_t data_size;
psa_status_t return_value;
} mock_export_public_data;
-static struct
-{
+static struct {
uint16_t called;
psa_key_slot_number_t key_slot;
psa_algorithm_t alg;
@@ -62,8 +56,7 @@
psa_status_t return_value;
} mock_sign_data;
-static struct
-{
+static struct {
uint16_t called;
psa_key_slot_number_t key_slot;
psa_algorithm_t alg;
@@ -72,21 +65,19 @@
psa_status_t return_value;
} mock_verify_data;
-static struct
-{
+static struct {
uint16_t called;
psa_status_t return_value;
} mock_allocate_data;
-static struct
-{
+static struct {
uint16_t called;
psa_key_slot_number_t slot_number;
psa_status_t return_value;
} mock_destroy_data;
#define MAX_KEY_ID_FOR_TEST 10
-static void psa_purge_storage( void )
+static void psa_purge_storage(void)
{
psa_key_id_t id;
psa_key_location_t location;
@@ -94,48 +85,50 @@
/* The tests may have potentially created key ids from 1 to
* MAX_KEY_ID_FOR_TEST. In addition, run the destroy function on key id
* 0, which file-based storage uses as a temporary file. */
- for( id = 0; id <= MAX_KEY_ID_FOR_TEST; id++ )
- psa_destroy_persistent_key( mbedtls_svc_key_id_make( 1, id ) );
+ for (id = 0; id <= MAX_KEY_ID_FOR_TEST; id++) {
+ psa_destroy_persistent_key(mbedtls_svc_key_id_make(1, id));
+ }
/* Purge the transaction file. */
- psa_crypto_stop_transaction( );
+ psa_crypto_stop_transaction();
/* Purge driver persistent data. */
- for( location = 0; location < PSA_MAX_SE_LOCATION; location++ )
- psa_destroy_se_persistent_data( location );
+ for (location = 0; location < PSA_MAX_SE_LOCATION; location++) {
+ psa_destroy_se_persistent_data(location);
+ }
}
-static void mock_teardown( void )
+static void mock_teardown(void)
{
- memset( &mock_init_data, 0, sizeof( mock_init_data ) );
- memset( &mock_import_data, 0, sizeof( mock_import_data ) );
- memset( &mock_export_data, 0, sizeof( mock_export_data ) );
- memset( &mock_export_public_data, 0, sizeof( mock_export_public_data ) );
- memset( &mock_sign_data, 0, sizeof( mock_sign_data ) );
- memset( &mock_verify_data, 0, sizeof( mock_verify_data ) );
- memset( &mock_allocate_data, 0, sizeof( mock_allocate_data ) );
- memset( &mock_destroy_data, 0, sizeof( mock_destroy_data ) );
- memset( &mock_generate_data, 0, sizeof( mock_generate_data ) );
- psa_purge_storage( );
+ memset(&mock_init_data, 0, sizeof(mock_init_data));
+ memset(&mock_import_data, 0, sizeof(mock_import_data));
+ memset(&mock_export_data, 0, sizeof(mock_export_data));
+ memset(&mock_export_public_data, 0, sizeof(mock_export_public_data));
+ memset(&mock_sign_data, 0, sizeof(mock_sign_data));
+ memset(&mock_verify_data, 0, sizeof(mock_verify_data));
+ memset(&mock_allocate_data, 0, sizeof(mock_allocate_data));
+ memset(&mock_destroy_data, 0, sizeof(mock_destroy_data));
+ memset(&mock_generate_data, 0, sizeof(mock_generate_data));
+ psa_purge_storage();
}
-static psa_status_t mock_init( psa_drv_se_context_t *drv_context,
- void *persistent_data,
- psa_key_location_t location )
+static psa_status_t mock_init(psa_drv_se_context_t *drv_context,
+ void *persistent_data,
+ psa_key_location_t location)
{
(void) drv_context;
(void) persistent_data;
mock_init_data.called++;
mock_init_data.location = location;
- return( mock_init_data.return_value );
+ return mock_init_data.return_value;
}
-static psa_status_t mock_generate( psa_drv_se_context_t *drv_context,
- psa_key_slot_number_t key_slot,
- const psa_key_attributes_t *attributes,
- uint8_t *pubkey,
- size_t pubkey_size,
- size_t *pubkey_length )
+static psa_status_t mock_generate(psa_drv_se_context_t *drv_context,
+ psa_key_slot_number_t key_slot,
+ const psa_key_attributes_t *attributes,
+ uint8_t *pubkey,
+ size_t pubkey_size,
+ size_t *pubkey_length)
{
(void) drv_context;
(void) pubkey;
@@ -146,15 +139,15 @@
mock_generate_data.attributes = *attributes;
mock_generate_data.pubkey_size = pubkey_size;
- return( mock_generate_data.return_value );
+ return mock_generate_data.return_value;
}
-static psa_status_t mock_import( psa_drv_se_context_t *drv_context,
- psa_key_slot_number_t key_slot,
- const psa_key_attributes_t *attributes,
- const uint8_t *data,
- size_t data_length,
- size_t *bits )
+static psa_status_t mock_import(psa_drv_se_context_t *drv_context,
+ psa_key_slot_number_t key_slot,
+ const psa_key_attributes_t *attributes,
+ const uint8_t *data,
+ size_t data_length,
+ size_t *bits)
{
(void) drv_context;
(void) data;
@@ -166,14 +159,14 @@
mock_import_data.attributes = *attributes;
mock_import_data.data_length = data_length;
- return( mock_import_data.return_value );
+ return mock_import_data.return_value;
}
-psa_status_t mock_export( psa_drv_se_context_t *context,
- psa_key_slot_number_t slot_number,
- uint8_t *p_data,
- size_t data_size,
- size_t *p_data_length )
+psa_status_t mock_export(psa_drv_se_context_t *context,
+ psa_key_slot_number_t slot_number,
+ uint8_t *p_data,
+ size_t data_size,
+ size_t *p_data_length)
{
(void) context;
(void) p_data;
@@ -183,14 +176,14 @@
mock_export_data.slot_number = slot_number;
mock_export_data.data_size = data_size;
- return( mock_export_data.return_value );
+ return mock_export_data.return_value;
}
-psa_status_t mock_export_public( psa_drv_se_context_t *context,
- psa_key_slot_number_t slot_number,
- uint8_t *p_data,
- size_t data_size,
- size_t *p_data_length )
+psa_status_t mock_export_public(psa_drv_se_context_t *context,
+ psa_key_slot_number_t slot_number,
+ uint8_t *p_data,
+ size_t data_size,
+ size_t *p_data_length)
{
(void) context;
(void) p_data;
@@ -200,17 +193,17 @@
mock_export_public_data.slot_number = slot_number;
mock_export_public_data.data_size = data_size;
- return( mock_export_public_data.return_value );
+ return mock_export_public_data.return_value;
}
-psa_status_t mock_sign( psa_drv_se_context_t *context,
- psa_key_slot_number_t key_slot,
- psa_algorithm_t alg,
- const uint8_t *p_hash,
- size_t hash_length,
- uint8_t *p_signature,
- size_t signature_size,
- size_t *p_signature_length )
+psa_status_t mock_sign(psa_drv_se_context_t *context,
+ psa_key_slot_number_t key_slot,
+ psa_algorithm_t alg,
+ const uint8_t *p_hash,
+ size_t hash_length,
+ uint8_t *p_signature,
+ size_t signature_size,
+ size_t *p_signature_length)
{
(void) context;
(void) p_hash;
@@ -226,13 +219,13 @@
return mock_sign_data.return_value;
}
-psa_status_t mock_verify( psa_drv_se_context_t *context,
- psa_key_slot_number_t key_slot,
- psa_algorithm_t alg,
- const uint8_t *p_hash,
- size_t hash_length,
- const uint8_t *p_signature,
- size_t signature_length )
+psa_status_t mock_verify(psa_drv_se_context_t *context,
+ psa_key_slot_number_t key_slot,
+ psa_algorithm_t alg,
+ const uint8_t *p_hash,
+ size_t hash_length,
+ const uint8_t *p_signature,
+ size_t signature_length)
{
(void) context;
(void) p_hash;
@@ -247,11 +240,11 @@
return mock_verify_data.return_value;
}
-psa_status_t mock_allocate( psa_drv_se_context_t *drv_context,
- void *persistent_data,
- const psa_key_attributes_t *attributes,
- psa_key_creation_method_t method,
- psa_key_slot_number_t *key_slot )
+psa_status_t mock_allocate(psa_drv_se_context_t *drv_context,
+ void *persistent_data,
+ const psa_key_attributes_t *attributes,
+ psa_key_creation_method_t method,
+ psa_key_slot_number_t *key_slot)
{
(void) drv_context;
(void) persistent_data;
@@ -262,12 +255,12 @@
mock_allocate_data.called++;
*key_slot = 0;
- return( mock_allocate_data.return_value );
+ return mock_allocate_data.return_value;
}
-psa_status_t mock_destroy( psa_drv_se_context_t *context,
- void *persistent_data,
- psa_key_slot_number_t slot_number )
+psa_status_t mock_destroy(psa_drv_se_context_t *context,
+ void *persistent_data,
+ psa_key_slot_number_t slot_number)
{
(void) context;
(void) persistent_data;
@@ -275,7 +268,7 @@
mock_destroy_data.called++;
mock_destroy_data.slot_number = slot_number;
- return( mock_destroy_data.return_value );
+ return mock_destroy_data.return_value;
}
/* END_HEADER */
@@ -286,11 +279,11 @@
*/
/* BEGIN_CASE */
-void mock_init( int location_arg,
- int expected_register_status_arg,
- int driver_status_arg,
- int expected_psa_status_arg,
- int expected_called )
+void mock_init(int location_arg,
+ int expected_register_status_arg,
+ int driver_status_arg,
+ int expected_psa_status_arg,
+ int expected_called)
{
psa_key_location_t location = location_arg;
psa_status_t expected_register_status = expected_register_status_arg;
@@ -304,112 +297,110 @@
mock_init_data.return_value = driver_status;
- TEST_EQUAL( psa_register_se_driver( location, &driver ),
- expected_register_status );
+ TEST_EQUAL(psa_register_se_driver(location, &driver),
+ expected_register_status);
psa_crypto_init_called = 1;
- TEST_EQUAL( psa_crypto_init( ), expected_psa_status );
+ TEST_EQUAL(psa_crypto_init(), expected_psa_status);
- TEST_EQUAL( mock_init_data.called, expected_called );
- if( expected_called )
- TEST_EQUAL( mock_init_data.location, location );
+ TEST_EQUAL(mock_init_data.called, expected_called);
+ if (expected_called) {
+ TEST_EQUAL(mock_init_data.location, location);
+ }
exit:
- if( psa_crypto_init_called )
- PSA_DONE( );
- mock_teardown( );
+ if (psa_crypto_init_called) {
+ PSA_DONE();
+ }
+ mock_teardown();
}
/* END_CASE */
/* BEGIN_CASE */
-void mock_import( int mock_alloc_return_value,
- int mock_import_return_value,
- int bits,
- int expected_result )
+void mock_import(int mock_alloc_return_value,
+ int mock_import_return_value,
+ int bits,
+ int expected_result)
{
psa_drv_se_t driver;
psa_drv_se_key_management_t key_management;
psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
mbedtls_svc_key_id_t returned_id;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- const uint8_t key_material[3] = {0xfa, 0xca, 0xde};
+ const uint8_t key_material[3] = { 0xfa, 0xca, 0xde };
mock_allocate_data.return_value = mock_alloc_return_value;
mock_import_data.return_value = mock_import_return_value;
mock_import_data.bits = bits;
- memset( &driver, 0, sizeof( driver ) );
- memset( &key_management, 0, sizeof( key_management ) );
+ memset(&driver, 0, sizeof(driver));
+ memset(&key_management, 0, sizeof(key_management));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
driver.key_management = &key_management;
key_management.p_import = mock_import;
key_management.p_destroy = mock_destroy;
key_management.p_allocate = mock_allocate;
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
- TEST_ASSERT( psa_import_key( &attributes,
- key_material, sizeof( key_material ),
- &returned_id ) == expected_result );
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
+ TEST_ASSERT(psa_import_key(&attributes,
+ key_material, sizeof(key_material),
+ &returned_id) == expected_result);
- TEST_ASSERT( mock_allocate_data.called == 1 );
- TEST_ASSERT( mock_import_data.called ==
- ( mock_alloc_return_value == PSA_SUCCESS? 1 : 0 ) );
+ TEST_ASSERT(mock_allocate_data.called == 1);
+ TEST_ASSERT(mock_import_data.called ==
+ (mock_alloc_return_value == PSA_SUCCESS ? 1 : 0));
- if( mock_alloc_return_value == PSA_SUCCESS )
- {
- TEST_ASSERT( mbedtls_svc_key_id_equal(
- mock_import_data.attributes.core.id, id ) );
- }
- else
- {
- TEST_ASSERT( MBEDTLS_SVC_KEY_ID_GET_KEY_ID(
- mock_import_data.attributes.core.id ) == 0 );
- TEST_ASSERT( MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(
- mock_import_data.attributes.core.id ) == 0 );
+ if (mock_alloc_return_value == PSA_SUCCESS) {
+ TEST_ASSERT(mbedtls_svc_key_id_equal(
+ mock_import_data.attributes.core.id, id));
+ } else {
+ TEST_ASSERT(MBEDTLS_SVC_KEY_ID_GET_KEY_ID(
+ mock_import_data.attributes.core.id) == 0);
+ TEST_ASSERT(MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(
+ mock_import_data.attributes.core.id) == 0);
}
- TEST_ASSERT( mock_import_data.attributes.core.lifetime ==
- ( mock_alloc_return_value == PSA_SUCCESS? lifetime : 0 ) );
- TEST_ASSERT( mock_import_data.attributes.core.policy.usage ==
- ( mock_alloc_return_value == PSA_SUCCESS? PSA_KEY_USAGE_EXPORT : 0 ) );
- TEST_ASSERT( mock_import_data.attributes.core.type ==
- ( mock_alloc_return_value == PSA_SUCCESS? PSA_KEY_TYPE_RAW_DATA : 0 ) );
+ TEST_ASSERT(mock_import_data.attributes.core.lifetime ==
+ (mock_alloc_return_value == PSA_SUCCESS ? lifetime : 0));
+ TEST_ASSERT(mock_import_data.attributes.core.policy.usage ==
+ (mock_alloc_return_value == PSA_SUCCESS ? PSA_KEY_USAGE_EXPORT : 0));
+ TEST_ASSERT(mock_import_data.attributes.core.type ==
+ (mock_alloc_return_value == PSA_SUCCESS ? PSA_KEY_TYPE_RAW_DATA : 0));
- if( expected_result == PSA_SUCCESS )
- {
- PSA_ASSERT( psa_destroy_key( id ) );
- TEST_ASSERT( mock_destroy_data.called == 1 );
+ if (expected_result == PSA_SUCCESS) {
+ PSA_ASSERT(psa_destroy_key(id));
+ TEST_ASSERT(mock_destroy_data.called == 1);
}
exit:
- PSA_DONE( );
- mock_teardown( );
+ PSA_DONE();
+ mock_teardown();
}
/* END_CASE */
/* BEGIN_CASE */
-void mock_export( int mock_export_return_value, int expected_result )
+void mock_export(int mock_export_return_value, int expected_result)
{
psa_drv_se_t driver;
psa_drv_se_key_management_t key_management;
psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
mbedtls_svc_key_id_t returned_id;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- const uint8_t key_material[3] = {0xfa, 0xca, 0xde};
- uint8_t exported[sizeof( key_material )];
+ const uint8_t key_material[3] = { 0xfa, 0xca, 0xde };
+ uint8_t exported[sizeof(key_material)];
size_t exported_length;
mock_export_data.return_value = mock_export_return_value;
- memset( &driver, 0, sizeof( driver ) );
- memset( &key_management, 0, sizeof( key_management ) );
+ memset(&driver, 0, sizeof(driver));
+ memset(&key_management, 0, sizeof(key_management));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
driver.key_management = &key_management;
driver.p_init = mock_init;
@@ -418,119 +409,115 @@
key_management.p_destroy = mock_destroy;
key_management.p_allocate = mock_allocate;
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
- PSA_ASSERT( psa_import_key( &attributes,
- key_material, sizeof( key_material ),
- &returned_id ) );
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
+ PSA_ASSERT(psa_import_key(&attributes,
+ key_material, sizeof(key_material),
+ &returned_id));
- TEST_ASSERT( psa_export_key( id,
- exported, sizeof( exported ),
- &exported_length ) == expected_result );
+ TEST_ASSERT(psa_export_key(id,
+ exported, sizeof(exported),
+ &exported_length) == expected_result);
- TEST_ASSERT( mock_export_data.called == 1 );
+ TEST_ASSERT(mock_export_data.called == 1);
- PSA_ASSERT( psa_destroy_key( id ) );
+ PSA_ASSERT(psa_destroy_key(id));
- TEST_ASSERT( mock_destroy_data.called == 1 );
+ TEST_ASSERT(mock_destroy_data.called == 1);
exit:
- PSA_DONE( );
- mock_teardown( );
+ PSA_DONE();
+ mock_teardown();
}
/* END_CASE */
/* BEGIN_CASE */
-void mock_generate( int mock_alloc_return_value,
- int mock_generate_return_value,
- int expected_result )
+void mock_generate(int mock_alloc_return_value,
+ int mock_generate_return_value,
+ int expected_result)
{
psa_drv_se_t driver;
psa_drv_se_key_management_t key_management;
psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
mbedtls_svc_key_id_t returned_id;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
mock_allocate_data.return_value = mock_alloc_return_value;
mock_generate_data.return_value = mock_generate_return_value;
- memset( &driver, 0, sizeof( driver ) );
- memset( &key_management, 0, sizeof( key_management ) );
+ memset(&driver, 0, sizeof(driver));
+ memset(&key_management, 0, sizeof(key_management));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
driver.key_management = &key_management;
key_management.p_generate = mock_generate;
key_management.p_destroy = mock_destroy;
key_management.p_allocate = mock_allocate;
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
- psa_set_key_bits( &attributes, 8 );
- TEST_ASSERT( psa_generate_key( &attributes, &returned_id) == expected_result );
- TEST_ASSERT( mock_allocate_data.called == 1 );
- TEST_ASSERT( mock_generate_data.called ==
- ( mock_alloc_return_value == PSA_SUCCESS? 1 : 0 ) );
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
+ psa_set_key_bits(&attributes, 8);
+ TEST_ASSERT(psa_generate_key(&attributes, &returned_id) == expected_result);
+ TEST_ASSERT(mock_allocate_data.called == 1);
+ TEST_ASSERT(mock_generate_data.called ==
+ (mock_alloc_return_value == PSA_SUCCESS ? 1 : 0));
- if( mock_alloc_return_value == PSA_SUCCESS )
- {
- TEST_ASSERT( mbedtls_svc_key_id_equal(
- mock_generate_data.attributes.core.id, id ) );
- }
- else
- {
- TEST_ASSERT( MBEDTLS_SVC_KEY_ID_GET_KEY_ID(
- mock_generate_data.attributes.core.id ) == 0 );
- TEST_ASSERT( MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(
- mock_generate_data.attributes.core.id ) == 0 );
+ if (mock_alloc_return_value == PSA_SUCCESS) {
+ TEST_ASSERT(mbedtls_svc_key_id_equal(
+ mock_generate_data.attributes.core.id, id));
+ } else {
+ TEST_ASSERT(MBEDTLS_SVC_KEY_ID_GET_KEY_ID(
+ mock_generate_data.attributes.core.id) == 0);
+ TEST_ASSERT(MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(
+ mock_generate_data.attributes.core.id) == 0);
}
- TEST_ASSERT( mock_generate_data.attributes.core.lifetime ==
- ( mock_alloc_return_value == PSA_SUCCESS? lifetime : 0 ) );
- TEST_ASSERT( mock_generate_data.attributes.core.policy.usage ==
- ( mock_alloc_return_value == PSA_SUCCESS? PSA_KEY_USAGE_EXPORT : 0 ) );
- TEST_ASSERT( mock_generate_data.attributes.core.type ==
- ( mock_alloc_return_value == PSA_SUCCESS? PSA_KEY_TYPE_RAW_DATA : 0 ) );
+ TEST_ASSERT(mock_generate_data.attributes.core.lifetime ==
+ (mock_alloc_return_value == PSA_SUCCESS ? lifetime : 0));
+ TEST_ASSERT(mock_generate_data.attributes.core.policy.usage ==
+ (mock_alloc_return_value == PSA_SUCCESS ? PSA_KEY_USAGE_EXPORT : 0));
+ TEST_ASSERT(mock_generate_data.attributes.core.type ==
+ (mock_alloc_return_value == PSA_SUCCESS ? PSA_KEY_TYPE_RAW_DATA : 0));
- if( expected_result == PSA_SUCCESS )
- {
- PSA_ASSERT( psa_destroy_key( id ) );
- TEST_ASSERT( mock_destroy_data.called == 1 );
+ if (expected_result == PSA_SUCCESS) {
+ PSA_ASSERT(psa_destroy_key(id));
+ TEST_ASSERT(mock_destroy_data.called == 1);
}
exit:
- PSA_DONE( );
- mock_teardown( );
+ PSA_DONE();
+ mock_teardown();
}
/* END_CASE */
/* BEGIN_CASE */
-void mock_export_public( int mock_export_public_return_value,
- int expected_result )
+void mock_export_public(int mock_export_public_return_value,
+ int expected_result)
{
psa_drv_se_t driver;
psa_drv_se_key_management_t key_management;
psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
mbedtls_svc_key_id_t returned_id;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- const uint8_t key_material[3] = {0xfa, 0xca, 0xde};
- uint8_t exported[sizeof( key_material )];
+ const uint8_t key_material[3] = { 0xfa, 0xca, 0xde };
+ uint8_t exported[sizeof(key_material)];
size_t exported_length;
mock_export_public_data.return_value = mock_export_public_return_value;
- memset( &driver, 0, sizeof( driver ) );
- memset( &key_management, 0, sizeof( key_management ) );
+ memset(&driver, 0, sizeof(driver));
+ memset(&key_management, 0, sizeof(key_management));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
driver.key_management = &key_management;
key_management.p_import = mock_import;
@@ -538,52 +525,52 @@
key_management.p_destroy = mock_destroy;
key_management.p_allocate = mock_allocate;
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RSA_PUBLIC_KEY );
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RSA_PUBLIC_KEY);
- PSA_ASSERT( psa_import_key( &attributes,
- key_material, sizeof( key_material ),
- &returned_id ) );
+ PSA_ASSERT(psa_import_key(&attributes,
+ key_material, sizeof(key_material),
+ &returned_id));
- TEST_ASSERT( psa_export_public_key( id, exported, sizeof(exported),
- &exported_length ) == expected_result );
- TEST_ASSERT( mock_export_public_data.called == 1 );
+ TEST_ASSERT(psa_export_public_key(id, exported, sizeof(exported),
+ &exported_length) == expected_result);
+ TEST_ASSERT(mock_export_public_data.called == 1);
- PSA_ASSERT( psa_destroy_key( id ) );
- TEST_ASSERT( mock_destroy_data.called == 1 );
+ PSA_ASSERT(psa_destroy_key(id));
+ TEST_ASSERT(mock_destroy_data.called == 1);
exit:
- PSA_DONE( );
- mock_teardown( );
+ PSA_DONE();
+ mock_teardown();
}
/* END_CASE */
/* BEGIN_CASE */
-void mock_sign( int mock_sign_return_value, int expected_result )
+void mock_sign(int mock_sign_return_value, int expected_result)
{
psa_drv_se_t driver;
psa_drv_se_key_management_t key_management;
psa_drv_se_asymmetric_t asymmetric;
psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
mbedtls_svc_key_id_t returned_id;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- const uint8_t key_material[3] = {0xfa, 0xca, 0xde};
+ const uint8_t key_material[3] = { 0xfa, 0xca, 0xde };
psa_algorithm_t algorithm = PSA_ALG_ECDSA(PSA_ALG_SHA_256);
- const uint8_t hash[1] = {'H'};
- uint8_t signature[1] = {'S'};
+ const uint8_t hash[1] = { 'H' };
+ uint8_t signature[1] = { 'S' };
size_t signature_length;
mock_sign_data.return_value = mock_sign_return_value;
- memset( &driver, 0, sizeof( driver ) );
- memset( &key_management, 0, sizeof( key_management ) );
- memset( &asymmetric, 0, sizeof( asymmetric ) );
+ memset(&driver, 0, sizeof(driver));
+ memset(&key_management, 0, sizeof(key_management));
+ memset(&asymmetric, 0, sizeof(asymmetric));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
@@ -595,55 +582,55 @@
driver.asymmetric = &asymmetric;
asymmetric.p_sign = mock_sign;
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_SIGN_HASH );
- psa_set_key_algorithm( &attributes, algorithm );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RSA_KEY_PAIR );
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH);
+ psa_set_key_algorithm(&attributes, algorithm);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RSA_KEY_PAIR);
- PSA_ASSERT( psa_import_key( &attributes,
- key_material, sizeof( key_material ),
- &returned_id ) );
+ PSA_ASSERT(psa_import_key(&attributes,
+ key_material, sizeof(key_material),
+ &returned_id));
- TEST_ASSERT( psa_sign_hash( id, algorithm,
- hash, sizeof( hash ),
- signature, sizeof( signature ),
- &signature_length)
- == expected_result );
- TEST_ASSERT( mock_sign_data.called == 1 );
+ TEST_ASSERT(psa_sign_hash(id, algorithm,
+ hash, sizeof(hash),
+ signature, sizeof(signature),
+ &signature_length)
+ == expected_result);
+ TEST_ASSERT(mock_sign_data.called == 1);
- PSA_ASSERT( psa_destroy_key( id ) );
- TEST_ASSERT( mock_destroy_data.called == 1 );
+ PSA_ASSERT(psa_destroy_key(id));
+ TEST_ASSERT(mock_destroy_data.called == 1);
exit:
- PSA_DONE( );
- mock_teardown( );
+ PSA_DONE();
+ mock_teardown();
}
/* END_CASE */
/* BEGIN_CASE */
-void mock_verify( int mock_verify_return_value, int expected_result )
+void mock_verify(int mock_verify_return_value, int expected_result)
{
psa_drv_se_t driver;
psa_drv_se_key_management_t key_management;
psa_drv_se_asymmetric_t asymmetric;
psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, 1 );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1);
mbedtls_svc_key_id_t returned_id;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- const uint8_t key_material[3] = {0xfa, 0xca, 0xde};
+ const uint8_t key_material[3] = { 0xfa, 0xca, 0xde };
psa_algorithm_t algorithm = PSA_ALG_ECDSA(PSA_ALG_SHA_256);
- const uint8_t hash[1] = {'H'};
- const uint8_t signature[1] = {'S'};
+ const uint8_t hash[1] = { 'H' };
+ const uint8_t signature[1] = { 'S' };
mock_verify_data.return_value = mock_verify_return_value;
- memset( &driver, 0, sizeof( driver ) );
- memset( &key_management, 0, sizeof( key_management ) );
- memset( &asymmetric, 0, sizeof( asymmetric ) );
+ memset(&driver, 0, sizeof(driver));
+ memset(&key_management, 0, sizeof(key_management));
+ memset(&asymmetric, 0, sizeof(asymmetric));
driver.hal_version = PSA_DRV_SE_HAL_VERSION;
@@ -655,30 +642,30 @@
driver.asymmetric = &asymmetric;
asymmetric.p_verify = mock_verify;
- PSA_ASSERT( psa_register_se_driver( location, &driver ) );
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_register_se_driver(location, &driver));
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_VERIFY_HASH );
- psa_set_key_algorithm( &attributes, algorithm );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_HASH);
+ psa_set_key_algorithm(&attributes, algorithm);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
- PSA_ASSERT( psa_import_key( &attributes,
- key_material, sizeof( key_material ),
- &returned_id ) );
+ PSA_ASSERT(psa_import_key(&attributes,
+ key_material, sizeof(key_material),
+ &returned_id));
- TEST_ASSERT( psa_verify_hash( id, algorithm,
- hash, sizeof( hash ),
- signature, sizeof( signature ) )
- == expected_result );
- TEST_ASSERT( mock_verify_data.called == 1 );
+ TEST_ASSERT(psa_verify_hash(id, algorithm,
+ hash, sizeof(hash),
+ signature, sizeof(signature))
+ == expected_result);
+ TEST_ASSERT(mock_verify_data.called == 1);
- PSA_ASSERT( psa_destroy_key( id ) );
- TEST_ASSERT( mock_destroy_data.called == 1 );
+ PSA_ASSERT(psa_destroy_key(id));
+ TEST_ASSERT(mock_destroy_data.called == 1);
exit:
- PSA_DONE( );
- mock_teardown( );
+ PSA_DONE();
+ mock_teardown();
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto_slot_management.function b/tests/suites/test_suite_psa_crypto_slot_management.function
index d577663..e3bb0d3 100644
--- a/tests/suites/test_suite_psa_crypto_slot_management.function
+++ b/tests/suites/test_suite_psa_crypto_slot_management.function
@@ -4,8 +4,7 @@
#include "psa_crypto_slot_management.h"
#include "psa_crypto_storage.h"
-typedef enum
-{
+typedef enum {
/**< Close key(s) */
INVALIDATE_BY_CLOSING,
@@ -28,15 +27,13 @@
INVALIDATE_BY_PURGING_WITH_SHUTDOWN,
} invalidate_method_t;
-typedef enum
-{
+typedef enum {
KEEP_OPEN,
CLOSE_BEFORE,
CLOSE_AFTER,
} reopen_policy_t;
-typedef enum
-{
+typedef enum {
INVALID_HANDLE_0,
INVALID_HANDLE_UNOPENED,
INVALID_HANDLE_CLOSED,
@@ -46,61 +43,59 @@
/** Apply \p invalidate_method to invalidate the specified key:
* close it, destroy it, or do nothing;
*/
-static int invalidate_key( invalidate_method_t invalidate_method,
- mbedtls_svc_key_id_t key )
+static int invalidate_key(invalidate_method_t invalidate_method,
+ mbedtls_svc_key_id_t key)
{
- switch( invalidate_method )
- {
+ switch (invalidate_method) {
/* Closing the key invalidate only volatile keys, not persistent ones. */
case INVALIDATE_BY_CLOSING:
case INVALIDATE_BY_CLOSING_WITH_SHUTDOWN:
- PSA_ASSERT( psa_close_key( key ) );
+ PSA_ASSERT(psa_close_key(key));
break;
case INVALIDATE_BY_DESTROYING:
case INVALIDATE_BY_DESTROYING_WITH_SHUTDOWN:
- PSA_ASSERT( psa_destroy_key( key ) );
+ PSA_ASSERT(psa_destroy_key(key));
break;
/* Purging the key just purges RAM data of persistent keys. */
case INVALIDATE_BY_PURGING:
case INVALIDATE_BY_PURGING_WITH_SHUTDOWN:
- PSA_ASSERT( psa_purge_key( key ) );
+ PSA_ASSERT(psa_purge_key(key));
break;
case INVALIDATE_BY_SHUTDOWN:
break;
}
- return( 1 );
+ return 1;
exit:
- return( 0 );
+ return 0;
}
/** Restart the PSA subsystem if \p invalidate_method says so. */
-static int invalidate_psa( invalidate_method_t invalidate_method )
+static int invalidate_psa(invalidate_method_t invalidate_method)
{
- switch( invalidate_method )
- {
+ switch (invalidate_method) {
case INVALIDATE_BY_CLOSING:
case INVALIDATE_BY_DESTROYING:
case INVALIDATE_BY_PURGING:
- return( 1 );
+ return 1;
case INVALIDATE_BY_CLOSING_WITH_SHUTDOWN:
case INVALIDATE_BY_DESTROYING_WITH_SHUTDOWN:
case INVALIDATE_BY_PURGING_WITH_SHUTDOWN:
/* All keys must have been closed. */
- PSA_SESSION_DONE( );
+ PSA_SESSION_DONE();
break;
case INVALIDATE_BY_SHUTDOWN:
/* Some keys may remain behind, and we're testing that this
* properly closes them. */
- mbedtls_psa_crypto_free( );
+ mbedtls_psa_crypto_free();
break;
}
- PSA_ASSERT( psa_crypto_init( ) );
- ASSERT_PSA_PRISTINE( );
- return( 1 );
+ PSA_ASSERT(psa_crypto_init());
+ ASSERT_PSA_PRISTINE();
+ return 1;
exit:
- return( 0 );
+ return 0;
}
/* END_HEADER */
@@ -111,10 +106,10 @@
*/
/* BEGIN_CASE */
-void transient_slot_lifecycle( int owner_id_arg,
- int usage_arg, int alg_arg,
- int type_arg, data_t *key_data,
- int invalidate_method_arg )
+void transient_slot_lifecycle(int owner_id_arg,
+ int usage_arg, int alg_arg,
+ int type_arg, data_t *key_data,
+ int invalidate_method_arg)
{
psa_algorithm_t alg = alg_arg;
psa_key_usage_t usage_flags = usage_arg;
@@ -123,40 +118,40 @@
mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- mbedtls_test_set_step( 1 );
- PSA_ASSERT( psa_crypto_init( ) );
+ mbedtls_test_set_step(1);
+ PSA_ASSERT(psa_crypto_init());
/* Import a key. */
#if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER)
mbedtls_key_owner_id_t owner_id = owner_id_arg;
- mbedtls_set_key_owner_id( &attributes, owner_id );
+ mbedtls_set_key_owner_id(&attributes, owner_id);
#else
- (void)owner_id_arg;
+ (void) owner_id_arg;
#endif
- psa_set_key_usage_flags( &attributes, usage_flags );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_type( &attributes, type );
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &key ) );
- TEST_ASSERT( ! mbedtls_svc_key_id_is_null( key ) );
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- TEST_EQUAL( psa_get_key_type( &attributes ), type );
- psa_reset_key_attributes( &attributes );
+ psa_set_key_usage_flags(&attributes, usage_flags);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_type(&attributes, type);
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &key));
+ TEST_ASSERT(!mbedtls_svc_key_id_is_null(key));
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ TEST_EQUAL(psa_get_key_type(&attributes), type);
+ psa_reset_key_attributes(&attributes);
#if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER)
{
psa_key_handle_t handle;
mbedtls_svc_key_id_t key_with_invalid_owner =
- mbedtls_svc_key_id_make( owner_id + 1,
- MBEDTLS_SVC_KEY_ID_GET_KEY_ID( key ) );
+ mbedtls_svc_key_id_make(owner_id + 1,
+ MBEDTLS_SVC_KEY_ID_GET_KEY_ID(key));
- TEST_ASSERT( mbedtls_key_owner_id_equal(
- owner_id,
- MBEDTLS_SVC_KEY_ID_GET_OWNER_ID( key ) ) );
- TEST_EQUAL( psa_open_key( key_with_invalid_owner, &handle ),
- PSA_ERROR_DOES_NOT_EXIST );
+ TEST_ASSERT(mbedtls_key_owner_id_equal(
+ owner_id,
+ MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(key)));
+ TEST_EQUAL(psa_open_key(key_with_invalid_owner, &handle),
+ PSA_ERROR_DOES_NOT_EXIST);
}
#endif
@@ -164,42 +159,44 @@
* Purge the key and make sure that it is still valid, as purging a
* volatile key shouldn't invalidate/destroy it.
*/
- PSA_ASSERT( psa_purge_key( key ) );
- PSA_ASSERT( psa_get_key_attributes( key, &attributes ) );
- TEST_EQUAL( psa_get_key_type( &attributes ), type );
- psa_reset_key_attributes( &attributes );
+ PSA_ASSERT(psa_purge_key(key));
+ PSA_ASSERT(psa_get_key_attributes(key, &attributes));
+ TEST_EQUAL(psa_get_key_type(&attributes), type);
+ psa_reset_key_attributes(&attributes);
/* Do something that invalidates the key. */
- mbedtls_test_set_step( 2 );
- if( ! invalidate_key( invalidate_method, key ) )
+ mbedtls_test_set_step(2);
+ if (!invalidate_key(invalidate_method, key)) {
goto exit;
- if( ! invalidate_psa( invalidate_method ) )
+ }
+ if (!invalidate_psa(invalidate_method)) {
goto exit;
+ }
/* Test that the key is now invalid. */
- TEST_EQUAL( psa_get_key_attributes( key, &attributes ),
- PSA_ERROR_INVALID_HANDLE );
- TEST_EQUAL( psa_close_key( key ), PSA_ERROR_INVALID_HANDLE );
+ TEST_EQUAL(psa_get_key_attributes(key, &attributes),
+ PSA_ERROR_INVALID_HANDLE);
+ TEST_EQUAL(psa_close_key(key), PSA_ERROR_INVALID_HANDLE);
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_STORAGE_C */
-void persistent_slot_lifecycle( int lifetime_arg, int owner_id_arg, int id_arg,
- int usage_arg, int alg_arg, int alg2_arg,
- int type_arg, data_t *key_data,
- int invalidate_method_arg )
+void persistent_slot_lifecycle(int lifetime_arg, int owner_id_arg, int id_arg,
+ int usage_arg, int alg_arg, int alg2_arg,
+ int type_arg, data_t *key_data,
+ int invalidate_method_arg)
{
psa_key_lifetime_t lifetime = lifetime_arg;
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( owner_id_arg, id_arg );
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(owner_id_arg, id_arg);
psa_algorithm_t alg = alg_arg;
psa_algorithm_t alg2 = alg2_arg;
psa_key_usage_t usage_flags = usage_arg;
@@ -214,112 +211,110 @@
#if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER)
mbedtls_svc_key_id_t wrong_owner_id =
- mbedtls_svc_key_id_make( owner_id_arg + 1, id_arg );
+ mbedtls_svc_key_id_make(owner_id_arg + 1, id_arg);
mbedtls_svc_key_id_t invalid_svc_key_id = MBEDTLS_SVC_KEY_ID_INIT;
#endif
- TEST_USES_KEY_ID( id );
+ TEST_USES_KEY_ID(id);
- mbedtls_test_set_step( 1 );
- PSA_ASSERT( psa_crypto_init( ) );
+ mbedtls_test_set_step(1);
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_type( &attributes, type );
- psa_set_key_usage_flags( &attributes, usage_flags );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_enrollment_algorithm( &attributes, alg2 );
- PSA_ASSERT( psa_import_key( &attributes, key_data->x, key_data->len,
- &returned_id ) );
- TEST_ASSERT( mbedtls_svc_key_id_equal( id, returned_id ) );
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_type(&attributes, type);
+ psa_set_key_usage_flags(&attributes, usage_flags);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_enrollment_algorithm(&attributes, alg2);
+ PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len,
+ &returned_id));
+ TEST_ASSERT(mbedtls_svc_key_id_equal(id, returned_id));
#if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER)
- TEST_EQUAL( psa_open_key( wrong_owner_id, &invalid_svc_key_id ),
- PSA_ERROR_DOES_NOT_EXIST );
+ TEST_EQUAL(psa_open_key(wrong_owner_id, &invalid_svc_key_id),
+ PSA_ERROR_DOES_NOT_EXIST);
#endif
- PSA_ASSERT( psa_get_key_attributes( id, &attributes ) );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ), lifetime );
- TEST_ASSERT( mbedtls_svc_key_id_equal(
- psa_get_key_id( &attributes ), id ) );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ),
- mbedtls_test_update_key_usage_flags( usage_flags ) );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ), alg );
- TEST_EQUAL( psa_get_key_enrollment_algorithm( &attributes ), alg2 );
- TEST_EQUAL( psa_get_key_type( &attributes ), type );
+ PSA_ASSERT(psa_get_key_attributes(id, &attributes));
+ TEST_EQUAL(psa_get_key_lifetime(&attributes), lifetime);
+ TEST_ASSERT(mbedtls_svc_key_id_equal(
+ psa_get_key_id(&attributes), id));
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes),
+ mbedtls_test_update_key_usage_flags(usage_flags));
+ TEST_EQUAL(psa_get_key_algorithm(&attributes), alg);
+ TEST_EQUAL(psa_get_key_enrollment_algorithm(&attributes), alg2);
+ TEST_EQUAL(psa_get_key_type(&attributes), type);
/* Close the key and then open it. */
- PSA_ASSERT( psa_close_key( id ) );
+ PSA_ASSERT(psa_close_key(id));
#if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER)
- TEST_EQUAL( psa_open_key( wrong_owner_id, &invalid_svc_key_id ),
- PSA_ERROR_DOES_NOT_EXIST );
+ TEST_EQUAL(psa_open_key(wrong_owner_id, &invalid_svc_key_id),
+ PSA_ERROR_DOES_NOT_EXIST);
#endif
- PSA_ASSERT( psa_open_key( id, &handle ) );
- TEST_ASSERT( ! psa_key_handle_is_null( handle ) );
- PSA_ASSERT( psa_get_key_attributes( handle, &attributes ) );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ), lifetime );
- TEST_ASSERT( mbedtls_svc_key_id_equal(
- psa_get_key_id( &attributes ), id ) );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ),
- mbedtls_test_update_key_usage_flags( usage_flags ) );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ), alg );
- TEST_EQUAL( psa_get_key_enrollment_algorithm( &attributes ), alg2 );
- TEST_EQUAL( psa_get_key_type( &attributes ), type );
+ PSA_ASSERT(psa_open_key(id, &handle));
+ TEST_ASSERT(!psa_key_handle_is_null(handle));
+ PSA_ASSERT(psa_get_key_attributes(handle, &attributes));
+ TEST_EQUAL(psa_get_key_lifetime(&attributes), lifetime);
+ TEST_ASSERT(mbedtls_svc_key_id_equal(
+ psa_get_key_id(&attributes), id));
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes),
+ mbedtls_test_update_key_usage_flags(usage_flags));
+ TEST_EQUAL(psa_get_key_algorithm(&attributes), alg);
+ TEST_EQUAL(psa_get_key_enrollment_algorithm(&attributes), alg2);
+ TEST_EQUAL(psa_get_key_type(&attributes), type);
/*
* Do something that wipes key data in volatile memory or destroy the
* key.
*/
- mbedtls_test_set_step( 2 );
- if( ! invalidate_key( invalidate_method, id ) )
+ mbedtls_test_set_step(2);
+ if (!invalidate_key(invalidate_method, id)) {
goto exit;
- if( ! invalidate_psa( invalidate_method ) )
+ }
+ if (!invalidate_psa(invalidate_method)) {
goto exit;
+ }
/* Try to reaccess the key. If we destroyed it, check that it doesn't
* exist. Otherwise check that it still exists and has the expected
* content. */
- switch( invalidate_method )
- {
+ switch (invalidate_method) {
case INVALIDATE_BY_CLOSING:
case INVALIDATE_BY_CLOSING_WITH_SHUTDOWN:
case INVALIDATE_BY_PURGING:
case INVALIDATE_BY_PURGING_WITH_SHUTDOWN:
case INVALIDATE_BY_SHUTDOWN:
- PSA_ASSERT( psa_open_key( id, &handle ) );
- PSA_ASSERT( psa_get_key_attributes( id, &read_attributes ) );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ),
- psa_get_key_lifetime( &read_attributes ) );
- TEST_ASSERT( mbedtls_svc_key_id_equal(
- psa_get_key_id( &attributes ),
- psa_get_key_id( &read_attributes ) ) );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ),
- mbedtls_test_update_key_usage_flags( usage_flags ) );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ),
- psa_get_key_algorithm( &read_attributes ) );
- TEST_EQUAL( psa_get_key_enrollment_algorithm( &attributes ),
- psa_get_key_enrollment_algorithm( &read_attributes ) );
- TEST_EQUAL( psa_get_key_type( &attributes ),
- psa_get_key_type( &read_attributes ) );
- TEST_EQUAL( psa_get_key_bits( &attributes ),
- psa_get_key_bits( &read_attributes ) );
- ASSERT_ALLOC( reexported, key_data->len );
- if( usage_flags & PSA_KEY_USAGE_EXPORT )
- {
- PSA_ASSERT( psa_export_key( id, reexported, key_data->len,
- &reexported_length ) );
- ASSERT_COMPARE( key_data->x, key_data->len,
- reexported, reexported_length );
+ PSA_ASSERT(psa_open_key(id, &handle));
+ PSA_ASSERT(psa_get_key_attributes(id, &read_attributes));
+ TEST_EQUAL(psa_get_key_lifetime(&attributes),
+ psa_get_key_lifetime(&read_attributes));
+ TEST_ASSERT(mbedtls_svc_key_id_equal(
+ psa_get_key_id(&attributes),
+ psa_get_key_id(&read_attributes)));
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes),
+ mbedtls_test_update_key_usage_flags(usage_flags));
+ TEST_EQUAL(psa_get_key_algorithm(&attributes),
+ psa_get_key_algorithm(&read_attributes));
+ TEST_EQUAL(psa_get_key_enrollment_algorithm(&attributes),
+ psa_get_key_enrollment_algorithm(&read_attributes));
+ TEST_EQUAL(psa_get_key_type(&attributes),
+ psa_get_key_type(&read_attributes));
+ TEST_EQUAL(psa_get_key_bits(&attributes),
+ psa_get_key_bits(&read_attributes));
+ ASSERT_ALLOC(reexported, key_data->len);
+ if (usage_flags & PSA_KEY_USAGE_EXPORT) {
+ PSA_ASSERT(psa_export_key(id, reexported, key_data->len,
+ &reexported_length));
+ ASSERT_COMPARE(key_data->x, key_data->len,
+ reexported, reexported_length);
+ } else {
+ TEST_EQUAL(psa_export_key(id, reexported,
+ key_data->len, &reexported_length),
+ PSA_ERROR_NOT_PERMITTED);
}
- else
- {
- TEST_EQUAL( psa_export_key( id, reexported,
- key_data->len, &reexported_length ),
- PSA_ERROR_NOT_PERMITTED );
- }
- PSA_ASSERT( psa_close_key( handle ) );
+ PSA_ASSERT(psa_close_key(handle));
break;
case INVALIDATE_BY_DESTROYING:
@@ -328,11 +323,11 @@
* Test that the key handle and identifier are now not referring to an
* existing key.
*/
- TEST_EQUAL( psa_get_key_attributes( handle, &read_attributes ),
- PSA_ERROR_INVALID_HANDLE );
- TEST_EQUAL( psa_close_key( handle ), PSA_ERROR_INVALID_HANDLE );
- TEST_EQUAL( psa_get_key_attributes( id, &read_attributes ),
- PSA_ERROR_INVALID_HANDLE );
+ TEST_EQUAL(psa_get_key_attributes(handle, &read_attributes),
+ PSA_ERROR_INVALID_HANDLE);
+ TEST_EQUAL(psa_close_key(handle), PSA_ERROR_INVALID_HANDLE);
+ TEST_EQUAL(psa_get_key_attributes(id, &read_attributes),
+ PSA_ERROR_INVALID_HANDLE);
break;
}
@@ -341,158 +336,159 @@
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
- psa_reset_key_attributes( &read_attributes );
+ psa_reset_key_attributes(&attributes);
+ psa_reset_key_attributes(&read_attributes);
- PSA_DONE( );
- mbedtls_free( reexported );
+ PSA_DONE();
+ mbedtls_free(reexported);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_STORAGE_C */
-void create_existent( int lifetime_arg, int owner_id_arg, int id_arg,
- int reopen_policy_arg )
+void create_existent(int lifetime_arg, int owner_id_arg, int id_arg,
+ int reopen_policy_arg)
{
psa_key_lifetime_t lifetime = lifetime_arg;
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( owner_id_arg, id_arg );
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(owner_id_arg, id_arg);
mbedtls_svc_key_id_t returned_id = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_type_t type1 = PSA_KEY_TYPE_RAW_DATA;
const uint8_t material1[5] = "a key";
const uint8_t material2[5] = "b key";
- size_t bits1 = PSA_BYTES_TO_BITS( sizeof( material1 ) );
- uint8_t reexported[sizeof( material1 )];
+ size_t bits1 = PSA_BYTES_TO_BITS(sizeof(material1));
+ uint8_t reexported[sizeof(material1)];
size_t reexported_length;
reopen_policy_t reopen_policy = reopen_policy_arg;
- TEST_USES_KEY_ID( id );
+ TEST_USES_KEY_ID(id);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* Create a key. */
- psa_set_key_id( &attributes, id );
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_type( &attributes, type1 );
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
- psa_set_key_algorithm( &attributes, 0 );
- PSA_ASSERT( psa_import_key( &attributes, material1, sizeof( material1 ),
- &returned_id ) );
- TEST_ASSERT( mbedtls_svc_key_id_equal( id, returned_id ) );
+ psa_set_key_id(&attributes, id);
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_type(&attributes, type1);
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
+ psa_set_key_algorithm(&attributes, 0);
+ PSA_ASSERT(psa_import_key(&attributes, material1, sizeof(material1),
+ &returned_id));
+ TEST_ASSERT(mbedtls_svc_key_id_equal(id, returned_id));
- if( reopen_policy == CLOSE_BEFORE )
- PSA_ASSERT( psa_close_key( id ) );
+ if (reopen_policy == CLOSE_BEFORE) {
+ PSA_ASSERT(psa_close_key(id));
+ }
/* Attempt to create a new key in the same slot. */
- TEST_EQUAL( psa_import_key( &attributes, material2, sizeof( material2 ),
- &returned_id ),
- PSA_ERROR_ALREADY_EXISTS );
- TEST_ASSERT( mbedtls_svc_key_id_is_null( returned_id ) );
+ TEST_EQUAL(psa_import_key(&attributes, material2, sizeof(material2),
+ &returned_id),
+ PSA_ERROR_ALREADY_EXISTS);
+ TEST_ASSERT(mbedtls_svc_key_id_is_null(returned_id));
- if( reopen_policy == CLOSE_AFTER )
- PSA_ASSERT( psa_close_key( id ) );
+ if (reopen_policy == CLOSE_AFTER) {
+ PSA_ASSERT(psa_close_key(id));
+ }
/* Check that the original key hasn't changed. */
- psa_reset_key_attributes( &attributes );
- PSA_ASSERT( psa_get_key_attributes( id, &attributes ) );
- TEST_ASSERT( mbedtls_svc_key_id_equal(
- psa_get_key_id( &attributes ), id ) );
- TEST_EQUAL( psa_get_key_lifetime( &attributes ), lifetime );
- TEST_EQUAL( psa_get_key_type( &attributes ), type1 );
- TEST_EQUAL( psa_get_key_bits( &attributes ), bits1 );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes ), PSA_KEY_USAGE_EXPORT );
- TEST_EQUAL( psa_get_key_algorithm( &attributes ), 0 );
+ psa_reset_key_attributes(&attributes);
+ PSA_ASSERT(psa_get_key_attributes(id, &attributes));
+ TEST_ASSERT(mbedtls_svc_key_id_equal(
+ psa_get_key_id(&attributes), id));
+ TEST_EQUAL(psa_get_key_lifetime(&attributes), lifetime);
+ TEST_EQUAL(psa_get_key_type(&attributes), type1);
+ TEST_EQUAL(psa_get_key_bits(&attributes), bits1);
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes), PSA_KEY_USAGE_EXPORT);
+ TEST_EQUAL(psa_get_key_algorithm(&attributes), 0);
- PSA_ASSERT( psa_export_key( id,
- reexported, sizeof( reexported ),
- &reexported_length ) );
- ASSERT_COMPARE( material1, sizeof( material1 ),
- reexported, reexported_length );
+ PSA_ASSERT(psa_export_key(id,
+ reexported, sizeof(reexported),
+ &reexported_length));
+ ASSERT_COMPARE(material1, sizeof(material1),
+ reexported, reexported_length);
- PSA_ASSERT( psa_close_key( id ) );
+ PSA_ASSERT(psa_close_key(id));
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void open_fail( int id_arg,
- int expected_status_arg )
+void open_fail(int id_arg,
+ int expected_status_arg)
{
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, id_arg );
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, id_arg);
psa_status_t expected_status = expected_status_arg;
- psa_key_handle_t handle = mbedtls_svc_key_id_make( 0xdead, 0xdead );
+ psa_key_handle_t handle = mbedtls_svc_key_id_make(0xdead, 0xdead);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- TEST_EQUAL( psa_open_key( id, &handle ), expected_status );
- TEST_ASSERT( psa_key_handle_is_null( handle ) );
+ TEST_EQUAL(psa_open_key(id, &handle), expected_status);
+ TEST_ASSERT(psa_key_handle_is_null(handle));
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void create_fail( int lifetime_arg, int id_arg,
- int expected_status_arg )
+void create_fail(int lifetime_arg, int id_arg,
+ int expected_status_arg)
{
psa_key_lifetime_t lifetime = lifetime_arg;
- mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make( 1, id_arg );
+ mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, id_arg);
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_status_t expected_status = expected_status_arg;
mbedtls_svc_key_id_t returned_id =
- mbedtls_svc_key_id_make( 0xdead, 0xdead );
- uint8_t material[1] = {'k'};
+ mbedtls_svc_key_id_make(0xdead, 0xdead);
+ uint8_t material[1] = { 'k' };
- TEST_USES_KEY_ID( id );
+ TEST_USES_KEY_ID(id);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_lifetime( &attributes, lifetime );
- if( PSA_KEY_LIFETIME_IS_VOLATILE( lifetime ) )
- {
+ psa_set_key_lifetime(&attributes, lifetime);
+ if (PSA_KEY_LIFETIME_IS_VOLATILE(lifetime)) {
/*
* Not possible to set a key identifier different from 0 through
* PSA key attributes APIs thus accessing to the attributes
* directly.
*/
attributes.core.id = id;
+ } else {
+ psa_set_key_id(&attributes, id);
}
- else
- psa_set_key_id( &attributes, id );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
- TEST_EQUAL( psa_import_key( &attributes, material, sizeof( material ),
- &returned_id ),
- expected_status );
- TEST_ASSERT( mbedtls_svc_key_id_is_null( returned_id ) );
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
+ TEST_EQUAL(psa_import_key(&attributes, material, sizeof(material),
+ &returned_id),
+ expected_status);
+ TEST_ASSERT(mbedtls_svc_key_id_is_null(returned_id));
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void copy_across_lifetimes( int source_lifetime_arg, int source_owner_id_arg,
- int source_id_arg, int source_usage_arg,
- int source_alg_arg, int source_alg2_arg,
- int type_arg, data_t *material,
- int target_lifetime_arg, int target_owner_id_arg,
- int target_id_arg, int target_usage_arg,
- int target_alg_arg, int target_alg2_arg,
- int expected_usage_arg,
- int expected_alg_arg, int expected_alg2_arg )
+void copy_across_lifetimes(int source_lifetime_arg, int source_owner_id_arg,
+ int source_id_arg, int source_usage_arg,
+ int source_alg_arg, int source_alg2_arg,
+ int type_arg, data_t *material,
+ int target_lifetime_arg, int target_owner_id_arg,
+ int target_id_arg, int target_usage_arg,
+ int target_alg_arg, int target_alg2_arg,
+ int expected_usage_arg,
+ int expected_alg_arg, int expected_alg2_arg)
{
psa_key_lifetime_t source_lifetime = source_lifetime_arg;
mbedtls_svc_key_id_t source_id =
- mbedtls_svc_key_id_make( source_owner_id_arg, source_id_arg );
+ mbedtls_svc_key_id_make(source_owner_id_arg, source_id_arg);
psa_key_usage_t source_usage = source_usage_arg;
psa_algorithm_t source_alg = source_alg_arg;
psa_key_attributes_t source_attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -500,7 +496,7 @@
mbedtls_svc_key_id_t returned_source_id = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_lifetime_t target_lifetime = target_lifetime_arg;
mbedtls_svc_key_id_t target_id =
- mbedtls_svc_key_id_make( target_owner_id_arg, target_id_arg );
+ mbedtls_svc_key_id_make(target_owner_id_arg, target_id_arg);
psa_key_usage_t target_usage = target_usage_arg;
psa_algorithm_t target_alg = target_alg_arg;
psa_key_attributes_t target_attributes = PSA_KEY_ATTRIBUTES_INIT;
@@ -511,127 +507,120 @@
psa_algorithm_t expected_alg2 = expected_alg2_arg;
uint8_t *export_buffer = NULL;
- TEST_USES_KEY_ID( source_id );
- TEST_USES_KEY_ID( target_id );
+ TEST_USES_KEY_ID(source_id);
+ TEST_USES_KEY_ID(target_id);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* Populate the source slot. */
- psa_set_key_id( &source_attributes, source_id );
- psa_set_key_lifetime( &source_attributes, source_lifetime );
+ psa_set_key_id(&source_attributes, source_id);
+ psa_set_key_lifetime(&source_attributes, source_lifetime);
- psa_set_key_type( &source_attributes, source_type );
- psa_set_key_usage_flags( &source_attributes, source_usage );
- psa_set_key_algorithm( &source_attributes, source_alg );
- psa_set_key_enrollment_algorithm( &source_attributes, source_alg2_arg );
- PSA_ASSERT( psa_import_key( &source_attributes,
- material->x, material->len,
- &returned_source_id ) );
+ psa_set_key_type(&source_attributes, source_type);
+ psa_set_key_usage_flags(&source_attributes, source_usage);
+ psa_set_key_algorithm(&source_attributes, source_alg);
+ psa_set_key_enrollment_algorithm(&source_attributes, source_alg2_arg);
+ PSA_ASSERT(psa_import_key(&source_attributes,
+ material->x, material->len,
+ &returned_source_id));
/* Update the attributes with the bit size. */
- PSA_ASSERT( psa_get_key_attributes( returned_source_id,
- &source_attributes ) );
+ PSA_ASSERT(psa_get_key_attributes(returned_source_id,
+ &source_attributes));
/* Prepare the target slot. */
- psa_set_key_id( &target_attributes, target_id );
- psa_set_key_lifetime( &target_attributes, target_lifetime );
+ psa_set_key_id(&target_attributes, target_id);
+ psa_set_key_lifetime(&target_attributes, target_lifetime);
- psa_set_key_usage_flags( &target_attributes, target_usage );
- psa_set_key_algorithm( &target_attributes, target_alg );
- psa_set_key_enrollment_algorithm( &target_attributes, target_alg2_arg );
+ psa_set_key_usage_flags(&target_attributes, target_usage);
+ psa_set_key_algorithm(&target_attributes, target_alg);
+ psa_set_key_enrollment_algorithm(&target_attributes, target_alg2_arg);
/* Copy the key. */
- PSA_ASSERT( psa_copy_key( returned_source_id,
- &target_attributes, &returned_target_id ) );
+ PSA_ASSERT(psa_copy_key(returned_source_id,
+ &target_attributes, &returned_target_id));
/* Destroy the source to ensure that this doesn't affect the target. */
- PSA_ASSERT( psa_destroy_key( returned_source_id ) );
+ PSA_ASSERT(psa_destroy_key(returned_source_id));
/* If the target key is persistent, restart the system to make
* sure that the material is still alive. */
- if( ! PSA_KEY_LIFETIME_IS_VOLATILE( target_lifetime ) )
- {
- mbedtls_psa_crypto_free( );
- PSA_ASSERT( psa_crypto_init( ) );
- PSA_ASSERT( psa_open_key( target_id, &target_handle ) );
+ if (!PSA_KEY_LIFETIME_IS_VOLATILE(target_lifetime)) {
+ mbedtls_psa_crypto_free();
+ PSA_ASSERT(psa_crypto_init());
+ PSA_ASSERT(psa_open_key(target_id, &target_handle));
}
/* Test that the target slot has the expected content. */
- psa_reset_key_attributes( &target_attributes );
- PSA_ASSERT( psa_get_key_attributes( returned_target_id,
- &target_attributes ) );
+ psa_reset_key_attributes(&target_attributes);
+ PSA_ASSERT(psa_get_key_attributes(returned_target_id,
+ &target_attributes));
- if( ! PSA_KEY_LIFETIME_IS_VOLATILE( target_lifetime ) )
- {
- TEST_ASSERT( mbedtls_svc_key_id_equal(
- target_id, psa_get_key_id( &target_attributes ) ) );
- }
- else
- {
+ if (!PSA_KEY_LIFETIME_IS_VOLATILE(target_lifetime)) {
+ TEST_ASSERT(mbedtls_svc_key_id_equal(
+ target_id, psa_get_key_id(&target_attributes)));
+ } else {
#if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER)
- TEST_EQUAL( MBEDTLS_SVC_KEY_ID_GET_OWNER_ID( returned_target_id ),
- target_owner_id_arg );
+ TEST_EQUAL(MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(returned_target_id),
+ target_owner_id_arg);
#endif
}
- TEST_EQUAL( target_lifetime, psa_get_key_lifetime( &target_attributes ) );
- TEST_EQUAL( source_type, psa_get_key_type( &target_attributes ) );
- TEST_EQUAL( psa_get_key_bits( &source_attributes ),
- psa_get_key_bits( &target_attributes ) );
- TEST_EQUAL( expected_usage, psa_get_key_usage_flags( &target_attributes ) );
- TEST_EQUAL( expected_alg, psa_get_key_algorithm( &target_attributes ) );
- TEST_EQUAL( expected_alg2,
- psa_get_key_enrollment_algorithm( &target_attributes ) );
- if( expected_usage & PSA_KEY_USAGE_EXPORT )
- {
+ TEST_EQUAL(target_lifetime, psa_get_key_lifetime(&target_attributes));
+ TEST_EQUAL(source_type, psa_get_key_type(&target_attributes));
+ TEST_EQUAL(psa_get_key_bits(&source_attributes),
+ psa_get_key_bits(&target_attributes));
+ TEST_EQUAL(expected_usage, psa_get_key_usage_flags(&target_attributes));
+ TEST_EQUAL(expected_alg, psa_get_key_algorithm(&target_attributes));
+ TEST_EQUAL(expected_alg2,
+ psa_get_key_enrollment_algorithm(&target_attributes));
+ if (expected_usage & PSA_KEY_USAGE_EXPORT) {
size_t length;
- ASSERT_ALLOC( export_buffer, material->len );
- PSA_ASSERT( psa_export_key( returned_target_id, export_buffer,
- material->len, &length ) );
- ASSERT_COMPARE( material->x, material->len,
- export_buffer, length );
- }
- else
- {
+ ASSERT_ALLOC(export_buffer, material->len);
+ PSA_ASSERT(psa_export_key(returned_target_id, export_buffer,
+ material->len, &length));
+ ASSERT_COMPARE(material->x, material->len,
+ export_buffer, length);
+ } else {
size_t length;
/* Check that the key is actually non-exportable. */
- TEST_EQUAL( psa_export_key( returned_target_id, export_buffer,
- material->len, &length ),
- PSA_ERROR_NOT_PERMITTED );
+ TEST_EQUAL(psa_export_key(returned_target_id, export_buffer,
+ material->len, &length),
+ PSA_ERROR_NOT_PERMITTED);
}
- PSA_ASSERT( psa_destroy_key( returned_target_id ) );
+ PSA_ASSERT(psa_destroy_key(returned_target_id));
exit:
/*
* Source and target key attributes may have been returned by
* psa_get_key_attributes() thus reset them as required.
*/
- psa_reset_key_attributes( &source_attributes );
- psa_reset_key_attributes( &target_attributes );
+ psa_reset_key_attributes(&source_attributes);
+ psa_reset_key_attributes(&target_attributes);
- PSA_DONE( );
- mbedtls_free( export_buffer );
+ PSA_DONE();
+ mbedtls_free(export_buffer);
}
/* END_CASE */
/* BEGIN_CASE */
-void copy_to_occupied( int source_lifetime_arg, int source_id_arg,
- int source_usage_arg, int source_alg_arg,
- int source_type_arg, data_t *source_material,
- int target_lifetime_arg, int target_id_arg,
- int target_usage_arg, int target_alg_arg,
- int target_type_arg, data_t *target_material )
+void copy_to_occupied(int source_lifetime_arg, int source_id_arg,
+ int source_usage_arg, int source_alg_arg,
+ int source_type_arg, data_t *source_material,
+ int target_lifetime_arg, int target_id_arg,
+ int target_usage_arg, int target_alg_arg,
+ int target_type_arg, data_t *target_material)
{
psa_key_lifetime_t source_lifetime = source_lifetime_arg;
mbedtls_svc_key_id_t source_id =
- mbedtls_svc_key_id_make( 1, source_id_arg );
+ mbedtls_svc_key_id_make(1, source_id_arg);
psa_key_usage_t source_usage = source_usage_arg;
psa_algorithm_t source_alg = source_alg_arg;
psa_key_type_t source_type = source_type_arg;
mbedtls_svc_key_id_t returned_source_id = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_lifetime_t target_lifetime = target_lifetime_arg;
mbedtls_svc_key_id_t target_id =
- mbedtls_svc_key_id_make( 1, target_id_arg );
+ mbedtls_svc_key_id_make(1, target_id_arg);
psa_key_usage_t target_usage = target_usage_arg;
psa_algorithm_t target_alg = target_alg_arg;
psa_key_type_t target_type = target_type_arg;
@@ -642,96 +631,92 @@
psa_key_attributes_t attributes1 = PSA_KEY_ATTRIBUTES_INIT;
psa_key_attributes_t attributes2 = PSA_KEY_ATTRIBUTES_INIT;
- TEST_USES_KEY_ID( source_id );
- TEST_USES_KEY_ID( target_id );
+ TEST_USES_KEY_ID(source_id);
+ TEST_USES_KEY_ID(target_id);
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* Populate the source slot. */
- if( ! PSA_KEY_LIFETIME_IS_VOLATILE( source_lifetime ) )
- {
- psa_set_key_id( &attributes, source_id );
- psa_set_key_lifetime( &attributes, source_lifetime );
+ if (!PSA_KEY_LIFETIME_IS_VOLATILE(source_lifetime)) {
+ psa_set_key_id(&attributes, source_id);
+ psa_set_key_lifetime(&attributes, source_lifetime);
}
- psa_set_key_type( &attributes, source_type );
- psa_set_key_usage_flags( &attributes, source_usage );
- psa_set_key_algorithm( &attributes, source_alg );
- PSA_ASSERT( psa_import_key( &attributes,
- source_material->x, source_material->len,
- &returned_source_id ) );
+ psa_set_key_type(&attributes, source_type);
+ psa_set_key_usage_flags(&attributes, source_usage);
+ psa_set_key_algorithm(&attributes, source_alg);
+ PSA_ASSERT(psa_import_key(&attributes,
+ source_material->x, source_material->len,
+ &returned_source_id));
/* Populate the target slot. */
- if( mbedtls_svc_key_id_equal( target_id, source_id ) )
- {
+ if (mbedtls_svc_key_id_equal(target_id, source_id)) {
returned_target_id = returned_source_id;
- }
- else
- {
- psa_set_key_id( &attributes1, target_id );
- psa_set_key_lifetime( &attributes1, target_lifetime );
- psa_set_key_type( &attributes1, target_type );
- psa_set_key_usage_flags( &attributes1, target_usage );
- psa_set_key_algorithm( &attributes1, target_alg );
- PSA_ASSERT( psa_import_key( &attributes1,
- target_material->x, target_material->len,
- &returned_target_id ) );
+ } else {
+ psa_set_key_id(&attributes1, target_id);
+ psa_set_key_lifetime(&attributes1, target_lifetime);
+ psa_set_key_type(&attributes1, target_type);
+ psa_set_key_usage_flags(&attributes1, target_usage);
+ psa_set_key_algorithm(&attributes1, target_alg);
+ PSA_ASSERT(psa_import_key(&attributes1,
+ target_material->x, target_material->len,
+ &returned_target_id));
}
- PSA_ASSERT( psa_get_key_attributes( returned_target_id, &attributes1 ) );
+ PSA_ASSERT(psa_get_key_attributes(returned_target_id, &attributes1));
/* Make a copy attempt. */
- psa_set_key_id( &attributes, target_id );
- psa_set_key_lifetime( &attributes, target_lifetime );
- TEST_EQUAL( psa_copy_key( returned_source_id,
- &attributes, &new_key ),
- PSA_ERROR_ALREADY_EXISTS );
- TEST_ASSERT( mbedtls_svc_key_id_is_null( new_key ) );
+ psa_set_key_id(&attributes, target_id);
+ psa_set_key_lifetime(&attributes, target_lifetime);
+ TEST_EQUAL(psa_copy_key(returned_source_id,
+ &attributes, &new_key),
+ PSA_ERROR_ALREADY_EXISTS);
+ TEST_ASSERT(mbedtls_svc_key_id_is_null(new_key));
/* Test that the target slot is unaffected. */
- PSA_ASSERT( psa_get_key_attributes( returned_target_id, &attributes2 ) );
- TEST_ASSERT( mbedtls_svc_key_id_equal(
- psa_get_key_id( &attributes1 ),
- psa_get_key_id( &attributes2 ) ) );
- TEST_EQUAL( psa_get_key_lifetime( &attributes1 ),
- psa_get_key_lifetime( &attributes2 ) );
- TEST_EQUAL( psa_get_key_type( &attributes1 ),
- psa_get_key_type( &attributes2 ) );
- TEST_EQUAL( psa_get_key_bits( &attributes1 ),
- psa_get_key_bits( &attributes2 ) );
- TEST_EQUAL( psa_get_key_usage_flags( &attributes1 ),
- psa_get_key_usage_flags( &attributes2 ) );
- TEST_EQUAL( psa_get_key_algorithm( &attributes1 ),
- psa_get_key_algorithm( &attributes2 ) );
- if( target_usage & PSA_KEY_USAGE_EXPORT )
- {
+ PSA_ASSERT(psa_get_key_attributes(returned_target_id, &attributes2));
+ TEST_ASSERT(mbedtls_svc_key_id_equal(
+ psa_get_key_id(&attributes1),
+ psa_get_key_id(&attributes2)));
+ TEST_EQUAL(psa_get_key_lifetime(&attributes1),
+ psa_get_key_lifetime(&attributes2));
+ TEST_EQUAL(psa_get_key_type(&attributes1),
+ psa_get_key_type(&attributes2));
+ TEST_EQUAL(psa_get_key_bits(&attributes1),
+ psa_get_key_bits(&attributes2));
+ TEST_EQUAL(psa_get_key_usage_flags(&attributes1),
+ psa_get_key_usage_flags(&attributes2));
+ TEST_EQUAL(psa_get_key_algorithm(&attributes1),
+ psa_get_key_algorithm(&attributes2));
+ if (target_usage & PSA_KEY_USAGE_EXPORT) {
size_t length;
- ASSERT_ALLOC( export_buffer, target_material->len );
- PSA_ASSERT( psa_export_key( returned_target_id, export_buffer,
- target_material->len, &length ) );
- ASSERT_COMPARE( target_material->x, target_material->len,
- export_buffer, length );
+ ASSERT_ALLOC(export_buffer, target_material->len);
+ PSA_ASSERT(psa_export_key(returned_target_id, export_buffer,
+ target_material->len, &length));
+ ASSERT_COMPARE(target_material->x, target_material->len,
+ export_buffer, length);
}
- PSA_ASSERT( psa_destroy_key( returned_source_id ) );
- if( ! mbedtls_svc_key_id_equal( target_id, source_id ) )
- PSA_ASSERT( psa_destroy_key( returned_target_id ) );
+ PSA_ASSERT(psa_destroy_key(returned_source_id));
+ if (!mbedtls_svc_key_id_equal(target_id, source_id)) {
+ PSA_ASSERT(psa_destroy_key(returned_target_id));
+ }
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes1 );
- psa_reset_key_attributes( &attributes2 );
+ psa_reset_key_attributes(&attributes1);
+ psa_reset_key_attributes(&attributes2);
- PSA_DONE( );
- mbedtls_free( export_buffer );
+ PSA_DONE();
+ mbedtls_free(export_buffer);
}
/* END_CASE */
/* BEGIN_CASE */
-void invalid_handle( int handle_construction,
- int close_status_arg )
+void invalid_handle(int handle_construction,
+ int close_status_arg)
{
psa_key_handle_t valid_handle = PSA_KEY_HANDLE_INIT;
psa_key_handle_t invalid_handle = PSA_KEY_HANDLE_INIT;
@@ -740,20 +725,19 @@
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
uint8_t material[1] = "a";
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
/* Allocate a handle and store a key in it. */
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
- psa_set_key_usage_flags( &attributes, 0 );
- psa_set_key_algorithm( &attributes, 0 );
- PSA_ASSERT( psa_import_key( &attributes,
- material, sizeof( material ),
- &valid_handle ) );
- TEST_ASSERT( ! psa_key_handle_is_null( valid_handle ) );
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
+ psa_set_key_usage_flags(&attributes, 0);
+ psa_set_key_algorithm(&attributes, 0);
+ PSA_ASSERT(psa_import_key(&attributes,
+ material, sizeof(material),
+ &valid_handle));
+ TEST_ASSERT(!psa_key_handle_is_null(valid_handle));
/* Construct an invalid handle as specified in the test case data. */
- switch( handle_construction )
- {
+ switch (handle_construction) {
case INVALID_HANDLE_0:
invalid_handle = PSA_KEY_HANDLE_INIT;
break;
@@ -770,129 +754,129 @@
* unopened and thus invalid identifier.
*/
- if( MBEDTLS_SVC_KEY_ID_GET_KEY_ID( valid_handle ) ==
- PSA_KEY_ID_VOLATILE_MIN )
+ if (MBEDTLS_SVC_KEY_ID_GET_KEY_ID(valid_handle) ==
+ PSA_KEY_ID_VOLATILE_MIN) {
key_id = PSA_KEY_ID_VOLATILE_MIN + 1;
- else
- key_id = MBEDTLS_SVC_KEY_ID_GET_KEY_ID( valid_handle ) - 1;
+ } else {
+ key_id = MBEDTLS_SVC_KEY_ID_GET_KEY_ID(valid_handle) - 1;
+ }
invalid_handle =
- mbedtls_svc_key_id_make( 0, key_id );
+ mbedtls_svc_key_id_make(0, key_id);
break;
case INVALID_HANDLE_CLOSED:
- PSA_ASSERT( psa_import_key( &attributes,
- material, sizeof( material ),
- &invalid_handle ) );
- PSA_ASSERT( psa_destroy_key( invalid_handle ) );
+ PSA_ASSERT(psa_import_key(&attributes,
+ material, sizeof(material),
+ &invalid_handle));
+ PSA_ASSERT(psa_destroy_key(invalid_handle));
break;
case INVALID_HANDLE_HUGE:
invalid_handle =
- mbedtls_svc_key_id_make( 0, PSA_KEY_ID_VENDOR_MAX + 1 );
+ mbedtls_svc_key_id_make(0, PSA_KEY_ID_VENDOR_MAX + 1);
break;
default:
- TEST_ASSERT( ! "unknown handle construction" );
+ TEST_ASSERT(!"unknown handle construction");
}
/* Attempt to use the invalid handle. */
- TEST_EQUAL( psa_get_key_attributes( invalid_handle, &attributes ),
- PSA_ERROR_INVALID_HANDLE );
- TEST_EQUAL( psa_close_key( invalid_handle ), close_status );
- TEST_EQUAL( psa_destroy_key( invalid_handle ), close_status );
+ TEST_EQUAL(psa_get_key_attributes(invalid_handle, &attributes),
+ PSA_ERROR_INVALID_HANDLE);
+ TEST_EQUAL(psa_close_key(invalid_handle), close_status);
+ TEST_EQUAL(psa_destroy_key(invalid_handle), close_status);
/* After all this, check that the original handle is intact. */
- PSA_ASSERT( psa_get_key_attributes( valid_handle, &attributes ) );
- TEST_EQUAL( psa_get_key_type( &attributes ), PSA_KEY_TYPE_RAW_DATA );
- TEST_EQUAL( psa_get_key_bits( &attributes ),
- PSA_BYTES_TO_BITS( sizeof( material ) ) );
- PSA_ASSERT( psa_close_key( valid_handle ) );
+ PSA_ASSERT(psa_get_key_attributes(valid_handle, &attributes));
+ TEST_EQUAL(psa_get_key_type(&attributes), PSA_KEY_TYPE_RAW_DATA);
+ TEST_EQUAL(psa_get_key_bits(&attributes),
+ PSA_BYTES_TO_BITS(sizeof(material)));
+ PSA_ASSERT(psa_close_key(valid_handle));
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void many_transient_keys( int max_keys_arg )
+void many_transient_keys(int max_keys_arg)
{
mbedtls_svc_key_id_t *keys = NULL;
size_t max_keys = max_keys_arg;
size_t i, j;
psa_status_t status;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- uint8_t exported[sizeof( size_t )];
+ uint8_t exported[sizeof(size_t)];
size_t exported_length;
- ASSERT_ALLOC( keys, max_keys );
- PSA_ASSERT( psa_crypto_init( ) );
+ ASSERT_ALLOC(keys, max_keys);
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
- psa_set_key_algorithm( &attributes, 0 );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
+ psa_set_key_algorithm(&attributes, 0);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
- for( i = 0; i < max_keys; i++ )
- {
- status = psa_import_key( &attributes,
- (uint8_t *) &i, sizeof( i ),
- &keys[i] );
- if( status == PSA_ERROR_INSUFFICIENT_MEMORY )
+ for (i = 0; i < max_keys; i++) {
+ status = psa_import_key(&attributes,
+ (uint8_t *) &i, sizeof(i),
+ &keys[i]);
+ if (status == PSA_ERROR_INSUFFICIENT_MEMORY) {
break;
- PSA_ASSERT( status );
- TEST_ASSERT( ! mbedtls_svc_key_id_is_null( keys[i] ) );
- for( j = 0; j < i; j++ )
- TEST_ASSERT( ! mbedtls_svc_key_id_equal( keys[i], keys[j] ) );
+ }
+ PSA_ASSERT(status);
+ TEST_ASSERT(!mbedtls_svc_key_id_is_null(keys[i]));
+ for (j = 0; j < i; j++) {
+ TEST_ASSERT(!mbedtls_svc_key_id_equal(keys[i], keys[j]));
+ }
}
max_keys = i;
- for( i = 1; i < max_keys; i++ )
- {
- PSA_ASSERT( psa_close_key( keys[i - 1] ) );
- PSA_ASSERT( psa_export_key( keys[i],
- exported, sizeof( exported ),
- &exported_length ) );
- ASSERT_COMPARE( exported, exported_length,
- (uint8_t *) &i, sizeof( i ) );
+ for (i = 1; i < max_keys; i++) {
+ PSA_ASSERT(psa_close_key(keys[i - 1]));
+ PSA_ASSERT(psa_export_key(keys[i],
+ exported, sizeof(exported),
+ &exported_length));
+ ASSERT_COMPARE(exported, exported_length,
+ (uint8_t *) &i, sizeof(i));
}
- PSA_ASSERT( psa_close_key( keys[i - 1] ) );
+ PSA_ASSERT(psa_close_key(keys[i - 1]));
exit:
- PSA_DONE( );
- mbedtls_free( keys );
+ PSA_DONE();
+ mbedtls_free(keys);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_STORAGE_C */
-void key_slot_eviction_to_import_new_key( int lifetime_arg )
+void key_slot_eviction_to_import_new_key(int lifetime_arg)
{
- psa_key_lifetime_t lifetime = (psa_key_lifetime_t)lifetime_arg;
+ psa_key_lifetime_t lifetime = (psa_key_lifetime_t) lifetime_arg;
size_t i;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- uint8_t exported[sizeof( size_t )];
+ uint8_t exported[sizeof(size_t)];
size_t exported_length;
mbedtls_svc_key_id_t key, returned_key_id;
- PSA_ASSERT( psa_crypto_init( ) );
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes, PSA_KEY_USAGE_EXPORT );
- psa_set_key_algorithm( &attributes, 0 );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
+ psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
+ psa_set_key_algorithm(&attributes, 0);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
/*
* Create MBEDTLS_PSA_KEY_SLOT_COUNT persistent keys.
*/
- for( i = 0; i < MBEDTLS_PSA_KEY_SLOT_COUNT; i++ )
- {
- key = mbedtls_svc_key_id_make( i, i + 1 );
- psa_set_key_id( &attributes, key );
- PSA_ASSERT( psa_import_key( &attributes,
- (uint8_t *) &i, sizeof( i ),
- &returned_key_id ) );
- TEST_ASSERT( mbedtls_svc_key_id_equal( returned_key_id, key ) );
+ for (i = 0; i < MBEDTLS_PSA_KEY_SLOT_COUNT; i++) {
+ key = mbedtls_svc_key_id_make(i, i + 1);
+ psa_set_key_id(&attributes, key);
+ PSA_ASSERT(psa_import_key(&attributes,
+ (uint8_t *) &i, sizeof(i),
+ &returned_key_id));
+ TEST_ASSERT(mbedtls_svc_key_id_equal(returned_key_id, key));
}
/*
@@ -902,18 +886,19 @@
* description in RAM.
*/
i = MBEDTLS_PSA_KEY_SLOT_COUNT;
- key = mbedtls_svc_key_id_make( i, i + 1 );
- psa_set_key_id( &attributes, key );
- psa_set_key_lifetime( &attributes, lifetime );
+ key = mbedtls_svc_key_id_make(i, i + 1);
+ psa_set_key_id(&attributes, key);
+ psa_set_key_lifetime(&attributes, lifetime);
- PSA_ASSERT( psa_import_key( &attributes,
- (uint8_t *) &i, sizeof( i ),
- &returned_key_id ) );
- if( lifetime != PSA_KEY_LIFETIME_VOLATILE )
- TEST_ASSERT( mbedtls_svc_key_id_equal( returned_key_id, key ) );
- else
- TEST_ASSERT( psa_key_id_is_volatile(
- MBEDTLS_SVC_KEY_ID_GET_KEY_ID( returned_key_id ) ) );
+ PSA_ASSERT(psa_import_key(&attributes,
+ (uint8_t *) &i, sizeof(i),
+ &returned_key_id));
+ if (lifetime != PSA_KEY_LIFETIME_VOLATILE) {
+ TEST_ASSERT(mbedtls_svc_key_id_equal(returned_key_id, key));
+ } else {
+ TEST_ASSERT(psa_key_id_is_volatile(
+ MBEDTLS_SVC_KEY_ID_GET_KEY_ID(returned_key_id)));
+ }
/*
* Check that we can export all ( MBEDTLS_PSA_KEY_SLOT_COUNT + 1 ) keys,
@@ -922,120 +907,118 @@
* slots when creating the last key is restored in a RAM slot to export
* its value.
*/
- for( i = 0; i <= MBEDTLS_PSA_KEY_SLOT_COUNT; i++ )
- {
- if( i < MBEDTLS_PSA_KEY_SLOT_COUNT )
- key = mbedtls_svc_key_id_make( i, i + 1 );
- else
+ for (i = 0; i <= MBEDTLS_PSA_KEY_SLOT_COUNT; i++) {
+ if (i < MBEDTLS_PSA_KEY_SLOT_COUNT) {
+ key = mbedtls_svc_key_id_make(i, i + 1);
+ } else {
key = returned_key_id;
+ }
- PSA_ASSERT( psa_export_key( key,
- exported, sizeof( exported ),
- &exported_length ) );
- ASSERT_COMPARE( exported, exported_length,
- (uint8_t *) &i, sizeof( i ) );
- PSA_ASSERT( psa_destroy_key( key ) );
+ PSA_ASSERT(psa_export_key(key,
+ exported, sizeof(exported),
+ &exported_length));
+ ASSERT_COMPARE(exported, exported_length,
+ (uint8_t *) &i, sizeof(i));
+ PSA_ASSERT(psa_destroy_key(key));
}
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_STORAGE_C */
-void non_reusable_key_slots_integrity_in_case_of_key_slot_starvation( )
+void non_reusable_key_slots_integrity_in_case_of_key_slot_starvation()
{
psa_status_t status;
size_t i;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- uint8_t exported[sizeof( size_t )];
+ uint8_t exported[sizeof(size_t)];
size_t exported_length;
mbedtls_svc_key_id_t persistent_key = MBEDTLS_SVC_KEY_ID_INIT;
mbedtls_svc_key_id_t persistent_key2 = MBEDTLS_SVC_KEY_ID_INIT;
mbedtls_svc_key_id_t returned_key_id = MBEDTLS_SVC_KEY_ID_INIT;
mbedtls_svc_key_id_t *keys = NULL;
- TEST_ASSERT( MBEDTLS_PSA_KEY_SLOT_COUNT >= 1 );
+ TEST_ASSERT(MBEDTLS_PSA_KEY_SLOT_COUNT >= 1);
- ASSERT_ALLOC( keys, MBEDTLS_PSA_KEY_SLOT_COUNT );
- PSA_ASSERT( psa_crypto_init( ) );
+ ASSERT_ALLOC(keys, MBEDTLS_PSA_KEY_SLOT_COUNT);
+ PSA_ASSERT(psa_crypto_init());
- psa_set_key_usage_flags( &attributes,
- PSA_KEY_USAGE_EXPORT | PSA_KEY_USAGE_COPY );
- psa_set_key_algorithm( &attributes, 0 );
- psa_set_key_type( &attributes, PSA_KEY_TYPE_RAW_DATA );
+ psa_set_key_usage_flags(&attributes,
+ PSA_KEY_USAGE_EXPORT | PSA_KEY_USAGE_COPY);
+ psa_set_key_algorithm(&attributes, 0);
+ psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA);
/*
* Create a persistent key
*/
- persistent_key = mbedtls_svc_key_id_make( 0x100, 0x205 );
- psa_set_key_id( &attributes, persistent_key );
- PSA_ASSERT( psa_import_key( &attributes,
- (uint8_t *) &persistent_key,
- sizeof( persistent_key ),
- &returned_key_id ) );
- TEST_ASSERT( mbedtls_svc_key_id_equal( returned_key_id, persistent_key ) );
+ persistent_key = mbedtls_svc_key_id_make(0x100, 0x205);
+ psa_set_key_id(&attributes, persistent_key);
+ PSA_ASSERT(psa_import_key(&attributes,
+ (uint8_t *) &persistent_key,
+ sizeof(persistent_key),
+ &returned_key_id));
+ TEST_ASSERT(mbedtls_svc_key_id_equal(returned_key_id, persistent_key));
/*
* Create MBEDTLS_PSA_KEY_SLOT_COUNT volatile keys
*/
- psa_set_key_lifetime( &attributes, PSA_KEY_LIFETIME_VOLATILE );
- for( i = 0; i < MBEDTLS_PSA_KEY_SLOT_COUNT; i++ )
- {
- PSA_ASSERT( psa_import_key( &attributes,
- (uint8_t *) &i, sizeof( i ),
- &keys[i]) );
+ psa_set_key_lifetime(&attributes, PSA_KEY_LIFETIME_VOLATILE);
+ for (i = 0; i < MBEDTLS_PSA_KEY_SLOT_COUNT; i++) {
+ PSA_ASSERT(psa_import_key(&attributes,
+ (uint8_t *) &i, sizeof(i),
+ &keys[i]));
}
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
/*
* Check that we cannot access the persistent key as all slots are
* occupied by volatile keys and the implementation needs to load the
* persistent key description in a slot to be able to access it.
*/
- status = psa_get_key_attributes( persistent_key, &attributes );
- TEST_EQUAL( status, PSA_ERROR_INSUFFICIENT_MEMORY );
+ status = psa_get_key_attributes(persistent_key, &attributes);
+ TEST_EQUAL(status, PSA_ERROR_INSUFFICIENT_MEMORY);
/*
* Check we can export the volatile key created last and that it has the
* expected value. Then, destroy it.
*/
- PSA_ASSERT( psa_export_key( keys[MBEDTLS_PSA_KEY_SLOT_COUNT - 1],
- exported, sizeof( exported ),
- &exported_length ) );
+ PSA_ASSERT(psa_export_key(keys[MBEDTLS_PSA_KEY_SLOT_COUNT - 1],
+ exported, sizeof(exported),
+ &exported_length));
i = MBEDTLS_PSA_KEY_SLOT_COUNT - 1;
- ASSERT_COMPARE( exported, exported_length, (uint8_t *) &i, sizeof( i ) );
- PSA_ASSERT( psa_destroy_key( keys[MBEDTLS_PSA_KEY_SLOT_COUNT - 1] ) );
+ ASSERT_COMPARE(exported, exported_length, (uint8_t *) &i, sizeof(i));
+ PSA_ASSERT(psa_destroy_key(keys[MBEDTLS_PSA_KEY_SLOT_COUNT - 1]));
/*
* Check that we can now access the persistent key again.
*/
- PSA_ASSERT( psa_get_key_attributes( persistent_key, &attributes ) );
- TEST_ASSERT( mbedtls_svc_key_id_equal( attributes.core.id,
- persistent_key ) );
+ PSA_ASSERT(psa_get_key_attributes(persistent_key, &attributes));
+ TEST_ASSERT(mbedtls_svc_key_id_equal(attributes.core.id,
+ persistent_key));
/*
* Check that we cannot copy the persistent key as all slots are occupied
* by the persistent key and the volatile keys and the slot containing the
* persistent key cannot be reclaimed as it contains the key to copy.
*/
- persistent_key2 = mbedtls_svc_key_id_make( 0x100, 0x204 );
- psa_set_key_id( &attributes, persistent_key2 );
- status = psa_copy_key( persistent_key, &attributes, &returned_key_id );
- TEST_EQUAL( status, PSA_ERROR_INSUFFICIENT_MEMORY );
+ persistent_key2 = mbedtls_svc_key_id_make(0x100, 0x204);
+ psa_set_key_id(&attributes, persistent_key2);
+ status = psa_copy_key(persistent_key, &attributes, &returned_key_id);
+ TEST_EQUAL(status, PSA_ERROR_INSUFFICIENT_MEMORY);
/*
* Check we can export the remaining volatile keys and that they have the
* expected values.
*/
- for( i = 0; i < ( MBEDTLS_PSA_KEY_SLOT_COUNT - 1 ); i++ )
- {
- PSA_ASSERT( psa_export_key( keys[i],
- exported, sizeof( exported ),
- &exported_length ) );
- ASSERT_COMPARE( exported, exported_length,
- (uint8_t *) &i, sizeof( i ) );
- PSA_ASSERT( psa_destroy_key( keys[i] ) );
+ for (i = 0; i < (MBEDTLS_PSA_KEY_SLOT_COUNT - 1); i++) {
+ PSA_ASSERT(psa_export_key(keys[i],
+ exported, sizeof(exported),
+ &exported_length));
+ ASSERT_COMPARE(exported, exported_length,
+ (uint8_t *) &i, sizeof(i));
+ PSA_ASSERT(psa_destroy_key(keys[i]));
}
/*
@@ -1043,19 +1026,19 @@
* value.
*/
- PSA_ASSERT( psa_export_key( persistent_key, exported, sizeof( exported ),
- &exported_length ) );
- ASSERT_COMPARE( exported, exported_length,
- (uint8_t *) &persistent_key, sizeof( persistent_key ) );
+ PSA_ASSERT(psa_export_key(persistent_key, exported, sizeof(exported),
+ &exported_length));
+ ASSERT_COMPARE(exported, exported_length,
+ (uint8_t *) &persistent_key, sizeof(persistent_key));
exit:
/*
* Key attributes may have been returned by psa_get_key_attributes()
* thus reset them as required.
*/
- psa_reset_key_attributes( &attributes );
+ psa_reset_key_attributes(&attributes);
- psa_destroy_key( persistent_key );
- PSA_DONE( );
- mbedtls_free( keys );
+ psa_destroy_key(persistent_key);
+ PSA_DONE();
+ mbedtls_free(keys);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_crypto_storage_format.function b/tests/suites/test_suite_psa_crypto_storage_format.function
index 7f0a00e..ee66f7d 100644
--- a/tests/suites/test_suite_psa_crypto_storage_format.function
+++ b/tests/suites/test_suite_psa_crypto_storage_format.function
@@ -16,10 +16,10 @@
* On error, including if the key representation in storage differs,
* mark the test case as failed and return 0. On success, return 1.
*/
-static int test_written_key( const psa_key_attributes_t *attributes,
- const data_t *material,
- psa_storage_uid_t uid,
- const data_t *expected_representation )
+static int test_written_key(const psa_key_attributes_t *attributes,
+ const data_t *material,
+ psa_storage_uid_t uid,
+ const data_t *expected_representation)
{
mbedtls_svc_key_id_t created_key_id = MBEDTLS_SVC_KEY_ID_INIT;
uint8_t *actual_representation = NULL;
@@ -28,136 +28,153 @@
int ok = 0;
/* Create a key with the given parameters. */
- PSA_ASSERT( psa_import_key( attributes, material->x, material->len,
- &created_key_id ) );
- TEST_ASSERT( mbedtls_svc_key_id_equal( psa_get_key_id( attributes ),
- created_key_id ) );
+ PSA_ASSERT(psa_import_key(attributes, material->x, material->len,
+ &created_key_id));
+ TEST_ASSERT(mbedtls_svc_key_id_equal(psa_get_key_id(attributes),
+ created_key_id));
/* 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 );
- ASSERT_ALLOC( actual_representation, storage_info.size );
- PSA_ASSERT( psa_its_get( uid, 0, storage_info.size,
- actual_representation, &length ) );
- ASSERT_COMPARE( expected_representation->x, expected_representation->len,
- actual_representation, length );
+ PSA_ASSERT(psa_its_get_info(uid, &storage_info));
+ TEST_EQUAL(storage_info.size, expected_representation->len);
+ ASSERT_ALLOC(actual_representation, storage_info.size);
+ PSA_ASSERT(psa_its_get(uid, 0, storage_info.size,
+ actual_representation, &length));
+ ASSERT_COMPARE(expected_representation->x, expected_representation->len,
+ actual_representation, length);
ok = 1;
exit:
- mbedtls_free( actual_representation );
- return( ok );
+ mbedtls_free(actual_representation);
+ return ok;
}
/** Check if a key is exportable. */
-static int can_export( const psa_key_attributes_t *attributes )
+static int can_export(const psa_key_attributes_t *attributes)
{
- if( psa_get_key_usage_flags( attributes ) & PSA_KEY_USAGE_EXPORT )
- return( 1 );
- else if( PSA_KEY_TYPE_IS_PUBLIC_KEY( psa_get_key_type( attributes ) ) )
- return( 1 );
- else
- return( 0 );
+ if (psa_get_key_usage_flags(attributes) & PSA_KEY_USAGE_EXPORT) {
+ return 1;
+ } else if (PSA_KEY_TYPE_IS_PUBLIC_KEY(psa_get_key_type(attributes))) {
+ return 1;
+ } else {
+ return 0;
+ }
}
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1)
-static int is_accelerated_rsa( psa_algorithm_t alg )
+static int is_accelerated_rsa(psa_algorithm_t alg)
{
#if defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PKCS1V15_SIGN)
- if ( PSA_ALG_IS_RSA_PKCS1V15_SIGN( alg ) )
- return( 1 );
+ if (PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg)) {
+ return 1;
+ }
#endif
#if defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PSS)
- if( PSA_ALG_IS_RSA_PSS( alg ) )
- return( 1 );
+ if (PSA_ALG_IS_RSA_PSS(alg)) {
+ return 1;
+ }
#endif
#if defined(MBEDTLS_PSA_ACCEL_ALG_RSA_OAEP)
- if( PSA_ALG_IS_RSA_OAEP( alg ) )
- return( 1 );
+ if (PSA_ALG_IS_RSA_OAEP(alg)) {
+ return 1;
+ }
#endif
(void) alg;
- return( 0 );
+ return 0;
}
/* Whether the algorithm is implemented as a builtin, i.e. not accelerated,
* and calls mbedtls_md() functions that require the hash algorithm to
* also be built-in. */
-static int is_builtin_calling_md( psa_algorithm_t alg )
+static int is_builtin_calling_md(psa_algorithm_t alg)
{
#if defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PKCS1V15_SIGN)
- if( PSA_ALG_IS_RSA_PKCS1V15_SIGN( alg ) )
- return( 1 );
+ if (PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg)) {
+ return 1;
+ }
#endif
#if defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS)
- if( PSA_ALG_IS_RSA_PSS( alg ) )
- return( 1 );
+ if (PSA_ALG_IS_RSA_PSS(alg)) {
+ return 1;
+ }
#endif
#if defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_OAEP)
- if( PSA_ALG_IS_RSA_OAEP( alg ) )
- return( 1 );
+ if (PSA_ALG_IS_RSA_OAEP(alg)) {
+ return 1;
+ }
#endif
#if defined(MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA)
- if( PSA_ALG_IS_DETERMINISTIC_ECDSA( alg ) )
- return( 1 );
+ if (PSA_ALG_IS_DETERMINISTIC_ECDSA(alg)) {
+ return 1;
+ }
#endif
(void) alg;
- return( 0 );
+ return 0;
}
-static int has_builtin_hash( psa_algorithm_t alg )
+static int has_builtin_hash(psa_algorithm_t alg)
{
#if !defined(MBEDTLS_MD2_C)
- if( alg == PSA_ALG_MD2 )
- return( 0 );
+ if (alg == PSA_ALG_MD2) {
+ return 0;
+ }
#endif
#if !defined(MBEDTLS_MD4_C)
- if( alg == PSA_ALG_MD4 )
- return( 0 );
+ if (alg == PSA_ALG_MD4) {
+ return 0;
+ }
#endif
#if !defined(MBEDTLS_MD5_C)
- if( alg == PSA_ALG_MD5 )
- return( 0 );
+ if (alg == PSA_ALG_MD5) {
+ return 0;
+ }
#endif
#if !defined(MBEDTLS_RIPEMD160_C)
- if( alg == PSA_ALG_RIPEMD160 )
- return( 0 );
+ if (alg == PSA_ALG_RIPEMD160) {
+ return 0;
+ }
#endif
#if !defined(MBEDTLS_SHA1_C)
- if( alg == PSA_ALG_SHA_1 )
- return( 0 );
+ if (alg == PSA_ALG_SHA_1) {
+ return 0;
+ }
#endif
#if !defined(MBEDTLS_SHA224_C)
- if( alg == PSA_ALG_SHA_224 )
- return( 0 );
+ if (alg == PSA_ALG_SHA_224) {
+ return 0;
+ }
#endif
#if !defined(MBEDTLS_SHA256_C)
- if( alg == PSA_ALG_SHA_256 )
- return( 0 );
+ if (alg == PSA_ALG_SHA_256) {
+ return 0;
+ }
#endif
#if !defined(MBEDTLS_SHA384_C)
- if( alg == PSA_ALG_SHA_384 )
- return( 0 );
+ if (alg == PSA_ALG_SHA_384) {
+ return 0;
+ }
#endif
#if !defined(MBEDTLS_SHA512_C)
- if( alg == PSA_ALG_SHA_512 )
- return( 0 );
+ if (alg == PSA_ALG_SHA_512) {
+ return 0;
+ }
#endif
(void) alg;
- return( 1 );
+ return 1;
}
#endif
/* Mbed TLS doesn't support certain combinations of key type and algorithm
* in certain configurations. */
-static int can_exercise( const psa_key_attributes_t *attributes )
+static int can_exercise(const psa_key_attributes_t *attributes)
{
- psa_key_type_t key_type = psa_get_key_type( attributes );
- psa_algorithm_t alg = psa_get_key_algorithm( attributes );
+ psa_key_type_t key_type = psa_get_key_type(attributes);
+ psa_algorithm_t alg = psa_get_key_algorithm(attributes);
psa_algorithm_t hash_alg =
- PSA_ALG_IS_HASH_AND_SIGN( alg ) ? PSA_ALG_SIGN_GET_HASH( alg ) :
- PSA_ALG_IS_RSA_OAEP( alg ) ? PSA_ALG_RSA_OAEP_GET_HASH( alg ) :
+ PSA_ALG_IS_HASH_AND_SIGN(alg) ? PSA_ALG_SIGN_GET_HASH(alg) :
+ PSA_ALG_IS_RSA_OAEP(alg) ? PSA_ALG_RSA_OAEP_GET_HASH(alg) :
PSA_ALG_NONE;
- psa_key_usage_t usage = psa_get_key_usage_flags( attributes );
+ psa_key_usage_t usage = psa_get_key_usage_flags(attributes);
#if defined(MBEDTLS_TEST_LIBTESTDRIVER1)
/* We test some configurations using drivers where the driver doesn't
@@ -171,32 +188,28 @@
* affected. All RSA signatures are affected except raw PKCS#1v1.5.
* OAEP is also affected.
*/
- if( PSA_ALG_IS_DETERMINISTIC_ECDSA( alg ) &&
- ! ( usage & ( PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_SIGN_MESSAGE ) ) )
- {
+ if (PSA_ALG_IS_DETERMINISTIC_ECDSA(alg) &&
+ !(usage & (PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_SIGN_MESSAGE))) {
/* Verification only. Verification doesn't use the hash algorithm. */
- return( 1 );
+ return 1;
}
#if defined(MBEDTLS_PSA_ACCEL_ALG_DETERMINISTIC_ECDSA)
- if( PSA_ALG_IS_DETERMINISTIC_ECDSA( alg ) &&
- ( hash_alg == PSA_ALG_MD5 ||
- hash_alg == PSA_ALG_RIPEMD160 ||
- hash_alg == PSA_ALG_SHA_1 ) )
- {
- return( 0 );
+ if (PSA_ALG_IS_DETERMINISTIC_ECDSA(alg) &&
+ (hash_alg == PSA_ALG_MD5 ||
+ hash_alg == PSA_ALG_RIPEMD160 ||
+ hash_alg == PSA_ALG_SHA_1)) {
+ return 0;
}
#endif
- if( is_accelerated_rsa( alg ) &&
- ( hash_alg == PSA_ALG_RIPEMD160 || hash_alg == PSA_ALG_SHA_384 ) )
- {
- return( 0 );
+ if (is_accelerated_rsa(alg) &&
+ (hash_alg == PSA_ALG_RIPEMD160 || hash_alg == PSA_ALG_SHA_384)) {
+ return 0;
}
#if defined(MBEDTLS_PSA_ACCEL_ALG_RSA_OAEP)
- if( PSA_ALG_IS_RSA_OAEP( alg ) &&
- ( hash_alg == PSA_ALG_RIPEMD160 || hash_alg == PSA_ALG_SHA_384 ) )
- {
- return( 0 );
+ if (PSA_ALG_IS_RSA_OAEP(alg) &&
+ (hash_alg == PSA_ALG_RIPEMD160 || hash_alg == PSA_ALG_SHA_384)) {
+ return 0;
}
#endif
@@ -204,9 +217,8 @@
* hash internally only dispatch to the internal md module, not to
* PSA. Until this is supported, don't try to actually perform
* operations when the operation is built-in and the hash isn't. */
- if( is_builtin_calling_md( alg ) && ! has_builtin_hash( hash_alg ) )
- {
- return( 0 );
+ if (is_builtin_calling_md(alg) && !has_builtin_hash(hash_alg)) {
+ return 0;
}
#endif /* MBEDTLS_TEST_LIBTESTDRIVER1 */
@@ -214,7 +226,7 @@
(void) alg;
(void) hash_alg;
(void) usage;
- return( 1 );
+ return 1;
}
/** Write a key with the given representation to storage, then check
@@ -223,78 +235,73 @@
* On error, including if the key representation in storage differs,
* mark the test case as failed and return 0. On success, return 1.
*/
-static int test_read_key( const psa_key_attributes_t *expected_attributes,
- const data_t *expected_material,
- psa_storage_uid_t uid,
- const data_t *representation,
- int flags )
+static int test_read_key(const psa_key_attributes_t *expected_attributes,
+ const data_t *expected_material,
+ psa_storage_uid_t uid,
+ const data_t *representation,
+ int flags)
{
psa_key_attributes_t actual_attributes = PSA_KEY_ATTRIBUTES_INIT;
- mbedtls_svc_key_id_t key_id = psa_get_key_id( expected_attributes );
+ mbedtls_svc_key_id_t key_id = psa_get_key_id(expected_attributes);
struct psa_storage_info_t storage_info;
int ok = 0;
uint8_t *exported_material = NULL;
size_t length;
/* Prime the storage with a key file. */
- PSA_ASSERT( psa_its_set( uid, representation->len, representation->x, 0 ) );
+ PSA_ASSERT(psa_its_set(uid, representation->len, representation->x, 0));
/* Check that the injected key exists and looks as expected. */
- PSA_ASSERT( psa_get_key_attributes( key_id, &actual_attributes ) );
- TEST_ASSERT( mbedtls_svc_key_id_equal( key_id,
- psa_get_key_id( &actual_attributes ) ) );
- TEST_EQUAL( psa_get_key_lifetime( expected_attributes ),
- psa_get_key_lifetime( &actual_attributes ) );
- TEST_EQUAL( psa_get_key_type( expected_attributes ),
- psa_get_key_type( &actual_attributes ) );
- TEST_EQUAL( psa_get_key_bits( expected_attributes ),
- psa_get_key_bits( &actual_attributes ) );
- TEST_EQUAL( psa_get_key_usage_flags( expected_attributes ),
- psa_get_key_usage_flags( &actual_attributes ) );
- TEST_EQUAL( psa_get_key_algorithm( expected_attributes ),
- psa_get_key_algorithm( &actual_attributes ) );
- TEST_EQUAL( psa_get_key_enrollment_algorithm( expected_attributes ),
- psa_get_key_enrollment_algorithm( &actual_attributes ) );
- if( can_export( expected_attributes ) )
- {
- ASSERT_ALLOC( exported_material, expected_material->len );
- PSA_ASSERT( psa_export_key( key_id,
- exported_material, expected_material->len,
- &length ) );
- ASSERT_COMPARE( expected_material->x, expected_material->len,
- exported_material, length );
+ PSA_ASSERT(psa_get_key_attributes(key_id, &actual_attributes));
+ TEST_ASSERT(mbedtls_svc_key_id_equal(key_id,
+ psa_get_key_id(&actual_attributes)));
+ TEST_EQUAL(psa_get_key_lifetime(expected_attributes),
+ psa_get_key_lifetime(&actual_attributes));
+ TEST_EQUAL(psa_get_key_type(expected_attributes),
+ psa_get_key_type(&actual_attributes));
+ TEST_EQUAL(psa_get_key_bits(expected_attributes),
+ psa_get_key_bits(&actual_attributes));
+ TEST_EQUAL(psa_get_key_usage_flags(expected_attributes),
+ psa_get_key_usage_flags(&actual_attributes));
+ TEST_EQUAL(psa_get_key_algorithm(expected_attributes),
+ psa_get_key_algorithm(&actual_attributes));
+ TEST_EQUAL(psa_get_key_enrollment_algorithm(expected_attributes),
+ psa_get_key_enrollment_algorithm(&actual_attributes));
+ if (can_export(expected_attributes)) {
+ ASSERT_ALLOC(exported_material, expected_material->len);
+ PSA_ASSERT(psa_export_key(key_id,
+ exported_material, expected_material->len,
+ &length));
+ ASSERT_COMPARE(expected_material->x, expected_material->len,
+ exported_material, length);
}
- if( ( flags & TEST_FLAG_EXERCISE ) && can_exercise( &actual_attributes ) )
- {
- TEST_ASSERT( mbedtls_test_psa_exercise_key(
- key_id,
- psa_get_key_usage_flags( expected_attributes ),
- psa_get_key_algorithm( expected_attributes ) ) );
+ if ((flags & TEST_FLAG_EXERCISE) && can_exercise(&actual_attributes)) {
+ TEST_ASSERT(mbedtls_test_psa_exercise_key(
+ key_id,
+ psa_get_key_usage_flags(expected_attributes),
+ psa_get_key_algorithm(expected_attributes)));
}
- if( flags & TEST_FLAG_READ_ONLY )
- {
+ if (flags & TEST_FLAG_READ_ONLY) {
/* Read-only keys cannot be removed through the API.
* The key will be removed through ITS in the cleanup code below. */
- TEST_EQUAL( PSA_ERROR_NOT_PERMITTED, psa_destroy_key( key_id ) );
- }
- else
- {
+ TEST_EQUAL(PSA_ERROR_NOT_PERMITTED, psa_destroy_key(key_id));
+ } else {
/* Destroy the key. Confirm through direct access to the storage. */
- PSA_ASSERT( psa_destroy_key( key_id ) );
- TEST_EQUAL( PSA_ERROR_DOES_NOT_EXIST,
- psa_its_get_info( uid, &storage_info ) );
+ PSA_ASSERT(psa_destroy_key(key_id));
+ TEST_EQUAL(PSA_ERROR_DOES_NOT_EXIST,
+ psa_its_get_info(uid, &storage_info));
}
ok = 1;
exit:
- psa_reset_key_attributes( &actual_attributes );
- psa_its_remove( uid );
- mbedtls_free( exported_material );
- return( ok );
+ psa_reset_key_attributes(&actual_attributes);
+ psa_its_remove(uid);
+ mbedtls_free(exported_material);
+ return ok;
}
/* END_HEADER */
@@ -305,10 +312,10 @@
*/
/* BEGIN_CASE */
-void key_storage_save( int lifetime_arg, int type_arg, int bits_arg,
- int usage_arg, int alg_arg, int alg2_arg,
- data_t *material,
- data_t *representation )
+void key_storage_save(int lifetime_arg, int type_arg, int bits_arg,
+ int usage_arg, int alg_arg, int alg2_arg,
+ data_t *material,
+ data_t *representation)
{
/* Forward compatibility: save a key in the current format and
* check that it has the expected format so that future versions
@@ -320,40 +327,40 @@
psa_key_usage_t usage = usage_arg;
psa_algorithm_t alg = alg_arg;
psa_algorithm_t alg2 = alg2_arg;
- mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make( 0, 1 );
+ mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make(0, 1);
psa_storage_uid_t uid = 1;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_INIT( );
- TEST_USES_KEY_ID( key_id );
+ PSA_INIT();
+ TEST_USES_KEY_ID(key_id);
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_id( &attributes, key_id );
- psa_set_key_type( &attributes, type );
- psa_set_key_bits( &attributes, bits );
- psa_set_key_usage_flags( &attributes, usage );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_enrollment_algorithm( &attributes, alg2 );
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_id(&attributes, key_id);
+ psa_set_key_type(&attributes, type);
+ psa_set_key_bits(&attributes, bits);
+ psa_set_key_usage_flags(&attributes, usage);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_enrollment_algorithm(&attributes, alg2);
/* This is the current storage format. Test that we know exactly how
* the key is stored. The stability of the test data in future
* versions of Mbed TLS will guarantee that future versions
* can read back what this version wrote. */
- TEST_ASSERT( test_written_key( &attributes, material,
- uid, representation ) );
+ TEST_ASSERT(test_written_key(&attributes, material,
+ uid, representation));
exit:
- psa_reset_key_attributes( &attributes );
- psa_destroy_key( key_id );
- PSA_DONE( );
+ psa_reset_key_attributes(&attributes);
+ psa_destroy_key(key_id);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void key_storage_read( int lifetime_arg, int type_arg, int bits_arg,
- int usage_arg, int alg_arg, int alg2_arg,
- data_t *material,
- data_t *representation, int flags )
+void key_storage_read(int lifetime_arg, int type_arg, int bits_arg,
+ int usage_arg, int alg_arg, int alg2_arg,
+ data_t *material,
+ data_t *representation, int flags)
{
/* Backward compatibility: read a key in the format of a past version
* and check that this version can use it. */
@@ -364,29 +371,29 @@
psa_key_usage_t usage = usage_arg;
psa_algorithm_t alg = alg_arg;
psa_algorithm_t alg2 = alg2_arg;
- mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make( 0, 1 );
+ mbedtls_svc_key_id_t key_id = mbedtls_svc_key_id_make(0, 1);
psa_storage_uid_t uid = 1;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
- PSA_INIT( );
- TEST_USES_KEY_ID( key_id );
+ PSA_INIT();
+ TEST_USES_KEY_ID(key_id);
- psa_set_key_lifetime( &attributes, lifetime );
- psa_set_key_id( &attributes, key_id );
- psa_set_key_type( &attributes, type );
- psa_set_key_bits( &attributes, bits );
- psa_set_key_usage_flags( &attributes, usage );
- psa_set_key_algorithm( &attributes, alg );
- psa_set_key_enrollment_algorithm( &attributes, alg2 );
+ psa_set_key_lifetime(&attributes, lifetime);
+ psa_set_key_id(&attributes, key_id);
+ psa_set_key_type(&attributes, type);
+ psa_set_key_bits(&attributes, bits);
+ psa_set_key_usage_flags(&attributes, usage);
+ psa_set_key_algorithm(&attributes, alg);
+ psa_set_key_enrollment_algorithm(&attributes, alg2);
/* Test that we can use a key with the given representation. This
* guarantees backward compatibility with keys that were stored by
* past versions of Mbed TLS. */
- TEST_ASSERT( test_read_key( &attributes, material,
- uid, representation, flags ) );
+ TEST_ASSERT(test_read_key(&attributes, material,
+ uid, representation, flags));
exit:
- psa_reset_key_attributes( &attributes );
- PSA_DONE( );
+ psa_reset_key_attributes(&attributes);
+ PSA_DONE();
}
/* END_CASE */
diff --git a/tests/suites/test_suite_psa_its.function b/tests/suites/test_suite_psa_its.function
index 12878b5..7864b9c 100644
--- a/tests/suites/test_suite_psa_its.function
+++ b/tests/suites/test_suite_psa_its.function
@@ -20,23 +20,23 @@
#define PSA_ITS_STORAGE_FILENAME_PATTERN "%08lx%08lx"
#define PSA_ITS_STORAGE_SUFFIX ".psa_its"
#define PSA_ITS_STORAGE_FILENAME_LENGTH \
- ( sizeof( PSA_ITS_STORAGE_PREFIX ) - 1 + /*prefix without terminating 0*/ \
- 16 + /*UID (64-bit number in hex)*/ \
- 16 + /*UID (64-bit number in hex)*/ \
- sizeof( PSA_ITS_STORAGE_SUFFIX ) - 1 + /*suffix without terminating 0*/ \
- 1 /*terminating null byte*/ )
+ (sizeof(PSA_ITS_STORAGE_PREFIX) - 1 + /*prefix without terminating 0*/ \
+ 16 + /*UID (64-bit number in hex)*/ \
+ 16 + /*UID (64-bit number in hex)*/ \
+ sizeof(PSA_ITS_STORAGE_SUFFIX) - 1 + /*suffix without terminating 0*/ \
+ 1 /*terminating null byte*/)
#define PSA_ITS_STORAGE_TEMP \
PSA_ITS_STORAGE_PREFIX "tempfile" PSA_ITS_STORAGE_SUFFIX
-static void psa_its_fill_filename( psa_storage_uid_t uid, char *filename )
+static void psa_its_fill_filename(psa_storage_uid_t uid, char *filename)
{
/* Break up the UID into two 32-bit pieces so as not to rely on
* long long support in snprintf. */
- mbedtls_snprintf( filename, PSA_ITS_STORAGE_FILENAME_LENGTH,
- "%s" PSA_ITS_STORAGE_FILENAME_PATTERN "%s",
- PSA_ITS_STORAGE_PREFIX,
- (unsigned long) ( uid >> 32 ),
- (unsigned long) ( uid & 0xffffffff ),
- PSA_ITS_STORAGE_SUFFIX );
+ mbedtls_snprintf(filename, PSA_ITS_STORAGE_FILENAME_LENGTH,
+ "%s" PSA_ITS_STORAGE_FILENAME_PATTERN "%s",
+ PSA_ITS_STORAGE_PREFIX,
+ (unsigned long) (uid >> 32),
+ (unsigned long) (uid & 0xffffffff),
+ PSA_ITS_STORAGE_SUFFIX);
}
/* Maximum uid used by the test, recorded so that cleanup() can delete
@@ -44,7 +44,7 @@
* need to and should not be taken into account for uid_max. */
static psa_storage_uid_t uid_max = 0;
-static void cleanup( void )
+static void cleanup(void)
{
/* Call remove() on all the files that a test might have created.
* We ignore the error if the file exists but remove() fails because
@@ -55,25 +55,25 @@
* test case. */
char filename[PSA_ITS_STORAGE_FILENAME_LENGTH];
psa_storage_uid_t uid;
- for( uid = 0; uid < uid_max; uid++ )
- {
- psa_its_fill_filename( uid, filename );
- (void) remove( filename );
+ for (uid = 0; uid < uid_max; uid++) {
+ psa_its_fill_filename(uid, filename);
+ (void) remove(filename);
}
- psa_its_fill_filename( (psa_storage_uid_t)( -1 ), filename );
- (void) remove( filename );
- (void) remove( PSA_ITS_STORAGE_TEMP );
+ psa_its_fill_filename((psa_storage_uid_t) (-1), filename);
+ (void) remove(filename);
+ (void) remove(PSA_ITS_STORAGE_TEMP);
uid_max = 0;
}
-static psa_status_t psa_its_set_wrap( psa_storage_uid_t uid,
- uint32_t data_length,
- const void *p_data,
- psa_storage_create_flags_t create_flags )
+static psa_status_t psa_its_set_wrap(psa_storage_uid_t uid,
+ uint32_t data_length,
+ const void *p_data,
+ psa_storage_create_flags_t create_flags)
{
- if( uid_max != (psa_storage_uid_t)( -1 ) && uid_max < uid )
+ if (uid_max != (psa_storage_uid_t) (-1) && uid_max < uid) {
uid_max = uid;
- return( psa_its_set( uid, data_length, p_data, create_flags ) );
+ }
+ return psa_its_set(uid, data_length, p_data, create_flags);
}
/* END_HEADER */
@@ -84,7 +84,7 @@
*/
/* BEGIN_CASE */
-void set_get_remove( int uid_arg, int flags_arg, data_t *data )
+void set_get_remove(int uid_arg, int flags_arg, data_t *data)
{
psa_storage_uid_t uid = uid_arg;
uint32_t flags = flags_arg;
@@ -92,28 +92,28 @@
unsigned char *buffer = NULL;
size_t ret_len = 0;
- ASSERT_ALLOC( buffer, data->len );
+ ASSERT_ALLOC(buffer, data->len);
- PSA_ASSERT( psa_its_set_wrap( uid, data->len, data->x, flags ) );
+ PSA_ASSERT(psa_its_set_wrap(uid, data->len, data->x, flags));
- PSA_ASSERT( psa_its_get_info( uid, &info ) );
- TEST_ASSERT( info.size == data->len );
- TEST_ASSERT( info.flags == flags );
- PSA_ASSERT( psa_its_get( uid, 0, data->len, buffer, &ret_len ) );
- ASSERT_COMPARE( data->x, data->len, buffer, ret_len );
+ PSA_ASSERT(psa_its_get_info(uid, &info));
+ TEST_ASSERT(info.size == data->len);
+ TEST_ASSERT(info.flags == flags);
+ PSA_ASSERT(psa_its_get(uid, 0, data->len, buffer, &ret_len));
+ ASSERT_COMPARE(data->x, data->len, buffer, ret_len);
- PSA_ASSERT( psa_its_remove( uid ) );
+ PSA_ASSERT(psa_its_remove(uid));
exit:
- mbedtls_free( buffer );
- cleanup( );
+ mbedtls_free(buffer);
+ cleanup();
}
/* END_CASE */
/* BEGIN_CASE */
-void set_overwrite( int uid_arg,
- int flags1_arg, data_t *data1,
- int flags2_arg, data_t *data2 )
+void set_overwrite(int uid_arg,
+ int flags1_arg, data_t *data1,
+ int flags2_arg, data_t *data2)
{
psa_storage_uid_t uid = uid_arg;
uint32_t flags1 = flags1_arg;
@@ -122,33 +122,33 @@
unsigned char *buffer = NULL;
size_t ret_len = 0;
- ASSERT_ALLOC( buffer, MAX( data1->len, data2->len ) );
+ ASSERT_ALLOC(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 ) );
- TEST_ASSERT( info.size == data1->len );
- TEST_ASSERT( info.flags == flags1 );
- PSA_ASSERT( psa_its_get( uid, 0, data1->len, buffer, &ret_len ) );
- ASSERT_COMPARE( data1->x, data1->len, buffer, ret_len );
+ PSA_ASSERT(psa_its_set_wrap(uid, data1->len, data1->x, flags1));
+ PSA_ASSERT(psa_its_get_info(uid, &info));
+ TEST_ASSERT(info.size == data1->len);
+ TEST_ASSERT(info.flags == flags1);
+ PSA_ASSERT(psa_its_get(uid, 0, data1->len, buffer, &ret_len));
+ ASSERT_COMPARE(data1->x, data1->len, buffer, ret_len);
- PSA_ASSERT( psa_its_set_wrap( uid, data2->len, data2->x, flags2 ) );
- PSA_ASSERT( psa_its_get_info( uid, &info ) );
- TEST_ASSERT( info.size == data2->len );
- TEST_ASSERT( info.flags == flags2 );
+ PSA_ASSERT(psa_its_set_wrap(uid, data2->len, data2->x, flags2));
+ PSA_ASSERT(psa_its_get_info(uid, &info));
+ TEST_ASSERT(info.size == data2->len);
+ TEST_ASSERT(info.flags == flags2);
ret_len = 0;
- PSA_ASSERT( psa_its_get( uid, 0, data2->len, buffer, &ret_len ) );
- ASSERT_COMPARE( data2->x, data2->len, buffer, ret_len );
+ PSA_ASSERT(psa_its_get(uid, 0, data2->len, buffer, &ret_len));
+ ASSERT_COMPARE(data2->x, data2->len, buffer, ret_len);
- PSA_ASSERT( psa_its_remove( uid ) );
+ PSA_ASSERT(psa_its_remove(uid));
exit:
- mbedtls_free( buffer );
- cleanup( );
+ mbedtls_free(buffer);
+ cleanup();
}
/* END_CASE */
/* BEGIN_CASE */
-void set_multiple( int first_id, int count )
+void set_multiple(int first_id, int count)
{
psa_storage_uid_t uid0 = first_id;
psa_storage_uid_t uid;
@@ -156,58 +156,55 @@
char retrieved[40];
size_t ret_len = 0;
- memset( stored, '.', sizeof( stored ) );
- for( uid = uid0; uid < uid0 + count; uid++ )
- {
- mbedtls_snprintf( stored, sizeof( stored ),
- "Content of file 0x%08lx", (unsigned long) uid );
- PSA_ASSERT( psa_its_set_wrap( uid, sizeof( stored ), stored, 0 ) );
+ memset(stored, '.', sizeof(stored));
+ for (uid = uid0; uid < uid0 + count; uid++) {
+ mbedtls_snprintf(stored, sizeof(stored),
+ "Content of file 0x%08lx", (unsigned long) uid);
+ PSA_ASSERT(psa_its_set_wrap(uid, sizeof(stored), stored, 0));
}
- for( uid = uid0; uid < uid0 + count; uid++ )
- {
- mbedtls_snprintf( stored, sizeof( stored ),
- "Content of file 0x%08lx", (unsigned long) uid );
- PSA_ASSERT( psa_its_get( uid, 0, sizeof( stored ), retrieved, &ret_len ) );
- ASSERT_COMPARE( retrieved, ret_len,
- stored, sizeof( stored ) );
- PSA_ASSERT( psa_its_remove( uid ) );
- TEST_ASSERT( psa_its_get( uid, 0, 0, NULL, NULL ) ==
- PSA_ERROR_DOES_NOT_EXIST );
+ for (uid = uid0; uid < uid0 + count; uid++) {
+ mbedtls_snprintf(stored, sizeof(stored),
+ "Content of file 0x%08lx", (unsigned long) uid);
+ PSA_ASSERT(psa_its_get(uid, 0, sizeof(stored), retrieved, &ret_len));
+ ASSERT_COMPARE(retrieved, ret_len,
+ stored, sizeof(stored));
+ PSA_ASSERT(psa_its_remove(uid));
+ TEST_ASSERT(psa_its_get(uid, 0, 0, NULL, NULL) ==
+ PSA_ERROR_DOES_NOT_EXIST);
}
exit:
- cleanup( );
+ cleanup();
}
/* END_CASE */
/* BEGIN_CASE */
-void nonexistent( int uid_arg, int create_and_remove )
+void nonexistent(int uid_arg, int create_and_remove)
{
psa_storage_uid_t uid = uid_arg;
struct psa_storage_info_t info;
- if( create_and_remove )
- {
- PSA_ASSERT( psa_its_set_wrap( uid, 0, NULL, 0 ) );
- PSA_ASSERT( psa_its_remove( uid ) );
+ if (create_and_remove) {
+ PSA_ASSERT(psa_its_set_wrap(uid, 0, NULL, 0));
+ PSA_ASSERT(psa_its_remove(uid));
}
- TEST_ASSERT( psa_its_remove( uid ) == PSA_ERROR_DOES_NOT_EXIST );
- TEST_ASSERT( psa_its_get_info( uid, &info ) ==
- PSA_ERROR_DOES_NOT_EXIST );
- TEST_ASSERT( psa_its_get( uid, 0, 0, NULL, NULL ) ==
- PSA_ERROR_DOES_NOT_EXIST );
+ TEST_ASSERT(psa_its_remove(uid) == PSA_ERROR_DOES_NOT_EXIST);
+ TEST_ASSERT(psa_its_get_info(uid, &info) ==
+ PSA_ERROR_DOES_NOT_EXIST);
+ TEST_ASSERT(psa_its_get(uid, 0, 0, NULL, NULL) ==
+ PSA_ERROR_DOES_NOT_EXIST);
exit:
- cleanup( );
+ cleanup();
}
/* END_CASE */
/* BEGIN_CASE */
-void get_at( int uid_arg, data_t *data,
- int offset, int length_arg,
- int expected_status )
+void get_at(int uid_arg, data_t *data,
+ int offset, int length_arg,
+ int expected_status)
{
psa_storage_uid_t uid = uid_arg;
unsigned char *buffer = NULL;
@@ -217,31 +214,33 @@
size_t i;
size_t ret_len = 0;
- ASSERT_ALLOC( buffer, length + 16 );
+ ASSERT_ALLOC(buffer, length + 16);
trailer = buffer + length;
- memset( trailer, '-', 16 );
+ memset(trailer, '-', 16);
- PSA_ASSERT( psa_its_set_wrap( uid, data->len, data->x, 0 ) );
+ PSA_ASSERT(psa_its_set_wrap(uid, data->len, data->x, 0));
- status = psa_its_get( uid, offset, length_arg, buffer, &ret_len );
- TEST_ASSERT( status == (psa_status_t) expected_status );
- if( status == PSA_SUCCESS )
- ASSERT_COMPARE( data->x + offset, (size_t) length_arg,
- buffer, ret_len );
- for( i = 0; i < 16; i++ )
- TEST_ASSERT( trailer[i] == '-' );
- PSA_ASSERT( psa_its_remove( uid ) );
+ status = psa_its_get(uid, offset, length_arg, buffer, &ret_len);
+ TEST_ASSERT(status == (psa_status_t) expected_status);
+ if (status == PSA_SUCCESS) {
+ ASSERT_COMPARE(data->x + offset, (size_t) length_arg,
+ buffer, ret_len);
+ }
+ for (i = 0; i < 16; i++) {
+ TEST_ASSERT(trailer[i] == '-');
+ }
+ PSA_ASSERT(psa_its_remove(uid));
exit:
- mbedtls_free( buffer );
- cleanup( );
+ mbedtls_free(buffer);
+ cleanup();
}
/* END_CASE */
/* BEGIN_CASE */
-void get_fail( int uid_arg, data_t *data,
- int overwrite_magic, int cut_header,
- int expected_status )
+void get_fail(int uid_arg, data_t *data,
+ int overwrite_magic, int cut_header,
+ int expected_status)
{
psa_storage_uid_t uid = uid_arg;
unsigned char *buffer = NULL;
@@ -252,54 +251,53 @@
FILE *stream = NULL;
char bad_char = 'X';
- PSA_ASSERT( psa_its_set_wrap( uid, data->len, data->x, 0 ) );
+ PSA_ASSERT(psa_its_set_wrap(uid, data->len, data->x, 0));
- psa_its_fill_filename( uid, filename );
- stream = fopen( filename, "rb+" );
- TEST_ASSERT( NULL != stream );
- if( 0 != overwrite_magic )
- {
+ psa_its_fill_filename(uid, filename);
+ stream = fopen(filename, "rb+");
+ TEST_ASSERT(NULL != stream);
+ if (0 != overwrite_magic) {
/* Overwrite the 1st byte of the file, the ITS magic number */
- TEST_ASSERT( fseek( stream, 0, SEEK_SET ) == 0 );
- n = fwrite( &bad_char, 1, 1, stream );
- TEST_ASSERT( 1 == n );
+ TEST_ASSERT(fseek(stream, 0, SEEK_SET) == 0);
+ n = fwrite(&bad_char, 1, 1, stream);
+ TEST_ASSERT(1 == n);
}
- if( 0 != cut_header )
- {
+ if (0 != cut_header) {
/* Reopen file and truncate it to 0 byte by specifying the 'w' flag */
- stream = freopen( filename, "wb", stream );
- TEST_ASSERT( NULL != stream );
+ stream = freopen(filename, "wb", stream);
+ TEST_ASSERT(NULL != stream);
}
- fclose( stream );
+ fclose(stream);
stream = NULL;
- status = psa_its_get( uid, 0, 0, buffer, &ret_len );
- TEST_ASSERT( status == (psa_status_t) expected_status );
- TEST_ASSERT( 0 == ret_len );
- PSA_ASSERT( psa_its_remove( uid ) );
+ status = psa_its_get(uid, 0, 0, buffer, &ret_len);
+ TEST_ASSERT(status == (psa_status_t) expected_status);
+ TEST_ASSERT(0 == ret_len);
+ PSA_ASSERT(psa_its_remove(uid));
/* Check if the file is really deleted. */
- stream = fopen( filename, "rb" );
- TEST_ASSERT( NULL == stream );
+ stream = fopen(filename, "rb");
+ TEST_ASSERT(NULL == stream);
exit:
- if( stream != NULL )
- fclose( stream );
+ if (stream != NULL) {
+ fclose(stream);
+ }
- mbedtls_free( buffer );
- cleanup( );
+ mbedtls_free(buffer);
+ cleanup();
}
/* END_CASE */
/* BEGIN_CASE */
-void set_fail( int uid_arg, data_t *data,
- int expected_status )
+void set_fail(int uid_arg, data_t *data,
+ int expected_status)
{
psa_storage_uid_t uid = uid_arg;
- TEST_ASSERT( psa_its_set_wrap( uid, data->len, data->x, 0 ) ==
- (psa_status_t) expected_status );
+ TEST_ASSERT(psa_its_set_wrap(uid, data->len, data->x, 0) ==
+ (psa_status_t) expected_status);
- exit:
- cleanup( );
+exit:
+ cleanup();
}
/* END_CASE */
diff --git a/tests/suites/test_suite_random.function b/tests/suites/test_suite_random.function
index 37fa36e..0f0c7fa 100644
--- a/tests/suites/test_suite_random.function
+++ b/tests/suites/test_suite_random.function
@@ -19,7 +19,7 @@
/* END_HEADER */
/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_C:!MBEDTLS_TEST_NULL_ENTROPY:MBEDTLS_CTR_DRBG_C */
-void random_twice_with_ctr_drbg( )
+void random_twice_with_ctr_drbg()
{
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context drbg;
@@ -27,176 +27,176 @@
unsigned char output2[OUTPUT_SIZE];
/* First round */
- mbedtls_entropy_init( &entropy );
- mbedtls_ctr_drbg_init( &drbg );
- TEST_EQUAL( 0, mbedtls_ctr_drbg_seed( &drbg,
- mbedtls_entropy_func, &entropy,
- NULL, 0 ) );
- TEST_EQUAL( 0, mbedtls_ctr_drbg_random( &drbg,
- output1, sizeof( output1 ) ) );
- mbedtls_ctr_drbg_free( &drbg );
- mbedtls_entropy_free( &entropy );
+ mbedtls_entropy_init(&entropy);
+ mbedtls_ctr_drbg_init(&drbg);
+ TEST_EQUAL(0, mbedtls_ctr_drbg_seed(&drbg,
+ mbedtls_entropy_func, &entropy,
+ NULL, 0));
+ TEST_EQUAL(0, mbedtls_ctr_drbg_random(&drbg,
+ output1, sizeof(output1)));
+ mbedtls_ctr_drbg_free(&drbg);
+ mbedtls_entropy_free(&entropy);
/* Second round */
- mbedtls_entropy_init( &entropy );
- mbedtls_ctr_drbg_init( &drbg );
- TEST_EQUAL( 0, mbedtls_ctr_drbg_seed( &drbg,
- mbedtls_entropy_func, &entropy,
- NULL, 0 ) );
- TEST_EQUAL( 0, mbedtls_ctr_drbg_random( &drbg,
- output2, sizeof( output2 ) ) );
- mbedtls_ctr_drbg_free( &drbg );
- mbedtls_entropy_free( &entropy );
+ mbedtls_entropy_init(&entropy);
+ mbedtls_ctr_drbg_init(&drbg);
+ TEST_EQUAL(0, mbedtls_ctr_drbg_seed(&drbg,
+ mbedtls_entropy_func, &entropy,
+ NULL, 0));
+ TEST_EQUAL(0, mbedtls_ctr_drbg_random(&drbg,
+ output2, sizeof(output2)));
+ mbedtls_ctr_drbg_free(&drbg);
+ mbedtls_entropy_free(&entropy);
/* The two rounds must generate different random data. */
- TEST_ASSERT( memcmp( output1, output2, OUTPUT_SIZE ) != 0 );
+ TEST_ASSERT(memcmp(output1, output2, OUTPUT_SIZE) != 0);
exit:
- mbedtls_ctr_drbg_free( &drbg );
- mbedtls_entropy_free( &entropy );
+ mbedtls_ctr_drbg_free(&drbg);
+ mbedtls_entropy_free(&entropy);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_C:!MBEDTLS_TEST_NULL_ENTROPY:MBEDTLS_HMAC_DRBG_C */
-void random_twice_with_hmac_drbg( int md_type )
+void random_twice_with_hmac_drbg(int md_type)
{
mbedtls_entropy_context entropy;
mbedtls_hmac_drbg_context drbg;
unsigned char output1[OUTPUT_SIZE];
unsigned char output2[OUTPUT_SIZE];
- const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type( md_type );
+ const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type(md_type);
/* First round */
- mbedtls_entropy_init( &entropy );
- mbedtls_hmac_drbg_init( &drbg );
- TEST_EQUAL( 0, mbedtls_hmac_drbg_seed( &drbg, md_info,
- mbedtls_entropy_func, &entropy,
- NULL, 0 ) );
- TEST_EQUAL( 0, mbedtls_hmac_drbg_random( &drbg,
- output1, sizeof( output1 ) ) );
- mbedtls_hmac_drbg_free( &drbg );
- mbedtls_entropy_free( &entropy );
+ mbedtls_entropy_init(&entropy);
+ mbedtls_hmac_drbg_init(&drbg);
+ TEST_EQUAL(0, mbedtls_hmac_drbg_seed(&drbg, md_info,
+ mbedtls_entropy_func, &entropy,
+ NULL, 0));
+ TEST_EQUAL(0, mbedtls_hmac_drbg_random(&drbg,
+ output1, sizeof(output1)));
+ mbedtls_hmac_drbg_free(&drbg);
+ mbedtls_entropy_free(&entropy);
/* Second round */
- mbedtls_entropy_init( &entropy );
- mbedtls_hmac_drbg_init( &drbg );
- TEST_EQUAL( 0, mbedtls_hmac_drbg_seed( &drbg, md_info,
- mbedtls_entropy_func, &entropy,
- NULL, 0 ) );
- TEST_EQUAL( 0, mbedtls_hmac_drbg_random( &drbg,
- output2, sizeof( output2 ) ) );
- mbedtls_hmac_drbg_free( &drbg );
- mbedtls_entropy_free( &entropy );
+ mbedtls_entropy_init(&entropy);
+ mbedtls_hmac_drbg_init(&drbg);
+ TEST_EQUAL(0, mbedtls_hmac_drbg_seed(&drbg, md_info,
+ mbedtls_entropy_func, &entropy,
+ NULL, 0));
+ TEST_EQUAL(0, mbedtls_hmac_drbg_random(&drbg,
+ output2, sizeof(output2)));
+ mbedtls_hmac_drbg_free(&drbg);
+ mbedtls_entropy_free(&entropy);
/* The two rounds must generate different random data. */
- TEST_ASSERT( memcmp( output1, output2, OUTPUT_SIZE ) != 0 );
+ TEST_ASSERT(memcmp(output1, output2, OUTPUT_SIZE) != 0);
exit:
- mbedtls_hmac_drbg_free( &drbg );
- mbedtls_entropy_free( &entropy );
+ mbedtls_hmac_drbg_free(&drbg);
+ mbedtls_entropy_free(&entropy);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_C:!MBEDTLS_TEST_NULL_ENTROPY:!MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */
-void random_twice_with_psa_from_classic( )
+void random_twice_with_psa_from_classic()
{
unsigned char output1[OUTPUT_SIZE];
unsigned char output2[OUTPUT_SIZE];
/* First round */
- PSA_ASSERT( psa_crypto_init( ) );
- TEST_EQUAL( 0, mbedtls_psa_get_random( MBEDTLS_PSA_RANDOM_STATE,
- output1, sizeof( output1 ) ) );
- PSA_DONE( );
+ PSA_ASSERT(psa_crypto_init());
+ TEST_EQUAL(0, mbedtls_psa_get_random(MBEDTLS_PSA_RANDOM_STATE,
+ output1, sizeof(output1)));
+ PSA_DONE();
/* Second round */
- PSA_ASSERT( psa_crypto_init( ) );
- TEST_EQUAL( 0, mbedtls_psa_get_random( MBEDTLS_PSA_RANDOM_STATE,
- output2, sizeof( output2 ) ) );
- PSA_DONE( );
+ PSA_ASSERT(psa_crypto_init());
+ TEST_EQUAL(0, mbedtls_psa_get_random(MBEDTLS_PSA_RANDOM_STATE,
+ output2, sizeof(output2)));
+ PSA_DONE();
/* The two rounds must generate different random data. */
- TEST_ASSERT( memcmp( output1, output2, OUTPUT_SIZE ) != 0 );
+ TEST_ASSERT(memcmp(output1, output2, OUTPUT_SIZE) != 0);
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_C:!MBEDTLS_TEST_NULL_ENTROPY:!MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */
-void random_twice_with_psa_from_psa( )
+void random_twice_with_psa_from_psa()
{
unsigned char output1[OUTPUT_SIZE];
unsigned char output2[OUTPUT_SIZE];
/* First round */
- PSA_ASSERT( psa_crypto_init( ) );
- PSA_ASSERT( psa_generate_random( output1, sizeof( output1 ) ) );
- PSA_DONE( );
+ PSA_ASSERT(psa_crypto_init());
+ PSA_ASSERT(psa_generate_random(output1, sizeof(output1)));
+ PSA_DONE();
/* Second round */
- PSA_ASSERT( psa_crypto_init( ) );
- PSA_ASSERT( psa_generate_random( output2, sizeof( output2 ) ) );
- PSA_DONE( );
+ PSA_ASSERT(psa_crypto_init());
+ PSA_ASSERT(psa_generate_random(output2, sizeof(output2)));
+ PSA_DONE();
/* The two rounds must generate different random data. */
- TEST_ASSERT( memcmp( output1, output2, OUTPUT_SIZE ) != 0 );
+ TEST_ASSERT(memcmp(output1, output2, OUTPUT_SIZE) != 0);
exit:
- PSA_DONE( );
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_C */
-void mbedtls_psa_get_random_no_init( )
+void mbedtls_psa_get_random_no_init()
{
unsigned char output[1];
- TEST_ASSERT( mbedtls_psa_get_random( MBEDTLS_PSA_RANDOM_STATE,
- output, sizeof( output ) ) != 0 );
+ TEST_ASSERT(mbedtls_psa_get_random(MBEDTLS_PSA_RANDOM_STATE,
+ output, sizeof(output)) != 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_C */
-void mbedtls_psa_get_random_length( int n )
+void mbedtls_psa_get_random_length(int n)
{
unsigned char *output = NULL;
- PSA_ASSERT( psa_crypto_init( ) );
- ASSERT_ALLOC( output, n );
+ PSA_ASSERT(psa_crypto_init());
+ ASSERT_ALLOC(output, n);
- TEST_EQUAL( 0, mbedtls_psa_get_random( MBEDTLS_PSA_RANDOM_STATE,
- output, n ) );
+ TEST_EQUAL(0, mbedtls_psa_get_random(MBEDTLS_PSA_RANDOM_STATE,
+ output, n));
exit:
- mbedtls_free( output );
- PSA_DONE( );
+ mbedtls_free(output);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_C:MBEDTLS_ECDSA_C */
-void mbedtls_psa_get_random_ecdsa_sign( int curve )
+void mbedtls_psa_get_random_ecdsa_sign(int curve)
{
mbedtls_ecp_group grp;
mbedtls_mpi d, r, s;
unsigned char buf[] = "This is not a hash.";
- mbedtls_ecp_group_init( &grp );
- mbedtls_mpi_init( &d );
- mbedtls_mpi_init( &r );
- mbedtls_mpi_init( &s );
+ mbedtls_ecp_group_init(&grp);
+ mbedtls_mpi_init(&d);
+ mbedtls_mpi_init(&r);
+ mbedtls_mpi_init(&s);
- TEST_EQUAL( 0, mbedtls_mpi_lset( &d, 123456789 ) );
- TEST_EQUAL( 0, mbedtls_ecp_group_load( &grp, curve ) );
- PSA_ASSERT( psa_crypto_init( ) );
- TEST_EQUAL( 0, mbedtls_ecdsa_sign( &grp, &r, &s, &d,
- buf, sizeof( buf ),
- mbedtls_psa_get_random,
- MBEDTLS_PSA_RANDOM_STATE ) );
+ TEST_EQUAL(0, mbedtls_mpi_lset(&d, 123456789));
+ TEST_EQUAL(0, mbedtls_ecp_group_load(&grp, curve));
+ PSA_ASSERT(psa_crypto_init());
+ TEST_EQUAL(0, mbedtls_ecdsa_sign(&grp, &r, &s, &d,
+ buf, sizeof(buf),
+ mbedtls_psa_get_random,
+ MBEDTLS_PSA_RANDOM_STATE));
exit:
- mbedtls_mpi_free( &d );
- mbedtls_mpi_free( &r );
- mbedtls_mpi_free( &s );
- mbedtls_ecp_group_free( &grp );
- PSA_DONE( );
+ mbedtls_mpi_free(&d);
+ mbedtls_mpi_free(&r);
+ mbedtls_mpi_free(&s);
+ mbedtls_ecp_group_free(&grp);
+ PSA_DONE();
}
/* END_CASE */
diff --git a/tests/suites/test_suite_rsa.function b/tests/suites/test_suite_rsa.function
index 3c0e35f..fa7fa95 100644
--- a/tests/suites/test_suite_rsa.function
+++ b/tests/suites/test_suite_rsa.function
@@ -18,7 +18,7 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void rsa_invalid_param( )
+void rsa_invalid_param()
{
mbedtls_rsa_context ctx;
const int valid_padding = MBEDTLS_RSA_PKCS_V21;
@@ -28,460 +28,460 @@
unsigned char buf[42] = { 0 };
size_t olen;
- TEST_INVALID_PARAM( mbedtls_rsa_init( NULL, valid_padding, 0 ) );
- TEST_INVALID_PARAM( mbedtls_rsa_init( &ctx, invalid_padding, 0 ) );
- TEST_VALID_PARAM( mbedtls_rsa_free( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_rsa_init(NULL, valid_padding, 0));
+ TEST_INVALID_PARAM(mbedtls_rsa_init(&ctx, invalid_padding, 0));
+ TEST_VALID_PARAM(mbedtls_rsa_free(NULL));
/* No more variants because only the first argument must be non-NULL. */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_import( NULL, NULL, NULL,
- NULL, NULL, NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_import_raw( NULL,
- NULL, 0,
- NULL, 0,
- NULL, 0,
- NULL, 0,
- NULL, 0 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_import(NULL, NULL, NULL,
+ NULL, NULL, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_import_raw(NULL,
+ NULL, 0,
+ NULL, 0,
+ NULL, 0,
+ NULL, 0,
+ NULL, 0));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_complete( NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_complete(NULL));
/* No more variants because only the first argument must be non-NULL. */
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_export( NULL, NULL, NULL,
- NULL, NULL, NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_export_raw( NULL,
- NULL, 0,
- NULL, 0,
- NULL, 0,
- NULL, 0,
- NULL, 0 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_export_crt( NULL, NULL, NULL, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_export(NULL, NULL, NULL,
+ NULL, NULL, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_export_raw(NULL,
+ NULL, 0,
+ NULL, 0,
+ NULL, 0,
+ NULL, 0,
+ NULL, 0));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_export_crt(NULL, NULL, NULL, NULL));
- TEST_INVALID_PARAM( mbedtls_rsa_set_padding( NULL,
- valid_padding, 0 ) );
- TEST_INVALID_PARAM( mbedtls_rsa_set_padding( &ctx,
- invalid_padding, 0 ) );
+ TEST_INVALID_PARAM(mbedtls_rsa_set_padding(NULL,
+ valid_padding, 0));
+ TEST_INVALID_PARAM(mbedtls_rsa_set_padding(&ctx,
+ invalid_padding, 0));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_gen_key( NULL,
- mbedtls_test_rnd_std_rand,
- NULL, 0, 0 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_gen_key( &ctx, NULL,
- NULL, 0, 0 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_gen_key(NULL,
+ mbedtls_test_rnd_std_rand,
+ NULL, 0, 0));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_gen_key(&ctx, NULL,
+ NULL, 0, 0));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_check_pubkey( NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_check_privkey( NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_check_pubkey(NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_check_privkey(NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_check_pub_priv( NULL, &ctx ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_check_pub_priv( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_check_pub_priv(NULL, &ctx));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_check_pub_priv(&ctx, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_public( NULL, buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_public( &ctx, NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_public( &ctx, buf, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_public(NULL, buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_public(&ctx, NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_public(&ctx, buf, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_private( NULL, NULL, NULL,
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_private( &ctx, NULL, NULL,
- NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_private( &ctx, NULL, NULL,
- buf, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_private(NULL, NULL, NULL,
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_private(&ctx, NULL, NULL,
+ NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_private(&ctx, NULL, NULL,
+ buf, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_encrypt( NULL, NULL, NULL,
- valid_mode,
- sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_encrypt( &ctx, NULL, NULL,
- invalid_mode,
- sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_encrypt( &ctx, NULL, NULL,
- valid_mode,
- sizeof( buf ), NULL,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_encrypt( &ctx, NULL, NULL,
- valid_mode,
- sizeof( buf ), buf,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_encrypt(NULL, NULL, NULL,
+ valid_mode,
+ sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_encrypt(&ctx, NULL, NULL,
+ invalid_mode,
+ sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_encrypt(&ctx, NULL, NULL,
+ valid_mode,
+ sizeof(buf), NULL,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_encrypt(&ctx, NULL, NULL,
+ valid_mode,
+ sizeof(buf), buf,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_pkcs1_v15_encrypt( NULL, NULL,
- NULL,
- valid_mode,
- sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_pkcs1_v15_encrypt( &ctx, NULL,
- NULL,
- invalid_mode,
- sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_pkcs1_v15_encrypt( &ctx, NULL,
- NULL,
- valid_mode,
- sizeof( buf ), NULL,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_pkcs1_v15_encrypt( &ctx, NULL,
- NULL,
- valid_mode,
- sizeof( buf ), buf,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_pkcs1_v15_encrypt(NULL, NULL,
+ NULL,
+ valid_mode,
+ sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_pkcs1_v15_encrypt(&ctx, NULL,
+ NULL,
+ invalid_mode,
+ sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_pkcs1_v15_encrypt(&ctx, NULL,
+ NULL,
+ valid_mode,
+ sizeof(buf), NULL,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_pkcs1_v15_encrypt(&ctx, NULL,
+ NULL,
+ valid_mode,
+ sizeof(buf), buf,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_oaep_encrypt( NULL, NULL, NULL,
- valid_mode,
- buf, sizeof( buf ),
- sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
- invalid_mode,
- buf, sizeof( buf ),
- sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
- valid_mode,
- NULL, sizeof( buf ),
- sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
- valid_mode,
- buf, sizeof( buf ),
- sizeof( buf ), NULL,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_oaep_encrypt( &ctx, NULL, NULL,
- valid_mode,
- buf, sizeof( buf ),
- sizeof( buf ), buf,
- NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_oaep_encrypt(NULL, NULL, NULL,
+ valid_mode,
+ buf, sizeof(buf),
+ sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_oaep_encrypt(&ctx, NULL, NULL,
+ invalid_mode,
+ buf, sizeof(buf),
+ sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_oaep_encrypt(&ctx, NULL, NULL,
+ valid_mode,
+ NULL, sizeof(buf),
+ sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_oaep_encrypt(&ctx, NULL, NULL,
+ valid_mode,
+ buf, sizeof(buf),
+ sizeof(buf), NULL,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_oaep_encrypt(&ctx, NULL, NULL,
+ valid_mode,
+ buf, sizeof(buf),
+ sizeof(buf), buf,
+ NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_decrypt( NULL, NULL, NULL,
- valid_mode, &olen,
- buf, buf, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
- invalid_mode, &olen,
- buf, buf, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
- valid_mode, NULL,
- buf, buf, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
- valid_mode, &olen,
- NULL, buf, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_decrypt( &ctx, NULL, NULL,
- valid_mode, &olen,
- buf, NULL, 42 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_decrypt(NULL, NULL, NULL,
+ valid_mode, &olen,
+ buf, buf, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_decrypt(&ctx, NULL, NULL,
+ invalid_mode, &olen,
+ buf, buf, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_decrypt(&ctx, NULL, NULL,
+ valid_mode, NULL,
+ buf, buf, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_decrypt(&ctx, NULL, NULL,
+ valid_mode, &olen,
+ NULL, buf, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_decrypt(&ctx, NULL, NULL,
+ valid_mode, &olen,
+ buf, NULL, 42));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_pkcs1_v15_decrypt( NULL, NULL,
- NULL,
- valid_mode, &olen,
- buf, buf, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
- NULL,
- invalid_mode, &olen,
- buf, buf, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
- NULL,
- valid_mode, NULL,
- buf, buf, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
- NULL,
- valid_mode, &olen,
- NULL, buf, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx, NULL,
- NULL,
- valid_mode, &olen,
- buf, NULL, 42 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_pkcs1_v15_decrypt(NULL, NULL,
+ NULL,
+ valid_mode, &olen,
+ buf, buf, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_pkcs1_v15_decrypt(&ctx, NULL,
+ NULL,
+ invalid_mode, &olen,
+ buf, buf, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_pkcs1_v15_decrypt(&ctx, NULL,
+ NULL,
+ valid_mode, NULL,
+ buf, buf, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_pkcs1_v15_decrypt(&ctx, NULL,
+ NULL,
+ valid_mode, &olen,
+ NULL, buf, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_pkcs1_v15_decrypt(&ctx, NULL,
+ NULL,
+ valid_mode, &olen,
+ buf, NULL, 42));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_oaep_decrypt( NULL, NULL, NULL,
- valid_mode,
- buf, sizeof( buf ),
- &olen,
- buf, buf, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
- invalid_mode,
- buf, sizeof( buf ),
- &olen,
- buf, buf, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
- valid_mode,
- NULL, sizeof( buf ),
- NULL,
- buf, buf, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
- valid_mode,
- buf, sizeof( buf ),
- &olen,
- NULL, buf, 42 ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsaes_oaep_decrypt( &ctx, NULL, NULL,
- valid_mode,
- buf, sizeof( buf ),
- &olen,
- buf, NULL, 42 ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_oaep_decrypt(NULL, NULL, NULL,
+ valid_mode,
+ buf, sizeof(buf),
+ &olen,
+ buf, buf, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_oaep_decrypt(&ctx, NULL, NULL,
+ invalid_mode,
+ buf, sizeof(buf),
+ &olen,
+ buf, buf, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_oaep_decrypt(&ctx, NULL, NULL,
+ valid_mode,
+ NULL, sizeof(buf),
+ NULL,
+ buf, buf, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_oaep_decrypt(&ctx, NULL, NULL,
+ valid_mode,
+ buf, sizeof(buf),
+ &olen,
+ NULL, buf, 42));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsaes_oaep_decrypt(&ctx, NULL, NULL,
+ valid_mode,
+ buf, sizeof(buf),
+ &olen,
+ buf, NULL, 42));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_sign( NULL, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
- invalid_mode,
- 0, sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ), NULL,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ), buf,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_sign( &ctx, NULL, NULL,
- valid_mode,
- MBEDTLS_MD_SHA1,
- 0, NULL,
- buf ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_sign(NULL, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_sign(&ctx, NULL, NULL,
+ invalid_mode,
+ 0, sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_sign(&ctx, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf), NULL,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_sign(&ctx, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf), buf,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_sign(&ctx, NULL, NULL,
+ valid_mode,
+ MBEDTLS_MD_SHA1,
+ 0, NULL,
+ buf));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pkcs1_v15_sign( NULL, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
- invalid_mode,
- 0, sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ), NULL,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ), buf,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pkcs1_v15_sign( &ctx, NULL, NULL,
- valid_mode,
- MBEDTLS_MD_SHA1,
- 0, NULL,
- buf ) );
-
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_sign( NULL, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
- invalid_mode,
- 0, sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ), NULL,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ), buf,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_sign( &ctx, NULL, NULL,
- valid_mode,
- MBEDTLS_MD_SHA1,
- 0, NULL,
- buf ) );
-
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_sign_ext( NULL, NULL, NULL,
- 0, sizeof( buf ), buf,
- MBEDTLS_RSA_SALT_LEN_ANY,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_sign_ext( &ctx, NULL, NULL,
- 0, sizeof( buf ), NULL,
- MBEDTLS_RSA_SALT_LEN_ANY,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_sign_ext( &ctx, NULL, NULL,
- 0, sizeof( buf ), buf,
- MBEDTLS_RSA_SALT_LEN_ANY,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_sign_ext( &ctx, NULL, NULL,
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pkcs1_v15_sign(NULL, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pkcs1_v15_sign(&ctx, NULL, NULL,
+ invalid_mode,
+ 0, sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pkcs1_v15_sign(&ctx, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf), NULL,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pkcs1_v15_sign(&ctx, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf), buf,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pkcs1_v15_sign(&ctx, NULL, NULL,
+ valid_mode,
MBEDTLS_MD_SHA1,
0, NULL,
- MBEDTLS_RSA_SALT_LEN_ANY,
- buf ) );
+ buf));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_verify( NULL, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
- invalid_mode,
- 0, sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ), NULL,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ), buf,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL,
- valid_mode,
- MBEDTLS_MD_SHA1, 0, NULL,
- buf ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_sign(NULL, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_sign(&ctx, NULL, NULL,
+ invalid_mode,
+ 0, sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_sign(&ctx, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf), NULL,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_sign(&ctx, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf), buf,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_sign(&ctx, NULL, NULL,
+ valid_mode,
+ MBEDTLS_MD_SHA1,
+ 0, NULL,
+ buf));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pkcs1_v15_verify( NULL, NULL,
- NULL,
- valid_mode,
- 0, sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
- NULL,
- invalid_mode,
- 0, sizeof( buf ), buf,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
- NULL,
- valid_mode,
- 0, sizeof( buf ),
- NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
- NULL,
- valid_mode,
- 0, sizeof( buf ), buf,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pkcs1_v15_verify( &ctx, NULL,
- NULL,
- valid_mode,
- MBEDTLS_MD_SHA1,
- 0, NULL,
- buf ) );
-
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_verify( NULL, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ),
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
- invalid_mode,
- 0, sizeof( buf ),
- buf, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ),
- NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
- valid_mode,
- 0, sizeof( buf ),
- buf, NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_verify( &ctx, NULL, NULL,
- valid_mode,
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_sign_ext(NULL, NULL, NULL,
+ 0, sizeof(buf), buf,
+ MBEDTLS_RSA_SALT_LEN_ANY,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_sign_ext(&ctx, NULL, NULL,
+ 0, sizeof(buf), NULL,
+ MBEDTLS_RSA_SALT_LEN_ANY,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_sign_ext(&ctx, NULL, NULL,
+ 0, sizeof(buf), buf,
+ MBEDTLS_RSA_SALT_LEN_ANY,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_sign_ext(&ctx, NULL, NULL,
MBEDTLS_MD_SHA1,
0, NULL,
- buf ) );
+ MBEDTLS_RSA_SALT_LEN_ANY,
+ buf));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_verify_ext( NULL, NULL, NULL,
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_verify(NULL, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL,
+ invalid_mode,
+ 0, sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf), NULL,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf), buf,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL,
+ valid_mode,
+ MBEDTLS_MD_SHA1, 0, NULL,
+ buf));
+
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pkcs1_v15_verify(NULL, NULL,
+ NULL,
valid_mode,
- 0, sizeof( buf ),
- buf,
- 0, 0,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
+ 0, sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pkcs1_v15_verify(&ctx, NULL,
+ NULL,
invalid_mode,
- 0, sizeof( buf ),
- buf,
- 0, 0,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
+ 0, sizeof(buf), buf,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pkcs1_v15_verify(&ctx, NULL,
+ NULL,
valid_mode,
- 0, sizeof( buf ),
- NULL, 0, 0,
- buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
+ 0, sizeof(buf),
+ NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pkcs1_v15_verify(&ctx, NULL,
+ NULL,
valid_mode,
- 0, sizeof( buf ),
- buf, 0, 0,
- NULL ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_rsassa_pss_verify_ext( &ctx, NULL, NULL,
+ 0, sizeof(buf), buf,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pkcs1_v15_verify(&ctx, NULL,
+ NULL,
valid_mode,
MBEDTLS_MD_SHA1,
0, NULL,
- 0, 0,
- buf ) );
+ buf));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_copy( NULL, &ctx ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
- mbedtls_rsa_copy( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_verify(NULL, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf),
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_verify(&ctx, NULL, NULL,
+ invalid_mode,
+ 0, sizeof(buf),
+ buf, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_verify(&ctx, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf),
+ NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_verify(&ctx, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf),
+ buf, NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_verify(&ctx, NULL, NULL,
+ valid_mode,
+ MBEDTLS_MD_SHA1,
+ 0, NULL,
+ buf));
+
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_verify_ext(NULL, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf),
+ buf,
+ 0, 0,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_verify_ext(&ctx, NULL, NULL,
+ invalid_mode,
+ 0, sizeof(buf),
+ buf,
+ 0, 0,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_verify_ext(&ctx, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf),
+ NULL, 0, 0,
+ buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_verify_ext(&ctx, NULL, NULL,
+ valid_mode,
+ 0, sizeof(buf),
+ buf, 0, 0,
+ NULL));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_rsassa_pss_verify_ext(&ctx, NULL, NULL,
+ valid_mode,
+ MBEDTLS_MD_SHA1,
+ 0, NULL,
+ 0, 0,
+ buf));
+
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_copy(NULL, &ctx));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_RSA_BAD_INPUT_DATA,
+ mbedtls_rsa_copy(&ctx, NULL));
exit:
return;
@@ -489,7 +489,7 @@
/* END_CASE */
/* BEGIN_CASE */
-void rsa_init_free( int reinit )
+void rsa_init_free(int reinit)
{
mbedtls_rsa_context ctx;
@@ -498,12 +498,13 @@
* unconditionally on an error path without checking whether it has
* already been called in the success path. */
- mbedtls_rsa_init( &ctx, 0, 0 );
- mbedtls_rsa_free( &ctx );
+ mbedtls_rsa_init(&ctx, 0, 0);
+ mbedtls_rsa_free(&ctx);
- if( reinit )
- mbedtls_rsa_init( &ctx, 0, 0 );
- mbedtls_rsa_free( &ctx );
+ if (reinit) {
+ mbedtls_rsa_init(&ctx, 0, 0);
+ }
+ mbedtls_rsa_free(&ctx);
/* This test case always succeeds, functionally speaking. A plausible
* bug might trigger an invalid pointer dereference or a memory leak. */
@@ -512,10 +513,10 @@
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_rsa_pkcs1_sign( data_t * message_str, int padding_mode,
- int digest, int mod, char * input_P,
- char * input_Q, char * input_N, char * input_E,
- data_t * result_str, int result )
+void mbedtls_rsa_pkcs1_sign(data_t *message_str, int padding_mode,
+ int digest, int mod, char *input_P,
+ char *input_Q, char *input_N, char *input_E,
+ data_t *result_str, int result)
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
unsigned char output[256];
@@ -523,303 +524,304 @@
mbedtls_mpi N, P, Q, E;
mbedtls_test_rnd_pseudo_info rnd_info;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
- mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
- mbedtls_rsa_init( &ctx, padding_mode, 0 );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
+ mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
+ mbedtls_rsa_init(&ctx, padding_mode, 0);
- memset( hash_result, 0x00, sizeof( hash_result ) );
- memset( output, 0x00, sizeof( output ) );
- memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ memset(hash_result, 0x00, sizeof(hash_result));
+ memset(output, 0x00, sizeof(output));
+ memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
- TEST_ASSERT( mbedtls_test_read_mpi( &P, input_P ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Q, input_Q ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
- TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
- TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, &P, &Q, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
+ TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
+ TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == 0);
- if( mbedtls_md_info_from_type( digest ) != NULL )
- TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
+ if (mbedtls_md_info_from_type(digest) != NULL) {
+ TEST_ASSERT(mbedtls_md(mbedtls_md_info_from_type(digest), message_str->x, message_str->len,
+ hash_result) == 0);
+ }
- TEST_ASSERT( mbedtls_rsa_pkcs1_sign( &ctx, &mbedtls_test_rnd_pseudo_rand,
- &rnd_info, MBEDTLS_RSA_PRIVATE, digest,
- 0, hash_result, output ) == result );
- if( result == 0 )
- {
+ TEST_ASSERT(mbedtls_rsa_pkcs1_sign(&ctx, &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info, MBEDTLS_RSA_PRIVATE, digest,
+ 0, hash_result, output) == result);
+ if (result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
- ctx.len, result_str->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
+ ctx.len, result_str->len) == 0);
}
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
- mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
+ mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_rsa_pkcs1_verify( data_t * message_str, int padding_mode,
- int digest, int mod,
- char * input_N, char * input_E,
- data_t * result_str, int result )
+void mbedtls_rsa_pkcs1_verify(data_t *message_str, int padding_mode,
+ int digest, int mod,
+ char *input_N, char *input_E,
+ data_t *result_str, int result)
{
unsigned char hash_result[MBEDTLS_MD_MAX_SIZE];
mbedtls_rsa_context ctx;
mbedtls_mpi N, E;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
- mbedtls_rsa_init( &ctx, padding_mode, 0 );
- memset( hash_result, 0x00, sizeof( hash_result ) );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
+ mbedtls_rsa_init(&ctx, padding_mode, 0);
+ memset(hash_result, 0x00, sizeof(hash_result));
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
- TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
- if( mbedtls_md_info_from_type( digest ) != NULL )
- TEST_ASSERT( mbedtls_md( mbedtls_md_info_from_type( digest ), message_str->x, message_str->len, hash_result ) == 0 );
+ if (mbedtls_md_info_from_type(digest) != NULL) {
+ TEST_ASSERT(mbedtls_md(mbedtls_md_info_from_type(digest), message_str->x, message_str->len,
+ hash_result) == 0);
+ }
- TEST_ASSERT( mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC, digest, 0, hash_result, result_str->x ) == result );
+ TEST_ASSERT(mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC, digest, 0,
+ hash_result, result_str->x) == result);
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void rsa_pkcs1_sign_raw( data_t * hash_result,
- int padding_mode, int mod,
- char * input_P, char * input_Q,
- char * input_N, char * input_E,
- data_t * result_str )
+void rsa_pkcs1_sign_raw(data_t *hash_result,
+ int padding_mode, int mod,
+ char *input_P, char *input_Q,
+ char *input_N, char *input_E,
+ data_t *result_str)
{
unsigned char output[256];
mbedtls_rsa_context ctx;
mbedtls_mpi N, P, Q, E;
mbedtls_test_rnd_pseudo_info rnd_info;
- mbedtls_rsa_init( &ctx, padding_mode, 0 );
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
- mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
+ mbedtls_rsa_init(&ctx, padding_mode, 0);
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
+ mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
- memset( output, 0x00, sizeof( output ) );
- memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ memset(output, 0x00, sizeof(output));
+ memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
- TEST_ASSERT( mbedtls_test_read_mpi( &P, input_P ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Q, input_Q ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
- TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
- TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, &P, &Q, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
+ TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
+ TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == 0);
- TEST_ASSERT( mbedtls_rsa_pkcs1_sign( &ctx, &mbedtls_test_rnd_pseudo_rand,
- &rnd_info, MBEDTLS_RSA_PRIVATE,
- MBEDTLS_MD_NONE, hash_result->len,
- hash_result->x, output ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_pkcs1_sign(&ctx, &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info, MBEDTLS_RSA_PRIVATE,
+ MBEDTLS_MD_NONE, hash_result->len,
+ hash_result->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
- ctx.len, result_str->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
+ ctx.len, result_str->len) == 0);
#if defined(MBEDTLS_PKCS1_V15)
/* For PKCS#1 v1.5, there is an alternative way to generate signatures */
- if( padding_mode == MBEDTLS_RSA_PKCS_V15 )
- {
+ if (padding_mode == MBEDTLS_RSA_PKCS_V15) {
int res;
- memset( output, 0x00, sizeof( output) );
+ memset(output, 0x00, sizeof(output));
- res = mbedtls_rsa_rsaes_pkcs1_v15_encrypt( &ctx,
- &mbedtls_test_rnd_pseudo_rand, &rnd_info,
- MBEDTLS_RSA_PRIVATE, hash_result->len,
- hash_result->x, output );
+ res = mbedtls_rsa_rsaes_pkcs1_v15_encrypt(&ctx,
+ &mbedtls_test_rnd_pseudo_rand, &rnd_info,
+ MBEDTLS_RSA_PRIVATE, hash_result->len,
+ hash_result->x, output);
#if !defined(MBEDTLS_RSA_ALT)
- TEST_ASSERT( res == 0 );
+ TEST_ASSERT(res == 0);
#else
- TEST_ASSERT( ( res == 0 ) ||
- ( res == MBEDTLS_ERR_RSA_UNSUPPORTED_OPERATION ) );
+ TEST_ASSERT((res == 0) ||
+ (res == MBEDTLS_ERR_RSA_UNSUPPORTED_OPERATION));
#endif
- if( res == 0 )
- {
- TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
- ctx.len,
- result_str->len ) == 0 );
+ if (res == 0) {
+ TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
+ ctx.len,
+ result_str->len) == 0);
}
}
#endif /* MBEDTLS_PKCS1_V15 */
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
- mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
+ mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
- mbedtls_rsa_free( &ctx );
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void rsa_pkcs1_verify_raw( data_t * hash_result,
- int padding_mode, int mod,
- char * input_N, char * input_E,
- data_t * result_str, int correct )
+void rsa_pkcs1_verify_raw(data_t *hash_result,
+ int padding_mode, int mod,
+ char *input_N, char *input_E,
+ data_t *result_str, int correct)
{
unsigned char output[256];
mbedtls_rsa_context ctx;
mbedtls_mpi N, E;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
- mbedtls_rsa_init( &ctx, padding_mode, 0 );
- memset( output, 0x00, sizeof( output ) );
+ mbedtls_rsa_init(&ctx, padding_mode, 0);
+ memset(output, 0x00, sizeof(output));
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
- TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
- TEST_ASSERT( mbedtls_rsa_pkcs1_verify( &ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC, MBEDTLS_MD_NONE, hash_result->len, hash_result->x, result_str->x ) == correct );
+ TEST_ASSERT(mbedtls_rsa_pkcs1_verify(&ctx, NULL, NULL, MBEDTLS_RSA_PUBLIC, MBEDTLS_MD_NONE,
+ hash_result->len, hash_result->x,
+ result_str->x) == correct);
#if defined(MBEDTLS_PKCS1_V15)
/* For PKCS#1 v1.5, there is an alternative way to verify signatures */
- if( padding_mode == MBEDTLS_RSA_PKCS_V15 )
- {
+ if (padding_mode == MBEDTLS_RSA_PKCS_V15) {
int res;
int ok;
size_t olen;
- res = mbedtls_rsa_rsaes_pkcs1_v15_decrypt( &ctx,
- NULL, NULL, MBEDTLS_RSA_PUBLIC,
- &olen, result_str->x, output, sizeof( output ) );
+ res = mbedtls_rsa_rsaes_pkcs1_v15_decrypt(&ctx,
+ NULL, NULL, MBEDTLS_RSA_PUBLIC,
+ &olen, result_str->x, output, sizeof(output));
#if !defined(MBEDTLS_RSA_ALT)
- TEST_ASSERT( res == 0 );
+ TEST_ASSERT(res == 0);
#else
- TEST_ASSERT( ( res == 0 ) ||
- ( res == MBEDTLS_ERR_RSA_UNSUPPORTED_OPERATION ) );
+ TEST_ASSERT((res == 0) ||
+ (res == MBEDTLS_ERR_RSA_UNSUPPORTED_OPERATION));
#endif
- if( res == 0 )
- {
- ok = olen == hash_result->len && memcmp( output, hash_result->x, olen ) == 0;
- if( correct == 0 )
- TEST_ASSERT( ok == 1 );
- else
- TEST_ASSERT( ok == 0 );
+ if (res == 0) {
+ ok = olen == hash_result->len && memcmp(output, hash_result->x, olen) == 0;
+ if (correct == 0) {
+ TEST_ASSERT(ok == 1);
+ } else {
+ TEST_ASSERT(ok == 0);
+ }
}
}
#endif /* MBEDTLS_PKCS1_V15 */
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_rsa_pkcs1_encrypt( data_t * message_str, int padding_mode,
- int mod, char * input_N, char * input_E,
- data_t * result_str, int result )
+void mbedtls_rsa_pkcs1_encrypt(data_t *message_str, int padding_mode,
+ int mod, char *input_N, char *input_E,
+ data_t *result_str, int result)
{
unsigned char output[256];
mbedtls_rsa_context ctx;
mbedtls_test_rnd_pseudo_info rnd_info;
mbedtls_mpi N, E;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
- memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
- mbedtls_rsa_init( &ctx, padding_mode, 0 );
- memset( output, 0x00, sizeof( output ) );
+ mbedtls_rsa_init(&ctx, padding_mode, 0);
+ memset(output, 0x00, sizeof(output));
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
- TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
- TEST_ASSERT( mbedtls_rsa_pkcs1_encrypt( &ctx,
- &mbedtls_test_rnd_pseudo_rand,
- &rnd_info, MBEDTLS_RSA_PUBLIC,
- message_str->len, message_str->x,
- output ) == result );
- if( result == 0 )
- {
+ TEST_ASSERT(mbedtls_rsa_pkcs1_encrypt(&ctx,
+ &mbedtls_test_rnd_pseudo_rand,
+ &rnd_info, MBEDTLS_RSA_PUBLIC,
+ message_str->len, message_str->x,
+ output) == result);
+ if (result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
- ctx.len, result_str->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
+ ctx.len, result_str->len) == 0);
}
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void rsa_pkcs1_encrypt_bad_rng( data_t * message_str, int padding_mode,
- int mod, char * input_N, char * input_E,
- data_t * result_str, int result )
+void rsa_pkcs1_encrypt_bad_rng(data_t *message_str, int padding_mode,
+ int mod, char *input_N, char *input_E,
+ data_t *result_str, int result)
{
unsigned char output[256];
mbedtls_rsa_context ctx;
mbedtls_mpi N, E;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
- mbedtls_rsa_init( &ctx, padding_mode, 0 );
- memset( output, 0x00, sizeof( output ) );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
+ mbedtls_rsa_init(&ctx, padding_mode, 0);
+ memset(output, 0x00, sizeof(output));
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
- TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
- TEST_ASSERT( mbedtls_rsa_pkcs1_encrypt( &ctx, &mbedtls_test_rnd_zero_rand,
- NULL, MBEDTLS_RSA_PUBLIC,
- message_str->len, message_str->x,
- output ) == result );
- if( result == 0 )
- {
+ TEST_ASSERT(mbedtls_rsa_pkcs1_encrypt(&ctx, &mbedtls_test_rnd_zero_rand,
+ NULL, MBEDTLS_RSA_PUBLIC,
+ message_str->len, message_str->x,
+ output) == result);
+ if (result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
- ctx.len, result_str->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
+ ctx.len, result_str->len) == 0);
}
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_rsa_pkcs1_decrypt( data_t * message_str, int padding_mode,
- int mod, char * input_P,
- char * input_Q, char * input_N,
- char * input_E, int max_output,
- data_t * result_str, int result )
+void mbedtls_rsa_pkcs1_decrypt(data_t *message_str, int padding_mode,
+ int mod, char *input_P,
+ char *input_Q, char *input_N,
+ char *input_E, int max_output,
+ data_t *result_str, int result)
{
unsigned char output[32];
mbedtls_rsa_context ctx;
@@ -827,107 +829,104 @@
mbedtls_test_rnd_pseudo_info rnd_info;
mbedtls_mpi N, P, Q, E;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
- mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
+ mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
- mbedtls_rsa_init( &ctx, padding_mode, 0 );
+ mbedtls_rsa_init(&ctx, padding_mode, 0);
- memset( output, 0x00, sizeof( output ) );
- memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ memset(output, 0x00, sizeof(output));
+ memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
- TEST_ASSERT( mbedtls_test_read_mpi( &P, input_P ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Q, input_Q ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
- TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
- TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, &P, &Q, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
+ TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
+ TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == 0);
output_len = 0;
- TEST_ASSERT( mbedtls_rsa_pkcs1_decrypt( &ctx, mbedtls_test_rnd_pseudo_rand,
- &rnd_info, MBEDTLS_RSA_PRIVATE,
- &output_len, message_str->x, output,
- max_output ) == result );
- if( result == 0 )
- {
+ TEST_ASSERT(mbedtls_rsa_pkcs1_decrypt(&ctx, mbedtls_test_rnd_pseudo_rand,
+ &rnd_info, MBEDTLS_RSA_PRIVATE,
+ &output_len, message_str->x, output,
+ max_output) == result);
+ if (result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
- output_len,
- result_str->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
+ output_len,
+ result_str->len) == 0);
}
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
- mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
+ mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_rsa_public( data_t * message_str, int mod,
- char * input_N, char * input_E,
- data_t * result_str, int result )
+void mbedtls_rsa_public(data_t *message_str, int mod,
+ char *input_N, char *input_E,
+ data_t *result_str, int result)
{
unsigned char output[256];
mbedtls_rsa_context ctx, ctx2; /* Also test mbedtls_rsa_copy() while at it */
mbedtls_mpi N, E;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
- mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, 0 );
- mbedtls_rsa_init( &ctx2, MBEDTLS_RSA_PKCS_V15, 0 );
- memset( output, 0x00, sizeof( output ) );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
+ mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V15, 0);
+ mbedtls_rsa_init(&ctx2, MBEDTLS_RSA_PKCS_V15, 0);
+ memset(output, 0x00, sizeof(output));
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
/* Check test data consistency */
- TEST_ASSERT( message_str->len == (size_t) ( mod / 8 ) );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
- TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == 0 );
+ TEST_ASSERT(message_str->len == (size_t) (mod / 8));
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == 0);
- TEST_ASSERT( mbedtls_rsa_public( &ctx, message_str->x, output ) == result );
- if( result == 0 )
- {
+ TEST_ASSERT(mbedtls_rsa_public(&ctx, message_str->x, output) == result);
+ if (result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
- ctx.len, result_str->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
+ ctx.len, result_str->len) == 0);
}
/* And now with the copy */
- TEST_ASSERT( mbedtls_rsa_copy( &ctx2, &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_copy(&ctx2, &ctx) == 0);
/* clear the original to be sure */
- mbedtls_rsa_free( &ctx );
+ mbedtls_rsa_free(&ctx);
- TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx2 ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx2) == 0);
- memset( output, 0x00, sizeof( output ) );
- TEST_ASSERT( mbedtls_rsa_public( &ctx2, message_str->x, output ) == result );
- if( result == 0 )
- {
+ memset(output, 0x00, sizeof(output));
+ TEST_ASSERT(mbedtls_rsa_public(&ctx2, message_str->x, output) == result);
+ if (result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
- ctx.len, result_str->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
+ ctx.len, result_str->len) == 0);
}
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
- mbedtls_rsa_free( &ctx2 );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
+ mbedtls_rsa_free(&ctx2);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_rsa_private( data_t * message_str, int mod,
- char * input_P, char * input_Q,
- char * input_N, char * input_E,
- data_t * result_str, int result )
+void mbedtls_rsa_private(data_t *message_str, int mod,
+ char *input_P, char *input_Q,
+ char *input_N, char *input_E,
+ data_t *result_str, int result)
{
unsigned char output[256];
mbedtls_rsa_context ctx, ctx2; /* Also test mbedtls_rsa_copy() while at it */
@@ -935,149 +934,136 @@
mbedtls_test_rnd_pseudo_info rnd_info;
int i;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P );
- mbedtls_mpi_init( &Q ); mbedtls_mpi_init( &E );
- mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, 0 );
- mbedtls_rsa_init( &ctx2, MBEDTLS_RSA_PKCS_V15, 0 );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&P);
+ mbedtls_mpi_init(&Q); mbedtls_mpi_init(&E);
+ mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V15, 0);
+ mbedtls_rsa_init(&ctx2, MBEDTLS_RSA_PKCS_V15, 0);
- memset( &rnd_info, 0, sizeof( mbedtls_test_rnd_pseudo_info ) );
+ memset(&rnd_info, 0, sizeof(mbedtls_test_rnd_pseudo_info));
- TEST_ASSERT( mbedtls_test_read_mpi( &P, input_P ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Q, input_Q ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, &P, &Q, NULL, &E ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, &P, &Q, NULL, &E) == 0);
/* Check test data consistency */
- TEST_ASSERT( message_str->len == (size_t) ( mod / 8 ) );
- TEST_ASSERT( mbedtls_rsa_get_len( &ctx ) == (size_t) ( mod / 8 ) );
- TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
- TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
+ TEST_ASSERT(message_str->len == (size_t) (mod / 8));
+ TEST_ASSERT(mbedtls_rsa_get_len(&ctx) == (size_t) (mod / 8));
+ TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
+ TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == 0);
/* repeat three times to test updating of blinding values */
- for( i = 0; i < 3; i++ )
- {
- memset( output, 0x00, sizeof( output ) );
- TEST_ASSERT( mbedtls_rsa_private( &ctx, mbedtls_test_rnd_pseudo_rand,
- &rnd_info, message_str->x,
- output ) == result );
- if( result == 0 )
- {
+ for (i = 0; i < 3; i++) {
+ memset(output, 0x00, sizeof(output));
+ TEST_ASSERT(mbedtls_rsa_private(&ctx, mbedtls_test_rnd_pseudo_rand,
+ &rnd_info, message_str->x,
+ output) == result);
+ if (result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
- ctx.len,
- result_str->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
+ ctx.len,
+ result_str->len) == 0);
}
}
/* And now one more time with the copy */
- TEST_ASSERT( mbedtls_rsa_copy( &ctx2, &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_copy(&ctx2, &ctx) == 0);
/* clear the original to be sure */
- mbedtls_rsa_free( &ctx );
+ mbedtls_rsa_free(&ctx);
- TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx2 ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx2) == 0);
- memset( output, 0x00, sizeof( output ) );
- TEST_ASSERT( mbedtls_rsa_private( &ctx2, mbedtls_test_rnd_pseudo_rand,
- &rnd_info, message_str->x,
- output ) == result );
- if( result == 0 )
- {
+ memset(output, 0x00, sizeof(output));
+ TEST_ASSERT(mbedtls_rsa_private(&ctx2, mbedtls_test_rnd_pseudo_rand,
+ &rnd_info, message_str->x,
+ output) == result);
+ if (result == 0) {
- TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
- ctx2.len,
- result_str->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
+ ctx2.len,
+ result_str->len) == 0);
}
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P );
- mbedtls_mpi_free( &Q ); mbedtls_mpi_free( &E );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&P);
+ mbedtls_mpi_free(&Q); mbedtls_mpi_free(&E);
- mbedtls_rsa_free( &ctx ); mbedtls_rsa_free( &ctx2 );
+ mbedtls_rsa_free(&ctx); mbedtls_rsa_free(&ctx2);
}
/* END_CASE */
/* BEGIN_CASE */
-void rsa_check_privkey_null( )
+void rsa_check_privkey_null()
{
mbedtls_rsa_context ctx;
- memset( &ctx, 0x00, sizeof( mbedtls_rsa_context ) );
+ memset(&ctx, 0x00, sizeof(mbedtls_rsa_context));
- TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
+ TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == MBEDTLS_ERR_RSA_KEY_CHECK_FAILED);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_rsa_check_pubkey( char * input_N, char * input_E, int result )
+void mbedtls_rsa_check_pubkey(char *input_N, char *input_E, int result)
{
mbedtls_rsa_context ctx;
mbedtls_mpi N, E;
- mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
- mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, 0 );
+ mbedtls_mpi_init(&N); mbedtls_mpi_init(&E);
+ mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V15, 0);
- if( strlen( input_N ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
+ if (strlen(input_N)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
}
- if( strlen( input_E ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
+ if (strlen(input_E)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
}
- TEST_ASSERT( mbedtls_rsa_import( &ctx, &N, NULL, NULL, NULL, &E ) == 0 );
- TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == result );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx, &N, NULL, NULL, NULL, &E) == 0);
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == result);
exit:
- mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
- mbedtls_rsa_free( &ctx );
+ mbedtls_mpi_free(&N); mbedtls_mpi_free(&E);
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_rsa_check_privkey( int mod, char * input_P, char * input_Q,
- char * input_N, char * input_E, char * input_D,
- char * input_DP, char * input_DQ, char * input_QP,
- int result )
+void mbedtls_rsa_check_privkey(int mod, char *input_P, char *input_Q,
+ char *input_N, char *input_E, char *input_D,
+ char *input_DP, char *input_DQ, char *input_QP,
+ int result)
{
mbedtls_rsa_context ctx;
- mbedtls_rsa_init( &ctx, MBEDTLS_RSA_PKCS_V15, 0 );
+ mbedtls_rsa_init(&ctx, MBEDTLS_RSA_PKCS_V15, 0);
ctx.len = mod / 8;
- if( strlen( input_P ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &ctx.P, input_P ) == 0 );
+ if (strlen(input_P)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&ctx.P, input_P) == 0);
}
- if( strlen( input_Q ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &ctx.Q, input_Q ) == 0 );
+ if (strlen(input_Q)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&ctx.Q, input_Q) == 0);
}
- if( strlen( input_N ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &ctx.N, input_N ) == 0 );
+ if (strlen(input_N)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&ctx.N, input_N) == 0);
}
- if( strlen( input_E ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &ctx.E, input_E ) == 0 );
+ if (strlen(input_E)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&ctx.E, input_E) == 0);
}
- if( strlen( input_D ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &ctx.D, input_D ) == 0 );
+ if (strlen(input_D)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&ctx.D, input_D) == 0);
}
#if !defined(MBEDTLS_RSA_NO_CRT)
- if( strlen( input_DP ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &ctx.DP, input_DP ) == 0 );
+ if (strlen(input_DP)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&ctx.DP, input_DP) == 0);
}
- if( strlen( input_DQ ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &ctx.DQ, input_DQ ) == 0 );
+ if (strlen(input_DQ)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&ctx.DQ, input_DQ) == 0);
}
- if( strlen( input_QP ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &ctx.QP, input_QP ) == 0 );
+ if (strlen(input_QP)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&ctx.QP, input_QP) == 0);
}
#else
((void) input_DP);
@@ -1085,68 +1071,58 @@
((void) input_QP);
#endif
- TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == result );
+ TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == result);
exit:
- mbedtls_rsa_free( &ctx );
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE */
-void rsa_check_pubpriv( int mod, char * input_Npub, char * input_Epub,
- char * input_P, char * input_Q, char * input_N,
- char * input_E, char * input_D, char * input_DP,
- char * input_DQ, char * input_QP, int result )
+void rsa_check_pubpriv(int mod, char *input_Npub, char *input_Epub,
+ char *input_P, char *input_Q, char *input_N,
+ char *input_E, char *input_D, char *input_DP,
+ char *input_DQ, char *input_QP, int result)
{
mbedtls_rsa_context pub, prv;
- mbedtls_rsa_init( &pub, MBEDTLS_RSA_PKCS_V15, 0 );
- mbedtls_rsa_init( &prv, MBEDTLS_RSA_PKCS_V15, 0 );
+ mbedtls_rsa_init(&pub, MBEDTLS_RSA_PKCS_V15, 0);
+ mbedtls_rsa_init(&prv, MBEDTLS_RSA_PKCS_V15, 0);
pub.len = mod / 8;
prv.len = mod / 8;
- if( strlen( input_Npub ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &pub.N, input_Npub ) == 0 );
+ if (strlen(input_Npub)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&pub.N, input_Npub) == 0);
}
- if( strlen( input_Epub ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &pub.E, input_Epub ) == 0 );
+ if (strlen(input_Epub)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&pub.E, input_Epub) == 0);
}
- if( strlen( input_P ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &prv.P, input_P ) == 0 );
+ if (strlen(input_P)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&prv.P, input_P) == 0);
}
- if( strlen( input_Q ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &prv.Q, input_Q ) == 0 );
+ if (strlen(input_Q)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&prv.Q, input_Q) == 0);
}
- if( strlen( input_N ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &prv.N, input_N ) == 0 );
+ if (strlen(input_N)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&prv.N, input_N) == 0);
}
- if( strlen( input_E ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &prv.E, input_E ) == 0 );
+ if (strlen(input_E)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&prv.E, input_E) == 0);
}
- if( strlen( input_D ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &prv.D, input_D ) == 0 );
+ if (strlen(input_D)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&prv.D, input_D) == 0);
}
#if !defined(MBEDTLS_RSA_NO_CRT)
- if( strlen( input_DP ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &prv.DP, input_DP ) == 0 );
+ if (strlen(input_DP)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&prv.DP, input_DP) == 0);
}
- if( strlen( input_DQ ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &prv.DQ, input_DQ ) == 0 );
+ if (strlen(input_DQ)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&prv.DQ, input_DQ) == 0);
}
- if( strlen( input_QP ) )
- {
- TEST_ASSERT( mbedtls_test_read_mpi( &prv.QP, input_QP ) == 0 );
+ if (strlen(input_QP)) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&prv.QP, input_QP) == 0);
}
#else
((void) input_DP);
@@ -1154,155 +1130,153 @@
((void) input_QP);
#endif
- TEST_ASSERT( mbedtls_rsa_check_pub_priv( &pub, &prv ) == result );
+ TEST_ASSERT(mbedtls_rsa_check_pub_priv(&pub, &prv) == result);
exit:
- mbedtls_rsa_free( &pub );
- mbedtls_rsa_free( &prv );
+ mbedtls_rsa_free(&pub);
+ mbedtls_rsa_free(&prv);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CTR_DRBG_C:MBEDTLS_ENTROPY_C:ENTROPY_HAVE_STRONG */
-void mbedtls_rsa_gen_key( int nrbits, int exponent, int result)
+void mbedtls_rsa_gen_key(int nrbits, int exponent, int result)
{
mbedtls_rsa_context ctx;
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context ctr_drbg;
const char *pers = "test_suite_rsa";
- mbedtls_ctr_drbg_init( &ctr_drbg );
- mbedtls_entropy_init( &entropy );
- mbedtls_rsa_init ( &ctx, 0, 0 );
+ mbedtls_ctr_drbg_init(&ctr_drbg);
+ mbedtls_entropy_init(&entropy);
+ mbedtls_rsa_init(&ctx, 0, 0);
- TEST_ASSERT( mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func,
- &entropy, (const unsigned char *) pers,
- strlen( pers ) ) == 0 );
+ TEST_ASSERT(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func,
+ &entropy, (const unsigned char *) pers,
+ strlen(pers)) == 0);
- TEST_ASSERT( mbedtls_rsa_gen_key( &ctx, mbedtls_ctr_drbg_random, &ctr_drbg, nrbits, exponent ) == result );
- if( result == 0 )
- {
- TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &ctx.P, &ctx.Q ) > 0 );
+ TEST_ASSERT(mbedtls_rsa_gen_key(&ctx, mbedtls_ctr_drbg_random, &ctr_drbg, nrbits,
+ exponent) == result);
+ if (result == 0) {
+ TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&ctx.P, &ctx.Q) > 0);
}
exit:
- mbedtls_rsa_free( &ctx );
- mbedtls_ctr_drbg_free( &ctr_drbg );
- mbedtls_entropy_free( &entropy );
+ mbedtls_rsa_free(&ctx);
+ mbedtls_ctr_drbg_free(&ctr_drbg);
+ mbedtls_entropy_free(&entropy);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CTR_DRBG_C:MBEDTLS_ENTROPY_C */
-void mbedtls_rsa_deduce_primes( char *input_N,
- char *input_D,
- char *input_E,
- char *output_P,
- char *output_Q,
- int corrupt, int result )
+void mbedtls_rsa_deduce_primes(char *input_N,
+ char *input_D,
+ char *input_E,
+ char *output_P,
+ char *output_Q,
+ int corrupt, int result)
{
mbedtls_mpi N, P, Pp, Q, Qp, D, E;
- mbedtls_mpi_init( &N );
- mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q );
- mbedtls_mpi_init( &Pp ); mbedtls_mpi_init( &Qp );
- mbedtls_mpi_init( &D ); mbedtls_mpi_init( &E );
+ mbedtls_mpi_init(&N);
+ mbedtls_mpi_init(&P); mbedtls_mpi_init(&Q);
+ mbedtls_mpi_init(&Pp); mbedtls_mpi_init(&Qp);
+ mbedtls_mpi_init(&D); mbedtls_mpi_init(&E);
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &D, input_D ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Qp, output_P ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Pp, output_Q ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&D, input_D) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Qp, output_P) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Pp, output_Q) == 0);
- if( corrupt )
- TEST_ASSERT( mbedtls_mpi_add_int( &D, &D, 2 ) == 0 );
+ if (corrupt) {
+ TEST_ASSERT(mbedtls_mpi_add_int(&D, &D, 2) == 0);
+ }
/* Try to deduce P, Q from N, D, E only. */
- TEST_ASSERT( mbedtls_rsa_deduce_primes( &N, &D, &E, &P, &Q ) == result );
+ TEST_ASSERT(mbedtls_rsa_deduce_primes(&N, &D, &E, &P, &Q) == result);
- if( !corrupt )
- {
+ if (!corrupt) {
/* Check if (P,Q) = (Pp, Qp) or (P,Q) = (Qp, Pp) */
- TEST_ASSERT( ( mbedtls_mpi_cmp_mpi( &P, &Pp ) == 0 && mbedtls_mpi_cmp_mpi( &Q, &Qp ) == 0 ) ||
- ( mbedtls_mpi_cmp_mpi( &P, &Qp ) == 0 && mbedtls_mpi_cmp_mpi( &Q, &Pp ) == 0 ) );
+ TEST_ASSERT((mbedtls_mpi_cmp_mpi(&P, &Pp) == 0 && mbedtls_mpi_cmp_mpi(&Q, &Qp) == 0) ||
+ (mbedtls_mpi_cmp_mpi(&P, &Qp) == 0 && mbedtls_mpi_cmp_mpi(&Q, &Pp) == 0));
}
exit:
- mbedtls_mpi_free( &N );
- mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q );
- mbedtls_mpi_free( &Pp ); mbedtls_mpi_free( &Qp );
- mbedtls_mpi_free( &D ); mbedtls_mpi_free( &E );
+ mbedtls_mpi_free(&N);
+ mbedtls_mpi_free(&P); mbedtls_mpi_free(&Q);
+ mbedtls_mpi_free(&Pp); mbedtls_mpi_free(&Qp);
+ mbedtls_mpi_free(&D); mbedtls_mpi_free(&E);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_rsa_deduce_private_exponent( char *input_P,
- char *input_Q,
- char *input_E,
- char *output_D,
- int corrupt, int result )
+void mbedtls_rsa_deduce_private_exponent(char *input_P,
+ char *input_Q,
+ char *input_E,
+ char *output_D,
+ int corrupt, int result)
{
mbedtls_mpi P, Q, D, Dp, E, R, Rp;
- mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q );
- mbedtls_mpi_init( &D ); mbedtls_mpi_init( &Dp );
- mbedtls_mpi_init( &E );
- mbedtls_mpi_init( &R ); mbedtls_mpi_init( &Rp );
+ mbedtls_mpi_init(&P); mbedtls_mpi_init(&Q);
+ mbedtls_mpi_init(&D); mbedtls_mpi_init(&Dp);
+ mbedtls_mpi_init(&E);
+ mbedtls_mpi_init(&R); mbedtls_mpi_init(&Rp);
- TEST_ASSERT( mbedtls_test_read_mpi( &P, input_P ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Q, input_Q ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
- TEST_ASSERT( mbedtls_test_read_mpi( &Dp, output_D ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
+ TEST_ASSERT(mbedtls_test_read_mpi(&Dp, output_D) == 0);
- if( corrupt )
- {
+ if (corrupt) {
/* Make E even */
- TEST_ASSERT( mbedtls_mpi_set_bit( &E, 0, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_set_bit(&E, 0, 0) == 0);
}
/* Try to deduce D from N, P, Q, E. */
- TEST_ASSERT( mbedtls_rsa_deduce_private_exponent( &P, &Q,
- &E, &D ) == result );
+ TEST_ASSERT(mbedtls_rsa_deduce_private_exponent(&P, &Q,
+ &E, &D) == result);
- if( !corrupt )
- {
+ if (!corrupt) {
/*
* Check that D and Dp agree modulo LCM(P-1, Q-1).
*/
/* Replace P,Q by P-1, Q-1 */
- TEST_ASSERT( mbedtls_mpi_sub_int( &P, &P, 1 ) == 0 );
- TEST_ASSERT( mbedtls_mpi_sub_int( &Q, &Q, 1 ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_sub_int(&P, &P, 1) == 0);
+ TEST_ASSERT(mbedtls_mpi_sub_int(&Q, &Q, 1) == 0);
/* Check D == Dp modulo P-1 */
- TEST_ASSERT( mbedtls_mpi_mod_mpi( &R, &D, &P ) == 0 );
- TEST_ASSERT( mbedtls_mpi_mod_mpi( &Rp, &Dp, &P ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R, &Rp ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_mod_mpi(&R, &D, &P) == 0);
+ TEST_ASSERT(mbedtls_mpi_mod_mpi(&Rp, &Dp, &P) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R, &Rp) == 0);
/* Check D == Dp modulo Q-1 */
- TEST_ASSERT( mbedtls_mpi_mod_mpi( &R, &D, &Q ) == 0 );
- TEST_ASSERT( mbedtls_mpi_mod_mpi( &Rp, &Dp, &Q ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &R, &Rp ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_mod_mpi(&R, &D, &Q) == 0);
+ TEST_ASSERT(mbedtls_mpi_mod_mpi(&Rp, &Dp, &Q) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&R, &Rp) == 0);
}
exit:
- mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q );
- mbedtls_mpi_free( &D ); mbedtls_mpi_free( &Dp );
- mbedtls_mpi_free( &E );
- mbedtls_mpi_free( &R ); mbedtls_mpi_free( &Rp );
+ mbedtls_mpi_free(&P); mbedtls_mpi_free(&Q);
+ mbedtls_mpi_free(&D); mbedtls_mpi_free(&Dp);
+ mbedtls_mpi_free(&E);
+ mbedtls_mpi_free(&R); mbedtls_mpi_free(&Rp);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CTR_DRBG_C:MBEDTLS_ENTROPY_C:ENTROPY_HAVE_STRONG */
-void mbedtls_rsa_import( char *input_N,
- char *input_P,
- char *input_Q,
- char *input_D,
- char *input_E,
- int successive,
- int is_priv,
- int res_check,
- int res_complete )
+void mbedtls_rsa_import(char *input_N,
+ char *input_P,
+ char *input_Q,
+ char *input_D,
+ char *input_E,
+ int successive,
+ int is_priv,
+ int res_check,
+ int res_complete)
{
mbedtls_mpi N, P, Q, D, E;
mbedtls_rsa_context ctx;
@@ -1316,140 +1290,143 @@
mbedtls_ctr_drbg_context ctr_drbg;
const char *pers = "test_suite_rsa";
- const int have_N = ( strlen( input_N ) > 0 );
- const int have_P = ( strlen( input_P ) > 0 );
- const int have_Q = ( strlen( input_Q ) > 0 );
- const int have_D = ( strlen( input_D ) > 0 );
- const int have_E = ( strlen( input_E ) > 0 );
+ const int have_N = (strlen(input_N) > 0);
+ const int have_P = (strlen(input_P) > 0);
+ const int have_Q = (strlen(input_Q) > 0);
+ const int have_D = (strlen(input_D) > 0);
+ const int have_E = (strlen(input_E) > 0);
- mbedtls_ctr_drbg_init( &ctr_drbg );
- mbedtls_entropy_init( &entropy );
- mbedtls_rsa_init( &ctx, 0, 0 );
+ mbedtls_ctr_drbg_init(&ctr_drbg);
+ mbedtls_entropy_init(&entropy);
+ mbedtls_rsa_init(&ctx, 0, 0);
- mbedtls_mpi_init( &N );
- mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q );
- mbedtls_mpi_init( &D ); mbedtls_mpi_init( &E );
+ mbedtls_mpi_init(&N);
+ mbedtls_mpi_init(&P); mbedtls_mpi_init(&Q);
+ mbedtls_mpi_init(&D); mbedtls_mpi_init(&E);
- TEST_ASSERT( mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func, &entropy,
- (const unsigned char *) pers, strlen( pers ) ) == 0 );
+ TEST_ASSERT(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy,
+ (const unsigned char *) pers, strlen(pers)) == 0);
- if( have_N )
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
-
- if( have_P )
- TEST_ASSERT( mbedtls_test_read_mpi( &P, input_P ) == 0 );
-
- if( have_Q )
- TEST_ASSERT( mbedtls_test_read_mpi( &Q, input_Q ) == 0 );
-
- if( have_D )
- TEST_ASSERT( mbedtls_test_read_mpi( &D, input_D ) == 0 );
-
- if( have_E )
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
-
- if( !successive )
- {
- TEST_ASSERT( mbedtls_rsa_import( &ctx,
- have_N ? &N : NULL,
- have_P ? &P : NULL,
- have_Q ? &Q : NULL,
- have_D ? &D : NULL,
- have_E ? &E : NULL ) == 0 );
+ if (have_N) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
}
- else
- {
+
+ if (have_P) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
+ }
+
+ if (have_Q) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
+ }
+
+ if (have_D) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&D, input_D) == 0);
+ }
+
+ if (have_E) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
+ }
+
+ if (!successive) {
+ TEST_ASSERT(mbedtls_rsa_import(&ctx,
+ have_N ? &N : NULL,
+ have_P ? &P : NULL,
+ have_Q ? &Q : NULL,
+ have_D ? &D : NULL,
+ have_E ? &E : NULL) == 0);
+ } else {
/* Import N, P, Q, D, E separately.
* This should make no functional difference. */
- TEST_ASSERT( mbedtls_rsa_import( &ctx,
- have_N ? &N : NULL,
- NULL, NULL, NULL, NULL ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx,
+ have_N ? &N : NULL,
+ NULL, NULL, NULL, NULL) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx,
- NULL,
- have_P ? &P : NULL,
- NULL, NULL, NULL ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx,
+ NULL,
+ have_P ? &P : NULL,
+ NULL, NULL, NULL) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx,
- NULL, NULL,
- have_Q ? &Q : NULL,
- NULL, NULL ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx,
+ NULL, NULL,
+ have_Q ? &Q : NULL,
+ NULL, NULL) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx,
- NULL, NULL, NULL,
- have_D ? &D : NULL,
- NULL ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx,
+ NULL, NULL, NULL,
+ have_D ? &D : NULL,
+ NULL) == 0);
- TEST_ASSERT( mbedtls_rsa_import( &ctx,
- NULL, NULL, NULL, NULL,
- have_E ? &E : NULL ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx,
+ NULL, NULL, NULL, NULL,
+ have_E ? &E : NULL) == 0);
}
- TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == res_complete );
+ TEST_ASSERT(mbedtls_rsa_complete(&ctx) == res_complete);
/* On expected success, perform some public and private
* key operations to check if the key is working properly. */
- if( res_complete == 0 )
- {
- if( is_priv )
- TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == res_check );
- else
- TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == res_check );
+ if (res_complete == 0) {
+ if (is_priv) {
+ TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == res_check);
+ } else {
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == res_check);
+ }
- if( res_check != 0 )
+ if (res_check != 0) {
goto exit;
+ }
- buf_orig = mbedtls_calloc( 1, mbedtls_rsa_get_len( &ctx ) );
- buf_enc = mbedtls_calloc( 1, mbedtls_rsa_get_len( &ctx ) );
- buf_dec = mbedtls_calloc( 1, mbedtls_rsa_get_len( &ctx ) );
- if( buf_orig == NULL || buf_enc == NULL || buf_dec == NULL )
+ buf_orig = mbedtls_calloc(1, mbedtls_rsa_get_len(&ctx));
+ buf_enc = mbedtls_calloc(1, mbedtls_rsa_get_len(&ctx));
+ buf_dec = mbedtls_calloc(1, mbedtls_rsa_get_len(&ctx));
+ if (buf_orig == NULL || buf_enc == NULL || buf_dec == NULL) {
goto exit;
+ }
- TEST_ASSERT( mbedtls_ctr_drbg_random( &ctr_drbg,
- buf_orig, mbedtls_rsa_get_len( &ctx ) ) == 0 );
+ TEST_ASSERT(mbedtls_ctr_drbg_random(&ctr_drbg,
+ buf_orig, mbedtls_rsa_get_len(&ctx)) == 0);
/* Make sure the number we're generating is smaller than the modulus */
buf_orig[0] = 0x00;
- TEST_ASSERT( mbedtls_rsa_public( &ctx, buf_orig, buf_enc ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_public(&ctx, buf_orig, buf_enc) == 0);
- if( is_priv )
- {
- TEST_ASSERT( mbedtls_rsa_private( &ctx, mbedtls_ctr_drbg_random,
- &ctr_drbg, buf_enc,
- buf_dec ) == 0 );
+ if (is_priv) {
+ TEST_ASSERT(mbedtls_rsa_private(&ctx, mbedtls_ctr_drbg_random,
+ &ctr_drbg, buf_enc,
+ buf_dec) == 0);
- TEST_ASSERT( memcmp( buf_orig, buf_dec,
- mbedtls_rsa_get_len( &ctx ) ) == 0 );
+ TEST_ASSERT(memcmp(buf_orig, buf_dec,
+ mbedtls_rsa_get_len(&ctx)) == 0);
}
}
exit:
- mbedtls_free( buf_orig );
- mbedtls_free( buf_enc );
- mbedtls_free( buf_dec );
+ mbedtls_free(buf_orig);
+ mbedtls_free(buf_enc);
+ mbedtls_free(buf_dec);
- mbedtls_rsa_free( &ctx );
+ mbedtls_rsa_free(&ctx);
- mbedtls_ctr_drbg_free( &ctr_drbg );
- mbedtls_entropy_free( &entropy );
+ mbedtls_ctr_drbg_free(&ctr_drbg);
+ mbedtls_entropy_free(&entropy);
- mbedtls_mpi_free( &N );
- mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q );
- mbedtls_mpi_free( &D ); mbedtls_mpi_free( &E );
+ mbedtls_mpi_free(&N);
+ mbedtls_mpi_free(&P); mbedtls_mpi_free(&Q);
+ mbedtls_mpi_free(&D); mbedtls_mpi_free(&E);
}
/* END_CASE */
/* BEGIN_CASE */
-void mbedtls_rsa_export( char *input_N,
- char *input_P,
- char *input_Q,
- char *input_D,
- char *input_E,
- int is_priv,
- int successive )
+void mbedtls_rsa_export(char *input_N,
+ char *input_P,
+ char *input_Q,
+ char *input_D,
+ char *input_E,
+ int is_priv,
+ int successive)
{
/* Original MPI's with which we set up the RSA context */
mbedtls_mpi N, P, Q, D, E;
@@ -1457,184 +1434,190 @@
/* Exported MPI's */
mbedtls_mpi Ne, Pe, Qe, De, Ee;
- const int have_N = ( strlen( input_N ) > 0 );
- const int have_P = ( strlen( input_P ) > 0 );
- const int have_Q = ( strlen( input_Q ) > 0 );
- const int have_D = ( strlen( input_D ) > 0 );
- const int have_E = ( strlen( input_E ) > 0 );
+ const int have_N = (strlen(input_N) > 0);
+ const int have_P = (strlen(input_P) > 0);
+ const int have_Q = (strlen(input_Q) > 0);
+ const int have_D = (strlen(input_D) > 0);
+ const int have_E = (strlen(input_E) > 0);
mbedtls_rsa_context ctx;
- mbedtls_rsa_init( &ctx, 0, 0 );
+ mbedtls_rsa_init(&ctx, 0, 0);
- mbedtls_mpi_init( &N );
- mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q );
- mbedtls_mpi_init( &D ); mbedtls_mpi_init( &E );
+ mbedtls_mpi_init(&N);
+ mbedtls_mpi_init(&P); mbedtls_mpi_init(&Q);
+ mbedtls_mpi_init(&D); mbedtls_mpi_init(&E);
- mbedtls_mpi_init( &Ne );
- mbedtls_mpi_init( &Pe ); mbedtls_mpi_init( &Qe );
- mbedtls_mpi_init( &De ); mbedtls_mpi_init( &Ee );
+ mbedtls_mpi_init(&Ne);
+ mbedtls_mpi_init(&Pe); mbedtls_mpi_init(&Qe);
+ mbedtls_mpi_init(&De); mbedtls_mpi_init(&Ee);
/* Setup RSA context */
- if( have_N )
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
+ if (have_N) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ }
- if( have_P )
- TEST_ASSERT( mbedtls_test_read_mpi( &P, input_P ) == 0 );
+ if (have_P) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
+ }
- if( have_Q )
- TEST_ASSERT( mbedtls_test_read_mpi( &Q, input_Q ) == 0 );
+ if (have_Q) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
+ }
- if( have_D )
- TEST_ASSERT( mbedtls_test_read_mpi( &D, input_D ) == 0 );
+ if (have_D) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&D, input_D) == 0);
+ }
- if( have_E )
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
+ if (have_E) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
+ }
- TEST_ASSERT( mbedtls_rsa_import( &ctx,
- strlen( input_N ) ? &N : NULL,
- strlen( input_P ) ? &P : NULL,
- strlen( input_Q ) ? &Q : NULL,
- strlen( input_D ) ? &D : NULL,
- strlen( input_E ) ? &E : NULL ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import(&ctx,
+ strlen(input_N) ? &N : NULL,
+ strlen(input_P) ? &P : NULL,
+ strlen(input_Q) ? &Q : NULL,
+ strlen(input_D) ? &D : NULL,
+ strlen(input_E) ? &E : NULL) == 0);
- TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
/*
* Export parameters and compare to original ones.
*/
/* N and E must always be present. */
- if( !successive )
- {
- TEST_ASSERT( mbedtls_rsa_export( &ctx, &Ne, NULL, NULL, NULL, &Ee ) == 0 );
+ if (!successive) {
+ TEST_ASSERT(mbedtls_rsa_export(&ctx, &Ne, NULL, NULL, NULL, &Ee) == 0);
+ } else {
+ TEST_ASSERT(mbedtls_rsa_export(&ctx, &Ne, NULL, NULL, NULL, NULL) == 0);
+ TEST_ASSERT(mbedtls_rsa_export(&ctx, NULL, NULL, NULL, NULL, &Ee) == 0);
}
- else
- {
- TEST_ASSERT( mbedtls_rsa_export( &ctx, &Ne, NULL, NULL, NULL, NULL ) == 0 );
- TEST_ASSERT( mbedtls_rsa_export( &ctx, NULL, NULL, NULL, NULL, &Ee ) == 0 );
- }
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &N, &Ne ) == 0 );
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &E, &Ee ) == 0 );
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&N, &Ne) == 0);
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&E, &Ee) == 0);
/* If we were providing enough information to setup a complete private context,
* we expect to be able to export all core parameters. */
- if( is_priv )
- {
- if( !successive )
- {
- TEST_ASSERT( mbedtls_rsa_export( &ctx, NULL, &Pe, &Qe,
- &De, NULL ) == 0 );
- }
- else
- {
- TEST_ASSERT( mbedtls_rsa_export( &ctx, NULL, &Pe, NULL,
- NULL, NULL ) == 0 );
- TEST_ASSERT( mbedtls_rsa_export( &ctx, NULL, NULL, &Qe,
- NULL, NULL ) == 0 );
- TEST_ASSERT( mbedtls_rsa_export( &ctx, NULL, NULL, NULL,
- &De, NULL ) == 0 );
+ if (is_priv) {
+ if (!successive) {
+ TEST_ASSERT(mbedtls_rsa_export(&ctx, NULL, &Pe, &Qe,
+ &De, NULL) == 0);
+ } else {
+ TEST_ASSERT(mbedtls_rsa_export(&ctx, NULL, &Pe, NULL,
+ NULL, NULL) == 0);
+ TEST_ASSERT(mbedtls_rsa_export(&ctx, NULL, NULL, &Qe,
+ NULL, NULL) == 0);
+ TEST_ASSERT(mbedtls_rsa_export(&ctx, NULL, NULL, NULL,
+ &De, NULL) == 0);
}
- if( have_P )
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &P, &Pe ) == 0 );
+ if (have_P) {
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&P, &Pe) == 0);
+ }
- if( have_Q )
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &Q, &Qe ) == 0 );
+ if (have_Q) {
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&Q, &Qe) == 0);
+ }
- if( have_D )
- TEST_ASSERT( mbedtls_mpi_cmp_mpi( &D, &De ) == 0 );
+ if (have_D) {
+ TEST_ASSERT(mbedtls_mpi_cmp_mpi(&D, &De) == 0);
+ }
/* While at it, perform a sanity check */
- TEST_ASSERT( mbedtls_rsa_validate_params( &Ne, &Pe, &Qe, &De, &Ee,
- NULL, NULL ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_validate_params(&Ne, &Pe, &Qe, &De, &Ee,
+ NULL, NULL) == 0);
}
exit:
- mbedtls_rsa_free( &ctx );
+ mbedtls_rsa_free(&ctx);
- mbedtls_mpi_free( &N );
- mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q );
- mbedtls_mpi_free( &D ); mbedtls_mpi_free( &E );
+ mbedtls_mpi_free(&N);
+ mbedtls_mpi_free(&P); mbedtls_mpi_free(&Q);
+ mbedtls_mpi_free(&D); mbedtls_mpi_free(&E);
- mbedtls_mpi_free( &Ne );
- mbedtls_mpi_free( &Pe ); mbedtls_mpi_free( &Qe );
- mbedtls_mpi_free( &De ); mbedtls_mpi_free( &Ee );
+ mbedtls_mpi_free(&Ne);
+ mbedtls_mpi_free(&Pe); mbedtls_mpi_free(&Qe);
+ mbedtls_mpi_free(&De); mbedtls_mpi_free(&Ee);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_ENTROPY_C:ENTROPY_HAVE_STRONG:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C */
-void mbedtls_rsa_validate_params( char *input_N,
- char *input_P,
- char *input_Q,
- char *input_D,
- char *input_E,
- int prng, int result )
+void mbedtls_rsa_validate_params(char *input_N,
+ char *input_P,
+ char *input_Q,
+ char *input_D,
+ char *input_E,
+ int prng, int result)
{
/* Original MPI's with which we set up the RSA context */
mbedtls_mpi N, P, Q, D, E;
- const int have_N = ( strlen( input_N ) > 0 );
- const int have_P = ( strlen( input_P ) > 0 );
- const int have_Q = ( strlen( input_Q ) > 0 );
- const int have_D = ( strlen( input_D ) > 0 );
- const int have_E = ( strlen( input_E ) > 0 );
+ const int have_N = (strlen(input_N) > 0);
+ const int have_P = (strlen(input_P) > 0);
+ const int have_Q = (strlen(input_Q) > 0);
+ const int have_D = (strlen(input_D) > 0);
+ const int have_E = (strlen(input_E) > 0);
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context ctr_drbg;
const char *pers = "test_suite_rsa";
- mbedtls_mpi_init( &N );
- mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q );
- mbedtls_mpi_init( &D ); mbedtls_mpi_init( &E );
+ mbedtls_mpi_init(&N);
+ mbedtls_mpi_init(&P); mbedtls_mpi_init(&Q);
+ mbedtls_mpi_init(&D); mbedtls_mpi_init(&E);
- mbedtls_ctr_drbg_init( &ctr_drbg );
- mbedtls_entropy_init( &entropy );
- TEST_ASSERT( mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func,
- &entropy, (const unsigned char *) pers,
- strlen( pers ) ) == 0 );
+ mbedtls_ctr_drbg_init(&ctr_drbg);
+ mbedtls_entropy_init(&entropy);
+ TEST_ASSERT(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func,
+ &entropy, (const unsigned char *) pers,
+ strlen(pers)) == 0);
- if( have_N )
- TEST_ASSERT( mbedtls_test_read_mpi( &N, input_N ) == 0 );
+ if (have_N) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&N, input_N) == 0);
+ }
- if( have_P )
- TEST_ASSERT( mbedtls_test_read_mpi( &P, input_P ) == 0 );
+ if (have_P) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&P, input_P) == 0);
+ }
- if( have_Q )
- TEST_ASSERT( mbedtls_test_read_mpi( &Q, input_Q ) == 0 );
+ if (have_Q) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&Q, input_Q) == 0);
+ }
- if( have_D )
- TEST_ASSERT( mbedtls_test_read_mpi( &D, input_D ) == 0 );
+ if (have_D) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&D, input_D) == 0);
+ }
- if( have_E )
- TEST_ASSERT( mbedtls_test_read_mpi( &E, input_E ) == 0 );
+ if (have_E) {
+ TEST_ASSERT(mbedtls_test_read_mpi(&E, input_E) == 0);
+ }
- TEST_ASSERT( mbedtls_rsa_validate_params( have_N ? &N : NULL,
- have_P ? &P : NULL,
- have_Q ? &Q : NULL,
- have_D ? &D : NULL,
- have_E ? &E : NULL,
- prng ? mbedtls_ctr_drbg_random : NULL,
- prng ? &ctr_drbg : NULL ) == result );
+ TEST_ASSERT(mbedtls_rsa_validate_params(have_N ? &N : NULL,
+ have_P ? &P : NULL,
+ have_Q ? &Q : NULL,
+ have_D ? &D : NULL,
+ have_E ? &E : NULL,
+ prng ? mbedtls_ctr_drbg_random : NULL,
+ prng ? &ctr_drbg : NULL) == result);
exit:
- mbedtls_ctr_drbg_free( &ctr_drbg );
- mbedtls_entropy_free( &entropy );
+ mbedtls_ctr_drbg_free(&ctr_drbg);
+ mbedtls_entropy_free(&entropy);
- mbedtls_mpi_free( &N );
- mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q );
- mbedtls_mpi_free( &D ); mbedtls_mpi_free( &E );
+ mbedtls_mpi_free(&N);
+ mbedtls_mpi_free(&P); mbedtls_mpi_free(&Q);
+ mbedtls_mpi_free(&D); mbedtls_mpi_free(&E);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CTR_DRBG_C:MBEDTLS_ENTROPY_C */
-void mbedtls_rsa_export_raw( data_t *input_N, data_t *input_P,
- data_t *input_Q, data_t *input_D,
- data_t *input_E, int is_priv,
- int successive )
+void mbedtls_rsa_export_raw(data_t *input_N, data_t *input_P,
+ data_t *input_Q, data_t *input_D,
+ data_t *input_E, int is_priv,
+ int successive)
{
/* Exported buffers */
unsigned char bufNe[256];
@@ -1645,94 +1628,90 @@
mbedtls_rsa_context ctx;
- mbedtls_rsa_init( &ctx, 0, 0 );
+ mbedtls_rsa_init(&ctx, 0, 0);
/* Setup RSA context */
- TEST_ASSERT( mbedtls_rsa_import_raw( &ctx,
- input_N->len ? input_N->x : NULL, input_N->len,
- input_P->len ? input_P->x : NULL, input_P->len,
- input_Q->len ? input_Q->x : NULL, input_Q->len,
- input_D->len ? input_D->x : NULL, input_D->len,
- input_E->len ? input_E->x : NULL, input_E->len ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import_raw(&ctx,
+ input_N->len ? input_N->x : NULL, input_N->len,
+ input_P->len ? input_P->x : NULL, input_P->len,
+ input_Q->len ? input_Q->x : NULL, input_Q->len,
+ input_D->len ? input_D->x : NULL, input_D->len,
+ input_E->len ? input_E->x : NULL, input_E->len) == 0);
- TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_complete(&ctx) == 0);
/*
* Export parameters and compare to original ones.
*/
/* N and E must always be present. */
- if( !successive )
- {
- TEST_ASSERT( mbedtls_rsa_export_raw( &ctx, bufNe, input_N->len,
- NULL, 0, NULL, 0, NULL, 0,
- bufEe, input_E->len ) == 0 );
+ if (!successive) {
+ TEST_ASSERT(mbedtls_rsa_export_raw(&ctx, bufNe, input_N->len,
+ NULL, 0, NULL, 0, NULL, 0,
+ bufEe, input_E->len) == 0);
+ } else {
+ TEST_ASSERT(mbedtls_rsa_export_raw(&ctx, bufNe, input_N->len,
+ NULL, 0, NULL, 0, NULL, 0,
+ NULL, 0) == 0);
+ TEST_ASSERT(mbedtls_rsa_export_raw(&ctx, NULL, 0,
+ NULL, 0, NULL, 0, NULL, 0,
+ bufEe, input_E->len) == 0);
}
- else
- {
- TEST_ASSERT( mbedtls_rsa_export_raw( &ctx, bufNe, input_N->len,
- NULL, 0, NULL, 0, NULL, 0,
- NULL, 0 ) == 0 );
- TEST_ASSERT( mbedtls_rsa_export_raw( &ctx, NULL, 0,
- NULL, 0, NULL, 0, NULL, 0,
- bufEe, input_E->len ) == 0 );
- }
- TEST_ASSERT( memcmp( input_N->x, bufNe, input_N->len ) == 0 );
- TEST_ASSERT( memcmp( input_E->x, bufEe, input_E->len ) == 0 );
+ TEST_ASSERT(memcmp(input_N->x, bufNe, input_N->len) == 0);
+ TEST_ASSERT(memcmp(input_E->x, bufEe, input_E->len) == 0);
/* If we were providing enough information to setup a complete private context,
* we expect to be able to export all core parameters. */
- if( is_priv )
- {
- if( !successive )
- {
- TEST_ASSERT( mbedtls_rsa_export_raw( &ctx, NULL, 0,
- bufPe, input_P->len ? input_P->len : sizeof( bufPe ),
- bufQe, input_Q->len ? input_Q->len : sizeof( bufQe ),
- bufDe, input_D->len ? input_D->len : sizeof( bufDe ),
- NULL, 0 ) == 0 );
- }
- else
- {
- TEST_ASSERT( mbedtls_rsa_export_raw( &ctx, NULL, 0,
- bufPe, input_P->len ? input_P->len : sizeof( bufPe ),
- NULL, 0, NULL, 0,
- NULL, 0 ) == 0 );
+ if (is_priv) {
+ if (!successive) {
+ TEST_ASSERT(mbedtls_rsa_export_raw(&ctx, NULL, 0,
+ bufPe, input_P->len ? input_P->len : sizeof(bufPe),
+ bufQe, input_Q->len ? input_Q->len : sizeof(bufQe),
+ bufDe, input_D->len ? input_D->len : sizeof(bufDe),
+ NULL, 0) == 0);
+ } else {
+ TEST_ASSERT(mbedtls_rsa_export_raw(&ctx, NULL, 0,
+ bufPe, input_P->len ? input_P->len : sizeof(bufPe),
+ NULL, 0, NULL, 0,
+ NULL, 0) == 0);
- TEST_ASSERT( mbedtls_rsa_export_raw( &ctx, NULL, 0, NULL, 0,
- bufQe, input_Q->len ? input_Q->len : sizeof( bufQe ),
- NULL, 0, NULL, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_export_raw(&ctx, NULL, 0, NULL, 0,
+ bufQe, input_Q->len ? input_Q->len : sizeof(bufQe),
+ NULL, 0, NULL, 0) == 0);
- TEST_ASSERT( mbedtls_rsa_export_raw( &ctx, NULL, 0, NULL, 0, NULL, 0,
- bufDe, input_D->len ? input_D->len : sizeof( bufDe ),
- NULL, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_export_raw(&ctx, NULL, 0, NULL, 0, NULL, 0,
+ bufDe, input_D->len ? input_D->len : sizeof(bufDe),
+ NULL, 0) == 0);
}
- if( input_P->len )
- TEST_ASSERT( memcmp( input_P->x, bufPe, input_P->len ) == 0 );
+ if (input_P->len) {
+ TEST_ASSERT(memcmp(input_P->x, bufPe, input_P->len) == 0);
+ }
- if( input_Q->len )
- TEST_ASSERT( memcmp( input_Q->x, bufQe, input_Q->len ) == 0 );
+ if (input_Q->len) {
+ TEST_ASSERT(memcmp(input_Q->x, bufQe, input_Q->len) == 0);
+ }
- if( input_D->len )
- TEST_ASSERT( memcmp( input_D->x, bufDe, input_D->len ) == 0 );
+ if (input_D->len) {
+ TEST_ASSERT(memcmp(input_D->x, bufDe, input_D->len) == 0);
+ }
}
exit:
- mbedtls_rsa_free( &ctx );
+ mbedtls_rsa_free(&ctx);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CTR_DRBG_C:MBEDTLS_ENTROPY_C:ENTROPY_HAVE_STRONG */
-void mbedtls_rsa_import_raw( data_t *input_N,
- data_t *input_P, data_t *input_Q,
- data_t *input_D, data_t *input_E,
- int successive,
- int is_priv,
- int res_check,
- int res_complete )
+void mbedtls_rsa_import_raw(data_t *input_N,
+ data_t *input_P, data_t *input_Q,
+ data_t *input_D, data_t *input_E,
+ int successive,
+ int is_priv,
+ int res_check,
+ int res_complete)
{
/* Buffers used for encryption-decryption test */
unsigned char *buf_orig = NULL;
@@ -1745,108 +1724,108 @@
const char *pers = "test_suite_rsa";
- mbedtls_ctr_drbg_init( &ctr_drbg );
- mbedtls_entropy_init( &entropy );
- mbedtls_rsa_init( &ctx, 0, 0 );
+ mbedtls_ctr_drbg_init(&ctr_drbg);
+ mbedtls_entropy_init(&entropy);
+ mbedtls_rsa_init(&ctx, 0, 0);
- TEST_ASSERT( mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func,
- &entropy, (const unsigned char *) pers,
- strlen( pers ) ) == 0 );
+ TEST_ASSERT(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func,
+ &entropy, (const unsigned char *) pers,
+ strlen(pers)) == 0);
- if( !successive )
- {
- TEST_ASSERT( mbedtls_rsa_import_raw( &ctx,
- ( input_N->len > 0 ) ? input_N->x : NULL, input_N->len,
- ( input_P->len > 0 ) ? input_P->x : NULL, input_P->len,
- ( input_Q->len > 0 ) ? input_Q->x : NULL, input_Q->len,
- ( input_D->len > 0 ) ? input_D->x : NULL, input_D->len,
- ( input_E->len > 0 ) ? input_E->x : NULL, input_E->len ) == 0 );
- }
- else
- {
+ if (!successive) {
+ TEST_ASSERT(mbedtls_rsa_import_raw(&ctx,
+ (input_N->len > 0) ? input_N->x : NULL, input_N->len,
+ (input_P->len > 0) ? input_P->x : NULL, input_P->len,
+ (input_Q->len > 0) ? input_Q->x : NULL, input_Q->len,
+ (input_D->len > 0) ? input_D->x : NULL, input_D->len,
+ (input_E->len > 0) ? input_E->x : NULL,
+ input_E->len) == 0);
+ } else {
/* Import N, P, Q, D, E separately.
* This should make no functional difference. */
- TEST_ASSERT( mbedtls_rsa_import_raw( &ctx,
- ( input_N->len > 0 ) ? input_N->x : NULL, input_N->len,
- NULL, 0, NULL, 0, NULL, 0, NULL, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import_raw(&ctx,
+ (input_N->len > 0) ? input_N->x : NULL, input_N->len,
+ NULL, 0, NULL, 0, NULL, 0, NULL, 0) == 0);
- TEST_ASSERT( mbedtls_rsa_import_raw( &ctx,
- NULL, 0,
- ( input_P->len > 0 ) ? input_P->x : NULL, input_P->len,
- NULL, 0, NULL, 0, NULL, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import_raw(&ctx,
+ NULL, 0,
+ (input_P->len > 0) ? input_P->x : NULL, input_P->len,
+ NULL, 0, NULL, 0, NULL, 0) == 0);
- TEST_ASSERT( mbedtls_rsa_import_raw( &ctx,
- NULL, 0, NULL, 0,
- ( input_Q->len > 0 ) ? input_Q->x : NULL, input_Q->len,
- NULL, 0, NULL, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import_raw(&ctx,
+ NULL, 0, NULL, 0,
+ (input_Q->len > 0) ? input_Q->x : NULL, input_Q->len,
+ NULL, 0, NULL, 0) == 0);
- TEST_ASSERT( mbedtls_rsa_import_raw( &ctx,
- NULL, 0, NULL, 0, NULL, 0,
- ( input_D->len > 0 ) ? input_D->x : NULL, input_D->len,
- NULL, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import_raw(&ctx,
+ NULL, 0, NULL, 0, NULL, 0,
+ (input_D->len > 0) ? input_D->x : NULL, input_D->len,
+ NULL, 0) == 0);
- TEST_ASSERT( mbedtls_rsa_import_raw( &ctx,
- NULL, 0, NULL, 0, NULL, 0, NULL, 0,
- ( input_E->len > 0 ) ? input_E->x : NULL, input_E->len ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_import_raw(&ctx,
+ NULL, 0, NULL, 0, NULL, 0, NULL, 0,
+ (input_E->len > 0) ? input_E->x : NULL,
+ input_E->len) == 0);
}
- TEST_ASSERT( mbedtls_rsa_complete( &ctx ) == res_complete );
+ TEST_ASSERT(mbedtls_rsa_complete(&ctx) == res_complete);
/* On expected success, perform some public and private
* key operations to check if the key is working properly. */
- if( res_complete == 0 )
- {
- if( is_priv )
- TEST_ASSERT( mbedtls_rsa_check_privkey( &ctx ) == res_check );
- else
- TEST_ASSERT( mbedtls_rsa_check_pubkey( &ctx ) == res_check );
+ if (res_complete == 0) {
+ if (is_priv) {
+ TEST_ASSERT(mbedtls_rsa_check_privkey(&ctx) == res_check);
+ } else {
+ TEST_ASSERT(mbedtls_rsa_check_pubkey(&ctx) == res_check);
+ }
- if( res_check != 0 )
+ if (res_check != 0) {
goto exit;
+ }
- buf_orig = mbedtls_calloc( 1, mbedtls_rsa_get_len( &ctx ) );
- buf_enc = mbedtls_calloc( 1, mbedtls_rsa_get_len( &ctx ) );
- buf_dec = mbedtls_calloc( 1, mbedtls_rsa_get_len( &ctx ) );
- if( buf_orig == NULL || buf_enc == NULL || buf_dec == NULL )
+ buf_orig = mbedtls_calloc(1, mbedtls_rsa_get_len(&ctx));
+ buf_enc = mbedtls_calloc(1, mbedtls_rsa_get_len(&ctx));
+ buf_dec = mbedtls_calloc(1, mbedtls_rsa_get_len(&ctx));
+ if (buf_orig == NULL || buf_enc == NULL || buf_dec == NULL) {
goto exit;
+ }
- TEST_ASSERT( mbedtls_ctr_drbg_random( &ctr_drbg,
- buf_orig, mbedtls_rsa_get_len( &ctx ) ) == 0 );
+ TEST_ASSERT(mbedtls_ctr_drbg_random(&ctr_drbg,
+ buf_orig, mbedtls_rsa_get_len(&ctx)) == 0);
/* Make sure the number we're generating is smaller than the modulus */
buf_orig[0] = 0x00;
- TEST_ASSERT( mbedtls_rsa_public( &ctx, buf_orig, buf_enc ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_public(&ctx, buf_orig, buf_enc) == 0);
- if( is_priv )
- {
- TEST_ASSERT( mbedtls_rsa_private( &ctx, mbedtls_ctr_drbg_random,
- &ctr_drbg, buf_enc,
- buf_dec ) == 0 );
+ if (is_priv) {
+ TEST_ASSERT(mbedtls_rsa_private(&ctx, mbedtls_ctr_drbg_random,
+ &ctr_drbg, buf_enc,
+ buf_dec) == 0);
- TEST_ASSERT( memcmp( buf_orig, buf_dec,
- mbedtls_rsa_get_len( &ctx ) ) == 0 );
+ TEST_ASSERT(memcmp(buf_orig, buf_dec,
+ mbedtls_rsa_get_len(&ctx)) == 0);
}
}
exit:
- mbedtls_free( buf_orig );
- mbedtls_free( buf_enc );
- mbedtls_free( buf_dec );
+ mbedtls_free(buf_orig);
+ mbedtls_free(buf_enc);
+ mbedtls_free(buf_dec);
- mbedtls_rsa_free( &ctx );
+ mbedtls_rsa_free(&ctx);
- mbedtls_ctr_drbg_free( &ctr_drbg );
- mbedtls_entropy_free( &entropy );
+ mbedtls_ctr_drbg_free(&ctr_drbg);
+ mbedtls_entropy_free(&entropy);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void rsa_selftest( )
+void rsa_selftest()
{
- TEST_ASSERT( mbedtls_rsa_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_rsa_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_shax.function b/tests/suites/test_suite_shax.function
index f3477ec..02c410e 100644
--- a/tests/suites/test_suite_shax.function
+++ b/tests/suites/test_suite_shax.function
@@ -5,46 +5,46 @@
/* END_HEADER */
/* BEGIN_CASE depends_on:MBEDTLS_SHA1_C */
-void sha1_valid_param( )
+void sha1_valid_param()
{
- TEST_VALID_PARAM( mbedtls_sha1_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_sha1_free(NULL));
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA1_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void sha1_invalid_param( )
+void sha1_invalid_param()
{
mbedtls_sha1_context ctx;
unsigned char buf[64] = { 0 };
- size_t const buflen = sizeof( buf );
+ size_t const buflen = sizeof(buf);
- TEST_INVALID_PARAM( mbedtls_sha1_init( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_sha1_init(NULL));
- TEST_INVALID_PARAM( mbedtls_sha1_clone( NULL, &ctx ) );
- TEST_INVALID_PARAM( mbedtls_sha1_clone( &ctx, NULL ) );
+ TEST_INVALID_PARAM(mbedtls_sha1_clone(NULL, &ctx));
+ TEST_INVALID_PARAM(mbedtls_sha1_clone(&ctx, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
- mbedtls_sha1_starts_ret( NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
+ mbedtls_sha1_starts_ret(NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
- mbedtls_sha1_update_ret( NULL, buf, buflen ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
- mbedtls_sha1_update_ret( &ctx, NULL, buflen ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
+ mbedtls_sha1_update_ret(NULL, buf, buflen));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
+ mbedtls_sha1_update_ret(&ctx, NULL, buflen));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
- mbedtls_sha1_finish_ret( NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
- mbedtls_sha1_finish_ret( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
+ mbedtls_sha1_finish_ret(NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
+ mbedtls_sha1_finish_ret(&ctx, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
- mbedtls_internal_sha1_process( NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
- mbedtls_internal_sha1_process( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
+ mbedtls_internal_sha1_process(NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
+ mbedtls_internal_sha1_process(&ctx, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
- mbedtls_sha1_ret( NULL, buflen, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
- mbedtls_sha1_ret( buf, buflen, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
+ mbedtls_sha1_ret(NULL, buflen, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA1_BAD_INPUT_DATA,
+ mbedtls_sha1_ret(buf, buflen, NULL));
exit:
return;
@@ -52,69 +52,69 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA1_C */
-void mbedtls_sha1( data_t * src_str, data_t * hash )
+void mbedtls_sha1(data_t *src_str, data_t *hash)
{
unsigned char output[41];
memset(output, 0x00, 41);
- TEST_ASSERT( mbedtls_sha1_ret( src_str->x, src_str->len, output ) == 0 );
+ TEST_ASSERT(mbedtls_sha1_ret(src_str->x, src_str->len, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x, 20, hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x, 20, hash->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
-void sha256_valid_param( )
+void sha256_valid_param()
{
- TEST_VALID_PARAM( mbedtls_sha256_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_sha256_free(NULL));
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void sha256_invalid_param( )
+void sha256_invalid_param()
{
mbedtls_sha256_context ctx;
unsigned char buf[64] = { 0 };
- size_t const buflen = sizeof( buf );
+ size_t const buflen = sizeof(buf);
int valid_type = 0;
int invalid_type = 42;
- TEST_INVALID_PARAM( mbedtls_sha256_init( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_sha256_init(NULL));
- TEST_INVALID_PARAM( mbedtls_sha256_clone( NULL, &ctx ) );
- TEST_INVALID_PARAM( mbedtls_sha256_clone( &ctx, NULL ) );
+ TEST_INVALID_PARAM(mbedtls_sha256_clone(NULL, &ctx));
+ TEST_INVALID_PARAM(mbedtls_sha256_clone(&ctx, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
- mbedtls_sha256_starts_ret( NULL, valid_type ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
- mbedtls_sha256_starts_ret( &ctx, invalid_type ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
+ mbedtls_sha256_starts_ret(NULL, valid_type));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
+ mbedtls_sha256_starts_ret(&ctx, invalid_type));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
- mbedtls_sha256_update_ret( NULL, buf, buflen ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
- mbedtls_sha256_update_ret( &ctx, NULL, buflen ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
+ mbedtls_sha256_update_ret(NULL, buf, buflen));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
+ mbedtls_sha256_update_ret(&ctx, NULL, buflen));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
- mbedtls_sha256_finish_ret( NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
- mbedtls_sha256_finish_ret( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
+ mbedtls_sha256_finish_ret(NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
+ mbedtls_sha256_finish_ret(&ctx, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
- mbedtls_internal_sha256_process( NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
- mbedtls_internal_sha256_process( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
+ mbedtls_internal_sha256_process(NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
+ mbedtls_internal_sha256_process(&ctx, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
- mbedtls_sha256_ret( NULL, buflen,
- buf, valid_type ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
- mbedtls_sha256_ret( buf, buflen,
- NULL, valid_type ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
- mbedtls_sha256_ret( buf, buflen,
- buf, invalid_type ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
+ mbedtls_sha256_ret(NULL, buflen,
+ buf, valid_type));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
+ mbedtls_sha256_ret(buf, buflen,
+ NULL, valid_type));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA256_BAD_INPUT_DATA,
+ mbedtls_sha256_ret(buf, buflen,
+ buf, invalid_type));
exit:
return;
@@ -122,83 +122,83 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
-void sha224( data_t * src_str, data_t * hash )
+void sha224(data_t *src_str, data_t *hash)
{
unsigned char output[57];
memset(output, 0x00, 57);
- TEST_ASSERT( mbedtls_sha256_ret( src_str->x, src_str->len, output, 1 ) == 0 );
+ TEST_ASSERT(mbedtls_sha256_ret(src_str->x, src_str->len, output, 1) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x, 28, hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x, 28, hash->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C */
-void mbedtls_sha256( data_t * src_str, data_t * hash )
+void mbedtls_sha256(data_t *src_str, data_t *hash)
{
unsigned char output[65];
memset(output, 0x00, 65);
- TEST_ASSERT( mbedtls_sha256_ret( src_str->x, src_str->len, output, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_sha256_ret(src_str->x, src_str->len, output, 0) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x, 32, hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x, 32, hash->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C */
-void sha512_valid_param( )
+void sha512_valid_param()
{
- TEST_VALID_PARAM( mbedtls_sha512_free( NULL ) );
+ TEST_VALID_PARAM(mbedtls_sha512_free(NULL));
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C:MBEDTLS_CHECK_PARAMS:!MBEDTLS_PARAM_FAILED_ALT */
-void sha512_invalid_param( )
+void sha512_invalid_param()
{
mbedtls_sha512_context ctx;
unsigned char buf[64] = { 0 };
- size_t const buflen = sizeof( buf );
+ size_t const buflen = sizeof(buf);
int valid_type = 0;
int invalid_type = 42;
- TEST_INVALID_PARAM( mbedtls_sha512_init( NULL ) );
+ TEST_INVALID_PARAM(mbedtls_sha512_init(NULL));
- TEST_INVALID_PARAM( mbedtls_sha512_clone( NULL, &ctx ) );
- TEST_INVALID_PARAM( mbedtls_sha512_clone( &ctx, NULL ) );
+ TEST_INVALID_PARAM(mbedtls_sha512_clone(NULL, &ctx));
+ TEST_INVALID_PARAM(mbedtls_sha512_clone(&ctx, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
- mbedtls_sha512_starts_ret( NULL, valid_type ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
- mbedtls_sha512_starts_ret( &ctx, invalid_type ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
+ mbedtls_sha512_starts_ret(NULL, valid_type));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
+ mbedtls_sha512_starts_ret(&ctx, invalid_type));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
- mbedtls_sha512_update_ret( NULL, buf, buflen ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
- mbedtls_sha512_update_ret( &ctx, NULL, buflen ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
+ mbedtls_sha512_update_ret(NULL, buf, buflen));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
+ mbedtls_sha512_update_ret(&ctx, NULL, buflen));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
- mbedtls_sha512_finish_ret( NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
- mbedtls_sha512_finish_ret( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
+ mbedtls_sha512_finish_ret(NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
+ mbedtls_sha512_finish_ret(&ctx, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
- mbedtls_internal_sha512_process( NULL, buf ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
- mbedtls_internal_sha512_process( &ctx, NULL ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
+ mbedtls_internal_sha512_process(NULL, buf));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
+ mbedtls_internal_sha512_process(&ctx, NULL));
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
- mbedtls_sha512_ret( NULL, buflen,
- buf, valid_type ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
- mbedtls_sha512_ret( buf, buflen,
- NULL, valid_type ) );
- TEST_INVALID_PARAM_RET( MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
- mbedtls_sha512_ret( buf, buflen,
- buf, invalid_type ) );
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
+ mbedtls_sha512_ret(NULL, buflen,
+ buf, valid_type));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
+ mbedtls_sha512_ret(buf, buflen,
+ NULL, valid_type));
+ TEST_INVALID_PARAM_RET(MBEDTLS_ERR_SHA512_BAD_INPUT_DATA,
+ mbedtls_sha512_ret(buf, buflen,
+ buf, invalid_type));
exit:
return;
@@ -206,50 +206,50 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C */
-void sha384( data_t * src_str, data_t * hash )
+void sha384(data_t *src_str, data_t *hash)
{
unsigned char output[97];
memset(output, 0x00, 97);
- TEST_ASSERT( mbedtls_sha512_ret( src_str->x, src_str->len, output, 1 ) == 0 );
+ TEST_ASSERT(mbedtls_sha512_ret(src_str->x, src_str->len, output, 1) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x, 48, hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x, 48, hash->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C */
-void mbedtls_sha512( data_t * src_str, data_t * hash )
+void mbedtls_sha512(data_t *src_str, data_t *hash)
{
unsigned char output[129];
memset(output, 0x00, 129);
- TEST_ASSERT( mbedtls_sha512_ret( src_str->x, src_str->len, output, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_sha512_ret(src_str->x, src_str->len, output, 0) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, hash->x, 64, hash->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, hash->x, 64, hash->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA1_C:MBEDTLS_SELF_TEST */
-void sha1_selftest( )
+void sha1_selftest()
{
- TEST_ASSERT( mbedtls_sha1_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_sha1_self_test(1) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA256_C:MBEDTLS_SELF_TEST */
-void sha256_selftest( )
+void sha256_selftest()
{
- TEST_ASSERT( mbedtls_sha256_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_sha256_self_test(1) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SHA512_C:MBEDTLS_SELF_TEST */
-void sha512_selftest( )
+void sha512_selftest()
{
- TEST_ASSERT( mbedtls_sha512_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_sha512_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_ssl.function b/tests/suites/test_suite_ssl.function
index 7575f78..5a92820 100644
--- a/tests/suites/test_suite_ssl.function
+++ b/tests/suites/test_suite_ssl.function
@@ -12,16 +12,14 @@
#include <test/constant_flow.h>
-enum
-{
-#define MBEDTLS_SSL_TLS1_3_LABEL( name, string ) \
- tls1_3_label_ ## name,
-MBEDTLS_SSL_TLS1_3_LABEL_LIST
+enum {
+#define MBEDTLS_SSL_TLS1_3_LABEL(name, string) \
+ tls1_3_label_ ## name,
+ MBEDTLS_SSL_TLS1_3_LABEL_LIST
#undef MBEDTLS_SSL_TLS1_3_LABEL
};
-typedef struct log_pattern
-{
+typedef struct log_pattern {
const char *pattern;
size_t counter;
} log_pattern;
@@ -31,9 +29,9 @@
* this case, it will count the instances of a log_pattern in the received
* logged messages.
*/
-void log_analyzer( void *ctx, int level,
- const char *file, int line,
- const char *str )
+void log_analyzer(void *ctx, int level,
+ const char *file, int line,
+ const char *str)
{
log_pattern *p = (log_pattern *) ctx;
@@ -41,10 +39,9 @@
(void) line;
(void) file;
- if( NULL != p &&
+ if (NULL != p &&
NULL != p->pattern &&
- NULL != strstr( str, p->pattern ) )
- {
+ NULL != strstr(str, p->pattern)) {
p->counter++;
}
}
@@ -52,8 +49,7 @@
/* Invalid minor version used when not specifying a min/max version or expecting a test to fail */
#define TEST_SSL_MINOR_VERSION_NONE -1
-typedef struct handshake_test_options
-{
+typedef struct handshake_test_options {
const char *cipher;
int client_min_version;
int client_max_version;
@@ -79,38 +75,37 @@
int resize_buffers;
} handshake_test_options;
-void init_handshake_options( handshake_test_options *opts )
+void init_handshake_options(handshake_test_options *opts)
{
- opts->cipher = "";
- opts->client_min_version = TEST_SSL_MINOR_VERSION_NONE;
- opts->client_max_version = TEST_SSL_MINOR_VERSION_NONE;
- opts->server_min_version = TEST_SSL_MINOR_VERSION_NONE;
- opts->server_max_version = TEST_SSL_MINOR_VERSION_NONE;
- opts->expected_negotiated_version = MBEDTLS_SSL_MINOR_VERSION_3;
- opts->pk_alg = MBEDTLS_PK_RSA;
- opts->psk_str = NULL;
- opts->dtls = 0;
- opts->srv_auth_mode = MBEDTLS_SSL_VERIFY_NONE;
- opts->serialize = 0;
- opts->mfl = MBEDTLS_SSL_MAX_FRAG_LEN_NONE;
- opts->cli_msg_len = 100;
- opts->srv_msg_len = 100;
- opts->expected_cli_fragments = 1;
- opts->expected_srv_fragments = 1;
- opts->renegotiate = 0;
- opts->legacy_renegotiation = MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION;
- opts->srv_log_obj = NULL;
- opts->srv_log_obj = NULL;
- opts->srv_log_fun = NULL;
- opts->cli_log_fun = NULL;
- opts->resize_buffers = 1;
+ opts->cipher = "";
+ opts->client_min_version = TEST_SSL_MINOR_VERSION_NONE;
+ opts->client_max_version = TEST_SSL_MINOR_VERSION_NONE;
+ opts->server_min_version = TEST_SSL_MINOR_VERSION_NONE;
+ opts->server_max_version = TEST_SSL_MINOR_VERSION_NONE;
+ opts->expected_negotiated_version = MBEDTLS_SSL_MINOR_VERSION_3;
+ opts->pk_alg = MBEDTLS_PK_RSA;
+ opts->psk_str = NULL;
+ opts->dtls = 0;
+ opts->srv_auth_mode = MBEDTLS_SSL_VERIFY_NONE;
+ opts->serialize = 0;
+ opts->mfl = MBEDTLS_SSL_MAX_FRAG_LEN_NONE;
+ opts->cli_msg_len = 100;
+ opts->srv_msg_len = 100;
+ opts->expected_cli_fragments = 1;
+ opts->expected_srv_fragments = 1;
+ opts->renegotiate = 0;
+ opts->legacy_renegotiation = MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION;
+ opts->srv_log_obj = NULL;
+ opts->srv_log_obj = NULL;
+ opts->srv_log_fun = NULL;
+ opts->cli_log_fun = NULL;
+ opts->resize_buffers = 1;
}
/*
* Buffer structure for custom I/O callbacks.
*/
-typedef struct mbedtls_test_buffer
-{
+typedef struct mbedtls_test_buffer {
size_t start;
size_t content_length;
size_t capacity;
@@ -121,32 +116,34 @@
* Initialises \p buf. After calling this function it is safe to call
* `mbedtls_test_buffer_free()` on \p buf.
*/
-void mbedtls_test_buffer_init( mbedtls_test_buffer *buf )
+void mbedtls_test_buffer_init(mbedtls_test_buffer *buf)
{
- memset( buf, 0, sizeof( *buf ) );
+ memset(buf, 0, sizeof(*buf));
}
/*
* Sets up \p buf. After calling this function it is safe to call
* `mbedtls_test_buffer_put()` and `mbedtls_test_buffer_get()` on \p buf.
*/
-int mbedtls_test_buffer_setup( mbedtls_test_buffer *buf, size_t capacity )
+int mbedtls_test_buffer_setup(mbedtls_test_buffer *buf, size_t capacity)
{
- buf->buffer = (unsigned char*) mbedtls_calloc( capacity,
- sizeof( unsigned char ) );
- if( NULL == buf->buffer )
+ buf->buffer = (unsigned char *) mbedtls_calloc(capacity,
+ sizeof(unsigned char));
+ if (NULL == buf->buffer) {
return MBEDTLS_ERR_SSL_ALLOC_FAILED;
+ }
buf->capacity = capacity;
return 0;
}
-void mbedtls_test_buffer_free( mbedtls_test_buffer *buf )
+void mbedtls_test_buffer_free(mbedtls_test_buffer *buf)
{
- if( buf->buffer != NULL )
- mbedtls_free( buf->buffer );
+ if (buf->buffer != NULL) {
+ mbedtls_free(buf->buffer);
+ }
- memset( buf, 0, sizeof( *buf ) );
+ memset(buf, 0, sizeof(*buf));
}
/*
@@ -160,49 +157,44 @@
* \retval -1, if \p buf is NULL, it hasn't been set up or \p input_len is not
* zero and \p input is NULL.
*/
-int mbedtls_test_buffer_put( mbedtls_test_buffer *buf,
- const unsigned char *input, size_t input_len )
+int mbedtls_test_buffer_put(mbedtls_test_buffer *buf,
+ const unsigned char *input, size_t input_len)
{
size_t overflow = 0;
- if( ( buf == NULL ) || ( buf->buffer == NULL ) )
+ if ((buf == NULL) || (buf->buffer == NULL)) {
return -1;
+ }
/* Reduce input_len to a number that fits in the buffer. */
- if ( ( buf->content_length + input_len ) > buf->capacity )
- {
+ if ((buf->content_length + input_len) > buf->capacity) {
input_len = buf->capacity - buf->content_length;
}
- if( input == NULL )
- {
- return ( input_len == 0 ) ? 0 : -1;
+ if (input == NULL) {
+ return (input_len == 0) ? 0 : -1;
}
- /* Check if the buffer has not come full circle and free space is not in
- * the middle */
- if( buf->start + buf->content_length < buf->capacity )
- {
+ /* Check if the buffer has not come full circle and free space is not in
+ * the middle */
+ if (buf->start + buf->content_length < buf->capacity) {
/* Calculate the number of bytes that need to be placed at lower memory
- * address */
- if( buf->start + buf->content_length + input_len
- > buf->capacity )
- {
- overflow = ( buf->start + buf->content_length + input_len )
- % buf->capacity;
+ * address */
+ if (buf->start + buf->content_length + input_len
+ > buf->capacity) {
+ overflow = (buf->start + buf->content_length + input_len)
+ % buf->capacity;
}
- memcpy( buf->buffer + buf->start + buf->content_length, input,
- input_len - overflow );
- memcpy( buf->buffer, input + input_len - overflow, overflow );
+ memcpy(buf->buffer + buf->start + buf->content_length, input,
+ input_len - overflow);
+ memcpy(buf->buffer, input + input_len - overflow, overflow);
- }
- else
- {
+ } else {
/* The buffer has come full circle and free space is in the middle */
- memcpy( buf->buffer + buf->start + buf->content_length - buf->capacity,
- input, input_len );
+ memcpy(buf->buffer + buf->start + buf->content_length - buf->capacity,
+ input, input_len);
}
buf->content_length += input_len;
@@ -221,35 +213,36 @@
* \retval 0 <= value < \p output_len, if the data is not available.
* \retval -1, if \buf is NULL or it hasn't been set up.
*/
-int mbedtls_test_buffer_get( mbedtls_test_buffer *buf,
- unsigned char* output, size_t output_len )
+int mbedtls_test_buffer_get(mbedtls_test_buffer *buf,
+ unsigned char *output, size_t output_len)
{
size_t overflow = 0;
- if( ( buf == NULL ) || ( buf->buffer == NULL ) )
+ if ((buf == NULL) || (buf->buffer == NULL)) {
return -1;
+ }
- if( output == NULL && output_len == 0 )
+ if (output == NULL && output_len == 0) {
return 0;
+ }
- if( buf->content_length < output_len )
+ if (buf->content_length < output_len) {
output_len = buf->content_length;
+ }
/* Calculate the number of bytes that need to be drawn from lower memory
* address */
- if( buf->start + output_len > buf->capacity )
- {
- overflow = ( buf->start + output_len ) % buf->capacity;
+ if (buf->start + output_len > buf->capacity) {
+ overflow = (buf->start + output_len) % buf->capacity;
}
- if( output != NULL )
- {
- memcpy( output, buf->buffer + buf->start, output_len - overflow );
- memcpy( output + output_len - overflow, buf->buffer, overflow );
+ if (output != NULL) {
+ memcpy(output, buf->buffer + buf->start, output_len - overflow);
+ memcpy(output + output_len - overflow, buf->buffer, overflow);
}
buf->content_length -= output_len;
- buf->start = ( buf->start + output_len ) % buf->capacity;
+ buf->start = (buf->start + output_len) % buf->capacity;
return output_len;
}
@@ -263,8 +256,7 @@
/*
* Context for a message metadata queue (fifo) that is on top of the ring buffer.
*/
-typedef struct mbedtls_test_message_queue
-{
+typedef struct mbedtls_test_message_queue {
size_t *messages;
int pos;
int num;
@@ -280,12 +272,13 @@
* \retval 0, if a metadata queue of a given length can be allocated.
* \retval MBEDTLS_ERR_SSL_ALLOC_FAILED, if allocation failed.
*/
-int mbedtls_test_message_queue_setup( mbedtls_test_message_queue *queue,
- size_t capacity )
+int mbedtls_test_message_queue_setup(mbedtls_test_message_queue *queue,
+ size_t capacity)
{
- queue->messages = (size_t*) mbedtls_calloc( capacity, sizeof( size_t ) );
- if( NULL == queue->messages )
+ queue->messages = (size_t *) mbedtls_calloc(capacity, sizeof(size_t));
+ if (NULL == queue->messages) {
return MBEDTLS_ERR_SSL_ALLOC_FAILED;
+ }
queue->capacity = capacity;
queue->pos = 0;
@@ -294,15 +287,17 @@
return 0;
}
-void mbedtls_test_message_queue_free( mbedtls_test_message_queue *queue )
+void mbedtls_test_message_queue_free(mbedtls_test_message_queue *queue)
{
- if( queue == NULL )
+ if (queue == NULL) {
return;
+ }
- if( queue->messages != NULL )
- mbedtls_free( queue->messages );
+ if (queue->messages != NULL) {
+ mbedtls_free(queue->messages);
+ }
- memset( queue, 0, sizeof( *queue ) );
+ memset(queue, 0, sizeof(*queue));
}
/*
@@ -313,17 +308,19 @@
* \retval MBEDTLS_ERR_SSL_WANT_WRITE, if the queue is full.
* \retval \p len, if the push was successful.
*/
-int mbedtls_test_message_queue_push_info( mbedtls_test_message_queue *queue,
- size_t len )
+int mbedtls_test_message_queue_push_info(mbedtls_test_message_queue *queue,
+ size_t len)
{
int place;
- if( queue == NULL )
+ if (queue == NULL) {
return MBEDTLS_TEST_ERROR_ARG_NULL;
+ }
- if( queue->num >= queue->capacity )
+ if (queue->num >= queue->capacity) {
return MBEDTLS_ERR_SSL_WANT_WRITE;
+ }
- place = ( queue->pos + queue->num ) % queue->capacity;
+ place = (queue->pos + queue->num) % queue->capacity;
queue->messages[place] = len;
queue->num++;
return len;
@@ -339,24 +336,27 @@
* \retval message length, if the pop was successful, up to the given
\p buf_len.
*/
-int mbedtls_test_message_queue_pop_info( mbedtls_test_message_queue *queue,
- size_t buf_len )
+int mbedtls_test_message_queue_pop_info(mbedtls_test_message_queue *queue,
+ size_t buf_len)
{
size_t message_length;
- if( queue == NULL )
+ if (queue == NULL) {
return MBEDTLS_TEST_ERROR_ARG_NULL;
- if( queue->num == 0 )
+ }
+ if (queue->num == 0) {
return MBEDTLS_ERR_SSL_WANT_READ;
+ }
message_length = queue->messages[queue->pos];
queue->messages[queue->pos] = 0;
queue->num--;
queue->pos++;
queue->pos %= queue->capacity;
- if( queue->pos < 0 )
+ if (queue->pos < 0) {
queue->pos += queue->capacity;
+ }
- return ( message_length > buf_len ) ? buf_len : message_length;
+ return (message_length > buf_len) ? buf_len : message_length;
}
/*
@@ -371,16 +371,18 @@
* set to the full message length so that the
* caller knows what portion of the message can be dropped.
*/
-int mbedtls_test_message_queue_peek_info( mbedtls_test_message_queue *queue,
- size_t buf_len, size_t* msg_len )
+int mbedtls_test_message_queue_peek_info(mbedtls_test_message_queue *queue,
+ size_t buf_len, size_t *msg_len)
{
- if( queue == NULL || msg_len == NULL )
+ if (queue == NULL || msg_len == NULL) {
return MBEDTLS_TEST_ERROR_ARG_NULL;
- if( queue->num == 0 )
+ }
+ if (queue->num == 0) {
return MBEDTLS_ERR_SSL_WANT_READ;
+ }
*msg_len = queue->messages[queue->pos];
- return ( *msg_len > buf_len ) ? MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED : 0;
+ return (*msg_len > buf_len) ? MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED : 0;
}
/*
* Context for the I/O callbacks simulating network connection.
@@ -388,8 +390,7 @@
#define MBEDTLS_MOCK_SOCKET_CONNECTED 1
-typedef struct mbedtls_mock_socket
-{
+typedef struct mbedtls_mock_socket {
int status;
mbedtls_test_buffer *input;
mbedtls_test_buffer *output;
@@ -399,9 +400,9 @@
/*
* Setup and teardown functions for mock sockets.
*/
-void mbedtls_mock_socket_init( mbedtls_mock_socket *socket )
+void mbedtls_mock_socket_init(mbedtls_mock_socket *socket)
{
- memset( socket, 0, sizeof( *socket ) );
+ memset(socket, 0, sizeof(*socket));
}
/*
@@ -417,27 +418,27 @@
* phenomenon that when closing a UDP connection the peer is not aware of the
* connection having been closed.
*/
-void mbedtls_mock_socket_close( mbedtls_mock_socket* socket )
+void mbedtls_mock_socket_close(mbedtls_mock_socket *socket)
{
- if( socket == NULL )
+ if (socket == NULL) {
return;
-
- if( socket->input != NULL )
- {
- mbedtls_test_buffer_free( socket->input );
- mbedtls_free( socket->input );
}
- if( socket->output != NULL )
- {
- mbedtls_test_buffer_free( socket->output );
- mbedtls_free( socket->output );
+ if (socket->input != NULL) {
+ mbedtls_test_buffer_free(socket->input);
+ mbedtls_free(socket->input);
}
- if( socket->peer != NULL )
- memset( socket->peer, 0, sizeof( *socket->peer ) );
+ if (socket->output != NULL) {
+ mbedtls_test_buffer_free(socket->output);
+ mbedtls_free(socket->output);
+ }
- memset( socket, 0, sizeof( *socket ) );
+ if (socket->peer != NULL) {
+ memset(socket->peer, 0, sizeof(*socket->peer));
+ }
+
+ memset(socket, 0, sizeof(*socket));
}
/*
@@ -450,35 +451,31 @@
* the correct value allows for simulation of MTU, sanity testing the mock
* implementation and mocking TCP connections with lower memory cost.
*/
-int mbedtls_mock_socket_connect( mbedtls_mock_socket* peer1,
- mbedtls_mock_socket* peer2,
- size_t bufsize )
+int mbedtls_mock_socket_connect(mbedtls_mock_socket *peer1,
+ mbedtls_mock_socket *peer2,
+ size_t bufsize)
{
int ret = -1;
peer1->output =
- (mbedtls_test_buffer*) mbedtls_calloc( 1, sizeof( mbedtls_test_buffer ) );
- if( peer1->output == NULL )
- {
+ (mbedtls_test_buffer *) mbedtls_calloc(1, sizeof(mbedtls_test_buffer));
+ if (peer1->output == NULL) {
ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
goto exit;
}
- mbedtls_test_buffer_init( peer1->output );
- if( 0 != ( ret = mbedtls_test_buffer_setup( peer1->output, bufsize ) ) )
- {
+ mbedtls_test_buffer_init(peer1->output);
+ if (0 != (ret = mbedtls_test_buffer_setup(peer1->output, bufsize))) {
goto exit;
}
peer2->output =
- (mbedtls_test_buffer*) mbedtls_calloc( 1, sizeof( mbedtls_test_buffer) );
- if( peer2->output == NULL )
- {
+ (mbedtls_test_buffer *) mbedtls_calloc(1, sizeof(mbedtls_test_buffer));
+ if (peer2->output == NULL) {
ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
goto exit;
}
- mbedtls_test_buffer_init( peer2->output );
- if( 0 != ( ret = mbedtls_test_buffer_setup( peer2->output, bufsize ) ) )
- {
+ mbedtls_test_buffer_init(peer2->output);
+ if (0 != (ret = mbedtls_test_buffer_setup(peer2->output, bufsize))) {
goto exit;
}
@@ -492,10 +489,9 @@
exit:
- if( ret != 0 )
- {
- mbedtls_mock_socket_close( peer1 );
- mbedtls_mock_socket_close( peer2 );
+ if (ret != 0) {
+ mbedtls_mock_socket_close(peer1);
+ mbedtls_mock_socket_close(peer2);
}
return ret;
@@ -505,58 +501,60 @@
* Callbacks for simulating blocking I/O over connection-oriented transport.
*/
-int mbedtls_mock_tcp_send_b( void *ctx, const unsigned char *buf, size_t len )
+int mbedtls_mock_tcp_send_b(void *ctx, const unsigned char *buf, size_t len)
{
- mbedtls_mock_socket *socket = (mbedtls_mock_socket*) ctx;
+ mbedtls_mock_socket *socket = (mbedtls_mock_socket *) ctx;
- if( socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED )
+ if (socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED) {
return -1;
+ }
- return mbedtls_test_buffer_put( socket->output, buf, len );
+ return mbedtls_test_buffer_put(socket->output, buf, len);
}
-int mbedtls_mock_tcp_recv_b( void *ctx, unsigned char *buf, size_t len )
+int mbedtls_mock_tcp_recv_b(void *ctx, unsigned char *buf, size_t len)
{
- mbedtls_mock_socket *socket = (mbedtls_mock_socket*) ctx;
+ mbedtls_mock_socket *socket = (mbedtls_mock_socket *) ctx;
- if( socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED )
+ if (socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED) {
return -1;
+ }
- return mbedtls_test_buffer_get( socket->input, buf, len );
+ return mbedtls_test_buffer_get(socket->input, buf, len);
}
/*
* Callbacks for simulating non-blocking I/O over connection-oriented transport.
*/
-int mbedtls_mock_tcp_send_nb( void *ctx, const unsigned char *buf, size_t len )
+int mbedtls_mock_tcp_send_nb(void *ctx, const unsigned char *buf, size_t len)
{
- mbedtls_mock_socket *socket = (mbedtls_mock_socket*) ctx;
+ mbedtls_mock_socket *socket = (mbedtls_mock_socket *) ctx;
- if( socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED )
+ if (socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED) {
return -1;
+ }
- if( socket->output->capacity == socket->output->content_length )
- {
+ if (socket->output->capacity == socket->output->content_length) {
return MBEDTLS_ERR_SSL_WANT_WRITE;
}
- return mbedtls_test_buffer_put( socket->output, buf, len );
+ return mbedtls_test_buffer_put(socket->output, buf, len);
}
-int mbedtls_mock_tcp_recv_nb( void *ctx, unsigned char *buf, size_t len )
+int mbedtls_mock_tcp_recv_nb(void *ctx, unsigned char *buf, size_t len)
{
- mbedtls_mock_socket *socket = (mbedtls_mock_socket*) ctx;
+ mbedtls_mock_socket *socket = (mbedtls_mock_socket *) ctx;
- if( socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED )
+ if (socket == NULL || socket->status != MBEDTLS_MOCK_SOCKET_CONNECTED) {
return -1;
+ }
- if( socket->input->content_length == 0 )
- {
+ if (socket->input->content_length == 0) {
return MBEDTLS_ERR_SSL_WANT_READ;
}
- return mbedtls_test_buffer_get( socket->input, buf, len );
+ return mbedtls_test_buffer_get(socket->input, buf, len);
}
/* Errors used in the message socket mocks */
@@ -572,14 +570,13 @@
* considered as an owner of the input queue only, which is initialized and
* freed in the respective setup and free calls.
*/
-typedef struct mbedtls_test_message_socket_context
-{
- mbedtls_test_message_queue* queue_input;
- mbedtls_test_message_queue* queue_output;
- mbedtls_mock_socket* socket;
+typedef struct mbedtls_test_message_socket_context {
+ mbedtls_test_message_queue *queue_input;
+ mbedtls_test_message_queue *queue_output;
+ mbedtls_mock_socket *socket;
} mbedtls_test_message_socket_context;
-void mbedtls_message_socket_init( mbedtls_test_message_socket_context *ctx )
+void mbedtls_message_socket_init(mbedtls_test_message_socket_context *ctx)
{
ctx->queue_input = NULL;
ctx->queue_output = NULL;
@@ -595,19 +592,20 @@
* \retval MBEDTLS_ERR_SSL_ALLOC_FAILED, if allocation of a message
* queue failed.
*/
-int mbedtls_message_socket_setup( mbedtls_test_message_queue* queue_input,
- mbedtls_test_message_queue* queue_output,
- size_t queue_capacity,
- mbedtls_mock_socket* socket,
- mbedtls_test_message_socket_context* ctx )
+int mbedtls_message_socket_setup(mbedtls_test_message_queue *queue_input,
+ mbedtls_test_message_queue *queue_output,
+ size_t queue_capacity,
+ mbedtls_mock_socket *socket,
+ mbedtls_test_message_socket_context *ctx)
{
- int ret = mbedtls_test_message_queue_setup( queue_input, queue_capacity );
- if( ret != 0 )
+ int ret = mbedtls_test_message_queue_setup(queue_input, queue_capacity);
+ if (ret != 0) {
return ret;
+ }
ctx->queue_input = queue_input;
ctx->queue_output = queue_output;
ctx->socket = socket;
- mbedtls_mock_socket_init( socket );
+ mbedtls_mock_socket_init(socket);
return 0;
}
@@ -616,14 +614,15 @@
* Close a given message socket context, along with the socket itself. Free the
* memory allocated by the input queue.
*/
-void mbedtls_message_socket_close( mbedtls_test_message_socket_context* ctx )
+void mbedtls_message_socket_close(mbedtls_test_message_socket_context *ctx)
{
- if( ctx == NULL )
+ if (ctx == NULL) {
return;
+ }
- mbedtls_test_message_queue_free( ctx->queue_input );
- mbedtls_mock_socket_close( ctx->socket );
- memset( ctx, 0, sizeof( *ctx ) );
+ mbedtls_test_message_queue_free(ctx->queue_input);
+ mbedtls_mock_socket_close(ctx->socket);
+ memset(ctx, 0, sizeof(*ctx));
}
/*
@@ -638,28 +637,29 @@
* This function will also return any error from
* mbedtls_test_message_queue_push_info.
*/
-int mbedtls_mock_tcp_send_msg( void *ctx, const unsigned char *buf, size_t len )
+int mbedtls_mock_tcp_send_msg(void *ctx, const unsigned char *buf, size_t len)
{
- mbedtls_test_message_queue* queue;
- mbedtls_mock_socket* socket;
- mbedtls_test_message_socket_context *context = (mbedtls_test_message_socket_context*) ctx;
+ mbedtls_test_message_queue *queue;
+ mbedtls_mock_socket *socket;
+ mbedtls_test_message_socket_context *context = (mbedtls_test_message_socket_context *) ctx;
- if( context == NULL || context->socket == NULL
- || context->queue_output == NULL )
- {
+ if (context == NULL || context->socket == NULL
+ || context->queue_output == NULL) {
return MBEDTLS_TEST_ERROR_CONTEXT_ERROR;
}
queue = context->queue_output;
socket = context->socket;
- if( queue->num >= queue->capacity )
+ if (queue->num >= queue->capacity) {
return MBEDTLS_ERR_SSL_WANT_WRITE;
+ }
- if( mbedtls_mock_tcp_send_b( socket, buf, len ) != (int) len )
+ if (mbedtls_mock_tcp_send_b(socket, buf, len) != (int) len) {
return MBEDTLS_TEST_ERROR_SEND_FAILED;
+ }
- return mbedtls_test_message_queue_push_info( queue, len );
+ return mbedtls_test_message_queue_push_info(queue, len);
}
/*
@@ -674,18 +674,17 @@
* This function will also return any error other than
* MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED from mbedtls_test_message_queue_peek_info.
*/
-int mbedtls_mock_tcp_recv_msg( void *ctx, unsigned char *buf, size_t buf_len )
+int mbedtls_mock_tcp_recv_msg(void *ctx, unsigned char *buf, size_t buf_len)
{
- mbedtls_test_message_queue* queue;
- mbedtls_mock_socket* socket;
- mbedtls_test_message_socket_context *context = (mbedtls_test_message_socket_context*) ctx;
+ mbedtls_test_message_queue *queue;
+ mbedtls_mock_socket *socket;
+ mbedtls_test_message_socket_context *context = (mbedtls_test_message_socket_context *) ctx;
size_t drop_len = 0;
size_t msg_len;
int ret;
- if( context == NULL || context->socket == NULL
- || context->queue_input == NULL )
- {
+ if (context == NULL || context->socket == NULL
+ || context->queue_input == NULL) {
return MBEDTLS_TEST_ERROR_CONTEXT_ERROR;
}
@@ -694,33 +693,30 @@
/* Peek first, so that in case of a socket error the data remains in
* the queue. */
- ret = mbedtls_test_message_queue_peek_info( queue, buf_len, &msg_len );
- if( ret == MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED )
- {
+ ret = mbedtls_test_message_queue_peek_info(queue, buf_len, &msg_len);
+ if (ret == MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED) {
/* Calculate how much to drop */
drop_len = msg_len - buf_len;
/* Set the requested message len to be buffer length */
msg_len = buf_len;
- } else if( ret != 0 )
- {
+ } else if (ret != 0) {
return ret;
}
- if( mbedtls_mock_tcp_recv_b( socket, buf, msg_len ) != (int) msg_len )
+ if (mbedtls_mock_tcp_recv_b(socket, buf, msg_len) != (int) msg_len) {
return MBEDTLS_TEST_ERROR_RECV_FAILED;
+ }
- if( ret == MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED )
- {
+ if (ret == MBEDTLS_TEST_ERROR_MESSAGE_TRUNCATED) {
/* Drop the remaining part of the message */
- if( mbedtls_mock_tcp_recv_b( socket, NULL, drop_len ) != (int) drop_len )
- {
- /* Inconsistent state - part of the message was read,
- * and a part couldn't. Not much we can do here, but it should not
- * happen in test environment, unless forced manually. */
+ if (mbedtls_mock_tcp_recv_b(socket, NULL, drop_len) != (int) drop_len) {
+ /* Inconsistent state - part of the message was read,
+ * and a part couldn't. Not much we can do here, but it should not
+ * happen in test environment, unless forced manually. */
}
}
- mbedtls_test_message_queue_pop_info( queue, buf_len );
+ mbedtls_test_message_queue_pop_info(queue, buf_len);
return msg_len;
}
@@ -732,18 +728,16 @@
/*
* Structure with endpoint's certificates for SSL communication tests.
*/
-typedef struct mbedtls_endpoint_certificate
-{
- mbedtls_x509_crt* ca_cert;
- mbedtls_x509_crt* cert;
- mbedtls_pk_context* pkey;
+typedef struct mbedtls_endpoint_certificate {
+ mbedtls_x509_crt *ca_cert;
+ mbedtls_x509_crt *cert;
+ mbedtls_pk_context *pkey;
} mbedtls_endpoint_certificate;
/*
* Endpoint structure for SSL communication tests.
*/
-typedef struct mbedtls_endpoint
-{
+typedef struct mbedtls_endpoint {
const char *name;
mbedtls_ssl_context ssl;
mbedtls_ssl_config conf;
@@ -756,34 +750,29 @@
/*
* Deinitializes certificates from endpoint represented by \p ep.
*/
-void mbedtls_endpoint_certificate_free( mbedtls_endpoint *ep )
+void mbedtls_endpoint_certificate_free(mbedtls_endpoint *ep)
{
- mbedtls_endpoint_certificate *cert = &( ep->cert );
- if( cert != NULL )
- {
- if( cert->ca_cert != NULL )
- {
- mbedtls_x509_crt_free( cert->ca_cert );
- mbedtls_free( cert->ca_cert );
+ mbedtls_endpoint_certificate *cert = &(ep->cert);
+ if (cert != NULL) {
+ if (cert->ca_cert != NULL) {
+ mbedtls_x509_crt_free(cert->ca_cert);
+ mbedtls_free(cert->ca_cert);
cert->ca_cert = NULL;
}
- if( cert->cert != NULL )
- {
- mbedtls_x509_crt_free( cert->cert );
- mbedtls_free( cert->cert );
+ if (cert->cert != NULL) {
+ mbedtls_x509_crt_free(cert->cert);
+ mbedtls_free(cert->cert);
cert->cert = NULL;
}
- if( cert->pkey != NULL )
- {
+ if (cert->pkey != NULL) {
#if defined(MBEDTLS_USE_PSA_CRYPTO)
- if( mbedtls_pk_get_type( cert->pkey ) == MBEDTLS_PK_OPAQUE )
- {
+ if (mbedtls_pk_get_type(cert->pkey) == MBEDTLS_PK_OPAQUE) {
mbedtls_svc_key_id_t *key_slot = cert->pkey->pk_ctx;
- psa_destroy_key( *key_slot );
+ psa_destroy_key(*key_slot);
}
#endif
- mbedtls_pk_free( cert->pkey );
- mbedtls_free( cert->pkey );
+ mbedtls_pk_free(cert->pkey);
+ mbedtls_free(cert->pkey);
cert->pkey = NULL;
}
}
@@ -795,103 +784,91 @@
*
* \retval 0 on success, otherwise error code.
*/
-int mbedtls_endpoint_certificate_init( mbedtls_endpoint *ep, int pk_alg )
+int mbedtls_endpoint_certificate_init(mbedtls_endpoint *ep, int pk_alg)
{
int i = 0;
int ret = -1;
mbedtls_endpoint_certificate *cert = NULL;
- if( ep == NULL )
- {
+ if (ep == NULL) {
return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
}
- cert = &( ep->cert );
- ASSERT_ALLOC( cert->ca_cert, 1 );
- ASSERT_ALLOC( cert->cert, 1 );
- ASSERT_ALLOC( cert->pkey, 1 );
+ cert = &(ep->cert);
+ ASSERT_ALLOC(cert->ca_cert, 1);
+ ASSERT_ALLOC(cert->cert, 1);
+ ASSERT_ALLOC(cert->pkey, 1);
- mbedtls_x509_crt_init( cert->ca_cert );
- mbedtls_x509_crt_init( cert->cert );
- mbedtls_pk_init( cert->pkey );
+ mbedtls_x509_crt_init(cert->ca_cert);
+ mbedtls_x509_crt_init(cert->cert);
+ mbedtls_pk_init(cert->pkey);
/* Load the trusted CA */
- for( i = 0; mbedtls_test_cas_der[i] != NULL; i++ )
- {
- ret = mbedtls_x509_crt_parse_der( cert->ca_cert,
- (const unsigned char *) mbedtls_test_cas_der[i],
- mbedtls_test_cas_der_len[i] );
- TEST_ASSERT( ret == 0 );
+ for (i = 0; mbedtls_test_cas_der[i] != NULL; i++) {
+ ret = mbedtls_x509_crt_parse_der(cert->ca_cert,
+ (const unsigned char *) mbedtls_test_cas_der[i],
+ mbedtls_test_cas_der_len[i]);
+ TEST_ASSERT(ret == 0);
}
/* Load own certificate and private key */
- if( ep->conf.endpoint == MBEDTLS_SSL_IS_SERVER )
- {
- if( pk_alg == MBEDTLS_PK_RSA )
- {
- ret = mbedtls_x509_crt_parse( cert->cert,
- (const unsigned char*) mbedtls_test_srv_crt_rsa_sha256_der,
- mbedtls_test_srv_crt_rsa_sha256_der_len );
- TEST_ASSERT( ret == 0 );
+ if (ep->conf.endpoint == MBEDTLS_SSL_IS_SERVER) {
+ if (pk_alg == MBEDTLS_PK_RSA) {
+ ret = mbedtls_x509_crt_parse(cert->cert,
+ (const unsigned char *) mbedtls_test_srv_crt_rsa_sha256_der,
+ mbedtls_test_srv_crt_rsa_sha256_der_len);
+ TEST_ASSERT(ret == 0);
- ret = mbedtls_pk_parse_key( cert->pkey,
- (const unsigned char*) mbedtls_test_srv_key_rsa_der,
- mbedtls_test_srv_key_rsa_der_len, NULL, 0 );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_pk_parse_key(cert->pkey,
+ (const unsigned char *) mbedtls_test_srv_key_rsa_der,
+ mbedtls_test_srv_key_rsa_der_len, NULL, 0);
+ TEST_ASSERT(ret == 0);
+ } else {
+ ret = mbedtls_x509_crt_parse(cert->cert,
+ (const unsigned char *) mbedtls_test_srv_crt_ec_der,
+ mbedtls_test_srv_crt_ec_der_len);
+ TEST_ASSERT(ret == 0);
+
+ ret = mbedtls_pk_parse_key(cert->pkey,
+ (const unsigned char *) mbedtls_test_srv_key_ec_der,
+ mbedtls_test_srv_key_ec_der_len, NULL, 0);
+ TEST_ASSERT(ret == 0);
}
- else
- {
- ret = mbedtls_x509_crt_parse( cert->cert,
- (const unsigned char*) mbedtls_test_srv_crt_ec_der,
- mbedtls_test_srv_crt_ec_der_len );
- TEST_ASSERT( ret == 0 );
+ } else {
+ if (pk_alg == MBEDTLS_PK_RSA) {
+ ret = mbedtls_x509_crt_parse(cert->cert,
+ (const unsigned char *) mbedtls_test_cli_crt_rsa_der,
+ mbedtls_test_cli_crt_rsa_der_len);
+ TEST_ASSERT(ret == 0);
- ret = mbedtls_pk_parse_key( cert->pkey,
- (const unsigned char*) mbedtls_test_srv_key_ec_der,
- mbedtls_test_srv_key_ec_der_len, NULL, 0 );
- TEST_ASSERT( ret == 0 );
- }
- }
- else
- {
- if( pk_alg == MBEDTLS_PK_RSA )
- {
- ret = mbedtls_x509_crt_parse( cert->cert,
- (const unsigned char *) mbedtls_test_cli_crt_rsa_der,
- mbedtls_test_cli_crt_rsa_der_len );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_pk_parse_key(cert->pkey,
+ (const unsigned char *) mbedtls_test_cli_key_rsa_der,
+ mbedtls_test_cli_key_rsa_der_len, NULL, 0);
+ TEST_ASSERT(ret == 0);
+ } else {
+ ret = mbedtls_x509_crt_parse(cert->cert,
+ (const unsigned char *) mbedtls_test_cli_crt_ec_der,
+ mbedtls_test_cli_crt_ec_len);
+ TEST_ASSERT(ret == 0);
- ret = mbedtls_pk_parse_key( cert->pkey,
- (const unsigned char *) mbedtls_test_cli_key_rsa_der,
- mbedtls_test_cli_key_rsa_der_len, NULL, 0 );
- TEST_ASSERT( ret == 0 );
- }
- else
- {
- ret = mbedtls_x509_crt_parse( cert->cert,
- (const unsigned char *) mbedtls_test_cli_crt_ec_der,
- mbedtls_test_cli_crt_ec_len );
- TEST_ASSERT( ret == 0 );
-
- ret = mbedtls_pk_parse_key( cert->pkey,
- (const unsigned char *) mbedtls_test_cli_key_ec_der,
- mbedtls_test_cli_key_ec_der_len, NULL, 0 );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_pk_parse_key(cert->pkey,
+ (const unsigned char *) mbedtls_test_cli_key_ec_der,
+ mbedtls_test_cli_key_ec_der_len, NULL, 0);
+ TEST_ASSERT(ret == 0);
}
}
- mbedtls_ssl_conf_ca_chain( &( ep->conf ), cert->ca_cert, NULL );
+ mbedtls_ssl_conf_ca_chain(&(ep->conf), cert->ca_cert, NULL);
- ret = mbedtls_ssl_conf_own_cert( &( ep->conf ), cert->cert,
- cert->pkey );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_ssl_conf_own_cert(&(ep->conf), cert->cert,
+ cert->pkey);
+ TEST_ASSERT(ret == 0);
exit:
- if( ret != 0 )
- {
- mbedtls_endpoint_certificate_free( ep );
+ if (ret != 0) {
+ mbedtls_endpoint_certificate_free(ep);
}
return ret;
@@ -911,87 +888,85 @@
*
* \retval 0 on success, otherwise error code.
*/
-int mbedtls_endpoint_init( mbedtls_endpoint *ep, int endpoint_type, int pk_alg,
- mbedtls_test_message_socket_context *dtls_context,
- mbedtls_test_message_queue *input_queue,
- mbedtls_test_message_queue *output_queue,
- const mbedtls_ecp_group_id *curves )
+int mbedtls_endpoint_init(mbedtls_endpoint *ep, int endpoint_type, int pk_alg,
+ mbedtls_test_message_socket_context *dtls_context,
+ mbedtls_test_message_queue *input_queue,
+ mbedtls_test_message_queue *output_queue,
+ const mbedtls_ecp_group_id *curves)
{
int ret = -1;
- if( dtls_context != NULL && ( input_queue == NULL || output_queue == NULL ) )
+ if (dtls_context != NULL && (input_queue == NULL || output_queue == NULL)) {
return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
-
- if( ep == NULL )
- return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
-
- memset( ep, 0, sizeof( *ep ) );
-
- ep->name = ( endpoint_type == MBEDTLS_SSL_IS_SERVER ) ? "Server" : "Client";
-
- mbedtls_ssl_init( &( ep->ssl ) );
- mbedtls_ssl_config_init( &( ep->conf ) );
- mbedtls_ctr_drbg_init( &( ep->ctr_drbg ) );
- mbedtls_ssl_conf_rng( &( ep->conf ),
- mbedtls_ctr_drbg_random,
- &( ep->ctr_drbg ) );
- mbedtls_entropy_init( &( ep->entropy ) );
- if( dtls_context != NULL )
- {
- TEST_ASSERT( mbedtls_message_socket_setup( input_queue, output_queue,
- 100, &( ep->socket ),
- dtls_context ) == 0 );
- }
- else
- {
- mbedtls_mock_socket_init( &( ep->socket ) );
}
- ret = mbedtls_ctr_drbg_seed( &( ep->ctr_drbg ), mbedtls_entropy_func,
- &( ep->entropy ), (const unsigned char *) ( ep->name ),
- strlen( ep->name ) );
- TEST_ASSERT( ret == 0 );
+ if (ep == NULL) {
+ return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
+ }
+
+ memset(ep, 0, sizeof(*ep));
+
+ ep->name = (endpoint_type == MBEDTLS_SSL_IS_SERVER) ? "Server" : "Client";
+
+ mbedtls_ssl_init(&(ep->ssl));
+ mbedtls_ssl_config_init(&(ep->conf));
+ mbedtls_ctr_drbg_init(&(ep->ctr_drbg));
+ mbedtls_ssl_conf_rng(&(ep->conf),
+ mbedtls_ctr_drbg_random,
+ &(ep->ctr_drbg));
+ mbedtls_entropy_init(&(ep->entropy));
+ if (dtls_context != NULL) {
+ TEST_ASSERT(mbedtls_message_socket_setup(input_queue, output_queue,
+ 100, &(ep->socket),
+ dtls_context) == 0);
+ } else {
+ mbedtls_mock_socket_init(&(ep->socket));
+ }
+
+ ret = mbedtls_ctr_drbg_seed(&(ep->ctr_drbg), mbedtls_entropy_func,
+ &(ep->entropy), (const unsigned char *) (ep->name),
+ strlen(ep->name));
+ TEST_ASSERT(ret == 0);
/* Non-blocking callbacks without timeout */
- if( dtls_context != NULL )
- {
- mbedtls_ssl_set_bio( &( ep->ssl ), dtls_context,
- mbedtls_mock_tcp_send_msg,
- mbedtls_mock_tcp_recv_msg,
- NULL );
- }
- else
- {
- mbedtls_ssl_set_bio( &( ep->ssl ), &( ep->socket ),
- mbedtls_mock_tcp_send_nb,
- mbedtls_mock_tcp_recv_nb,
- NULL );
+ if (dtls_context != NULL) {
+ mbedtls_ssl_set_bio(&(ep->ssl), dtls_context,
+ mbedtls_mock_tcp_send_msg,
+ mbedtls_mock_tcp_recv_msg,
+ NULL);
+ } else {
+ mbedtls_ssl_set_bio(&(ep->ssl), &(ep->socket),
+ mbedtls_mock_tcp_send_nb,
+ mbedtls_mock_tcp_recv_nb,
+ NULL);
}
- ret = mbedtls_ssl_config_defaults( &( ep->conf ), endpoint_type,
- ( dtls_context != NULL ) ?
- MBEDTLS_SSL_TRANSPORT_DATAGRAM :
- MBEDTLS_SSL_TRANSPORT_STREAM,
- MBEDTLS_SSL_PRESET_DEFAULT );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_ssl_config_defaults(&(ep->conf), endpoint_type,
+ (dtls_context != NULL) ?
+ MBEDTLS_SSL_TRANSPORT_DATAGRAM :
+ MBEDTLS_SSL_TRANSPORT_STREAM,
+ MBEDTLS_SSL_PRESET_DEFAULT);
+ TEST_ASSERT(ret == 0);
#if defined(MBEDTLS_ECP_C)
- if( curves != NULL )
- mbedtls_ssl_conf_curves( &(ep->conf), curves );
+ if (curves != NULL) {
+ mbedtls_ssl_conf_curves(&(ep->conf), curves);
+ }
#else
(void) curves;
#endif
- ret = mbedtls_ssl_setup( &( ep->ssl ), &( ep->conf ) );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_ssl_setup(&(ep->ssl), &(ep->conf));
+ TEST_ASSERT(ret == 0);
#if defined(MBEDTLS_SSL_PROTO_DTLS) && defined(MBEDTLS_SSL_SRV_C)
- if( endpoint_type == MBEDTLS_SSL_IS_SERVER && dtls_context != NULL )
- mbedtls_ssl_conf_dtls_cookies( &( ep->conf ), NULL, NULL, NULL );
+ if (endpoint_type == MBEDTLS_SSL_IS_SERVER && dtls_context != NULL) {
+ mbedtls_ssl_conf_dtls_cookies(&(ep->conf), NULL, NULL, NULL);
+ }
#endif
- ret = mbedtls_endpoint_certificate_init( ep, pk_alg );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_endpoint_certificate_init(ep, pk_alg);
+ TEST_ASSERT(ret == 0);
exit:
return ret;
@@ -1000,23 +975,20 @@
/*
* Deinitializes endpoint represented by \p ep.
*/
-void mbedtls_endpoint_free( mbedtls_endpoint *ep,
- mbedtls_test_message_socket_context *context )
+void mbedtls_endpoint_free(mbedtls_endpoint *ep,
+ mbedtls_test_message_socket_context *context)
{
- mbedtls_endpoint_certificate_free( ep );
+ mbedtls_endpoint_certificate_free(ep);
- mbedtls_ssl_free( &( ep->ssl ) );
- mbedtls_ssl_config_free( &( ep->conf ) );
- mbedtls_ctr_drbg_free( &( ep->ctr_drbg ) );
- mbedtls_entropy_free( &( ep->entropy ) );
+ mbedtls_ssl_free(&(ep->ssl));
+ mbedtls_ssl_config_free(&(ep->conf));
+ mbedtls_ctr_drbg_free(&(ep->ctr_drbg));
+ mbedtls_entropy_free(&(ep->entropy));
- if( context != NULL )
- {
- mbedtls_message_socket_close( context );
- }
- else
- {
- mbedtls_mock_socket_close( &( ep->socket ) );
+ if (context != NULL) {
+ mbedtls_message_socket_close(context);
+ } else {
+ mbedtls_mock_socket_close(&(ep->socket));
}
}
@@ -1027,45 +999,40 @@
*
* \retval 0 on success, otherwise error code.
*/
-int mbedtls_move_handshake_to_state( mbedtls_ssl_context *ssl,
- mbedtls_ssl_context *second_ssl,
- int state )
+int mbedtls_move_handshake_to_state(mbedtls_ssl_context *ssl,
+ mbedtls_ssl_context *second_ssl,
+ int state)
{
enum { BUFFSIZE = 1024 };
int max_steps = 1000;
int ret = 0;
- if( ssl == NULL || second_ssl == NULL )
- {
+ if (ssl == NULL || second_ssl == NULL) {
return MBEDTLS_ERR_SSL_BAD_INPUT_DATA;
}
/* Perform communication via connected sockets */
- while( ( ssl->state != state ) && ( --max_steps >= 0 ) )
- {
+ while ((ssl->state != state) && (--max_steps >= 0)) {
/* If /p second_ssl ends the handshake procedure before /p ssl then
* there is no need to call the next step */
- if( second_ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER )
- {
- ret = mbedtls_ssl_handshake_step( second_ssl );
- if( ret != 0 && ret != MBEDTLS_ERR_SSL_WANT_READ &&
- ret != MBEDTLS_ERR_SSL_WANT_WRITE )
- {
+ if (second_ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER) {
+ ret = mbedtls_ssl_handshake_step(second_ssl);
+ if (ret != 0 && ret != MBEDTLS_ERR_SSL_WANT_READ &&
+ ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
return ret;
}
}
/* We only care about the \p ssl state and returns, so we call it last,
* to leave the iteration as soon as the state is as expected. */
- ret = mbedtls_ssl_handshake_step( ssl );
- if( ret != 0 && ret != MBEDTLS_ERR_SSL_WANT_READ &&
- ret != MBEDTLS_ERR_SSL_WANT_WRITE )
- {
+ ret = mbedtls_ssl_handshake_step(ssl);
+ if (ret != 0 && ret != MBEDTLS_ERR_SSL_WANT_READ &&
+ ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
return ret;
}
}
- return ( max_steps >= 0 ) ? ret : -1;
+ return (max_steps >= 0) ? ret : -1;
}
#endif /* MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED && MBEDTLS_ENTROPY_C && MBEDTLS_CTR_DRBG_C */
@@ -1073,38 +1040,32 @@
/*
* Write application data. Increase write counter if necessary.
*/
-int mbedtls_ssl_write_fragment( mbedtls_ssl_context *ssl, unsigned char *buf,
- int buf_len, int *written,
- const int expected_fragments )
+int mbedtls_ssl_write_fragment(mbedtls_ssl_context *ssl, unsigned char *buf,
+ int buf_len, int *written,
+ const int expected_fragments)
{
- int ret = mbedtls_ssl_write( ssl, buf + *written, buf_len - *written );
- if( ret > 0 )
- {
+ int ret = mbedtls_ssl_write(ssl, buf + *written, buf_len - *written);
+ if (ret > 0) {
*written += ret;
}
- if( expected_fragments == 0 )
- {
+ if (expected_fragments == 0) {
/* Used for DTLS and the message size larger than MFL. In that case
* the message can not be fragmented and the library should return
* MBEDTLS_ERR_SSL_BAD_INPUT_DATA error. This error must be returned
* to prevent a dead loop inside mbedtls_exchange_data(). */
return ret;
- }
- else if( expected_fragments == 1 )
- {
+ } else if (expected_fragments == 1) {
/* Used for TLS/DTLS and the message size lower than MFL */
- TEST_ASSERT( ret == buf_len ||
- ret == MBEDTLS_ERR_SSL_WANT_READ ||
- ret == MBEDTLS_ERR_SSL_WANT_WRITE );
- }
- else
- {
+ TEST_ASSERT(ret == buf_len ||
+ ret == MBEDTLS_ERR_SSL_WANT_READ ||
+ ret == MBEDTLS_ERR_SSL_WANT_WRITE);
+ } else {
/* Used for TLS and the message size larger than MFL */
- TEST_ASSERT( expected_fragments > 1 );
- TEST_ASSERT( ( ret >= 0 && ret <= buf_len ) ||
- ret == MBEDTLS_ERR_SSL_WANT_READ ||
- ret == MBEDTLS_ERR_SSL_WANT_WRITE );
+ TEST_ASSERT(expected_fragments > 1);
+ TEST_ASSERT((ret >= 0 && ret <= buf_len) ||
+ ret == MBEDTLS_ERR_SSL_WANT_READ ||
+ ret == MBEDTLS_ERR_SSL_WANT_WRITE);
}
return 0;
@@ -1117,33 +1078,27 @@
/*
* Read application data and increase read counter and fragments counter if necessary.
*/
-int mbedtls_ssl_read_fragment( mbedtls_ssl_context *ssl, unsigned char *buf,
- int buf_len, int *read,
- int *fragments, const int expected_fragments )
+int mbedtls_ssl_read_fragment(mbedtls_ssl_context *ssl, unsigned char *buf,
+ int buf_len, int *read,
+ int *fragments, const int expected_fragments)
{
- int ret = mbedtls_ssl_read( ssl, buf + *read, buf_len - *read );
- if( ret > 0 )
- {
- ( *fragments )++;
+ int ret = mbedtls_ssl_read(ssl, buf + *read, buf_len - *read);
+ if (ret > 0) {
+ (*fragments)++;
*read += ret;
}
- if( expected_fragments == 0 )
- {
- TEST_ASSERT( ret == 0 );
- }
- else if( expected_fragments == 1 )
- {
- TEST_ASSERT( ret == buf_len ||
- ret == MBEDTLS_ERR_SSL_WANT_READ ||
- ret == MBEDTLS_ERR_SSL_WANT_WRITE );
- }
- else
- {
- TEST_ASSERT( expected_fragments > 1 );
- TEST_ASSERT( ( ret >= 0 && ret <= buf_len ) ||
- ret == MBEDTLS_ERR_SSL_WANT_READ ||
- ret == MBEDTLS_ERR_SSL_WANT_WRITE );
+ if (expected_fragments == 0) {
+ TEST_ASSERT(ret == 0);
+ } else if (expected_fragments == 1) {
+ TEST_ASSERT(ret == buf_len ||
+ ret == MBEDTLS_ERR_SSL_WANT_READ ||
+ ret == MBEDTLS_ERR_SSL_WANT_WRITE);
+ } else {
+ TEST_ASSERT(expected_fragments > 1);
+ TEST_ASSERT((ret >= 0 && ret <= buf_len) ||
+ ret == MBEDTLS_ERR_SSL_WANT_READ ||
+ ret == MBEDTLS_ERR_SSL_WANT_WRITE);
}
return 0;
@@ -1159,54 +1114,52 @@
* and version.
*/
-#define CHK( x ) \
+#define CHK(x) \
do \
{ \
- if( !( x ) ) \
+ if (!(x)) \
{ \
ret = -1; \
goto cleanup; \
} \
- } while( 0 )
+ } while (0)
-void set_ciphersuite( mbedtls_ssl_config *conf, const char *cipher,
- int* forced_ciphersuite )
+void set_ciphersuite(mbedtls_ssl_config *conf, const char *cipher,
+ int *forced_ciphersuite)
{
const mbedtls_ssl_ciphersuite_t *ciphersuite_info;
- forced_ciphersuite[0] = mbedtls_ssl_get_ciphersuite_id( cipher );
+ forced_ciphersuite[0] = mbedtls_ssl_get_ciphersuite_id(cipher);
forced_ciphersuite[1] = 0;
ciphersuite_info =
- mbedtls_ssl_ciphersuite_from_id( forced_ciphersuite[0] );
+ mbedtls_ssl_ciphersuite_from_id(forced_ciphersuite[0]);
- TEST_ASSERT( ciphersuite_info != NULL );
- TEST_ASSERT( ciphersuite_info->min_minor_ver <= conf->max_minor_ver );
- TEST_ASSERT( ciphersuite_info->max_minor_ver >= conf->min_minor_ver );
+ TEST_ASSERT(ciphersuite_info != NULL);
+ TEST_ASSERT(ciphersuite_info->min_minor_ver <= conf->max_minor_ver);
+ TEST_ASSERT(ciphersuite_info->max_minor_ver >= conf->min_minor_ver);
- if( conf->max_minor_ver > ciphersuite_info->max_minor_ver )
- {
+ if (conf->max_minor_ver > ciphersuite_info->max_minor_ver) {
conf->max_minor_ver = ciphersuite_info->max_minor_ver;
}
- if( conf->min_minor_ver < ciphersuite_info->min_minor_ver )
- {
+ if (conf->min_minor_ver < ciphersuite_info->min_minor_ver) {
conf->min_minor_ver = ciphersuite_info->min_minor_ver;
}
- mbedtls_ssl_conf_ciphersuites( conf, forced_ciphersuite );
+ mbedtls_ssl_conf_ciphersuites(conf, forced_ciphersuite);
exit:
return;
}
-int psk_dummy_callback( void *p_info, mbedtls_ssl_context *ssl,
- const unsigned char *name, size_t name_len )
+int psk_dummy_callback(void *p_info, mbedtls_ssl_context *ssl,
+ const unsigned char *name, size_t name_len)
{
(void) p_info;
(void) ssl;
(void) name;
(void) name_len;
- return ( 0 );
+ return 0;
}
#if MBEDTLS_SSL_CID_OUT_LEN_MAX > MBEDTLS_SSL_CID_IN_LEN_MAX
@@ -1215,12 +1168,12 @@
#define SSL_CID_LEN_MIN MBEDTLS_SSL_CID_OUT_LEN_MAX
#endif
-static int build_transforms( mbedtls_ssl_transform *t_in,
- mbedtls_ssl_transform *t_out,
- int cipher_type, int hash_id,
- int etm, int tag_mode, int ver,
- size_t cid0_len,
- size_t cid1_len )
+static int build_transforms(mbedtls_ssl_transform *t_in,
+ mbedtls_ssl_transform *t_out,
+ int cipher_type, int hash_id,
+ int etm, int tag_mode, int ver,
+ size_t cid0_len,
+ size_t cid1_len)
{
mbedtls_cipher_info_t const *cipher_info;
int ret = 0;
@@ -1231,11 +1184,11 @@
unsigned char iv_enc[16], iv_dec[16];
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
- unsigned char cid0[ SSL_CID_LEN_MIN ];
- unsigned char cid1[ SSL_CID_LEN_MIN ];
+ unsigned char cid0[SSL_CID_LEN_MIN];
+ unsigned char cid1[SSL_CID_LEN_MIN];
- mbedtls_test_rnd_std_rand( NULL, cid0, sizeof( cid0 ) );
- mbedtls_test_rnd_std_rand( NULL, cid1, sizeof( cid1 ) );
+ mbedtls_test_rnd_std_rand(NULL, cid0, sizeof(cid0));
+ mbedtls_test_rnd_std_rand(NULL, cid1, sizeof(cid1));
#else
((void) cid0_len);
((void) cid1_len);
@@ -1244,91 +1197,87 @@
maclen = 0;
/* Pick cipher */
- cipher_info = mbedtls_cipher_info_from_type( cipher_type );
- CHK( cipher_info != NULL );
- CHK( cipher_info->iv_size <= 16 );
- CHK( cipher_info->key_bitlen % 8 == 0 );
+ cipher_info = mbedtls_cipher_info_from_type(cipher_type);
+ CHK(cipher_info != NULL);
+ CHK(cipher_info->iv_size <= 16);
+ CHK(cipher_info->key_bitlen % 8 == 0);
/* Pick keys */
keylen = cipher_info->key_bitlen / 8;
/* Allocate `keylen + 1` bytes to ensure that we get
* a non-NULL pointers from `mbedtls_calloc` even if
* `keylen == 0` in the case of the NULL cipher. */
- CHK( ( key0 = mbedtls_calloc( 1, keylen + 1 ) ) != NULL );
- CHK( ( key1 = mbedtls_calloc( 1, keylen + 1 ) ) != NULL );
- memset( key0, 0x1, keylen );
- memset( key1, 0x2, keylen );
+ CHK((key0 = mbedtls_calloc(1, keylen + 1)) != NULL);
+ CHK((key1 = mbedtls_calloc(1, keylen + 1)) != NULL);
+ memset(key0, 0x1, keylen);
+ memset(key1, 0x2, keylen);
/* Setup cipher contexts */
- CHK( mbedtls_cipher_setup( &t_in->cipher_ctx_enc, cipher_info ) == 0 );
- CHK( mbedtls_cipher_setup( &t_in->cipher_ctx_dec, cipher_info ) == 0 );
- CHK( mbedtls_cipher_setup( &t_out->cipher_ctx_enc, cipher_info ) == 0 );
- CHK( mbedtls_cipher_setup( &t_out->cipher_ctx_dec, cipher_info ) == 0 );
+ CHK(mbedtls_cipher_setup(&t_in->cipher_ctx_enc, cipher_info) == 0);
+ CHK(mbedtls_cipher_setup(&t_in->cipher_ctx_dec, cipher_info) == 0);
+ CHK(mbedtls_cipher_setup(&t_out->cipher_ctx_enc, cipher_info) == 0);
+ CHK(mbedtls_cipher_setup(&t_out->cipher_ctx_dec, cipher_info) == 0);
#if defined(MBEDTLS_CIPHER_MODE_CBC)
- if( cipher_info->mode == MBEDTLS_MODE_CBC )
- {
- CHK( mbedtls_cipher_set_padding_mode( &t_in->cipher_ctx_enc,
- MBEDTLS_PADDING_NONE ) == 0 );
- CHK( mbedtls_cipher_set_padding_mode( &t_in->cipher_ctx_dec,
- MBEDTLS_PADDING_NONE ) == 0 );
- CHK( mbedtls_cipher_set_padding_mode( &t_out->cipher_ctx_enc,
- MBEDTLS_PADDING_NONE ) == 0 );
- CHK( mbedtls_cipher_set_padding_mode( &t_out->cipher_ctx_dec,
- MBEDTLS_PADDING_NONE ) == 0 );
+ if (cipher_info->mode == MBEDTLS_MODE_CBC) {
+ CHK(mbedtls_cipher_set_padding_mode(&t_in->cipher_ctx_enc,
+ MBEDTLS_PADDING_NONE) == 0);
+ CHK(mbedtls_cipher_set_padding_mode(&t_in->cipher_ctx_dec,
+ MBEDTLS_PADDING_NONE) == 0);
+ CHK(mbedtls_cipher_set_padding_mode(&t_out->cipher_ctx_enc,
+ MBEDTLS_PADDING_NONE) == 0);
+ CHK(mbedtls_cipher_set_padding_mode(&t_out->cipher_ctx_dec,
+ MBEDTLS_PADDING_NONE) == 0);
}
#endif /* MBEDTLS_CIPHER_MODE_CBC */
- CHK( mbedtls_cipher_setkey( &t_in->cipher_ctx_enc, key0,
- keylen << 3, MBEDTLS_ENCRYPT ) == 0 );
- CHK( mbedtls_cipher_setkey( &t_in->cipher_ctx_dec, key1,
- keylen << 3, MBEDTLS_DECRYPT ) == 0 );
- CHK( mbedtls_cipher_setkey( &t_out->cipher_ctx_enc, key1,
- keylen << 3, MBEDTLS_ENCRYPT ) == 0 );
- CHK( mbedtls_cipher_setkey( &t_out->cipher_ctx_dec, key0,
- keylen << 3, MBEDTLS_DECRYPT ) == 0 );
+ CHK(mbedtls_cipher_setkey(&t_in->cipher_ctx_enc, key0,
+ keylen << 3, MBEDTLS_ENCRYPT) == 0);
+ CHK(mbedtls_cipher_setkey(&t_in->cipher_ctx_dec, key1,
+ keylen << 3, MBEDTLS_DECRYPT) == 0);
+ CHK(mbedtls_cipher_setkey(&t_out->cipher_ctx_enc, key1,
+ keylen << 3, MBEDTLS_ENCRYPT) == 0);
+ CHK(mbedtls_cipher_setkey(&t_out->cipher_ctx_dec, key0,
+ keylen << 3, MBEDTLS_DECRYPT) == 0);
/* Setup MAC contexts */
#if defined(MBEDTLS_SSL_SOME_MODES_USE_MAC)
- if( cipher_info->mode == MBEDTLS_MODE_CBC ||
- cipher_info->mode == MBEDTLS_MODE_STREAM )
- {
+ if (cipher_info->mode == MBEDTLS_MODE_CBC ||
+ cipher_info->mode == MBEDTLS_MODE_STREAM) {
mbedtls_md_info_t const *md_info;
/* Pick hash */
- md_info = mbedtls_md_info_from_type( hash_id );
- CHK( md_info != NULL );
+ md_info = mbedtls_md_info_from_type(hash_id);
+ CHK(md_info != NULL);
/* Pick hash keys */
- maclen = mbedtls_md_get_size( md_info );
- CHK( ( md0 = mbedtls_calloc( 1, maclen ) ) != NULL );
- CHK( ( md1 = mbedtls_calloc( 1, maclen ) ) != NULL );
- memset( md0, 0x5, maclen );
- memset( md1, 0x6, maclen );
+ maclen = mbedtls_md_get_size(md_info);
+ CHK((md0 = mbedtls_calloc(1, maclen)) != NULL);
+ CHK((md1 = mbedtls_calloc(1, maclen)) != NULL);
+ memset(md0, 0x5, maclen);
+ memset(md1, 0x6, maclen);
- CHK( mbedtls_md_setup( &t_out->md_ctx_enc, md_info, 1 ) == 0 );
- CHK( mbedtls_md_setup( &t_out->md_ctx_dec, md_info, 1 ) == 0 );
- CHK( mbedtls_md_setup( &t_in->md_ctx_enc, md_info, 1 ) == 0 );
- CHK( mbedtls_md_setup( &t_in->md_ctx_dec, md_info, 1 ) == 0 );
+ CHK(mbedtls_md_setup(&t_out->md_ctx_enc, md_info, 1) == 0);
+ CHK(mbedtls_md_setup(&t_out->md_ctx_dec, md_info, 1) == 0);
+ CHK(mbedtls_md_setup(&t_in->md_ctx_enc, md_info, 1) == 0);
+ CHK(mbedtls_md_setup(&t_in->md_ctx_dec, md_info, 1) == 0);
- if( ver > MBEDTLS_SSL_MINOR_VERSION_0 )
- {
- CHK( mbedtls_md_hmac_starts( &t_in->md_ctx_enc,
- md0, maclen ) == 0 );
- CHK( mbedtls_md_hmac_starts( &t_in->md_ctx_dec,
- md1, maclen ) == 0 );
- CHK( mbedtls_md_hmac_starts( &t_out->md_ctx_enc,
- md1, maclen ) == 0 );
- CHK( mbedtls_md_hmac_starts( &t_out->md_ctx_dec,
- md0, maclen ) == 0 );
+ if (ver > MBEDTLS_SSL_MINOR_VERSION_0) {
+ CHK(mbedtls_md_hmac_starts(&t_in->md_ctx_enc,
+ md0, maclen) == 0);
+ CHK(mbedtls_md_hmac_starts(&t_in->md_ctx_dec,
+ md1, maclen) == 0);
+ CHK(mbedtls_md_hmac_starts(&t_out->md_ctx_enc,
+ md1, maclen) == 0);
+ CHK(mbedtls_md_hmac_starts(&t_out->md_ctx_dec,
+ md0, maclen) == 0);
}
#if defined(MBEDTLS_SSL_PROTO_SSL3)
- else
- {
- memcpy( &t_in->mac_enc, md0, maclen );
- memcpy( &t_in->mac_dec, md1, maclen );
- memcpy( &t_out->mac_enc, md1, maclen );
- memcpy( &t_out->mac_dec, md0, maclen );
+ else {
+ memcpy(&t_in->mac_enc, md0, maclen);
+ memcpy(&t_in->mac_dec, md1, maclen);
+ memcpy(&t_out->mac_enc, md1, maclen);
+ memcpy(&t_out->mac_dec, md0, maclen);
}
#endif
}
@@ -1340,8 +1289,8 @@
/* Pick IV's (regardless of whether they
* are being used by the transform). */
ivlen = cipher_info->iv_size;
- memset( iv_enc, 0x3, sizeof( iv_enc ) );
- memset( iv_dec, 0x4, sizeof( iv_dec ) );
+ memset(iv_enc, 0x3, sizeof(iv_enc));
+ memset(iv_dec, 0x4, sizeof(iv_dec));
/*
* Setup transforms
@@ -1360,17 +1309,14 @@
t_out->ivlen = ivlen;
t_in->ivlen = ivlen;
- switch( cipher_info->mode )
- {
+ switch (cipher_info->mode) {
case MBEDTLS_MODE_GCM:
case MBEDTLS_MODE_CCM:
#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
- if( ver == MBEDTLS_SSL_MINOR_VERSION_4 )
- {
+ if (ver == MBEDTLS_SSL_MINOR_VERSION_4) {
t_out->fixed_ivlen = 12;
t_in->fixed_ivlen = 12;
- }
- else
+ } else
#endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
{
t_out->fixed_ivlen = 4;
@@ -1378,8 +1324,7 @@
}
t_out->maclen = 0;
t_in->maclen = 0;
- switch( tag_mode )
- {
+ switch (tag_mode) {
case 0: /* Full tag */
t_out->taglen = 16;
t_in->taglen = 16;
@@ -1399,8 +1344,7 @@
t_in->fixed_ivlen = 12;
t_out->maclen = 0;
t_in->maclen = 0;
- switch( tag_mode )
- {
+ switch (tag_mode) {
case 0: /* Full tag */
t_out->taglen = 16;
t_in->taglen = 16;
@@ -1421,8 +1365,7 @@
t_in->fixed_ivlen = 0; /* redundant, must be 0 */
t_out->taglen = 0;
t_in->taglen = 0;
- switch( tag_mode )
- {
+ switch (tag_mode) {
case 0: /* Full tag */
t_out->maclen = maclen;
t_in->maclen = maclen;
@@ -1444,88 +1387,91 @@
/* Setup IV's */
- memcpy( &t_in->iv_dec, iv_dec, sizeof( iv_dec ) );
- memcpy( &t_in->iv_enc, iv_enc, sizeof( iv_enc ) );
- memcpy( &t_out->iv_dec, iv_enc, sizeof( iv_enc ) );
- memcpy( &t_out->iv_enc, iv_dec, sizeof( iv_dec ) );
+ memcpy(&t_in->iv_dec, iv_dec, sizeof(iv_dec));
+ memcpy(&t_in->iv_enc, iv_enc, sizeof(iv_enc));
+ memcpy(&t_out->iv_dec, iv_enc, sizeof(iv_enc));
+ memcpy(&t_out->iv_enc, iv_dec, sizeof(iv_dec));
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
/* Add CID */
- memcpy( &t_in->in_cid, cid0, cid0_len );
- memcpy( &t_in->out_cid, cid1, cid1_len );
+ memcpy(&t_in->in_cid, cid0, cid0_len);
+ memcpy(&t_in->out_cid, cid1, cid1_len);
t_in->in_cid_len = cid0_len;
t_in->out_cid_len = cid1_len;
- memcpy( &t_out->in_cid, cid1, cid1_len );
- memcpy( &t_out->out_cid, cid0, cid0_len );
+ memcpy(&t_out->in_cid, cid1, cid1_len);
+ memcpy(&t_out->out_cid, cid0, cid0_len);
t_out->in_cid_len = cid1_len;
t_out->out_cid_len = cid0_len;
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
cleanup:
- mbedtls_free( key0 );
- mbedtls_free( key1 );
+ mbedtls_free(key0);
+ mbedtls_free(key1);
- mbedtls_free( md0 );
- mbedtls_free( md1 );
+ mbedtls_free(md0);
+ mbedtls_free(md1);
- return( ret );
+ return ret;
}
/*
* Populate a session structure for serialization tests.
* Choose dummy values, mostly non-0 to distinguish from the init default.
*/
-static int ssl_populate_session( mbedtls_ssl_session *session,
- int ticket_len,
- const char *crt_file )
+static int ssl_populate_session(mbedtls_ssl_session *session,
+ int ticket_len,
+ const char *crt_file)
{
#if defined(MBEDTLS_HAVE_TIME)
- session->start = mbedtls_time( NULL ) - 42;
+ session->start = mbedtls_time(NULL) - 42;
#endif
session->ciphersuite = 0xabcd;
session->compression = 1;
- session->id_len = sizeof( session->id );
- memset( session->id, 66, session->id_len );
- memset( session->master, 17, sizeof( session->master ) );
+ session->id_len = sizeof(session->id);
+ memset(session->id, 66, session->id_len);
+ memset(session->master, 17, sizeof(session->master));
#if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED) && defined(MBEDTLS_FS_IO)
- if( strlen( crt_file ) != 0 )
- {
+ if (strlen(crt_file) != 0) {
mbedtls_x509_crt tmp_crt;
int ret;
- mbedtls_x509_crt_init( &tmp_crt );
- ret = mbedtls_x509_crt_parse_file( &tmp_crt, crt_file );
- if( ret != 0 )
- return( ret );
+ mbedtls_x509_crt_init(&tmp_crt);
+ ret = mbedtls_x509_crt_parse_file(&tmp_crt, crt_file);
+ if (ret != 0) {
+ return ret;
+ }
#if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
/* Move temporary CRT. */
- session->peer_cert = mbedtls_calloc( 1, sizeof( *session->peer_cert ) );
- if( session->peer_cert == NULL )
- return( -1 );
+ session->peer_cert = mbedtls_calloc(1, sizeof(*session->peer_cert));
+ if (session->peer_cert == NULL) {
+ return -1;
+ }
*session->peer_cert = tmp_crt;
- memset( &tmp_crt, 0, sizeof( tmp_crt ) );
+ memset(&tmp_crt, 0, sizeof(tmp_crt));
#else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
/* Calculate digest of temporary CRT. */
session->peer_cert_digest =
- mbedtls_calloc( 1, MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN );
- if( session->peer_cert_digest == NULL )
- return( -1 );
- ret = mbedtls_md( mbedtls_md_info_from_type(
- MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE ),
- tmp_crt.raw.p, tmp_crt.raw.len,
- session->peer_cert_digest );
- if( ret != 0 )
- return( ret );
+ mbedtls_calloc(1, MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN);
+ if (session->peer_cert_digest == NULL) {
+ return -1;
+ }
+ ret = mbedtls_md(mbedtls_md_info_from_type(
+ MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE),
+ tmp_crt.raw.p, tmp_crt.raw.len,
+ session->peer_cert_digest);
+ if (ret != 0) {
+ return ret;
+ }
session->peer_cert_digest_type =
MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_TYPE;
session->peer_cert_digest_len =
MBEDTLS_SSL_PEER_CERT_DIGEST_DFL_LEN;
#endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
- mbedtls_x509_crt_free( &tmp_crt );
+ mbedtls_x509_crt_free(&tmp_crt);
}
#else /* MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED && MBEDTLS_FS_IO */
(void) crt_file;
@@ -1533,12 +1479,12 @@
session->verify_result = 0xdeadbeef;
#if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
- if( ticket_len != 0 )
- {
- session->ticket = mbedtls_calloc( 1, ticket_len );
- if( session->ticket == NULL )
- return( -1 );
- memset( session->ticket, 33, ticket_len );
+ if (ticket_len != 0) {
+ session->ticket = mbedtls_calloc(1, ticket_len);
+ if (session->ticket == NULL) {
+ return -1;
+ }
+ memset(session->ticket, 33, ticket_len);
}
session->ticket_len = ticket_len;
session->ticket_lifetime = 86401;
@@ -1556,7 +1502,7 @@
session->encrypt_then_mac = 1;
#endif
- return( 0 );
+ return 0;
}
/*
@@ -1579,22 +1525,21 @@
*
* \retval 0 on success, otherwise error code.
*/
-int mbedtls_exchange_data( mbedtls_ssl_context *ssl_1,
- int msg_len_1, const int expected_fragments_1,
- mbedtls_ssl_context *ssl_2,
- int msg_len_2, const int expected_fragments_2 )
+int mbedtls_exchange_data(mbedtls_ssl_context *ssl_1,
+ int msg_len_1, const int expected_fragments_1,
+ mbedtls_ssl_context *ssl_2,
+ int msg_len_2, const int expected_fragments_2)
{
- unsigned char *msg_buf_1 = malloc( msg_len_1 );
- unsigned char *msg_buf_2 = malloc( msg_len_2 );
- unsigned char *in_buf_1 = malloc( msg_len_2 );
- unsigned char *in_buf_2 = malloc( msg_len_1 );
+ unsigned char *msg_buf_1 = malloc(msg_len_1);
+ unsigned char *msg_buf_2 = malloc(msg_len_2);
+ unsigned char *in_buf_1 = malloc(msg_len_2);
+ unsigned char *in_buf_2 = malloc(msg_len_1);
int msg_type, ret = -1;
/* Perform this test with two message types. At first use a message
* consisting of only 0x00 for the client and only 0xFF for the server.
* At the second time use message with generated data */
- for( msg_type = 0; msg_type < 2; msg_type++ )
- {
+ for (msg_type = 0; msg_type < 2; msg_type++) {
int written_1 = 0;
int written_2 = 0;
int read_1 = 0;
@@ -1602,99 +1547,83 @@
int fragments_1 = 0;
int fragments_2 = 0;
- if( msg_type == 0 )
- {
- memset( msg_buf_1, 0x00, msg_len_1 );
- memset( msg_buf_2, 0xff, msg_len_2 );
- }
- else
- {
+ if (msg_type == 0) {
+ memset(msg_buf_1, 0x00, msg_len_1);
+ memset(msg_buf_2, 0xff, msg_len_2);
+ } else {
int i, j = 0;
- for( i = 0; i < msg_len_1; i++ )
- {
+ for (i = 0; i < msg_len_1; i++) {
msg_buf_1[i] = j++ & 0xFF;
}
- for( i = 0; i < msg_len_2; i++ )
- {
- msg_buf_2[i] = ( j -= 5 ) & 0xFF;
+ for (i = 0; i < msg_len_2; i++) {
+ msg_buf_2[i] = (j -= 5) & 0xFF;
}
}
- while( read_1 < msg_len_2 || read_2 < msg_len_1 )
- {
+ while (read_1 < msg_len_2 || read_2 < msg_len_1) {
/* ssl_1 sending */
- if( msg_len_1 > written_1 )
- {
- ret = mbedtls_ssl_write_fragment( ssl_1, msg_buf_1,
- msg_len_1, &written_1,
- expected_fragments_1 );
- if( expected_fragments_1 == 0 )
- {
+ if (msg_len_1 > written_1) {
+ ret = mbedtls_ssl_write_fragment(ssl_1, msg_buf_1,
+ msg_len_1, &written_1,
+ expected_fragments_1);
+ if (expected_fragments_1 == 0) {
/* This error is expected when the message is too large and
* cannot be fragmented */
- TEST_ASSERT( ret == MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
+ TEST_ASSERT(ret == MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
msg_len_1 = 0;
- }
- else
- {
- TEST_ASSERT( ret == 0 );
+ } else {
+ TEST_ASSERT(ret == 0);
}
}
/* ssl_2 sending */
- if( msg_len_2 > written_2 )
- {
- ret = mbedtls_ssl_write_fragment( ssl_2, msg_buf_2,
- msg_len_2, &written_2,
- expected_fragments_2 );
- if( expected_fragments_2 == 0 )
- {
+ if (msg_len_2 > written_2) {
+ ret = mbedtls_ssl_write_fragment(ssl_2, msg_buf_2,
+ msg_len_2, &written_2,
+ expected_fragments_2);
+ if (expected_fragments_2 == 0) {
/* This error is expected when the message is too large and
* cannot be fragmented */
- TEST_ASSERT( ret == MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
+ TEST_ASSERT(ret == MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
msg_len_2 = 0;
- }
- else
- {
- TEST_ASSERT( ret == 0 );
+ } else {
+ TEST_ASSERT(ret == 0);
}
}
/* ssl_1 reading */
- if( read_1 < msg_len_2 )
- {
- ret = mbedtls_ssl_read_fragment( ssl_1, in_buf_1,
- msg_len_2, &read_1,
- &fragments_2,
- expected_fragments_2 );
- TEST_ASSERT( ret == 0 );
+ if (read_1 < msg_len_2) {
+ ret = mbedtls_ssl_read_fragment(ssl_1, in_buf_1,
+ msg_len_2, &read_1,
+ &fragments_2,
+ expected_fragments_2);
+ TEST_ASSERT(ret == 0);
}
/* ssl_2 reading */
- if( read_2 < msg_len_1 )
- {
- ret = mbedtls_ssl_read_fragment( ssl_2, in_buf_2,
- msg_len_1, &read_2,
- &fragments_1,
- expected_fragments_1 );
- TEST_ASSERT( ret == 0 );
+ if (read_2 < msg_len_1) {
+ ret = mbedtls_ssl_read_fragment(ssl_2, in_buf_2,
+ msg_len_1, &read_2,
+ &fragments_1,
+ expected_fragments_1);
+ TEST_ASSERT(ret == 0);
}
}
ret = -1;
- TEST_ASSERT( 0 == memcmp( msg_buf_1, in_buf_2, msg_len_1 ) );
- TEST_ASSERT( 0 == memcmp( msg_buf_2, in_buf_1, msg_len_2 ) );
- TEST_ASSERT( fragments_1 == expected_fragments_1 );
- TEST_ASSERT( fragments_2 == expected_fragments_2 );
+ TEST_ASSERT(0 == memcmp(msg_buf_1, in_buf_2, msg_len_1));
+ TEST_ASSERT(0 == memcmp(msg_buf_2, in_buf_1, msg_len_2));
+ TEST_ASSERT(fragments_1 == expected_fragments_1);
+ TEST_ASSERT(fragments_2 == expected_fragments_2);
}
ret = 0;
exit:
- free( msg_buf_1 );
- free( in_buf_1 );
- free( msg_buf_2 );
- free( in_buf_2 );
+ free(msg_buf_1);
+ free(in_buf_1);
+ free(msg_buf_2);
+ free(in_buf_2);
return ret;
}
@@ -1705,17 +1634,17 @@
*
* \retval 0 on success, otherwise error code.
*/
-int exchange_data( mbedtls_ssl_context *ssl_1,
- mbedtls_ssl_context *ssl_2 )
+int exchange_data(mbedtls_ssl_context *ssl_1,
+ mbedtls_ssl_context *ssl_2)
{
- return mbedtls_exchange_data( ssl_1, 256, 1,
- ssl_2, 256, 1 );
+ return mbedtls_exchange_data(ssl_1, 256, 1,
+ ssl_2, 256, 1);
}
#if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED) && \
defined(MBEDTLS_ENTROPY_C) && \
defined(MBEDTLS_CTR_DRBG_C)
-void perform_handshake( handshake_test_options* options )
+void perform_handshake(handshake_test_options *options)
{
/* forced_ciphersuite needs to last until the end of the handshake */
int forced_ciphersuite[2];
@@ -1736,360 +1665,332 @@
#endif
int expected_handshake_result = 0;
- USE_PSA_INIT( );
- mbedtls_platform_zeroize( &client, sizeof( client ) );
- mbedtls_platform_zeroize( &server, sizeof( server ) );
+ USE_PSA_INIT();
+ mbedtls_platform_zeroize(&client, sizeof(client));
+ mbedtls_platform_zeroize(&server, sizeof(server));
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
- mbedtls_message_socket_init( &server_context );
- mbedtls_message_socket_init( &client_context );
+ mbedtls_message_socket_init(&server_context);
+ mbedtls_message_socket_init(&client_context);
/* Client side */
- if( options->dtls != 0 )
- {
- TEST_ASSERT( mbedtls_endpoint_init( &client, MBEDTLS_SSL_IS_CLIENT,
- options->pk_alg, &client_context,
- &client_queue,
- &server_queue, NULL ) == 0 );
+ if (options->dtls != 0) {
+ TEST_ASSERT(mbedtls_endpoint_init(&client, MBEDTLS_SSL_IS_CLIENT,
+ options->pk_alg, &client_context,
+ &client_queue,
+ &server_queue, NULL) == 0);
#if defined(MBEDTLS_TIMING_C)
- mbedtls_ssl_set_timer_cb( &client.ssl, &timer_client,
- mbedtls_timing_set_delay,
- mbedtls_timing_get_delay );
+ mbedtls_ssl_set_timer_cb(&client.ssl, &timer_client,
+ mbedtls_timing_set_delay,
+ mbedtls_timing_get_delay);
#endif
- }
- else
- {
- TEST_ASSERT( mbedtls_endpoint_init( &client, MBEDTLS_SSL_IS_CLIENT,
- options->pk_alg, NULL, NULL,
- NULL, NULL ) == 0 );
+ } else {
+ TEST_ASSERT(mbedtls_endpoint_init(&client, MBEDTLS_SSL_IS_CLIENT,
+ options->pk_alg, NULL, NULL,
+ NULL, NULL) == 0);
}
- if( options->client_min_version != TEST_SSL_MINOR_VERSION_NONE )
- {
- mbedtls_ssl_conf_min_version( &client.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
- options->client_min_version );
+ if (options->client_min_version != TEST_SSL_MINOR_VERSION_NONE) {
+ mbedtls_ssl_conf_min_version(&client.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
+ options->client_min_version);
}
- if( options->client_max_version != TEST_SSL_MINOR_VERSION_NONE )
- {
- mbedtls_ssl_conf_max_version( &client.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
- options->client_max_version );
+ if (options->client_max_version != TEST_SSL_MINOR_VERSION_NONE) {
+ mbedtls_ssl_conf_max_version(&client.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
+ options->client_max_version);
}
- if( strlen( options->cipher ) > 0 )
- {
- set_ciphersuite( &client.conf, options->cipher, forced_ciphersuite );
+ if (strlen(options->cipher) > 0) {
+ set_ciphersuite(&client.conf, options->cipher, forced_ciphersuite);
}
-#if defined (MBEDTLS_DEBUG_C)
- if( options->cli_log_fun )
- {
- mbedtls_debug_set_threshold( 4 );
- mbedtls_ssl_conf_dbg( &client.conf, options->cli_log_fun,
- options->cli_log_obj );
+#if defined(MBEDTLS_DEBUG_C)
+ if (options->cli_log_fun) {
+ mbedtls_debug_set_threshold(4);
+ mbedtls_ssl_conf_dbg(&client.conf, options->cli_log_fun,
+ options->cli_log_obj);
}
#endif
/* Server side */
- if( options->dtls != 0 )
- {
- TEST_ASSERT( mbedtls_endpoint_init( &server, MBEDTLS_SSL_IS_SERVER,
- options->pk_alg, &server_context,
- &server_queue,
- &client_queue, NULL ) == 0 );
+ if (options->dtls != 0) {
+ TEST_ASSERT(mbedtls_endpoint_init(&server, MBEDTLS_SSL_IS_SERVER,
+ options->pk_alg, &server_context,
+ &server_queue,
+ &client_queue, NULL) == 0);
#if defined(MBEDTLS_TIMING_C)
- mbedtls_ssl_set_timer_cb( &server.ssl, &timer_server,
- mbedtls_timing_set_delay,
- mbedtls_timing_get_delay );
+ mbedtls_ssl_set_timer_cb(&server.ssl, &timer_server,
+ mbedtls_timing_set_delay,
+ mbedtls_timing_get_delay);
#endif
- }
- else
- {
- TEST_ASSERT( mbedtls_endpoint_init( &server, MBEDTLS_SSL_IS_SERVER,
- options->pk_alg, NULL, NULL,
- NULL, NULL ) == 0 );
+ } else {
+ TEST_ASSERT(mbedtls_endpoint_init(&server, MBEDTLS_SSL_IS_SERVER,
+ options->pk_alg, NULL, NULL,
+ NULL, NULL) == 0);
}
- mbedtls_ssl_conf_authmode( &server.conf, options->srv_auth_mode );
+ mbedtls_ssl_conf_authmode(&server.conf, options->srv_auth_mode);
- if( options->server_min_version != TEST_SSL_MINOR_VERSION_NONE )
- {
- mbedtls_ssl_conf_min_version( &server.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
- options->server_min_version );
+ if (options->server_min_version != TEST_SSL_MINOR_VERSION_NONE) {
+ mbedtls_ssl_conf_min_version(&server.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
+ options->server_min_version);
}
- if( options->server_max_version != TEST_SSL_MINOR_VERSION_NONE )
- {
- mbedtls_ssl_conf_max_version( &server.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
- options->server_max_version );
+ if (options->server_max_version != TEST_SSL_MINOR_VERSION_NONE) {
+ mbedtls_ssl_conf_max_version(&server.conf, MBEDTLS_SSL_MAJOR_VERSION_3,
+ options->server_max_version);
}
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
- TEST_ASSERT( mbedtls_ssl_conf_max_frag_len( &(server.conf),
- (unsigned char) options->mfl ) == 0 );
- TEST_ASSERT( mbedtls_ssl_conf_max_frag_len( &(client.conf),
- (unsigned char) options->mfl ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_conf_max_frag_len(&(server.conf),
+ (unsigned char) options->mfl) == 0);
+ TEST_ASSERT(mbedtls_ssl_conf_max_frag_len(&(client.conf),
+ (unsigned char) options->mfl) == 0);
#else
- TEST_ASSERT( MBEDTLS_SSL_MAX_FRAG_LEN_NONE == options->mfl );
+ TEST_ASSERT(MBEDTLS_SSL_MAX_FRAG_LEN_NONE == options->mfl);
#endif /* MBEDTLS_SSL_MAX_FRAGMENT_LENGTH */
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
- if( options->psk_str != NULL && options->psk_str->len > 0 )
- {
- TEST_ASSERT( mbedtls_ssl_conf_psk( &client.conf, options->psk_str->x,
- options->psk_str->len,
- (const unsigned char *) psk_identity,
- strlen( psk_identity ) ) == 0 );
+ if (options->psk_str != NULL && options->psk_str->len > 0) {
+ TEST_ASSERT(mbedtls_ssl_conf_psk(&client.conf, options->psk_str->x,
+ options->psk_str->len,
+ (const unsigned char *) psk_identity,
+ strlen(psk_identity)) == 0);
- TEST_ASSERT( mbedtls_ssl_conf_psk( &server.conf, options->psk_str->x,
- options->psk_str->len,
- (const unsigned char *) psk_identity,
- strlen( psk_identity ) ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_conf_psk(&server.conf, options->psk_str->x,
+ options->psk_str->len,
+ (const unsigned char *) psk_identity,
+ strlen(psk_identity)) == 0);
- mbedtls_ssl_conf_psk_cb( &server.conf, psk_dummy_callback, NULL );
+ mbedtls_ssl_conf_psk_cb(&server.conf, psk_dummy_callback, NULL);
}
#endif
#if defined(MBEDTLS_SSL_RENEGOTIATION)
- if( options->renegotiate )
- {
- mbedtls_ssl_conf_renegotiation( &(server.conf),
- MBEDTLS_SSL_RENEGOTIATION_ENABLED );
- mbedtls_ssl_conf_renegotiation( &(client.conf),
- MBEDTLS_SSL_RENEGOTIATION_ENABLED );
+ if (options->renegotiate) {
+ mbedtls_ssl_conf_renegotiation(&(server.conf),
+ MBEDTLS_SSL_RENEGOTIATION_ENABLED);
+ mbedtls_ssl_conf_renegotiation(&(client.conf),
+ MBEDTLS_SSL_RENEGOTIATION_ENABLED);
- mbedtls_ssl_conf_legacy_renegotiation( &(server.conf),
- options->legacy_renegotiation );
- mbedtls_ssl_conf_legacy_renegotiation( &(client.conf),
- options->legacy_renegotiation );
+ mbedtls_ssl_conf_legacy_renegotiation(&(server.conf),
+ options->legacy_renegotiation);
+ mbedtls_ssl_conf_legacy_renegotiation(&(client.conf),
+ options->legacy_renegotiation);
}
#endif /* MBEDTLS_SSL_RENEGOTIATION */
-#if defined (MBEDTLS_DEBUG_C)
- if( options->srv_log_fun )
- {
- mbedtls_debug_set_threshold( 4 );
- mbedtls_ssl_conf_dbg( &server.conf, options->srv_log_fun,
- options->srv_log_obj );
+#if defined(MBEDTLS_DEBUG_C)
+ if (options->srv_log_fun) {
+ mbedtls_debug_set_threshold(4);
+ mbedtls_ssl_conf_dbg(&server.conf, options->srv_log_fun,
+ options->srv_log_obj);
}
#endif
- TEST_ASSERT( mbedtls_mock_socket_connect( &(client.socket),
- &(server.socket),
- BUFFSIZE ) == 0 );
+ TEST_ASSERT(mbedtls_mock_socket_connect(&(client.socket),
+ &(server.socket),
+ BUFFSIZE) == 0);
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
- if( options->resize_buffers != 0 )
- {
+ if (options->resize_buffers != 0) {
/* Ensure that the buffer sizes are appropriate before resizes */
- TEST_ASSERT( client.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN );
- TEST_ASSERT( client.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN );
- TEST_ASSERT( server.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN );
- TEST_ASSERT( server.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN );
+ TEST_ASSERT(client.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
+ TEST_ASSERT(client.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
+ TEST_ASSERT(server.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
+ TEST_ASSERT(server.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
}
#endif
- if( options->expected_negotiated_version == TEST_SSL_MINOR_VERSION_NONE )
- {
+ if (options->expected_negotiated_version == TEST_SSL_MINOR_VERSION_NONE) {
expected_handshake_result = MBEDTLS_ERR_SSL_BAD_HS_PROTOCOL_VERSION;
}
- TEST_ASSERT( mbedtls_move_handshake_to_state( &(client.ssl),
- &(server.ssl),
- MBEDTLS_SSL_HANDSHAKE_OVER )
- == expected_handshake_result );
+ TEST_ASSERT(mbedtls_move_handshake_to_state(&(client.ssl),
+ &(server.ssl),
+ MBEDTLS_SSL_HANDSHAKE_OVER)
+ == expected_handshake_result);
- if( expected_handshake_result != 0 )
- {
+ if (expected_handshake_result != 0) {
/* Connection will have failed by this point, skip to cleanup */
goto exit;
}
- TEST_ASSERT( client.ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER );
- TEST_ASSERT( server.ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER );
+ TEST_ASSERT(client.ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER);
+ TEST_ASSERT(server.ssl.state == MBEDTLS_SSL_HANDSHAKE_OVER);
/* Check that we agree on the version... */
- TEST_ASSERT( client.ssl.minor_ver == server.ssl.minor_ver );
+ TEST_ASSERT(client.ssl.minor_ver == server.ssl.minor_ver);
/* And check that the version negotiated is the expected one. */
- TEST_EQUAL( client.ssl.minor_ver, options->expected_negotiated_version );
+ TEST_EQUAL(client.ssl.minor_ver, options->expected_negotiated_version);
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
- if( options->resize_buffers != 0 )
- {
- if( options->expected_negotiated_version != MBEDTLS_SSL_MINOR_VERSION_0 &&
- options->expected_negotiated_version != MBEDTLS_SSL_MINOR_VERSION_1 )
- {
+ if (options->resize_buffers != 0) {
+ if (options->expected_negotiated_version != MBEDTLS_SSL_MINOR_VERSION_0 &&
+ options->expected_negotiated_version != MBEDTLS_SSL_MINOR_VERSION_1) {
/* A server, when using DTLS, might delay a buffer resize to happen
* after it receives a message, so we force it. */
- TEST_ASSERT( exchange_data( &(client.ssl), &(server.ssl) ) == 0 );
+ TEST_ASSERT(exchange_data(&(client.ssl), &(server.ssl)) == 0);
- TEST_ASSERT( client.ssl.out_buf_len ==
- mbedtls_ssl_get_output_buflen( &client.ssl ) );
- TEST_ASSERT( client.ssl.in_buf_len ==
- mbedtls_ssl_get_input_buflen( &client.ssl ) );
- TEST_ASSERT( server.ssl.out_buf_len ==
- mbedtls_ssl_get_output_buflen( &server.ssl ) );
- TEST_ASSERT( server.ssl.in_buf_len ==
- mbedtls_ssl_get_input_buflen( &server.ssl ) );
+ TEST_ASSERT(client.ssl.out_buf_len ==
+ mbedtls_ssl_get_output_buflen(&client.ssl));
+ TEST_ASSERT(client.ssl.in_buf_len ==
+ mbedtls_ssl_get_input_buflen(&client.ssl));
+ TEST_ASSERT(server.ssl.out_buf_len ==
+ mbedtls_ssl_get_output_buflen(&server.ssl));
+ TEST_ASSERT(server.ssl.in_buf_len ==
+ mbedtls_ssl_get_input_buflen(&server.ssl));
}
}
#endif
- if( options->cli_msg_len != 0 || options->srv_msg_len != 0 )
- {
+ if (options->cli_msg_len != 0 || options->srv_msg_len != 0) {
/* Start data exchanging test */
- TEST_ASSERT( mbedtls_exchange_data( &(client.ssl), options->cli_msg_len,
- options->expected_cli_fragments,
- &(server.ssl), options->srv_msg_len,
- options->expected_srv_fragments )
- == 0 );
+ TEST_ASSERT(mbedtls_exchange_data(&(client.ssl), options->cli_msg_len,
+ options->expected_cli_fragments,
+ &(server.ssl), options->srv_msg_len,
+ options->expected_srv_fragments)
+ == 0);
}
#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
- if( options->serialize == 1 )
- {
- TEST_ASSERT( options->dtls == 1 );
+ if (options->serialize == 1) {
+ TEST_ASSERT(options->dtls == 1);
- TEST_ASSERT( mbedtls_ssl_context_save( &(server.ssl), NULL,
- 0, &context_buf_len )
- == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
+ TEST_ASSERT(mbedtls_ssl_context_save(&(server.ssl), NULL,
+ 0, &context_buf_len)
+ == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
- context_buf = mbedtls_calloc( 1, context_buf_len );
- TEST_ASSERT( context_buf != NULL );
+ context_buf = mbedtls_calloc(1, context_buf_len);
+ TEST_ASSERT(context_buf != NULL);
- TEST_ASSERT( mbedtls_ssl_context_save( &(server.ssl), context_buf,
- context_buf_len,
- &context_buf_len ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_context_save(&(server.ssl), context_buf,
+ context_buf_len,
+ &context_buf_len) == 0);
- mbedtls_ssl_free( &(server.ssl) );
- mbedtls_ssl_init( &(server.ssl) );
+ mbedtls_ssl_free(&(server.ssl));
+ mbedtls_ssl_init(&(server.ssl));
- TEST_ASSERT( mbedtls_ssl_setup( &(server.ssl), &(server.conf) ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_setup(&(server.ssl), &(server.conf)) == 0);
- mbedtls_ssl_set_bio( &( server.ssl ), &server_context,
- mbedtls_mock_tcp_send_msg,
- mbedtls_mock_tcp_recv_msg,
- NULL );
+ mbedtls_ssl_set_bio(&(server.ssl), &server_context,
+ mbedtls_mock_tcp_send_msg,
+ mbedtls_mock_tcp_recv_msg,
+ NULL);
#if defined(MBEDTLS_TIMING_C)
- mbedtls_ssl_set_timer_cb( &server.ssl, &timer_server,
- mbedtls_timing_set_delay,
- mbedtls_timing_get_delay );
+ mbedtls_ssl_set_timer_cb(&server.ssl, &timer_server,
+ mbedtls_timing_set_delay,
+ mbedtls_timing_get_delay);
#endif
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
- if( options->resize_buffers != 0 )
- {
+ if (options->resize_buffers != 0) {
/* Ensure that the buffer sizes are appropriate before resizes */
- TEST_ASSERT( server.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN );
- TEST_ASSERT( server.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN );
+ TEST_ASSERT(server.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
+ TEST_ASSERT(server.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
}
#endif
- TEST_ASSERT( mbedtls_ssl_context_load( &( server.ssl ), context_buf,
- context_buf_len ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_context_load(&(server.ssl), context_buf,
+ context_buf_len) == 0);
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
/* Validate buffer sizes after context deserialization */
- if( options->resize_buffers != 0 )
- {
- TEST_ASSERT( server.ssl.out_buf_len ==
- mbedtls_ssl_get_output_buflen( &server.ssl ) );
- TEST_ASSERT( server.ssl.in_buf_len ==
- mbedtls_ssl_get_input_buflen( &server.ssl ) );
+ if (options->resize_buffers != 0) {
+ TEST_ASSERT(server.ssl.out_buf_len ==
+ mbedtls_ssl_get_output_buflen(&server.ssl));
+ TEST_ASSERT(server.ssl.in_buf_len ==
+ mbedtls_ssl_get_input_buflen(&server.ssl));
}
#endif
/* Retest writing/reading */
- if( options->cli_msg_len != 0 || options->srv_msg_len != 0 )
- {
- TEST_ASSERT( mbedtls_exchange_data( &(client.ssl),
- options->cli_msg_len,
- options->expected_cli_fragments,
- &(server.ssl),
- options->srv_msg_len,
- options->expected_srv_fragments )
- == 0 );
+ if (options->cli_msg_len != 0 || options->srv_msg_len != 0) {
+ TEST_ASSERT(mbedtls_exchange_data(&(client.ssl),
+ options->cli_msg_len,
+ options->expected_cli_fragments,
+ &(server.ssl),
+ options->srv_msg_len,
+ options->expected_srv_fragments)
+ == 0);
}
}
#endif /* MBEDTLS_SSL_CONTEXT_SERIALIZATION */
#if defined(MBEDTLS_SSL_RENEGOTIATION)
- if( options->renegotiate )
- {
+ if (options->renegotiate) {
/* Start test with renegotiation */
- TEST_ASSERT( server.ssl.renego_status ==
- MBEDTLS_SSL_INITIAL_HANDSHAKE );
- TEST_ASSERT( client.ssl.renego_status ==
- MBEDTLS_SSL_INITIAL_HANDSHAKE );
+ TEST_ASSERT(server.ssl.renego_status ==
+ MBEDTLS_SSL_INITIAL_HANDSHAKE);
+ TEST_ASSERT(client.ssl.renego_status ==
+ MBEDTLS_SSL_INITIAL_HANDSHAKE);
/* After calling this function for the server, it only sends a handshake
* request. All renegotiation should happen during data exchanging */
- TEST_ASSERT( mbedtls_ssl_renegotiate( &(server.ssl) ) == 0 );
- TEST_ASSERT( server.ssl.renego_status ==
- MBEDTLS_SSL_RENEGOTIATION_PENDING );
- TEST_ASSERT( client.ssl.renego_status ==
- MBEDTLS_SSL_INITIAL_HANDSHAKE );
+ TEST_ASSERT(mbedtls_ssl_renegotiate(&(server.ssl)) == 0);
+ TEST_ASSERT(server.ssl.renego_status ==
+ MBEDTLS_SSL_RENEGOTIATION_PENDING);
+ TEST_ASSERT(client.ssl.renego_status ==
+ MBEDTLS_SSL_INITIAL_HANDSHAKE);
- TEST_ASSERT( exchange_data( &(client.ssl), &(server.ssl) ) == 0 );
- TEST_ASSERT( server.ssl.renego_status ==
- MBEDTLS_SSL_RENEGOTIATION_DONE );
- TEST_ASSERT( client.ssl.renego_status ==
- MBEDTLS_SSL_RENEGOTIATION_DONE );
+ TEST_ASSERT(exchange_data(&(client.ssl), &(server.ssl)) == 0);
+ TEST_ASSERT(server.ssl.renego_status ==
+ MBEDTLS_SSL_RENEGOTIATION_DONE);
+ TEST_ASSERT(client.ssl.renego_status ==
+ MBEDTLS_SSL_RENEGOTIATION_DONE);
/* After calling mbedtls_ssl_renegotiate for the client all renegotiation
* should happen inside this function. However in this test, we cannot
* perform simultaneous communication between client and server so this
* function will return waiting error on the socket. All rest of
* renegotiation should happen during data exchanging */
- ret = mbedtls_ssl_renegotiate( &(client.ssl) );
+ ret = mbedtls_ssl_renegotiate(&(client.ssl));
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
- if( options->resize_buffers != 0 )
- {
+ if (options->resize_buffers != 0) {
/* Ensure that the buffer sizes are appropriate before resizes */
- TEST_ASSERT( client.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN );
- TEST_ASSERT( client.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN );
+ TEST_ASSERT(client.ssl.out_buf_len == MBEDTLS_SSL_OUT_BUFFER_LEN);
+ TEST_ASSERT(client.ssl.in_buf_len == MBEDTLS_SSL_IN_BUFFER_LEN);
}
#endif
- TEST_ASSERT( ret == 0 ||
- ret == MBEDTLS_ERR_SSL_WANT_READ ||
- ret == MBEDTLS_ERR_SSL_WANT_WRITE );
- TEST_ASSERT( server.ssl.renego_status ==
- MBEDTLS_SSL_RENEGOTIATION_DONE );
- TEST_ASSERT( client.ssl.renego_status ==
- MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS );
+ TEST_ASSERT(ret == 0 ||
+ ret == MBEDTLS_ERR_SSL_WANT_READ ||
+ ret == MBEDTLS_ERR_SSL_WANT_WRITE);
+ TEST_ASSERT(server.ssl.renego_status ==
+ MBEDTLS_SSL_RENEGOTIATION_DONE);
+ TEST_ASSERT(client.ssl.renego_status ==
+ MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS);
- TEST_ASSERT( exchange_data( &(client.ssl), &(server.ssl) ) == 0 );
- TEST_ASSERT( server.ssl.renego_status ==
- MBEDTLS_SSL_RENEGOTIATION_DONE );
- TEST_ASSERT( client.ssl.renego_status ==
- MBEDTLS_SSL_RENEGOTIATION_DONE );
+ TEST_ASSERT(exchange_data(&(client.ssl), &(server.ssl)) == 0);
+ TEST_ASSERT(server.ssl.renego_status ==
+ MBEDTLS_SSL_RENEGOTIATION_DONE);
+ TEST_ASSERT(client.ssl.renego_status ==
+ MBEDTLS_SSL_RENEGOTIATION_DONE);
#if defined(MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH)
/* Validate buffer sizes after renegotiation */
- if( options->resize_buffers != 0 )
- {
- TEST_ASSERT( client.ssl.out_buf_len ==
- mbedtls_ssl_get_output_buflen( &client.ssl ) );
- TEST_ASSERT( client.ssl.in_buf_len ==
- mbedtls_ssl_get_input_buflen( &client.ssl ) );
- TEST_ASSERT( server.ssl.out_buf_len ==
- mbedtls_ssl_get_output_buflen( &server.ssl ) );
- TEST_ASSERT( server.ssl.in_buf_len ==
- mbedtls_ssl_get_input_buflen( &server.ssl ) );
+ if (options->resize_buffers != 0) {
+ TEST_ASSERT(client.ssl.out_buf_len ==
+ mbedtls_ssl_get_output_buflen(&client.ssl));
+ TEST_ASSERT(client.ssl.in_buf_len ==
+ mbedtls_ssl_get_input_buflen(&client.ssl));
+ TEST_ASSERT(server.ssl.out_buf_len ==
+ mbedtls_ssl_get_output_buflen(&server.ssl));
+ TEST_ASSERT(server.ssl.in_buf_len ==
+ mbedtls_ssl_get_input_buflen(&server.ssl));
}
#endif /* MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH */
}
#endif /* MBEDTLS_SSL_RENEGOTIATION */
exit:
- mbedtls_endpoint_free( &client, options->dtls != 0 ? &client_context : NULL );
- mbedtls_endpoint_free( &server, options->dtls != 0 ? &server_context : NULL );
-#if defined (MBEDTLS_DEBUG_C)
- if( options->cli_log_fun || options->srv_log_fun )
- {
- mbedtls_debug_set_threshold( 0 );
+ mbedtls_endpoint_free(&client, options->dtls != 0 ? &client_context : NULL);
+ mbedtls_endpoint_free(&server, options->dtls != 0 ? &server_context : NULL);
+#if defined(MBEDTLS_DEBUG_C)
+ if (options->cli_log_fun || options->srv_log_fun) {
+ mbedtls_debug_set_threshold(0);
}
#endif
#if defined(MBEDTLS_SSL_CONTEXT_SERIALIZATION)
- if( context_buf != NULL )
- mbedtls_free( context_buf );
+ if (context_buf != NULL) {
+ mbedtls_free(context_buf);
+ }
#endif
}
#endif /* MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED && MBEDTLS_ENTROPY_C && MBEDTLS_CTR_DRBG_C */
@@ -2109,56 +2010,56 @@
unsigned char input[MSGLEN];
unsigned char output[MSGLEN];
- memset( input, 0, sizeof( input ) );
+ memset(input, 0, sizeof(input));
/* Make sure calling put and get on NULL buffer results in error. */
- TEST_ASSERT( mbedtls_test_buffer_put( NULL, input, sizeof( input ) )
- == -1 );
- TEST_ASSERT( mbedtls_test_buffer_get( NULL, output, sizeof( output ) )
- == -1 );
- TEST_ASSERT( mbedtls_test_buffer_put( NULL, NULL, sizeof( input ) ) == -1 );
+ TEST_ASSERT(mbedtls_test_buffer_put(NULL, input, sizeof(input))
+ == -1);
+ TEST_ASSERT(mbedtls_test_buffer_get(NULL, output, sizeof(output))
+ == -1);
+ TEST_ASSERT(mbedtls_test_buffer_put(NULL, NULL, sizeof(input)) == -1);
- TEST_ASSERT( mbedtls_test_buffer_put( NULL, NULL, 0 ) == -1 );
- TEST_ASSERT( mbedtls_test_buffer_get( NULL, NULL, 0 ) == -1 );
+ TEST_ASSERT(mbedtls_test_buffer_put(NULL, NULL, 0) == -1);
+ TEST_ASSERT(mbedtls_test_buffer_get(NULL, NULL, 0) == -1);
/* Make sure calling put and get on a buffer that hasn't been set up results
* in error. */
- mbedtls_test_buffer_init( &buf );
+ mbedtls_test_buffer_init(&buf);
- TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, sizeof( input ) ) == -1 );
- TEST_ASSERT( mbedtls_test_buffer_get( &buf, output, sizeof( output ) )
- == -1 );
- TEST_ASSERT( mbedtls_test_buffer_put( &buf, NULL, sizeof( input ) ) == -1 );
+ TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, sizeof(input)) == -1);
+ TEST_ASSERT(mbedtls_test_buffer_get(&buf, output, sizeof(output))
+ == -1);
+ TEST_ASSERT(mbedtls_test_buffer_put(&buf, NULL, sizeof(input)) == -1);
- TEST_ASSERT( mbedtls_test_buffer_put( &buf, NULL, 0 ) == -1 );
- TEST_ASSERT( mbedtls_test_buffer_get( &buf, NULL, 0 ) == -1 );
+ TEST_ASSERT(mbedtls_test_buffer_put(&buf, NULL, 0) == -1);
+ TEST_ASSERT(mbedtls_test_buffer_get(&buf, NULL, 0) == -1);
/* Make sure calling put and get on NULL input only results in
* error if the length is not zero, and that a NULL output is valid for data
* dropping.
*/
- TEST_ASSERT( mbedtls_test_buffer_setup( &buf, sizeof( input ) ) == 0 );
+ TEST_ASSERT(mbedtls_test_buffer_setup(&buf, sizeof(input)) == 0);
- TEST_ASSERT( mbedtls_test_buffer_put( &buf, NULL, sizeof( input ) ) == -1 );
- TEST_ASSERT( mbedtls_test_buffer_get( &buf, NULL, sizeof( output ) )
- == 0 );
- TEST_ASSERT( mbedtls_test_buffer_put( &buf, NULL, 0 ) == 0 );
- TEST_ASSERT( mbedtls_test_buffer_get( &buf, NULL, 0 ) == 0 );
+ TEST_ASSERT(mbedtls_test_buffer_put(&buf, NULL, sizeof(input)) == -1);
+ TEST_ASSERT(mbedtls_test_buffer_get(&buf, NULL, sizeof(output))
+ == 0);
+ TEST_ASSERT(mbedtls_test_buffer_put(&buf, NULL, 0) == 0);
+ TEST_ASSERT(mbedtls_test_buffer_get(&buf, NULL, 0) == 0);
/* Make sure calling put several times in the row is safe */
- TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, sizeof( input ) )
- == sizeof( input ) );
- TEST_ASSERT( mbedtls_test_buffer_get( &buf, output, 2 ) == 2 );
- TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, 1 ) == 1 );
- TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, 2 ) == 1 );
- TEST_ASSERT( mbedtls_test_buffer_put( &buf, input, 2 ) == 0 );
+ TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, sizeof(input))
+ == sizeof(input));
+ TEST_ASSERT(mbedtls_test_buffer_get(&buf, output, 2) == 2);
+ TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, 1) == 1);
+ TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, 2) == 1);
+ TEST_ASSERT(mbedtls_test_buffer_put(&buf, input, 2) == 0);
exit:
- mbedtls_test_buffer_free( &buf );
+ mbedtls_test_buffer_free(&buf);
}
/* END_CASE */
@@ -2176,9 +2077,9 @@
*/
/* BEGIN_CASE */
-void test_callback_buffer( int size, int put1, int put1_ret,
- int get1, int get1_ret, int put2, int put2_ret,
- int get2, int get2_ret )
+void test_callback_buffer(int size, int put1, int put1_ret,
+ int get1, int get1_ret, int put2, int put2_ret,
+ int get2, int get2_ret)
{
enum { ROUNDS = 2 };
size_t put[ROUNDS];
@@ -2186,96 +2087,91 @@
size_t get[ROUNDS];
int get_ret[ROUNDS];
mbedtls_test_buffer buf;
- unsigned char* input = NULL;
+ unsigned char *input = NULL;
size_t input_len;
- unsigned char* output = NULL;
+ unsigned char *output = NULL;
size_t output_len;
size_t i, j, written, read;
- mbedtls_test_buffer_init( &buf );
- TEST_ASSERT( mbedtls_test_buffer_setup( &buf, size ) == 0 );
+ mbedtls_test_buffer_init(&buf);
+ TEST_ASSERT(mbedtls_test_buffer_setup(&buf, size) == 0);
/* Check the sanity of input parameters and initialise local variables. That
* is, ensure that the amount of data is not negative and that we are not
* expecting more to put or get than we actually asked for. */
- TEST_ASSERT( put1 >= 0 );
+ TEST_ASSERT(put1 >= 0);
put[0] = put1;
put_ret[0] = put1_ret;
- TEST_ASSERT( put1_ret <= put1 );
- TEST_ASSERT( put2 >= 0 );
+ TEST_ASSERT(put1_ret <= put1);
+ TEST_ASSERT(put2 >= 0);
put[1] = put2;
put_ret[1] = put2_ret;
- TEST_ASSERT( put2_ret <= put2 );
+ TEST_ASSERT(put2_ret <= put2);
- TEST_ASSERT( get1 >= 0 );
+ TEST_ASSERT(get1 >= 0);
get[0] = get1;
get_ret[0] = get1_ret;
- TEST_ASSERT( get1_ret <= get1 );
- TEST_ASSERT( get2 >= 0 );
+ TEST_ASSERT(get1_ret <= get1);
+ TEST_ASSERT(get2 >= 0);
get[1] = get2;
get_ret[1] = get2_ret;
- TEST_ASSERT( get2_ret <= get2 );
+ TEST_ASSERT(get2_ret <= get2);
input_len = 0;
/* Calculate actual input and output lengths */
- for( j = 0; j < ROUNDS; j++ )
- {
- if( put_ret[j] > 0 )
- {
+ for (j = 0; j < ROUNDS; j++) {
+ if (put_ret[j] > 0) {
input_len += put_ret[j];
}
}
/* In order to always have a valid pointer we always allocate at least 1
* byte. */
- if( input_len == 0 )
+ if (input_len == 0) {
input_len = 1;
- ASSERT_ALLOC( input, input_len );
+ }
+ ASSERT_ALLOC(input, input_len);
output_len = 0;
- for( j = 0; j < ROUNDS; j++ )
- {
- if( get_ret[j] > 0 )
- {
+ for (j = 0; j < ROUNDS; j++) {
+ if (get_ret[j] > 0) {
output_len += get_ret[j];
}
}
- TEST_ASSERT( output_len <= input_len );
+ TEST_ASSERT(output_len <= input_len);
/* In order to always have a valid pointer we always allocate at least 1
* byte. */
- if( output_len == 0 )
+ if (output_len == 0) {
output_len = 1;
- ASSERT_ALLOC( output, output_len );
+ }
+ ASSERT_ALLOC(output, output_len);
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
- for( i = 0; i < input_len; i++ )
- {
+ for (i = 0; i < input_len; i++) {
input[i] = i & 0xFF;
}
written = read = 0;
- for( j = 0; j < ROUNDS; j++ )
- {
- TEST_ASSERT( put_ret[j] == mbedtls_test_buffer_put( &buf,
- input + written, put[j] ) );
+ for (j = 0; j < ROUNDS; j++) {
+ TEST_ASSERT(put_ret[j] == mbedtls_test_buffer_put(&buf,
+ input + written, put[j]));
written += put_ret[j];
- TEST_ASSERT( get_ret[j] == mbedtls_test_buffer_get( &buf,
- output + read, get[j] ) );
+ TEST_ASSERT(get_ret[j] == mbedtls_test_buffer_get(&buf,
+ output + read, get[j]));
read += get_ret[j];
- TEST_ASSERT( read <= written );
- if( get_ret[j] > 0 )
- {
- TEST_ASSERT( memcmp( output + read - get_ret[j],
- input + read - get_ret[j], get_ret[j] )
- == 0 );
+ TEST_ASSERT(read <= written);
+ if (get_ret[j] > 0) {
+ TEST_ASSERT(memcmp(output + read - get_ret[j],
+ input + read - get_ret[j], get_ret[j])
+ == 0);
}
}
exit:
- mbedtls_free( input );
- mbedtls_free( output );
- mbedtls_test_buffer_free( &buf );
+ mbedtls_free(input);
+ mbedtls_free(output);
+ mbedtls_test_buffer_free(&buf);
}
/* END_CASE */
@@ -2285,30 +2181,30 @@
*/
/* BEGIN_CASE */
-void ssl_mock_sanity( )
+void ssl_mock_sanity()
{
enum { MSGLEN = 105 };
unsigned char message[MSGLEN] = { 0 };
unsigned char received[MSGLEN] = { 0 };
mbedtls_mock_socket socket;
- mbedtls_mock_socket_init( &socket );
- TEST_ASSERT( mbedtls_mock_tcp_send_b( &socket, message, MSGLEN ) < 0 );
- mbedtls_mock_socket_close( &socket );
- mbedtls_mock_socket_init( &socket );
- TEST_ASSERT( mbedtls_mock_tcp_recv_b( &socket, received, MSGLEN ) < 0 );
- mbedtls_mock_socket_close( &socket );
+ mbedtls_mock_socket_init(&socket);
+ TEST_ASSERT(mbedtls_mock_tcp_send_b(&socket, message, MSGLEN) < 0);
+ mbedtls_mock_socket_close(&socket);
+ mbedtls_mock_socket_init(&socket);
+ TEST_ASSERT(mbedtls_mock_tcp_recv_b(&socket, received, MSGLEN) < 0);
+ mbedtls_mock_socket_close(&socket);
- mbedtls_mock_socket_init( &socket );
- TEST_ASSERT( mbedtls_mock_tcp_send_nb( &socket, message, MSGLEN ) < 0 );
- mbedtls_mock_socket_close( &socket );
- mbedtls_mock_socket_init( &socket );
- TEST_ASSERT( mbedtls_mock_tcp_recv_nb( &socket, received, MSGLEN ) < 0 );
- mbedtls_mock_socket_close( &socket );
+ mbedtls_mock_socket_init(&socket);
+ TEST_ASSERT(mbedtls_mock_tcp_send_nb(&socket, message, MSGLEN) < 0);
+ mbedtls_mock_socket_close(&socket);
+ mbedtls_mock_socket_init(&socket);
+ TEST_ASSERT(mbedtls_mock_tcp_recv_nb(&socket, received, MSGLEN) < 0);
+ mbedtls_mock_socket_close(&socket);
exit:
- mbedtls_mock_socket_close( &socket );
+ mbedtls_mock_socket_close(&socket);
}
/* END_CASE */
@@ -2318,7 +2214,7 @@
*/
/* BEGIN_CASE */
-void ssl_mock_tcp( int blocking )
+void ssl_mock_tcp(int blocking)
{
enum { MSGLEN = 105 };
enum { BUFLEN = MSGLEN / 5 };
@@ -2332,94 +2228,76 @@
mbedtls_ssl_recv_t *recv;
unsigned i;
- if( blocking == 0 )
- {
+ if (blocking == 0) {
send = mbedtls_mock_tcp_send_nb;
recv = mbedtls_mock_tcp_recv_nb;
- }
- else
- {
+ } else {
send = mbedtls_mock_tcp_send_b;
recv = mbedtls_mock_tcp_recv_b;
}
- mbedtls_mock_socket_init( &client );
- mbedtls_mock_socket_init( &server );
+ mbedtls_mock_socket_init(&client);
+ mbedtls_mock_socket_init(&server);
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
- for( i = 0; i < MSGLEN; i++ )
- {
+ for (i = 0; i < MSGLEN; i++) {
message[i] = i & 0xFF;
}
/* Make sure that sending a message takes a few iterations. */
- TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server, BUFLEN ) );
+ TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server, BUFLEN));
/* Send the message to the server */
send_ret = recv_ret = 1;
written = read = 0;
- while( send_ret != 0 || recv_ret != 0 )
- {
- send_ret = send( &client, message + written, MSGLEN - written );
+ while (send_ret != 0 || recv_ret != 0) {
+ send_ret = send(&client, message + written, MSGLEN - written);
- TEST_ASSERT( send_ret >= 0 );
- TEST_ASSERT( send_ret <= BUFLEN );
+ TEST_ASSERT(send_ret >= 0);
+ TEST_ASSERT(send_ret <= BUFLEN);
written += send_ret;
/* If the buffer is full we can test blocking and non-blocking send */
- if ( send_ret == BUFLEN )
- {
- int blocking_ret = send( &client, message , 1 );
- if ( blocking )
- {
- TEST_ASSERT( blocking_ret == 0 );
- }
- else
- {
- TEST_ASSERT( blocking_ret == MBEDTLS_ERR_SSL_WANT_WRITE );
+ if (send_ret == BUFLEN) {
+ int blocking_ret = send(&client, message, 1);
+ if (blocking) {
+ TEST_ASSERT(blocking_ret == 0);
+ } else {
+ TEST_ASSERT(blocking_ret == MBEDTLS_ERR_SSL_WANT_WRITE);
}
}
- recv_ret = recv( &server, received + read, MSGLEN - read );
+ recv_ret = recv(&server, received + read, MSGLEN - read);
/* The result depends on whether any data was sent */
- if ( send_ret > 0 )
- {
- TEST_ASSERT( recv_ret > 0 );
- TEST_ASSERT( recv_ret <= BUFLEN );
+ if (send_ret > 0) {
+ TEST_ASSERT(recv_ret > 0);
+ TEST_ASSERT(recv_ret <= BUFLEN);
read += recv_ret;
- }
- else if( blocking )
- {
- TEST_ASSERT( recv_ret == 0 );
- }
- else
- {
- TEST_ASSERT( recv_ret == MBEDTLS_ERR_SSL_WANT_READ );
+ } else if (blocking) {
+ TEST_ASSERT(recv_ret == 0);
+ } else {
+ TEST_ASSERT(recv_ret == MBEDTLS_ERR_SSL_WANT_READ);
recv_ret = 0;
}
/* If the buffer is empty we can test blocking and non-blocking read */
- if ( recv_ret == BUFLEN )
- {
- int blocking_ret = recv( &server, received, 1 );
- if ( blocking )
- {
- TEST_ASSERT( blocking_ret == 0 );
- }
- else
- {
- TEST_ASSERT( blocking_ret == MBEDTLS_ERR_SSL_WANT_READ );
+ if (recv_ret == BUFLEN) {
+ int blocking_ret = recv(&server, received, 1);
+ if (blocking) {
+ TEST_ASSERT(blocking_ret == 0);
+ } else {
+ TEST_ASSERT(blocking_ret == MBEDTLS_ERR_SSL_WANT_READ);
}
}
}
- TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
+ TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
exit:
- mbedtls_mock_socket_close( &client );
- mbedtls_mock_socket_close( &server );
+ mbedtls_mock_socket_close(&client);
+ mbedtls_mock_socket_close(&server);
}
/* END_CASE */
@@ -2430,7 +2308,7 @@
*/
/* BEGIN_CASE */
-void ssl_mock_tcp_interleaving( int blocking )
+void ssl_mock_tcp_interleaving(int blocking)
{
enum { ROUNDS = 2 };
enum { MSGLEN = 105 };
@@ -2447,305 +2325,283 @@
mbedtls_ssl_send_t *send;
mbedtls_ssl_recv_t *recv;
- if( blocking == 0 )
- {
+ if (blocking == 0) {
send = mbedtls_mock_tcp_send_nb;
recv = mbedtls_mock_tcp_recv_nb;
- }
- else
- {
+ } else {
send = mbedtls_mock_tcp_send_b;
recv = mbedtls_mock_tcp_recv_b;
}
- mbedtls_mock_socket_init( &client );
- mbedtls_mock_socket_init( &server );
+ mbedtls_mock_socket_init(&client);
+ mbedtls_mock_socket_init(&server);
/* Fill up the buffers with structured data so that unwanted changes
* can be detected */
- for( i = 0; i < ROUNDS; i++ )
- {
- for( j = 0; j < MSGLEN; j++ )
- {
- message[i][j] = ( i * MSGLEN + j ) & 0xFF;
+ for (i = 0; i < ROUNDS; i++) {
+ for (j = 0; j < MSGLEN; j++) {
+ message[i][j] = (i * MSGLEN + j) & 0xFF;
}
}
/* Make sure that sending a message takes a few iterations. */
- TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server, BUFLEN ) );
+ TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server, BUFLEN));
/* Send the message from both sides, interleaving. */
progress = 1;
- for( i = 0; i < ROUNDS; i++ )
- {
+ for (i = 0; i < ROUNDS; i++) {
written[i] = 0;
read[i] = 0;
}
/* This loop does not stop as long as there was a successful write or read
* of at least one byte on either side. */
- while( progress != 0 )
- {
+ while (progress != 0) {
mbedtls_mock_socket *socket;
- for( i = 0; i < ROUNDS; i++ )
- {
+ for (i = 0; i < ROUNDS; i++) {
/* First sending is from the client */
- socket = ( i % 2 == 0 ) ? ( &client ) : ( &server );
+ socket = (i % 2 == 0) ? (&client) : (&server);
- send_ret[i] = send( socket, message[i] + written[i],
- MSGLEN - written[i] );
- TEST_ASSERT( send_ret[i] >= 0 );
- TEST_ASSERT( send_ret[i] <= BUFLEN );
+ send_ret[i] = send(socket, message[i] + written[i],
+ MSGLEN - written[i]);
+ TEST_ASSERT(send_ret[i] >= 0);
+ TEST_ASSERT(send_ret[i] <= BUFLEN);
written[i] += send_ret[i];
/* If the buffer is full we can test blocking and non-blocking
* send */
- if ( send_ret[i] == BUFLEN )
- {
- int blocking_ret = send( socket, message[i] , 1 );
- if ( blocking )
- {
- TEST_ASSERT( blocking_ret == 0 );
- }
- else
- {
- TEST_ASSERT( blocking_ret == MBEDTLS_ERR_SSL_WANT_WRITE );
+ if (send_ret[i] == BUFLEN) {
+ int blocking_ret = send(socket, message[i], 1);
+ if (blocking) {
+ TEST_ASSERT(blocking_ret == 0);
+ } else {
+ TEST_ASSERT(blocking_ret == MBEDTLS_ERR_SSL_WANT_WRITE);
}
}
}
- for( i = 0; i < ROUNDS; i++ )
- {
+ for (i = 0; i < ROUNDS; i++) {
/* First receiving is from the server */
- socket = ( i % 2 == 0 ) ? ( &server ) : ( &client );
+ socket = (i % 2 == 0) ? (&server) : (&client);
- recv_ret[i] = recv( socket, received[i] + read[i],
- MSGLEN - read[i] );
+ recv_ret[i] = recv(socket, received[i] + read[i],
+ MSGLEN - read[i]);
/* The result depends on whether any data was sent */
- if ( send_ret[i] > 0 )
- {
- TEST_ASSERT( recv_ret[i] > 0 );
- TEST_ASSERT( recv_ret[i] <= BUFLEN );
+ if (send_ret[i] > 0) {
+ TEST_ASSERT(recv_ret[i] > 0);
+ TEST_ASSERT(recv_ret[i] <= BUFLEN);
read[i] += recv_ret[i];
- }
- else if( blocking )
- {
- TEST_ASSERT( recv_ret[i] == 0 );
- }
- else
- {
- TEST_ASSERT( recv_ret[i] == MBEDTLS_ERR_SSL_WANT_READ );
+ } else if (blocking) {
+ TEST_ASSERT(recv_ret[i] == 0);
+ } else {
+ TEST_ASSERT(recv_ret[i] == MBEDTLS_ERR_SSL_WANT_READ);
recv_ret[i] = 0;
}
/* If the buffer is empty we can test blocking and non-blocking
* read */
- if ( recv_ret[i] == BUFLEN )
- {
- int blocking_ret = recv( socket, received[i], 1 );
- if ( blocking )
- {
- TEST_ASSERT( blocking_ret == 0 );
- }
- else
- {
- TEST_ASSERT( blocking_ret == MBEDTLS_ERR_SSL_WANT_READ );
+ if (recv_ret[i] == BUFLEN) {
+ int blocking_ret = recv(socket, received[i], 1);
+ if (blocking) {
+ TEST_ASSERT(blocking_ret == 0);
+ } else {
+ TEST_ASSERT(blocking_ret == MBEDTLS_ERR_SSL_WANT_READ);
}
}
}
progress = 0;
- for( i = 0; i < ROUNDS; i++ )
- {
+ for (i = 0; i < ROUNDS; i++) {
progress += send_ret[i] + recv_ret[i];
}
}
- for( i = 0; i < ROUNDS; i++ )
- TEST_ASSERT( memcmp( message[i], received[i], MSGLEN ) == 0 );
+ for (i = 0; i < ROUNDS; i++) {
+ TEST_ASSERT(memcmp(message[i], received[i], MSGLEN) == 0);
+ }
exit:
- mbedtls_mock_socket_close( &client );
- mbedtls_mock_socket_close( &server );
+ mbedtls_mock_socket_close(&client);
+ mbedtls_mock_socket_close(&server);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_message_queue_sanity( )
+void ssl_message_queue_sanity()
{
mbedtls_test_message_queue queue;
/* Trying to push/pull to an empty queue */
- TEST_ASSERT( mbedtls_test_message_queue_push_info( NULL, 1 )
- == MBEDTLS_TEST_ERROR_ARG_NULL );
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( NULL, 1 )
- == MBEDTLS_TEST_ERROR_ARG_NULL );
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(NULL, 1)
+ == MBEDTLS_TEST_ERROR_ARG_NULL);
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(NULL, 1)
+ == MBEDTLS_TEST_ERROR_ARG_NULL);
- TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 3 ) == 0 );
- TEST_ASSERT( queue.capacity == 3 );
- TEST_ASSERT( queue.num == 0 );
+ TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 3) == 0);
+ TEST_ASSERT(queue.capacity == 3);
+ TEST_ASSERT(queue.num == 0);
exit:
- mbedtls_test_message_queue_free( &queue );
+ mbedtls_test_message_queue_free(&queue);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_message_queue_basic( )
+void ssl_message_queue_basic()
{
mbedtls_test_message_queue queue;
- TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 3 ) == 0 );
+ TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 3) == 0);
/* Sanity test - 3 pushes and 3 pops with sufficient space */
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
- TEST_ASSERT( queue.capacity == 3 );
- TEST_ASSERT( queue.num == 1 );
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
- TEST_ASSERT( queue.capacity == 3 );
- TEST_ASSERT( queue.num == 2 );
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 2 ) == 2 );
- TEST_ASSERT( queue.capacity == 3 );
- TEST_ASSERT( queue.num == 3 );
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
+ TEST_ASSERT(queue.capacity == 3);
+ TEST_ASSERT(queue.num == 1);
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
+ TEST_ASSERT(queue.capacity == 3);
+ TEST_ASSERT(queue.num == 2);
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 2) == 2);
+ TEST_ASSERT(queue.capacity == 3);
+ TEST_ASSERT(queue.num == 3);
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 2 ) == 2 );
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 2) == 2);
exit:
- mbedtls_test_message_queue_free( &queue );
+ mbedtls_test_message_queue_free(&queue);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_message_queue_overflow_underflow( )
+void ssl_message_queue_overflow_underflow()
{
mbedtls_test_message_queue queue;
- TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 3 ) == 0 );
+ TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 3) == 0);
/* 4 pushes (last one with an error), 4 pops (last one with an error) */
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 2 ) == 2 );
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 3 )
- == MBEDTLS_ERR_SSL_WANT_WRITE );
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 2) == 2);
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 3)
+ == MBEDTLS_ERR_SSL_WANT_WRITE);
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 2 ) == 2 );
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 2) == 2);
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 )
- == MBEDTLS_ERR_SSL_WANT_READ );
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1)
+ == MBEDTLS_ERR_SSL_WANT_READ);
exit:
- mbedtls_test_message_queue_free( &queue );
+ mbedtls_test_message_queue_free(&queue);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_message_queue_interleaved( )
+void ssl_message_queue_interleaved()
{
mbedtls_test_message_queue queue;
- TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 3 ) == 0 );
+ TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 3) == 0);
/* Interleaved test - [2 pushes, 1 pop] twice, and then two pops
* (to wrap around the buffer) */
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 1 ) == 1 );
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 1) == 1);
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 2 ) == 2 );
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 3 ) == 3 );
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 2) == 2);
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 3) == 3);
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 1 ) == 1 );
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 2 ) == 2 );
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 1) == 1);
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 2) == 2);
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 5 ) == 5 );
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, 8 ) == 8 );
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 5) == 5);
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, 8) == 8);
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 3 ) == 3 );
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 3) == 3);
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 5 ) == 5 );
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 5) == 5);
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, 8 ) == 8 );
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, 8) == 8);
exit:
- mbedtls_test_message_queue_free( &queue );
+ mbedtls_test_message_queue_free(&queue);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_message_queue_insufficient_buffer( )
+void ssl_message_queue_insufficient_buffer()
{
mbedtls_test_message_queue queue;
size_t message_len = 10;
size_t buffer_len = 5;
- TEST_ASSERT( mbedtls_test_message_queue_setup( &queue, 1 ) == 0 );
+ TEST_ASSERT(mbedtls_test_message_queue_setup(&queue, 1) == 0);
/* Popping without a sufficient buffer */
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &queue, message_len )
- == (int) message_len );
- TEST_ASSERT( mbedtls_test_message_queue_pop_info( &queue, buffer_len )
- == (int) buffer_len );
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&queue, message_len)
+ == (int) message_len);
+ TEST_ASSERT(mbedtls_test_message_queue_pop_info(&queue, buffer_len)
+ == (int) buffer_len);
exit:
- mbedtls_test_message_queue_free( &queue );
+ mbedtls_test_message_queue_free(&queue);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_message_mock_uninitialized( )
+void ssl_message_mock_uninitialized()
{
enum { MSGLEN = 10 };
- unsigned char message[MSGLEN] = {0}, received[MSGLEN];
+ unsigned char message[MSGLEN] = { 0 }, received[MSGLEN];
mbedtls_mock_socket client, server;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
- mbedtls_message_socket_init( &server_context );
- mbedtls_message_socket_init( &client_context );
+ mbedtls_message_socket_init(&server_context);
+ mbedtls_message_socket_init(&client_context);
/* Send with a NULL context */
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( NULL, message, MSGLEN )
- == MBEDTLS_TEST_ERROR_CONTEXT_ERROR );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(NULL, message, MSGLEN)
+ == MBEDTLS_TEST_ERROR_CONTEXT_ERROR);
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( NULL, message, MSGLEN )
- == MBEDTLS_TEST_ERROR_CONTEXT_ERROR );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(NULL, message, MSGLEN)
+ == MBEDTLS_TEST_ERROR_CONTEXT_ERROR);
- TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 1,
- &server,
- &server_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 1,
+ &server,
+ &server_context) == 0);
- TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 1,
- &client,
- &client_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 1,
+ &client,
+ &client_context) == 0);
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message, MSGLEN )
- == MBEDTLS_TEST_ERROR_SEND_FAILED );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message, MSGLEN)
+ == MBEDTLS_TEST_ERROR_SEND_FAILED);
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
- == MBEDTLS_ERR_SSL_WANT_READ );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+ == MBEDTLS_ERR_SSL_WANT_READ);
/* Push directly to a queue to later simulate a disconnected behavior */
- TEST_ASSERT( mbedtls_test_message_queue_push_info( &server_queue, MSGLEN )
- == MSGLEN );
+ TEST_ASSERT(mbedtls_test_message_queue_push_info(&server_queue, MSGLEN)
+ == MSGLEN);
/* Test if there's an error when trying to read from a disconnected
* socket */
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
- == MBEDTLS_TEST_ERROR_RECV_FAILED );
- exit:
- mbedtls_message_socket_close( &server_context );
- mbedtls_message_socket_close( &client_context );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+ == MBEDTLS_TEST_ERROR_RECV_FAILED);
+exit:
+ mbedtls_message_socket_close(&server_context);
+ mbedtls_message_socket_close(&client_context);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_message_mock_basic( )
+void ssl_message_mock_basic()
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN], received[MSGLEN];
@@ -2753,54 +2609,53 @@
unsigned i;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
- mbedtls_message_socket_init( &server_context );
- mbedtls_message_socket_init( &client_context );
+ mbedtls_message_socket_init(&server_context);
+ mbedtls_message_socket_init(&client_context);
- TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 1,
- &server,
- &server_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 1,
+ &server,
+ &server_context) == 0);
- TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 1,
- &client,
- &client_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 1,
+ &client,
+ &client_context) == 0);
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
- for( i = 0; i < MSGLEN; i++ )
- {
+ for (i = 0; i < MSGLEN; i++) {
message[i] = i & 0xFF;
}
- TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
- MSGLEN ) );
+ TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
+ MSGLEN));
/* Send the message to the server */
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
- MSGLEN ) == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
+ MSGLEN) == MSGLEN);
/* Read from the server */
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
- == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+ == MSGLEN);
- TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
- memset( received, 0, MSGLEN );
+ TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
+ memset(received, 0, MSGLEN);
/* Send the message to the client */
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &server_context, message,
- MSGLEN ) == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&server_context, message,
+ MSGLEN) == MSGLEN);
/* Read from the client */
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &client_context, received, MSGLEN )
- == MSGLEN );
- TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&client_context, received, MSGLEN)
+ == MSGLEN);
+ TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
- exit:
- mbedtls_message_socket_close( &server_context );
- mbedtls_message_socket_close( &client_context );
+exit:
+ mbedtls_message_socket_close(&server_context);
+ mbedtls_message_socket_close(&client_context);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_message_mock_queue_overflow_underflow( )
+void ssl_message_mock_queue_overflow_underflow()
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN], received[MSGLEN];
@@ -2808,57 +2663,56 @@
unsigned i;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
- mbedtls_message_socket_init( &server_context );
- mbedtls_message_socket_init( &client_context );
+ mbedtls_message_socket_init(&server_context);
+ mbedtls_message_socket_init(&client_context);
- TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 2,
- &server,
- &server_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 2,
+ &server,
+ &server_context) == 0);
- TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 2,
- &client,
- &client_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 2,
+ &client,
+ &client_context) == 0);
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
- for( i = 0; i < MSGLEN; i++ )
- {
+ for (i = 0; i < MSGLEN; i++) {
message[i] = i & 0xFF;
}
- TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
- MSGLEN*2 ) );
+ TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
+ MSGLEN*2));
/* Send three message to the server, last one with an error */
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
- MSGLEN - 1 ) == MSGLEN - 1 );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
+ MSGLEN - 1) == MSGLEN - 1);
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
- MSGLEN ) == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
+ MSGLEN) == MSGLEN);
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
- MSGLEN )
- == MBEDTLS_ERR_SSL_WANT_WRITE );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
+ MSGLEN)
+ == MBEDTLS_ERR_SSL_WANT_WRITE);
/* Read three messages from the server, last one with an error */
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
- MSGLEN - 1 ) == MSGLEN - 1 );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
+ MSGLEN - 1) == MSGLEN - 1);
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
- == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+ == MSGLEN);
- TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
+ TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
- == MBEDTLS_ERR_SSL_WANT_READ );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+ == MBEDTLS_ERR_SSL_WANT_READ);
- exit:
- mbedtls_message_socket_close( &server_context );
- mbedtls_message_socket_close( &client_context );
+exit:
+ mbedtls_message_socket_close(&server_context);
+ mbedtls_message_socket_close(&client_context);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_message_mock_socket_overflow( )
+void ssl_message_mock_socket_overflow()
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN], received[MSGLEN];
@@ -2866,48 +2720,47 @@
unsigned i;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
- mbedtls_message_socket_init( &server_context );
- mbedtls_message_socket_init( &client_context );
+ mbedtls_message_socket_init(&server_context);
+ mbedtls_message_socket_init(&client_context);
- TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 2,
- &server,
- &server_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 2,
+ &server,
+ &server_context) == 0);
- TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 2,
- &client,
- &client_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 2,
+ &client,
+ &client_context) == 0);
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
- for( i = 0; i < MSGLEN; i++ )
- {
+ for (i = 0; i < MSGLEN; i++) {
message[i] = i & 0xFF;
}
- TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
- MSGLEN ) );
+ TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
+ MSGLEN));
/* Send two message to the server, second one with an error */
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
- MSGLEN ) == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
+ MSGLEN) == MSGLEN);
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
- MSGLEN )
- == MBEDTLS_TEST_ERROR_SEND_FAILED );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
+ MSGLEN)
+ == MBEDTLS_TEST_ERROR_SEND_FAILED);
/* Read the only message from the server */
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
- == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+ == MSGLEN);
- TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
+ TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
- exit:
- mbedtls_message_socket_close( &server_context );
- mbedtls_message_socket_close( &client_context );
+exit:
+ mbedtls_message_socket_close(&server_context);
+ mbedtls_message_socket_close(&client_context);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_message_mock_truncated( )
+void ssl_message_mock_truncated()
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN], received[MSGLEN];
@@ -2915,58 +2768,57 @@
unsigned i;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
- mbedtls_message_socket_init( &server_context );
- mbedtls_message_socket_init( &client_context );
+ mbedtls_message_socket_init(&server_context);
+ mbedtls_message_socket_init(&client_context);
- TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 2,
- &server,
- &server_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 2,
+ &server,
+ &server_context) == 0);
- TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 2,
- &client,
- &client_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 2,
+ &client,
+ &client_context) == 0);
- memset( received, 0, MSGLEN );
+ memset(received, 0, MSGLEN);
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
- for( i = 0; i < MSGLEN; i++ )
- {
+ for (i = 0; i < MSGLEN; i++) {
message[i] = i & 0xFF;
}
- TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
- 2 * MSGLEN ) );
+ TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
+ 2 * MSGLEN));
/* Send two messages to the server, the second one small enough to fit in the
* receiver's buffer. */
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
- MSGLEN ) == MSGLEN );
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
- MSGLEN / 2 ) == MSGLEN / 2 );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
+ MSGLEN) == MSGLEN);
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
+ MSGLEN / 2) == MSGLEN / 2);
/* Read a truncated message from the server */
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN/2 )
- == MSGLEN/2 );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN/2)
+ == MSGLEN/2);
/* Test that the first half of the message is valid, and second one isn't */
- TEST_ASSERT( memcmp( message, received, MSGLEN/2 ) == 0 );
- TEST_ASSERT( memcmp( message + MSGLEN/2, received + MSGLEN/2, MSGLEN/2 )
- != 0 );
- memset( received, 0, MSGLEN );
+ TEST_ASSERT(memcmp(message, received, MSGLEN/2) == 0);
+ TEST_ASSERT(memcmp(message + MSGLEN/2, received + MSGLEN/2, MSGLEN/2)
+ != 0);
+ memset(received, 0, MSGLEN);
/* Read a full message from the server */
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN/2 )
- == MSGLEN / 2 );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN/2)
+ == MSGLEN / 2);
/* Test that the first half of the message is valid */
- TEST_ASSERT( memcmp( message, received, MSGLEN/2 ) == 0 );
+ TEST_ASSERT(memcmp(message, received, MSGLEN/2) == 0);
- exit:
- mbedtls_message_socket_close( &server_context );
- mbedtls_message_socket_close( &client_context );
+exit:
+ mbedtls_message_socket_close(&server_context);
+ mbedtls_message_socket_close(&client_context);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_message_mock_socket_read_error( )
+void ssl_message_mock_socket_read_error()
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN], received[MSGLEN];
@@ -2974,53 +2826,52 @@
unsigned i;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
- mbedtls_message_socket_init( &server_context );
- mbedtls_message_socket_init( &client_context );
+ mbedtls_message_socket_init(&server_context);
+ mbedtls_message_socket_init(&client_context);
- TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 1,
- &server,
- &server_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 1,
+ &server,
+ &server_context) == 0);
- TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 1,
- &client,
- &client_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 1,
+ &client,
+ &client_context) == 0);
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
- for( i = 0; i < MSGLEN; i++ )
- {
+ for (i = 0; i < MSGLEN; i++) {
message[i] = i & 0xFF;
}
- TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
- MSGLEN ) );
+ TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
+ MSGLEN));
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
- MSGLEN ) == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
+ MSGLEN) == MSGLEN);
/* Force a read error by disconnecting the socket by hand */
server.status = 0;
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
- == MBEDTLS_TEST_ERROR_RECV_FAILED );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+ == MBEDTLS_TEST_ERROR_RECV_FAILED);
/* Return to a valid state */
server.status = MBEDTLS_MOCK_SOCKET_CONNECTED;
- memset( received, 0, sizeof( received ) );
+ memset(received, 0, sizeof(received));
/* Test that even though the server tried to read once disconnected, the
* continuity is preserved */
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
- == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+ == MSGLEN);
- TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
+ TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
- exit:
- mbedtls_message_socket_close( &server_context );
- mbedtls_message_socket_close( &client_context );
+exit:
+ mbedtls_message_socket_close(&server_context);
+ mbedtls_message_socket_close(&client_context);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_message_mock_interleaved_one_way( )
+void ssl_message_mock_interleaved_one_way()
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN], received[MSGLEN];
@@ -3028,59 +2879,56 @@
unsigned i;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
- mbedtls_message_socket_init( &server_context );
- mbedtls_message_socket_init( &client_context );
+ mbedtls_message_socket_init(&server_context);
+ mbedtls_message_socket_init(&client_context);
- TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 3,
- &server,
- &server_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 3,
+ &server,
+ &server_context) == 0);
- TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 3,
- &client,
- &client_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 3,
+ &client,
+ &client_context) == 0);
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
- for( i = 0; i < MSGLEN; i++ )
- {
+ for (i = 0; i < MSGLEN; i++) {
message[i] = i & 0xFF;
}
- TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
- MSGLEN*3 ) );
+ TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
+ MSGLEN*3));
/* Interleaved test - [2 sends, 1 read] twice, and then two reads
* (to wrap around the buffer) */
- for( i = 0; i < 2; i++ )
- {
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
- MSGLEN ) == MSGLEN );
+ for (i = 0; i < 2; i++) {
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
+ MSGLEN) == MSGLEN);
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
- MSGLEN ) == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
+ MSGLEN) == MSGLEN);
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
- MSGLEN ) == MSGLEN );
- TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
- memset( received, 0, sizeof( received ) );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
+ MSGLEN) == MSGLEN);
+ TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
+ memset(received, 0, sizeof(received));
}
- for( i = 0; i < 2; i++ )
- {
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
- MSGLEN ) == MSGLEN );
+ for (i = 0; i < 2; i++) {
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
+ MSGLEN) == MSGLEN);
- TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
+ TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
}
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
- == MBEDTLS_ERR_SSL_WANT_READ );
- exit:
- mbedtls_message_socket_close( &server_context );
- mbedtls_message_socket_close( &client_context );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+ == MBEDTLS_ERR_SSL_WANT_READ);
+exit:
+ mbedtls_message_socket_close(&server_context);
+ mbedtls_message_socket_close(&client_context);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_message_mock_interleaved_two_ways( )
+void ssl_message_mock_interleaved_two_ways()
{
enum { MSGLEN = 10 };
unsigned char message[MSGLEN], received[MSGLEN];
@@ -3088,132 +2936,128 @@
unsigned i;
mbedtls_test_message_queue server_queue, client_queue;
mbedtls_test_message_socket_context server_context, client_context;
- mbedtls_message_socket_init( &server_context );
- mbedtls_message_socket_init( &client_context );
+ mbedtls_message_socket_init(&server_context);
+ mbedtls_message_socket_init(&client_context);
- TEST_ASSERT( mbedtls_message_socket_setup( &server_queue, &client_queue, 3,
- &server,
- &server_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&server_queue, &client_queue, 3,
+ &server,
+ &server_context) == 0);
- TEST_ASSERT( mbedtls_message_socket_setup( &client_queue, &server_queue, 3,
- &client,
- &client_context ) == 0 );
+ TEST_ASSERT(mbedtls_message_socket_setup(&client_queue, &server_queue, 3,
+ &client,
+ &client_context) == 0);
/* Fill up the buffer with structured data so that unwanted changes
* can be detected */
- for( i = 0; i < MSGLEN; i++ )
- {
+ for (i = 0; i < MSGLEN; i++) {
message[i] = i & 0xFF;
}
- TEST_ASSERT( 0 == mbedtls_mock_socket_connect( &client, &server,
- MSGLEN*3 ) );
+ TEST_ASSERT(0 == mbedtls_mock_socket_connect(&client, &server,
+ MSGLEN*3));
/* Interleaved test - [2 sends, 1 read] twice, both ways, and then two reads
* (to wrap around the buffer) both ways. */
- for( i = 0; i < 2; i++ )
- {
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
- MSGLEN ) == MSGLEN );
+ for (i = 0; i < 2; i++) {
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
+ MSGLEN) == MSGLEN);
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &client_context, message,
- MSGLEN ) == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&client_context, message,
+ MSGLEN) == MSGLEN);
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &server_context, message,
- MSGLEN ) == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&server_context, message,
+ MSGLEN) == MSGLEN);
- TEST_ASSERT( mbedtls_mock_tcp_send_msg( &server_context, message,
- MSGLEN ) == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_send_msg(&server_context, message,
+ MSGLEN) == MSGLEN);
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
- MSGLEN ) == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
+ MSGLEN) == MSGLEN);
- TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
+ TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
- memset( received, 0, sizeof( received ) );
+ memset(received, 0, sizeof(received));
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &client_context, received,
- MSGLEN ) == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&client_context, received,
+ MSGLEN) == MSGLEN);
- TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
+ TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
- memset( received, 0, sizeof( received ) );
+ memset(received, 0, sizeof(received));
}
- for( i = 0; i < 2; i++ )
- {
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received,
- MSGLEN ) == MSGLEN );
+ for (i = 0; i < 2; i++) {
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received,
+ MSGLEN) == MSGLEN);
- TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
- memset( received, 0, sizeof( received ) );
+ TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
+ memset(received, 0, sizeof(received));
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &client_context, received,
- MSGLEN ) == MSGLEN );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&client_context, received,
+ MSGLEN) == MSGLEN);
- TEST_ASSERT( memcmp( message, received, MSGLEN ) == 0 );
- memset( received, 0, sizeof( received ) );
+ TEST_ASSERT(memcmp(message, received, MSGLEN) == 0);
+ memset(received, 0, sizeof(received));
}
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &server_context, received, MSGLEN )
- == MBEDTLS_ERR_SSL_WANT_READ );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&server_context, received, MSGLEN)
+ == MBEDTLS_ERR_SSL_WANT_READ);
- TEST_ASSERT( mbedtls_mock_tcp_recv_msg( &client_context, received, MSGLEN )
- == MBEDTLS_ERR_SSL_WANT_READ );
- exit:
- mbedtls_message_socket_close( &server_context );
- mbedtls_message_socket_close( &client_context );
+ TEST_ASSERT(mbedtls_mock_tcp_recv_msg(&client_context, received, MSGLEN)
+ == MBEDTLS_ERR_SSL_WANT_READ);
+exit:
+ mbedtls_message_socket_close(&server_context);
+ mbedtls_message_socket_close(&client_context);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SSL_DTLS_ANTI_REPLAY */
-void ssl_dtls_replay( data_t * prevs, data_t * new, int ret )
+void ssl_dtls_replay(data_t *prevs, data_t *new, int ret)
{
uint32_t len = 0;
mbedtls_ssl_context ssl;
mbedtls_ssl_config conf;
- mbedtls_ssl_init( &ssl );
- mbedtls_ssl_config_init( &conf );
+ mbedtls_ssl_init(&ssl);
+ mbedtls_ssl_config_init(&conf);
- TEST_ASSERT( mbedtls_ssl_config_defaults( &conf,
- MBEDTLS_SSL_IS_CLIENT,
- MBEDTLS_SSL_TRANSPORT_DATAGRAM,
- MBEDTLS_SSL_PRESET_DEFAULT ) == 0 );
- TEST_ASSERT( mbedtls_ssl_setup( &ssl, &conf ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_config_defaults(&conf,
+ MBEDTLS_SSL_IS_CLIENT,
+ MBEDTLS_SSL_TRANSPORT_DATAGRAM,
+ MBEDTLS_SSL_PRESET_DEFAULT) == 0);
+ TEST_ASSERT(mbedtls_ssl_setup(&ssl, &conf) == 0);
/* Read previous record numbers */
- for( len = 0; len < prevs->len; len += 6 )
- {
- memcpy( ssl.in_ctr + 2, prevs->x + len, 6 );
- mbedtls_ssl_dtls_replay_update( &ssl );
+ for (len = 0; len < prevs->len; len += 6) {
+ memcpy(ssl.in_ctr + 2, prevs->x + len, 6);
+ mbedtls_ssl_dtls_replay_update(&ssl);
}
/* Check new number */
- memcpy( ssl.in_ctr + 2, new->x, 6 );
- TEST_ASSERT( mbedtls_ssl_dtls_replay_check( &ssl ) == ret );
+ memcpy(ssl.in_ctr + 2, new->x, 6);
+ TEST_ASSERT(mbedtls_ssl_dtls_replay_check(&ssl) == ret);
- mbedtls_ssl_free( &ssl );
- mbedtls_ssl_config_free( &conf );
+ mbedtls_ssl_free(&ssl);
+ mbedtls_ssl_config_free(&conf);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED */
-void ssl_set_hostname_twice( char *hostname0, char *hostname1 )
+void ssl_set_hostname_twice(char *hostname0, char *hostname1)
{
mbedtls_ssl_context ssl;
- mbedtls_ssl_init( &ssl );
+ mbedtls_ssl_init(&ssl);
- 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, hostname0) == 0);
+ TEST_ASSERT(mbedtls_ssl_set_hostname(&ssl, hostname1) == 0);
- mbedtls_ssl_free( &ssl );
+ mbedtls_ssl_free(&ssl);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_crypt_record( int cipher_type, int hash_id,
- int etm, int tag_mode, int ver,
- int cid0_len, int cid1_len )
+void ssl_crypt_record(int cipher_type, int hash_id,
+ int etm, int tag_mode, int ver,
+ int cid0_len, int cid1_len)
{
/*
* Test several record encryptions and decryptions
@@ -3230,27 +3074,23 @@
size_t const buflen = 512;
mbedtls_record rec, rec_backup;
- mbedtls_ssl_init( &ssl );
- mbedtls_ssl_transform_init( &t0 );
- mbedtls_ssl_transform_init( &t1 );
- TEST_ASSERT( build_transforms( &t0, &t1, cipher_type, hash_id,
- etm, tag_mode, ver,
- (size_t) cid0_len,
- (size_t) cid1_len ) == 0 );
+ mbedtls_ssl_init(&ssl);
+ mbedtls_ssl_transform_init(&t0);
+ mbedtls_ssl_transform_init(&t1);
+ TEST_ASSERT(build_transforms(&t0, &t1, cipher_type, hash_id,
+ etm, tag_mode, ver,
+ (size_t) cid0_len,
+ (size_t) cid1_len) == 0);
- TEST_ASSERT( ( buf = mbedtls_calloc( 1, buflen ) ) != NULL );
+ TEST_ASSERT((buf = mbedtls_calloc(1, buflen)) != NULL);
- while( num_records-- > 0 )
- {
+ while (num_records-- > 0) {
mbedtls_ssl_transform *t_dec, *t_enc;
/* Take turns in who's sending and who's receiving. */
- if( num_records % 3 == 0 )
- {
+ if (num_records % 3 == 0) {
t_dec = &t0;
t_enc = &t1;
- }
- else
- {
+ } else {
t_dec = &t1;
t_enc = &t0;
}
@@ -3267,7 +3107,7 @@
* type is sensible.
*/
- memset( rec.ctr, num_records, sizeof( rec.ctr ) );
+ memset(rec.ctr, num_records, sizeof(rec.ctr));
rec.type = 42;
rec.ver[0] = num_records;
rec.ver[1] = num_records;
@@ -3282,71 +3122,68 @@
* paddings. */
rec.data_len = 1 + num_records;
- memset( rec.buf + rec.data_offset, 42, rec.data_len );
+ memset(rec.buf + rec.data_offset, 42, rec.data_len);
/* Make a copy for later comparison */
rec_backup = rec;
/* Encrypt record */
- ret = mbedtls_ssl_encrypt_buf( &ssl, t_enc, &rec,
- mbedtls_test_rnd_std_rand, NULL );
- TEST_ASSERT( ret == 0 || ret == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
- if( ret != 0 )
- {
+ ret = mbedtls_ssl_encrypt_buf(&ssl, t_enc, &rec,
+ mbedtls_test_rnd_std_rand, NULL);
+ TEST_ASSERT(ret == 0 || ret == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
+ if (ret != 0) {
continue;
}
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
- if( rec.cid_len != 0 )
- {
+ if (rec.cid_len != 0) {
/* DTLS 1.2 + CID hides the real content type and
* uses a special CID content type in the protected
* record. Double-check this. */
- TEST_ASSERT( rec.type == MBEDTLS_SSL_MSG_CID );
+ TEST_ASSERT(rec.type == MBEDTLS_SSL_MSG_CID);
}
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
- if( t_enc->minor_ver == MBEDTLS_SSL_MINOR_VERSION_4 )
- {
+ if (t_enc->minor_ver == MBEDTLS_SSL_MINOR_VERSION_4) {
/* TLS 1.3 hides the real content type and
* always uses Application Data as the content type
* for protected records. Double-check this. */
- TEST_ASSERT( rec.type == MBEDTLS_SSL_MSG_APPLICATION_DATA );
+ TEST_ASSERT(rec.type == MBEDTLS_SSL_MSG_APPLICATION_DATA);
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
/* Decrypt record with t_dec */
- ret = mbedtls_ssl_decrypt_buf( &ssl, t_dec, &rec );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_ssl_decrypt_buf(&ssl, t_dec, &rec);
+ TEST_ASSERT(ret == 0);
/* Compare results */
- TEST_ASSERT( rec.type == rec_backup.type );
- TEST_ASSERT( memcmp( rec.ctr, rec_backup.ctr, 8 ) == 0 );
- TEST_ASSERT( rec.ver[0] == rec_backup.ver[0] );
- TEST_ASSERT( rec.ver[1] == rec_backup.ver[1] );
- TEST_ASSERT( rec.data_len == rec_backup.data_len );
- TEST_ASSERT( rec.data_offset == rec_backup.data_offset );
- TEST_ASSERT( memcmp( rec.buf + rec.data_offset,
- rec_backup.buf + rec_backup.data_offset,
- rec.data_len ) == 0 );
+ TEST_ASSERT(rec.type == rec_backup.type);
+ TEST_ASSERT(memcmp(rec.ctr, rec_backup.ctr, 8) == 0);
+ TEST_ASSERT(rec.ver[0] == rec_backup.ver[0]);
+ TEST_ASSERT(rec.ver[1] == rec_backup.ver[1]);
+ TEST_ASSERT(rec.data_len == rec_backup.data_len);
+ TEST_ASSERT(rec.data_offset == rec_backup.data_offset);
+ TEST_ASSERT(memcmp(rec.buf + rec.data_offset,
+ rec_backup.buf + rec_backup.data_offset,
+ rec.data_len) == 0);
}
exit:
/* Cleanup */
- mbedtls_ssl_free( &ssl );
- mbedtls_ssl_transform_free( &t0 );
- mbedtls_ssl_transform_free( &t1 );
+ mbedtls_ssl_free(&ssl);
+ mbedtls_ssl_transform_free(&t0);
+ mbedtls_ssl_transform_free(&t1);
- mbedtls_free( buf );
+ mbedtls_free(buf);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_crypt_record_small( int cipher_type, int hash_id,
- int etm, int tag_mode, int ver,
- int cid0_len, int cid1_len )
+void ssl_crypt_record_small(int cipher_type, int hash_id,
+ int etm, int tag_mode, int ver,
+ int cid0_len, int cid1_len)
{
/*
* Test pairs of encryption and decryption with an increasing
@@ -3386,26 +3223,24 @@
int seen_success; /* Indicates if in the current mode we've
* already seen a successful test. */
- mbedtls_ssl_init( &ssl );
- mbedtls_ssl_transform_init( &t0 );
- mbedtls_ssl_transform_init( &t1 );
- TEST_ASSERT( build_transforms( &t0, &t1, cipher_type, hash_id,
- etm, tag_mode, ver,
- (size_t) cid0_len,
- (size_t) cid1_len ) == 0 );
+ mbedtls_ssl_init(&ssl);
+ mbedtls_ssl_transform_init(&t0);
+ mbedtls_ssl_transform_init(&t1);
+ TEST_ASSERT(build_transforms(&t0, &t1, cipher_type, hash_id,
+ etm, tag_mode, ver,
+ (size_t) cid0_len,
+ (size_t) cid1_len) == 0);
- TEST_ASSERT( ( buf = mbedtls_calloc( 1, buflen ) ) != NULL );
+ TEST_ASSERT((buf = mbedtls_calloc(1, buflen)) != NULL);
- for( mode=1; mode <= 3; mode++ )
- {
+ for (mode = 1; mode <= 3; mode++) {
seen_success = 0;
- for( offset=0; offset <= threshold; offset++ )
- {
+ for (offset = 0; offset <= threshold; offset++) {
mbedtls_ssl_transform *t_dec, *t_enc;
t_dec = &t0;
t_enc = &t1;
- memset( rec.ctr, offset, sizeof( rec.ctr ) );
+ memset(rec.ctr, offset, sizeof(rec.ctr));
rec.type = 42;
rec.ver[0] = offset;
rec.ver[1] = offset;
@@ -3415,8 +3250,7 @@
rec.cid_len = 0;
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
- switch( mode )
- {
+ switch (mode) {
case 1: /* Space in the beginning */
rec.data_offset = offset;
rec.data_len = buflen - offset - default_post_padding;
@@ -3433,85 +3267,82 @@
break;
default:
- TEST_ASSERT( 0 );
+ TEST_ASSERT(0);
break;
}
- memset( rec.buf + rec.data_offset, 42, rec.data_len );
+ memset(rec.buf + rec.data_offset, 42, rec.data_len);
/* Make a copy for later comparison */
rec_backup = rec;
/* Encrypt record */
- ret = mbedtls_ssl_encrypt_buf( &ssl, t_enc, &rec,
- mbedtls_test_rnd_std_rand, NULL );
+ ret = mbedtls_ssl_encrypt_buf(&ssl, t_enc, &rec,
+ mbedtls_test_rnd_std_rand, NULL);
- if( ( mode == 1 || mode == 2 ) && seen_success )
- {
- TEST_ASSERT( ret == 0 );
- }
- else
- {
- TEST_ASSERT( ret == 0 || ret == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
- if( ret == 0 )
+ if ((mode == 1 || mode == 2) && seen_success) {
+ TEST_ASSERT(ret == 0);
+ } else {
+ TEST_ASSERT(ret == 0 || ret == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
+ if (ret == 0) {
seen_success = 1;
+ }
}
- if( ret != 0 )
+ if (ret != 0) {
continue;
+ }
#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
- if( rec.cid_len != 0 )
- {
+ if (rec.cid_len != 0) {
/* DTLS 1.2 + CID hides the real content type and
* uses a special CID content type in the protected
* record. Double-check this. */
- TEST_ASSERT( rec.type == MBEDTLS_SSL_MSG_CID );
+ TEST_ASSERT(rec.type == MBEDTLS_SSL_MSG_CID);
}
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
#if defined(MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL)
- if( t_enc->minor_ver == MBEDTLS_SSL_MINOR_VERSION_4 )
- {
+ if (t_enc->minor_ver == MBEDTLS_SSL_MINOR_VERSION_4) {
/* TLS 1.3 hides the real content type and
* always uses Application Data as the content type
* for protected records. Double-check this. */
- TEST_ASSERT( rec.type == MBEDTLS_SSL_MSG_APPLICATION_DATA );
+ TEST_ASSERT(rec.type == MBEDTLS_SSL_MSG_APPLICATION_DATA);
}
#endif /* MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
/* Decrypt record with t_dec */
- TEST_ASSERT( mbedtls_ssl_decrypt_buf( &ssl, t_dec, &rec ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_decrypt_buf(&ssl, t_dec, &rec) == 0);
/* Compare results */
- TEST_ASSERT( rec.type == rec_backup.type );
- TEST_ASSERT( memcmp( rec.ctr, rec_backup.ctr, 8 ) == 0 );
- TEST_ASSERT( rec.ver[0] == rec_backup.ver[0] );
- TEST_ASSERT( rec.ver[1] == rec_backup.ver[1] );
- TEST_ASSERT( rec.data_len == rec_backup.data_len );
- TEST_ASSERT( rec.data_offset == rec_backup.data_offset );
- TEST_ASSERT( memcmp( rec.buf + rec.data_offset,
- rec_backup.buf + rec_backup.data_offset,
- rec.data_len ) == 0 );
+ TEST_ASSERT(rec.type == rec_backup.type);
+ TEST_ASSERT(memcmp(rec.ctr, rec_backup.ctr, 8) == 0);
+ TEST_ASSERT(rec.ver[0] == rec_backup.ver[0]);
+ TEST_ASSERT(rec.ver[1] == rec_backup.ver[1]);
+ TEST_ASSERT(rec.data_len == rec_backup.data_len);
+ TEST_ASSERT(rec.data_offset == rec_backup.data_offset);
+ TEST_ASSERT(memcmp(rec.buf + rec.data_offset,
+ rec_backup.buf + rec_backup.data_offset,
+ rec.data_len) == 0);
}
- TEST_ASSERT( seen_success == 1 );
+ TEST_ASSERT(seen_success == 1);
}
exit:
/* Cleanup */
- mbedtls_ssl_free( &ssl );
- mbedtls_ssl_transform_free( &t0 );
- mbedtls_ssl_transform_free( &t1 );
+ mbedtls_ssl_free(&ssl);
+ mbedtls_ssl_transform_free(&t0);
+ mbedtls_ssl_transform_free(&t1);
- mbedtls_free( buf );
+ mbedtls_free(buf);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC:MBEDTLS_AES_C:MBEDTLS_SSL_PROTO_TLS1_2 */
-void ssl_decrypt_non_etm_cbc( int cipher_type, int hash_id, int trunc_hmac,
- int length_selector )
+void ssl_decrypt_non_etm_cbc(int cipher_type, int hash_id, int trunc_hmac,
+ int length_selector)
{
/*
* Test record decryption for CBC without EtM, focused on the verification
@@ -3542,50 +3373,48 @@
int exp_ret;
const unsigned char pad_max_len = 255; /* Per the standard */
- mbedtls_ssl_init( &ssl );
- mbedtls_ssl_transform_init( &t0 );
- mbedtls_ssl_transform_init( &t1 );
+ mbedtls_ssl_init(&ssl);
+ mbedtls_ssl_transform_init(&t0);
+ mbedtls_ssl_transform_init(&t1);
/* Set up transforms with dummy keys */
- TEST_ASSERT( build_transforms( &t0, &t1, cipher_type, hash_id,
- 0, trunc_hmac,
- MBEDTLS_SSL_MINOR_VERSION_3,
- 0 , 0 ) == 0 );
+ TEST_ASSERT(build_transforms(&t0, &t1, cipher_type, hash_id,
+ 0, trunc_hmac,
+ MBEDTLS_SSL_MINOR_VERSION_3,
+ 0, 0) == 0);
/* Determine padding/plaintext length */
- TEST_ASSERT( length_selector >= -2 && length_selector <= 255 );
+ TEST_ASSERT(length_selector >= -2 && length_selector <= 255);
block_size = t0.ivlen;
- if( length_selector < 0 )
- {
+ if (length_selector < 0) {
plaintext_len = 0;
/* Minimal padding
* The +1 is for the padding_length byte, not counted in padlen. */
- padlen = block_size - ( t0.maclen + 1 ) % block_size;
+ padlen = block_size - (t0.maclen + 1) % block_size;
/* Maximal padding? */
- if( length_selector == -2 )
- padlen += block_size * ( ( pad_max_len - padlen ) / block_size );
- }
- else
- {
+ if (length_selector == -2) {
+ padlen += block_size * ((pad_max_len - padlen) / block_size);
+ }
+ } else {
padlen = length_selector;
/* Minimal non-zero plaintext_length giving desired padding.
* The +1 is for the padding_length byte, not counted in padlen. */
- plaintext_len = block_size - ( padlen + t0.maclen + 1 ) % block_size;
+ plaintext_len = block_size - (padlen + t0.maclen + 1) % block_size;
}
/* Prepare a buffer for record data */
buflen = block_size
- + plaintext_len
- + t0.maclen
- + padlen + 1;
- ASSERT_ALLOC( buf, buflen );
- ASSERT_ALLOC( buf_save, buflen );
+ + plaintext_len
+ + t0.maclen
+ + padlen + 1;
+ ASSERT_ALLOC(buf, buflen);
+ ASSERT_ALLOC(buf_save, buflen);
/* Prepare a dummy record header */
- memset( rec.ctr, 0, sizeof( rec.ctr ) );
+ memset(rec.ctr, 0, sizeof(rec.ctr));
rec.type = MBEDTLS_SSL_MSG_APPLICATION_DATA;
rec.ver[0] = MBEDTLS_SSL_MAJOR_VERSION_3;
rec.ver[1] = MBEDTLS_SSL_MINOR_VERSION_3;
@@ -3598,82 +3427,81 @@
rec.buf_len = buflen;
rec.data_offset = block_size;
rec.data_len = plaintext_len;
- memset( rec.buf + rec.data_offset, 42, rec.data_len );
+ memset(rec.buf + rec.data_offset, 42, rec.data_len);
/* Serialized version of record header for MAC purposes */
- memcpy( add_data, rec.ctr, 8 );
+ memcpy(add_data, rec.ctr, 8);
add_data[8] = rec.type;
add_data[9] = rec.ver[0];
add_data[10] = rec.ver[1];
- add_data[11] = ( rec.data_len >> 8 ) & 0xff;
- add_data[12] = ( rec.data_len >> 0 ) & 0xff;
+ add_data[11] = (rec.data_len >> 8) & 0xff;
+ add_data[12] = (rec.data_len >> 0) & 0xff;
/* Set dummy IV */
- memset( t0.iv_enc, 0x55, t0.ivlen );
- memcpy( rec.buf, t0.iv_enc, t0.ivlen );
+ memset(t0.iv_enc, 0x55, t0.ivlen);
+ memcpy(rec.buf, t0.iv_enc, t0.ivlen);
/*
* Prepare a pre-encryption record (with MAC and padding), and save it.
*/
/* MAC with additional data */
- TEST_EQUAL( 0, mbedtls_md_hmac_update( &t0.md_ctx_enc, add_data, 13 ) );
- TEST_EQUAL( 0, mbedtls_md_hmac_update( &t0.md_ctx_enc,
- rec.buf + rec.data_offset,
- rec.data_len ) );
- TEST_EQUAL( 0, mbedtls_md_hmac_finish( &t0.md_ctx_enc, mac ) );
+ TEST_EQUAL(0, mbedtls_md_hmac_update(&t0.md_ctx_enc, add_data, 13));
+ TEST_EQUAL(0, mbedtls_md_hmac_update(&t0.md_ctx_enc,
+ rec.buf + rec.data_offset,
+ rec.data_len));
+ TEST_EQUAL(0, mbedtls_md_hmac_finish(&t0.md_ctx_enc, mac));
- memcpy( rec.buf + rec.data_offset + rec.data_len, mac, t0.maclen );
+ memcpy(rec.buf + rec.data_offset + rec.data_len, mac, t0.maclen);
rec.data_len += t0.maclen;
/* Pad */
- memset( rec.buf + rec.data_offset + rec.data_len, padlen, padlen + 1 );
+ memset(rec.buf + rec.data_offset + rec.data_len, padlen, padlen + 1);
rec.data_len += padlen + 1;
/* Save correct pre-encryption record */
rec_save = rec;
rec_save.buf = buf_save;
- memcpy( buf_save, buf, buflen );
+ memcpy(buf_save, buf, buflen);
/*
* Encrypt and decrypt the correct record, expecting success
*/
- TEST_EQUAL( 0, mbedtls_cipher_crypt( &t0.cipher_ctx_enc,
- t0.iv_enc, t0.ivlen,
- rec.buf + rec.data_offset, rec.data_len,
- rec.buf + rec.data_offset, &olen ) );
+ TEST_EQUAL(0, mbedtls_cipher_crypt(&t0.cipher_ctx_enc,
+ t0.iv_enc, t0.ivlen,
+ rec.buf + rec.data_offset, rec.data_len,
+ rec.buf + rec.data_offset, &olen));
rec.data_offset -= t0.ivlen;
rec.data_len += t0.ivlen;
- TEST_EQUAL( 0, mbedtls_ssl_decrypt_buf( &ssl, &t1, &rec ) );
+ TEST_EQUAL(0, mbedtls_ssl_decrypt_buf(&ssl, &t1, &rec));
/*
* Modify each byte of the pre-encryption record before encrypting and
* decrypting it, expecting failure every time.
*/
- for( i = block_size; i < buflen; i++ )
- {
- mbedtls_test_set_step( i );
+ for (i = block_size; i < buflen; i++) {
+ mbedtls_test_set_step(i);
/* Restore correct pre-encryption record */
rec = rec_save;
rec.buf = buf;
- memcpy( buf, buf_save, buflen );
+ memcpy(buf, buf_save, buflen);
/* Corrupt one byte of the data (could be plaintext, MAC or padding) */
rec.buf[i] ^= 0x01;
/* Encrypt */
- TEST_EQUAL( 0, mbedtls_cipher_crypt( &t0.cipher_ctx_enc,
- t0.iv_enc, t0.ivlen,
- rec.buf + rec.data_offset, rec.data_len,
- rec.buf + rec.data_offset, &olen ) );
+ TEST_EQUAL(0, mbedtls_cipher_crypt(&t0.cipher_ctx_enc,
+ t0.iv_enc, t0.ivlen,
+ rec.buf + rec.data_offset, rec.data_len,
+ rec.buf + rec.data_offset, &olen));
rec.data_offset -= t0.ivlen;
rec.data_len += t0.ivlen;
/* Decrypt and expect failure */
- TEST_EQUAL( MBEDTLS_ERR_SSL_INVALID_MAC,
- mbedtls_ssl_decrypt_buf( &ssl, &t1, &rec ) );
+ TEST_EQUAL(MBEDTLS_ERR_SSL_INVALID_MAC,
+ mbedtls_ssl_decrypt_buf(&ssl, &t1, &rec));
}
/*
@@ -3688,214 +3516,213 @@
* (Start the loop with correct padding, just to double-check that record
* saving did work, and that we're overwriting the correct bytes.)
*/
- for( i = padlen; i <= pad_max_len; i++ )
- {
- mbedtls_test_set_step( i );
+ for (i = padlen; i <= pad_max_len; i++) {
+ mbedtls_test_set_step(i);
/* Restore correct pre-encryption record */
rec = rec_save;
rec.buf = buf;
- memcpy( buf, buf_save, buflen );
+ memcpy(buf, buf_save, buflen);
/* Set padding bytes to new value */
- memset( buf + buflen - padlen - 1, i, padlen + 1 );
+ memset(buf + buflen - padlen - 1, i, padlen + 1);
/* Encrypt */
- TEST_EQUAL( 0, mbedtls_cipher_crypt( &t0.cipher_ctx_enc,
- t0.iv_enc, t0.ivlen,
- rec.buf + rec.data_offset, rec.data_len,
- rec.buf + rec.data_offset, &olen ) );
+ TEST_EQUAL(0, mbedtls_cipher_crypt(&t0.cipher_ctx_enc,
+ t0.iv_enc, t0.ivlen,
+ rec.buf + rec.data_offset, rec.data_len,
+ rec.buf + rec.data_offset, &olen));
rec.data_offset -= t0.ivlen;
rec.data_len += t0.ivlen;
/* Decrypt and expect failure except the first time */
- exp_ret = ( i == padlen ) ? 0 : MBEDTLS_ERR_SSL_INVALID_MAC;
- TEST_EQUAL( exp_ret, mbedtls_ssl_decrypt_buf( &ssl, &t1, &rec ) );
+ exp_ret = (i == padlen) ? 0 : MBEDTLS_ERR_SSL_INVALID_MAC;
+ TEST_EQUAL(exp_ret, mbedtls_ssl_decrypt_buf(&ssl, &t1, &rec));
}
exit:
- mbedtls_ssl_free( &ssl );
- mbedtls_ssl_transform_free( &t0 );
- mbedtls_ssl_transform_free( &t1 );
- mbedtls_free( buf );
- mbedtls_free( buf_save );
+ mbedtls_ssl_free(&ssl);
+ mbedtls_ssl_transform_free(&t0);
+ mbedtls_ssl_transform_free(&t1);
+ mbedtls_free(buf);
+ mbedtls_free(buf_save);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
-void ssl_tls1_3_hkdf_expand_label( int hash_alg,
- data_t *secret,
- int label_idx,
- data_t *ctx,
- int desired_length,
- data_t *expected )
+void ssl_tls1_3_hkdf_expand_label(int hash_alg,
+ data_t *secret,
+ int label_idx,
+ data_t *ctx,
+ int desired_length,
+ data_t *expected)
{
- unsigned char dst[ 100 ];
+ unsigned char dst[100];
unsigned char const *lbl = NULL;
size_t lbl_len;
-#define MBEDTLS_SSL_TLS1_3_LABEL( name, string ) \
- if( label_idx == (int) tls1_3_label_ ## name ) \
+#define MBEDTLS_SSL_TLS1_3_LABEL(name, string) \
+ if (label_idx == (int) tls1_3_label_ ## name) \
{ \
lbl = mbedtls_ssl_tls1_3_labels.name; \
- lbl_len = sizeof( mbedtls_ssl_tls1_3_labels.name ); \
+ lbl_len = sizeof(mbedtls_ssl_tls1_3_labels.name); \
}
-MBEDTLS_SSL_TLS1_3_LABEL_LIST
+ MBEDTLS_SSL_TLS1_3_LABEL_LIST
#undef MBEDTLS_SSL_TLS1_3_LABEL
- TEST_ASSERT( lbl != NULL );
+ TEST_ASSERT(lbl != NULL);
/* Check sanity of test parameters. */
- TEST_ASSERT( (size_t) desired_length <= sizeof( dst ) );
- TEST_ASSERT( (size_t) desired_length == expected->len );
+ TEST_ASSERT((size_t) desired_length <= sizeof(dst));
+ TEST_ASSERT((size_t) desired_length == expected->len);
- TEST_ASSERT( mbedtls_ssl_tls1_3_hkdf_expand_label(
- (mbedtls_md_type_t) hash_alg,
- secret->x, secret->len,
- lbl, lbl_len,
- ctx->x, ctx->len,
- dst, desired_length ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_tls1_3_hkdf_expand_label(
+ (mbedtls_md_type_t) hash_alg,
+ secret->x, secret->len,
+ lbl, lbl_len,
+ ctx->x, ctx->len,
+ dst, desired_length) == 0);
- ASSERT_COMPARE( dst, (size_t) desired_length,
- expected->x, (size_t) expected->len );
+ ASSERT_COMPARE(dst, (size_t) desired_length,
+ expected->x, (size_t) expected->len);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
-void ssl_tls1_3_traffic_key_generation( int hash_alg,
- data_t *server_secret,
- data_t *client_secret,
- int desired_iv_len,
- int desired_key_len,
- data_t *expected_server_write_key,
- data_t *expected_server_write_iv,
- data_t *expected_client_write_key,
- data_t *expected_client_write_iv )
+void ssl_tls1_3_traffic_key_generation(int hash_alg,
+ data_t *server_secret,
+ data_t *client_secret,
+ int desired_iv_len,
+ int desired_key_len,
+ data_t *expected_server_write_key,
+ data_t *expected_server_write_iv,
+ data_t *expected_client_write_key,
+ data_t *expected_client_write_iv)
{
mbedtls_ssl_key_set keys;
/* Check sanity of test parameters. */
- TEST_ASSERT( client_secret->len == server_secret->len );
- TEST_ASSERT( expected_client_write_iv->len == expected_server_write_iv->len &&
- expected_client_write_iv->len == (size_t) desired_iv_len );
- TEST_ASSERT( expected_client_write_key->len == expected_server_write_key->len &&
- expected_client_write_key->len == (size_t) desired_key_len );
+ TEST_ASSERT(client_secret->len == server_secret->len);
+ TEST_ASSERT(expected_client_write_iv->len == expected_server_write_iv->len &&
+ expected_client_write_iv->len == (size_t) desired_iv_len);
+ TEST_ASSERT(expected_client_write_key->len == expected_server_write_key->len &&
+ expected_client_write_key->len == (size_t) desired_key_len);
- TEST_ASSERT( mbedtls_ssl_tls1_3_make_traffic_keys(
- (mbedtls_md_type_t) hash_alg,
- client_secret->x,
- server_secret->x,
- client_secret->len /* == server_secret->len */,
- desired_key_len, desired_iv_len,
- &keys ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_tls1_3_make_traffic_keys(
+ (mbedtls_md_type_t) hash_alg,
+ client_secret->x,
+ server_secret->x,
+ client_secret->len /* == server_secret->len */,
+ desired_key_len, desired_iv_len,
+ &keys) == 0);
- ASSERT_COMPARE( keys.client_write_key,
- keys.key_len,
- expected_client_write_key->x,
- (size_t) desired_key_len );
- ASSERT_COMPARE( keys.server_write_key,
- keys.key_len,
- expected_server_write_key->x,
- (size_t) desired_key_len );
- ASSERT_COMPARE( keys.client_write_iv,
- keys.iv_len,
- expected_client_write_iv->x,
- (size_t) desired_iv_len );
- ASSERT_COMPARE( keys.server_write_iv,
- keys.iv_len,
- expected_server_write_iv->x,
- (size_t) desired_iv_len );
+ ASSERT_COMPARE(keys.client_write_key,
+ keys.key_len,
+ expected_client_write_key->x,
+ (size_t) desired_key_len);
+ ASSERT_COMPARE(keys.server_write_key,
+ keys.key_len,
+ expected_server_write_key->x,
+ (size_t) desired_key_len);
+ ASSERT_COMPARE(keys.client_write_iv,
+ keys.iv_len,
+ expected_client_write_iv->x,
+ (size_t) desired_iv_len);
+ ASSERT_COMPARE(keys.server_write_iv,
+ keys.iv_len,
+ expected_server_write_iv->x,
+ (size_t) desired_iv_len);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
-void ssl_tls1_3_derive_secret( int hash_alg,
- data_t *secret,
- int label_idx,
- data_t *ctx,
- int desired_length,
- int already_hashed,
- data_t *expected )
+void ssl_tls1_3_derive_secret(int hash_alg,
+ data_t *secret,
+ int label_idx,
+ data_t *ctx,
+ int desired_length,
+ int already_hashed,
+ data_t *expected)
{
- unsigned char dst[ 100 ];
+ unsigned char dst[100];
unsigned char const *lbl = NULL;
size_t lbl_len;
-#define MBEDTLS_SSL_TLS1_3_LABEL( name, string ) \
- if( label_idx == (int) tls1_3_label_ ## name ) \
+#define MBEDTLS_SSL_TLS1_3_LABEL(name, string) \
+ if (label_idx == (int) tls1_3_label_ ## name) \
{ \
lbl = mbedtls_ssl_tls1_3_labels.name; \
- lbl_len = sizeof( mbedtls_ssl_tls1_3_labels.name ); \
+ lbl_len = sizeof(mbedtls_ssl_tls1_3_labels.name); \
}
-MBEDTLS_SSL_TLS1_3_LABEL_LIST
+ MBEDTLS_SSL_TLS1_3_LABEL_LIST
#undef MBEDTLS_SSL_TLS1_3_LABEL
- TEST_ASSERT( lbl != NULL );
+ TEST_ASSERT(lbl != NULL);
/* Check sanity of test parameters. */
- TEST_ASSERT( (size_t) desired_length <= sizeof( dst ) );
- TEST_ASSERT( (size_t) desired_length == expected->len );
+ TEST_ASSERT((size_t) desired_length <= sizeof(dst));
+ TEST_ASSERT((size_t) desired_length == expected->len);
- TEST_ASSERT( mbedtls_ssl_tls1_3_derive_secret(
- (mbedtls_md_type_t) hash_alg,
- secret->x, secret->len,
- lbl, lbl_len,
- ctx->x, ctx->len,
- already_hashed,
- dst, desired_length ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_tls1_3_derive_secret(
+ (mbedtls_md_type_t) hash_alg,
+ secret->x, secret->len,
+ lbl, lbl_len,
+ ctx->x, ctx->len,
+ already_hashed,
+ dst, desired_length) == 0);
- ASSERT_COMPARE( dst, desired_length,
- expected->x, desired_length );
+ ASSERT_COMPARE(dst, desired_length,
+ expected->x, desired_length);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SSL_PROTO_TLS1_3_EXPERIMENTAL */
-void ssl_tls1_3_key_evolution( int hash_alg,
- data_t *secret,
- data_t *input,
- data_t *expected )
+void ssl_tls1_3_key_evolution(int hash_alg,
+ data_t *secret,
+ data_t *input,
+ data_t *expected)
{
- unsigned char secret_new[ MBEDTLS_MD_MAX_SIZE ];
+ unsigned char secret_new[MBEDTLS_MD_MAX_SIZE];
- TEST_ASSERT( mbedtls_ssl_tls1_3_evolve_secret(
- (mbedtls_md_type_t) hash_alg,
- secret->len ? secret->x : NULL,
- input->len ? input->x : NULL, input->len,
- secret_new ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_tls1_3_evolve_secret(
+ (mbedtls_md_type_t) hash_alg,
+ secret->len ? secret->x : NULL,
+ input->len ? input->x : NULL, input->len,
+ secret_new) == 0);
- ASSERT_COMPARE( secret_new, (size_t) expected->len,
- expected->x, (size_t) expected->len );
+ ASSERT_COMPARE(secret_new, (size_t) expected->len,
+ expected->x, (size_t) expected->len);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_tls_prf( int type, data_t * secret, data_t * random,
- char *label, data_t *result_str, int exp_ret )
+void ssl_tls_prf(int type, data_t *secret, data_t *random,
+ char *label, data_t *result_str, int exp_ret)
{
unsigned char *output;
- output = mbedtls_calloc( 1, result_str->len );
- if( output == NULL )
+ output = mbedtls_calloc(1, result_str->len);
+ if (output == NULL) {
goto exit;
+ }
- USE_PSA_INIT( );
+ USE_PSA_INIT();
- TEST_ASSERT( mbedtls_ssl_tls_prf( type, secret->x, secret->len,
- label, random->x, random->len,
- output, result_str->len ) == exp_ret );
+ TEST_ASSERT(mbedtls_ssl_tls_prf(type, secret->x, secret->len,
+ label, random->x, random->len,
+ output, result_str->len) == exp_ret);
- if( exp_ret == 0 )
- {
- TEST_ASSERT( mbedtls_test_hexcmp( output, result_str->x,
- result_str->len, result_str->len ) == 0 );
+ if (exp_ret == 0) {
+ TEST_ASSERT(mbedtls_test_hexcmp(output, result_str->x,
+ result_str->len, result_str->len) == 0);
}
exit:
- mbedtls_free( output );
- USE_PSA_DONE( );
+ mbedtls_free(output);
+ USE_PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_serialize_session_save_load( int ticket_len, char *crt_file )
+void ssl_serialize_session_save_load(int ticket_len, char *crt_file)
{
mbedtls_ssl_session original, restored;
unsigned char *buf = NULL;
@@ -3905,98 +3732,95 @@
* Test that a save-load pair is the identity
*/
- mbedtls_ssl_session_init( &original );
- mbedtls_ssl_session_init( &restored );
+ mbedtls_ssl_session_init(&original);
+ mbedtls_ssl_session_init(&restored);
/* Prepare a dummy session to work on */
- TEST_ASSERT( ssl_populate_session( &original, ticket_len, crt_file ) == 0 );
+ TEST_ASSERT(ssl_populate_session(&original, ticket_len, crt_file) == 0);
/* Serialize it */
- TEST_ASSERT( mbedtls_ssl_session_save( &original, NULL, 0, &len )
- == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
- TEST_ASSERT( ( buf = mbedtls_calloc( 1, len ) ) != NULL );
- TEST_ASSERT( mbedtls_ssl_session_save( &original, buf, len, &len )
- == 0 );
+ TEST_ASSERT(mbedtls_ssl_session_save(&original, NULL, 0, &len)
+ == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
+ TEST_ASSERT((buf = mbedtls_calloc(1, len)) != NULL);
+ TEST_ASSERT(mbedtls_ssl_session_save(&original, buf, len, &len)
+ == 0);
/* Restore session from serialized data */
- TEST_ASSERT( mbedtls_ssl_session_load( &restored, buf, len) == 0 );
+ TEST_ASSERT(mbedtls_ssl_session_load(&restored, buf, len) == 0);
/*
* Make sure both session structures are identical
*/
#if defined(MBEDTLS_HAVE_TIME)
- TEST_ASSERT( original.start == restored.start );
+ TEST_ASSERT(original.start == restored.start);
#endif
- TEST_ASSERT( original.ciphersuite == restored.ciphersuite );
- TEST_ASSERT( original.compression == restored.compression );
- TEST_ASSERT( original.id_len == restored.id_len );
- TEST_ASSERT( memcmp( original.id,
- restored.id, sizeof( original.id ) ) == 0 );
- TEST_ASSERT( memcmp( original.master,
- restored.master, sizeof( original.master ) ) == 0 );
+ TEST_ASSERT(original.ciphersuite == restored.ciphersuite);
+ TEST_ASSERT(original.compression == restored.compression);
+ TEST_ASSERT(original.id_len == restored.id_len);
+ TEST_ASSERT(memcmp(original.id,
+ restored.id, sizeof(original.id)) == 0);
+ TEST_ASSERT(memcmp(original.master,
+ restored.master, sizeof(original.master)) == 0);
#if defined(MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED)
#if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
- TEST_ASSERT( ( original.peer_cert == NULL ) ==
- ( restored.peer_cert == NULL ) );
- if( original.peer_cert != NULL )
- {
- TEST_ASSERT( original.peer_cert->raw.len ==
- restored.peer_cert->raw.len );
- TEST_ASSERT( memcmp( original.peer_cert->raw.p,
- restored.peer_cert->raw.p,
- original.peer_cert->raw.len ) == 0 );
+ TEST_ASSERT((original.peer_cert == NULL) ==
+ (restored.peer_cert == NULL));
+ if (original.peer_cert != NULL) {
+ TEST_ASSERT(original.peer_cert->raw.len ==
+ restored.peer_cert->raw.len);
+ TEST_ASSERT(memcmp(original.peer_cert->raw.p,
+ restored.peer_cert->raw.p,
+ original.peer_cert->raw.len) == 0);
}
#else /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
- TEST_ASSERT( original.peer_cert_digest_type ==
- restored.peer_cert_digest_type );
- TEST_ASSERT( original.peer_cert_digest_len ==
- restored.peer_cert_digest_len );
- TEST_ASSERT( ( original.peer_cert_digest == NULL ) ==
- ( restored.peer_cert_digest == NULL ) );
- if( original.peer_cert_digest != NULL )
- {
- TEST_ASSERT( memcmp( original.peer_cert_digest,
- restored.peer_cert_digest,
- original.peer_cert_digest_len ) == 0 );
+ TEST_ASSERT(original.peer_cert_digest_type ==
+ restored.peer_cert_digest_type);
+ TEST_ASSERT(original.peer_cert_digest_len ==
+ restored.peer_cert_digest_len);
+ TEST_ASSERT((original.peer_cert_digest == NULL) ==
+ (restored.peer_cert_digest == NULL));
+ if (original.peer_cert_digest != NULL) {
+ TEST_ASSERT(memcmp(original.peer_cert_digest,
+ restored.peer_cert_digest,
+ original.peer_cert_digest_len) == 0);
}
#endif /* MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
#endif /* MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED */
- TEST_ASSERT( original.verify_result == restored.verify_result );
+ TEST_ASSERT(original.verify_result == restored.verify_result);
#if defined(MBEDTLS_SSL_SESSION_TICKETS) && defined(MBEDTLS_SSL_CLI_C)
- TEST_ASSERT( original.ticket_len == restored.ticket_len );
- if( original.ticket_len != 0 )
- {
- TEST_ASSERT( original.ticket != NULL );
- TEST_ASSERT( restored.ticket != NULL );
- TEST_ASSERT( memcmp( original.ticket,
- restored.ticket, original.ticket_len ) == 0 );
+ TEST_ASSERT(original.ticket_len == restored.ticket_len);
+ if (original.ticket_len != 0) {
+ TEST_ASSERT(original.ticket != NULL);
+ TEST_ASSERT(restored.ticket != NULL);
+ TEST_ASSERT(memcmp(original.ticket,
+ restored.ticket, original.ticket_len) == 0);
}
- TEST_ASSERT( original.ticket_lifetime == restored.ticket_lifetime );
+ TEST_ASSERT(original.ticket_lifetime == restored.ticket_lifetime);
#endif
#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
- TEST_ASSERT( original.mfl_code == restored.mfl_code );
+ TEST_ASSERT(original.mfl_code == restored.mfl_code);
#endif
#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
- TEST_ASSERT( original.trunc_hmac == restored.trunc_hmac );
+ TEST_ASSERT(original.trunc_hmac == restored.trunc_hmac);
#endif
#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
- TEST_ASSERT( original.encrypt_then_mac == restored.encrypt_then_mac );
+ TEST_ASSERT(original.encrypt_then_mac == restored.encrypt_then_mac);
#endif
exit:
- mbedtls_ssl_session_free( &original );
- mbedtls_ssl_session_free( &restored );
- mbedtls_free( buf );
+ mbedtls_ssl_session_free(&original);
+ mbedtls_ssl_session_free(&restored);
+ mbedtls_free(buf);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_serialize_session_load_save( int ticket_len, char *crt_file )
+void ssl_serialize_session_load_save(int ticket_len, char *crt_file)
{
mbedtls_ssl_session session;
unsigned char *buf1 = NULL, *buf2 = NULL;
@@ -4006,47 +3830,47 @@
* Test that a load-save pair is the identity
*/
- mbedtls_ssl_session_init( &session );
+ mbedtls_ssl_session_init(&session);
/* Prepare a dummy session to work on */
- TEST_ASSERT( ssl_populate_session( &session, ticket_len, crt_file ) == 0 );
+ TEST_ASSERT(ssl_populate_session(&session, ticket_len, crt_file) == 0);
/* Get desired buffer size for serializing */
- TEST_ASSERT( mbedtls_ssl_session_save( &session, NULL, 0, &len0 )
- == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
+ TEST_ASSERT(mbedtls_ssl_session_save(&session, NULL, 0, &len0)
+ == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
/* Allocate first buffer */
- buf1 = mbedtls_calloc( 1, len0 );
- TEST_ASSERT( buf1 != NULL );
+ buf1 = mbedtls_calloc(1, len0);
+ TEST_ASSERT(buf1 != NULL);
/* Serialize to buffer and free live session */
- TEST_ASSERT( mbedtls_ssl_session_save( &session, buf1, len0, &len1 )
- == 0 );
- TEST_ASSERT( len0 == len1 );
- mbedtls_ssl_session_free( &session );
+ TEST_ASSERT(mbedtls_ssl_session_save(&session, buf1, len0, &len1)
+ == 0);
+ TEST_ASSERT(len0 == len1);
+ mbedtls_ssl_session_free(&session);
/* Restore session from serialized data */
- TEST_ASSERT( mbedtls_ssl_session_load( &session, buf1, len1 ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_session_load(&session, buf1, len1) == 0);
/* Allocate second buffer and serialize to it */
- buf2 = mbedtls_calloc( 1, len0 );
- TEST_ASSERT( buf2 != NULL );
- TEST_ASSERT( mbedtls_ssl_session_save( &session, buf2, len0, &len2 )
- == 0 );
+ buf2 = mbedtls_calloc(1, len0);
+ TEST_ASSERT(buf2 != NULL);
+ TEST_ASSERT(mbedtls_ssl_session_save(&session, buf2, len0, &len2)
+ == 0);
/* Make sure both serialized versions are identical */
- TEST_ASSERT( len1 == len2 );
- TEST_ASSERT( memcmp( buf1, buf2, len1 ) == 0 );
+ TEST_ASSERT(len1 == len2);
+ TEST_ASSERT(memcmp(buf1, buf2, len1) == 0);
exit:
- mbedtls_ssl_session_free( &session );
- mbedtls_free( buf1 );
- mbedtls_free( buf2 );
+ mbedtls_ssl_session_free(&session);
+ mbedtls_free(buf1);
+ mbedtls_free(buf2);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_serialize_session_save_buf_size( int ticket_len, char *crt_file )
+void ssl_serialize_session_save_buf_size(int ticket_len, char *crt_file)
{
mbedtls_ssl_session session;
unsigned char *buf = NULL;
@@ -4056,33 +3880,32 @@
* Test that session_save() fails cleanly on small buffers
*/
- mbedtls_ssl_session_init( &session );
+ mbedtls_ssl_session_init(&session);
/* Prepare dummy session and get serialized size */
- TEST_ASSERT( ssl_populate_session( &session, ticket_len, crt_file ) == 0 );
- TEST_ASSERT( mbedtls_ssl_session_save( &session, NULL, 0, &good_len )
- == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
+ TEST_ASSERT(ssl_populate_session(&session, ticket_len, crt_file) == 0);
+ TEST_ASSERT(mbedtls_ssl_session_save(&session, NULL, 0, &good_len)
+ == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
/* Try all possible bad lengths */
- for( bad_len = 1; bad_len < good_len; bad_len++ )
- {
+ for (bad_len = 1; bad_len < good_len; bad_len++) {
/* Allocate exact size so that asan/valgrind can detect any overwrite */
- mbedtls_free( buf );
- TEST_ASSERT( ( buf = mbedtls_calloc( 1, bad_len ) ) != NULL );
- TEST_ASSERT( mbedtls_ssl_session_save( &session, buf, bad_len,
- &test_len )
- == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
- TEST_ASSERT( test_len == good_len );
+ mbedtls_free(buf);
+ TEST_ASSERT((buf = mbedtls_calloc(1, bad_len)) != NULL);
+ TEST_ASSERT(mbedtls_ssl_session_save(&session, buf, bad_len,
+ &test_len)
+ == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
+ TEST_ASSERT(test_len == good_len);
}
exit:
- mbedtls_ssl_session_free( &session );
- mbedtls_free( buf );
+ mbedtls_ssl_session_free(&session);
+ mbedtls_free(buf);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_serialize_session_load_buf_size( int ticket_len, char *crt_file )
+void ssl_serialize_session_load_buf_size(int ticket_len, char *crt_file)
{
mbedtls_ssl_session session;
unsigned char *good_buf = NULL, *bad_buf = NULL;
@@ -4092,44 +3915,43 @@
* Test that session_load() fails cleanly on small buffers
*/
- mbedtls_ssl_session_init( &session );
+ mbedtls_ssl_session_init(&session);
/* Prepare serialized session data */
- TEST_ASSERT( ssl_populate_session( &session, ticket_len, crt_file ) == 0 );
- TEST_ASSERT( mbedtls_ssl_session_save( &session, NULL, 0, &good_len )
- == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
- TEST_ASSERT( ( good_buf = mbedtls_calloc( 1, good_len ) ) != NULL );
- TEST_ASSERT( mbedtls_ssl_session_save( &session, good_buf, good_len,
- &good_len ) == 0 );
- mbedtls_ssl_session_free( &session );
+ TEST_ASSERT(ssl_populate_session(&session, ticket_len, crt_file) == 0);
+ TEST_ASSERT(mbedtls_ssl_session_save(&session, NULL, 0, &good_len)
+ == MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
+ TEST_ASSERT((good_buf = mbedtls_calloc(1, good_len)) != NULL);
+ TEST_ASSERT(mbedtls_ssl_session_save(&session, good_buf, good_len,
+ &good_len) == 0);
+ mbedtls_ssl_session_free(&session);
/* Try all possible bad lengths */
- for( bad_len = 0; bad_len < good_len; bad_len++ )
- {
+ for (bad_len = 0; bad_len < good_len; bad_len++) {
/* Allocate exact size so that asan/valgrind can detect any overread */
- mbedtls_free( bad_buf );
- bad_buf = mbedtls_calloc( 1, bad_len ? bad_len : 1 );
- TEST_ASSERT( bad_buf != NULL );
- memcpy( bad_buf, good_buf, bad_len );
+ mbedtls_free(bad_buf);
+ bad_buf = mbedtls_calloc(1, bad_len ? bad_len : 1);
+ TEST_ASSERT(bad_buf != NULL);
+ memcpy(bad_buf, good_buf, bad_len);
- TEST_ASSERT( mbedtls_ssl_session_load( &session, bad_buf, bad_len )
- == MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
+ TEST_ASSERT(mbedtls_ssl_session_load(&session, bad_buf, bad_len)
+ == MBEDTLS_ERR_SSL_BAD_INPUT_DATA);
}
exit:
- mbedtls_ssl_session_free( &session );
- mbedtls_free( good_buf );
- mbedtls_free( bad_buf );
+ mbedtls_ssl_session_free(&session);
+ mbedtls_free(good_buf);
+ mbedtls_free(bad_buf);
}
/* END_CASE */
/* BEGIN_CASE */
-void ssl_session_serialize_version_check( int corrupt_major,
- int corrupt_minor,
- int corrupt_patch,
- int corrupt_config )
+void ssl_session_serialize_version_check(int corrupt_major,
+ int corrupt_minor,
+ int corrupt_patch,
+ int corrupt_config)
{
- unsigned char serialized_session[ 2048 ];
+ unsigned char serialized_session[2048];
size_t serialized_session_len;
unsigned cur_byte;
mbedtls_ssl_session session;
@@ -4139,44 +3961,43 @@
corrupt_config == 1,
corrupt_config == 1 };
- mbedtls_ssl_session_init( &session );
+ mbedtls_ssl_session_init(&session);
/* Infer length of serialized session. */
- TEST_ASSERT( mbedtls_ssl_session_save( &session,
- serialized_session,
- sizeof( serialized_session ),
- &serialized_session_len ) == 0 );
+ TEST_ASSERT(mbedtls_ssl_session_save(&session,
+ serialized_session,
+ sizeof(serialized_session),
+ &serialized_session_len) == 0);
- mbedtls_ssl_session_free( &session );
+ mbedtls_ssl_session_free(&session);
/* Without any modification, we should be able to successfully
* de-serialize the session - double-check that. */
- TEST_ASSERT( mbedtls_ssl_session_load( &session,
- serialized_session,
- serialized_session_len ) == 0 );
- mbedtls_ssl_session_free( &session );
+ TEST_ASSERT(mbedtls_ssl_session_load(&session,
+ serialized_session,
+ serialized_session_len) == 0);
+ mbedtls_ssl_session_free(&session);
/* Go through the bytes in the serialized session header and
* corrupt them bit-by-bit. */
- for( cur_byte = 0; cur_byte < sizeof( should_corrupt_byte ); cur_byte++ )
- {
+ for (cur_byte = 0; cur_byte < sizeof(should_corrupt_byte); cur_byte++) {
int cur_bit;
- unsigned char * const byte = &serialized_session[ cur_byte ];
+ unsigned char * const byte = &serialized_session[cur_byte];
- if( should_corrupt_byte[ cur_byte ] == 0 )
+ if (should_corrupt_byte[cur_byte] == 0) {
continue;
+ }
- for( cur_bit = 0; cur_bit < CHAR_BIT; cur_bit++ )
- {
+ for (cur_bit = 0; cur_bit < CHAR_BIT; cur_bit++) {
unsigned char const corrupted_bit = 0x1u << cur_bit;
/* Modify a single bit in the serialized session. */
*byte ^= corrupted_bit;
/* Attempt to deserialize */
- TEST_ASSERT( mbedtls_ssl_session_load( &session,
- serialized_session,
- serialized_session_len ) ==
- MBEDTLS_ERR_SSL_VERSION_MISMATCH );
+ TEST_ASSERT(mbedtls_ssl_session_load(&session,
+ serialized_session,
+ serialized_session_len) ==
+ MBEDTLS_ERR_SSL_VERSION_MISMATCH);
/* Undo the change */
*byte ^= corrupted_bit;
@@ -4187,25 +4008,25 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_ENTROPY_C:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
-void mbedtls_endpoint_sanity( int endpoint_type )
+void mbedtls_endpoint_sanity(int endpoint_type)
{
enum { BUFFSIZE = 1024 };
mbedtls_endpoint ep;
int ret = -1;
- ret = mbedtls_endpoint_init( NULL, endpoint_type, MBEDTLS_PK_RSA,
- NULL, NULL, NULL, NULL );
- TEST_ASSERT( MBEDTLS_ERR_SSL_BAD_INPUT_DATA == ret );
+ ret = mbedtls_endpoint_init(NULL, endpoint_type, MBEDTLS_PK_RSA,
+ NULL, NULL, NULL, NULL);
+ TEST_ASSERT(MBEDTLS_ERR_SSL_BAD_INPUT_DATA == ret);
- ret = mbedtls_endpoint_certificate_init( NULL, MBEDTLS_PK_RSA );
- TEST_ASSERT( MBEDTLS_ERR_SSL_BAD_INPUT_DATA == ret );
+ ret = mbedtls_endpoint_certificate_init(NULL, MBEDTLS_PK_RSA);
+ TEST_ASSERT(MBEDTLS_ERR_SSL_BAD_INPUT_DATA == ret);
- ret = mbedtls_endpoint_init( &ep, endpoint_type, MBEDTLS_PK_RSA,
- NULL, NULL, NULL, NULL );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_endpoint_init(&ep, endpoint_type, MBEDTLS_PK_RSA,
+ NULL, NULL, NULL, NULL);
+ TEST_ASSERT(ret == 0);
exit:
- mbedtls_endpoint_free( &ep, NULL );
+ mbedtls_endpoint_free(&ep, NULL);
}
/* END_CASE */
@@ -4216,51 +4037,48 @@
mbedtls_endpoint base_ep, second_ep;
int ret = -1;
- mbedtls_platform_zeroize( &base_ep, sizeof( base_ep ) );
- mbedtls_platform_zeroize( &second_ep, sizeof( second_ep ) );
+ mbedtls_platform_zeroize(&base_ep, sizeof(base_ep));
+ mbedtls_platform_zeroize(&second_ep, sizeof(second_ep));
- ret = mbedtls_endpoint_init( &base_ep, endpoint_type, MBEDTLS_PK_RSA,
- NULL, NULL, NULL, NULL );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_endpoint_init(&base_ep, endpoint_type, MBEDTLS_PK_RSA,
+ NULL, NULL, NULL, NULL);
+ TEST_ASSERT(ret == 0);
- ret = mbedtls_endpoint_init( &second_ep,
- ( endpoint_type == MBEDTLS_SSL_IS_SERVER ) ?
- MBEDTLS_SSL_IS_CLIENT : MBEDTLS_SSL_IS_SERVER,
- MBEDTLS_PK_RSA, NULL, NULL, NULL, NULL );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_endpoint_init(&second_ep,
+ (endpoint_type == MBEDTLS_SSL_IS_SERVER) ?
+ MBEDTLS_SSL_IS_CLIENT : MBEDTLS_SSL_IS_SERVER,
+ MBEDTLS_PK_RSA, NULL, NULL, NULL, NULL);
+ TEST_ASSERT(ret == 0);
- ret = mbedtls_mock_socket_connect( &(base_ep.socket),
- &(second_ep.socket),
- BUFFSIZE );
- TEST_ASSERT( ret == 0 );
+ ret = mbedtls_mock_socket_connect(&(base_ep.socket),
+ &(second_ep.socket),
+ BUFFSIZE);
+ TEST_ASSERT(ret == 0);
- ret = mbedtls_move_handshake_to_state( &(base_ep.ssl),
- &(second_ep.ssl),
- state );
- if( need_pass )
- {
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( base_ep.ssl.state == state );
- }
- else
- {
- TEST_ASSERT( ret != 0 );
- TEST_ASSERT( base_ep.ssl.state != state );
+ ret = mbedtls_move_handshake_to_state(&(base_ep.ssl),
+ &(second_ep.ssl),
+ state);
+ if (need_pass) {
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(base_ep.ssl.state == state);
+ } else {
+ TEST_ASSERT(ret != 0);
+ TEST_ASSERT(base_ep.ssl.state != state);
}
exit:
- mbedtls_endpoint_free( &base_ep, NULL );
- mbedtls_endpoint_free( &second_ep, NULL );
+ mbedtls_endpoint_free(&base_ep, NULL);
+ mbedtls_endpoint_free(&second_ep, NULL);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_ECP_C:MBEDTLS_SHA256_C */
-void handshake_version( int dtls, int client_min_version, int client_max_version,
- int server_min_version, int server_max_version,
- int expected_negotiated_version )
+void handshake_version(int dtls, int client_min_version, int client_max_version,
+ int server_min_version, int server_max_version,
+ int expected_negotiated_version)
{
handshake_test_options options;
- init_handshake_options( &options );
+ init_handshake_options(&options);
options.client_min_version = client_min_version;
options.client_max_version = client_max_version;
@@ -4272,13 +4090,12 @@
options.dtls = dtls;
/* By default, SSLv3.0 and TLSv1.0 use 1/n-1 splitting when sending data, so
* the number of fragments will be twice as big. */
- if( expected_negotiated_version == MBEDTLS_SSL_MINOR_VERSION_0 ||
- expected_negotiated_version == MBEDTLS_SSL_MINOR_VERSION_1 )
- {
+ if (expected_negotiated_version == MBEDTLS_SSL_MINOR_VERSION_0 ||
+ expected_negotiated_version == MBEDTLS_SSL_MINOR_VERSION_1) {
options.expected_cli_fragments = 2;
options.expected_srv_fragments = 2;
}
- perform_handshake( &options );
+ perform_handshake(&options);
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
@@ -4286,17 +4103,17 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
-void handshake_psk_cipher( char* cipher, int pk_alg, data_t *psk_str, int dtls )
+void handshake_psk_cipher(char *cipher, int pk_alg, data_t *psk_str, int dtls)
{
handshake_test_options options;
- init_handshake_options( &options );
+ init_handshake_options(&options);
options.cipher = cipher;
options.dtls = dtls;
options.psk_str = psk_str;
options.pk_alg = pk_alg;
- perform_handshake( &options );
+ perform_handshake(&options);
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
@@ -4304,9 +4121,9 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
-void handshake_cipher( char* cipher, int pk_alg, int dtls )
+void handshake_cipher(char *cipher, int pk_alg, int dtls)
{
- test_handshake_psk_cipher( cipher, pk_alg, NULL, dtls );
+ test_handshake_psk_cipher(cipher, pk_alg, NULL, dtls);
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
@@ -4314,12 +4131,12 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
-void app_data( int mfl, int cli_msg_len, int srv_msg_len,
- int expected_cli_fragments,
- int expected_srv_fragments, int dtls )
+void app_data(int mfl, int cli_msg_len, int srv_msg_len,
+ int expected_cli_fragments,
+ int expected_srv_fragments, int dtls)
{
handshake_test_options options;
- init_handshake_options( &options );
+ init_handshake_options(&options);
options.mfl = mfl;
options.cli_msg_len = cli_msg_len;
@@ -4328,52 +4145,54 @@
options.expected_srv_fragments = expected_srv_fragments;
options.dtls = dtls;
- perform_handshake( &options );
+ perform_handshake(&options);
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_ECP_C:MBEDTLS_SHA256_C */
-void app_data_tls( int mfl, int cli_msg_len, int srv_msg_len,
- int expected_cli_fragments,
- int expected_srv_fragments )
+void app_data_tls(int mfl, int cli_msg_len, int srv_msg_len,
+ int expected_cli_fragments,
+ int expected_srv_fragments)
{
- test_app_data( mfl, cli_msg_len, srv_msg_len, expected_cli_fragments,
- expected_srv_fragments, 0 );
+ test_app_data(mfl, cli_msg_len, srv_msg_len, expected_cli_fragments,
+ expected_srv_fragments, 0);
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_SSL_PROTO_DTLS:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
-void app_data_dtls( int mfl, int cli_msg_len, int srv_msg_len,
- int expected_cli_fragments,
- int expected_srv_fragments )
+void app_data_dtls(int mfl, int cli_msg_len, int srv_msg_len,
+ int expected_cli_fragments,
+ int expected_srv_fragments)
{
- test_app_data( mfl, cli_msg_len, srv_msg_len, expected_cli_fragments,
- expected_srv_fragments, 1 );
+ test_app_data(mfl, cli_msg_len, srv_msg_len, expected_cli_fragments,
+ expected_srv_fragments, 1);
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_SSL_PROTO_DTLS:MBEDTLS_SSL_RENEGOTIATION:MBEDTLS_SSL_CONTEXT_SERIALIZATION:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
-void handshake_serialization( )
+void handshake_serialization()
{
handshake_test_options options;
- init_handshake_options( &options );
+ init_handshake_options(&options);
options.serialize = 1;
options.dtls = 1;
- perform_handshake( &options );
+ perform_handshake(&options);
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_DEBUG_C:MBEDTLS_SSL_MAX_FRAGMENT_LENGTH:MBEDTLS_CIPHER_MODE_CBC:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
-void handshake_fragmentation( int mfl, int expected_srv_hs_fragmentation, int expected_cli_hs_fragmentation)
+void handshake_fragmentation(int mfl,
+ int expected_srv_hs_fragmentation,
+ int expected_cli_hs_fragmentation)
{
handshake_test_options options;
log_pattern srv_pattern, cli_pattern;
@@ -4382,7 +4201,7 @@
srv_pattern.counter = 0;
cli_pattern.counter = 0;
- init_handshake_options( &options );
+ init_handshake_options(&options);
options.dtls = 1;
options.mfl = mfl;
/* Set cipher to one using CBC so that record splitting can be tested */
@@ -4393,43 +4212,41 @@
options.srv_log_fun = log_analyzer;
options.cli_log_fun = log_analyzer;
- perform_handshake( &options );
+ perform_handshake(&options);
/* Test if the server received a fragmented handshake */
- if( expected_srv_hs_fragmentation )
- {
- TEST_ASSERT( srv_pattern.counter >= 1 );
+ if (expected_srv_hs_fragmentation) {
+ TEST_ASSERT(srv_pattern.counter >= 1);
}
/* Test if the client received a fragmented handshake */
- if( expected_cli_hs_fragmentation )
- {
- TEST_ASSERT( cli_pattern.counter >= 1 );
+ if (expected_cli_hs_fragmentation) {
+ TEST_ASSERT(cli_pattern.counter >= 1);
}
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_SSL_PROTO_DTLS:MBEDTLS_SSL_RENEGOTIATION:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
-void renegotiation( int legacy_renegotiation )
+void renegotiation(int legacy_renegotiation)
{
handshake_test_options options;
- init_handshake_options( &options );
+ init_handshake_options(&options);
options.renegotiate = 1;
options.legacy_renegotiation = legacy_renegotiation;
options.dtls = 1;
- perform_handshake( &options );
+ perform_handshake(&options);
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
-void resize_buffers( int mfl, int renegotiation, int legacy_renegotiation,
- int serialize, int dtls, char *cipher )
+void resize_buffers(int mfl, int renegotiation, int legacy_renegotiation,
+ int serialize, int dtls, char *cipher)
{
handshake_test_options options;
- init_handshake_options( &options );
+ init_handshake_options(&options);
options.mfl = mfl;
options.cipher = cipher;
@@ -4439,17 +4256,17 @@
options.dtls = dtls;
options.resize_buffers = 1;
- perform_handshake( &options );
+ perform_handshake(&options);
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH:MBEDTLS_SSL_CONTEXT_SERIALIZATION:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_SSL_PROTO_DTLS:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
-void resize_buffers_serialize_mfl( int mfl )
+void resize_buffers_serialize_mfl(int mfl)
{
- test_resize_buffers( mfl, 0, MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION, 1, 1,
- (char *) "" );
+ test_resize_buffers(mfl, 0, MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION, 1, 1,
+ (char *) "");
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
@@ -4457,10 +4274,10 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:!MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_VARIABLE_BUFFER_LENGTH:MBEDTLS_SSL_RENEGOTIATION:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_CTR_DRBG_C:MBEDTLS_SHA256_C */
-void resize_buffers_renegotiate_mfl( int mfl, int legacy_renegotiation,
- char *cipher )
+void resize_buffers_renegotiate_mfl(int mfl, int legacy_renegotiation,
+ char *cipher)
{
- test_resize_buffers( mfl, 1, legacy_renegotiation, 0, 1, cipher );
+ test_resize_buffers(mfl, 1, legacy_renegotiation, 0, 1, cipher);
/* The goto below is used to avoid an "unused label" warning.*/
goto exit;
@@ -4468,7 +4285,7 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_KEY_EXCHANGE_WITH_CERT_ENABLED:MBEDTLS_USE_PSA_CRYPTO:MBEDTLS_PKCS1_V15:MBEDTLS_SSL_PROTO_TLS1_2:MBEDTLS_ECP_DP_SECP256R1_ENABLED:MBEDTLS_ENTROPY_C:MBEDTLS_RSA_C:MBEDTLS_ECP_DP_SECP384R1_ENABLED:MBEDTLS_CTR_DRBG_C:MBEDTLS_ECP_C:MBEDTLS_ECDSA_C */
-void raw_key_agreement_fail( int bad_server_ecdhe_key )
+void raw_key_agreement_fail(int bad_server_ecdhe_key)
{
enum { BUFFSIZE = 17000 };
mbedtls_endpoint client, server;
@@ -4477,87 +4294,87 @@
mbedtls_ecp_group_id curve_list[] = { MBEDTLS_ECP_DP_SECP256R1,
MBEDTLS_ECP_DP_NONE };
- USE_PSA_INIT( );
- mbedtls_platform_zeroize( &client, sizeof( client ) );
- mbedtls_platform_zeroize( &server, sizeof( server ) );
+ USE_PSA_INIT();
+ mbedtls_platform_zeroize(&client, sizeof(client));
+ mbedtls_platform_zeroize(&server, sizeof(server));
/* Client side, force SECP256R1 to make one key bitflip fail
* the raw key agreement. Flipping the first byte makes the
* required 0x04 identifier invalid. */
- TEST_EQUAL( mbedtls_endpoint_init( &client, MBEDTLS_SSL_IS_CLIENT,
- MBEDTLS_PK_ECDSA, NULL, NULL,
- NULL, curve_list ), 0 );
+ TEST_EQUAL(mbedtls_endpoint_init(&client, MBEDTLS_SSL_IS_CLIENT,
+ MBEDTLS_PK_ECDSA, NULL, NULL,
+ NULL, curve_list), 0);
/* Server side */
- TEST_EQUAL( mbedtls_endpoint_init( &server, MBEDTLS_SSL_IS_SERVER,
- MBEDTLS_PK_ECDSA, NULL, NULL,
- NULL, NULL ), 0 );
+ TEST_EQUAL(mbedtls_endpoint_init(&server, MBEDTLS_SSL_IS_SERVER,
+ MBEDTLS_PK_ECDSA, NULL, NULL,
+ NULL, NULL), 0);
- TEST_EQUAL( mbedtls_mock_socket_connect( &(client.socket),
- &(server.socket),
- BUFFSIZE ), 0 );
+ TEST_EQUAL(mbedtls_mock_socket_connect(&(client.socket),
+ &(server.socket),
+ BUFFSIZE), 0);
- TEST_EQUAL( mbedtls_move_handshake_to_state( &(client.ssl),
- &(server.ssl),
- MBEDTLS_SSL_CLIENT_KEY_EXCHANGE )
- , 0 );
+ TEST_EQUAL(mbedtls_move_handshake_to_state(&(client.ssl),
+ &(server.ssl),
+ MBEDTLS_SSL_CLIENT_KEY_EXCHANGE)
+ , 0);
- mbedtls_psa_get_stats( &stats );
+ mbedtls_psa_get_stats(&stats);
/* Save the number of slots in use up to this point.
* With PSA, one can be used for the ECDH private key. */
free_slots_before = stats.empty_slots;
- if( bad_server_ecdhe_key )
- {
+ if (bad_server_ecdhe_key) {
/* Force a simulated bitflip in the server key. to make the
* raw key agreement in ssl_write_client_key_exchange fail. */
(client.ssl).handshake->ecdh_psa_peerkey[0] ^= 0x02;
}
- TEST_EQUAL( mbedtls_move_handshake_to_state( &(client.ssl),
- &(server.ssl),
- MBEDTLS_SSL_HANDSHAKE_OVER ),
- bad_server_ecdhe_key ? MBEDTLS_ERR_SSL_HW_ACCEL_FAILED : 0 );
+ TEST_EQUAL(mbedtls_move_handshake_to_state(&(client.ssl),
+ &(server.ssl),
+ MBEDTLS_SSL_HANDSHAKE_OVER),
+ bad_server_ecdhe_key ? MBEDTLS_ERR_SSL_HW_ACCEL_FAILED : 0);
- mbedtls_psa_get_stats( &stats );
+ mbedtls_psa_get_stats(&stats);
/* Make sure that the key slot is already destroyed in case of failure,
* without waiting to close the connection. */
- if( bad_server_ecdhe_key )
- TEST_EQUAL( free_slots_before, stats.empty_slots );
+ if (bad_server_ecdhe_key) {
+ TEST_EQUAL(free_slots_before, stats.empty_slots);
+ }
exit:
- mbedtls_endpoint_free( &client, NULL );
- mbedtls_endpoint_free( &server, NULL );
+ mbedtls_endpoint_free(&client, NULL);
+ mbedtls_endpoint_free(&server, NULL);
- USE_PSA_DONE( );
+ USE_PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SSL_SRV_C:MBEDTLS_SSL_DTLS_CLIENT_PORT_REUSE:MBEDTLS_TEST_HOOKS */
-void cookie_parsing( data_t *cookie, int exp_ret )
+void cookie_parsing(data_t *cookie, int exp_ret)
{
mbedtls_ssl_context ssl;
mbedtls_ssl_config conf;
size_t len;
- mbedtls_ssl_init( &ssl );
- mbedtls_ssl_config_init( &conf );
- TEST_EQUAL( mbedtls_ssl_config_defaults( &conf, MBEDTLS_SSL_IS_SERVER,
- MBEDTLS_SSL_TRANSPORT_DATAGRAM,
- MBEDTLS_SSL_PRESET_DEFAULT ),
- 0 );
+ mbedtls_ssl_init(&ssl);
+ mbedtls_ssl_config_init(&conf);
+ TEST_EQUAL(mbedtls_ssl_config_defaults(&conf, MBEDTLS_SSL_IS_SERVER,
+ MBEDTLS_SSL_TRANSPORT_DATAGRAM,
+ MBEDTLS_SSL_PRESET_DEFAULT),
+ 0);
- TEST_EQUAL( mbedtls_ssl_setup( &ssl, &conf ), 0 );
- TEST_EQUAL( mbedtls_ssl_check_dtls_clihlo_cookie( &ssl, ssl.cli_id,
- ssl.cli_id_len,
- cookie->x, cookie->len,
- ssl.out_buf,
- MBEDTLS_SSL_OUT_CONTENT_LEN,
- &len ),
- exp_ret );
+ TEST_EQUAL(mbedtls_ssl_setup(&ssl, &conf), 0);
+ TEST_EQUAL(mbedtls_ssl_check_dtls_clihlo_cookie(&ssl, ssl.cli_id,
+ ssl.cli_id_len,
+ cookie->x, cookie->len,
+ ssl.out_buf,
+ MBEDTLS_SSL_OUT_CONTENT_LEN,
+ &len),
+ exp_ret);
- mbedtls_ssl_free( &ssl );
- mbedtls_ssl_config_free( &conf );
+ mbedtls_ssl_free(&ssl);
+ mbedtls_ssl_config_free(&conf);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_timing.function b/tests/suites/test_suite_timing.function
index 74dc823..59c1207 100644
--- a/tests/suites/test_suite_timing.function
+++ b/tests/suites/test_suite_timing.function
@@ -17,7 +17,7 @@
*/
/* BEGIN_CASE */
-void timing_hardclock( )
+void timing_hardclock()
{
(void) mbedtls_timing_hardclock();
/* This goto is added to avoid warnings from the generated code. */
@@ -26,49 +26,43 @@
/* END_CASE */
/* BEGIN_CASE */
-void timing_get_timer( )
+void timing_get_timer()
{
struct mbedtls_timing_hr_time time;
- (void) mbedtls_timing_get_timer( &time, 1 );
- (void) mbedtls_timing_get_timer( &time, 0 );
+ (void) mbedtls_timing_get_timer(&time, 1);
+ (void) mbedtls_timing_get_timer(&time, 0);
/* This goto is added to avoid warnings from the generated code. */
goto exit;
}
/* END_CASE */
/* BEGIN_CASE */
-void timing_set_alarm( int seconds )
+void timing_set_alarm(int seconds)
{
- if( seconds == 0 )
- {
- mbedtls_set_alarm( seconds );
- TEST_ASSERT( mbedtls_timing_alarmed == 1 );
- }
- else
- {
- mbedtls_set_alarm( seconds );
- TEST_ASSERT( mbedtls_timing_alarmed == 0 ||
- mbedtls_timing_alarmed == 1 );
+ if (seconds == 0) {
+ mbedtls_set_alarm(seconds);
+ TEST_ASSERT(mbedtls_timing_alarmed == 1);
+ } else {
+ mbedtls_set_alarm(seconds);
+ TEST_ASSERT(mbedtls_timing_alarmed == 0 ||
+ mbedtls_timing_alarmed == 1);
}
}
/* END_CASE */
/* BEGIN_CASE */
-void timing_delay( int fin_ms )
+void timing_delay(int fin_ms)
{
mbedtls_timing_delay_context ctx;
int result;
- if( fin_ms == 0 )
- {
- mbedtls_timing_set_delay( &ctx, 0, 0 );
- result = mbedtls_timing_get_delay( &ctx );
- TEST_ASSERT( result == -1 );
- }
- else
- {
- mbedtls_timing_set_delay( &ctx, fin_ms / 2, fin_ms );
- result = mbedtls_timing_get_delay( &ctx );
- TEST_ASSERT( result >= 0 && result <= 2 );
+ if (fin_ms == 0) {
+ mbedtls_timing_set_delay(&ctx, 0, 0);
+ result = mbedtls_timing_get_delay(&ctx);
+ TEST_ASSERT(result == -1);
+ } else {
+ mbedtls_timing_set_delay(&ctx, fin_ms / 2, fin_ms);
+ result = mbedtls_timing_get_delay(&ctx);
+ TEST_ASSERT(result >= 0 && result <= 2);
}
}
/* END_CASE */
diff --git a/tests/suites/test_suite_version.function b/tests/suites/test_suite_version.function
index 7d59794..981f8ab 100644
--- a/tests/suites/test_suite_version.function
+++ b/tests/suites/test_suite_version.function
@@ -8,34 +8,34 @@
*/
/* BEGIN_CASE */
-void check_compiletime_version( char * version_str )
+void check_compiletime_version(char *version_str)
{
char build_str[100];
char build_str_full[100];
unsigned int build_int;
- memset( build_str, 0, 100 );
- memset( build_str_full, 0, 100 );
+ memset(build_str, 0, 100);
+ memset(build_str_full, 0, 100);
- mbedtls_snprintf( build_str, 100, "%d.%d.%d", MBEDTLS_VERSION_MAJOR,
- MBEDTLS_VERSION_MINOR, MBEDTLS_VERSION_PATCH );
+ mbedtls_snprintf(build_str, 100, "%d.%d.%d", MBEDTLS_VERSION_MAJOR,
+ MBEDTLS_VERSION_MINOR, MBEDTLS_VERSION_PATCH);
- mbedtls_snprintf( build_str_full, 100, "mbed TLS %d.%d.%d", MBEDTLS_VERSION_MAJOR,
- MBEDTLS_VERSION_MINOR, MBEDTLS_VERSION_PATCH );
+ mbedtls_snprintf(build_str_full, 100, "mbed TLS %d.%d.%d", MBEDTLS_VERSION_MAJOR,
+ MBEDTLS_VERSION_MINOR, MBEDTLS_VERSION_PATCH);
build_int = MBEDTLS_VERSION_MAJOR << 24 |
- MBEDTLS_VERSION_MINOR << 16 |
- MBEDTLS_VERSION_PATCH << 8;
+ MBEDTLS_VERSION_MINOR << 16 |
+ MBEDTLS_VERSION_PATCH << 8;
- TEST_ASSERT( build_int == MBEDTLS_VERSION_NUMBER );
- TEST_ASSERT( strcmp( build_str, MBEDTLS_VERSION_STRING ) == 0 );
- TEST_ASSERT( strcmp( build_str_full, MBEDTLS_VERSION_STRING_FULL ) == 0 );
- TEST_ASSERT( strcmp( version_str, MBEDTLS_VERSION_STRING ) == 0 );
+ TEST_ASSERT(build_int == MBEDTLS_VERSION_NUMBER);
+ TEST_ASSERT(strcmp(build_str, MBEDTLS_VERSION_STRING) == 0);
+ TEST_ASSERT(strcmp(build_str_full, MBEDTLS_VERSION_STRING_FULL) == 0);
+ TEST_ASSERT(strcmp(version_str, MBEDTLS_VERSION_STRING) == 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void check_runtime_version( char * version_str )
+void check_runtime_version(char *version_str)
{
char build_str[100];
char get_str[100];
@@ -43,31 +43,31 @@
char get_str_full[100];
unsigned int get_int;
- memset( build_str, 0, 100 );
- memset( get_str, 0, 100 );
- memset( build_str_full, 0, 100 );
- memset( get_str_full, 0, 100 );
+ memset(build_str, 0, 100);
+ memset(get_str, 0, 100);
+ memset(build_str_full, 0, 100);
+ memset(get_str_full, 0, 100);
get_int = mbedtls_version_get_number();
- mbedtls_version_get_string( get_str );
- mbedtls_version_get_string_full( get_str_full );
+ mbedtls_version_get_string(get_str);
+ mbedtls_version_get_string_full(get_str_full);
- mbedtls_snprintf( build_str, 100, "%u.%u.%u",
- (get_int >> 24) & 0xFF,
- (get_int >> 16) & 0xFF,
- (get_int >> 8) & 0xFF );
- mbedtls_snprintf( build_str_full, 100, "mbed TLS %s", version_str );
+ mbedtls_snprintf(build_str, 100, "%u.%u.%u",
+ (get_int >> 24) & 0xFF,
+ (get_int >> 16) & 0xFF,
+ (get_int >> 8) & 0xFF);
+ mbedtls_snprintf(build_str_full, 100, "mbed TLS %s", version_str);
- TEST_ASSERT( strcmp( build_str, version_str ) == 0 );
- TEST_ASSERT( strcmp( build_str_full, get_str_full ) == 0 );
- TEST_ASSERT( strcmp( version_str, get_str ) == 0 );
+ TEST_ASSERT(strcmp(build_str, version_str) == 0);
+ TEST_ASSERT(strcmp(build_str_full, get_str_full) == 0);
+ TEST_ASSERT(strcmp(version_str, get_str) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_VERSION_FEATURES */
-void check_feature( char *feature, int result )
+void check_feature(char *feature, int result)
{
- int check = mbedtls_version_check_feature( feature );
- TEST_ASSERT( check == result );
+ int check = mbedtls_version_check_feature(feature);
+ TEST_ASSERT(check == result);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_x509parse.function b/tests/suites/test_suite_x509parse.function
index ba5c860..91ac00d 100644
--- a/tests/suites/test_suite_x509parse.function
+++ b/tests/suites/test_suite_x509parse.function
@@ -12,8 +12,8 @@
#if MBEDTLS_X509_MAX_INTERMEDIATE_CA > 19
#error "The value of MBEDTLS_X509_MAX_INTERMEDIATE_C is larger \
-than the current threshold 19. To test larger values, please \
-adapt the script tests/data_files/dir-max/long.sh."
+ than the current threshold 19. To test larger values, please \
+ adapt the script tests/data_files/dir-max/long.sh."
#endif
/* Test-only profile allowing all digests, PK algorithms, and curves. */
@@ -29,12 +29,12 @@
profile. */
const mbedtls_x509_crt_profile compat_profile =
{
- MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA1 ) |
- MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_RIPEMD160 ) |
- MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA224 ) |
- MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
- MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ) |
- MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA512 ),
+ MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA1) |
+ MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_RIPEMD160) |
+ MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA224) |
+ MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA256) |
+ MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA384) |
+ MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA512),
0xFFFFFFFF, /* Any PK alg */
0xFFFFFFFF, /* Any curve */
1024,
@@ -42,23 +42,23 @@
const mbedtls_x509_crt_profile profile_rsa3072 =
{
- MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
- MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ) |
- MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA512 ),
- MBEDTLS_X509_ID_FLAG( MBEDTLS_PK_RSA ),
+ MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA256) |
+ MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA384) |
+ MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA512),
+ MBEDTLS_X509_ID_FLAG(MBEDTLS_PK_RSA),
0,
3072,
};
const mbedtls_x509_crt_profile profile_sha512 =
{
- MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA512 ),
+ MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA512),
0xFFFFFFFF, /* Any PK alg */
0xFFFFFFFF, /* Any curve */
1024,
};
-int verify_none( void *data, mbedtls_x509_crt *crt, int certificate_depth, uint32_t *flags )
+int verify_none(void *data, mbedtls_x509_crt *crt, int certificate_depth, uint32_t *flags)
{
((void) data);
((void) crt);
@@ -68,7 +68,7 @@
return 0;
}
-int verify_all( void *data, mbedtls_x509_crt *crt, int certificate_depth, uint32_t *flags )
+int verify_all(void *data, mbedtls_x509_crt *crt, int certificate_depth, uint32_t *flags)
{
((void) data);
((void) crt);
@@ -79,7 +79,7 @@
}
#if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
-int ca_callback_fail( void *data, mbedtls_x509_crt const *child, mbedtls_x509_crt **candidates )
+int ca_callback_fail(void *data, mbedtls_x509_crt const *child, mbedtls_x509_crt **candidates)
{
((void) data);
((void) child);
@@ -88,8 +88,8 @@
return -1;
}
-int ca_callback( void *data, mbedtls_x509_crt const *child,
- mbedtls_x509_crt **candidates )
+int ca_callback(void *data, mbedtls_x509_crt const *child,
+ mbedtls_x509_crt **candidates)
{
int ret = 0;
mbedtls_x509_crt *ca = (mbedtls_x509_crt *) data;
@@ -105,25 +105,21 @@
* and parent `Subject` field. */
((void) child);
- first = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt ) );
- if( first == NULL )
- {
+ first = mbedtls_calloc(1, sizeof(mbedtls_x509_crt));
+ if (first == NULL) {
ret = -1;
goto exit;
}
- mbedtls_x509_crt_init( first );
+ mbedtls_x509_crt_init(first);
- if( mbedtls_x509_crt_parse_der( first, ca->raw.p, ca->raw.len ) != 0 )
- {
+ if (mbedtls_x509_crt_parse_der(first, ca->raw.p, ca->raw.len) != 0) {
ret = -1;
goto exit;
}
- while( ca->next != NULL )
- {
+ while (ca->next != NULL) {
ca = ca->next;
- if( mbedtls_x509_crt_parse_der( first, ca->raw.p, ca->raw.len ) != 0 )
- {
+ if (mbedtls_x509_crt_parse_der(first, ca->raw.p, ca->raw.len) != 0) {
ret = -1;
goto exit;
}
@@ -131,19 +127,18 @@
exit:
- if( ret != 0 )
- {
- mbedtls_x509_crt_free( first );
- mbedtls_free( first );
+ if (ret != 0) {
+ mbedtls_x509_crt_free(first);
+ mbedtls_free(first);
first = NULL;
}
*candidates = first;
- return( ret );
+ return ret;
}
#endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
-int verify_fatal( void *data, mbedtls_x509_crt *crt, int certificate_depth, uint32_t *flags )
+int verify_fatal(void *data, mbedtls_x509_crt *crt, int certificate_depth, uint32_t *flags)
{
int *levels = (int *) data;
@@ -151,13 +146,12 @@
((void) certificate_depth);
/* Simulate a fatal error in the callback */
- if( *levels & ( 1 << certificate_depth ) )
- {
- *flags |= ( 1 << certificate_depth );
- return( -1 - certificate_depth );
+ if (*levels & (1 << certificate_depth)) {
+ *flags |= (1 << certificate_depth);
+ return -1 - certificate_depth;
}
- return( 0 );
+ return 0;
}
/* strsep() not available on Windows */
@@ -166,28 +160,27 @@
const char *p;
char *ret = *stringp;
- if( *stringp == NULL )
- return( NULL );
+ if (*stringp == NULL) {
+ return NULL;
+ }
- for( ; ; (*stringp)++ )
- {
- if( **stringp == '\0' )
- {
+ for (;; (*stringp)++) {
+ if (**stringp == '\0') {
*stringp = NULL;
goto done;
}
- for( p = delim; *p != '\0'; p++ )
- if( **stringp == *p )
- {
+ for (p = delim; *p != '\0'; p++) {
+ if (**stringp == *p) {
**stringp = '\0';
(*stringp)++;
goto done;
}
+ }
}
done:
- return( ret );
+ return ret;
}
#if defined(MBEDTLS_X509_CRT_PARSE_C)
@@ -196,195 +189,204 @@
char *p;
} verify_print_context;
-void verify_print_init( verify_print_context *ctx )
+void verify_print_init(verify_print_context *ctx)
{
- memset( ctx, 0, sizeof( verify_print_context ) );
+ memset(ctx, 0, sizeof(verify_print_context));
ctx->p = ctx->buf;
}
-int verify_print( void *data, mbedtls_x509_crt *crt, int certificate_depth, uint32_t *flags )
+int verify_print(void *data, mbedtls_x509_crt *crt, int certificate_depth, uint32_t *flags)
{
int ret;
verify_print_context *ctx = (verify_print_context *) data;
char *p = ctx->p;
- size_t n = ctx->buf + sizeof( ctx->buf ) - ctx->p;
+ size_t n = ctx->buf + sizeof(ctx->buf) - ctx->p;
((void) flags);
- ret = mbedtls_snprintf( p, n, "depth %d - serial ", certificate_depth );
+ ret = mbedtls_snprintf(p, n, "depth %d - serial ", certificate_depth);
MBEDTLS_X509_SAFE_SNPRINTF;
- ret = mbedtls_x509_serial_gets( p, n, &crt->serial );
+ ret = mbedtls_x509_serial_gets(p, n, &crt->serial);
MBEDTLS_X509_SAFE_SNPRINTF;
- ret = mbedtls_snprintf( p, n, " - subject " );
+ ret = mbedtls_snprintf(p, n, " - subject ");
MBEDTLS_X509_SAFE_SNPRINTF;
- ret = mbedtls_x509_dn_gets( p, n, &crt->subject );
+ ret = mbedtls_x509_dn_gets(p, n, &crt->subject);
MBEDTLS_X509_SAFE_SNPRINTF;
- ret = mbedtls_snprintf( p, n, " - flags 0x%08x\n", *flags );
+ ret = mbedtls_snprintf(p, n, " - flags 0x%08x\n", *flags);
MBEDTLS_X509_SAFE_SNPRINTF;
ctx->p = p;
- return( 0 );
+ return 0;
}
-int verify_parse_san( mbedtls_x509_subject_alternative_name *san,
- char **buf, size_t *size )
+int verify_parse_san(mbedtls_x509_subject_alternative_name *san,
+ char **buf, size_t *size)
{
int ret;
size_t i;
char *p = *buf;
size_t n = *size;
- ret = mbedtls_snprintf( p, n, "type : %d", san->type );
+ ret = mbedtls_snprintf(p, n, "type : %d", san->type);
MBEDTLS_X509_SAFE_SNPRINTF;
- switch( san->type )
- {
- case( MBEDTLS_X509_SAN_OTHER_NAME ):
- ret = mbedtls_snprintf( p, n, "\notherName :");
+ switch (san->type) {
+ case (MBEDTLS_X509_SAN_OTHER_NAME):
+ ret = mbedtls_snprintf(p, n, "\notherName :");
MBEDTLS_X509_SAFE_SNPRINTF;
- if( MBEDTLS_OID_CMP( MBEDTLS_OID_ON_HW_MODULE_NAME,
- &san->san.other_name.value.hardware_module_name.oid ) != 0 )
- {
- ret = mbedtls_snprintf( p, n, " hardware module name :" );
+ if (MBEDTLS_OID_CMP(MBEDTLS_OID_ON_HW_MODULE_NAME,
+ &san->san.other_name.value.hardware_module_name.oid) != 0) {
+ ret = mbedtls_snprintf(p, n, " hardware module name :");
MBEDTLS_X509_SAFE_SNPRINTF;
- ret = mbedtls_snprintf( p, n, " hardware type : " );
+ ret = mbedtls_snprintf(p, n, " hardware type : ");
MBEDTLS_X509_SAFE_SNPRINTF;
- ret = mbedtls_oid_get_numeric_string( p, n,
- &san->san.other_name.value.hardware_module_name.oid );
+ ret = mbedtls_oid_get_numeric_string(p,
+ n,
+ &san->san.other_name.value.hardware_module_name.oid);
MBEDTLS_X509_SAFE_SNPRINTF;
- ret = mbedtls_snprintf( p, n, ", hardware serial number : " );
+ ret = mbedtls_snprintf(p, n, ", hardware serial number : ");
MBEDTLS_X509_SAFE_SNPRINTF;
- for( i = 0; i < san->san.other_name.value.hardware_module_name.val.len; i++ )
- {
- ret = mbedtls_snprintf( p, n, "%02X", san->san.other_name.value.hardware_module_name.val.p[i] );
+ for (i = 0; i < san->san.other_name.value.hardware_module_name.val.len; i++) {
+ ret = mbedtls_snprintf(p,
+ n,
+ "%02X",
+ san->san.other_name.value.hardware_module_name.val.p[i]);
MBEDTLS_X509_SAFE_SNPRINTF;
}
}
- break;/* MBEDTLS_OID_ON_HW_MODULE_NAME */
- case( MBEDTLS_X509_SAN_DNS_NAME ):
- ret = mbedtls_snprintf( p, n, "\ndNSName : " );
+ break;/* MBEDTLS_OID_ON_HW_MODULE_NAME */
+ case (MBEDTLS_X509_SAN_DNS_NAME):
+ ret = mbedtls_snprintf(p, n, "\ndNSName : ");
MBEDTLS_X509_SAFE_SNPRINTF;
- if( san->san.unstructured_name.len >= n )
- {
+ if (san->san.unstructured_name.len >= n) {
*p = '\0';
- return( MBEDTLS_ERR_X509_BUFFER_TOO_SMALL );
+ return MBEDTLS_ERR_X509_BUFFER_TOO_SMALL;
}
n -= san->san.unstructured_name.len;
- for( i = 0; i < san->san.unstructured_name.len; i++ )
+ for (i = 0; i < san->san.unstructured_name.len; i++) {
*p++ = san->san.unstructured_name.p[i];
- break;/* MBEDTLS_X509_SAN_DNS_NAME */
+ }
+ break;/* MBEDTLS_X509_SAN_DNS_NAME */
default:
- /*
- * Should not happen.
- */
- return( -1 );
+ /*
+ * Should not happen.
+ */
+ return -1;
}
- ret = mbedtls_snprintf( p, n, "\n" );
+ ret = mbedtls_snprintf(p, n, "\n");
MBEDTLS_X509_SAFE_SNPRINTF;
*size = n;
*buf = p;
- return( 0 );
+ return 0;
}
-int parse_crt_ext_cb( void *p_ctx, mbedtls_x509_crt const *crt, mbedtls_x509_buf const *oid,
- int critical, const unsigned char *cp, const unsigned char *end )
+int parse_crt_ext_cb(void *p_ctx, mbedtls_x509_crt const *crt, mbedtls_x509_buf const *oid,
+ int critical, const unsigned char *cp, const unsigned char *end)
{
- ( void ) crt;
- ( void ) critical;
- mbedtls_x509_buf *new_oid = (mbedtls_x509_buf *)p_ctx;
- if( oid->tag == MBEDTLS_ASN1_OID &&
- MBEDTLS_OID_CMP( MBEDTLS_OID_CERTIFICATE_POLICIES, oid ) == 0 )
- {
+ (void) crt;
+ (void) critical;
+ mbedtls_x509_buf *new_oid = (mbedtls_x509_buf *) p_ctx;
+ if (oid->tag == MBEDTLS_ASN1_OID &&
+ MBEDTLS_OID_CMP(MBEDTLS_OID_CERTIFICATE_POLICIES, oid) == 0) {
/* Handle unknown certificate policy */
int ret, parse_ret = 0;
size_t len;
- unsigned char **p = (unsigned char **)&cp;
+ unsigned char **p = (unsigned char **) &cp;
/* Get main sequence tag */
- ret = mbedtls_asn1_get_tag( p, end, &len,
- MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE );
- if( ret != 0 )
- return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_X509_INVALID_EXTENSIONS, ret ) );
+ ret = mbedtls_asn1_get_tag(p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE);
+ if (ret != 0) {
+ return MBEDTLS_ERROR_ADD(MBEDTLS_ERR_X509_INVALID_EXTENSIONS, ret);
+ }
- if( *p + len != end )
- return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_X509_INVALID_EXTENSIONS,
- MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ) );
+ if (*p + len != end) {
+ return MBEDTLS_ERROR_ADD(MBEDTLS_ERR_X509_INVALID_EXTENSIONS,
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH);
+ }
/*
* Cannot be an empty sequence.
*/
- if( len == 0 )
- return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_X509_INVALID_EXTENSIONS,
- MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ) );
+ if (len == 0) {
+ return MBEDTLS_ERROR_ADD(MBEDTLS_ERR_X509_INVALID_EXTENSIONS,
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH);
+ }
- while( *p < end )
- {
+ while (*p < end) {
const unsigned char *policy_end;
/*
* Get the policy sequence
*/
- if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
- MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
- return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_X509_INVALID_EXTENSIONS, ret ) );
+ if ((ret = mbedtls_asn1_get_tag(p, end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE)) !=
+ 0) {
+ return MBEDTLS_ERROR_ADD(MBEDTLS_ERR_X509_INVALID_EXTENSIONS, ret);
+ }
policy_end = *p + len;
- if( ( ret = mbedtls_asn1_get_tag( p, policy_end, &len,
- MBEDTLS_ASN1_OID ) ) != 0 )
- return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_X509_INVALID_EXTENSIONS, ret ) );
+ if ((ret = mbedtls_asn1_get_tag(p, policy_end, &len,
+ MBEDTLS_ASN1_OID)) != 0) {
+ return MBEDTLS_ERROR_ADD(MBEDTLS_ERR_X509_INVALID_EXTENSIONS, ret);
+ }
/*
* Recognize exclusively the policy with OID 1
*/
- if( len != 1 || *p[0] != 1 )
+ if (len != 1 || *p[0] != 1) {
parse_ret = MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE;
+ }
*p += len;
- /*
- * If there is an optional qualifier, then *p < policy_end
- * Check the Qualifier len to verify it doesn't exceed policy_end.
- */
- if( *p < policy_end )
- {
- if( ( ret = mbedtls_asn1_get_tag( p, policy_end, &len,
- MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
- return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_X509_INVALID_EXTENSIONS, ret ) );
+ /*
+ * If there is an optional qualifier, then *p < policy_end
+ * Check the Qualifier len to verify it doesn't exceed policy_end.
+ */
+ if (*p < policy_end) {
+ if ((ret = mbedtls_asn1_get_tag(p, policy_end, &len,
+ MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE)) != 0) {
+ return MBEDTLS_ERROR_ADD(MBEDTLS_ERR_X509_INVALID_EXTENSIONS, ret);
+ }
/*
* Skip the optional policy qualifiers.
*/
*p += len;
}
- if( *p != policy_end )
- return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_X509_INVALID_EXTENSIONS,
- MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ) );
+ if (*p != policy_end) {
+ return MBEDTLS_ERROR_ADD(MBEDTLS_ERR_X509_INVALID_EXTENSIONS,
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH);
+ }
}
- if( *p != end )
- return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_X509_INVALID_EXTENSIONS,
- MBEDTLS_ERR_ASN1_LENGTH_MISMATCH ) );
+ if (*p != end) {
+ return MBEDTLS_ERROR_ADD(MBEDTLS_ERR_X509_INVALID_EXTENSIONS,
+ MBEDTLS_ERR_ASN1_LENGTH_MISMATCH);
+ }
- return( parse_ret );
+ return parse_ret;
+ } else if (new_oid != NULL && new_oid->tag == oid->tag && new_oid->len == oid->len &&
+ memcmp(new_oid->p, oid->p, oid->len) == 0) {
+ return 0;
+ } else {
+ return MBEDTLS_ERROR_ADD(MBEDTLS_ERR_X509_INVALID_EXTENSIONS,
+ MBEDTLS_ERR_ASN1_UNEXPECTED_TAG);
}
- else if( new_oid != NULL && new_oid->tag == oid->tag && new_oid->len == oid->len &&
- memcmp( new_oid->p, oid->p, oid->len ) == 0 )
- return( 0 );
- else
- return( MBEDTLS_ERROR_ADD( MBEDTLS_ERR_X509_INVALID_EXTENSIONS,
- MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) );
}
#endif /* MBEDTLS_X509_CRT_PARSE_C */
/* END_HEADER */
@@ -395,7 +397,7 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C */
-void x509_parse_san( char * crt_file, char * result_str )
+void x509_parse_san(char *crt_file, char *result_str)
{
int ret;
mbedtls_x509_crt crt;
@@ -403,142 +405,141 @@
mbedtls_x509_sequence *cur = NULL;
char buf[2000];
char *p = buf;
- size_t n = sizeof( buf );
+ size_t n = sizeof(buf);
- mbedtls_x509_crt_init( &crt );
- memset( buf, 0, 2000 );
+ mbedtls_x509_crt_init(&crt);
+ 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);
- if( crt.ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
- {
+ if (crt.ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME) {
cur = &crt.subject_alt_names;
- while( cur != NULL )
- {
- ret = mbedtls_x509_parse_subject_alt_name( &cur->buf, &san );
- TEST_ASSERT( ret == 0 || ret == MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE );
+ while (cur != NULL) {
+ ret = mbedtls_x509_parse_subject_alt_name(&cur->buf, &san);
+ TEST_ASSERT(ret == 0 || ret == MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE);
/*
* If san type not supported, ignore.
*/
- if( ret == 0)
- TEST_ASSERT( verify_parse_san( &san, &p, &n ) == 0 );
+ if (ret == 0) {
+ TEST_ASSERT(verify_parse_san(&san, &p, &n) == 0);
+ }
cur = cur->next;
}
}
- TEST_ASSERT( strcmp( buf, result_str ) == 0 );
+ TEST_ASSERT(strcmp(buf, result_str) == 0);
exit:
- mbedtls_x509_crt_free( &crt );
+ mbedtls_x509_crt_free(&crt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C */
-void x509_cert_info( char * crt_file, char * result_str )
+void x509_cert_info(char *crt_file, char *result_str)
{
mbedtls_x509_crt crt;
char buf[2000];
int res;
- mbedtls_x509_crt_init( &crt );
- memset( buf, 0, 2000 );
+ mbedtls_x509_crt_init(&crt);
+ memset(buf, 0, 2000);
- TEST_ASSERT( mbedtls_x509_crt_parse_file( &crt, crt_file ) == 0 );
- res = mbedtls_x509_crt_info( buf, 2000, "", &crt );
+ TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
+ res = mbedtls_x509_crt_info(buf, 2000, "", &crt);
- TEST_ASSERT( res != -1 );
- TEST_ASSERT( res != -2 );
+ TEST_ASSERT(res != -1);
+ TEST_ASSERT(res != -2);
- TEST_ASSERT( strcmp( buf, result_str ) == 0 );
+ TEST_ASSERT(strcmp(buf, result_str) == 0);
exit:
- mbedtls_x509_crt_free( &crt );
+ mbedtls_x509_crt_free(&crt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRL_PARSE_C */
-void mbedtls_x509_crl_info( char * crl_file, char * result_str )
+void mbedtls_x509_crl_info(char *crl_file, char *result_str)
{
mbedtls_x509_crl crl;
char buf[2000];
int res;
- mbedtls_x509_crl_init( &crl );
- memset( buf, 0, 2000 );
+ mbedtls_x509_crl_init(&crl);
+ memset(buf, 0, 2000);
- TEST_ASSERT( mbedtls_x509_crl_parse_file( &crl, crl_file ) == 0 );
- res = mbedtls_x509_crl_info( buf, 2000, "", &crl );
+ TEST_ASSERT(mbedtls_x509_crl_parse_file(&crl, crl_file) == 0);
+ res = mbedtls_x509_crl_info(buf, 2000, "", &crl);
- TEST_ASSERT( res != -1 );
- TEST_ASSERT( res != -2 );
+ TEST_ASSERT(res != -1);
+ TEST_ASSERT(res != -2);
- TEST_ASSERT( strcmp( buf, result_str ) == 0 );
+ TEST_ASSERT(strcmp(buf, result_str) == 0);
exit:
- mbedtls_x509_crl_free( &crl );
+ mbedtls_x509_crl_free(&crl);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRL_PARSE_C */
-void mbedtls_x509_crl_parse( char * crl_file, int result )
+void mbedtls_x509_crl_parse(char *crl_file, int result)
{
mbedtls_x509_crl crl;
char buf[2000];
- mbedtls_x509_crl_init( &crl );
- memset( buf, 0, 2000 );
+ mbedtls_x509_crl_init(&crl);
+ 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);
exit:
- mbedtls_x509_crl_free( &crl );
+ mbedtls_x509_crl_free(&crl);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CSR_PARSE_C */
-void mbedtls_x509_csr_info( char * csr_file, char * result_str )
+void mbedtls_x509_csr_info(char *csr_file, char *result_str)
{
mbedtls_x509_csr csr;
char buf[2000];
int res;
- mbedtls_x509_csr_init( &csr );
- memset( buf, 0, 2000 );
+ mbedtls_x509_csr_init(&csr);
+ memset(buf, 0, 2000);
- TEST_ASSERT( mbedtls_x509_csr_parse_file( &csr, csr_file ) == 0 );
- res = mbedtls_x509_csr_info( buf, 2000, "", &csr );
+ TEST_ASSERT(mbedtls_x509_csr_parse_file(&csr, csr_file) == 0);
+ res = mbedtls_x509_csr_info(buf, 2000, "", &csr);
- TEST_ASSERT( res != -1 );
- TEST_ASSERT( res != -2 );
+ TEST_ASSERT(res != -1);
+ TEST_ASSERT(res != -2);
- TEST_ASSERT( strcmp( buf, result_str ) == 0 );
+ TEST_ASSERT(strcmp(buf, result_str) == 0);
exit:
- mbedtls_x509_csr_free( &csr );
+ mbedtls_x509_csr_free(&csr);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C */
-void x509_verify_info( int flags, char * prefix, char * result_str )
+void x509_verify_info(int flags, char *prefix, char *result_str)
{
char buf[2000];
int res;
- memset( buf, 0, sizeof( buf ) );
+ memset(buf, 0, sizeof(buf));
- res = mbedtls_x509_crt_verify_info( buf, sizeof( buf ), prefix, flags );
+ res = mbedtls_x509_crt_verify_info(buf, sizeof(buf), prefix, flags);
- TEST_ASSERT( res >= 0 );
+ TEST_ASSERT(res >= 0);
- TEST_ASSERT( strcmp( buf, result_str ) == 0 );
+ TEST_ASSERT(strcmp(buf, result_str) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_X509_CRL_PARSE_C:MBEDTLS_ECP_RESTARTABLE:MBEDTLS_ECDSA_C */
-void x509_verify_restart( char *crt_file, char *ca_file,
- int result, int flags_result,
- int max_ops, int min_restart, int max_restart )
+void x509_verify_restart(char *crt_file, char *ca_file,
+ int result, int flags_result,
+ int max_ops, int min_restart, int max_restart)
{
int ret, cnt_restart;
mbedtls_x509_crt_restart_ctx rs_ctx;
@@ -556,46 +557,46 @@
* - x509_verify() for server10 -> int-ca3 -> int-ca2: ~ 25500
*/
- mbedtls_x509_crt_restart_init( &rs_ctx );
- mbedtls_x509_crt_init( &crt );
- mbedtls_x509_crt_init( &ca );
+ mbedtls_x509_crt_restart_init(&rs_ctx);
+ mbedtls_x509_crt_init(&crt);
+ mbedtls_x509_crt_init(&ca);
- 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(&crt, crt_file) == 0);
+ TEST_ASSERT(mbedtls_x509_crt_parse_file(&ca, ca_file) == 0);
- mbedtls_ecp_set_max_ops( max_ops );
+ mbedtls_ecp_set_max_ops(max_ops);
cnt_restart = 0;
do {
- ret = mbedtls_x509_crt_verify_restartable( &crt, &ca, NULL,
- &mbedtls_x509_crt_profile_default, NULL, &flags,
- NULL, NULL, &rs_ctx );
- } while( ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart );
+ ret = mbedtls_x509_crt_verify_restartable(&crt, &ca, NULL,
+ &mbedtls_x509_crt_profile_default, NULL, &flags,
+ NULL, NULL, &rs_ctx);
+ } while (ret == MBEDTLS_ERR_ECP_IN_PROGRESS && ++cnt_restart);
- TEST_ASSERT( ret == result );
- TEST_ASSERT( flags == (uint32_t) flags_result );
+ TEST_ASSERT(ret == result);
+ TEST_ASSERT(flags == (uint32_t) flags_result);
- TEST_ASSERT( cnt_restart >= min_restart );
- TEST_ASSERT( cnt_restart <= max_restart );
+ TEST_ASSERT(cnt_restart >= min_restart);
+ TEST_ASSERT(cnt_restart <= max_restart);
/* Do we leak memory when aborting? */
- ret = mbedtls_x509_crt_verify_restartable( &crt, &ca, NULL,
- &mbedtls_x509_crt_profile_default, NULL, &flags,
- NULL, NULL, &rs_ctx );
- TEST_ASSERT( ret == result || ret == MBEDTLS_ERR_ECP_IN_PROGRESS );
+ ret = mbedtls_x509_crt_verify_restartable(&crt, &ca, NULL,
+ &mbedtls_x509_crt_profile_default, NULL, &flags,
+ NULL, NULL, &rs_ctx);
+ TEST_ASSERT(ret == result || ret == MBEDTLS_ERR_ECP_IN_PROGRESS);
exit:
- mbedtls_x509_crt_restart_free( &rs_ctx );
- mbedtls_x509_crt_free( &crt );
- mbedtls_x509_crt_free( &ca );
+ mbedtls_x509_crt_restart_free(&rs_ctx);
+ mbedtls_x509_crt_free(&crt);
+ mbedtls_x509_crt_free(&ca);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_X509_CRL_PARSE_C */
-void x509_verify( char *crt_file, char *ca_file, char *crl_file,
- char *cn_name_str, int result, int flags_result,
- char *profile_str,
- char *verify_callback )
+void x509_verify(char *crt_file, char *ca_file, char *crl_file,
+ char *cn_name_str, int result, int flags_result,
+ char *profile_str,
+ char *verify_callback)
{
mbedtls_x509_crt crt;
mbedtls_x509_crt ca;
@@ -603,103 +604,120 @@
uint32_t flags = 0;
int res;
int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *) = NULL;
- char * cn_name = NULL;
+ char *cn_name = NULL;
const mbedtls_x509_crt_profile *profile;
- mbedtls_x509_crt_init( &crt );
- mbedtls_x509_crt_init( &ca );
- mbedtls_x509_crl_init( &crl );
+ mbedtls_x509_crt_init(&crt);
+ mbedtls_x509_crt_init(&ca);
+ mbedtls_x509_crl_init(&crl);
- USE_PSA_INIT( );
+ USE_PSA_INIT();
- if( strcmp( cn_name_str, "NULL" ) != 0 )
+ if (strcmp(cn_name_str, "NULL") != 0) {
cn_name = cn_name_str;
+ }
- if( strcmp( profile_str, "" ) == 0 )
+ if (strcmp(profile_str, "") == 0) {
profile = &mbedtls_x509_crt_profile_default;
- else if( strcmp( profile_str, "next" ) == 0 )
+ } else if (strcmp(profile_str, "next") == 0) {
profile = &mbedtls_x509_crt_profile_next;
- else if( strcmp( profile_str, "suite_b" ) == 0 )
+ } else if (strcmp(profile_str, "suite_b") == 0) {
profile = &mbedtls_x509_crt_profile_suiteb;
- else if( strcmp( profile_str, "compat" ) == 0 )
+ } else if (strcmp(profile_str, "compat") == 0) {
profile = &compat_profile;
- else if( strcmp( profile_str, "all" ) == 0 )
+ } else if (strcmp(profile_str, "all") == 0) {
profile = &profile_all;
- else
- TEST_ASSERT( "Unknown algorithm profile" == 0 );
+ } else {
+ TEST_ASSERT("Unknown algorithm profile" == 0);
+ }
- if( strcmp( verify_callback, "NULL" ) == 0 )
+ if (strcmp(verify_callback, "NULL") == 0) {
f_vrfy = NULL;
- else if( strcmp( verify_callback, "verify_none" ) == 0 )
+ } else if (strcmp(verify_callback, "verify_none") == 0) {
f_vrfy = verify_none;
- else if( strcmp( verify_callback, "verify_all" ) == 0 )
+ } else if (strcmp(verify_callback, "verify_all") == 0) {
f_vrfy = verify_all;
- else
- TEST_ASSERT( "No known verify callback selected" == 0 );
+ } else {
+ TEST_ASSERT("No known verify callback selected" == 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_crl_parse_file( &crl, crl_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_crl_parse_file(&crl, crl_file) == 0);
- res = mbedtls_x509_crt_verify_with_profile( &crt, &ca, &crl, profile, cn_name, &flags, f_vrfy, NULL );
+ res = mbedtls_x509_crt_verify_with_profile(&crt,
+ &ca,
+ &crl,
+ profile,
+ cn_name,
+ &flags,
+ f_vrfy,
+ NULL);
- TEST_ASSERT( res == ( result ) );
- TEST_ASSERT( flags == (uint32_t)( flags_result ) );
+ TEST_ASSERT(res == (result));
+ TEST_ASSERT(flags == (uint32_t) (flags_result));
#if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
/* CRLs aren't supported with CA callbacks, so skip the CA callback
* version of the test if CRLs are in use. */
- if( crl_file == NULL || strcmp( crl_file, "" ) == 0 )
- {
+ if (crl_file == NULL || strcmp(crl_file, "") == 0) {
flags = 0;
- res = mbedtls_x509_crt_verify_with_ca_cb( &crt, ca_callback, &ca, profile, cn_name, &flags, f_vrfy, NULL );
+ res = mbedtls_x509_crt_verify_with_ca_cb(&crt,
+ ca_callback,
+ &ca,
+ profile,
+ cn_name,
+ &flags,
+ f_vrfy,
+ NULL);
- TEST_ASSERT( res == ( result ) );
- TEST_ASSERT( flags == (uint32_t)( flags_result ) );
+ TEST_ASSERT(res == (result));
+ TEST_ASSERT(flags == (uint32_t) (flags_result));
}
#endif /* MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
exit:
- mbedtls_x509_crt_free( &crt );
- mbedtls_x509_crt_free( &ca );
- mbedtls_x509_crl_free( &crl );
- USE_PSA_DONE( );
+ mbedtls_x509_crt_free(&crt);
+ mbedtls_x509_crt_free(&ca);
+ mbedtls_x509_crl_free(&crl);
+ USE_PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_X509_CRL_PARSE_C:MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK */
-void x509_verify_ca_cb_failure( char *crt_file, char *ca_file, char *name,
- int exp_ret )
+void x509_verify_ca_cb_failure(char *crt_file, char *ca_file, char *name,
+ int exp_ret)
{
int ret;
mbedtls_x509_crt crt;
mbedtls_x509_crt ca;
uint32_t flags = 0;
- mbedtls_x509_crt_init( &crt );
- mbedtls_x509_crt_init( &ca );
+ mbedtls_x509_crt_init(&crt);
+ mbedtls_x509_crt_init(&ca);
- 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(&crt, crt_file) == 0);
+ TEST_ASSERT(mbedtls_x509_crt_parse_file(&ca, ca_file) == 0);
- if( strcmp( name, "NULL" ) == 0 )
+ if (strcmp(name, "NULL") == 0) {
name = NULL;
+ }
- ret = mbedtls_x509_crt_verify_with_ca_cb( &crt, ca_callback_fail, &ca,
- &compat_profile, name, &flags,
- NULL, NULL );
+ ret = mbedtls_x509_crt_verify_with_ca_cb(&crt, ca_callback_fail, &ca,
+ &compat_profile, name, &flags,
+ NULL, NULL);
- TEST_ASSERT( ret == exp_ret );
- TEST_ASSERT( flags == (uint32_t)( -1 ) );
+ TEST_ASSERT(ret == exp_ret);
+ TEST_ASSERT(flags == (uint32_t) (-1));
exit:
- mbedtls_x509_crt_free( &crt );
- mbedtls_x509_crt_free( &ca );
+ mbedtls_x509_crt_free(&crt);
+ mbedtls_x509_crt_free(&ca);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C */
-void x509_verify_callback( char *crt_file, char *ca_file, char *name,
- int exp_ret, char *exp_vrfy_out )
+void x509_verify_callback(char *crt_file, char *ca_file, char *name,
+ int exp_ret, char *exp_vrfy_out)
{
int ret;
mbedtls_x509_crt crt;
@@ -707,94 +725,96 @@
uint32_t flags = 0;
verify_print_context vrfy_ctx;
- mbedtls_x509_crt_init( &crt );
- mbedtls_x509_crt_init( &ca );
- verify_print_init( &vrfy_ctx );
+ mbedtls_x509_crt_init(&crt);
+ mbedtls_x509_crt_init(&ca);
+ verify_print_init(&vrfy_ctx);
- USE_PSA_INIT( );
+ USE_PSA_INIT();
- 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(&crt, crt_file) == 0);
+ TEST_ASSERT(mbedtls_x509_crt_parse_file(&ca, ca_file) == 0);
- if( strcmp( name, "NULL" ) == 0 )
+ if (strcmp(name, "NULL") == 0) {
name = NULL;
+ }
- ret = mbedtls_x509_crt_verify_with_profile( &crt, &ca, NULL,
- &compat_profile,
- name, &flags,
- verify_print, &vrfy_ctx );
+ ret = mbedtls_x509_crt_verify_with_profile(&crt, &ca, NULL,
+ &compat_profile,
+ name, &flags,
+ verify_print, &vrfy_ctx);
- TEST_ASSERT( ret == exp_ret );
- TEST_ASSERT( strcmp( vrfy_ctx.buf, exp_vrfy_out ) == 0 );
+ TEST_ASSERT(ret == exp_ret);
+ TEST_ASSERT(strcmp(vrfy_ctx.buf, exp_vrfy_out) == 0);
exit:
- mbedtls_x509_crt_free( &crt );
- mbedtls_x509_crt_free( &ca );
- USE_PSA_DONE( );
+ mbedtls_x509_crt_free(&crt);
+ mbedtls_x509_crt_free(&ca);
+ USE_PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C */
-void mbedtls_x509_dn_gets( char * crt_file, char * entity, char * result_str )
+void mbedtls_x509_dn_gets(char *crt_file, char *entity, char *result_str)
{
mbedtls_x509_crt crt;
char buf[2000];
int res = 0;
- mbedtls_x509_crt_init( &crt );
- memset( buf, 0, 2000 );
+ mbedtls_x509_crt_init(&crt);
+ memset(buf, 0, 2000);
- TEST_ASSERT( mbedtls_x509_crt_parse_file( &crt, crt_file ) == 0 );
- if( strcmp( entity, "subject" ) == 0 )
- res = mbedtls_x509_dn_gets( buf, 2000, &crt.subject );
- else if( strcmp( entity, "issuer" ) == 0 )
- res = mbedtls_x509_dn_gets( buf, 2000, &crt.issuer );
- else
- TEST_ASSERT( "Unknown entity" == 0 );
+ TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
+ if (strcmp(entity, "subject") == 0) {
+ res = mbedtls_x509_dn_gets(buf, 2000, &crt.subject);
+ } else if (strcmp(entity, "issuer") == 0) {
+ res = mbedtls_x509_dn_gets(buf, 2000, &crt.issuer);
+ } else {
+ TEST_ASSERT("Unknown entity" == 0);
+ }
- TEST_ASSERT( res != -1 );
- TEST_ASSERT( res != -2 );
+ TEST_ASSERT(res != -1);
+ TEST_ASSERT(res != -2);
- TEST_ASSERT( strcmp( buf, result_str ) == 0 );
+ TEST_ASSERT(strcmp(buf, result_str) == 0);
exit:
- mbedtls_x509_crt_free( &crt );
+ mbedtls_x509_crt_free(&crt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C:!MBEDTLS_X509_REMOVE_INFO */
-void mbedtls_x509_dn_gets_subject_replace( char * crt_file, char * new_subject_ou, char * result_str, int ret )
+void mbedtls_x509_dn_gets_subject_replace(char *crt_file,
+ char *new_subject_ou,
+ char *result_str,
+ int ret)
{
mbedtls_x509_crt crt;
char buf[2000];
int res = 0;
- mbedtls_x509_crt_init( &crt );
- memset( buf, 0, 2000 );
+ mbedtls_x509_crt_init(&crt);
+ 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);
crt.subject.next->val.p = (unsigned char *) new_subject_ou;
- crt.subject.next->val.len = strlen( new_subject_ou );
+ crt.subject.next->val.len = strlen(new_subject_ou);
- res = mbedtls_x509_dn_gets( buf, 2000, &crt.subject );
+ res = mbedtls_x509_dn_gets(buf, 2000, &crt.subject);
- if ( ret != 0 )
- {
- TEST_ASSERT( res == ret );
- }
- else
- {
- TEST_ASSERT( res != -1 );
- TEST_ASSERT( res != -2 );
- TEST_ASSERT( strcmp( buf, result_str ) == 0 );
+ if (ret != 0) {
+ TEST_ASSERT(res == ret);
+ } else {
+ TEST_ASSERT(res != -1);
+ TEST_ASSERT(res != -2);
+ TEST_ASSERT(strcmp(buf, result_str) == 0);
}
exit:
- mbedtls_x509_crt_free( &crt );
+ mbedtls_x509_crt_free(&crt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C */
-void mbedtls_x509_get_name( char * rdn_sequence, int exp_ret )
+void mbedtls_x509_get_name(char *rdn_sequence, int exp_ret)
{
unsigned char *name;
unsigned char *p;
@@ -803,160 +823,158 @@
mbedtls_x509_name *allocated, *prev;
int ret;
- memset( &head, 0, sizeof( head ) );
+ memset(&head, 0, sizeof(head));
- name = mbedtls_test_unhexify_alloc( rdn_sequence, &name_len );
+ name = mbedtls_test_unhexify_alloc(rdn_sequence, &name_len);
p = name;
- ret = mbedtls_x509_get_name( &p, ( name + name_len ), &head );
- if( ret == 0 )
- {
+ ret = mbedtls_x509_get_name(&p, (name + name_len), &head);
+ if (ret == 0) {
allocated = head.next;
- while( allocated != NULL )
- {
+ while (allocated != NULL) {
prev = allocated;
allocated = allocated->next;
- mbedtls_free( prev );
+ mbedtls_free(prev);
}
}
- TEST_EQUAL( ret, exp_ret );
+ TEST_EQUAL(ret, exp_ret);
- mbedtls_free( name );
+ mbedtls_free(name);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C */
-void mbedtls_x509_time_is_past( char * crt_file, char * entity, int result )
+void mbedtls_x509_time_is_past(char *crt_file, char *entity, int result)
{
mbedtls_x509_crt crt;
- mbedtls_x509_crt_init( &crt );
+ mbedtls_x509_crt_init(&crt);
- TEST_ASSERT( mbedtls_x509_crt_parse_file( &crt, crt_file ) == 0 );
+ TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
- if( strcmp( entity, "valid_from" ) == 0 )
- TEST_ASSERT( mbedtls_x509_time_is_past( &crt.valid_from ) == result );
- else if( strcmp( entity, "valid_to" ) == 0 )
- TEST_ASSERT( mbedtls_x509_time_is_past( &crt.valid_to ) == result );
- else
- TEST_ASSERT( "Unknown entity" == 0 );
+ if (strcmp(entity, "valid_from") == 0) {
+ TEST_ASSERT(mbedtls_x509_time_is_past(&crt.valid_from) == result);
+ } else if (strcmp(entity, "valid_to") == 0) {
+ TEST_ASSERT(mbedtls_x509_time_is_past(&crt.valid_to) == result);
+ } else {
+ TEST_ASSERT("Unknown entity" == 0);
+ }
exit:
- mbedtls_x509_crt_free( &crt );
+ mbedtls_x509_crt_free(&crt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C */
-void mbedtls_x509_time_is_future( char * crt_file, char * entity, int result )
+void mbedtls_x509_time_is_future(char *crt_file, char *entity, int result)
{
mbedtls_x509_crt crt;
- mbedtls_x509_crt_init( &crt );
+ mbedtls_x509_crt_init(&crt);
- TEST_ASSERT( mbedtls_x509_crt_parse_file( &crt, crt_file ) == 0 );
+ TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == 0);
- if( strcmp( entity, "valid_from" ) == 0 )
- TEST_ASSERT( mbedtls_x509_time_is_future( &crt.valid_from ) == result );
- else if( strcmp( entity, "valid_to" ) == 0 )
- TEST_ASSERT( mbedtls_x509_time_is_future( &crt.valid_to ) == result );
- else
- TEST_ASSERT( "Unknown entity" == 0 );
+ if (strcmp(entity, "valid_from") == 0) {
+ TEST_ASSERT(mbedtls_x509_time_is_future(&crt.valid_from) == result);
+ } else if (strcmp(entity, "valid_to") == 0) {
+ TEST_ASSERT(mbedtls_x509_time_is_future(&crt.valid_to) == result);
+ } else {
+ TEST_ASSERT("Unknown entity" == 0);
+ }
exit:
- mbedtls_x509_crt_free( &crt );
+ mbedtls_x509_crt_free(&crt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_FS_IO */
-void x509parse_crt_file( char * crt_file, int result )
+void x509parse_crt_file(char *crt_file, int result)
{
mbedtls_x509_crt crt;
- mbedtls_x509_crt_init( &crt );
+ mbedtls_x509_crt_init(&crt);
- TEST_ASSERT( mbedtls_x509_crt_parse_file( &crt, crt_file ) == result );
+ TEST_ASSERT(mbedtls_x509_crt_parse_file(&crt, crt_file) == result);
exit:
- mbedtls_x509_crt_free( &crt );
+ mbedtls_x509_crt_free(&crt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C */
-void x509parse_crt( data_t * buf, char * result_str, int result )
+void x509parse_crt(data_t *buf, char *result_str, int result)
{
mbedtls_x509_crt crt;
unsigned char output[2000];
int res;
- mbedtls_x509_crt_init( &crt );
- memset( output, 0, 2000 );
+ mbedtls_x509_crt_init(&crt);
+ memset(output, 0, 2000);
- TEST_ASSERT( mbedtls_x509_crt_parse_der( &crt, buf->x, buf->len ) == ( result ) );
- if( ( result ) == 0 )
- {
- res = mbedtls_x509_crt_info( (char *) output, 2000, "", &crt );
+ TEST_ASSERT(mbedtls_x509_crt_parse_der(&crt, buf->x, buf->len) == (result));
+ if ((result) == 0) {
+ res = mbedtls_x509_crt_info((char *) output, 2000, "", &crt);
- TEST_ASSERT( res != -1 );
- TEST_ASSERT( res != -2 );
+ TEST_ASSERT(res != -1);
+ TEST_ASSERT(res != -2);
- TEST_ASSERT( strcmp( (char *) output, result_str ) == 0 );
+ TEST_ASSERT(strcmp((char *) output, result_str) == 0);
}
- mbedtls_x509_crt_free( &crt );
- mbedtls_x509_crt_init( &crt );
- memset( output, 0, 2000 );
+ mbedtls_x509_crt_free(&crt);
+ mbedtls_x509_crt_init(&crt);
+ memset(output, 0, 2000);
- TEST_ASSERT( mbedtls_x509_crt_parse_der_nocopy( &crt, buf->x, buf->len ) == ( result ) );
- if( ( result ) == 0 )
- {
- res = mbedtls_x509_crt_info( (char *) output, 2000, "", &crt );
+ TEST_ASSERT(mbedtls_x509_crt_parse_der_nocopy(&crt, buf->x, buf->len) == (result));
+ if ((result) == 0) {
+ res = mbedtls_x509_crt_info((char *) output, 2000, "", &crt);
- TEST_ASSERT( res != -1 );
- TEST_ASSERT( res != -2 );
+ TEST_ASSERT(res != -1);
+ TEST_ASSERT(res != -2);
- TEST_ASSERT( strcmp( (char *) output, result_str ) == 0 );
+ TEST_ASSERT(strcmp((char *) output, result_str) == 0);
}
- mbedtls_x509_crt_free( &crt );
- mbedtls_x509_crt_init( &crt );
- memset( output, 0, 2000 );
+ mbedtls_x509_crt_free(&crt);
+ mbedtls_x509_crt_init(&crt);
+ memset(output, 0, 2000);
- TEST_ASSERT( mbedtls_x509_crt_parse_der_with_ext_cb( &crt, buf->x, buf->len, 0, NULL, NULL ) == ( result ) );
- if( ( result ) == 0 )
- {
- res = mbedtls_x509_crt_info( (char *) output, 2000, "", &crt );
+ TEST_ASSERT(mbedtls_x509_crt_parse_der_with_ext_cb(&crt, buf->x, buf->len, 0, NULL,
+ NULL) == (result));
+ if ((result) == 0) {
+ res = mbedtls_x509_crt_info((char *) output, 2000, "", &crt);
- TEST_ASSERT( res != -1 );
- TEST_ASSERT( res != -2 );
+ TEST_ASSERT(res != -1);
+ TEST_ASSERT(res != -2);
- TEST_ASSERT( strcmp( (char *) output, result_str ) == 0 );
+ TEST_ASSERT(strcmp((char *) output, result_str) == 0);
}
- mbedtls_x509_crt_free( &crt );
- mbedtls_x509_crt_init( &crt );
- memset( output, 0, 2000 );
+ mbedtls_x509_crt_free(&crt);
+ mbedtls_x509_crt_init(&crt);
+ memset(output, 0, 2000);
- TEST_ASSERT( mbedtls_x509_crt_parse_der_with_ext_cb( &crt, buf->x, buf->len, 1, NULL, NULL ) == ( result ) );
- if( ( result ) == 0 )
- {
- res = mbedtls_x509_crt_info( (char *) output, 2000, "", &crt );
+ TEST_ASSERT(mbedtls_x509_crt_parse_der_with_ext_cb(&crt, buf->x, buf->len, 1, NULL,
+ NULL) == (result));
+ if ((result) == 0) {
+ res = mbedtls_x509_crt_info((char *) output, 2000, "", &crt);
- TEST_ASSERT( res != -1 );
- TEST_ASSERT( res != -2 );
+ TEST_ASSERT(res != -1);
+ TEST_ASSERT(res != -2);
- TEST_ASSERT( strcmp( (char *) output, result_str ) == 0 );
+ TEST_ASSERT(strcmp((char *) output, result_str) == 0);
}
exit:
- mbedtls_x509_crt_free( &crt );
+ mbedtls_x509_crt_free(&crt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C */
-void x509parse_crt_cb( data_t * buf, char * result_str, int result )
+void x509parse_crt_cb(data_t *buf, char *result_str, int result)
{
mbedtls_x509_crt crt;
mbedtls_x509_buf oid;
@@ -965,119 +983,119 @@
oid.tag = MBEDTLS_ASN1_OID;
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 );
- memset( output, 0, 2000 );
+ mbedtls_x509_crt_init(&crt);
+ memset(output, 0, 2000);
- TEST_ASSERT( mbedtls_x509_crt_parse_der_with_ext_cb( &crt, buf->x, buf->len, 0, parse_crt_ext_cb, &oid ) == ( result ) );
- if( ( result ) == 0 )
- {
- res = mbedtls_x509_crt_info( (char *) output, 2000, "", &crt );
+ TEST_ASSERT(mbedtls_x509_crt_parse_der_with_ext_cb(&crt, buf->x, buf->len, 0, parse_crt_ext_cb,
+ &oid) == (result));
+ if ((result) == 0) {
+ res = mbedtls_x509_crt_info((char *) output, 2000, "", &crt);
- TEST_ASSERT( res != -1 );
- TEST_ASSERT( res != -2 );
+ TEST_ASSERT(res != -1);
+ TEST_ASSERT(res != -2);
- TEST_ASSERT( strcmp( (char *) output, result_str ) == 0 );
+ TEST_ASSERT(strcmp((char *) output, result_str) == 0);
}
- mbedtls_x509_crt_free( &crt );
- mbedtls_x509_crt_init( &crt );
- memset( output, 0, 2000 );
+ mbedtls_x509_crt_free(&crt);
+ mbedtls_x509_crt_init(&crt);
+ memset(output, 0, 2000);
- TEST_ASSERT( mbedtls_x509_crt_parse_der_with_ext_cb( &crt, buf->x, buf->len, 1, parse_crt_ext_cb, &oid ) == ( result ) );
- if( ( result ) == 0 )
- {
- res = mbedtls_x509_crt_info( (char *) output, 2000, "", &crt );
+ TEST_ASSERT(mbedtls_x509_crt_parse_der_with_ext_cb(&crt, buf->x, buf->len, 1, parse_crt_ext_cb,
+ &oid) == (result));
+ if ((result) == 0) {
+ res = mbedtls_x509_crt_info((char *) output, 2000, "", &crt);
- TEST_ASSERT( res != -1 );
- TEST_ASSERT( res != -2 );
+ TEST_ASSERT(res != -1);
+ TEST_ASSERT(res != -2);
- TEST_ASSERT( strcmp( (char *) output, result_str ) == 0 );
+ TEST_ASSERT(strcmp((char *) output, result_str) == 0);
}
exit:
- mbedtls_x509_crt_free( &crt );
+ mbedtls_x509_crt_free(&crt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_X509_CRL_PARSE_C */
-void x509parse_crl( data_t * buf, char * result_str, int result )
+void x509parse_crl(data_t *buf, char *result_str, int result)
{
mbedtls_x509_crl crl;
unsigned char output[2000];
int res;
- mbedtls_x509_crl_init( &crl );
- memset( output, 0, 2000 );
+ mbedtls_x509_crl_init(&crl);
+ memset(output, 0, 2000);
- TEST_ASSERT( mbedtls_x509_crl_parse( &crl, buf->x, buf->len ) == ( result ) );
- if( ( result ) == 0 )
- {
- res = mbedtls_x509_crl_info( (char *) output, 2000, "", &crl );
+ TEST_ASSERT(mbedtls_x509_crl_parse(&crl, buf->x, buf->len) == (result));
+ if ((result) == 0) {
+ res = mbedtls_x509_crl_info((char *) output, 2000, "", &crl);
- TEST_ASSERT( res != -1 );
- TEST_ASSERT( res != -2 );
+ TEST_ASSERT(res != -1);
+ TEST_ASSERT(res != -2);
- TEST_ASSERT( strcmp( (char *) output, result_str ) == 0 );
+ TEST_ASSERT(strcmp((char *) output, result_str) == 0);
}
exit:
- mbedtls_x509_crl_free( &crl );
+ mbedtls_x509_crl_free(&crl);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_X509_CSR_PARSE_C */
-void mbedtls_x509_csr_parse( data_t * csr_der, char * ref_out, int ref_ret )
+void mbedtls_x509_csr_parse(data_t *csr_der, char *ref_out, int ref_ret)
{
mbedtls_x509_csr csr;
char my_out[1000];
int my_ret;
- mbedtls_x509_csr_init( &csr );
- memset( my_out, 0, sizeof( my_out ) );
+ mbedtls_x509_csr_init(&csr);
+ memset(my_out, 0, sizeof(my_out));
- my_ret = mbedtls_x509_csr_parse_der( &csr, csr_der->x, csr_der->len );
- TEST_ASSERT( my_ret == ref_ret );
+ my_ret = mbedtls_x509_csr_parse_der(&csr, csr_der->x, csr_der->len);
+ TEST_ASSERT(my_ret == ref_ret);
- if( ref_ret == 0 )
- {
- size_t my_out_len = mbedtls_x509_csr_info( my_out, sizeof( my_out ), "", &csr );
- TEST_ASSERT( my_out_len == strlen( ref_out ) );
- TEST_ASSERT( strcmp( my_out, ref_out ) == 0 );
+ if (ref_ret == 0) {
+ size_t my_out_len = mbedtls_x509_csr_info(my_out, sizeof(my_out), "", &csr);
+ TEST_ASSERT(my_out_len == strlen(ref_out));
+ TEST_ASSERT(strcmp(my_out, ref_out) == 0);
}
exit:
- mbedtls_x509_csr_free( &csr );
+ mbedtls_x509_csr_free(&csr);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C */
-void mbedtls_x509_crt_parse_path( char * crt_path, int ret, int nb_crt )
+void mbedtls_x509_crt_parse_path(char *crt_path, int ret, int nb_crt)
{
mbedtls_x509_crt chain, *cur;
int i;
- mbedtls_x509_crt_init( &chain );
+ mbedtls_x509_crt_init(&chain);
- TEST_ASSERT( mbedtls_x509_crt_parse_path( &chain, crt_path ) == ret );
+ TEST_ASSERT(mbedtls_x509_crt_parse_path(&chain, crt_path) == ret);
/* Check how many certs we got */
- for( i = 0, cur = &chain; cur != NULL; cur = cur->next )
- if( cur->raw.p != NULL )
+ for (i = 0, cur = &chain; cur != NULL; cur = cur->next) {
+ if (cur->raw.p != NULL) {
i++;
+ }
+ }
- TEST_ASSERT( i == nb_crt );
+ TEST_ASSERT(i == nb_crt);
exit:
- mbedtls_x509_crt_free( &chain );
+ mbedtls_x509_crt_free(&chain);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C */
-void mbedtls_x509_crt_verify_max( char *ca_file, char *chain_dir, int nb_int,
- int ret_chk, int flags_chk )
+void mbedtls_x509_crt_verify_max(char *ca_file, char *chain_dir, int nb_int,
+ int ret_chk, int flags_chk)
{
char file_buf[128];
int ret;
@@ -1089,80 +1107,82 @@
* with NN.crt signed by NN-1.crt
*/
- mbedtls_x509_crt_init( &trusted );
- mbedtls_x509_crt_init( &chain );
+ mbedtls_x509_crt_init(&trusted);
+ mbedtls_x509_crt_init(&chain);
- USE_PSA_INIT( );
+ USE_PSA_INIT();
/* 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);
/* Load a chain with nb_int intermediates (from 01 to nb_int),
* plus one "end-entity" cert (nb_int + 1) */
- ret = mbedtls_snprintf( file_buf, sizeof file_buf, "%s/c%02d.pem", chain_dir,
- nb_int + 1 );
- TEST_ASSERT( ret > 0 && (size_t) ret < sizeof file_buf );
- TEST_ASSERT( mbedtls_x509_crt_parse_file( &chain, file_buf ) == 0 );
+ ret = mbedtls_snprintf(file_buf, sizeof file_buf, "%s/c%02d.pem", chain_dir,
+ nb_int + 1);
+ TEST_ASSERT(ret > 0 && (size_t) ret < sizeof file_buf);
+ TEST_ASSERT(mbedtls_x509_crt_parse_file(&chain, file_buf) == 0);
/* Try to verify that chain */
- ret = mbedtls_x509_crt_verify( &chain, &trusted, NULL, NULL, &flags,
- NULL, NULL );
- TEST_ASSERT( ret == ret_chk );
- TEST_ASSERT( flags == (uint32_t) flags_chk );
+ ret = mbedtls_x509_crt_verify(&chain, &trusted, NULL, NULL, &flags,
+ NULL, NULL);
+ TEST_ASSERT(ret == ret_chk);
+ TEST_ASSERT(flags == (uint32_t) flags_chk);
exit:
- mbedtls_x509_crt_free( &chain );
- mbedtls_x509_crt_free( &trusted );
- USE_PSA_DONE( );
+ mbedtls_x509_crt_free(&chain);
+ mbedtls_x509_crt_free(&trusted);
+ USE_PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C */
-void mbedtls_x509_crt_verify_chain( char *chain_paths, char *trusted_ca,
- int flags_result, int result,
- char *profile_name, int vrfy_fatal_lvls )
+void mbedtls_x509_crt_verify_chain(char *chain_paths, char *trusted_ca,
+ int flags_result, int result,
+ char *profile_name, int vrfy_fatal_lvls)
{
- char* act;
+ char *act;
uint32_t flags;
int res;
mbedtls_x509_crt trusted, chain;
const mbedtls_x509_crt_profile *profile = NULL;
- mbedtls_x509_crt_init( &chain );
- mbedtls_x509_crt_init( &trusted );
+ mbedtls_x509_crt_init(&chain);
+ mbedtls_x509_crt_init(&trusted);
- USE_PSA_INIT( );
+ USE_PSA_INIT();
- while( ( act = mystrsep( &chain_paths, " " ) ) != NULL )
- TEST_ASSERT( mbedtls_x509_crt_parse_file( &chain, act ) == 0 );
- TEST_ASSERT( mbedtls_x509_crt_parse_file( &trusted, trusted_ca ) == 0 );
+ while ((act = mystrsep(&chain_paths, " ")) != NULL) {
+ TEST_ASSERT(mbedtls_x509_crt_parse_file(&chain, act) == 0);
+ }
+ TEST_ASSERT(mbedtls_x509_crt_parse_file(&trusted, trusted_ca) == 0);
- if( strcmp( profile_name, "" ) == 0 )
+ if (strcmp(profile_name, "") == 0) {
profile = &mbedtls_x509_crt_profile_default;
- else if( strcmp( profile_name, "next" ) == 0 )
+ } else if (strcmp(profile_name, "next") == 0) {
profile = &mbedtls_x509_crt_profile_next;
- else if( strcmp( profile_name, "suiteb" ) == 0 )
+ } else if (strcmp(profile_name, "suiteb") == 0) {
profile = &mbedtls_x509_crt_profile_suiteb;
- else if( strcmp( profile_name, "rsa3072" ) == 0 )
+ } else if (strcmp(profile_name, "rsa3072") == 0) {
profile = &profile_rsa3072;
- else if( strcmp( profile_name, "sha512" ) == 0 )
+ } else if (strcmp(profile_name, "sha512") == 0) {
profile = &profile_sha512;
+ }
- res = mbedtls_x509_crt_verify_with_profile( &chain, &trusted, NULL, profile,
- NULL, &flags, verify_fatal, &vrfy_fatal_lvls );
+ res = mbedtls_x509_crt_verify_with_profile(&chain, &trusted, NULL, profile,
+ NULL, &flags, verify_fatal, &vrfy_fatal_lvls);
- TEST_ASSERT( res == ( result ) );
- TEST_ASSERT( flags == (uint32_t)( flags_result ) );
+ TEST_ASSERT(res == (result));
+ TEST_ASSERT(flags == (uint32_t) (flags_result));
exit:
- mbedtls_x509_crt_free( &trusted );
- mbedtls_x509_crt_free( &chain );
- USE_PSA_DONE( );
+ mbedtls_x509_crt_free(&trusted);
+ mbedtls_x509_crt_free(&chain);
+ USE_PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_X509_USE_C */
-void x509_oid_desc( data_t * buf, char * ref_desc )
+void x509_oid_desc(data_t *buf, char *ref_desc)
{
mbedtls_x509_buf oid;
const char *desc = NULL;
@@ -1173,114 +1193,110 @@
oid.p = buf->x;
oid.len = buf->len;
- ret = mbedtls_oid_get_extended_key_usage( &oid, &desc );
+ ret = mbedtls_oid_get_extended_key_usage(&oid, &desc);
- if( strcmp( ref_desc, "notfound" ) == 0 )
- {
- TEST_ASSERT( ret != 0 );
- TEST_ASSERT( desc == NULL );
- }
- else
- {
- TEST_ASSERT( ret == 0 );
- TEST_ASSERT( desc != NULL );
- TEST_ASSERT( strcmp( desc, ref_desc ) == 0 );
+ if (strcmp(ref_desc, "notfound") == 0) {
+ TEST_ASSERT(ret != 0);
+ TEST_ASSERT(desc == NULL);
+ } else {
+ TEST_ASSERT(ret == 0);
+ TEST_ASSERT(desc != NULL);
+ TEST_ASSERT(strcmp(desc, ref_desc) == 0);
}
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_X509_USE_C */
-void x509_oid_numstr( data_t * oid_buf, char * numstr, int blen, int ret )
+void x509_oid_numstr(data_t *oid_buf, char *numstr, int blen, int ret)
{
mbedtls_x509_buf oid;
char num_buf[100];
- memset( num_buf, 0x2a, sizeof num_buf );
+ memset(num_buf, 0x2a, sizeof num_buf);
oid.tag = MBEDTLS_ASN1_OID;
oid.p = oid_buf->x;
oid.len = oid_buf->len;
- TEST_ASSERT( (size_t) blen <= sizeof num_buf );
+ TEST_ASSERT((size_t) blen <= sizeof num_buf);
- TEST_ASSERT( mbedtls_oid_get_numeric_string( num_buf, blen, &oid ) == ret );
+ TEST_ASSERT(mbedtls_oid_get_numeric_string(num_buf, blen, &oid) == ret);
- if( ret >= 0 )
- {
- TEST_ASSERT( num_buf[ret] == 0 );
- TEST_ASSERT( strcmp( num_buf, numstr ) == 0 );
+ if (ret >= 0) {
+ TEST_ASSERT(num_buf[ret] == 0);
+ TEST_ASSERT(strcmp(num_buf, numstr) == 0);
}
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_X509_CHECK_KEY_USAGE */
-void x509_check_key_usage( char * crt_file, int usage, int ret )
+void x509_check_key_usage(char *crt_file, int usage, int ret)
{
mbedtls_x509_crt crt;
- mbedtls_x509_crt_init( &crt );
+ mbedtls_x509_crt_init(&crt);
- 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_check_key_usage( &crt, usage ) == ret );
+ TEST_ASSERT(mbedtls_x509_crt_check_key_usage(&crt, usage) == ret);
exit:
- mbedtls_x509_crt_free( &crt );
+ mbedtls_x509_crt_free(&crt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_FS_IO:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE */
-void x509_check_extended_key_usage( char * crt_file, data_t * oid, int ret
- )
+void x509_check_extended_key_usage(char *crt_file, data_t *oid, int ret
+ )
{
mbedtls_x509_crt crt;
- mbedtls_x509_crt_init( &crt );
+ mbedtls_x509_crt_init(&crt);
- 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_check_extended_key_usage( &crt, (const char *)oid->x, oid->len ) == ret );
+ TEST_ASSERT(mbedtls_x509_crt_check_extended_key_usage(&crt, (const char *) oid->x,
+ oid->len) == ret);
exit:
- mbedtls_x509_crt_free( &crt );
+ mbedtls_x509_crt_free(&crt);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_X509_USE_C */
-void x509_get_time( int tag, char * time_str, int ret, int year, int mon,
- int day, int hour, int min, int sec )
+void x509_get_time(int tag, char *time_str, int ret, int year, int mon,
+ int day, int hour, int min, int sec)
{
mbedtls_x509_time time;
unsigned char buf[21];
- unsigned char* start = buf;
- unsigned char* end = buf;
+ unsigned char *start = buf;
+ unsigned char *end = buf;
- memset( &time, 0x00, sizeof( time ) );
- *end = (unsigned char)tag; end++;
- *end = strlen( time_str );
- TEST_ASSERT( *end < 20 );
+ memset(&time, 0x00, sizeof(time));
+ *end = (unsigned char) tag; end++;
+ *end = strlen(time_str);
+ TEST_ASSERT(*end < 20);
end++;
- memcpy( end, time_str, (size_t)*(end - 1) );
+ memcpy(end, time_str, (size_t) *(end - 1));
end += *(end - 1);
- TEST_ASSERT( mbedtls_x509_get_time( &start, end, &time ) == ret );
- if( ret == 0 )
- {
- TEST_ASSERT( year == time.year );
- TEST_ASSERT( mon == time.mon );
- TEST_ASSERT( day == time.day );
- TEST_ASSERT( hour == time.hour );
- TEST_ASSERT( min == time.min );
- TEST_ASSERT( sec == time.sec );
+ TEST_ASSERT(mbedtls_x509_get_time(&start, end, &time) == ret);
+ if (ret == 0) {
+ TEST_ASSERT(year == time.year);
+ TEST_ASSERT(mon == time.mon);
+ TEST_ASSERT(day == time.day);
+ TEST_ASSERT(hour == time.hour);
+ TEST_ASSERT(min == time.min);
+ TEST_ASSERT(sec == time.sec);
}
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_X509_RSASSA_PSS_SUPPORT */
-void x509_parse_rsassa_pss_params( data_t * params, int params_tag,
- int ref_msg_md, int ref_mgf_md,
- int ref_salt_len, int ref_ret )
+void x509_parse_rsassa_pss_params(data_t *params, int params_tag,
+ int ref_msg_md, int ref_mgf_md,
+ int ref_salt_len, int ref_ret)
{
int my_ret;
mbedtls_x509_buf buf;
@@ -1291,16 +1307,15 @@
buf.len = params->len;
buf.tag = params_tag;
- my_ret = mbedtls_x509_get_rsassa_pss_params( &buf, &my_msg_md, &my_mgf_md,
- &my_salt_len );
+ my_ret = mbedtls_x509_get_rsassa_pss_params(&buf, &my_msg_md, &my_mgf_md,
+ &my_salt_len);
- TEST_ASSERT( my_ret == ref_ret );
+ TEST_ASSERT(my_ret == ref_ret);
- if( ref_ret == 0 )
- {
- TEST_ASSERT( my_msg_md == (mbedtls_md_type_t) ref_msg_md );
- TEST_ASSERT( my_mgf_md == (mbedtls_md_type_t) ref_mgf_md );
- TEST_ASSERT( my_salt_len == ref_salt_len );
+ if (ref_ret == 0) {
+ TEST_ASSERT(my_msg_md == (mbedtls_md_type_t) ref_msg_md);
+ TEST_ASSERT(my_mgf_md == (mbedtls_md_type_t) ref_mgf_md);
+ TEST_ASSERT(my_salt_len == ref_salt_len);
}
exit:
@@ -1309,8 +1324,8 @@
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_SELF_TEST */
-void x509_selftest( )
+void x509_selftest()
{
- TEST_ASSERT( mbedtls_x509_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_x509_self_test(1) == 0);
}
/* END_CASE */
diff --git a/tests/suites/test_suite_x509write.function b/tests/suites/test_suite_x509write.function
index b27a252..84da143 100644
--- a/tests/suites/test_suite_x509write.function
+++ b/tests/suites/test_suite_x509write.function
@@ -8,64 +8,61 @@
#include "mbedtls/asn1write.h"
#if defined(MBEDTLS_RSA_C)
-int mbedtls_rsa_decrypt_func( void *ctx, int mode, size_t *olen,
- const unsigned char *input, unsigned char *output,
- size_t output_max_len )
+int mbedtls_rsa_decrypt_func(void *ctx, int mode, size_t *olen,
+ const unsigned char *input, unsigned char *output,
+ size_t output_max_len)
{
- return( mbedtls_rsa_pkcs1_decrypt( (mbedtls_rsa_context *) ctx, NULL, NULL, mode, olen,
- input, output, output_max_len ) );
+ return mbedtls_rsa_pkcs1_decrypt((mbedtls_rsa_context *) ctx, NULL, NULL, mode, olen,
+ input, output, output_max_len);
}
-int mbedtls_rsa_sign_func( void *ctx,
- int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
- int mode, mbedtls_md_type_t md_alg, unsigned int hashlen,
- const unsigned char *hash, unsigned char *sig )
+int mbedtls_rsa_sign_func(void *ctx,
+ int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
+ int mode, mbedtls_md_type_t md_alg, unsigned int hashlen,
+ const unsigned char *hash, unsigned char *sig)
{
- return( mbedtls_rsa_pkcs1_sign( (mbedtls_rsa_context *) ctx, f_rng, p_rng, mode,
- md_alg, hashlen, hash, sig ) );
+ return mbedtls_rsa_pkcs1_sign((mbedtls_rsa_context *) ctx, f_rng, p_rng, mode,
+ md_alg, hashlen, hash, sig);
}
-size_t mbedtls_rsa_key_len_func( void *ctx )
+size_t mbedtls_rsa_key_len_func(void *ctx)
{
- return( ((const mbedtls_rsa_context *) ctx)->len );
+ return ((const mbedtls_rsa_context *) ctx)->len;
}
#endif /* MBEDTLS_RSA_C */
#if defined(MBEDTLS_USE_PSA_CRYPTO) && \
defined(MBEDTLS_PEM_WRITE_C) && defined(MBEDTLS_X509_CSR_WRITE_C)
-static int x509_crt_verifycsr( const unsigned char *buf, size_t buflen )
+static int x509_crt_verifycsr(const unsigned char *buf, size_t buflen)
{
unsigned char hash[MBEDTLS_MD_MAX_SIZE];
const mbedtls_md_info_t *md_info;
mbedtls_x509_csr csr;
int ret = 0;
- mbedtls_x509_csr_init( &csr );
+ mbedtls_x509_csr_init(&csr);
- if( mbedtls_x509_csr_parse( &csr, buf, buflen ) != 0 )
- {
+ if (mbedtls_x509_csr_parse(&csr, buf, buflen) != 0) {
ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA;
goto cleanup;
}
- md_info = mbedtls_md_info_from_type( csr.sig_md );
- if( mbedtls_md( md_info, csr.cri.p, csr.cri.len, hash ) != 0 )
- {
+ md_info = mbedtls_md_info_from_type(csr.sig_md);
+ if (mbedtls_md(md_info, csr.cri.p, csr.cri.len, hash) != 0) {
/* Note: this can't happen except after an internal error */
ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA;
goto cleanup;
}
- if( mbedtls_pk_verify_ext( csr.sig_pk, csr.sig_opts, &csr.pk,
- csr.sig_md, hash, mbedtls_md_get_size( md_info ),
- csr.sig.p, csr.sig.len ) != 0 )
- {
+ if (mbedtls_pk_verify_ext(csr.sig_pk, csr.sig_opts, &csr.pk,
+ csr.sig_md, hash, mbedtls_md_get_size(md_info),
+ csr.sig.p, csr.sig.len) != 0) {
ret = MBEDTLS_ERR_X509_CERT_VERIFY_FAILED;
goto cleanup;
}
cleanup:
- mbedtls_x509_csr_free( &csr );
- return( ret );
+ mbedtls_x509_csr_free(&csr);
+ return ret;
}
#endif /* MBEDTLS_USE_PSA_CRYPTO && MBEDTLS_PEM_WRITE_C && MBEDTLS_X509_CSR_WRITE_C */
@@ -91,11 +88,11 @@
*/
#define EXT_KEY_USAGE_TMP_BUF_MAX_LENGTH 12
-static int csr_set_extended_key_usage( mbedtls_x509write_csr *ctx,
- const char *oid, size_t oid_len )
+static int csr_set_extended_key_usage(mbedtls_x509write_csr *ctx,
+ const char *oid, size_t oid_len)
{
unsigned char buf[EXT_KEY_USAGE_TMP_BUF_MAX_LENGTH] = { 0 };
- unsigned char *p = buf + sizeof( buf );
+ unsigned char *p = buf + sizeof(buf);
int ret;
size_t len = 0;
@@ -103,18 +100,21 @@
* Following functions fail anyway if the temporary buffer is not large,
* but we set an extra check here to emphasize a possible source of errors
*/
- if ( oid_len > EXT_KEY_USAGE_TMP_BUF_MAX_LENGTH )
- {
+ if (oid_len > EXT_KEY_USAGE_TMP_BUF_MAX_LENGTH) {
return MBEDTLS_ERR_X509_BAD_INPUT_DATA;
}
- MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_oid( &p, buf, oid, oid_len ) );
- MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( &p, buf, ret ) );
- MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( &p, buf,
- MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) );
+ MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_oid(&p, buf, oid, oid_len));
+ MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(&p, buf, ret));
+ MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(&p, buf,
+ MBEDTLS_ASN1_CONSTRUCTED |
+ MBEDTLS_ASN1_SEQUENCE));
- ret = mbedtls_x509write_csr_set_extension( ctx, MBEDTLS_OID_EXTENDED_KEY_USAGE,
- MBEDTLS_OID_SIZE( MBEDTLS_OID_EXTENDED_KEY_USAGE ), p, len );
+ ret = mbedtls_x509write_csr_set_extension(ctx,
+ MBEDTLS_OID_EXTENDED_KEY_USAGE,
+ MBEDTLS_OID_SIZE(MBEDTLS_OID_EXTENDED_KEY_USAGE),
+ p,
+ len);
return ret;
}
@@ -127,9 +127,9 @@
*/
/* BEGIN_CASE depends_on:MBEDTLS_PEM_WRITE_C:MBEDTLS_X509_CSR_WRITE_C */
-void x509_csr_check( char * key_file, char * cert_req_check_file, int md_type,
- int key_usage, int set_key_usage, int cert_type,
- int set_cert_type, int set_extension )
+void x509_csr_check(char *key_file, char *cert_req_check_file, int md_type,
+ int key_usage, int set_key_usage, int cert_type,
+ int set_cert_type, int set_extension)
{
mbedtls_pk_context key;
mbedtls_x509write_csr req;
@@ -142,64 +142,67 @@
const char *subject_name = "C=NL,O=PolarSSL,CN=PolarSSL Server 1";
mbedtls_test_rnd_pseudo_info rnd_info;
- 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 );
- TEST_ASSERT( mbedtls_pk_parse_keyfile( &key, key_file, NULL ) == 0 );
+ mbedtls_pk_init(&key);
+ TEST_ASSERT(mbedtls_pk_parse_keyfile(&key, key_file, NULL) == 0);
- mbedtls_x509write_csr_set_md_alg( &req, md_type );
- mbedtls_x509write_csr_set_key( &req, &key );
- TEST_ASSERT( mbedtls_x509write_csr_set_subject_name( &req, subject_name ) == 0 );
- if( set_key_usage != 0 )
- TEST_ASSERT( mbedtls_x509write_csr_set_key_usage( &req, key_usage ) == 0 );
- if( set_cert_type != 0 )
- TEST_ASSERT( mbedtls_x509write_csr_set_ns_cert_type( &req, cert_type ) == 0 );
- if ( set_extension != 0 )
- TEST_ASSERT( csr_set_extended_key_usage( &req, MBEDTLS_OID_SERVER_AUTH,
- MBEDTLS_OID_SIZE( MBEDTLS_OID_SERVER_AUTH ) ) == 0 );
-
- ret = mbedtls_x509write_csr_pem( &req, buf, sizeof( buf ),
- mbedtls_test_rnd_pseudo_rand, &rnd_info );
- TEST_ASSERT( ret == 0 );
-
- pem_len = strlen( (char *) buf );
-
- for( buf_index = pem_len; buf_index < sizeof( buf ); ++buf_index )
- {
- TEST_ASSERT( buf[buf_index] == 0 );
+ mbedtls_x509write_csr_set_md_alg(&req, md_type);
+ mbedtls_x509write_csr_set_key(&req, &key);
+ TEST_ASSERT(mbedtls_x509write_csr_set_subject_name(&req, subject_name) == 0);
+ if (set_key_usage != 0) {
+ TEST_ASSERT(mbedtls_x509write_csr_set_key_usage(&req, key_usage) == 0);
+ }
+ if (set_cert_type != 0) {
+ TEST_ASSERT(mbedtls_x509write_csr_set_ns_cert_type(&req, cert_type) == 0);
+ }
+ if (set_extension != 0) {
+ TEST_ASSERT(csr_set_extended_key_usage(&req, MBEDTLS_OID_SERVER_AUTH,
+ MBEDTLS_OID_SIZE(MBEDTLS_OID_SERVER_AUTH)) == 0);
}
- f = fopen( cert_req_check_file, "r" );
- TEST_ASSERT( f != NULL );
- olen = fread( check_buf, 1, sizeof( check_buf ), f );
- fclose( f );
+ ret = mbedtls_x509write_csr_pem(&req, buf, sizeof(buf),
+ mbedtls_test_rnd_pseudo_rand, &rnd_info);
+ TEST_ASSERT(ret == 0);
- TEST_ASSERT( olen >= pem_len - 1 );
- TEST_ASSERT( memcmp( buf, check_buf, pem_len - 1 ) == 0 );
+ pem_len = strlen((char *) buf);
- der_len = mbedtls_x509write_csr_der( &req, buf, sizeof( buf ),
- mbedtls_test_rnd_pseudo_rand,
- &rnd_info );
- TEST_ASSERT( der_len >= 0 );
+ for (buf_index = pem_len; buf_index < sizeof(buf); ++buf_index) {
+ TEST_ASSERT(buf[buf_index] == 0);
+ }
- if( der_len == 0 )
+ f = fopen(cert_req_check_file, "r");
+ TEST_ASSERT(f != NULL);
+ olen = fread(check_buf, 1, sizeof(check_buf), f);
+ fclose(f);
+
+ TEST_ASSERT(olen >= pem_len - 1);
+ TEST_ASSERT(memcmp(buf, check_buf, pem_len - 1) == 0);
+
+ der_len = mbedtls_x509write_csr_der(&req, buf, sizeof(buf),
+ mbedtls_test_rnd_pseudo_rand,
+ &rnd_info);
+ TEST_ASSERT(der_len >= 0);
+
+ if (der_len == 0) {
goto exit;
+ }
- ret = mbedtls_x509write_csr_der( &req, buf, (size_t)( der_len - 1 ),
- mbedtls_test_rnd_pseudo_rand, &rnd_info );
- TEST_ASSERT( ret == MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
+ ret = mbedtls_x509write_csr_der(&req, buf, (size_t) (der_len - 1),
+ mbedtls_test_rnd_pseudo_rand, &rnd_info);
+ TEST_ASSERT(ret == MBEDTLS_ERR_ASN1_BUF_TOO_SMALL);
exit:
- mbedtls_x509write_csr_free( &req );
- mbedtls_pk_free( &key );
+ mbedtls_x509write_csr_free(&req);
+ mbedtls_pk_free(&key);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PEM_WRITE_C:MBEDTLS_X509_CSR_WRITE_C:MBEDTLS_USE_PSA_CRYPTO */
-void x509_csr_check_opaque( char *key_file, int md_type, int key_usage,
- int cert_type )
+void x509_csr_check_opaque(char *key_file, int md_type, int key_usage,
+ int cert_type)
{
mbedtls_pk_context key;
mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
@@ -211,53 +214,55 @@
const char *subject_name = "C=NL,O=PolarSSL,CN=PolarSSL Server 1";
mbedtls_test_rnd_pseudo_info rnd_info;
- 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);
- USE_PSA_INIT( );
+ USE_PSA_INIT();
- md_alg_psa = mbedtls_psa_translate_md( (mbedtls_md_type_t) md_type );
- TEST_ASSERT( md_alg_psa != MBEDTLS_MD_NONE );
+ md_alg_psa = mbedtls_psa_translate_md((mbedtls_md_type_t) md_type);
+ TEST_ASSERT(md_alg_psa != MBEDTLS_MD_NONE);
- mbedtls_pk_init( &key );
- TEST_ASSERT( mbedtls_pk_parse_keyfile( &key, key_file, NULL ) == 0 );
- TEST_ASSERT( mbedtls_pk_wrap_as_opaque( &key, &key_id, md_alg_psa ) == 0 );
+ mbedtls_pk_init(&key);
+ TEST_ASSERT(mbedtls_pk_parse_keyfile(&key, key_file, NULL) == 0);
+ TEST_ASSERT(mbedtls_pk_wrap_as_opaque(&key, &key_id, md_alg_psa) == 0);
- mbedtls_x509write_csr_set_md_alg( &req, md_type );
- mbedtls_x509write_csr_set_key( &req, &key );
- TEST_ASSERT( mbedtls_x509write_csr_set_subject_name( &req, subject_name ) == 0 );
- if( key_usage != 0 )
- TEST_ASSERT( mbedtls_x509write_csr_set_key_usage( &req, key_usage ) == 0 );
- if( cert_type != 0 )
- TEST_ASSERT( mbedtls_x509write_csr_set_ns_cert_type( &req, cert_type ) == 0 );
+ mbedtls_x509write_csr_set_md_alg(&req, md_type);
+ mbedtls_x509write_csr_set_key(&req, &key);
+ TEST_ASSERT(mbedtls_x509write_csr_set_subject_name(&req, subject_name) == 0);
+ if (key_usage != 0) {
+ TEST_ASSERT(mbedtls_x509write_csr_set_key_usage(&req, key_usage) == 0);
+ }
+ if (cert_type != 0) {
+ TEST_ASSERT(mbedtls_x509write_csr_set_ns_cert_type(&req, cert_type) == 0);
+ }
- ret = mbedtls_x509write_csr_pem( &req, buf, sizeof( buf ) - 1,
- mbedtls_test_rnd_pseudo_rand, &rnd_info );
+ ret = mbedtls_x509write_csr_pem(&req, buf, sizeof(buf) - 1,
+ mbedtls_test_rnd_pseudo_rand, &rnd_info);
- TEST_ASSERT( ret == 0 );
+ TEST_ASSERT(ret == 0);
- pem_len = strlen( (char *) buf );
+ pem_len = strlen((char *) buf);
buf[pem_len] = '\0';
- TEST_ASSERT( x509_crt_verifycsr( buf, pem_len + 1 ) == 0 );
+ TEST_ASSERT(x509_crt_verifycsr(buf, pem_len + 1) == 0);
exit:
- mbedtls_x509write_csr_free( &req );
- mbedtls_pk_free( &key );
- psa_destroy_key( key_id );
- PSA_DONE( );
+ mbedtls_x509write_csr_free(&req);
+ mbedtls_pk_free(&key);
+ psa_destroy_key(key_id);
+ PSA_DONE();
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_PEM_WRITE_C:MBEDTLS_X509_CRT_WRITE_C:MBEDTLS_SHA1_C */
-void x509_crt_check( char *subject_key_file, char *subject_pwd,
- char *subject_name, char *issuer_key_file,
- char *issuer_pwd, char *issuer_name,
- char *serial_str, char *not_before, char *not_after,
- int md_type, int key_usage, int set_key_usage,
- int cert_type, int set_cert_type, int auth_ident,
- int ver, char *cert_check_file, int rsa_alt, int is_ca )
+void x509_crt_check(char *subject_key_file, char *subject_pwd,
+ char *subject_name, char *issuer_key_file,
+ char *issuer_pwd, char *issuer_name,
+ char *serial_str, char *not_before, char *not_after,
+ int md_type, int key_usage, int set_key_usage,
+ int cert_type, int set_cert_type, int auth_ident,
+ int ver, char *cert_check_file, int rsa_alt, int is_ca)
{
mbedtls_pk_context subject_key, issuer_key, issuer_key_alt;
mbedtls_pk_context *key = &issuer_key;
@@ -274,30 +279,29 @@
FILE *f;
mbedtls_test_rnd_pseudo_info rnd_info;
- memset( &rnd_info, 0x2a, sizeof( mbedtls_test_rnd_pseudo_info ) );
- mbedtls_mpi_init( &serial );
+ memset(&rnd_info, 0x2a, sizeof(mbedtls_test_rnd_pseudo_info));
+ mbedtls_mpi_init(&serial);
- mbedtls_pk_init( &subject_key );
- mbedtls_pk_init( &issuer_key );
- mbedtls_pk_init( &issuer_key_alt );
+ mbedtls_pk_init(&subject_key);
+ mbedtls_pk_init(&issuer_key);
+ mbedtls_pk_init(&issuer_key_alt);
- mbedtls_x509write_crt_init( &crt );
+ mbedtls_x509write_crt_init(&crt);
- TEST_ASSERT( mbedtls_pk_parse_keyfile( &subject_key, subject_key_file,
- subject_pwd ) == 0 );
+ TEST_ASSERT(mbedtls_pk_parse_keyfile(&subject_key, subject_key_file,
+ subject_pwd) == 0);
- TEST_ASSERT( mbedtls_pk_parse_keyfile( &issuer_key, issuer_key_file,
- issuer_pwd ) == 0 );
+ TEST_ASSERT(mbedtls_pk_parse_keyfile(&issuer_key, issuer_key_file,
+ issuer_pwd) == 0);
#if defined(MBEDTLS_RSA_C)
/* For RSA PK contexts, create a copy as an alternative RSA context. */
- if( rsa_alt == 1 && mbedtls_pk_get_type( &issuer_key ) == MBEDTLS_PK_RSA )
- {
- TEST_ASSERT( mbedtls_pk_setup_rsa_alt( &issuer_key_alt,
- mbedtls_pk_rsa( issuer_key ),
- mbedtls_rsa_decrypt_func,
- mbedtls_rsa_sign_func,
- mbedtls_rsa_key_len_func ) == 0 );
+ if (rsa_alt == 1 && mbedtls_pk_get_type(&issuer_key) == MBEDTLS_PK_RSA) {
+ TEST_ASSERT(mbedtls_pk_setup_rsa_alt(&issuer_key_alt,
+ mbedtls_pk_rsa(issuer_key),
+ mbedtls_rsa_decrypt_func,
+ mbedtls_rsa_sign_func,
+ mbedtls_rsa_key_len_func) == 0);
key = &issuer_key_alt;
}
@@ -305,130 +309,125 @@
(void) rsa_alt;
#endif
- TEST_ASSERT( mbedtls_test_read_mpi( &serial, serial_str ) == 0 );
+ TEST_ASSERT(mbedtls_test_read_mpi(&serial, serial_str) == 0);
- if( ver != -1 )
- mbedtls_x509write_crt_set_version( &crt, ver );
-
- TEST_ASSERT( mbedtls_x509write_crt_set_serial( &crt, &serial ) == 0 );
- TEST_ASSERT( mbedtls_x509write_crt_set_validity( &crt, not_before,
- not_after ) == 0 );
- mbedtls_x509write_crt_set_md_alg( &crt, md_type );
- TEST_ASSERT( mbedtls_x509write_crt_set_issuer_name( &crt, issuer_name ) == 0 );
- TEST_ASSERT( mbedtls_x509write_crt_set_subject_name( &crt, subject_name ) == 0 );
- mbedtls_x509write_crt_set_subject_key( &crt, &subject_key );
-
- mbedtls_x509write_crt_set_issuer_key( &crt, key );
-
- if( crt.version >= MBEDTLS_X509_CRT_VERSION_3 )
- {
- /* For the CA case, a path length of -1 means unlimited. */
- TEST_ASSERT( mbedtls_x509write_crt_set_basic_constraints( &crt, is_ca,
- (is_ca ? -1 : 0) ) == 0 );
- TEST_ASSERT( mbedtls_x509write_crt_set_subject_key_identifier( &crt ) == 0 );
- if( auth_ident )
- TEST_ASSERT( mbedtls_x509write_crt_set_authority_key_identifier( &crt ) == 0 );
- if( set_key_usage != 0 )
- TEST_ASSERT( mbedtls_x509write_crt_set_key_usage( &crt, key_usage ) == 0 );
- if( set_cert_type != 0 )
- TEST_ASSERT( mbedtls_x509write_crt_set_ns_cert_type( &crt, cert_type ) == 0 );
+ if (ver != -1) {
+ mbedtls_x509write_crt_set_version(&crt, ver);
}
- ret = mbedtls_x509write_crt_pem( &crt, buf, sizeof( buf ),
- mbedtls_test_rnd_pseudo_rand, &rnd_info );
- TEST_ASSERT( ret == 0 );
+ TEST_ASSERT(mbedtls_x509write_crt_set_serial(&crt, &serial) == 0);
+ TEST_ASSERT(mbedtls_x509write_crt_set_validity(&crt, not_before,
+ not_after) == 0);
+ mbedtls_x509write_crt_set_md_alg(&crt, md_type);
+ TEST_ASSERT(mbedtls_x509write_crt_set_issuer_name(&crt, issuer_name) == 0);
+ TEST_ASSERT(mbedtls_x509write_crt_set_subject_name(&crt, subject_name) == 0);
+ mbedtls_x509write_crt_set_subject_key(&crt, &subject_key);
- pem_len = strlen( (char *) buf );
+ mbedtls_x509write_crt_set_issuer_key(&crt, key);
+
+ if (crt.version >= MBEDTLS_X509_CRT_VERSION_3) {
+ /* For the CA case, a path length of -1 means unlimited. */
+ TEST_ASSERT(mbedtls_x509write_crt_set_basic_constraints(&crt, is_ca,
+ (is_ca ? -1 : 0)) == 0);
+ TEST_ASSERT(mbedtls_x509write_crt_set_subject_key_identifier(&crt) == 0);
+ if (auth_ident) {
+ TEST_ASSERT(mbedtls_x509write_crt_set_authority_key_identifier(&crt) == 0);
+ }
+ if (set_key_usage != 0) {
+ TEST_ASSERT(mbedtls_x509write_crt_set_key_usage(&crt, key_usage) == 0);
+ }
+ if (set_cert_type != 0) {
+ TEST_ASSERT(mbedtls_x509write_crt_set_ns_cert_type(&crt, cert_type) == 0);
+ }
+ }
+
+ ret = mbedtls_x509write_crt_pem(&crt, buf, sizeof(buf),
+ mbedtls_test_rnd_pseudo_rand, &rnd_info);
+ TEST_ASSERT(ret == 0);
+
+ pem_len = strlen((char *) buf);
// check that the rest of the buffer remains clear
- for( buf_index = pem_len; buf_index < sizeof( buf ); ++buf_index )
- {
- TEST_ASSERT( buf[buf_index] == 0 );
+ for (buf_index = pem_len; buf_index < sizeof(buf); ++buf_index) {
+ TEST_ASSERT(buf[buf_index] == 0);
}
- if( *cert_check_file != '\0' )
- {
- f = fopen( cert_check_file, "r" );
- TEST_ASSERT( f != NULL );
- olen = fread( check_buf, 1, sizeof( check_buf ), f );
- fclose( f );
- TEST_ASSERT( olen < sizeof( check_buf ) );
- TEST_ASSERT( olen >= pem_len - 1 );
- TEST_ASSERT( memcmp( buf, check_buf, pem_len - 1 ) == 0 );
+ if (*cert_check_file != '\0') {
+ f = fopen(cert_check_file, "r");
+ TEST_ASSERT(f != NULL);
+ olen = fread(check_buf, 1, sizeof(check_buf), f);
+ fclose(f);
+ TEST_ASSERT(olen < sizeof(check_buf));
+ TEST_ASSERT(olen >= pem_len - 1);
+ TEST_ASSERT(memcmp(buf, check_buf, pem_len - 1) == 0);
}
- der_len = mbedtls_x509write_crt_der( &crt, buf, sizeof( buf ),
- mbedtls_test_rnd_pseudo_rand,
- &rnd_info );
- TEST_ASSERT( der_len >= 0 );
+ der_len = mbedtls_x509write_crt_der(&crt, buf, sizeof(buf),
+ mbedtls_test_rnd_pseudo_rand,
+ &rnd_info);
+ TEST_ASSERT(der_len >= 0);
- if( der_len == 0 )
+ if (der_len == 0) {
goto exit;
+ }
// Not testing against file, check date format
- if( *cert_check_file == '\0' )
- {
+ if (*cert_check_file == '\0') {
// UTC tag if before 2050, 2 digits less for year
- if( not_before[0] == '2' && ( not_before[1] > '0' || not_before[2] > '4' ) )
- {
+ if (not_before[0] == '2' && (not_before[1] > '0' || not_before[2] > '4')) {
before_tag = MBEDTLS_ASN1_GENERALIZED_TIME;
- }
- else
- {
+ } else {
before_tag = MBEDTLS_ASN1_UTC_TIME;
not_before += 2;
}
- if( not_after[0] == '2' && ( not_after[1] > '0' || not_after[2] > '4' ) )
- {
+ if (not_after[0] == '2' && (not_after[1] > '0' || not_after[2] > '4')) {
after_tag = MBEDTLS_ASN1_GENERALIZED_TIME;
- }
- else
- {
+ } else {
after_tag = MBEDTLS_ASN1_UTC_TIME;
not_after += 2;
}
- end = buf + sizeof( buf );
- for( p = end - der_len ; p < end ; )
- {
+ end = buf + sizeof(buf);
+ for (p = end - der_len; p < end;) {
tag = *p++;
sz = *p++;
- if( tag == MBEDTLS_ASN1_UTC_TIME || tag == MBEDTLS_ASN1_GENERALIZED_TIME )
- {
+ if (tag == MBEDTLS_ASN1_UTC_TIME || tag == MBEDTLS_ASN1_GENERALIZED_TIME) {
// Check correct tag and time written
- TEST_ASSERT( before_tag == tag );
- TEST_ASSERT( memcmp( p, not_before, sz - 1 ) == 0 );
+ TEST_ASSERT(before_tag == tag);
+ TEST_ASSERT(memcmp(p, not_before, sz - 1) == 0);
p += sz;
tag = *p++;
sz = *p++;
- TEST_ASSERT( after_tag == tag );
- TEST_ASSERT( memcmp( p, not_after, sz - 1 ) == 0 );
+ TEST_ASSERT(after_tag == tag);
+ TEST_ASSERT(memcmp(p, not_after, sz - 1) == 0);
break;
}
// Increment if long form ASN1 length
- if( sz & 0x80 )
+ if (sz & 0x80) {
p += sz & 0x0F;
- if( tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) )
+ }
+ if (tag != (MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE)) {
p += sz;
+ }
}
- TEST_ASSERT( p < end );
+ TEST_ASSERT(p < end);
}
- ret = mbedtls_x509write_crt_der( &crt, buf, (size_t)( der_len - 1 ),
- mbedtls_test_rnd_pseudo_rand, &rnd_info );
- TEST_ASSERT( ret == MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
+ ret = mbedtls_x509write_crt_der(&crt, buf, (size_t) (der_len - 1),
+ mbedtls_test_rnd_pseudo_rand, &rnd_info);
+ TEST_ASSERT(ret == MBEDTLS_ERR_ASN1_BUF_TOO_SMALL);
exit:
- mbedtls_x509write_crt_free( &crt );
- mbedtls_pk_free( &issuer_key_alt );
- mbedtls_pk_free( &subject_key );
- mbedtls_pk_free( &issuer_key );
- mbedtls_mpi_free( &serial );
+ mbedtls_x509write_crt_free(&crt);
+ mbedtls_pk_free(&issuer_key_alt);
+ mbedtls_pk_free(&subject_key);
+ mbedtls_pk_free(&issuer_key);
+ mbedtls_mpi_free(&serial);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_X509_CREATE_C:MBEDTLS_X509_USE_C */
-void mbedtls_x509_string_to_names( char * name, char * parsed_name, int result
- )
+void mbedtls_x509_string_to_names(char *name, char *parsed_name, int result
+ )
{
int ret;
size_t len = 0;
@@ -436,38 +435,38 @@
mbedtls_x509_name parsed, *parsed_cur, *parsed_prv;
unsigned char buf[1024], out[1024], *c;
- memset( &parsed, 0, sizeof( parsed ) );
- memset( out, 0, sizeof( out ) );
- memset( buf, 0, sizeof( buf ) );
- c = buf + sizeof( buf );
+ memset(&parsed, 0, sizeof(parsed));
+ memset(out, 0, sizeof(out));
+ memset(buf, 0, sizeof(buf));
+ c = buf + sizeof(buf);
- ret = mbedtls_x509_string_to_names( &names, name );
- TEST_ASSERT( ret == result );
+ ret = mbedtls_x509_string_to_names(&names, name);
+ TEST_ASSERT(ret == result);
- if( ret != 0 )
+ if (ret != 0) {
goto exit;
+ }
- ret = mbedtls_x509_write_names( &c, buf, names );
- TEST_ASSERT( ret > 0 );
+ ret = mbedtls_x509_write_names(&c, buf, names);
+ TEST_ASSERT(ret > 0);
- TEST_ASSERT( mbedtls_asn1_get_tag( &c, buf + sizeof( buf ), &len,
- MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) == 0 );
- TEST_ASSERT( mbedtls_x509_get_name( &c, buf + sizeof( buf ), &parsed ) == 0 );
+ TEST_ASSERT(mbedtls_asn1_get_tag(&c, buf + sizeof(buf), &len,
+ MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE) == 0);
+ TEST_ASSERT(mbedtls_x509_get_name(&c, buf + sizeof(buf), &parsed) == 0);
- ret = mbedtls_x509_dn_gets( (char *) out, sizeof( out ), &parsed );
- TEST_ASSERT( ret > 0 );
+ ret = mbedtls_x509_dn_gets((char *) out, sizeof(out), &parsed);
+ TEST_ASSERT(ret > 0);
- TEST_ASSERT( strcmp( (char *) out, parsed_name ) == 0 );
+ TEST_ASSERT(strcmp((char *) out, parsed_name) == 0);
exit:
- mbedtls_asn1_free_named_data_list( &names );
+ mbedtls_asn1_free_named_data_list(&names);
parsed_cur = parsed.next;
- while( parsed_cur != 0 )
- {
+ while (parsed_cur != 0) {
parsed_prv = parsed_cur;
parsed_cur = parsed_cur->next;
- mbedtls_free( parsed_prv );
+ mbedtls_free(parsed_prv);
}
}
/* END_CASE */
diff --git a/tests/suites/test_suite_xtea.function b/tests/suites/test_suite_xtea.function
index 1d5b29b..7e06e30 100644
--- a/tests/suites/test_suite_xtea.function
+++ b/tests/suites/test_suite_xtea.function
@@ -8,8 +8,8 @@
*/
/* BEGIN_CASE */
-void xtea_encrypt_ecb( data_t * key_str, data_t * src_str,
- data_t * dst )
+void xtea_encrypt_ecb(data_t *key_str, data_t *src_str,
+ data_t *dst)
{
unsigned char output[100];
mbedtls_xtea_context ctx;
@@ -17,15 +17,15 @@
memset(output, 0x00, 100);
- mbedtls_xtea_setup( &ctx, key_str->x );
- TEST_ASSERT( mbedtls_xtea_crypt_ecb( &ctx, MBEDTLS_XTEA_ENCRYPT, src_str->x, output ) == 0 );
+ mbedtls_xtea_setup(&ctx, key_str->x);
+ TEST_ASSERT(mbedtls_xtea_crypt_ecb(&ctx, MBEDTLS_XTEA_ENCRYPT, src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 8, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 8, dst->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE */
-void xtea_decrypt_ecb( data_t * key_str, data_t * src_str, data_t * dst )
+void xtea_decrypt_ecb(data_t *key_str, data_t *src_str, data_t *dst)
{
unsigned char output[100];
mbedtls_xtea_context ctx;
@@ -33,16 +33,16 @@
memset(output, 0x00, 100);
- mbedtls_xtea_setup( &ctx, key_str->x );
- TEST_ASSERT( mbedtls_xtea_crypt_ecb( &ctx, MBEDTLS_XTEA_DECRYPT, src_str->x, output ) == 0 );
+ mbedtls_xtea_setup(&ctx, key_str->x);
+ TEST_ASSERT(mbedtls_xtea_crypt_ecb(&ctx, MBEDTLS_XTEA_DECRYPT, src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x, 8, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x, 8, dst->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void xtea_encrypt_cbc( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst )
+void xtea_encrypt_cbc(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst)
{
unsigned char output[100];
mbedtls_xtea_context ctx;
@@ -50,18 +50,18 @@
memset(output, 0x00, 100);
- mbedtls_xtea_setup( &ctx, key_str->x );
- TEST_ASSERT( mbedtls_xtea_crypt_cbc( &ctx, MBEDTLS_XTEA_ENCRYPT, src_str->len, iv_str->x,
- src_str->x, output ) == 0 );
+ mbedtls_xtea_setup(&ctx, key_str->x);
+ TEST_ASSERT(mbedtls_xtea_crypt_cbc(&ctx, MBEDTLS_XTEA_ENCRYPT, src_str->len, iv_str->x,
+ src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
- src_str->len, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
+ src_str->len, dst->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_CIPHER_MODE_CBC */
-void xtea_decrypt_cbc( data_t * key_str, data_t * iv_str,
- data_t * src_str, data_t * dst )
+void xtea_decrypt_cbc(data_t *key_str, data_t *iv_str,
+ data_t *src_str, data_t *dst)
{
unsigned char output[100];
mbedtls_xtea_context ctx;
@@ -69,18 +69,18 @@
memset(output, 0x00, 100);
- mbedtls_xtea_setup( &ctx, key_str->x );
- TEST_ASSERT( mbedtls_xtea_crypt_cbc( &ctx, MBEDTLS_XTEA_DECRYPT, src_str->len, iv_str->x,
- src_str->x, output ) == 0 );
+ mbedtls_xtea_setup(&ctx, key_str->x);
+ TEST_ASSERT(mbedtls_xtea_crypt_cbc(&ctx, MBEDTLS_XTEA_DECRYPT, src_str->len, iv_str->x,
+ src_str->x, output) == 0);
- TEST_ASSERT( mbedtls_test_hexcmp( output, dst->x,
- src_str->len, dst->len ) == 0 );
+ TEST_ASSERT(mbedtls_test_hexcmp(output, dst->x,
+ src_str->len, dst->len) == 0);
}
/* END_CASE */
/* BEGIN_CASE depends_on:MBEDTLS_SELF_TEST */
-void xtea_selftest( )
+void xtea_selftest()
{
- TEST_ASSERT( mbedtls_xtea_self_test( 1 ) == 0 );
+ TEST_ASSERT(mbedtls_xtea_self_test(1) == 0);
}
/* END_CASE */