Apply clang formatting.
Executed with:
`find . -regextype posix-egrep -regex ".*\.([hc]|fmt|function)" | xargs -L1 clang-format-12 -i`
Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
diff --git a/tests/src/drivers/hash.c b/tests/src/drivers/hash.c
index d57ce6c..e23c6fa 100644
--- a/tests/src/drivers/hash.c
+++ b/tests/src/drivers/hash.c
@@ -20,138 +20,121 @@
#include <test/helpers.h>
#if defined(MBEDTLS_PSA_CRYPTO_DRIVERS) && defined(PSA_CRYPTO_DRIVER_TEST)
-#include "psa_crypto_hash.h"
+# include "psa_crypto_hash.h"
-#include "test/drivers/hash.h"
+# include "test/drivers/hash.h"
-mbedtls_test_driver_hash_hooks_t
- mbedtls_test_driver_hash_hooks = MBEDTLS_TEST_DRIVER_HASH_INIT;
+mbedtls_test_driver_hash_hooks_t mbedtls_test_driver_hash_hooks =
+ MBEDTLS_TEST_DRIVER_HASH_INIT;
-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 )
+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)
{
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 {
mbedtls_test_driver_hash_hooks.driver_status =
mbedtls_transparent_test_driver_hash_compute(
- alg, input, input_length,
- hash, hash_size, hash_length );
+ alg, input, input_length, hash, hash_size, hash_length);
}
- 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 (mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS) {
mbedtls_test_driver_hash_hooks.driver_status =
- mbedtls_transparent_test_driver_hash_setup( operation, alg );
+ mbedtls_test_driver_hash_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_hash_hooks.driver_status =
+ mbedtls_transparent_test_driver_hash_setup(operation, alg);
}
- 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 (mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS) {
mbedtls_test_driver_hash_hooks.driver_status =
- mbedtls_transparent_test_driver_hash_clone( source_operation,
- target_operation );
+ mbedtls_test_driver_hash_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_hash_hooks.driver_status =
+ mbedtls_transparent_test_driver_hash_clone(source_operation,
+ target_operation);
}
- 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_transparent_test_driver_hash_update(
- operation, input, input_length );
+ mbedtls_test_driver_hash_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_hash_hooks.driver_status =
+ mbedtls_transparent_test_driver_hash_update(operation, input,
+ input_length);
}
- 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_transparent_test_driver_hash_finish(
- operation, hash, hash_size, hash_length );
+ mbedtls_test_driver_hash_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_hash_hooks.driver_status =
+ mbedtls_transparent_test_driver_hash_finish(operation, hash,
+ hash_size, hash_length);
}
- 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 (mbedtls_test_driver_hash_hooks.forced_status != PSA_SUCCESS) {
mbedtls_test_driver_hash_hooks.driver_status =
- mbedtls_transparent_test_driver_hash_abort( operation );
+ mbedtls_test_driver_hash_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_hash_hooks.driver_status =
+ mbedtls_transparent_test_driver_hash_abort(operation);
}
- 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 6d125a0..072f465 100644
--- a/tests/src/drivers/platform_builtin_keys.c
+++ b/tests/src/drivers/platform_builtin_keys.c
@@ -26,11 +26,10 @@
#include <psa/crypto_extra.h>
#if defined(PSA_CRYPTO_DRIVER_TEST)
-#include <test/drivers/test_driver.h>
+# 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;
@@ -42,52 +41,56 @@
* 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_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_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 76afcd7..4cc7751 100644
--- a/tests/src/drivers/test_driver_aead.c
+++ b/tests/src/drivers/test_driver_aead.c
@@ -20,73 +20,71 @@
#include <test/helpers.h>
#if defined(MBEDTLS_PSA_CRYPTO_DRIVERS) && defined(PSA_CRYPTO_DRIVER_TEST)
-#include "psa_crypto_aead.h"
+# include "psa_crypto_aead.h"
-#include "test/drivers/aead.h"
+# include "test/drivers/aead.h"
-mbedtls_test_driver_aead_hooks_t
- mbedtls_test_driver_aead_hooks = MBEDTLS_TEST_DRIVER_AEAD_INIT;
+mbedtls_test_driver_aead_hooks_t mbedtls_test_driver_aead_hooks =
+ MBEDTLS_TEST_DRIVER_AEAD_INIT;
-psa_status_t mbedtls_test_transparent_aead_encrypt(
- const psa_key_attributes_t *attributes,
- const uint8_t *key_buffer, size_t key_buffer_size,
- psa_algorithm_t alg,
- 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 )
+psa_status_t
+mbedtls_test_transparent_aead_encrypt(const psa_key_attributes_t *attributes,
+ const uint8_t *key_buffer,
+ size_t key_buffer_size,
+ psa_algorithm_t alg,
+ 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)
{
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_psa_aead_encrypt(
- attributes, key_buffer, key_buffer_size,
- alg,
- nonce, nonce_length,
- additional_data, additional_data_length,
- plaintext, plaintext_length,
- ciphertext, ciphertext_size, ciphertext_length );
+ mbedtls_test_driver_aead_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_aead_hooks.driver_status = mbedtls_psa_aead_encrypt(
+ attributes, key_buffer, key_buffer_size, alg, nonce, nonce_length,
+ additional_data, additional_data_length, plaintext,
+ plaintext_length, ciphertext, ciphertext_size, ciphertext_length);
}
- return mbedtls_test_driver_aead_hooks.driver_status ;
+ return mbedtls_test_driver_aead_hooks.driver_status;
}
-psa_status_t mbedtls_test_transparent_aead_decrypt(
- const psa_key_attributes_t *attributes,
- const uint8_t *key_buffer, size_t key_buffer_size,
- psa_algorithm_t alg,
- 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 )
+psa_status_t
+mbedtls_test_transparent_aead_decrypt(const psa_key_attributes_t *attributes,
+ const uint8_t *key_buffer,
+ size_t key_buffer_size,
+ psa_algorithm_t alg,
+ 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)
{
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_psa_aead_decrypt(
- attributes, key_buffer, key_buffer_size,
- alg,
- nonce, nonce_length,
- additional_data, additional_data_length,
- ciphertext, ciphertext_length,
- plaintext, plaintext_size, plaintext_length );
+ mbedtls_test_driver_aead_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_aead_hooks.driver_status = mbedtls_psa_aead_decrypt(
+ attributes, key_buffer, key_buffer_size, alg, nonce, nonce_length,
+ additional_data, additional_data_length, ciphertext,
+ ciphertext_length, plaintext, plaintext_size, plaintext_length);
}
- 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 20d79d8..0f369ba 100644
--- a/tests/src/drivers/test_driver_cipher.c
+++ b/tests/src/drivers/test_driver_cipher.c
@@ -21,96 +21,92 @@
#include <test/helpers.h>
#if defined(MBEDTLS_PSA_CRYPTO_DRIVERS) && defined(PSA_CRYPTO_DRIVER_TEST)
-#include "psa/crypto.h"
-#include "psa_crypto_cipher.h"
-#include "psa_crypto_core.h"
-#include "mbedtls/cipher.h"
+# include "psa/crypto.h"
+# include "psa_crypto_cipher.h"
+# include "psa_crypto_core.h"
+# include "mbedtls/cipher.h"
-#include "test/drivers/cipher.h"
+# include "test/drivers/cipher.h"
-#include "test/random.h"
+# include "test/random.h"
-#include <string.h>
+# include <string.h>
mbedtls_test_driver_cipher_hooks_t mbedtls_test_driver_cipher_hooks =
MBEDTLS_TEST_DRIVER_CIPHER_INIT;
-psa_status_t mbedtls_test_transparent_cipher_encrypt(
- const psa_key_attributes_t *attributes,
- const uint8_t *key_buffer,
- size_t key_buffer_size,
- psa_algorithm_t alg,
- const uint8_t *input,
- size_t input_length,
- uint8_t *output,
- size_t output_size,
- size_t *output_length )
+psa_status_t
+mbedtls_test_transparent_cipher_encrypt(const psa_key_attributes_t *attributes,
+ const uint8_t *key_buffer,
+ size_t key_buffer_size,
+ psa_algorithm_t alg,
+ const uint8_t *input,
+ size_t input_length,
+ uint8_t *output,
+ size_t output_size,
+ 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;
- psa_generate_random( output, PSA_CIPHER_IV_LENGTH( attributes->core.type, alg ) );
+ psa_generate_random(output,
+ PSA_CIPHER_IV_LENGTH(attributes->core.type, alg));
- return( mbedtls_transparent_test_driver_cipher_encrypt(
- attributes, key_buffer, key_buffer_size,
- alg, input, input_length,
- output, output_size, output_length ) );
+ return (mbedtls_transparent_test_driver_cipher_encrypt(
+ attributes, key_buffer, key_buffer_size, alg, input, input_length,
+ output, output_size, output_length));
}
-psa_status_t mbedtls_test_transparent_cipher_decrypt(
- const psa_key_attributes_t *attributes,
- const uint8_t *key_buffer,
- size_t key_buffer_size,
- psa_algorithm_t alg,
- const uint8_t *input,
- size_t input_length,
- uint8_t *output,
- size_t output_size,
- size_t *output_length )
+psa_status_t
+mbedtls_test_transparent_cipher_decrypt(const psa_key_attributes_t *attributes,
+ const uint8_t *key_buffer,
+ size_t key_buffer_size,
+ psa_algorithm_t alg,
+ const uint8_t *input,
+ size_t input_length,
+ uint8_t *output,
+ size_t output_size,
+ 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;
- return( mbedtls_transparent_test_driver_cipher_decrypt(
- attributes, key_buffer, key_buffer_size,
- alg, input, input_length,
- output, output_size, output_length ) );
+ return (mbedtls_transparent_test_driver_cipher_decrypt(
+ attributes, key_buffer, key_buffer_size, alg, input, input_length,
+ output, output_size, output_length));
}
psa_status_t mbedtls_test_transparent_cipher_encrypt_setup(
mbedtls_transparent_test_driver_cipher_operation_t *operation,
const psa_key_attributes_t *attributes,
- const uint8_t *key, size_t key_length,
+ const uint8_t *key,
+ size_t key_length,
psa_algorithm_t alg)
{
mbedtls_test_driver_cipher_hooks.hits++;
@@ -119,28 +115,29 @@
* 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;
- return ( mbedtls_transparent_test_driver_cipher_encrypt_setup(
- operation, attributes, key, key_length, alg ) );
+ return (mbedtls_transparent_test_driver_cipher_encrypt_setup(
+ operation, attributes, key, key_length, alg));
}
psa_status_t mbedtls_test_transparent_cipher_decrypt_setup(
mbedtls_transparent_test_driver_cipher_operation_t *operation,
const psa_key_attributes_t *attributes,
- const uint8_t *key, size_t key_length,
+ const uint8_t *key,
+ size_t key_length,
psa_algorithm_t alg)
{
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;
- return ( mbedtls_transparent_test_driver_cipher_decrypt_setup(
- operation, attributes, key, key_length, alg ) );
+ return (mbedtls_transparent_test_driver_cipher_decrypt_setup(
+ operation, attributes, key, key_length, alg));
}
psa_status_t mbedtls_test_transparent_cipher_abort(
@@ -148,18 +145,18 @@
{
mbedtls_test_driver_cipher_hooks.hits++;
- if( operation->alg == 0 )
- return PSA_SUCCESS ;
+ if (operation->alg == 0)
+ return PSA_SUCCESS;
- mbedtls_transparent_test_driver_cipher_abort( operation );
+ mbedtls_transparent_test_driver_cipher_abort(operation);
/* 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(
@@ -169,11 +166,11 @@
{
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;
- return( mbedtls_transparent_test_driver_cipher_set_iv(
- operation, iv, iv_length ) );
+ return (mbedtls_transparent_test_driver_cipher_set_iv(operation, iv,
+ iv_length));
}
psa_status_t mbedtls_test_transparent_cipher_update(
@@ -186,25 +183,22 @@
{
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;
- return( mbedtls_transparent_test_driver_cipher_update(
- operation, input, input_length,
- output, output_size, output_length ) );
+ return (mbedtls_transparent_test_driver_cipher_update(
+ operation, input, input_length, output, output_size, output_length));
}
psa_status_t mbedtls_test_transparent_cipher_finish(
@@ -215,100 +209,108 @@
{
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;
- return( mbedtls_transparent_test_driver_cipher_finish(
- operation, output, output_size, output_length ) );
+ return (mbedtls_transparent_test_driver_cipher_finish(
+ operation, output, output_size, output_length));
}
/*
* opaque versions, to do
*/
-psa_status_t mbedtls_test_opaque_cipher_encrypt(
- const psa_key_attributes_t *attributes,
- const uint8_t *key, size_t key_length,
- psa_algorithm_t alg,
- const uint8_t *input, size_t input_length,
- uint8_t *output, size_t output_size, size_t *output_length)
+psa_status_t
+mbedtls_test_opaque_cipher_encrypt(const psa_key_attributes_t *attributes,
+ const uint8_t *key,
+ size_t key_length,
+ psa_algorithm_t alg,
+ const uint8_t *input,
+ size_t input_length,
+ uint8_t *output,
+ size_t output_size,
+ size_t *output_length)
{
- (void) attributes;
- (void) key;
- (void) key_length;
- (void) alg;
- (void) input;
- (void) input_length;
- (void) output;
- (void) output_size;
- (void) output_length;
- return PSA_ERROR_NOT_SUPPORTED ;
+ (void)attributes;
+ (void)key;
+ (void)key_length;
+ (void)alg;
+ (void)input;
+ (void)input_length;
+ (void)output;
+ (void)output_size;
+ (void)output_length;
+ return PSA_ERROR_NOT_SUPPORTED;
}
-psa_status_t mbedtls_test_opaque_cipher_decrypt(
- const psa_key_attributes_t *attributes,
- const uint8_t *key, size_t key_length,
- psa_algorithm_t alg,
- const uint8_t *input, size_t input_length,
- uint8_t *output, size_t output_size, size_t *output_length)
+psa_status_t
+mbedtls_test_opaque_cipher_decrypt(const psa_key_attributes_t *attributes,
+ const uint8_t *key,
+ size_t key_length,
+ psa_algorithm_t alg,
+ const uint8_t *input,
+ size_t input_length,
+ uint8_t *output,
+ size_t output_size,
+ size_t *output_length)
{
- (void) attributes;
- (void) key;
- (void) key_length;
- (void) alg;
- (void) input;
- (void) input_length;
- (void) output;
- (void) output_size;
- (void) output_length;
- return PSA_ERROR_NOT_SUPPORTED ;
+ (void)attributes;
+ (void)key;
+ (void)key_length;
+ (void)alg;
+ (void)input;
+ (void)input_length;
+ (void)output;
+ (void)output_size;
+ (void)output_length;
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_cipher_encrypt_setup(
mbedtls_opaque_test_driver_cipher_operation_t *operation,
const psa_key_attributes_t *attributes,
- const uint8_t *key, size_t key_length,
+ const uint8_t *key,
+ size_t key_length,
psa_algorithm_t alg)
{
- (void) operation;
- (void) attributes;
- (void) key;
- (void) key_length;
- (void) alg;
- return PSA_ERROR_NOT_SUPPORTED ;
+ (void)operation;
+ (void)attributes;
+ (void)key;
+ (void)key_length;
+ (void)alg;
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_cipher_decrypt_setup(
mbedtls_opaque_test_driver_cipher_operation_t *operation,
const psa_key_attributes_t *attributes,
- const uint8_t *key, size_t key_length,
+ const uint8_t *key,
+ size_t key_length,
psa_algorithm_t alg)
{
- (void) operation;
- (void) attributes;
- (void) key;
- (void) key_length;
- (void) alg;
- return PSA_ERROR_NOT_SUPPORTED ;
+ (void)operation;
+ (void)attributes;
+ (void)key;
+ (void)key_length;
+ (void)alg;
+ 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 ;
+ (void)operation;
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_cipher_set_iv(
@@ -316,10 +318,10 @@
const uint8_t *iv,
size_t iv_length)
{
- (void) operation;
- (void) iv;
- (void) iv_length;
- return PSA_ERROR_NOT_SUPPORTED ;
+ (void)operation;
+ (void)iv;
+ (void)iv_length;
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_cipher_update(
@@ -330,13 +332,13 @@
size_t output_size,
size_t *output_length)
{
- (void) operation;
- (void) input;
- (void) input_length;
- (void) output;
- (void) output_size;
- (void) output_length;
- return PSA_ERROR_NOT_SUPPORTED ;
+ (void)operation;
+ (void)input;
+ (void)input_length;
+ (void)output;
+ (void)output_size;
+ (void)output_length;
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_opaque_cipher_finish(
@@ -345,10 +347,10 @@
size_t output_size,
size_t *output_length)
{
- (void) operation;
- (void) output;
- (void) output_size;
- (void) output_length;
- return PSA_ERROR_NOT_SUPPORTED ;
+ (void)operation;
+ (void)output;
+ (void)output_size;
+ (void)output_length;
+ 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 d2bc9b8..dd1b206 100644
--- a/tests/src/drivers/test_driver_key_management.c
+++ b/tests/src/drivers/test_driver_key_management.c
@@ -21,136 +21,130 @@
#include <test/helpers.h>
#if defined(MBEDTLS_PSA_CRYPTO_DRIVERS) && defined(PSA_CRYPTO_DRIVER_TEST)
-#include "psa/crypto.h"
-#include "psa_crypto_core.h"
-#include "psa_crypto_ecp.h"
-#include "psa_crypto_rsa.h"
-#include "mbedtls/ecp.h"
-#include "mbedtls/error.h"
+# include "psa/crypto.h"
+# include "psa_crypto_core.h"
+# include "psa_crypto_ecp.h"
+# include "psa_crypto_rsa.h"
+# include "mbedtls/ecp.h"
+# include "mbedtls/error.h"
-#include "test/drivers/key_management.h"
+# include "test/drivers/key_management.h"
-#include "test/random.h"
+# include "test/random.h"
-#include <string.h>
+# include <string.h>
mbedtls_test_driver_key_management_hooks_t
- mbedtls_test_driver_key_management_hooks = MBEDTLS_TEST_DRIVER_KEY_MANAGEMENT_INIT;
+ 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 };
-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 };
-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 };
+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 };
+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
+};
+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
+};
-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 )
+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)
{
++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 );
- *key_length = mbedtls_test_driver_key_management_hooks.forced_output_length;
- return PSA_SUCCESS ;
+ 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;
}
/* Copied from psa_crypto.c */
-#if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR)
- if ( PSA_KEY_TYPE_IS_ECC( psa_get_key_type( attributes ) )
- && PSA_KEY_TYPE_IS_KEY_PAIR( psa_get_key_type( attributes ) ) )
- {
- return( mbedtls_transparent_test_driver_ecp_generate_key(
- attributes, key, key_size, key_length ) );
- }
- else
-#endif /* defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR) */
+# if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR)
+ if (PSA_KEY_TYPE_IS_ECC(psa_get_key_type(attributes)) &&
+ PSA_KEY_TYPE_IS_KEY_PAIR(psa_get_key_type(attributes))) {
+ return (mbedtls_transparent_test_driver_ecp_generate_key(
+ attributes, key, key_size, key_length));
+ } else
+# endif /* defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR) */
-#if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_KEY_PAIR)
- if ( psa_get_key_type( attributes ) == PSA_KEY_TYPE_RSA_KEY_PAIR )
- return( mbedtls_transparent_test_driver_rsa_generate_key(
- attributes, key, key_size, key_length ) );
+# if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_KEY_PAIR)
+ if (psa_get_key_type(attributes) == PSA_KEY_TYPE_RSA_KEY_PAIR)
+ return (mbedtls_transparent_test_driver_rsa_generate_key(
+ attributes, key, key_size, key_length));
else
-#endif /* defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_KEY_PAIR) */
+# endif /* defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_KEY_PAIR) */
{
(void)attributes;
- return PSA_ERROR_NOT_SUPPORTED ;
+ 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 )
+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)
{
- (void) attributes;
- (void) key;
- (void) key_size;
- (void) key_length;
- return PSA_ERROR_NOT_SUPPORTED ;
+ (void)attributes;
+ (void)key;
+ (void)key_size;
+ (void)key_length;
+ return PSA_ERROR_NOT_SUPPORTED;
}
-psa_status_t mbedtls_test_transparent_import_key(
- const psa_key_attributes_t *attributes,
- const uint8_t *data,
- size_t data_length,
- uint8_t *key_buffer,
- size_t key_buffer_size,
- size_t *key_buffer_length,
- size_t *bits)
+psa_status_t
+mbedtls_test_transparent_import_key(const psa_key_attributes_t *attributes,
+ const uint8_t *data,
+ size_t data_length,
+ uint8_t *key_buffer,
+ size_t key_buffer_size,
+ size_t *key_buffer_length,
+ size_t *bits)
{
++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;
psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
- psa_key_type_t type = psa_get_key_type( attributes );
+ psa_key_type_t type = psa_get_key_type(attributes);
-#if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR) || \
- defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_PUBLIC_KEY)
- if( PSA_KEY_TYPE_IS_ECC( type ) )
- {
+# if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR) || \
+ defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_PUBLIC_KEY)
+ if (PSA_KEY_TYPE_IS_ECC(type)) {
status = mbedtls_transparent_test_driver_ecp_import_key(
- attributes,
- data, data_length,
- key_buffer, key_buffer_size,
- key_buffer_length, bits );
- }
- else
-#endif
-#if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_KEY_PAIR) || \
- defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_PUBLIC_KEY)
- if( PSA_KEY_TYPE_IS_RSA( type ) )
- {
+ attributes, data, data_length, key_buffer, key_buffer_size,
+ key_buffer_length, bits);
+ } else
+# endif
+# if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_KEY_PAIR) || \
+ defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_PUBLIC_KEY)
+ if (PSA_KEY_TYPE_IS_RSA(type)) {
status = mbedtls_transparent_test_driver_rsa_import_key(
- attributes,
- data, data_length,
- key_buffer, key_buffer_size,
- key_buffer_length, bits );
- }
- else
-#endif
+ attributes, data, data_length, key_buffer, key_buffer_size,
+ key_buffer_length, bits);
+ } else
+# endif
{
status = PSA_ERROR_NOT_SUPPORTED;
(void)data;
@@ -162,120 +156,118 @@
(void)type;
}
- return status ;
+ return status;
}
-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 )
+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)
{
- 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 );
+ psa_drv_slot_number_t slot_number = *((psa_drv_slot_number_t *)key);
- 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 )
+ const uint8_t *key_buffer,
+ size_t key_buffer_size,
+ 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 );
- *data_length = mbedtls_test_driver_key_management_hooks.forced_output_length;
- return PSA_SUCCESS ;
+ 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;
}
psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
- psa_key_type_t key_type = psa_get_key_type( attributes );
+ psa_key_type_t key_type = psa_get_key_type(attributes);
-#if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR) || \
- defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_PUBLIC_KEY)
- if( PSA_KEY_TYPE_IS_ECC( key_type ) )
- {
+# if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR) || \
+ defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_PUBLIC_KEY)
+ if (PSA_KEY_TYPE_IS_ECC(key_type)) {
status = mbedtls_transparent_test_driver_ecp_export_public_key(
- attributes,
- key_buffer, key_buffer_size,
- data, data_size, data_length );
- }
- else
-#endif
-#if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_KEY_PAIR) || \
- defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_PUBLIC_KEY)
- if( PSA_KEY_TYPE_IS_RSA( key_type ) )
- {
+ attributes, key_buffer, key_buffer_size, data, data_size,
+ data_length);
+ } else
+# endif
+# if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_KEY_PAIR) || \
+ defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_PUBLIC_KEY)
+ if (PSA_KEY_TYPE_IS_RSA(key_type)) {
status = mbedtls_transparent_test_driver_rsa_export_public_key(
- attributes,
- key_buffer, key_buffer_size,
- data, data_size, data_length );
- }
- else
-#endif
+ attributes, key_buffer, key_buffer_size, data, data_size,
+ data_length);
+ } else
+# endif
{
status = PSA_ERROR_NOT_SUPPORTED;
(void)key_buffer;
@@ -283,46 +275,47 @@
(void)key_type;
}
- return status ;
+ return status;
}
-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 )
+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)
{
- 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;
}
}
@@ -336,52 +329,47 @@
* (i.e. for an actual driver this would mean 'builtin_key_size' =
* sizeof(psa_drv_slot_number_t)).
*/
-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 )
+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)
{
- 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_usage_flags(
- attributes,
- PSA_KEY_USAGE_ENCRYPT |
- PSA_KEY_USAGE_DECRYPT |
- PSA_KEY_USAGE_EXPORT );
- psa_set_key_algorithm( attributes, PSA_ALG_CTR );
+ 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);
- 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_set_key_usage_flags(
- attributes,
- PSA_KEY_USAGE_SIGN_HASH |
- PSA_KEY_USAGE_VERIFY_HASH |
- PSA_KEY_USAGE_EXPORT );
- psa_set_key_algorithm(
- attributes, PSA_ALG_ECDSA( PSA_ALG_ANY_HASH ) );
+ 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_VERIFY_HASH |
+ PSA_KEY_USAGE_EXPORT);
+ psa_set_key_algorithm(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 cfcf162..4a8504e 100644
--- a/tests/src/drivers/test_driver_mac.c
+++ b/tests/src/drivers/test_driver_mac.c
@@ -20,41 +20,37 @@
#include <test/helpers.h>
#if defined(MBEDTLS_PSA_CRYPTO_DRIVERS) && defined(PSA_CRYPTO_DRIVER_TEST)
-#include "psa_crypto_mac.h"
+# include "psa_crypto_mac.h"
-#include "test/drivers/mac.h"
+# include "test/drivers/mac.h"
mbedtls_test_driver_mac_hooks_t mbedtls_test_driver_mac_hooks =
MBEDTLS_TEST_DRIVER_MAC_INIT;
-psa_status_t mbedtls_test_transparent_mac_compute(
- const psa_key_attributes_t *attributes,
- const uint8_t *key_buffer,
- size_t key_buffer_size,
- psa_algorithm_t alg,
- const uint8_t *input,
- size_t input_length,
- uint8_t *mac,
- size_t mac_size,
- size_t *mac_length )
+psa_status_t
+mbedtls_test_transparent_mac_compute(const psa_key_attributes_t *attributes,
+ const uint8_t *key_buffer,
+ size_t key_buffer_size,
+ psa_algorithm_t alg,
+ const uint8_t *input,
+ size_t input_length,
+ uint8_t *mac,
+ size_t mac_size,
+ 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 {
mbedtls_test_driver_mac_hooks.driver_status =
mbedtls_transparent_test_driver_mac_compute(
- attributes, key_buffer, key_buffer_size, alg,
- input, input_length,
- mac, mac_size, mac_length );
+ attributes, key_buffer, key_buffer_size, alg, input,
+ input_length, mac, mac_size, mac_length);
}
- 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(
@@ -62,23 +58,20 @@
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 {
mbedtls_test_driver_mac_hooks.driver_status =
mbedtls_transparent_test_driver_mac_sign_setup(
- operation, attributes, key_buffer, key_buffer_size, alg );
+ operation, attributes, key_buffer, key_buffer_size, alg);
}
- 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(
@@ -86,139 +79,121 @@
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 {
mbedtls_test_driver_mac_hooks.driver_status =
mbedtls_transparent_test_driver_mac_verify_setup(
- operation, attributes, key_buffer, key_buffer_size, alg );
+ operation, attributes, key_buffer, key_buffer_size, alg);
}
- 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_transparent_test_driver_mac_update(
- operation, input, input_length );
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_transparent_test_driver_mac_update(operation, input,
+ input_length);
}
- 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 {
mbedtls_test_driver_mac_hooks.driver_status =
mbedtls_transparent_test_driver_mac_sign_finish(
- operation, mac, mac_size, mac_length );
+ operation, mac, mac_size, mac_length);
}
- 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_transparent_test_driver_mac_verify_finish(
- operation, mac, mac_length );
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_transparent_test_driver_mac_verify_finish(operation, mac,
+ mac_length);
}
- 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 (mbedtls_test_driver_mac_hooks.forced_status != PSA_SUCCESS) {
mbedtls_test_driver_mac_hooks.driver_status =
- mbedtls_transparent_test_driver_mac_abort( operation );
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_transparent_test_driver_mac_abort(operation);
}
- return mbedtls_test_driver_mac_hooks.driver_status ;
+ return mbedtls_test_driver_mac_hooks.driver_status;
}
-psa_status_t mbedtls_test_opaque_mac_compute(
- const psa_key_attributes_t *attributes,
- const uint8_t *key_buffer,
- size_t key_buffer_size,
- psa_algorithm_t alg,
- const uint8_t *input,
- size_t input_length,
- uint8_t *mac,
- size_t mac_size,
- size_t *mac_length )
+psa_status_t
+mbedtls_test_opaque_mac_compute(const psa_key_attributes_t *attributes,
+ const uint8_t *key_buffer,
+ size_t key_buffer_size,
+ psa_algorithm_t alg,
+ const uint8_t *input,
+ size_t input_length,
+ uint8_t *mac,
+ size_t mac_size,
+ 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_opaque_test_driver_mac_compute(
- attributes, key_buffer, key_buffer_size, alg,
- input, input_length,
- mac, mac_size, mac_length );
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_opaque_test_driver_mac_compute(attributes, key_buffer,
+ key_buffer_size, alg, input,
+ input_length, mac, mac_size,
+ mac_length);
}
- 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(
@@ -226,23 +201,20 @@
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 {
mbedtls_test_driver_mac_hooks.driver_status =
mbedtls_opaque_test_driver_mac_sign_setup(
- operation, attributes, key_buffer, key_buffer_size, alg );
+ operation, attributes, key_buffer, key_buffer_size, alg);
}
- 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(
@@ -250,109 +222,94 @@
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 {
mbedtls_test_driver_mac_hooks.driver_status =
mbedtls_opaque_test_driver_mac_verify_setup(
- operation, attributes, key_buffer, key_buffer_size, alg );
+ operation, attributes, key_buffer, key_buffer_size, alg);
}
- 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_opaque_test_driver_mac_update(
- operation, input, input_length );
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_opaque_test_driver_mac_update(operation, input,
+ input_length);
}
- 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_opaque_test_driver_mac_sign_finish(
- operation, mac, mac_size, mac_length );
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_opaque_test_driver_mac_sign_finish(operation, mac, mac_size,
+ mac_length);
}
- 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_opaque_test_driver_mac_verify_finish(
- operation, mac, mac_length );
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_opaque_test_driver_mac_verify_finish(operation, mac,
+ mac_length);
}
- 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_opaque_test_driver_mac_abort( operation );
+ mbedtls_test_driver_mac_hooks.forced_status;
+ } else {
+ mbedtls_test_driver_mac_hooks.driver_status =
+ mbedtls_opaque_test_driver_mac_abort(operation);
}
- 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 e573b72..4bf60a5 100644
--- a/tests/src/drivers/test_driver_signature.c
+++ b/tests/src/drivers/test_driver_signature.c
@@ -22,78 +22,66 @@
#include <test/helpers.h>
#if defined(MBEDTLS_PSA_CRYPTO_DRIVERS) && defined(PSA_CRYPTO_DRIVER_TEST)
-#include "psa/crypto.h"
-#include "psa_crypto_core.h"
-#include "psa_crypto_ecp.h"
-#include "psa_crypto_hash.h"
-#include "psa_crypto_rsa.h"
-#include "mbedtls/ecp.h"
+# include "psa/crypto.h"
+# include "psa_crypto_core.h"
+# include "psa_crypto_ecp.h"
+# include "psa_crypto_hash.h"
+# include "psa_crypto_rsa.h"
+# include "mbedtls/ecp.h"
-#include "test/drivers/signature.h"
+# include "test/drivers/signature.h"
-#include "mbedtls/md.h"
-#include "mbedtls/ecdsa.h"
+# include "mbedtls/md.h"
+# include "mbedtls/ecdsa.h"
-#include "test/random.h"
+# include "test/random.h"
-#include <string.h>
+# include <string.h>
-mbedtls_test_driver_signature_hooks_t
- mbedtls_test_driver_signature_sign_hooks = MBEDTLS_TEST_DRIVER_SIGNATURE_INIT;
-mbedtls_test_driver_signature_hooks_t
- mbedtls_test_driver_signature_verify_hooks = MBEDTLS_TEST_DRIVER_SIGNATURE_INIT;
+mbedtls_test_driver_signature_hooks_t mbedtls_test_driver_signature_sign_hooks =
+ MBEDTLS_TEST_DRIVER_SIGNATURE_INIT;
+mbedtls_test_driver_signature_hooks_t mbedtls_test_driver_signature_verify_hooks =
+ MBEDTLS_TEST_DRIVER_SIGNATURE_INIT;
-psa_status_t sign_hash(
- const psa_key_attributes_t *attributes,
- 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 )
+psa_status_t sign_hash(const psa_key_attributes_t *attributes,
+ 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)
{
-#if defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PKCS1V15_SIGN) || \
- defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PSS)
- if( attributes->core.type == PSA_KEY_TYPE_RSA_KEY_PAIR )
- {
- return( mbedtls_transparent_test_driver_rsa_sign_hash(
- attributes,
- key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_size, signature_length ) );
- }
- else
-#endif /* defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PKCS1V15_SIGN) ||
- * defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PSS) */
+# if defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PKCS1V15_SIGN) || \
+ defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PSS)
+ if (attributes->core.type == PSA_KEY_TYPE_RSA_KEY_PAIR) {
+ return (mbedtls_transparent_test_driver_rsa_sign_hash(
+ attributes, key_buffer, key_buffer_size, alg, hash, hash_length,
+ signature, signature_size, signature_length));
+ } else
+# endif /* defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PKCS1V15_SIGN) || \
+ * defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PSS) */
-#if defined(MBEDTLS_PSA_ACCEL_ALG_ECDSA) || \
- defined(MBEDTLS_PSA_ACCEL_ALG_DETERMINISTIC_ECDSA)
- if( PSA_KEY_TYPE_IS_ECC( attributes->core.type ) )
- {
- if(
-#if defined(MBEDTLS_PSA_ACCEL_ALG_DETERMINISTIC_ECDSA)
- PSA_ALG_IS_ECDSA( alg )
-#else
- PSA_ALG_IS_RANDOMIZED_ECDSA( alg )
-#endif
- )
- {
- return( mbedtls_transparent_test_driver_ecdsa_sign_hash(
- attributes,
- key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_size, signature_length ) );
+# if defined(MBEDTLS_PSA_ACCEL_ALG_ECDSA) || \
+ defined(MBEDTLS_PSA_ACCEL_ALG_DETERMINISTIC_ECDSA)
+ if (PSA_KEY_TYPE_IS_ECC(attributes->core.type)) {
+ if (
+# if defined(MBEDTLS_PSA_ACCEL_ALG_DETERMINISTIC_ECDSA)
+ PSA_ALG_IS_ECDSA(alg)
+# else
+ PSA_ALG_IS_RANDOMIZED_ECDSA(alg)
+# endif
+ ) {
+ return (mbedtls_transparent_test_driver_ecdsa_sign_hash(
+ attributes, key_buffer, key_buffer_size, alg, hash, hash_length,
+ signature, signature_size, signature_length));
+ } else {
+ return PSA_ERROR_INVALID_ARGUMENT;
}
- else
- {
- return PSA_ERROR_INVALID_ARGUMENT ;
- }
- }
- else
-#endif /* defined(MBEDTLS_PSA_ACCEL_ALG_ECDSA) ||
- * defined(MBEDTLS_PSA_ACCEL_ALG_DETERMINISTIC_ECDSA) */
+ } else
+# endif /* defined(MBEDTLS_PSA_ACCEL_ALG_ECDSA) || \
+ * defined(MBEDTLS_PSA_ACCEL_ALG_DETERMINISTIC_ECDSA) */
{
(void)attributes;
(void)key_buffer;
@@ -104,54 +92,42 @@
(void)signature;
(void)signature_size;
(void)signature_length;
- return PSA_ERROR_NOT_SUPPORTED ;
+ return PSA_ERROR_NOT_SUPPORTED;
}
}
-psa_status_t verify_hash(
- const psa_key_attributes_t *attributes,
- 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 )
+psa_status_t verify_hash(const psa_key_attributes_t *attributes,
+ 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)
{
-#if defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PKCS1V15_SIGN) || \
- defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PSS)
- if( PSA_KEY_TYPE_IS_RSA( attributes->core.type ) )
- {
- return( mbedtls_transparent_test_driver_rsa_verify_hash(
- attributes,
- key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_length ) );
- }
- else
-#endif /* defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PKCS1V15_SIGN) ||
- * defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PSS) */
+# if defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PKCS1V15_SIGN) || \
+ defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PSS)
+ if (PSA_KEY_TYPE_IS_RSA(attributes->core.type)) {
+ return (mbedtls_transparent_test_driver_rsa_verify_hash(
+ attributes, key_buffer, key_buffer_size, alg, hash, hash_length,
+ signature, signature_length));
+ } else
+# endif /* defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PKCS1V15_SIGN) || \
+ * defined(MBEDTLS_PSA_ACCEL_ALG_RSA_PSS) */
-#if defined(MBEDTLS_PSA_ACCEL_ALG_ECDSA) || \
- defined(MBEDTLS_PSA_ACCEL_ALG_DETERMINISTIC_ECDSA)
- if( PSA_KEY_TYPE_IS_ECC( attributes->core.type ) )
- {
- if( PSA_ALG_IS_ECDSA( alg ) )
- {
- return( mbedtls_transparent_test_driver_ecdsa_verify_hash(
- attributes,
- key_buffer, key_buffer_size,
- alg, hash, hash_length,
- signature, signature_length ) );
+# if defined(MBEDTLS_PSA_ACCEL_ALG_ECDSA) || \
+ defined(MBEDTLS_PSA_ACCEL_ALG_DETERMINISTIC_ECDSA)
+ if (PSA_KEY_TYPE_IS_ECC(attributes->core.type)) {
+ if (PSA_ALG_IS_ECDSA(alg)) {
+ return (mbedtls_transparent_test_driver_ecdsa_verify_hash(
+ attributes, key_buffer, key_buffer_size, alg, hash, hash_length,
+ signature, signature_length));
+ } else {
+ return PSA_ERROR_INVALID_ARGUMENT;
}
- else
- {
- return PSA_ERROR_INVALID_ARGUMENT ;
- }
- }
- else
-#endif /* defined(MBEDTLS_PSA_ACCEL_ALG_ECDSA) ||
- * defined(MBEDTLS_PSA_ACCEL_ALG_DETERMINISTIC_ECDSA) */
+ } else
+# endif /* defined(MBEDTLS_PSA_ACCEL_ALG_ECDSA) || \
+ * defined(MBEDTLS_PSA_ACCEL_ALG_DETERMINISTIC_ECDSA) */
{
(void)attributes;
(void)key_buffer;
@@ -162,7 +138,7 @@
(void)signature;
(void)signature_length;
- return PSA_ERROR_NOT_SUPPORTED ;
+ return PSA_ERROR_NOT_SUPPORTED;
}
}
@@ -175,7 +151,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;
@@ -183,31 +159,32 @@
++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 );
- *signature_length = 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;
}
status = mbedtls_transparent_test_driver_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);
- 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(
@@ -219,19 +196,19 @@
size_t input_length,
uint8_t *signature,
size_t signature_size,
- size_t *signature_length )
+ size_t *signature_length)
{
- (void) attributes;
- (void) key;
- (void) key_length;
- (void) alg;
- (void) input;
- (void) input_length;
- (void) signature;
- (void) signature_size;
- (void) signature_length;
+ (void)attributes;
+ (void)key;
+ (void)key_length;
+ (void)alg;
+ (void)input;
+ (void)input_length;
+ (void)signature;
+ (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(
@@ -242,7 +219,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;
@@ -250,19 +227,18 @@
++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;
status = mbedtls_transparent_test_driver_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);
- 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(
@@ -273,100 +249,114 @@
const uint8_t *input,
size_t input_length,
const uint8_t *signature,
- size_t signature_length )
+ size_t signature_length)
{
- (void) attributes;
- (void) key;
- (void) key_length;
- (void) alg;
- (void) input;
- (void) input_length;
- (void) signature;
- (void) signature_length;
+ (void)attributes;
+ (void)key;
+ (void)key_length;
+ (void)alg;
+ (void)input;
+ (void)input_length;
+ (void)signature;
+ (void)signature_length;
- return PSA_ERROR_NOT_SUPPORTED ;
+ return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_test_transparent_signature_sign_hash(
const psa_key_attributes_t *attributes,
- const uint8_t *key_buffer, size_t key_buffer_size,
+ 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 )
+ const uint8_t *hash,
+ size_t hash_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_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_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 );
+ 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(
- 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 )
+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)
{
- (void) attributes;
- (void) key;
- (void) key_length;
- (void) alg;
- (void) hash;
- (void) hash_length;
- (void) signature;
- (void) signature_size;
- (void) signature_length;
+ (void)attributes;
+ (void)key;
+ (void)key_length;
+ (void)alg;
+ (void)hash;
+ (void)hash_length;
+ (void)signature;
+ (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(
const psa_key_attributes_t *attributes,
- const uint8_t *key_buffer, size_t key_buffer_size,
+ 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 *hash,
+ size_t hash_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(
const psa_key_attributes_t *attributes,
- const uint8_t *key, size_t key_length,
+ 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 *hash,
+ size_t hash_length,
+ const uint8_t *signature,
+ size_t signature_length)
{
- (void) attributes;
- (void) key;
- (void) key_length;
- (void) alg;
- (void) hash;
- (void) hash_length;
- (void) signature;
- (void) signature_length;
- return PSA_ERROR_NOT_SUPPORTED ;
+ (void)attributes;
+ (void)key;
+ (void)key_length;
+ (void)alg;
+ (void)hash;
+ (void)hash_length;
+ (void)signature;
+ (void)signature_length;
+ 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 837d82a..66d8667 100644
--- a/tests/src/drivers/test_driver_size.c
+++ b/tests/src/drivers/test_driver_size.c
@@ -22,8 +22,8 @@
#if defined(MBEDTLS_PSA_CRYPTO_DRIVERS) && defined(PSA_CRYPTO_DRIVER_TEST)
-#include "test/drivers/size.h"
-#include "psa/crypto.h"
+# include "test/drivers/size.h"
+# include "psa/crypto.h"
typedef struct {
unsigned int context;
@@ -33,7 +33,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.
@@ -42,56 +42,51 @@
* Based on this value, the size of the private key can be derived by
* subtracting the public key size below from this one.
*/
-#define TEST_DRIVER_KEY_CONTEXT_KEY_PAIR_SIZE 65
+# define TEST_DRIVER_KEY_CONTEXT_KEY_PAIR_SIZE 65
/*
* Number of bytes included in every key context for a public key.
*
* For ECC public keys, it needs 257 bits so 33 bytes.
*/
-#define TEST_DRIVER_KEY_CONTEXT_PUBLIC_KEY_SIZE 33
+# define TEST_DRIVER_KEY_CONTEXT_PUBLIC_KEY_SIZE 33
/*
* Every key context for a symmetric key includes this many times the key size.
*/
-#define TEST_DRIVER_KEY_CONTEXT_SYMMETRIC_FACTOR 0
+# define TEST_DRIVER_KEY_CONTEXT_SYMMETRIC_FACTOR 0
/*
- * If this is true for a key pair, the key context includes space for the public key.
- * If this is false, no additional space is added for the public key.
+ * If this is true for a key pair, the key context includes space for the public
+ * key. If this is false, no additional space is added for the public key.
*
* For this instance, store the public key with the private one.
*/
-#define TEST_DRIVER_KEY_CONTEXT_STORE_PUBLIC_KEY 1
+# define TEST_DRIVER_KEY_CONTEXT_STORE_PUBLIC_KEY 1
-size_t mbedtls_test_size_function(
- const psa_key_type_t key_type,
- const size_t key_bits )
+size_t mbedtls_test_size_function(const psa_key_type_t key_type,
+ 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 ) )
- {
- key_buffer_size = TEST_DRIVER_KEY_CONTEXT_BASE_SIZE +
- ( TEST_DRIVER_KEY_CONTEXT_SYMMETRIC_FACTOR *
- ( ( key_bits + 7 ) / 8 ) );
+ } 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));
}
- return key_buffer_size ;
+ return key_buffer_size;
}
#endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */