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/library/psa_crypto_se.c b/library/psa_crypto_se.c
index 8b185cf..0aefb00 100644
--- a/library/psa_crypto_se.c
+++ b/library/psa_crypto_se.c
@@ -22,28 +22,26 @@
#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
-#include <assert.h>
-#include <stdint.h>
-#include <string.h>
+# include <assert.h>
+# include <stdint.h>
+# include <string.h>
-#include "psa/crypto_se_driver.h"
+# include "psa/crypto_se_driver.h"
-#include "psa_crypto_se.h"
+# include "psa_crypto_se.h"
-#if defined(MBEDTLS_PSA_ITS_FILE_C)
-#include "psa_crypto_its.h"
-#else /* Native ITS implementation */
-#include "psa/error.h"
-#include "psa/internal_trusted_storage.h"
-#endif
+# if defined(MBEDTLS_PSA_ITS_FILE_C)
+# include "psa_crypto_its.h"
+# else /* Native ITS implementation */
+# include "psa/error.h"
+# include "psa/internal_trusted_storage.h"
+# endif
-#include "mbedtls/platform.h"
-#if !defined(MBEDTLS_PLATFORM_C)
-#define mbedtls_calloc calloc
-#define mbedtls_free free
-#endif
-
-
+# include "mbedtls/platform.h"
+# if !defined(MBEDTLS_PLATFORM_C)
+# define mbedtls_calloc calloc
+# define mbedtls_free free
+# endif
/****************************************************************/
/* Driver lookup */
@@ -52,19 +50,16 @@
/* This structure is identical to psa_drv_se_context_t declared in
* `crypto_se_driver.h`, except that some parts are writable here
* (non-const, or pointer to non-const). */
-typedef struct
-{
+typedef struct {
void *persistent_data;
size_t persistent_data_size;
uintptr_t transient_data;
} psa_drv_se_internal_context_t;
-struct psa_se_drv_table_entry_s
-{
+struct psa_se_drv_table_entry_s {
psa_key_location_t location;
const psa_drv_se_t *methods;
- union
- {
+ union {
psa_drv_se_internal_context_t internal;
psa_drv_se_context_t context;
} u;
@@ -72,83 +67,78 @@
static psa_se_drv_table_entry_t driver_table[PSA_MAX_SE_DRIVERS];
-psa_se_drv_table_entry_t *psa_get_se_driver_entry(
- psa_key_lifetime_t lifetime )
+psa_se_drv_table_entry_t *psa_get_se_driver_entry(psa_key_lifetime_t lifetime)
{
size_t i;
- psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION( lifetime );
+ psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime);
/* In the driver table, location=0 means an entry that isn't used.
* No driver has a location of 0 because it's a reserved value
* (which designates transparent keys). Make sure we never return
* a driver entry for location 0. */
- if( location == 0 )
- return NULL ;
- for( i = 0; i < PSA_MAX_SE_DRIVERS; i++ )
- {
- if( driver_table[i].location == location )
- return &driver_table[i] ;
+ if (location == 0)
+ return NULL;
+ for (i = 0; i < PSA_MAX_SE_DRIVERS; i++) {
+ if (driver_table[i].location == location)
+ return &driver_table[i];
}
- return NULL ;
+ return NULL;
}
-const psa_drv_se_t *psa_get_se_driver_methods(
- const psa_se_drv_table_entry_t *driver )
+const psa_drv_se_t *
+psa_get_se_driver_methods(const psa_se_drv_table_entry_t *driver)
{
- return driver->methods ;
+ return driver->methods;
}
-psa_drv_se_context_t *psa_get_se_driver_context(
- psa_se_drv_table_entry_t *driver )
+psa_drv_se_context_t *
+psa_get_se_driver_context(psa_se_drv_table_entry_t *driver)
{
- return &driver->u.context ;
+ return &driver->u.context;
}
-int psa_get_se_driver( psa_key_lifetime_t lifetime,
- const psa_drv_se_t **p_methods,
- psa_drv_se_context_t **p_drv_context)
+int psa_get_se_driver(psa_key_lifetime_t lifetime,
+ const psa_drv_se_t **p_methods,
+ psa_drv_se_context_t **p_drv_context)
{
- psa_se_drv_table_entry_t *driver = psa_get_se_driver_entry( lifetime );
- if( p_methods != NULL )
- *p_methods = ( driver ? driver->methods : NULL );
- if( p_drv_context != NULL )
- *p_drv_context = ( driver ? &driver->u.context : NULL );
- return driver != NULL ;
+ psa_se_drv_table_entry_t *driver = psa_get_se_driver_entry(lifetime);
+ if (p_methods != NULL)
+ *p_methods = (driver ? driver->methods : NULL);
+ if (p_drv_context != NULL)
+ *p_drv_context = (driver ? &driver->u.context : NULL);
+ return driver != NULL;
}
-
-
/****************************************************************/
/* Persistent data management */
/****************************************************************/
-static psa_status_t psa_get_se_driver_its_file_uid(
- const psa_se_drv_table_entry_t *driver,
- psa_storage_uid_t *uid )
+static psa_status_t
+psa_get_se_driver_its_file_uid(const psa_se_drv_table_entry_t *driver,
+ psa_storage_uid_t *uid)
{
- if( driver->location > PSA_MAX_SE_LOCATION )
- return PSA_ERROR_NOT_SUPPORTED ;
+ if (driver->location > PSA_MAX_SE_LOCATION)
+ return PSA_ERROR_NOT_SUPPORTED;
-#if SIZE_MAX > UINT32_MAX
+# if SIZE_MAX > UINT32_MAX
/* ITS file sizes are limited to 32 bits. */
- if( driver->u.internal.persistent_data_size > UINT32_MAX )
- return PSA_ERROR_NOT_SUPPORTED ;
-#endif
+ if (driver->u.internal.persistent_data_size > UINT32_MAX)
+ return PSA_ERROR_NOT_SUPPORTED;
+# endif
/* See the documentation of PSA_CRYPTO_SE_DRIVER_ITS_UID_BASE. */
*uid = PSA_CRYPTO_SE_DRIVER_ITS_UID_BASE + driver->location;
- return PSA_SUCCESS ;
+ return PSA_SUCCESS;
}
-psa_status_t psa_load_se_persistent_data(
- const psa_se_drv_table_entry_t *driver )
+psa_status_t psa_load_se_persistent_data(const psa_se_drv_table_entry_t *driver)
{
psa_status_t status;
psa_storage_uid_t uid;
size_t length;
- status = psa_get_se_driver_its_file_uid( driver, &uid );
- if( status != PSA_SUCCESS )
- return status ;
+ status = psa_get_se_driver_its_file_uid(driver, &uid);
+ if (status != PSA_SUCCESS)
+ return status;
/* Read the amount of persistent data that the driver requests.
* If the data in storage is larger, it is truncated. If the data
@@ -157,97 +147,85 @@
/* psa_get_se_driver_its_file_uid ensures that the size_t
* persistent_data_size is in range, but compilers don't know that,
* so cast to reassure them. */
- return( psa_its_get( uid, 0,
- (uint32_t) driver->u.internal.persistent_data_size,
- driver->u.internal.persistent_data,
- &length ) );
+ return (psa_its_get(uid, 0,
+ (uint32_t)driver->u.internal.persistent_data_size,
+ driver->u.internal.persistent_data, &length));
}
-psa_status_t psa_save_se_persistent_data(
- const psa_se_drv_table_entry_t *driver )
+psa_status_t psa_save_se_persistent_data(const psa_se_drv_table_entry_t *driver)
{
psa_status_t status;
psa_storage_uid_t uid;
- status = psa_get_se_driver_its_file_uid( driver, &uid );
- if( status != PSA_SUCCESS )
- return status ;
+ status = psa_get_se_driver_its_file_uid(driver, &uid);
+ if (status != PSA_SUCCESS)
+ return status;
/* psa_get_se_driver_its_file_uid ensures that the size_t
* persistent_data_size is in range, but compilers don't know that,
* so cast to reassure them. */
- return( psa_its_set( uid,
- (uint32_t) driver->u.internal.persistent_data_size,
- driver->u.internal.persistent_data,
- 0 ) );
+ return (psa_its_set(uid, (uint32_t)driver->u.internal.persistent_data_size,
+ driver->u.internal.persistent_data, 0));
}
-psa_status_t psa_destroy_se_persistent_data( psa_key_location_t location )
+psa_status_t psa_destroy_se_persistent_data(psa_key_location_t location)
{
psa_storage_uid_t uid;
- if( location > PSA_MAX_SE_LOCATION )
- return PSA_ERROR_NOT_SUPPORTED ;
+ if (location > PSA_MAX_SE_LOCATION)
+ return PSA_ERROR_NOT_SUPPORTED;
uid = PSA_CRYPTO_SE_DRIVER_ITS_UID_BASE + location;
- return psa_its_remove( uid ) ;
+ return psa_its_remove(uid);
}
-psa_status_t psa_find_se_slot_for_key(
- const psa_key_attributes_t *attributes,
- psa_key_creation_method_t method,
- psa_se_drv_table_entry_t *driver,
- psa_key_slot_number_t *slot_number )
+psa_status_t psa_find_se_slot_for_key(const psa_key_attributes_t *attributes,
+ psa_key_creation_method_t method,
+ psa_se_drv_table_entry_t *driver,
+ psa_key_slot_number_t *slot_number)
{
psa_status_t status;
psa_key_location_t key_location =
- PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime( attributes ) );
+ PSA_KEY_LIFETIME_GET_LOCATION(psa_get_key_lifetime(attributes));
/* If the location is wrong, it's a bug in the library. */
- if( driver->location != key_location )
- return PSA_ERROR_CORRUPTION_DETECTED ;
+ if (driver->location != key_location)
+ return PSA_ERROR_CORRUPTION_DETECTED;
/* If the driver doesn't support key creation in any way, give up now. */
- if( driver->methods->key_management == NULL )
- return PSA_ERROR_NOT_SUPPORTED ;
+ if (driver->methods->key_management == NULL)
+ return PSA_ERROR_NOT_SUPPORTED;
- if( psa_get_key_slot_number( attributes, slot_number ) == PSA_SUCCESS )
- {
+ if (psa_get_key_slot_number(attributes, slot_number) == PSA_SUCCESS) {
/* The application wants to use a specific slot. Allow it if
* the driver supports it. On a system with isolation,
* the crypto service must check that the application is
* permitted to request this slot. */
psa_drv_se_validate_slot_number_t p_validate_slot_number =
driver->methods->key_management->p_validate_slot_number;
- if( p_validate_slot_number == NULL )
- return PSA_ERROR_NOT_SUPPORTED ;
- status = p_validate_slot_number( &driver->u.context,
- driver->u.internal.persistent_data,
- attributes, method,
- *slot_number );
- }
- else if( method == PSA_KEY_CREATION_REGISTER )
- {
+ if (p_validate_slot_number == NULL)
+ return PSA_ERROR_NOT_SUPPORTED;
+ status = p_validate_slot_number(&driver->u.context,
+ driver->u.internal.persistent_data,
+ attributes, method, *slot_number);
+ } else if (method == PSA_KEY_CREATION_REGISTER) {
/* The application didn't specify a slot number. This doesn't
* make sense when registering a slot. */
- return PSA_ERROR_INVALID_ARGUMENT ;
- }
- else
- {
+ return PSA_ERROR_INVALID_ARGUMENT;
+ } else {
/* The application didn't tell us which slot to use. Let the driver
* choose. This is the normal case. */
psa_drv_se_allocate_key_t p_allocate =
driver->methods->key_management->p_allocate;
- if( p_allocate == NULL )
- return PSA_ERROR_NOT_SUPPORTED ;
- status = p_allocate( &driver->u.context,
- driver->u.internal.persistent_data,
- attributes, method,
- slot_number );
+ if (p_allocate == NULL)
+ return PSA_ERROR_NOT_SUPPORTED;
+ status = p_allocate(&driver->u.context,
+ driver->u.internal.persistent_data, attributes,
+ method, slot_number);
}
- return status ;
+ return status;
}
-psa_status_t psa_destroy_se_key( psa_se_drv_table_entry_t *driver,
- psa_key_slot_number_t slot_number )
+psa_status_t psa_destroy_se_key(psa_se_drv_table_entry_t *driver,
+ psa_key_slot_number_t slot_number)
{
psa_status_t status;
psa_status_t storage_status;
@@ -259,123 +237,109 @@
* locked in a read-only state: we can use the keys but not
* destroy them. Hence, if the driver doesn't support destroying
* keys, it's really a lack of permission. */
- if( driver->methods->key_management == NULL ||
- driver->methods->key_management->p_destroy == NULL )
- return PSA_ERROR_NOT_PERMITTED ;
+ if (driver->methods->key_management == NULL ||
+ driver->methods->key_management->p_destroy == NULL)
+ return PSA_ERROR_NOT_PERMITTED;
status = driver->methods->key_management->p_destroy(
- &driver->u.context,
- driver->u.internal.persistent_data,
- slot_number );
- storage_status = psa_save_se_persistent_data( driver );
- return status == PSA_SUCCESS ? storage_status : status ;
+ &driver->u.context, driver->u.internal.persistent_data, slot_number);
+ storage_status = psa_save_se_persistent_data(driver);
+ return status == PSA_SUCCESS ? storage_status : status;
}
-psa_status_t psa_init_all_se_drivers( void )
+psa_status_t psa_init_all_se_drivers(void)
{
size_t i;
- for( i = 0; i < PSA_MAX_SE_DRIVERS; i++ )
- {
+ for (i = 0; i < PSA_MAX_SE_DRIVERS; i++) {
psa_se_drv_table_entry_t *driver = &driver_table[i];
- if( driver->location == 0 )
+ if (driver->location == 0)
continue; /* skipping unused entry */
- const psa_drv_se_t *methods = psa_get_se_driver_methods( driver );
- if( methods->p_init != NULL )
- {
+ const psa_drv_se_t *methods = psa_get_se_driver_methods(driver);
+ if (methods->p_init != NULL) {
psa_status_t status = methods->p_init(
- &driver->u.context,
- driver->u.internal.persistent_data,
- driver->location );
- if( status != PSA_SUCCESS )
- return status ;
- status = psa_save_se_persistent_data( driver );
- if( status != PSA_SUCCESS )
- return status ;
+ &driver->u.context, driver->u.internal.persistent_data,
+ driver->location);
+ if (status != PSA_SUCCESS)
+ return status;
+ status = psa_save_se_persistent_data(driver);
+ if (status != PSA_SUCCESS)
+ return status;
}
}
- return PSA_SUCCESS ;
+ return PSA_SUCCESS;
}
-
-
/****************************************************************/
/* Driver registration */
/****************************************************************/
-psa_status_t psa_register_se_driver(
- psa_key_location_t location,
- const psa_drv_se_t *methods)
+psa_status_t psa_register_se_driver(psa_key_location_t location,
+ const psa_drv_se_t *methods)
{
size_t i;
psa_status_t status;
- if( methods->hal_version != PSA_DRV_SE_HAL_VERSION )
- return PSA_ERROR_NOT_SUPPORTED ;
- /* Driver table entries are 0-initialized. 0 is not a valid driver
- * location because it means a transparent key. */
-#if defined(static_assert)
- static_assert( PSA_KEY_LOCATION_LOCAL_STORAGE == 0,
- "Secure element support requires 0 to mean a local key" );
-#endif
- if( location == PSA_KEY_LOCATION_LOCAL_STORAGE )
- return PSA_ERROR_INVALID_ARGUMENT ;
- if( location > PSA_MAX_SE_LOCATION )
- return PSA_ERROR_NOT_SUPPORTED ;
+ if (methods->hal_version != PSA_DRV_SE_HAL_VERSION)
+ return PSA_ERROR_NOT_SUPPORTED;
+ /* Driver table entries are 0-initialized. 0 is not a valid driver
+ * location because it means a transparent key. */
+# if defined(static_assert)
+ static_assert(PSA_KEY_LOCATION_LOCAL_STORAGE == 0,
+ "Secure element support requires 0 to mean a local key");
+# endif
+ if (location == PSA_KEY_LOCATION_LOCAL_STORAGE)
+ return PSA_ERROR_INVALID_ARGUMENT;
+ if (location > PSA_MAX_SE_LOCATION)
+ return PSA_ERROR_NOT_SUPPORTED;
- for( i = 0; i < PSA_MAX_SE_DRIVERS; i++ )
- {
- if( driver_table[i].location == 0 )
+ for (i = 0; i < PSA_MAX_SE_DRIVERS; i++) {
+ if (driver_table[i].location == 0)
break;
/* Check that location isn't already in use up to the first free
* entry. Since entries are created in order and never deleted,
* there can't be a used entry after the first free entry. */
- if( driver_table[i].location == location )
- return PSA_ERROR_ALREADY_EXISTS ;
+ if (driver_table[i].location == location)
+ return PSA_ERROR_ALREADY_EXISTS;
}
- if( i == PSA_MAX_SE_DRIVERS )
- return PSA_ERROR_INSUFFICIENT_MEMORY ;
+ if (i == PSA_MAX_SE_DRIVERS)
+ return PSA_ERROR_INSUFFICIENT_MEMORY;
driver_table[i].location = location;
driver_table[i].methods = methods;
driver_table[i].u.internal.persistent_data_size =
methods->persistent_data_size;
- if( methods->persistent_data_size != 0 )
- {
+ if (methods->persistent_data_size != 0) {
driver_table[i].u.internal.persistent_data =
- mbedtls_calloc( 1, methods->persistent_data_size );
- if( driver_table[i].u.internal.persistent_data == NULL )
- {
+ mbedtls_calloc(1, methods->persistent_data_size);
+ if (driver_table[i].u.internal.persistent_data == NULL) {
status = PSA_ERROR_INSUFFICIENT_MEMORY;
goto error;
}
/* Load the driver's persistent data. On first use, the persistent
* data does not exist in storage, and is initialized to
* all-bits-zero by the calloc call just above. */
- status = psa_load_se_persistent_data( &driver_table[i] );
- if( status != PSA_SUCCESS && status != PSA_ERROR_DOES_NOT_EXIST )
+ status = psa_load_se_persistent_data(&driver_table[i]);
+ if (status != PSA_SUCCESS && status != PSA_ERROR_DOES_NOT_EXIST)
goto error;
}
- return PSA_SUCCESS ;
+ return PSA_SUCCESS;
error:
- memset( &driver_table[i], 0, sizeof( driver_table[i] ) );
- return status ;
+ memset(&driver_table[i], 0, sizeof(driver_table[i]));
+ return status;
}
-void psa_unregister_all_se_drivers( void )
+void psa_unregister_all_se_drivers(void)
{
size_t i;
- for( i = 0; i < PSA_MAX_SE_DRIVERS; i++ )
- {
- if( driver_table[i].u.internal.persistent_data != NULL )
- mbedtls_free( driver_table[i].u.internal.persistent_data );
+ for (i = 0; i < PSA_MAX_SE_DRIVERS; i++) {
+ if (driver_table[i].u.internal.persistent_data != NULL)
+ mbedtls_free(driver_table[i].u.internal.persistent_data);
}
- memset( driver_table, 0, sizeof( driver_table ) );
+ memset(driver_table, 0, sizeof(driver_table));
}
-
-
/****************************************************************/
/* The end */
/****************************************************************/