| /* BEGIN_HEADER */ |
| #include <stdint.h> |
| |
| #include "psa_crypto_slot_management.h" |
| #include "psa_crypto_storage.h" |
| |
| typedef enum { |
| /**< Close key(s) */ |
| INVALIDATE_BY_CLOSING, |
| |
| /**< Destroy key(s) */ |
| INVALIDATE_BY_DESTROYING, |
| |
| /**< Purge key(s) */ |
| INVALIDATE_BY_PURGING, |
| |
| /**< Terminate and reinitialize without closing/destroying keys */ |
| INVALIDATE_BY_SHUTDOWN, |
| |
| /**< Close key(s) then terminate and re-initialize */ |
| INVALIDATE_BY_CLOSING_WITH_SHUTDOWN, |
| |
| /**< Destroy key(s) then terminate and re-initialize */ |
| INVALIDATE_BY_DESTROYING_WITH_SHUTDOWN, |
| |
| /**< Purge key(s) then terminate and re-initialize */ |
| INVALIDATE_BY_PURGING_WITH_SHUTDOWN, |
| } invalidate_method_t; |
| |
| typedef enum { |
| KEEP_OPEN, |
| CLOSE_BEFORE, |
| CLOSE_AFTER, |
| } reopen_policy_t; |
| |
| typedef enum { |
| INVALID_HANDLE_0, |
| INVALID_HANDLE_UNOPENED, |
| INVALID_HANDLE_CLOSED, |
| INVALID_HANDLE_HUGE, |
| } invalid_handle_construction_t; |
| |
| /** Apply \p invalidate_method to invalidate the specified key: |
| * close it, destroy it, or do nothing; |
| */ |
| static int invalidate_key(invalidate_method_t invalidate_method, |
| mbedtls_svc_key_id_t key) |
| { |
| switch (invalidate_method) { |
| /* Closing the key invalidate only volatile keys, not persistent ones. */ |
| case INVALIDATE_BY_CLOSING: |
| case INVALIDATE_BY_CLOSING_WITH_SHUTDOWN: |
| PSA_ASSERT(psa_close_key(key)); |
| break; |
| case INVALIDATE_BY_DESTROYING: |
| case INVALIDATE_BY_DESTROYING_WITH_SHUTDOWN: |
| PSA_ASSERT(psa_destroy_key(key)); |
| break; |
| /* Purging the key just purges RAM data of persistent keys. */ |
| case INVALIDATE_BY_PURGING: |
| case INVALIDATE_BY_PURGING_WITH_SHUTDOWN: |
| PSA_ASSERT(psa_purge_key(key)); |
| break; |
| case INVALIDATE_BY_SHUTDOWN: |
| break; |
| } |
| return 1; |
| exit: |
| return 0; |
| } |
| |
| /** Restart the PSA subsystem if \p invalidate_method says so. */ |
| static int invalidate_psa(invalidate_method_t invalidate_method) |
| { |
| switch (invalidate_method) { |
| case INVALIDATE_BY_CLOSING: |
| case INVALIDATE_BY_DESTROYING: |
| case INVALIDATE_BY_PURGING: |
| return 1; |
| case INVALIDATE_BY_CLOSING_WITH_SHUTDOWN: |
| case INVALIDATE_BY_DESTROYING_WITH_SHUTDOWN: |
| case INVALIDATE_BY_PURGING_WITH_SHUTDOWN: |
| /* All keys must have been closed. */ |
| PSA_SESSION_DONE(); |
| break; |
| case INVALIDATE_BY_SHUTDOWN: |
| /* Some keys may remain behind, and we're testing that this |
| * properly closes them. */ |
| mbedtls_psa_crypto_free(); |
| break; |
| } |
| |
| PSA_ASSERT(psa_crypto_init()); |
| ASSERT_PSA_PRISTINE(); |
| return 1; |
| |
| exit: |
| return 0; |
| } |
| |
| /* END_HEADER */ |
| |
| /* BEGIN_DEPENDENCIES |
| * depends_on:MBEDTLS_PSA_CRYPTO_C |
| * END_DEPENDENCIES |
| */ |
| |
| /* BEGIN_CASE */ |
| void transient_slot_lifecycle(int owner_id_arg, |
| int usage_arg, int alg_arg, |
| int type_arg, data_t *key_data, |
| int invalidate_method_arg) |
| { |
| psa_algorithm_t alg = alg_arg; |
| psa_key_usage_t usage_flags = usage_arg; |
| psa_key_type_t type = type_arg; |
| invalidate_method_t invalidate_method = invalidate_method_arg; |
| mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| |
| mbedtls_test_set_step(1); |
| PSA_ASSERT(psa_crypto_init()); |
| |
| /* Import a key. */ |
| #if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER) |
| mbedtls_key_owner_id_t owner_id = owner_id_arg; |
| |
| mbedtls_set_key_owner_id(&attributes, owner_id); |
| #else |
| (void) owner_id_arg; |
| #endif |
| |
| psa_set_key_usage_flags(&attributes, usage_flags); |
| psa_set_key_algorithm(&attributes, alg); |
| psa_set_key_type(&attributes, type); |
| PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len, |
| &key)); |
| TEST_ASSERT(!mbedtls_svc_key_id_is_null(key)); |
| PSA_ASSERT(psa_get_key_attributes(key, &attributes)); |
| TEST_EQUAL(psa_get_key_type(&attributes), type); |
| psa_reset_key_attributes(&attributes); |
| |
| #if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER) |
| { |
| mbedtls_svc_key_id_t key_with_invalid_owner = |
| mbedtls_svc_key_id_make(owner_id + 1, |
| MBEDTLS_SVC_KEY_ID_GET_KEY_ID(key)); |
| |
| TEST_ASSERT(mbedtls_key_owner_id_equal( |
| owner_id, |
| MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(key))); |
| TEST_EQUAL(psa_get_key_attributes(key_with_invalid_owner, &attributes), |
| PSA_ERROR_INVALID_HANDLE); |
| } |
| #endif |
| |
| /* |
| * Purge the key and make sure that it is still valid, as purging a |
| * volatile key shouldn't invalidate/destroy it. |
| */ |
| PSA_ASSERT(psa_purge_key(key)); |
| PSA_ASSERT(psa_get_key_attributes(key, &attributes)); |
| TEST_EQUAL(psa_get_key_type(&attributes), type); |
| psa_reset_key_attributes(&attributes); |
| |
| /* Do something that invalidates the key. */ |
| mbedtls_test_set_step(2); |
| if (!invalidate_key(invalidate_method, key)) { |
| goto exit; |
| } |
| if (!invalidate_psa(invalidate_method)) { |
| goto exit; |
| } |
| |
| /* Test that the key is now invalid. */ |
| TEST_EQUAL(psa_get_key_attributes(key, &attributes), |
| PSA_ERROR_INVALID_HANDLE); |
| TEST_EQUAL(psa_close_key(key), PSA_ERROR_INVALID_HANDLE); |
| |
| exit: |
| /* |
| * Key attributes may have been returned by psa_get_key_attributes() |
| * thus reset them as required. |
| */ |
| psa_reset_key_attributes(&attributes); |
| |
| PSA_DONE(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_STORAGE_C */ |
| void persistent_slot_lifecycle(int lifetime_arg, int owner_id_arg, int id_arg, |
| int usage_arg, int alg_arg, int alg2_arg, |
| int type_arg, data_t *key_data, |
| int invalidate_method_arg) |
| { |
| psa_key_lifetime_t lifetime = lifetime_arg; |
| mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(owner_id_arg, id_arg); |
| psa_algorithm_t alg = alg_arg; |
| psa_algorithm_t alg2 = alg2_arg; |
| psa_key_usage_t usage_flags = usage_arg; |
| psa_key_type_t type = type_arg; |
| invalidate_method_t invalidate_method = invalidate_method_arg; |
| mbedtls_svc_key_id_t returned_id = MBEDTLS_SVC_KEY_ID_INIT; |
| psa_key_handle_t handle = PSA_KEY_HANDLE_INIT; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| psa_key_attributes_t read_attributes = PSA_KEY_ATTRIBUTES_INIT; |
| uint8_t *reexported = NULL; |
| size_t reexported_length = -1; |
| |
| #if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER) |
| mbedtls_svc_key_id_t wrong_owner_id = |
| mbedtls_svc_key_id_make(owner_id_arg + 1, id_arg); |
| mbedtls_svc_key_id_t invalid_svc_key_id = MBEDTLS_SVC_KEY_ID_INIT; |
| #endif |
| |
| TEST_USES_KEY_ID(id); |
| |
| mbedtls_test_set_step(1); |
| 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_usage_flags(&attributes, usage_flags); |
| psa_set_key_algorithm(&attributes, alg); |
| psa_set_key_enrollment_algorithm(&attributes, alg2); |
| PSA_ASSERT(psa_import_key(&attributes, key_data->x, key_data->len, |
| &returned_id)); |
| TEST_ASSERT(mbedtls_svc_key_id_equal(id, returned_id)); |
| |
| #if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER) |
| TEST_EQUAL(psa_open_key(wrong_owner_id, &invalid_svc_key_id), |
| PSA_ERROR_DOES_NOT_EXIST); |
| #endif |
| |
| PSA_ASSERT(psa_get_key_attributes(id, &attributes)); |
| TEST_EQUAL(psa_get_key_lifetime(&attributes), lifetime); |
| TEST_ASSERT(mbedtls_svc_key_id_equal( |
| psa_get_key_id(&attributes), id)); |
| TEST_EQUAL(psa_get_key_usage_flags(&attributes), |
| mbedtls_test_update_key_usage_flags(usage_flags)); |
| TEST_EQUAL(psa_get_key_algorithm(&attributes), alg); |
| TEST_EQUAL(psa_get_key_enrollment_algorithm(&attributes), alg2); |
| TEST_EQUAL(psa_get_key_type(&attributes), type); |
| |
| /* Close the key and then open it. */ |
| PSA_ASSERT(psa_close_key(id)); |
| |
| #if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER) |
| TEST_EQUAL(psa_open_key(wrong_owner_id, &invalid_svc_key_id), |
| PSA_ERROR_DOES_NOT_EXIST); |
| #endif |
| |
| PSA_ASSERT(psa_open_key(id, &handle)); |
| TEST_ASSERT(!psa_key_handle_is_null(handle)); |
| PSA_ASSERT(psa_get_key_attributes(handle, &attributes)); |
| TEST_EQUAL(psa_get_key_lifetime(&attributes), lifetime); |
| TEST_ASSERT(mbedtls_svc_key_id_equal( |
| psa_get_key_id(&attributes), id)); |
| TEST_EQUAL(psa_get_key_usage_flags(&attributes), |
| mbedtls_test_update_key_usage_flags(usage_flags)); |
| TEST_EQUAL(psa_get_key_algorithm(&attributes), alg); |
| TEST_EQUAL(psa_get_key_enrollment_algorithm(&attributes), alg2); |
| TEST_EQUAL(psa_get_key_type(&attributes), type); |
| |
| /* |
| * Do something that wipes key data in volatile memory or destroy the |
| * key. |
| */ |
| mbedtls_test_set_step(2); |
| if (!invalidate_key(invalidate_method, id)) { |
| goto exit; |
| } |
| if (!invalidate_psa(invalidate_method)) { |
| goto exit; |
| } |
| |
| /* Try to reaccess the key. If we destroyed it, check that it doesn't |
| * exist. Otherwise check that it still exists and has the expected |
| * content. */ |
| switch (invalidate_method) { |
| case INVALIDATE_BY_CLOSING: |
| case INVALIDATE_BY_CLOSING_WITH_SHUTDOWN: |
| case INVALIDATE_BY_PURGING: |
| case INVALIDATE_BY_PURGING_WITH_SHUTDOWN: |
| case INVALIDATE_BY_SHUTDOWN: |
| PSA_ASSERT(psa_open_key(id, &handle)); |
| PSA_ASSERT(psa_get_key_attributes(id, &read_attributes)); |
| TEST_EQUAL(psa_get_key_lifetime(&attributes), |
| psa_get_key_lifetime(&read_attributes)); |
| TEST_ASSERT(mbedtls_svc_key_id_equal( |
| psa_get_key_id(&attributes), |
| psa_get_key_id(&read_attributes))); |
| TEST_EQUAL(psa_get_key_usage_flags(&attributes), |
| mbedtls_test_update_key_usage_flags(usage_flags)); |
| TEST_EQUAL(psa_get_key_algorithm(&attributes), |
| psa_get_key_algorithm(&read_attributes)); |
| TEST_EQUAL(psa_get_key_enrollment_algorithm(&attributes), |
| psa_get_key_enrollment_algorithm(&read_attributes)); |
| TEST_EQUAL(psa_get_key_type(&attributes), |
| psa_get_key_type(&read_attributes)); |
| TEST_EQUAL(psa_get_key_bits(&attributes), |
| psa_get_key_bits(&read_attributes)); |
| TEST_CALLOC(reexported, key_data->len); |
| if (usage_flags & PSA_KEY_USAGE_EXPORT) { |
| PSA_ASSERT(psa_export_key(id, reexported, key_data->len, |
| &reexported_length)); |
| TEST_MEMORY_COMPARE(key_data->x, key_data->len, |
| reexported, reexported_length); |
| } else { |
| TEST_EQUAL(psa_export_key(id, reexported, |
| key_data->len, &reexported_length), |
| PSA_ERROR_NOT_PERMITTED); |
| } |
| PSA_ASSERT(psa_close_key(handle)); |
| break; |
| |
| case INVALIDATE_BY_DESTROYING: |
| case INVALIDATE_BY_DESTROYING_WITH_SHUTDOWN: |
| /* |
| * Test that the key handle and identifier are now not referring to an |
| * existing key. |
| */ |
| TEST_EQUAL(psa_get_key_attributes(handle, &read_attributes), |
| PSA_ERROR_INVALID_HANDLE); |
| TEST_EQUAL(psa_close_key(handle), PSA_ERROR_INVALID_HANDLE); |
| TEST_EQUAL(psa_get_key_attributes(id, &read_attributes), |
| PSA_ERROR_INVALID_HANDLE); |
| break; |
| } |
| |
| exit: |
| /* |
| * Key attributes may have been returned by psa_get_key_attributes() |
| * thus reset them as required. |
| */ |
| psa_reset_key_attributes(&attributes); |
| psa_reset_key_attributes(&read_attributes); |
| |
| PSA_DONE(); |
| mbedtls_free(reexported); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_STORAGE_C */ |
| void create_existent(int lifetime_arg, int owner_id_arg, int id_arg, |
| int reopen_policy_arg) |
| { |
| psa_key_lifetime_t lifetime = lifetime_arg; |
| mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(owner_id_arg, id_arg); |
| mbedtls_svc_key_id_t returned_id = MBEDTLS_SVC_KEY_ID_INIT; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| psa_key_type_t type1 = PSA_KEY_TYPE_RAW_DATA; |
| const uint8_t material1[5] = "a key"; |
| const uint8_t material2[5] = "b key"; |
| size_t bits1 = PSA_BYTES_TO_BITS(sizeof(material1)); |
| uint8_t reexported[sizeof(material1)]; |
| size_t reexported_length; |
| reopen_policy_t reopen_policy = reopen_policy_arg; |
| |
| TEST_USES_KEY_ID(id); |
| |
| PSA_ASSERT(psa_crypto_init()); |
| |
| /* Create a key. */ |
| psa_set_key_id(&attributes, id); |
| psa_set_key_lifetime(&attributes, lifetime); |
| psa_set_key_type(&attributes, type1); |
| psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT); |
| psa_set_key_algorithm(&attributes, 0); |
| PSA_ASSERT(psa_import_key(&attributes, material1, sizeof(material1), |
| &returned_id)); |
| TEST_ASSERT(mbedtls_svc_key_id_equal(id, returned_id)); |
| |
| if (reopen_policy == CLOSE_BEFORE) { |
| PSA_ASSERT(psa_close_key(id)); |
| } |
| |
| /* Attempt to create a new key in the same slot. */ |
| TEST_EQUAL(psa_import_key(&attributes, material2, sizeof(material2), |
| &returned_id), |
| PSA_ERROR_ALREADY_EXISTS); |
| TEST_ASSERT(mbedtls_svc_key_id_is_null(returned_id)); |
| |
| if (reopen_policy == CLOSE_AFTER) { |
| PSA_ASSERT(psa_close_key(id)); |
| } |
| |
| /* Check that the original key hasn't changed. */ |
| psa_reset_key_attributes(&attributes); |
| PSA_ASSERT(psa_get_key_attributes(id, &attributes)); |
| TEST_ASSERT(mbedtls_svc_key_id_equal( |
| psa_get_key_id(&attributes), id)); |
| TEST_EQUAL(psa_get_key_lifetime(&attributes), lifetime); |
| TEST_EQUAL(psa_get_key_type(&attributes), type1); |
| TEST_EQUAL(psa_get_key_bits(&attributes), bits1); |
| TEST_EQUAL(psa_get_key_usage_flags(&attributes), PSA_KEY_USAGE_EXPORT); |
| TEST_EQUAL(psa_get_key_algorithm(&attributes), 0); |
| |
| PSA_ASSERT(psa_export_key(id, |
| reexported, sizeof(reexported), |
| &reexported_length)); |
| TEST_MEMORY_COMPARE(material1, sizeof(material1), |
| reexported, reexported_length); |
| |
| PSA_ASSERT(psa_close_key(id)); |
| |
| exit: |
| /* |
| * Key attributes may have been returned by psa_get_key_attributes() |
| * thus reset them as required. |
| */ |
| psa_reset_key_attributes(&attributes); |
| |
| PSA_DONE(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void open_fail(int id_arg, |
| int expected_status_arg) |
| { |
| mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, id_arg); |
| psa_status_t expected_status = expected_status_arg; |
| psa_key_handle_t handle = mbedtls_svc_key_id_make(0xdead, 0xdead); |
| |
| PSA_ASSERT(psa_crypto_init()); |
| |
| TEST_EQUAL(psa_open_key(id, &handle), expected_status); |
| TEST_ASSERT(psa_key_handle_is_null(handle)); |
| |
| exit: |
| PSA_DONE(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void create_fail(int lifetime_arg, int id_arg, |
| int expected_status_arg) |
| { |
| psa_key_lifetime_t lifetime = lifetime_arg; |
| mbedtls_svc_key_id_t id = mbedtls_svc_key_id_make(1, id_arg); |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| psa_status_t expected_status = expected_status_arg; |
| mbedtls_svc_key_id_t returned_id = |
| mbedtls_svc_key_id_make(0xdead, 0xdead); |
| uint8_t material[1] = { 'k' }; |
| |
| TEST_USES_KEY_ID(id); |
| |
| PSA_ASSERT(psa_crypto_init()); |
| |
| psa_set_key_lifetime(&attributes, lifetime); |
| if (PSA_KEY_LIFETIME_IS_VOLATILE(lifetime)) { |
| /* |
| * Not possible to set a key identifier different from 0 through |
| * PSA key attributes APIs thus accessing to the attributes |
| * directly. |
| */ |
| attributes.id = id; |
| } else { |
| psa_set_key_id(&attributes, id); |
| } |
| |
| psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA); |
| TEST_EQUAL(psa_import_key(&attributes, material, sizeof(material), |
| &returned_id), |
| expected_status); |
| TEST_ASSERT(mbedtls_svc_key_id_is_null(returned_id)); |
| |
| exit: |
| PSA_DONE(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void copy_across_lifetimes(int source_lifetime_arg, int source_owner_id_arg, |
| int source_id_arg, int source_usage_arg, |
| int source_alg_arg, int source_alg2_arg, |
| int type_arg, data_t *material, |
| int target_lifetime_arg, int target_owner_id_arg, |
| int target_id_arg, int target_usage_arg, |
| int target_alg_arg, int target_alg2_arg, |
| int expected_usage_arg, |
| int expected_alg_arg, int expected_alg2_arg) |
| { |
| psa_key_lifetime_t source_lifetime = source_lifetime_arg; |
| mbedtls_svc_key_id_t source_id = |
| mbedtls_svc_key_id_make(source_owner_id_arg, source_id_arg); |
| psa_key_usage_t source_usage = source_usage_arg; |
| psa_algorithm_t source_alg = source_alg_arg; |
| psa_key_attributes_t source_attributes = PSA_KEY_ATTRIBUTES_INIT; |
| psa_key_type_t source_type = type_arg; |
| mbedtls_svc_key_id_t returned_source_id = MBEDTLS_SVC_KEY_ID_INIT; |
| psa_key_lifetime_t target_lifetime = target_lifetime_arg; |
| mbedtls_svc_key_id_t target_id = |
| mbedtls_svc_key_id_make(target_owner_id_arg, target_id_arg); |
| psa_key_usage_t target_usage = target_usage_arg; |
| psa_algorithm_t target_alg = target_alg_arg; |
| psa_key_attributes_t target_attributes = PSA_KEY_ATTRIBUTES_INIT; |
| mbedtls_svc_key_id_t returned_target_id = MBEDTLS_SVC_KEY_ID_INIT; |
| psa_key_handle_t target_handle = PSA_KEY_HANDLE_INIT; |
| psa_key_usage_t expected_usage = expected_usage_arg; |
| psa_algorithm_t expected_alg = expected_alg_arg; |
| psa_algorithm_t expected_alg2 = expected_alg2_arg; |
| uint8_t *export_buffer = NULL; |
| |
| TEST_USES_KEY_ID(source_id); |
| TEST_USES_KEY_ID(target_id); |
| |
| PSA_ASSERT(psa_crypto_init()); |
| |
| /* Populate the source slot. */ |
| psa_set_key_id(&source_attributes, source_id); |
| psa_set_key_lifetime(&source_attributes, source_lifetime); |
| |
| psa_set_key_type(&source_attributes, source_type); |
| psa_set_key_usage_flags(&source_attributes, source_usage); |
| psa_set_key_algorithm(&source_attributes, source_alg); |
| psa_set_key_enrollment_algorithm(&source_attributes, source_alg2_arg); |
| PSA_ASSERT(psa_import_key(&source_attributes, |
| material->x, material->len, |
| &returned_source_id)); |
| /* Update the attributes with the bit size. */ |
| PSA_ASSERT(psa_get_key_attributes(returned_source_id, |
| &source_attributes)); |
| |
| /* Prepare the target slot. */ |
| psa_set_key_id(&target_attributes, target_id); |
| psa_set_key_lifetime(&target_attributes, target_lifetime); |
| |
| psa_set_key_usage_flags(&target_attributes, target_usage); |
| psa_set_key_algorithm(&target_attributes, target_alg); |
| psa_set_key_enrollment_algorithm(&target_attributes, target_alg2_arg); |
| |
| /* Copy the key. */ |
| PSA_ASSERT(psa_copy_key(returned_source_id, |
| &target_attributes, &returned_target_id)); |
| |
| /* Destroy the source to ensure that this doesn't affect the target. */ |
| PSA_ASSERT(psa_destroy_key(returned_source_id)); |
| |
| /* If the target key is persistent, restart the system to make |
| * sure that the material is still alive. */ |
| if (!PSA_KEY_LIFETIME_IS_VOLATILE(target_lifetime)) { |
| mbedtls_psa_crypto_free(); |
| PSA_ASSERT(psa_crypto_init()); |
| PSA_ASSERT(psa_open_key(target_id, &target_handle)); |
| } |
| |
| /* Test that the target slot has the expected content. */ |
| psa_reset_key_attributes(&target_attributes); |
| PSA_ASSERT(psa_get_key_attributes(returned_target_id, |
| &target_attributes)); |
| |
| if (!PSA_KEY_LIFETIME_IS_VOLATILE(target_lifetime)) { |
| TEST_ASSERT(mbedtls_svc_key_id_equal( |
| target_id, psa_get_key_id(&target_attributes))); |
| } else { |
| #if defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER) |
| TEST_EQUAL(MBEDTLS_SVC_KEY_ID_GET_OWNER_ID(returned_target_id), |
| target_owner_id_arg); |
| #endif |
| } |
| |
| TEST_EQUAL(target_lifetime, psa_get_key_lifetime(&target_attributes)); |
| TEST_EQUAL(source_type, psa_get_key_type(&target_attributes)); |
| TEST_EQUAL(psa_get_key_bits(&source_attributes), |
| psa_get_key_bits(&target_attributes)); |
| TEST_EQUAL(expected_usage, psa_get_key_usage_flags(&target_attributes)); |
| TEST_EQUAL(expected_alg, psa_get_key_algorithm(&target_attributes)); |
| TEST_EQUAL(expected_alg2, |
| psa_get_key_enrollment_algorithm(&target_attributes)); |
| if (expected_usage & PSA_KEY_USAGE_EXPORT) { |
| size_t length; |
| TEST_CALLOC(export_buffer, material->len); |
| PSA_ASSERT(psa_export_key(returned_target_id, export_buffer, |
| material->len, &length)); |
| TEST_MEMORY_COMPARE(material->x, material->len, |
| export_buffer, length); |
| } else { |
| size_t length; |
| /* Check that the key is actually non-exportable. */ |
| TEST_EQUAL(psa_export_key(returned_target_id, export_buffer, |
| material->len, &length), |
| PSA_ERROR_NOT_PERMITTED); |
| } |
| |
| PSA_ASSERT(psa_destroy_key(returned_target_id)); |
| |
| exit: |
| /* |
| * Source and target key attributes may have been returned by |
| * psa_get_key_attributes() thus reset them as required. |
| */ |
| psa_reset_key_attributes(&source_attributes); |
| psa_reset_key_attributes(&target_attributes); |
| |
| PSA_DONE(); |
| mbedtls_free(export_buffer); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void copy_to_occupied(int source_lifetime_arg, int source_id_arg, |
| int source_usage_arg, int source_alg_arg, |
| int source_type_arg, data_t *source_material, |
| int target_lifetime_arg, int target_id_arg, |
| int target_usage_arg, int target_alg_arg, |
| int target_type_arg, data_t *target_material) |
| { |
| psa_key_lifetime_t source_lifetime = source_lifetime_arg; |
| mbedtls_svc_key_id_t source_id = |
| mbedtls_svc_key_id_make(1, source_id_arg); |
| psa_key_usage_t source_usage = source_usage_arg; |
| psa_algorithm_t source_alg = source_alg_arg; |
| psa_key_type_t source_type = source_type_arg; |
| mbedtls_svc_key_id_t returned_source_id = MBEDTLS_SVC_KEY_ID_INIT; |
| psa_key_lifetime_t target_lifetime = target_lifetime_arg; |
| mbedtls_svc_key_id_t target_id = |
| mbedtls_svc_key_id_make(1, target_id_arg); |
| psa_key_usage_t target_usage = target_usage_arg; |
| psa_algorithm_t target_alg = target_alg_arg; |
| psa_key_type_t target_type = target_type_arg; |
| mbedtls_svc_key_id_t returned_target_id = MBEDTLS_SVC_KEY_ID_INIT; |
| mbedtls_svc_key_id_t new_key = MBEDTLS_SVC_KEY_ID_INIT; |
| uint8_t *export_buffer = NULL; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| psa_key_attributes_t attributes1 = PSA_KEY_ATTRIBUTES_INIT; |
| psa_key_attributes_t attributes2 = PSA_KEY_ATTRIBUTES_INIT; |
| |
| TEST_USES_KEY_ID(source_id); |
| TEST_USES_KEY_ID(target_id); |
| |
| PSA_ASSERT(psa_crypto_init()); |
| |
| /* Populate the source slot. */ |
| if (!PSA_KEY_LIFETIME_IS_VOLATILE(source_lifetime)) { |
| psa_set_key_id(&attributes, source_id); |
| psa_set_key_lifetime(&attributes, source_lifetime); |
| } |
| psa_set_key_type(&attributes, source_type); |
| psa_set_key_usage_flags(&attributes, source_usage); |
| psa_set_key_algorithm(&attributes, source_alg); |
| PSA_ASSERT(psa_import_key(&attributes, |
| source_material->x, source_material->len, |
| &returned_source_id)); |
| |
| /* Populate the target slot. */ |
| if (mbedtls_svc_key_id_equal(target_id, source_id)) { |
| returned_target_id = returned_source_id; |
| } else { |
| psa_set_key_id(&attributes1, target_id); |
| psa_set_key_lifetime(&attributes1, target_lifetime); |
| psa_set_key_type(&attributes1, target_type); |
| psa_set_key_usage_flags(&attributes1, target_usage); |
| psa_set_key_algorithm(&attributes1, target_alg); |
| PSA_ASSERT(psa_import_key(&attributes1, |
| target_material->x, target_material->len, |
| &returned_target_id)); |
| } |
| |
| PSA_ASSERT(psa_get_key_attributes(returned_target_id, &attributes1)); |
| |
| /* Make a copy attempt. */ |
| psa_set_key_id(&attributes, target_id); |
| psa_set_key_lifetime(&attributes, target_lifetime); |
| TEST_EQUAL(psa_copy_key(returned_source_id, |
| &attributes, &new_key), |
| PSA_ERROR_ALREADY_EXISTS); |
| TEST_ASSERT(mbedtls_svc_key_id_is_null(new_key)); |
| |
| /* Test that the target slot is unaffected. */ |
| PSA_ASSERT(psa_get_key_attributes(returned_target_id, &attributes2)); |
| TEST_ASSERT(mbedtls_svc_key_id_equal( |
| psa_get_key_id(&attributes1), |
| psa_get_key_id(&attributes2))); |
| TEST_EQUAL(psa_get_key_lifetime(&attributes1), |
| psa_get_key_lifetime(&attributes2)); |
| TEST_EQUAL(psa_get_key_type(&attributes1), |
| psa_get_key_type(&attributes2)); |
| TEST_EQUAL(psa_get_key_bits(&attributes1), |
| psa_get_key_bits(&attributes2)); |
| TEST_EQUAL(psa_get_key_usage_flags(&attributes1), |
| psa_get_key_usage_flags(&attributes2)); |
| TEST_EQUAL(psa_get_key_algorithm(&attributes1), |
| psa_get_key_algorithm(&attributes2)); |
| if (target_usage & PSA_KEY_USAGE_EXPORT) { |
| size_t length; |
| TEST_CALLOC(export_buffer, target_material->len); |
| PSA_ASSERT(psa_export_key(returned_target_id, export_buffer, |
| target_material->len, &length)); |
| TEST_MEMORY_COMPARE(target_material->x, target_material->len, |
| export_buffer, length); |
| } |
| |
| PSA_ASSERT(psa_destroy_key(returned_source_id)); |
| if (!mbedtls_svc_key_id_equal(target_id, source_id)) { |
| PSA_ASSERT(psa_destroy_key(returned_target_id)); |
| } |
| |
| exit: |
| /* |
| * Key attributes may have been returned by psa_get_key_attributes() |
| * thus reset them as required. |
| */ |
| psa_reset_key_attributes(&attributes1); |
| psa_reset_key_attributes(&attributes2); |
| |
| PSA_DONE(); |
| mbedtls_free(export_buffer); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void invalid_handle(int handle_construction, |
| int close_status_arg) |
| { |
| psa_key_handle_t valid_handle = PSA_KEY_HANDLE_INIT; |
| psa_key_handle_t invalid_handle = PSA_KEY_HANDLE_INIT; |
| psa_key_id_t key_id; |
| psa_status_t close_status = close_status_arg; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| uint8_t material[1] = "a"; |
| |
| PSA_ASSERT(psa_crypto_init()); |
| |
| /* Allocate a handle and store a key in it. */ |
| psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA); |
| psa_set_key_usage_flags(&attributes, 0); |
| psa_set_key_algorithm(&attributes, 0); |
| PSA_ASSERT(psa_import_key(&attributes, |
| material, sizeof(material), |
| &valid_handle)); |
| TEST_ASSERT(!psa_key_handle_is_null(valid_handle)); |
| |
| /* Construct an invalid handle as specified in the test case data. */ |
| switch (handle_construction) { |
| case INVALID_HANDLE_0: |
| invalid_handle = PSA_KEY_HANDLE_INIT; |
| break; |
| case INVALID_HANDLE_UNOPENED: |
| |
| /* |
| * MBEDTLS_SVC_KEY_ID_GET_KEY_ID( valid_handle ) is a volatile |
| * key identifier as the imported key is a volatile key. Volatile |
| * key identifiers are in the range from PSA_KEY_ID_VOLATILE_MIN |
| * to PSA_KEY_ID_VOLATILE_MAX included. It is very unlikely that |
| * all IDs are used up to the last one, so pick |
| * PSA_KEY_ID_VOLATILE_MAX to build an unopened and thus invalid |
| * identifier. |
| */ |
| key_id = PSA_KEY_ID_VOLATILE_MAX; |
| |
| invalid_handle = |
| mbedtls_svc_key_id_make(0, key_id); |
| break; |
| case INVALID_HANDLE_CLOSED: |
| PSA_ASSERT(psa_import_key(&attributes, |
| material, sizeof(material), |
| &invalid_handle)); |
| PSA_ASSERT(psa_destroy_key(invalid_handle)); |
| break; |
| case INVALID_HANDLE_HUGE: |
| invalid_handle = |
| mbedtls_svc_key_id_make(0, PSA_KEY_ID_VENDOR_MAX + 1); |
| break; |
| default: |
| TEST_FAIL("unknown handle construction"); |
| } |
| |
| /* Attempt to use the invalid handle. */ |
| TEST_EQUAL(psa_get_key_attributes(invalid_handle, &attributes), |
| PSA_ERROR_INVALID_HANDLE); |
| TEST_EQUAL(psa_close_key(invalid_handle), close_status); |
| TEST_EQUAL(psa_destroy_key(invalid_handle), close_status); |
| |
| /* After all this, check that the original handle is intact. */ |
| PSA_ASSERT(psa_get_key_attributes(valid_handle, &attributes)); |
| TEST_EQUAL(psa_get_key_type(&attributes), PSA_KEY_TYPE_RAW_DATA); |
| TEST_EQUAL(psa_get_key_bits(&attributes), |
| PSA_BYTES_TO_BITS(sizeof(material))); |
| PSA_ASSERT(psa_close_key(valid_handle)); |
| |
| exit: |
| /* |
| * Key attributes may have been returned by psa_get_key_attributes() |
| * thus reset them as required. |
| */ |
| psa_reset_key_attributes(&attributes); |
| |
| PSA_DONE(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE */ |
| void many_transient_keys(int max_keys_arg) |
| { |
| mbedtls_svc_key_id_t *keys = NULL; |
| size_t max_keys = max_keys_arg; |
| size_t i, j; |
| psa_status_t status; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| uint8_t exported[sizeof(size_t)]; |
| size_t exported_length; |
| |
| TEST_CALLOC(keys, max_keys); |
| PSA_ASSERT(psa_crypto_init()); |
| |
| psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT); |
| psa_set_key_algorithm(&attributes, 0); |
| psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA); |
| |
| for (i = 0; i < max_keys; i++) { |
| status = psa_import_key(&attributes, |
| (uint8_t *) &i, sizeof(i), |
| &keys[i]); |
| if (status == PSA_ERROR_INSUFFICIENT_MEMORY) { |
| break; |
| } |
| PSA_ASSERT(status); |
| TEST_ASSERT(!mbedtls_svc_key_id_is_null(keys[i])); |
| for (j = 0; j < i; j++) { |
| TEST_ASSERT(!mbedtls_svc_key_id_equal(keys[i], keys[j])); |
| } |
| } |
| max_keys = i; |
| |
| for (i = 1; i < max_keys; i++) { |
| PSA_ASSERT(psa_close_key(keys[i - 1])); |
| PSA_ASSERT(psa_export_key(keys[i], |
| exported, sizeof(exported), |
| &exported_length)); |
| TEST_MEMORY_COMPARE(exported, exported_length, |
| (uint8_t *) &i, sizeof(i)); |
| } |
| PSA_ASSERT(psa_close_key(keys[i - 1])); |
| |
| exit: |
| PSA_DONE(); |
| mbedtls_free(keys); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_STORAGE_C */ |
| void key_slot_eviction_to_import_new_key(int lifetime_arg) |
| { |
| psa_key_lifetime_t lifetime = (psa_key_lifetime_t) lifetime_arg; |
| size_t i; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| uint8_t exported[sizeof(size_t)]; |
| size_t exported_length; |
| mbedtls_svc_key_id_t key, returned_key_id; |
| |
| PSA_ASSERT(psa_crypto_init()); |
| |
| psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT); |
| psa_set_key_algorithm(&attributes, 0); |
| psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA); |
| |
| /* |
| * Create MBEDTLS_PSA_KEY_SLOT_COUNT persistent keys. |
| */ |
| for (i = 0; i < MBEDTLS_PSA_KEY_SLOT_COUNT; i++) { |
| key = mbedtls_svc_key_id_make(i, i + 1); |
| psa_set_key_id(&attributes, key); |
| PSA_ASSERT(psa_import_key(&attributes, |
| (uint8_t *) &i, sizeof(i), |
| &returned_key_id)); |
| TEST_ASSERT(mbedtls_svc_key_id_equal(returned_key_id, key)); |
| } |
| |
| /* |
| * Create a new persistent or volatile key. When creating the key, |
| * one of the descriptions of the previously created persistent keys |
| * is removed from the RAM key slots. This makes room to store its |
| * description in RAM. |
| */ |
| i = MBEDTLS_PSA_KEY_SLOT_COUNT; |
| key = mbedtls_svc_key_id_make(i, i + 1); |
| psa_set_key_id(&attributes, key); |
| psa_set_key_lifetime(&attributes, lifetime); |
| |
| PSA_ASSERT(psa_import_key(&attributes, |
| (uint8_t *) &i, sizeof(i), |
| &returned_key_id)); |
| if (lifetime != PSA_KEY_LIFETIME_VOLATILE) { |
| TEST_ASSERT(mbedtls_svc_key_id_equal(returned_key_id, key)); |
| } else { |
| TEST_ASSERT(psa_key_id_is_volatile( |
| MBEDTLS_SVC_KEY_ID_GET_KEY_ID(returned_key_id))); |
| } |
| |
| /* |
| * Check that we can export all ( MBEDTLS_PSA_KEY_SLOT_COUNT + 1 ) keys, |
| * that they have the expected value and destroy them. In that process, |
| * the description of the persistent key that was evicted from the RAM |
| * slots when creating the last key is restored in a RAM slot to export |
| * its value. |
| */ |
| for (i = 0; i <= MBEDTLS_PSA_KEY_SLOT_COUNT; i++) { |
| if (i < MBEDTLS_PSA_KEY_SLOT_COUNT) { |
| key = mbedtls_svc_key_id_make(i, i + 1); |
| } else { |
| key = returned_key_id; |
| } |
| |
| PSA_ASSERT(psa_export_key(key, |
| exported, sizeof(exported), |
| &exported_length)); |
| TEST_MEMORY_COMPARE(exported, exported_length, |
| (uint8_t *) &i, sizeof(i)); |
| PSA_ASSERT(psa_destroy_key(key)); |
| } |
| |
| exit: |
| PSA_DONE(); |
| } |
| /* END_CASE */ |
| |
| /* BEGIN_CASE depends_on:MBEDTLS_PSA_CRYPTO_STORAGE_C */ |
| void non_reusable_key_slots_integrity_in_case_of_key_slot_starvation() |
| { |
| psa_status_t status; |
| size_t i; |
| psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| uint8_t exported[sizeof(size_t)]; |
| size_t exported_length; |
| mbedtls_svc_key_id_t persistent_key = MBEDTLS_SVC_KEY_ID_INIT; |
| mbedtls_svc_key_id_t persistent_key2 = MBEDTLS_SVC_KEY_ID_INIT; |
| mbedtls_svc_key_id_t returned_key_id = MBEDTLS_SVC_KEY_ID_INIT; |
| mbedtls_svc_key_id_t *keys = NULL; |
| mbedtls_psa_stats_t psa_key_slots_stats; |
| size_t available_key_slots = 0; |
| |
| TEST_ASSERT(MBEDTLS_PSA_KEY_SLOT_COUNT >= 1); |
| |
| PSA_ASSERT(psa_crypto_init()); |
| mbedtls_psa_get_stats(&psa_key_slots_stats); |
| available_key_slots = psa_key_slots_stats.empty_slots; |
| |
| TEST_CALLOC(keys, available_key_slots); |
| |
| psa_set_key_usage_flags(&attributes, |
| PSA_KEY_USAGE_EXPORT | PSA_KEY_USAGE_COPY); |
| psa_set_key_algorithm(&attributes, 0); |
| psa_set_key_type(&attributes, PSA_KEY_TYPE_RAW_DATA); |
| |
| /* |
| * Create a persistent key |
| */ |
| persistent_key = mbedtls_svc_key_id_make(0x100, 0x205); |
| psa_set_key_id(&attributes, persistent_key); |
| PSA_ASSERT(psa_import_key(&attributes, |
| (uint8_t *) &persistent_key, |
| sizeof(persistent_key), |
| &returned_key_id)); |
| TEST_ASSERT(mbedtls_svc_key_id_equal(returned_key_id, persistent_key)); |
| |
| /* |
| * Create the maximum available number of volatile keys |
| */ |
| psa_set_key_lifetime(&attributes, PSA_KEY_LIFETIME_VOLATILE); |
| for (i = 0; i < available_key_slots; i++) { |
| PSA_ASSERT(psa_import_key(&attributes, |
| (uint8_t *) &i, sizeof(i), |
| &keys[i])); |
| } |
| psa_reset_key_attributes(&attributes); |
| |
| /* |
| * Check that we cannot access the persistent key as all slots are |
| * occupied by volatile keys and the implementation needs to load the |
| * persistent key description in a slot to be able to access it. |
| */ |
| status = psa_get_key_attributes(persistent_key, &attributes); |
| TEST_EQUAL(status, PSA_ERROR_INSUFFICIENT_MEMORY); |
| |
| /* |
| * Check we can export the volatile key created last and that it has the |
| * expected value. Then, destroy it. |
| */ |
| PSA_ASSERT(psa_export_key(keys[available_key_slots - 1], |
| exported, sizeof(exported), |
| &exported_length)); |
| i = available_key_slots - 1; |
| TEST_MEMORY_COMPARE(exported, exported_length, (uint8_t *) &i, sizeof(i)); |
| PSA_ASSERT(psa_destroy_key(keys[available_key_slots - 1])); |
| |
| /* |
| * Check that we can now access the persistent key again. |
| */ |
| PSA_ASSERT(psa_get_key_attributes(persistent_key, &attributes)); |
| TEST_ASSERT(mbedtls_svc_key_id_equal(attributes.id, |
| persistent_key)); |
| |
| /* |
| * Check that we cannot copy the persistent key as all slots are occupied |
| * by the persistent key and the volatile keys and the slot containing the |
| * persistent key cannot be reclaimed as it contains the key to copy. |
| */ |
| persistent_key2 = mbedtls_svc_key_id_make(0x100, 0x204); |
| psa_set_key_id(&attributes, persistent_key2); |
| status = psa_copy_key(persistent_key, &attributes, &returned_key_id); |
| TEST_EQUAL(status, PSA_ERROR_INSUFFICIENT_MEMORY); |
| |
| /* |
| * Check we can export the remaining volatile keys and that they have the |
| * expected values. |
| */ |
| for (i = 0; i < (available_key_slots - 1); i++) { |
| PSA_ASSERT(psa_export_key(keys[i], |
| exported, sizeof(exported), |
| &exported_length)); |
| TEST_MEMORY_COMPARE(exported, exported_length, |
| (uint8_t *) &i, sizeof(i)); |
| PSA_ASSERT(psa_destroy_key(keys[i])); |
| } |
| |
| /* |
| * Check we can export the persistent key and that it have the expected |
| * value. |
| */ |
| |
| PSA_ASSERT(psa_export_key(persistent_key, exported, sizeof(exported), |
| &exported_length)); |
| TEST_MEMORY_COMPARE(exported, exported_length, |
| (uint8_t *) &persistent_key, sizeof(persistent_key)); |
| exit: |
| /* |
| * Key attributes may have been returned by psa_get_key_attributes() |
| * thus reset them as required. |
| */ |
| psa_reset_key_attributes(&attributes); |
| |
| psa_destroy_key(persistent_key); |
| PSA_DONE(); |
| mbedtls_free(keys); |
| } |
| /* END_CASE */ |
