/* * PSA crypto support for secure element drivers */ /* * Copyright The Mbed TLS Contributors * SPDX-License-Identifier: Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); you may * not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "common.h" #if defined(MBEDTLS_PSA_CRYPTO_SE_C) #include #include #include #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" #if !defined(MBEDTLS_PLATFORM_C) #define mbedtls_calloc calloc #define mbedtls_free free #endif /****************************************************************/ /* 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); #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 /* 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. */ #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) 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 */