| /* BEGIN_HEADER */ |
| #include "psa/crypto_se_driver.h" |
| |
| #include "psa_crypto_se.h" |
| #include "psa_crypto_slot_management.h" |
| #include "psa_crypto_storage.h" |
| |
| /* Invasive peeking: check the persistent data */ |
| #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 |
| |
| |
| /****************************************************************/ |
| /* Test driver helpers */ |
| /****************************************************************/ |
| |
| /** The minimum valid location value for a secure element driver. */ |
| #define MIN_DRIVER_LOCATION 1 |
| |
| /** The location and lifetime used for tests that use a single driver. */ |
| #define TEST_DRIVER_LOCATION 1 |
| #define TEST_SE_PERSISTENT_LIFETIME \ |
| (PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION( \ |
| PSA_KEY_PERSISTENCE_DEFAULT, TEST_DRIVER_LOCATION)) |
| |
| #define TEST_SE_VOLATILE_LIFETIME \ |
| (PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION( \ |
| PSA_KEY_PERSISTENCE_VOLATILE, TEST_DRIVER_LOCATION)) |
| |
| /** The driver detected a condition that shouldn't happen. |
| * This is probably a bug in the library. */ |
| #define PSA_ERROR_DETECTED_BY_DRIVER ((psa_status_t) (-500)) |
| |
| /** Like #TEST_ASSERT for use in a driver method, with no cleanup. |
| * |
| * If an error happens, this macro returns from the calling function. |
| * |
| * Use this macro to assert on guarantees provided by the core. |
| */ |
| #define DRIVER_ASSERT_RETURN(TEST) \ |
| do { \ |
| if (!(TEST)) \ |
| { \ |
| mbedtls_test_fail( #TEST, __LINE__, __FILE__); \ |
| return PSA_ERROR_DETECTED_BY_DRIVER; \ |
| } \ |
| } while (0) |
| |
| /** Like #TEST_ASSERT for use in a driver method, with cleanup. |
| * |
| * In case of error, this macro sets `status` and jumps to the |
| * label `exit`. |
| * |
| * Use this macro to assert on guarantees provided by the core. |
| */ |
| #define DRIVER_ASSERT(TEST) \ |
| do { \ |
| if (!(TEST)) \ |
| { \ |
| mbedtls_test_fail( #TEST, __LINE__, __FILE__); \ |
| status = PSA_ERROR_DETECTED_BY_DRIVER; \ |
| goto exit; \ |
| } \ |
| } while (0) |
| |
| /** Like #PSA_ASSERT for a PSA API call that calls a driver underneath. |
| * |
| * Run the code \p expr. If this returns \p expected_status, |
| * do nothing. If this returns #PSA_ERROR_DETECTED_BY_DRIVER, |
| * jump directly to the `exit` label. If this returns any other |
| * status, call mbedtls_test_fail() then jump to `exit`. |
| * |
| * The special case for #PSA_ERROR_DETECTED_BY_DRIVER is because in this |
| * case, the test driver code is expected to have called mbedtls_test_fail() |
| * already, so we make sure not to overwrite the failure information. |
| */ |
| #define PSA_ASSERT_VIA_DRIVER(expr, expected_status) \ |
| do { \ |
| psa_status_t PSA_ASSERT_VIA_DRIVER_status = (expr); \ |
| if (PSA_ASSERT_VIA_DRIVER_status == PSA_ERROR_DETECTED_BY_DRIVER) \ |
| goto exit; \ |
| if (PSA_ASSERT_VIA_DRIVER_status != (expected_status)) \ |
| { \ |
| mbedtls_test_fail( #expr, __LINE__, __FILE__); \ |
| goto exit; \ |
| } \ |
| } while (0) |
| |
| |
| |
| /****************************************************************/ |
| /* Domain support functions */ |
| /****************************************************************/ |
| |
| /* Return the exact bit size given a curve family and a byte length. */ |
| static size_t ecc_curve_bits(psa_ecc_family_t curve, size_t data_length) |
| { |
| switch (curve) { |
| case PSA_ECC_FAMILY_SECP_R1: |
| if (data_length == PSA_BYTES_TO_BITS(521)) { |
| return 521; |
| } |
| break; |
| case PSA_ECC_FAMILY_MONTGOMERY: |
| if (data_length == PSA_BYTES_TO_BITS(255)) { |
| return 255; |
| } |
| } |
| /* If not listed above, assume a multiple of 8 bits. */ |
| return PSA_BYTES_TO_BITS(data_length); |
| } |
| |
| |
| /****************************************************************/ |
| /* Miscellaneous driver methods */ |
| /****************************************************************/ |
| |
| typedef struct { |
| psa_key_slot_number_t slot_number; |
| psa_key_creation_method_t method; |
| psa_status_t status; |
| } validate_slot_number_directions_t; |
| static validate_slot_number_directions_t validate_slot_number_directions; |
| |
| /* Validate a choice of slot number as directed. */ |
| static psa_status_t validate_slot_number_as_directed( |
| psa_drv_se_context_t *context, |
| void *persistent_data, |
| const psa_key_attributes_t *attributes, |
| psa_key_creation_method_t method, |
| psa_key_slot_number_t slot_number) |
| { |
| (void) context; |
| (void) persistent_data; |
| (void) attributes; |
| DRIVER_ASSERT_RETURN(slot_number == |
| validate_slot_number_directions.slot_number); |
| DRIVER_ASSERT_RETURN(method == |
| validate_slot_number_directions.method); |
| return validate_slot_number_directions.status; |
| } |
| |
| /* Allocate slot numbers with a monotonic counter. */ |
| static psa_key_slot_number_t shadow_counter; |
| static void counter_reset(void) |
| { |
| shadow_counter = 0; |
| } |
| static psa_status_t counter_allocate(psa_drv_se_context_t *context, |
| void *persistent_data, |
| const psa_key_attributes_t *attributes, |
| psa_key_creation_method_t method, |
| psa_key_slot_number_t *slot_number) |
| { |
| psa_key_slot_number_t *p_counter = persistent_data; |
| (void) attributes; |
| (void) method; |
| if (context->persistent_data_size != sizeof(psa_key_slot_number_t)) { |
| return PSA_ERROR_DETECTED_BY_DRIVER; |
| } |
| ++*p_counter; |
| if (*p_counter == 0) { |
| return PSA_ERROR_INSUFFICIENT_STORAGE; |
| } |
| shadow_counter = *p_counter; |
| *slot_number = *p_counter; |
| return PSA_SUCCESS; |
| } |
| |
| /* Null import: do nothing, but pretend it worked. */ |
| #if defined(AT_LEAST_ONE_BUILTIN_KDF) |
| static psa_status_t null_import(psa_drv_se_context_t *context, |
| psa_key_slot_number_t slot_number, |
| const psa_key_attributes_t *attributes, |
| const uint8_t *data, |
| size_t data_length, |
| size_t *bits) |
| { |
| (void) context; |
| (void) slot_number; |
| (void) attributes; |
| (void) data; |
| /* We're supposed to return a key size. Return one that's correct for |
| * plain data keys. */ |
| *bits = PSA_BYTES_TO_BITS(data_length); |
| return PSA_SUCCESS; |
| } |
| #endif /* AT_LEAST_ONE_BUILTIN_KDF */ |
| |
| /* Null generate: do nothing, but pretend it worked. */ |
| #if defined(AT_LEAST_ONE_BUILTIN_KDF) |
| static psa_status_t null_generate(psa_drv_se_context_t *context, |
| psa_key_slot_number_t slot_number, |
| const psa_key_attributes_t *attributes, |
| uint8_t *pubkey, |
| size_t pubkey_size, |
| size_t *pubkey_length) |
| { |
| (void) context; |
| (void) slot_number; |
| (void) attributes; |
| |
| DRIVER_ASSERT_RETURN(*pubkey_length == 0); |
| if (!PSA_KEY_TYPE_IS_KEY_PAIR(psa_get_key_type(attributes))) { |
| DRIVER_ASSERT_RETURN(pubkey == NULL); |
| DRIVER_ASSERT_RETURN(pubkey_size == 0); |
| } |
| |
| return PSA_SUCCESS; |
| } |
| #endif /* AT_LEAST_ONE_BUILTIN_KDF */ |
| |
| /* Null destroy: do nothing, but pretend it worked. */ |
| static psa_status_t null_destroy(psa_drv_se_context_t *context, |
| void *persistent_data, |
| psa_key_slot_number_t slot_number) |
| { |
| (void) context; |
| (void) persistent_data; |
| (void) slot_number; |
| return PSA_SUCCESS; |
| } |
| |
| |
| |
| /****************************************************************/ |
| /* RAM-based test driver */ |
| /****************************************************************/ |
| |
| #define RAM_MAX_KEY_SIZE 64 |
| typedef struct { |
| psa_key_lifetime_t lifetime; |
| psa_key_type_t type; |
| size_t bits; |
| uint8_t content[RAM_MAX_KEY_SIZE]; |
| } ram_slot_t; |
| static ram_slot_t ram_slots[16]; |
| |
| /* A type with at least ARRAY_LENGTH(ram_slots) bits, containing a |
| * bit vector indicating which slots are in use. */ |
| typedef uint16_t ram_slot_usage_t; |
| |
| static ram_slot_usage_t ram_shadow_slot_usage; |
| |
| static uint8_t ram_min_slot = 0; |
| |
| static void ram_slots_reset(void) |
| { |
| memset(ram_slots, 0, sizeof(ram_slots)); |
| ram_min_slot = 0; |
| ram_shadow_slot_usage = 0; |
| } |
| |
| /* Common parts of key creation. |
| * |
| * In case of error, zero out ram_slots[slot_number]. But don't |
| * do that if the error is PSA_ERROR_DETECTED_BY_DRIVER: in this case |
| * you don't need to clean up (ram_slot_reset() will take care of it |
| * in the test case function's cleanup code) and it might be wrong |
| * (if slot_number is invalid). |
| */ |
| static psa_status_t ram_create_common(psa_drv_se_context_t *context, |
| psa_key_slot_number_t slot_number, |
| const psa_key_attributes_t *attributes, |
| size_t required_storage) |
| { |
| (void) context; |
| DRIVER_ASSERT_RETURN(slot_number < ARRAY_LENGTH(ram_slots)); |
| |
| ram_slots[slot_number].lifetime = psa_get_key_lifetime(attributes); |
| ram_slots[slot_number].type = psa_get_key_type(attributes); |
| ram_slots[slot_number].bits = psa_get_key_bits(attributes); |
| |
| if (required_storage > sizeof(ram_slots[slot_number].content)) { |
| memset(&ram_slots[slot_number], 0, sizeof(ram_slots[slot_number])); |
| return PSA_ERROR_INSUFFICIENT_STORAGE; |
| } |
| |
| return PSA_SUCCESS; |
| } |
| |
| /* This function does everything except actually generating key material. |
| * After calling it, you must copy the desired key material to |
| * ram_slots[slot_number].content. */ |
| static psa_status_t ram_fake_generate(psa_drv_se_context_t *context, |
| psa_key_slot_number_t slot_number, |
| const psa_key_attributes_t *attributes, |
| uint8_t *pubkey, |
| size_t pubkey_size, |
| size_t *pubkey_length) |
| { |
| psa_status_t status; |
| size_t required_storage = |
| PSA_EXPORT_KEY_OUTPUT_SIZE(psa_get_key_type(attributes), |
| psa_get_key_bits(attributes)); |
| |
| DRIVER_ASSERT_RETURN(*pubkey_length == 0); |
| if (!PSA_KEY_TYPE_IS_KEY_PAIR(psa_get_key_type(attributes))) { |
| DRIVER_ASSERT_RETURN(pubkey == NULL); |
| DRIVER_ASSERT_RETURN(pubkey_size == 0); |
| } |
| |
| status = ram_create_common(context, slot_number, attributes, |
| required_storage); |
| return status; |
| } |
| |
| static psa_status_t ram_import(psa_drv_se_context_t *context, |
| psa_key_slot_number_t slot_number, |
| const psa_key_attributes_t *attributes, |
| const uint8_t *data, |
| size_t data_length, |
| size_t *bits) |
| { |
| psa_key_type_t type = psa_get_key_type(attributes); |
| psa_status_t status = ram_create_common(context, slot_number, attributes, |
| data_length); |
| if (status != PSA_SUCCESS) { |
| return status; |
| } |
| |
| /* The RAM driver only works for certain key types: raw keys, |
| * and ECC key pairs. This is true in particular of the bit-size |
| * calculation here. */ |
| if (PSA_KEY_TYPE_IS_UNSTRUCTURED(type)) { |
| *bits = PSA_BYTES_TO_BITS(data_length); |
| } else if (PSA_KEY_TYPE_IS_ECC_KEY_PAIR(type)) { |
| *bits = ecc_curve_bits(PSA_KEY_TYPE_ECC_GET_FAMILY(type), data_length); |
| if (*bits == 0) { |
| return PSA_ERROR_DETECTED_BY_DRIVER; |
| } |
| } else { |
| memset(&ram_slots[slot_number], 0, sizeof(ram_slots[slot_number])); |
| return PSA_ERROR_NOT_SUPPORTED; |
| } |
| |
| ram_slots[slot_number].bits = *bits; |
| memcpy(ram_slots[slot_number].content, data, data_length); |
| |
| return PSA_SUCCESS; |
| } |
| |
| static psa_status_t ram_export(psa_drv_se_context_t *context, |
| psa_key_slot_number_t slot_number, |
| uint8_t *data, |
| size_t data_size, |
| size_t *data_length) |
| { |
| size_t actual_size; |
| (void) context; |
| DRIVER_ASSERT_RETURN(slot_number < ARRAY_LENGTH(ram_slots)); |
| actual_size = PSA_BITS_TO_BYTES(ram_slots[slot_number].bits); |
| if (actual_size > data_size) { |
| return PSA_ERROR_BUFFER_TOO_SMALL; |
| } |
| *data_length = actual_size; |
| memcpy(data, ram_slots[slot_number].content, actual_size); |
| return PSA_SUCCESS; |
| } |
| |
| static psa_status_t ram_export_public(psa_drv_se_context_t *context, |
| psa_key_slot_number_t slot_number, |
| uint8_t *data, |
| size_t data_size, |
| size_t *data_length) |
| { |
| psa_status_t status; |
| mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| |
| (void) context; |
| DRIVER_ASSERT_RETURN(slot_number < ARRAY_LENGTH(ram_slots)); |
| DRIVER_ASSERT_RETURN( |
| PSA_KEY_TYPE_IS_KEY_PAIR(ram_slots[slot_number].type)); |
| |
| psa_set_key_type(&attributes, ram_slots[slot_number].type); |
| status = psa_import_key(&attributes, |
| ram_slots[slot_number].content, |
| PSA_BITS_TO_BYTES(ram_slots[slot_number].bits), |
| &key); |
| if (status != PSA_SUCCESS) { |
| return status; |
| } |
| status = psa_export_public_key(key, data, data_size, data_length); |
| psa_destroy_key(key); |
| return PSA_SUCCESS; |
| } |
| |
| static psa_status_t ram_destroy(psa_drv_se_context_t *context, |
| void *persistent_data, |
| psa_key_slot_number_t slot_number) |
| { |
| ram_slot_usage_t *slot_usage = persistent_data; |
| DRIVER_ASSERT_RETURN(context->persistent_data_size == sizeof(ram_slot_usage_t)); |
| DRIVER_ASSERT_RETURN(slot_number < ARRAY_LENGTH(ram_slots)); |
| memset(&ram_slots[slot_number], 0, sizeof(ram_slots[slot_number])); |
| *slot_usage &= ~(ram_slot_usage_t) (1 << slot_number); |
| ram_shadow_slot_usage = *slot_usage; |
| return PSA_SUCCESS; |
| } |
| |
| static psa_status_t ram_allocate(psa_drv_se_context_t *context, |
| void *persistent_data, |
| const psa_key_attributes_t *attributes, |
| psa_key_creation_method_t method, |
| psa_key_slot_number_t *slot_number) |
| { |
| ram_slot_usage_t *slot_usage = persistent_data; |
| (void) attributes; |
| (void) method; |
| DRIVER_ASSERT_RETURN(context->persistent_data_size == sizeof(ram_slot_usage_t)); |
| for (*slot_number = ram_min_slot; |
| *slot_number < ARRAY_LENGTH(ram_slots); |
| ++(*slot_number)) { |
| if (!(*slot_usage & 1 << *slot_number)) { |
| ram_shadow_slot_usage = *slot_usage; |
| return PSA_SUCCESS; |
| } |
| } |
| return PSA_ERROR_INSUFFICIENT_STORAGE; |
| } |
| |
| static psa_status_t ram_validate_slot_number( |
| psa_drv_se_context_t *context, |
| void *persistent_data, |
| const psa_key_attributes_t *attributes, |
| psa_key_creation_method_t method, |
| psa_key_slot_number_t slot_number) |
| { |
| (void) context; |
| (void) persistent_data; |
| (void) attributes; |
| (void) method; |
| if (slot_number >= ARRAY_LENGTH(ram_slots)) { |
| return PSA_ERROR_INVALID_ARGUMENT; |
| } |
| return PSA_SUCCESS; |
| } |
| |
| static psa_status_t ram_sign(psa_drv_se_context_t *context, |
| psa_key_slot_number_t slot_number, |
| psa_algorithm_t alg, |
| const uint8_t *hash, |
| size_t hash_length, |
| uint8_t *signature, |
| size_t signature_size, |
| size_t *signature_length) |
| { |
| ram_slot_t *slot; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT; |
| psa_status_t status = PSA_ERROR_GENERIC_ERROR; |
| |
| (void) context; |
| DRIVER_ASSERT_RETURN(slot_number < ARRAY_LENGTH(ram_slots)); |
| slot = &ram_slots[slot_number]; |
| |
| psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH); |
| psa_set_key_algorithm(&attributes, alg); |
| psa_set_key_type(&attributes, slot->type); |
| DRIVER_ASSERT(psa_import_key(&attributes, |
| slot->content, |
| PSA_BITS_TO_BYTES(slot->bits), |
| &key) == PSA_SUCCESS); |
| status = psa_sign_hash(key, alg, |
| hash, hash_length, |
| signature, signature_size, signature_length); |
| |
| exit: |
| psa_destroy_key(key); |
| return status; |
| } |
| |
| static psa_status_t ram_verify(psa_drv_se_context_t *context, |
| psa_key_slot_number_t slot_number, |
| psa_algorithm_t alg, |
| const uint8_t *hash, |
| size_t hash_length, |
| const uint8_t *signature, |
| size_t signature_length) |
| { |
| ram_slot_t *slot; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT; |
| psa_status_t status = PSA_ERROR_GENERIC_ERROR; |
| |
| (void) context; |
| DRIVER_ASSERT_RETURN(slot_number < ARRAY_LENGTH(ram_slots)); |
| slot = &ram_slots[slot_number]; |
| |
| psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_HASH); |
| psa_set_key_algorithm(&attributes, alg); |
| psa_set_key_type(&attributes, slot->type); |
| DRIVER_ASSERT(psa_import_key(&attributes, |
| slot->content, |
| PSA_BITS_TO_BYTES(slot->bits), |
| &key) == |
| PSA_SUCCESS); |
| status = psa_verify_hash(key, alg, |
| hash, hash_length, |
| signature, signature_length); |
| |
| exit: |
| psa_destroy_key(key); |
| return status; |
| } |
| |
| |
| /****************************************************************/ |
| /* Other test helper functions */ |
| /****************************************************************/ |
| |
| typedef enum { |
| SIGN_IN_SOFTWARE_AND_PARALLEL_CREATION, |
| SIGN_IN_DRIVER_AND_PARALLEL_CREATION, |
| SIGN_IN_DRIVER_THEN_EXPORT_PUBLIC, |
| } sign_verify_method_t; |
| |
| /* Check that the attributes of a key reported by psa_get_key_attributes() |
| * are consistent with the attributes used when creating the key. */ |
| static int check_key_attributes( |
| mbedtls_svc_key_id_t key, |
| const psa_key_attributes_t *reference_attributes) |
| { |
| int ok = 0; |
| psa_key_attributes_t actual_attributes = PSA_KEY_ATTRIBUTES_INIT; |
| |
| PSA_ASSERT(psa_get_key_attributes(key, &actual_attributes)); |
| |
| TEST_ASSERT(mbedtls_svc_key_id_equal( |
| psa_get_key_id(&actual_attributes), |
| psa_get_key_id(reference_attributes))); |
| TEST_EQUAL(psa_get_key_lifetime(&actual_attributes), |
| psa_get_key_lifetime(reference_attributes)); |
| TEST_EQUAL(psa_get_key_type(&actual_attributes), |
| psa_get_key_type(reference_attributes)); |
| TEST_EQUAL(psa_get_key_usage_flags(&actual_attributes), |
| psa_get_key_usage_flags(reference_attributes)); |
| TEST_EQUAL(psa_get_key_algorithm(&actual_attributes), |
| psa_get_key_algorithm(reference_attributes)); |
| TEST_EQUAL(psa_get_key_enrollment_algorithm(&actual_attributes), |
| psa_get_key_enrollment_algorithm(reference_attributes)); |
| if (psa_get_key_bits(reference_attributes) != 0) { |
| TEST_EQUAL(psa_get_key_bits(&actual_attributes), |
| psa_get_key_bits(reference_attributes)); |
| } |
| |
| { |
| psa_key_slot_number_t actual_slot_number = 0xdeadbeef; |
| psa_key_slot_number_t desired_slot_number = 0xb90cc011; |
| psa_key_lifetime_t lifetime = |
| psa_get_key_lifetime(&actual_attributes); |
| psa_status_t status = psa_get_key_slot_number(&actual_attributes, |
| &actual_slot_number); |
| if (PSA_KEY_LIFETIME_GET_LOCATION(lifetime) < MIN_DRIVER_LOCATION) { |
| /* The key is not in a secure element. */ |
| TEST_EQUAL(status, PSA_ERROR_INVALID_ARGUMENT); |
| } else { |
| /* The key is in a secure element. If it had been created |
| * in a specific slot, check that it is reported there. */ |
| PSA_ASSERT(status); |
| status = psa_get_key_slot_number(reference_attributes, |
| &desired_slot_number); |
| if (status == PSA_SUCCESS) { |
| TEST_EQUAL(desired_slot_number, actual_slot_number); |
| } |
| } |
| } |
| ok = 1; |
| |
| exit: |
| /* |
| * Actual key attributes may have been returned by psa_get_key_attributes() |
| * thus reset them as required. |
| */ |
| psa_reset_key_attributes(&actual_attributes); |
| |
| return ok; |
| } |
| |
| /* Get the file UID corresponding to the specified location. |
| * If this changes, the storage format version must change. |
| * See psa_get_se_driver_its_file_uid() in psa_crypto_se.c. |
| */ |
| psa_storage_uid_t file_uid_for_location(psa_key_location_t location) |
| { |
| if (location > PSA_MAX_SE_LOCATION) { |
| return 0; |
| } |
| return 0xfffffe00 + location; |
| } |
| |
| /* Check that the persistent data of a driver has its expected content. */ |
| static int check_persistent_data(psa_key_location_t location, |
| const void *expected_data, |
| size_t size) |
| { |
| psa_storage_uid_t uid = file_uid_for_location(location); |
| struct psa_storage_info_t info; |
| uint8_t *loaded = NULL; |
| int ok = 0; |
| |
| PSA_ASSERT(psa_its_get_info(uid, &info)); |
| TEST_CALLOC(loaded, info.size); |
| PSA_ASSERT(psa_its_get(uid, 0, info.size, loaded, NULL)); |
| TEST_MEMORY_COMPARE(expected_data, size, loaded, info.size); |
| ok = 1; |
| |
| exit: |
| mbedtls_free(loaded); |
| return ok; |
| } |
| |
| /* Check that no persistent data exists for the given location. */ |
| static int check_no_persistent_data(psa_key_location_t location) |
| { |
| psa_storage_uid_t uid = file_uid_for_location(location); |
| struct psa_storage_info_t info; |
| int ok = 0; |
| |
| TEST_EQUAL(psa_its_get_info(uid, &info), PSA_ERROR_DOES_NOT_EXIST); |
| ok = 1; |
| |
| exit: |
| return ok; |
| } |
| |
| /* Check that a function's return status is "smoke-free", i.e. that |
| * it's an acceptable error code when calling an API function that operates |
| * on a key with potentially bogus parameters. */ |
| #if defined(AT_LEAST_ONE_BUILTIN_KDF) |
| static int is_status_smoke_free(psa_status_t status) |
| { |
| switch (status) { |
| case PSA_SUCCESS: |
| case PSA_ERROR_NOT_SUPPORTED: |
| case PSA_ERROR_NOT_PERMITTED: |
| case PSA_ERROR_BUFFER_TOO_SMALL: |
| case PSA_ERROR_INVALID_ARGUMENT: |
| case PSA_ERROR_INVALID_SIGNATURE: |
| case PSA_ERROR_INVALID_PADDING: |
| return 1; |
| default: |
| return 0; |
| } |
| } |
| #endif /* AT_LEAST_ONE_BUILTIN_KDF */ |
| |
| #define SMOKE_ASSERT(expr) \ |
| TEST_ASSERT(is_status_smoke_free(expr)) |
| |
| /* Smoke test a key. There are mostly no wrong answers here since we pass |
| * mostly bogus parameters: the goal is to ensure that there is no memory |
| * corruption or crash. This test function is most useful when run under |
| * an environment with sanity checks such as ASan or MSan. */ |
| #if defined(AT_LEAST_ONE_BUILTIN_KDF) |
| static int smoke_test_key(mbedtls_svc_key_id_t key) |
| { |
| int ok = 0; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| psa_mac_operation_t mac_operation = PSA_MAC_OPERATION_INIT; |
| psa_cipher_operation_t cipher_operation = PSA_CIPHER_OPERATION_INIT; |
| psa_key_derivation_operation_t derivation_operation = |
| PSA_KEY_DERIVATION_OPERATION_INIT; |
| uint8_t buffer[80]; /* large enough for a public key for ECDH */ |
| size_t length; |
| mbedtls_svc_key_id_t key2 = MBEDTLS_SVC_KEY_ID_INIT; |
| |
| SMOKE_ASSERT(psa_get_key_attributes(key, &attributes)); |
| |
| SMOKE_ASSERT(psa_export_key(key, |
| buffer, sizeof(buffer), &length)); |
| SMOKE_ASSERT(psa_export_public_key(key, |
| buffer, sizeof(buffer), &length)); |
| |
| SMOKE_ASSERT(psa_copy_key(key, &attributes, &key2)); |
| if (!mbedtls_svc_key_id_is_null(key2)) { |
| PSA_ASSERT(psa_destroy_key(key2)); |
| } |
| |
| SMOKE_ASSERT(psa_mac_sign_setup(&mac_operation, key, PSA_ALG_CMAC)); |
| PSA_ASSERT(psa_mac_abort(&mac_operation)); |
| SMOKE_ASSERT(psa_mac_verify_setup(&mac_operation, key, |
| PSA_ALG_HMAC(PSA_ALG_SHA_256))); |
| PSA_ASSERT(psa_mac_abort(&mac_operation)); |
| |
| SMOKE_ASSERT(psa_cipher_encrypt_setup(&cipher_operation, key, |
| PSA_ALG_CTR)); |
| PSA_ASSERT(psa_cipher_abort(&cipher_operation)); |
| SMOKE_ASSERT(psa_cipher_decrypt_setup(&cipher_operation, key, |
| PSA_ALG_CTR)); |
| PSA_ASSERT(psa_cipher_abort(&cipher_operation)); |
| |
| SMOKE_ASSERT(psa_aead_encrypt(key, PSA_ALG_CCM, |
| buffer, sizeof(buffer), |
| NULL, 0, |
| buffer, sizeof(buffer), |
| buffer, sizeof(buffer), &length)); |
| SMOKE_ASSERT(psa_aead_decrypt(key, PSA_ALG_CCM, |
| buffer, sizeof(buffer), |
| NULL, 0, |
| buffer, sizeof(buffer), |
| buffer, sizeof(buffer), &length)); |
| |
| SMOKE_ASSERT(psa_sign_hash(key, PSA_ALG_ECDSA_ANY, |
| buffer, 32, |
| buffer, sizeof(buffer), &length)); |
| SMOKE_ASSERT(psa_verify_hash(key, PSA_ALG_ECDSA_ANY, |
| buffer, 32, |
| buffer, sizeof(buffer))); |
| |
| SMOKE_ASSERT(psa_asymmetric_encrypt(key, PSA_ALG_RSA_PKCS1V15_CRYPT, |
| buffer, 10, NULL, 0, |
| buffer, sizeof(buffer), &length)); |
| SMOKE_ASSERT(psa_asymmetric_decrypt(key, PSA_ALG_RSA_PKCS1V15_CRYPT, |
| buffer, sizeof(buffer), NULL, 0, |
| buffer, sizeof(buffer), &length)); |
| |
| #if defined(PSA_WANT_ALG_SHA_256) |
| /* Try the key in a plain key derivation. */ |
| PSA_ASSERT(psa_key_derivation_setup(&derivation_operation, |
| PSA_ALG_HKDF(PSA_ALG_SHA_256))); |
| PSA_ASSERT(psa_key_derivation_input_bytes(&derivation_operation, |
| PSA_KEY_DERIVATION_INPUT_SALT, |
| NULL, 0)); |
| SMOKE_ASSERT(psa_key_derivation_input_key(&derivation_operation, |
| PSA_KEY_DERIVATION_INPUT_SECRET, |
| key)); |
| PSA_ASSERT(psa_key_derivation_abort(&derivation_operation)); |
| |
| /* If the key is asymmetric, try it in a key agreement, both as |
| * part of a derivation operation and standalone. */ |
| if (psa_export_public_key(key, buffer, sizeof(buffer), &length) == |
| PSA_SUCCESS) { |
| psa_algorithm_t alg = |
| PSA_ALG_KEY_AGREEMENT(PSA_ALG_ECDH, |
| PSA_ALG_HKDF(PSA_ALG_SHA_256)); |
| PSA_ASSERT(psa_key_derivation_setup(&derivation_operation, alg)); |
| PSA_ASSERT(psa_key_derivation_input_bytes( |
| &derivation_operation, PSA_KEY_DERIVATION_INPUT_SALT, |
| NULL, 0)); |
| SMOKE_ASSERT(psa_key_derivation_key_agreement( |
| &derivation_operation, |
| PSA_KEY_DERIVATION_INPUT_SECRET, |
| key, buffer, length)); |
| PSA_ASSERT(psa_key_derivation_abort(&derivation_operation)); |
| |
| SMOKE_ASSERT(psa_raw_key_agreement( |
| alg, key, buffer, length, |
| buffer, sizeof(buffer), &length)); |
| } |
| #endif /* PSA_WANT_ALG_SHA_256 */ |
| |
| ok = 1; |
| |
| exit: |
| /* |
| * Key attributes may have been returned by psa_get_key_attributes() |
| * thus reset them as required. |
| */ |
| psa_reset_key_attributes(&attributes); |
| |
| return ok; |
| } |
| #endif /* AT_LEAST_ONE_BUILTIN_KDF */ |
| |
| static void psa_purge_storage(void) |
| { |
| /* The generic code in mbedtls_test_psa_purge_key_storage() |
| * (which is called by PSA_DONE()) doesn't take care of things that are |
| * specific to dynamic secure elements. */ |
| psa_key_location_t location; |
| /* Purge the transaction file. */ |
| psa_crypto_stop_transaction(); |
| /* Purge driver persistent data. */ |
| for (location = 0; location < PSA_MAX_SE_LOCATION; location++) { |
| psa_destroy_se_persistent_data(location); |
| } |
| } |
| |
| /* END_HEADER */ |
| |
| /* BEGIN_DEPENDENCIES |
| * depends_on:MBEDTLS_PSA_CRYPTO_SE_C |
| * END_DEPENDENCIES |
| */ |
| |
| /* BEGIN_CASE */ |
| void register_one(int location, int version, int expected_status_arg) |
| { |
| psa_status_t expected_status = expected_status_arg; |
| psa_drv_se_t driver; |
| |
| memset(&driver, 0, sizeof(driver)); |
| driver.hal_version = version; |
| |
| TEST_EQUAL(psa_register_se_driver(location, &driver), |
| expected_status); |
| |
| PSA_ASSERT(psa_crypto_init()); |
| |
| exit: |
| PSA_DONE(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void register_twice(int count) |
| { |
| psa_drv_se_t driver; |
| psa_key_location_t location; |
| psa_key_location_t max = MIN_DRIVER_LOCATION + count; |
| |
| memset(&driver, 0, sizeof(driver)); |
| driver.hal_version = PSA_DRV_SE_HAL_VERSION; |
| |
| for (location = MIN_DRIVER_LOCATION; location < max; location++) { |
| PSA_ASSERT(psa_register_se_driver(location, &driver)); |
| } |
| for (location = MIN_DRIVER_LOCATION; location < max; location++) { |
| TEST_EQUAL(psa_register_se_driver(location, &driver), |
| PSA_ERROR_ALREADY_EXISTS); |
| } |
| |
| PSA_ASSERT(psa_crypto_init()); |
| |
| exit: |
| PSA_DONE(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void register_max() |
| { |
| psa_drv_se_t driver; |
| psa_key_location_t location; |
| psa_key_location_t max = MIN_DRIVER_LOCATION + PSA_MAX_SE_DRIVERS; |
| |
| memset(&driver, 0, sizeof(driver)); |
| driver.hal_version = PSA_DRV_SE_HAL_VERSION; |
| |
| for (location = MIN_DRIVER_LOCATION; location < max; location++) { |
| PSA_ASSERT(psa_register_se_driver(location, &driver)); |
| } |
| |
| TEST_EQUAL(psa_register_se_driver(location, &driver), |
| PSA_ERROR_INSUFFICIENT_MEMORY); |
| |
| PSA_ASSERT(psa_crypto_init()); |
| |
| exit: |
| PSA_DONE(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void key_creation_import_export(int lifetime_arg, int min_slot, int restart) |
| { |
| psa_drv_se_t driver; |
| psa_drv_se_key_management_t key_management; |
| psa_key_lifetime_t lifetime = (psa_key_lifetime_t) lifetime_arg; |
| psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime); |
| mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1); |
| mbedtls_svc_key_id_t returned_id = MBEDTLS_SVC_KEY_ID_INIT; |
| psa_key_handle_t handle; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| const uint8_t key_material[3] = { 0xfa, 0xca, 0xde }; |
| uint8_t exported[sizeof(key_material)]; |
| size_t exported_length; |
| |
| TEST_USES_KEY_ID(id); |
| |
| memset(&driver, 0, sizeof(driver)); |
| memset(&key_management, 0, sizeof(key_management)); |
| driver.hal_version = PSA_DRV_SE_HAL_VERSION; |
| driver.key_management = &key_management; |
| driver.persistent_data_size = sizeof(ram_slot_usage_t); |
| key_management.p_allocate = ram_allocate; |
| key_management.p_import = ram_import; |
| key_management.p_destroy = ram_destroy; |
| key_management.p_export = ram_export; |
| ram_min_slot = min_slot; |
| |
| PSA_ASSERT(psa_register_se_driver(location, &driver)); |
| PSA_ASSERT(psa_crypto_init()); |
| |
| /* Create a key. */ |
| psa_set_key_id(&attributes, id); |
| psa_set_key_lifetime(&attributes, lifetime); |
| psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT); |
| psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA); |
| PSA_ASSERT(psa_import_key(&attributes, |
| key_material, sizeof(key_material), |
| &returned_id)); |
| |
| if (PSA_KEY_LIFETIME_IS_VOLATILE(lifetime)) { |
| /* For volatile keys, check no persistent data was created */ |
| if (!check_no_persistent_data(location)) { |
| goto exit; |
| } |
| } else { |
| /* For persistent keys, check persistent data */ |
| if (!check_persistent_data(location, |
| &ram_shadow_slot_usage, |
| sizeof(ram_shadow_slot_usage))) { |
| goto exit; |
| } |
| } |
| |
| /* Test that the key was created in the expected slot. */ |
| TEST_EQUAL(ram_slots[min_slot].type, PSA_KEY_TYPE_RAW_DATA); |
| |
| /* Maybe restart, to check that the information is saved correctly. */ |
| if (restart) { |
| mbedtls_psa_crypto_free(); |
| PSA_ASSERT(psa_register_se_driver(location, &driver)); |
| PSA_ASSERT(psa_crypto_init()); |
| |
| if (PSA_KEY_LIFETIME_IS_VOLATILE(lifetime)) { |
| /* Check that the PSA core has no knowledge of the volatile key */ |
| TEST_ASSERT(psa_open_key(returned_id, &handle) == |
| PSA_ERROR_DOES_NOT_EXIST); |
| |
| /* Drop data from our mockup driver */ |
| ram_slots_reset(); |
| ram_min_slot = min_slot; |
| |
| /* Re-import key */ |
| PSA_ASSERT(psa_import_key(&attributes, |
| key_material, sizeof(key_material), |
| &returned_id)); |
| } else { |
| /* Check the persistent key file */ |
| if (!check_persistent_data(location, |
| &ram_shadow_slot_usage, |
| sizeof(ram_shadow_slot_usage))) { |
| goto exit; |
| } |
| } |
| } |
| |
| /* Test that the key was created in the expected slot. */ |
| TEST_EQUAL(ram_slots[min_slot].type, PSA_KEY_TYPE_RAW_DATA); |
| |
| /* Test the key attributes, including the reported slot number. */ |
| psa_set_key_bits(&attributes, |
| PSA_BYTES_TO_BITS(sizeof(key_material))); |
| psa_set_key_slot_number(&attributes, min_slot); |
| |
| if (PSA_KEY_LIFETIME_IS_VOLATILE(lifetime)) { |
| attributes.id = returned_id; |
| } else { |
| psa_set_key_id(&attributes, returned_id); |
| } |
| |
| if (!check_key_attributes(returned_id, &attributes)) { |
| goto exit; |
| } |
| |
| /* Test the key data. */ |
| PSA_ASSERT(psa_export_key(returned_id, |
| exported, sizeof(exported), |
| &exported_length)); |
| TEST_MEMORY_COMPARE(key_material, sizeof(key_material), |
| exported, exported_length); |
| |
| PSA_ASSERT(psa_destroy_key(returned_id)); |
| if (!check_persistent_data(location, |
| &ram_shadow_slot_usage, |
| sizeof(ram_shadow_slot_usage))) { |
| goto exit; |
| } |
| TEST_EQUAL(psa_open_key(returned_id, &handle), |
| PSA_ERROR_DOES_NOT_EXIST); |
| |
| /* Test that the key has been erased from the designated slot. */ |
| TEST_EQUAL(ram_slots[min_slot].type, 0); |
| |
| exit: |
| PSA_DONE(); |
| ram_slots_reset(); |
| psa_purge_storage(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void key_creation_in_chosen_slot(int slot_arg, |
| int restart, |
| int expected_status_arg) |
| { |
| psa_key_slot_number_t wanted_slot = slot_arg; |
| psa_status_t expected_status = expected_status_arg; |
| psa_status_t status; |
| psa_drv_se_t driver; |
| psa_drv_se_key_management_t key_management; |
| psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME; |
| psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime); |
| mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1); |
| mbedtls_svc_key_id_t returned_id; |
| psa_key_handle_t handle; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| const uint8_t key_material[3] = { 0xfa, 0xca, 0xde }; |
| |
| TEST_USES_KEY_ID(id); |
| |
| memset(&driver, 0, sizeof(driver)); |
| memset(&key_management, 0, sizeof(key_management)); |
| driver.hal_version = PSA_DRV_SE_HAL_VERSION; |
| driver.key_management = &key_management; |
| driver.persistent_data_size = sizeof(ram_slot_usage_t); |
| key_management.p_validate_slot_number = ram_validate_slot_number; |
| key_management.p_import = ram_import; |
| key_management.p_destroy = ram_destroy; |
| key_management.p_export = ram_export; |
| |
| PSA_ASSERT(psa_register_se_driver(location, &driver)); |
| PSA_ASSERT(psa_crypto_init()); |
| |
| /* Create a key. */ |
| psa_set_key_id(&attributes, id); |
| psa_set_key_lifetime(&attributes, lifetime); |
| psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT); |
| psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA); |
| psa_set_key_slot_number(&attributes, wanted_slot); |
| status = psa_import_key(&attributes, |
| key_material, sizeof(key_material), |
| &returned_id); |
| TEST_EQUAL(status, expected_status); |
| |
| if (status != PSA_SUCCESS) { |
| goto exit; |
| } |
| if (!check_persistent_data(location, |
| &ram_shadow_slot_usage, |
| sizeof(ram_shadow_slot_usage))) { |
| goto exit; |
| } |
| |
| /* Maybe restart, to check that the information is saved correctly. */ |
| if (restart) { |
| mbedtls_psa_crypto_free(); |
| PSA_ASSERT(psa_register_se_driver(location, &driver)); |
| PSA_ASSERT(psa_crypto_init()); |
| if (!check_persistent_data(location, |
| &ram_shadow_slot_usage, |
| sizeof(ram_shadow_slot_usage))) { |
| goto exit; |
| } |
| } |
| |
| /* Test that the key was created in the expected slot. */ |
| TEST_EQUAL(ram_slots[wanted_slot].type, PSA_KEY_TYPE_RAW_DATA); |
| |
| /* Test that the key is reported with the correct attributes, |
| * including the expected slot. */ |
| PSA_ASSERT(psa_get_key_attributes(id, &attributes)); |
| |
| PSA_ASSERT(psa_destroy_key(id)); |
| if (!check_persistent_data(location, |
| &ram_shadow_slot_usage, |
| sizeof(ram_shadow_slot_usage))) { |
| goto exit; |
| } |
| TEST_EQUAL(psa_open_key(id, &handle), PSA_ERROR_DOES_NOT_EXIST); |
| |
| exit: |
| /* |
| * Key attributes may have been returned by psa_get_key_attributes() |
| * thus reset them as required. |
| */ |
| psa_reset_key_attributes(&attributes); |
| |
| PSA_DONE(); |
| ram_slots_reset(); |
| psa_purge_storage(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE depends_on:AT_LEAST_ONE_BUILTIN_KDF */ |
| void import_key_smoke(int type_arg, int alg_arg, |
| data_t *key_material) |
| { |
| psa_key_type_t type = type_arg; |
| psa_algorithm_t alg = alg_arg; |
| psa_drv_se_t driver; |
| psa_drv_se_key_management_t key_management; |
| psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME; |
| psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime); |
| mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1); |
| mbedtls_svc_key_id_t returned_id; |
| psa_key_handle_t handle; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| |
| TEST_USES_KEY_ID(id); |
| |
| memset(&driver, 0, sizeof(driver)); |
| memset(&key_management, 0, sizeof(key_management)); |
| driver.hal_version = PSA_DRV_SE_HAL_VERSION; |
| driver.key_management = &key_management; |
| driver.persistent_data_size = sizeof(psa_key_slot_number_t); |
| key_management.p_allocate = counter_allocate; |
| key_management.p_import = null_import; |
| key_management.p_destroy = null_destroy; |
| |
| PSA_ASSERT(psa_register_se_driver(location, &driver)); |
| PSA_ASSERT(psa_crypto_init()); |
| |
| /* Create a key. */ |
| psa_set_key_id(&attributes, id); |
| psa_set_key_lifetime(&attributes, lifetime); |
| psa_set_key_usage_flags(&attributes, |
| PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH | |
| PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT | |
| PSA_KEY_USAGE_EXPORT); |
| psa_set_key_algorithm(&attributes, alg); |
| psa_set_key_type(&attributes, type); |
| PSA_ASSERT(psa_import_key(&attributes, |
| key_material->x, key_material->len, |
| &returned_id)); |
| if (!check_persistent_data(location, |
| &shadow_counter, sizeof(shadow_counter))) { |
| goto exit; |
| } |
| |
| /* Do stuff with the key. */ |
| if (!smoke_test_key(id)) { |
| goto exit; |
| } |
| |
| /* Restart and try again. */ |
| mbedtls_psa_crypto_free(); |
| PSA_ASSERT(psa_register_se_driver(location, &driver)); |
| PSA_ASSERT(psa_crypto_init()); |
| if (!check_persistent_data(location, |
| &shadow_counter, sizeof(shadow_counter))) { |
| goto exit; |
| } |
| if (!smoke_test_key(id)) { |
| goto exit; |
| } |
| |
| /* We're done. */ |
| PSA_ASSERT(psa_destroy_key(id)); |
| if (!check_persistent_data(location, |
| &shadow_counter, sizeof(shadow_counter))) { |
| goto exit; |
| } |
| TEST_EQUAL(psa_open_key(id, &handle), PSA_ERROR_DOES_NOT_EXIST); |
| |
| exit: |
| PSA_DONE(); |
| counter_reset(); |
| psa_purge_storage(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void generate_key_not_supported(int type_arg, int bits_arg) |
| { |
| psa_key_type_t type = type_arg; |
| size_t bits = bits_arg; |
| psa_drv_se_t driver; |
| psa_drv_se_key_management_t key_management; |
| psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME; |
| psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime); |
| mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1); |
| mbedtls_svc_key_id_t returned_id; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| |
| TEST_USES_KEY_ID(id); |
| |
| memset(&driver, 0, sizeof(driver)); |
| memset(&key_management, 0, sizeof(key_management)); |
| driver.hal_version = PSA_DRV_SE_HAL_VERSION; |
| driver.key_management = &key_management; |
| driver.persistent_data_size = sizeof(psa_key_slot_number_t); |
| key_management.p_allocate = counter_allocate; |
| /* No p_generate method */ |
| |
| PSA_ASSERT(psa_register_se_driver(location, &driver)); |
| PSA_ASSERT(psa_crypto_init()); |
| |
| psa_set_key_id(&attributes, id); |
| psa_set_key_lifetime(&attributes, lifetime); |
| psa_set_key_type(&attributes, type); |
| psa_set_key_bits(&attributes, bits); |
| TEST_EQUAL(psa_generate_key(&attributes, &returned_id), |
| PSA_ERROR_NOT_SUPPORTED); |
| |
| exit: |
| PSA_DONE(); |
| counter_reset(); |
| psa_purge_storage(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE depends_on:AT_LEAST_ONE_BUILTIN_KDF */ |
| void generate_key_smoke(int type_arg, int bits_arg, int alg_arg) |
| { |
| psa_key_type_t type = type_arg; |
| psa_key_bits_t bits = bits_arg; |
| psa_algorithm_t alg = alg_arg; |
| psa_drv_se_t driver; |
| psa_drv_se_key_management_t key_management; |
| psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME; |
| psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime); |
| mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1); |
| mbedtls_svc_key_id_t returned_id; |
| psa_key_handle_t handle; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| |
| TEST_USES_KEY_ID(id); |
| |
| memset(&driver, 0, sizeof(driver)); |
| memset(&key_management, 0, sizeof(key_management)); |
| driver.hal_version = PSA_DRV_SE_HAL_VERSION; |
| driver.key_management = &key_management; |
| driver.persistent_data_size = sizeof(psa_key_slot_number_t); |
| key_management.p_allocate = counter_allocate; |
| key_management.p_generate = null_generate; |
| key_management.p_destroy = null_destroy; |
| |
| PSA_ASSERT(psa_register_se_driver(location, &driver)); |
| PSA_ASSERT(psa_crypto_init()); |
| |
| /* Create a key. */ |
| psa_set_key_id(&attributes, id); |
| psa_set_key_lifetime(&attributes, lifetime); |
| psa_set_key_usage_flags(&attributes, |
| PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH | |
| PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT | |
| PSA_KEY_USAGE_EXPORT); |
| psa_set_key_algorithm(&attributes, alg); |
| psa_set_key_type(&attributes, type); |
| psa_set_key_bits(&attributes, bits); |
| PSA_ASSERT(psa_generate_key(&attributes, &returned_id)); |
| if (!check_persistent_data(location, |
| &shadow_counter, sizeof(shadow_counter))) { |
| goto exit; |
| } |
| |
| /* Do stuff with the key. */ |
| if (!smoke_test_key(id)) { |
| goto exit; |
| } |
| |
| /* Restart and try again. */ |
| mbedtls_psa_crypto_free(); |
| PSA_ASSERT(psa_register_se_driver(location, &driver)); |
| PSA_ASSERT(psa_crypto_init()); |
| if (!check_persistent_data(location, |
| &shadow_counter, sizeof(shadow_counter))) { |
| goto exit; |
| } |
| if (!smoke_test_key(id)) { |
| goto exit; |
| } |
| |
| /* We're done. */ |
| PSA_ASSERT(psa_destroy_key(id)); |
| if (!check_persistent_data(location, |
| &shadow_counter, sizeof(shadow_counter))) { |
| goto exit; |
| } |
| TEST_EQUAL(psa_open_key(id, &handle), PSA_ERROR_DOES_NOT_EXIST); |
| |
| exit: |
| PSA_DONE(); |
| counter_reset(); |
| psa_purge_storage(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void sign_verify(int flow, |
| int type_arg, int alg_arg, |
| int bits_arg, data_t *key_material, |
| data_t *input) |
| { |
| psa_key_type_t type = type_arg; |
| psa_algorithm_t alg = alg_arg; |
| size_t bits = bits_arg; |
| /* Pass bits=0 to import, bits>0 to fake-generate */ |
| int generating = (bits != 0); |
| |
| psa_drv_se_t driver; |
| psa_drv_se_key_management_t key_management; |
| psa_drv_se_asymmetric_t asymmetric; |
| |
| psa_key_lifetime_t lifetime = TEST_SE_PERSISTENT_LIFETIME; |
| psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime); |
| mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, 1); |
| mbedtls_svc_key_id_t returned_id; |
| mbedtls_svc_key_id_t sw_key = MBEDTLS_SVC_KEY_ID_INIT; |
| psa_key_attributes_t sw_attributes = PSA_KEY_ATTRIBUTES_INIT; |
| psa_key_attributes_t drv_attributes = PSA_KEY_ATTRIBUTES_INIT; |
| uint8_t signature[PSA_SIGNATURE_MAX_SIZE]; |
| size_t signature_length; |
| |
| TEST_USES_KEY_ID(id); |
| |
| memset(&driver, 0, sizeof(driver)); |
| memset(&key_management, 0, sizeof(key_management)); |
| memset(&asymmetric, 0, sizeof(asymmetric)); |
| driver.hal_version = PSA_DRV_SE_HAL_VERSION; |
| driver.key_management = &key_management; |
| driver.asymmetric = &asymmetric; |
| driver.persistent_data_size = sizeof(ram_slot_usage_t); |
| key_management.p_allocate = ram_allocate; |
| key_management.p_destroy = ram_destroy; |
| if (generating) { |
| key_management.p_generate = ram_fake_generate; |
| } else { |
| key_management.p_import = ram_import; |
| } |
| switch (flow) { |
| case SIGN_IN_SOFTWARE_AND_PARALLEL_CREATION: |
| break; |
| case SIGN_IN_DRIVER_AND_PARALLEL_CREATION: |
| asymmetric.p_sign = ram_sign; |
| break; |
| case SIGN_IN_DRIVER_THEN_EXPORT_PUBLIC: |
| asymmetric.p_sign = ram_sign; |
| key_management.p_export_public = ram_export_public; |
| break; |
| default: |
| TEST_FAIL("unsupported flow (should be SIGN_IN_xxx)"); |
| break; |
| } |
| asymmetric.p_verify = ram_verify; |
| |
| PSA_ASSERT(psa_register_se_driver(location, &driver)); |
| PSA_ASSERT(psa_crypto_init()); |
| |
| /* Prepare to create two keys with the same key material: a transparent |
| * key, and one that goes through the driver. */ |
| psa_set_key_usage_flags(&sw_attributes, |
| PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_VERIFY_HASH); |
| psa_set_key_algorithm(&sw_attributes, alg); |
| psa_set_key_type(&sw_attributes, type); |
| drv_attributes = sw_attributes; |
| psa_set_key_id(&drv_attributes, id); |
| psa_set_key_lifetime(&drv_attributes, lifetime); |
| |
| /* Create the key in the driver. */ |
| if (generating) { |
| psa_set_key_bits(&drv_attributes, bits); |
| PSA_ASSERT(psa_generate_key(&drv_attributes, &returned_id)); |
| /* Since we called a generate method that does not actually |
| * generate material, store the desired result of generation in |
| * the mock secure element storage. */ |
| PSA_ASSERT(psa_get_key_attributes(id, &drv_attributes)); |
| TEST_EQUAL(key_material->len, PSA_BITS_TO_BYTES(bits)); |
| memcpy(ram_slots[ram_min_slot].content, key_material->x, |
| key_material->len); |
| } else { |
| PSA_ASSERT(psa_import_key(&drv_attributes, |
| key_material->x, key_material->len, |
| &returned_id)); |
| } |
| |
| /* Either import the same key in software, or export the driver's |
| * public key and import that. */ |
| switch (flow) { |
| case SIGN_IN_SOFTWARE_AND_PARALLEL_CREATION: |
| case SIGN_IN_DRIVER_AND_PARALLEL_CREATION: |
| PSA_ASSERT(psa_import_key(&sw_attributes, |
| key_material->x, key_material->len, |
| &sw_key)); |
| break; |
| case SIGN_IN_DRIVER_THEN_EXPORT_PUBLIC: |
| { |
| uint8_t public_key[PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(PSA_VENDOR_ECC_MAX_CURVE_BITS) |
| ]; |
| size_t public_key_length; |
| PSA_ASSERT(psa_export_public_key(id, |
| public_key, sizeof(public_key), |
| &public_key_length)); |
| psa_set_key_type(&sw_attributes, |
| PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(type)); |
| PSA_ASSERT(psa_import_key(&sw_attributes, |
| public_key, public_key_length, |
| &sw_key)); |
| break; |
| } |
| } |
| |
| /* Sign with the chosen key. */ |
| switch (flow) { |
| case SIGN_IN_DRIVER_AND_PARALLEL_CREATION: |
| case SIGN_IN_DRIVER_THEN_EXPORT_PUBLIC: |
| PSA_ASSERT_VIA_DRIVER( |
| psa_sign_hash(id, alg, |
| input->x, input->len, |
| signature, sizeof(signature), |
| &signature_length), |
| PSA_SUCCESS); |
| break; |
| case SIGN_IN_SOFTWARE_AND_PARALLEL_CREATION: |
| PSA_ASSERT(psa_sign_hash(sw_key, alg, |
| input->x, input->len, |
| signature, sizeof(signature), |
| &signature_length)); |
| break; |
| } |
| |
| /* Verify with both keys. */ |
| PSA_ASSERT(psa_verify_hash(sw_key, alg, |
| input->x, input->len, |
| signature, signature_length)); |
| PSA_ASSERT_VIA_DRIVER( |
| psa_verify_hash(id, alg, |
| input->x, input->len, |
| signature, signature_length), |
| PSA_SUCCESS); |
| |
| /* Change the signature and verify again. */ |
| signature[0] ^= 1; |
| TEST_EQUAL(psa_verify_hash(sw_key, alg, |
| input->x, input->len, |
| signature, signature_length), |
| PSA_ERROR_INVALID_SIGNATURE); |
| PSA_ASSERT_VIA_DRIVER( |
| psa_verify_hash(id, alg, |
| input->x, input->len, |
| signature, signature_length), |
| PSA_ERROR_INVALID_SIGNATURE); |
| |
| exit: |
| /* |
| * Driver key attributes may have been returned by psa_get_key_attributes() |
| * thus reset them as required. |
| */ |
| psa_reset_key_attributes(&drv_attributes); |
| |
| psa_destroy_key(id); |
| psa_destroy_key(sw_key); |
| PSA_DONE(); |
| ram_slots_reset(); |
| psa_purge_storage(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void register_key_smoke_test(int lifetime_arg, |
| int owner_id_arg, |
| int id_arg, |
| int validate, |
| int expected_status_arg) |
| { |
| psa_key_lifetime_t lifetime = lifetime_arg; |
| psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(lifetime); |
| psa_status_t expected_status = expected_status_arg; |
| psa_drv_se_t driver; |
| psa_drv_se_key_management_t key_management; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(owner_id_arg, id_arg); |
| psa_key_handle_t handle; |
| size_t bit_size = 48; |
| psa_key_slot_number_t wanted_slot = 0x123456789; |
| psa_status_t status; |
| |
| TEST_USES_KEY_ID(id); |
| |
| memset(&driver, 0, sizeof(driver)); |
| driver.hal_version = PSA_DRV_SE_HAL_VERSION; |
| memset(&key_management, 0, sizeof(key_management)); |
| driver.key_management = &key_management; |
| key_management.p_destroy = null_destroy; |
| if (validate >= 0) { |
| key_management.p_validate_slot_number = validate_slot_number_as_directed; |
| validate_slot_number_directions.slot_number = wanted_slot; |
| validate_slot_number_directions.method = PSA_KEY_CREATION_REGISTER; |
| validate_slot_number_directions.status = |
| (validate > 0 ? PSA_SUCCESS : PSA_ERROR_NOT_PERMITTED); |
| } |
| |
| mbedtls_test_set_step(1); |
| PSA_ASSERT(psa_register_se_driver(MIN_DRIVER_LOCATION, &driver)); |
| PSA_ASSERT(psa_crypto_init()); |
| |
| psa_set_key_id(&attributes, id); |
| psa_set_key_lifetime(&attributes, lifetime); |
| psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT); |
| psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA); |
| psa_set_key_bits(&attributes, bit_size); |
| psa_set_key_slot_number(&attributes, wanted_slot); |
| |
| status = mbedtls_psa_register_se_key(&attributes); |
| TEST_EQUAL(status, expected_status); |
| |
| if (status != PSA_SUCCESS) { |
| goto exit; |
| } |
| |
| /* Test that the key exists and has the expected attributes. */ |
| if (!check_key_attributes(id, &attributes)) { |
| goto exit; |
| } |
| |
| #if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER) |
| mbedtls_svc_key_id_t invalid_id = |
| mbedtls_svc_key_id_make(owner_id_arg + 1, id_arg); |
| TEST_EQUAL(psa_open_key(invalid_id, &handle), PSA_ERROR_DOES_NOT_EXIST); |
| #endif |
| |
| PSA_ASSERT(psa_purge_key(id)); |
| |
| /* Restart and try again. */ |
| mbedtls_test_set_step(2); |
| PSA_SESSION_DONE(); |
| PSA_ASSERT(psa_register_se_driver(location, &driver)); |
| PSA_ASSERT(psa_crypto_init()); |
| if (!check_key_attributes(id, &attributes)) { |
| goto exit; |
| } |
| /* This time, destroy the key. */ |
| PSA_ASSERT(psa_destroy_key(id)); |
| TEST_EQUAL(psa_open_key(id, &handle), PSA_ERROR_DOES_NOT_EXIST); |
| |
| exit: |
| psa_reset_key_attributes(&attributes); |
| psa_destroy_key(id); |
| PSA_DONE(); |
| psa_purge_storage(); |
| memset(&validate_slot_number_directions, 0, |
| sizeof(validate_slot_number_directions)); |
| } |
| /* END_CASE */ |
