mirror of
https://github.com/RfidResearchGroup/proxmark3.git
synced 2025-08-21 05:43:48 -07:00
mbedtls: make style
This commit is contained in:
Philippe Teuwen
parent
6324e2e746
commit
b1d6eaf2f7
177 changed files with 37224 additions and 41821 deletions
|
|
@ -52,19 +52,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;
|
||||
|
|
@ -73,46 +70,41 @@ struct psa_se_drv_table_entry_s
|
|||
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_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 )
|
||||
{
|
||||
return( driver->methods );
|
||||
const psa_se_drv_table_entry_t *driver) {
|
||||
return (driver->methods);
|
||||
}
|
||||
|
||||
psa_drv_se_context_t *psa_get_se_driver_context(
|
||||
psa_se_drv_table_entry_t *driver )
|
||||
{
|
||||
return( &driver->u.context );
|
||||
psa_se_drv_table_entry_t *driver) {
|
||||
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)
|
||||
{
|
||||
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 );
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -123,32 +115,30 @@ int psa_get_se_driver( psa_key_lifetime_t lifetime,
|
|||
|
||||
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 );
|
||||
psa_storage_uid_t *uid) {
|
||||
if (driver->location > PSA_MAX_SE_LOCATION)
|
||||
return (PSA_ERROR_NOT_SUPPORTED);
|
||||
|
||||
#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 );
|
||||
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 )
|
||||
{
|
||||
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,98 +147,89 @@ psa_status_t psa_load_se_persistent_data(
|
|||
/* 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 )
|
||||
{
|
||||
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_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;
|
||||
/* Normally a missing method would mean that the action is not
|
||||
|
|
@ -259,40 +240,37 @@ psa_status_t psa_destroy_se_key( psa_se_drv_table_entry_t *driver,
|
|||
* 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);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -303,75 +281,69 @@ psa_status_t psa_init_all_se_drivers( void )
|
|||
|
||||
psa_status_t psa_register_se_driver(
|
||||
psa_key_location_t location,
|
||||
const psa_drv_se_t *methods)
|
||||
{
|
||||
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 );
|
||||
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" );
|
||||
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 (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));
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue