| /* |
| * PSA crypto support for secure element drivers |
| */ |
| /* |
| * Copyright The Mbed TLS Contributors |
| * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later |
| */ |
| |
| #include "common.h" |
| |
| #if defined(MBEDTLS_PSA_CRYPTO_SE_C) |
| |
| #include <stdint.h> |
| #include <string.h> |
| |
| #include "psa/crypto_se_driver.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 |
| |
| #include "mbedtls/platform.h" |
| |
| |
| |
| /****************************************************************/ |
| /* Driver lookup */ |
| /****************************************************************/ |
| |
| /* 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 { |
| 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 { |
| psa_key_location_t location; |
| const psa_drv_se_t *methods; |
| union { |
| psa_drv_se_internal_context_t internal; |
| psa_drv_se_context_t context; |
| } u; |
| }; |
| |
| 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) |
| { |
| size_t i; |
| 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]; |
| } |
| } |
| return NULL; |
| } |
| |
| const psa_drv_se_t *psa_get_se_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; |
| } |
| |
| 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; |
| } |
| |
| |
| |
| /****************************************************************/ |
| /* 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) |
| { |
| if (driver->location > PSA_MAX_SE_LOCATION) { |
| return PSA_ERROR_NOT_SUPPORTED; |
| } |
| |
| /* ITS file sizes are limited to 32 bits. */ |
| if (driver->u.internal.persistent_data_size > UINT32_MAX) { |
| return PSA_ERROR_NOT_SUPPORTED; |
| } |
| |
| /* See the documentation of PSA_CRYPTO_SE_DRIVER_ITS_UID_BASE. */ |
| *uid = PSA_CRYPTO_SE_DRIVER_ITS_UID_BASE + driver->location; |
| return PSA_SUCCESS; |
| } |
| |
| 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; |
| } |
| |
| /* Read the amount of persistent data that the driver requests. |
| * If the data in storage is larger, it is truncated. If the data |
| * in storage is smaller, silently keep what is already at the end |
| * of the output buffer. */ |
| /* 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); |
| } |
| |
| 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; |
| } |
| |
| /* 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); |
| } |
| |
| 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; |
| } |
| uid = PSA_CRYPTO_SE_DRIVER_ITS_UID_BASE + location; |
| 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 status; |
| psa_key_location_t key_location = |
| 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 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 (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) { |
| /* The application didn't specify a slot number. This doesn't |
| * make sense when registering a slot. */ |
| 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); |
| } |
| 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 status; |
| psa_status_t storage_status; |
| /* Normally a missing method would mean that the action is not |
| * supported. But psa_destroy_key() is not supposed to return |
| * PSA_ERROR_NOT_SUPPORTED: if you can create a key, you should |
| * be able to destroy it. The only use case for a driver that |
| * does not have a way to destroy keys at all is if the keys are |
| * 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; |
| } |
| 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; |
| } |
| |
| psa_status_t psa_init_all_se_drivers(void) |
| { |
| size_t i; |
| for (i = 0; i < PSA_MAX_SE_DRIVERS; i++) { |
| psa_se_drv_table_entry_t *driver = &driver_table[i]; |
| 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) { |
| 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; |
| } |
| } |
| } |
| return PSA_SUCCESS; |
| } |
| |
| |
| |
| /****************************************************************/ |
| /* Driver registration */ |
| /****************************************************************/ |
| |
| 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. */ |
| MBEDTLS_STATIC_ASSERT(PSA_KEY_LOCATION_LOCAL_STORAGE == 0, |
| "Secure element support requires 0 to mean a local key"); |
| |
| 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) { |
| 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 (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) { |
| driver_table[i].u.internal.persistent_data = |
| 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) { |
| goto error; |
| } |
| } |
| |
| return PSA_SUCCESS; |
| |
| error: |
| memset(&driver_table[i], 0, sizeof(driver_table[i])); |
| return status; |
| } |
| |
| 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); |
| } |
| } |
| memset(driver_table, 0, sizeof(driver_table)); |
| } |
| |
| |
| |
| /****************************************************************/ |
| /* The end */ |
| /****************************************************************/ |
| |
| #endif /* MBEDTLS_PSA_CRYPTO_SE_C */ |
