yuzu/mbedtls
1
0
Fork 0
mirror of https://github.com/yuzu-emu/mbedtls.git synced 2024-12-25 04:25:44 +00:00
Code Issues Packages Projects Releases Wiki Activity
mbedtls/tests/suites/test_suite_psa_crypto_se_driver_hal.data

173 lines
8.8 KiB
Plaintext
Raw Normal View History

Smoke test for secure element driver registration
2019-06-24 11:47:24 +00:00
Register SE driver: good
register_one:2:PSA_DRV_SE_HAL_VERSION:PSA_SUCCESS
Add negative tests for driver registration
2019-06-24 12:34:59 +00:00
# Run this test case a second time to verify that the library deinit
# unregistered the first driver.
Register SE driver: good, again
register_one:2:PSA_DRV_SE_HAL_VERSION:PSA_SUCCESS
Update SE support to pass a location when registering a driver Now that lifetimes have structures and secure element drivers handle all the lifetimes with a certain location, update driver registration to take a location as argument rather than a lifetime. This commit updates the tests. Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
2020-05-09 22:44:30 +00:00
Register SE driver: invalid location (0)
Fix typo in invalid-lifetime test and add explicit test for 0
2019-06-26 09:50:30 +00:00
register_one:0:PSA_DRV_SE_HAL_VERSION:PSA_ERROR_INVALID_ARGUMENT
Update SE support to pass a location when registering a driver Now that lifetimes have structures and secure element drivers handle all the lifetimes with a certain location, update driver registration to take a location as argument rather than a lifetime. This commit updates the tests. Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
2020-05-09 22:44:30 +00:00
Register SE driver: invalid location (local)
register_one:PSA_KEY_LOCATION_LOCAL_STORAGE:PSA_DRV_SE_HAL_VERSION:PSA_ERROR_INVALID_ARGUMENT
Add negative tests for driver registration
2019-06-24 12:34:59 +00:00
Driver registration: more future-proof bad-version test
2019-06-24 17:58:12 +00:00
Register SE driver: invalid version (ancient)
register_one:2:0x00000003:PSA_ERROR_NOT_SUPPORTED
Register SE driver: invalid version (future)
register_one:2:PSA_DRV_SE_HAL_VERSION + 1:PSA_ERROR_NOT_SUPPORTED
Add negative tests for driver registration
2019-06-24 12:34:59 +00:00
Register SE driver: already registered
register_twice:3
Register SE driver: maximum number of drivers
register_max:
SE keys: smoke test import, export, destroy
2019-07-12 21:47:47 +00:00
Add test to check that volatile external keys do not get persisted Signed-off-by: Steven Cooreman <steven.cooreman@silabs.com>
2020-06-08 16:30:20 +00:00
SE key import-export persistent (p_allocate allows all slots)
key_creation_import_export:TEST_SE_PERSISTENT_LIFETIME:0:0
SE keys: smoke test import, export, destroy
2019-07-12 21:47:47 +00:00
Add test to check that volatile external keys do not get persisted Signed-off-by: Steven Cooreman <steven.cooreman@silabs.com>
2020-06-08 16:30:20 +00:00
SE key import-export persistent (p_allocate allows 1 slot)
key_creation_import_export:TEST_SE_PERSISTENT_LIFETIME:ARRAY_LENGTH( ram_slots ) - 1:0
SE keys: implement persistent storage For a key in a secure element, persist the key slot. This is implemented in the nominal case. Failures may not be handled properly.
2019-07-23 14:13:14 +00:00
Add test to check that volatile external keys do not get persisted Signed-off-by: Steven Cooreman <steven.cooreman@silabs.com>
2020-06-08 16:30:20 +00:00
SE key import-export persistent, check after restart (slot 0)
key_creation_import_export:TEST_SE_PERSISTENT_LIFETIME:0:1
SE keys: implement persistent storage For a key in a secure element, persist the key slot. This is implemented in the nominal case. Failures may not be handled properly.
2019-07-23 14:13:14 +00:00
Add test to check that volatile external keys do not get persisted Signed-off-by: Steven Cooreman <steven.cooreman@silabs.com>
2020-06-08 16:30:20 +00:00
SE key import-export persistent, check after restart (slot 3)
key_creation_import_export:TEST_SE_PERSISTENT_LIFETIME:3:1
SE key import-export volatile (p_allocate allows all slots)
key_creation_import_export:TEST_SE_VOLATILE_LIFETIME:0:0
SE key import-export volatile (p_allocate allows 1 slot)
key_creation_import_export:TEST_SE_VOLATILE_LIFETIME:ARRAY_LENGTH( ram_slots ) - 1:0
SE key import-export volatile, check after restart (slot 0)
key_creation_import_export:TEST_SE_VOLATILE_LIFETIME:0:1
SE key import-export volatile, check after restart (slot 3)
key_creation_import_export:TEST_SE_VOLATILE_LIFETIME:3:1
SE keys: test NOT_SUPPORTED error from generate_key
2019-07-24 11:45:02 +00:00
Support slot_number attribute when creating a key Allow the application to choose the slot number in a secure element, rather than always letting the driver choose. With this commit, any application may request any slot. In an implementation with isolation, it's up to the service to filter key creation requests and apply policies to limit which applications can request which slot.
2019-08-05 12:55:50 +00:00
Key creation in a specific slot (0)
Test restarting after creating a key in a specific slot
2019-08-05 12:59:15 +00:00
key_creation_in_chosen_slot:0:0:PSA_SUCCESS
Support slot_number attribute when creating a key Allow the application to choose the slot number in a secure element, rather than always letting the driver choose. With this commit, any application may request any slot. In an implementation with isolation, it's up to the service to filter key creation requests and apply policies to limit which applications can request which slot.
2019-08-05 12:55:50 +00:00
Key creation in a specific slot (max)
Test restarting after creating a key in a specific slot
2019-08-05 12:59:15 +00:00
key_creation_in_chosen_slot:ARRAY_LENGTH( ram_slots ) - 1:0:PSA_SUCCESS
Key creation in a specific slot (0, restart)
key_creation_in_chosen_slot:0:1:PSA_SUCCESS
Key creation in a specific slot (max, restart)
key_creation_in_chosen_slot:ARRAY_LENGTH( ram_slots ) - 1:1:PSA_SUCCESS
Support slot_number attribute when creating a key Allow the application to choose the slot number in a secure element, rather than always letting the driver choose. With this commit, any application may request any slot. In an implementation with isolation, it's up to the service to filter key creation requests and apply policies to limit which applications can request which slot.
2019-08-05 12:55:50 +00:00
Key creation in a specific slot (too large)
Test restarting after creating a key in a specific slot
2019-08-05 12:59:15 +00:00
key_creation_in_chosen_slot:ARRAY_LENGTH( ram_slots ):0:PSA_ERROR_INVALID_ARGUMENT
Support slot_number attribute when creating a key Allow the application to choose the slot number in a secure element, rather than always letting the driver choose. With this commit, any application may request any slot. In an implementation with isolation, it's up to the service to filter key creation requests and apply policies to limit which applications can request which slot.
2019-08-05 12:55:50 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: AES-CTR
import_key_smoke:PSA_KEY_TYPE_AES:PSA_ALG_CTR:"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: AES-CBC
import_key_smoke:PSA_KEY_TYPE_AES:PSA_ALG_CBC_NO_PADDING:"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: AES-CMAC
import_key_smoke:PSA_KEY_TYPE_AES:PSA_ALG_CMAC:"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: AES-CCM
import_key_smoke:PSA_KEY_TYPE_AES:PSA_ALG_CCM:"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: AES-GCM
import_key_smoke:PSA_KEY_TYPE_AES:PSA_ALG_GCM:"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: CAMELLIA-CTR
import_key_smoke:PSA_KEY_TYPE_CAMELLIA:PSA_ALG_CTR:"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: CAMELLIA-CBC
import_key_smoke:PSA_KEY_TYPE_CAMELLIA:PSA_ALG_CBC_NO_PADDING:"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: CAMELLIA-CMAC
import_key_smoke:PSA_KEY_TYPE_CAMELLIA:PSA_ALG_CMAC:"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: CAMELLIA-CCM
psa_crypto_se_driver_hal: Fix copypasta in test cases Before: say CCM twice, do GCM twice. After: say CCM and do CCM, then say GCM and do GCM.
2019-09-19 18:59:15 +00:00
import_key_smoke:PSA_KEY_TYPE_CAMELLIA:PSA_ALG_CCM:"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
psa_crypto_se_driver_hal: Fix copypasta in test cases Before: say CCM twice, do GCM twice. After: say CCM and do CCM, then say GCM and do GCM.
2019-09-19 18:59:15 +00:00
Key import smoke test: CAMELLIA-GCM
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
import_key_smoke:PSA_KEY_TYPE_CAMELLIA:PSA_ALG_GCM:"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: HMAC-SHA-256
import_key_smoke:PSA_KEY_TYPE_HMAC:PSA_ALG_HMAC( PSA_ALG_SHA_256 ):"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: HKDF-SHA-256
import_key_smoke:PSA_KEY_TYPE_DERIVE:PSA_ALG_HKDF( PSA_ALG_SHA_256 ):"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: RSA PKCS#1v1.5 signature
import_key_smoke:PSA_KEY_TYPE_RSA_KEY_PAIR:PSA_ALG_RSA_PKCS1V15_SIGN_RAW:"30818902818100af057d396ee84fb75fdbb5c2b13c7fe5a654aa8aa2470b541ee1feb0b12d25c79711531249e1129628042dbbb6c120d1443524ef4c0e6e1d8956eeb2077af12349ddeee54483bc06c2c61948cd02b202e796aebd94d3a7cbf859c2c1819c324cb82b9cd34ede263a2abffe4733f077869e8660f7d6834da53d690ef7985f6bc30203010001"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: RSA PKCS#1v1.5 encryption
import_key_smoke:PSA_KEY_TYPE_RSA_KEY_PAIR:PSA_ALG_RSA_PKCS1V15_CRYPT:"30818902818100af057d396ee84fb75fdbb5c2b13c7fe5a654aa8aa2470b541ee1feb0b12d25c79711531249e1129628042dbbb6c120d1443524ef4c0e6e1d8956eeb2077af12349ddeee54483bc06c2c61948cd02b202e796aebd94d3a7cbf859c2c1819c324cb82b9cd34ede263a2abffe4733f077869e8660f7d6834da53d690ef7985f6bc30203010001"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: RSA OAEP encryption
import_key_smoke:PSA_KEY_TYPE_RSA_KEY_PAIR:PSA_ALG_RSA_OAEP( PSA_ALG_SHA_256 ):"30818902818100af057d396ee84fb75fdbb5c2b13c7fe5a654aa8aa2470b541ee1feb0b12d25c79711531249e1129628042dbbb6c120d1443524ef4c0e6e1d8956eeb2077af12349ddeee54483bc06c2c61948cd02b202e796aebd94d3a7cbf859c2c1819c324cb82b9cd34ede263a2abffe4733f077869e8660f7d6834da53d690ef7985f6bc30203010001"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: ECDSA secp256r1
Define EC curve family constants Define constants for ECC curve families and DH group families. These constants have 0x0000 in the lower 16 bits of the key type. Support these constants in the implementation and in the PSA metadata tests. Switch the slot management and secure element driver HAL tests to the new curve encodings. This requires SE driver code to become slightly more clever when figuring out the bit-size of an imported EC key since it now needs to take the data size into account. Switch some documentation to the new encodings. Remove the macro PSA_ECC_CURVE_BITS which can no longer be implemented.
2019-12-03 16:24:19 +00:00
import_key_smoke:PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_CURVE_SECP_R1 ):PSA_ALG_ECDSA_ANY:"49c9a8c18c4b885638c431cf1df1c994131609b580d4fd43a0cab17db2f13eee"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: ECDH secp256r1
Define EC curve family constants Define constants for ECC curve families and DH group families. These constants have 0x0000 in the lower 16 bits of the key type. Support these constants in the implementation and in the PSA metadata tests. Switch the slot management and secure element driver HAL tests to the new curve encodings. This requires SE driver code to become slightly more clever when figuring out the bit-size of an imported EC key since it now needs to take the data size into account. Switch some documentation to the new encodings. Remove the macro PSA_ECC_CURVE_BITS which can no longer be implemented.
2019-12-03 16:24:19 +00:00
import_key_smoke:PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_CURVE_SECP_R1 ):PSA_ALG_ECDH:"49c9a8c18c4b885638c431cf1df1c994131609b580d4fd43a0cab17db2f13eee"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key import smoke test: ECDH secp256r1 with HKDF
Define EC curve family constants Define constants for ECC curve families and DH group families. These constants have 0x0000 in the lower 16 bits of the key type. Support these constants in the implementation and in the PSA metadata tests. Switch the slot management and secure element driver HAL tests to the new curve encodings. This requires SE driver code to become slightly more clever when figuring out the bit-size of an imported EC key since it now needs to take the data size into account. Switch some documentation to the new encodings. Remove the macro PSA_ECC_CURVE_BITS which can no longer be implemented.
2019-12-03 16:24:19 +00:00
import_key_smoke:PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_CURVE_SECP_R1 ):PSA_ALG_KEY_AGREEMENT( PSA_ALG_ECDH, PSA_ALG_HKDF( PSA_ALG_SHA_256 ) ):"49c9a8c18c4b885638c431cf1df1c994131609b580d4fd43a0cab17db2f13eee"
SE keys: test that no function goes crazy Run all functions that take a key handle as input with a key that is in a secure element. All calls are expected to error out one way or another (not permitted by policy, invalid key type, method not implemented in the secure element, ...). The goal of this test is to ensure that nothing bad happens (e.g. invalid pointer dereference). Run with various key types and algorithms to get good coverage.
2019-07-24 11:45:36 +00:00
SE keys: test NOT_SUPPORTED error from generate_key
2019-07-24 11:45:02 +00:00
Generate key: not supported
generate_key_not_supported:PSA_KEY_TYPE_AES:128
New function mbedtls_psa_register_se_key Register an existing key in a secure element. Minimal implementation that doesn't call any driver method and just lets the application declare whatever it wants.
2019-08-05 13:55:54 +00:00
SE keys: implement and smoke-test p_generate
2019-08-06 16:36:36 +00:00
Key generation smoke test: AES-128-CTR
generate_key_smoke:PSA_KEY_TYPE_AES:128:PSA_ALG_CTR
Key generation smoke test: AES-256-CTR
generate_key_smoke:PSA_KEY_TYPE_AES:128:PSA_ALG_CTR
Key generation smoke test: HMAC-SHA-256
generate_key_smoke:PSA_KEY_TYPE_HMAC:256:PSA_ALG_HMAC( PSA_ALG_SHA_256 )
New function mbedtls_psa_register_se_key Register an existing key in a secure element. Minimal implementation that doesn't call any driver method and just lets the application declare whatever it wants.
2019-08-05 13:55:54 +00:00
Key registration: smoke test
Update SE support to pass a location when registering a driver Now that lifetimes have structures and secure element drivers handle all the lifetimes with a certain location, update driver registration to take a location as argument rather than a lifetime. This commit updates the tests. Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
2020-05-09 22:44:30 +00:00
register_key_smoke_test:TEST_SE_PERSISTENT_LIFETIME:1:PSA_SUCCESS
New function mbedtls_psa_register_se_key Register an existing key in a secure element. Minimal implementation that doesn't call any driver method and just lets the application declare whatever it wants.
2019-08-05 13:55:54 +00:00
Key registration: invalid lifetime (volatile)
SE support: Use a transaction when registering a key When registering a key in a secure element, go through the transaction mechanism. This makes the code simpler, at the expense of a few extra storage operations. Given that registering a key is typically very rare over the lifetime of a device, this is an acceptable loss. Drivers must now have a p_validate_slot_number method, otherwise registering a key is not possible. This reduces the risk that due to a mistake during the integration of a device, an application might claim a slot in a way that is not supported by the driver.
2019-10-01 12:18:35 +00:00
register_key_smoke_test:PSA_KEY_LIFETIME_VOLATILE:1:PSA_ERROR_INVALID_ARGUMENT
New function mbedtls_psa_register_se_key Register an existing key in a secure element. Minimal implementation that doesn't call any driver method and just lets the application declare whatever it wants.
2019-08-05 13:55:54 +00:00
Key registration: invalid lifetime (internal storage)
SE support: Use a transaction when registering a key When registering a key in a secure element, go through the transaction mechanism. This makes the code simpler, at the expense of a few extra storage operations. Given that registering a key is typically very rare over the lifetime of a device, this is an acceptable loss. Drivers must now have a p_validate_slot_number method, otherwise registering a key is not possible. This reduces the risk that due to a mistake during the integration of a device, an application might claim a slot in a way that is not supported by the driver.
2019-10-01 12:18:35 +00:00
register_key_smoke_test:PSA_KEY_LIFETIME_PERSISTENT:1:PSA_ERROR_INVALID_ARGUMENT
New function mbedtls_psa_register_se_key Register an existing key in a secure element. Minimal implementation that doesn't call any driver method and just lets the application declare whatever it wants.
2019-08-05 13:55:54 +00:00
Key registration: invalid lifetime (no registered driver)
Update SE support to pass a location when registering a driver Now that lifetimes have structures and secure element drivers handle all the lifetimes with a certain location, update driver registration to take a location as argument rather than a lifetime. This commit updates the tests. Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
2020-05-09 22:44:30 +00:00
register_key_smoke_test:PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION( PSA_KEY_PERSISTENCE_DEFAULT, TEST_DRIVER_LOCATION + 1 ):1:PSA_ERROR_INVALID_ARGUMENT
Test the call to p_validate_slot_number when registering a key
2019-08-05 15:17:52 +00:00
SE support: Use a transaction when registering a key When registering a key in a secure element, go through the transaction mechanism. This makes the code simpler, at the expense of a few extra storage operations. Given that registering a key is typically very rare over the lifetime of a device, this is an acceptable loss. Drivers must now have a p_validate_slot_number method, otherwise registering a key is not possible. This reduces the risk that due to a mistake during the integration of a device, an application might claim a slot in a way that is not supported by the driver.
2019-10-01 12:18:35 +00:00
Key registration: rejected
Update SE support to pass a location when registering a driver Now that lifetimes have structures and secure element drivers handle all the lifetimes with a certain location, update driver registration to take a location as argument rather than a lifetime. This commit updates the tests. Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
2020-05-09 22:44:30 +00:00
register_key_smoke_test:TEST_SE_PERSISTENT_LIFETIME:0:PSA_ERROR_NOT_PERMITTED
SE support: Test sign and verify hooks with a passthrough driver
2019-08-07 19:05:24 +00:00
SE support: Use a transaction when registering a key When registering a key in a secure element, go through the transaction mechanism. This makes the code simpler, at the expense of a few extra storage operations. Given that registering a key is typically very rare over the lifetime of a device, this is an acceptable loss. Drivers must now have a p_validate_slot_number method, otherwise registering a key is not possible. This reduces the risk that due to a mistake during the integration of a device, an application might claim a slot in a way that is not supported by the driver.
2019-10-01 12:18:35 +00:00
Key registration: not supported
Update SE support to pass a location when registering a driver Now that lifetimes have structures and secure element drivers handle all the lifetimes with a certain location, update driver registration to take a location as argument rather than a lifetime. This commit updates the tests. Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
2020-05-09 22:44:30 +00:00
register_key_smoke_test:TEST_SE_PERSISTENT_LIFETIME:-1:PSA_ERROR_NOT_SUPPORTED
SE support: Use a transaction when registering a key When registering a key in a secure element, go through the transaction mechanism. This makes the code simpler, at the expense of a few extra storage operations. Given that registering a key is typically very rare over the lifetime of a device, this is an acceptable loss. Drivers must now have a p_validate_slot_number method, otherwise registering a key is not possible. This reduces the risk that due to a mistake during the integration of a device, an application might claim a slot in a way that is not supported by the driver.
2019-10-01 12:18:35 +00:00
SE support: Test sign and verify hooks with a passthrough driver
2019-08-07 19:05:24 +00:00
Import-sign-verify: sign in driver, ECDSA
depends_on:MBEDTLS_ECDSA_C:MBEDTLS_ECP_C:MBEDTLS_ECP_DP_SECP256R1_ENABLED
Define EC curve family constants Define constants for ECC curve families and DH group families. These constants have 0x0000 in the lower 16 bits of the key type. Support these constants in the implementation and in the PSA metadata tests. Switch the slot management and secure element driver HAL tests to the new curve encodings. This requires SE driver code to become slightly more clever when figuring out the bit-size of an imported EC key since it now needs to take the data size into account. Switch some documentation to the new encodings. Remove the macro PSA_ECC_CURVE_BITS which can no longer be implemented.
2019-12-03 16:24:19 +00:00
sign_verify:SIGN_IN_DRIVER_AND_PARALLEL_CREATION:PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_CURVE_SECP_R1 ):PSA_ALG_ECDSA_ANY:0:"49c9a8c18c4b885638c431cf1df1c994131609b580d4fd43a0cab17db2f13eee":"54686973206973206e6f74206120686173682e"
SE generate/sign/verify tests: also test export_public Add a flow where the key is imported or fake-generated in the secure element, then call psa_export_public_key and do the software verification with the public key.
2019-08-09 10:50:39 +00:00
Import-sign-verify: sign in driver then export_public, ECDSA
depends_on:MBEDTLS_ECDSA_C:MBEDTLS_ECP_C:MBEDTLS_ECP_DP_SECP256R1_ENABLED
Define EC curve family constants Define constants for ECC curve families and DH group families. These constants have 0x0000 in the lower 16 bits of the key type. Support these constants in the implementation and in the PSA metadata tests. Switch the slot management and secure element driver HAL tests to the new curve encodings. This requires SE driver code to become slightly more clever when figuring out the bit-size of an imported EC key since it now needs to take the data size into account. Switch some documentation to the new encodings. Remove the macro PSA_ECC_CURVE_BITS which can no longer be implemented.
2019-12-03 16:24:19 +00:00
sign_verify:SIGN_IN_DRIVER_THEN_EXPORT_PUBLIC:PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_CURVE_SECP_R1 ):PSA_ALG_ECDSA_ANY:0:"49c9a8c18c4b885638c431cf1df1c994131609b580d4fd43a0cab17db2f13eee":"54686973206973206e6f74206120686173682e"
SE support: Test sign and verify hooks with a passthrough driver
2019-08-07 19:05:24 +00:00
Import-sign-verify: sign in software, ECDSA
depends_on:MBEDTLS_ECDSA_C:MBEDTLS_ECP_C:MBEDTLS_ECP_DP_SECP256R1_ENABLED
Define EC curve family constants Define constants for ECC curve families and DH group families. These constants have 0x0000 in the lower 16 bits of the key type. Support these constants in the implementation and in the PSA metadata tests. Switch the slot management and secure element driver HAL tests to the new curve encodings. This requires SE driver code to become slightly more clever when figuring out the bit-size of an imported EC key since it now needs to take the data size into account. Switch some documentation to the new encodings. Remove the macro PSA_ECC_CURVE_BITS which can no longer be implemented.
2019-12-03 16:24:19 +00:00
sign_verify:SIGN_IN_SOFTWARE_AND_PARALLEL_CREATION:PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_CURVE_SECP_R1 ):PSA_ALG_ECDSA_ANY:0:"49c9a8c18c4b885638c431cf1df1c994131609b580d4fd43a0cab17db2f13eee":"54686973206973206e6f74206120686173682e"
SE support: Test sign and verify hooks with a passthrough driver
2019-08-07 19:05:24 +00:00
Generate-sign-verify: sign in driver, ECDSA
depends_on:MBEDTLS_ECDSA_C:MBEDTLS_ECP_C:MBEDTLS_ECP_DP_SECP256R1_ENABLED
Define EC curve family constants Define constants for ECC curve families and DH group families. These constants have 0x0000 in the lower 16 bits of the key type. Support these constants in the implementation and in the PSA metadata tests. Switch the slot management and secure element driver HAL tests to the new curve encodings. This requires SE driver code to become slightly more clever when figuring out the bit-size of an imported EC key since it now needs to take the data size into account. Switch some documentation to the new encodings. Remove the macro PSA_ECC_CURVE_BITS which can no longer be implemented.
2019-12-03 16:24:19 +00:00
sign_verify:SIGN_IN_DRIVER_AND_PARALLEL_CREATION:PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_CURVE_SECP_R1 ):PSA_ALG_ECDSA_ANY:256:"49c9a8c18c4b885638c431cf1df1c994131609b580d4fd43a0cab17db2f13eee":"54686973206973206e6f74206120686173682e"
SE generate/sign/verify tests: also test export_public Add a flow where the key is imported or fake-generated in the secure element, then call psa_export_public_key and do the software verification with the public key.
2019-08-09 10:50:39 +00:00
Generate-sign-verify: sign in driver then export_public, ECDSA
depends_on:MBEDTLS_ECDSA_C:MBEDTLS_ECP_C:MBEDTLS_ECP_DP_SECP256R1_ENABLED
Define EC curve family constants Define constants for ECC curve families and DH group families. These constants have 0x0000 in the lower 16 bits of the key type. Support these constants in the implementation and in the PSA metadata tests. Switch the slot management and secure element driver HAL tests to the new curve encodings. This requires SE driver code to become slightly more clever when figuring out the bit-size of an imported EC key since it now needs to take the data size into account. Switch some documentation to the new encodings. Remove the macro PSA_ECC_CURVE_BITS which can no longer be implemented.
2019-12-03 16:24:19 +00:00
sign_verify:SIGN_IN_DRIVER_THEN_EXPORT_PUBLIC:PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_CURVE_SECP_R1 ):PSA_ALG_ECDSA_ANY:256:"49c9a8c18c4b885638c431cf1df1c994131609b580d4fd43a0cab17db2f13eee":"54686973206973206e6f74206120686173682e"
SE support: Test sign and verify hooks with a passthrough driver
2019-08-07 19:05:24 +00:00
Generate-sign-verify: sign in software, ECDSA
depends_on:MBEDTLS_ECDSA_C:MBEDTLS_ECP_C:MBEDTLS_ECP_DP_SECP256R1_ENABLED
Define EC curve family constants Define constants for ECC curve families and DH group families. These constants have 0x0000 in the lower 16 bits of the key type. Support these constants in the implementation and in the PSA metadata tests. Switch the slot management and secure element driver HAL tests to the new curve encodings. This requires SE driver code to become slightly more clever when figuring out the bit-size of an imported EC key since it now needs to take the data size into account. Switch some documentation to the new encodings. Remove the macro PSA_ECC_CURVE_BITS which can no longer be implemented.
2019-12-03 16:24:19 +00:00
sign_verify:SIGN_IN_SOFTWARE_AND_PARALLEL_CREATION:PSA_KEY_TYPE_ECC_KEY_PAIR( PSA_ECC_CURVE_SECP_R1 ):PSA_ALG_ECDSA_ANY:256:"49c9a8c18c4b885638c431cf1df1c994131609b580d4fd43a0cab17db2f13eee":"54686973206973206e6f74206120686173682e"
Reference in a new issue Copy permalink