yuzu-emu/mbedtls
1
0
Fork 0
mirror of https://github.com/yuzu-emu/mbedtls.git synced 2024-11-25 15:05:45 +01:00
Code Issues Packages Projects Releases Wiki Activity

psa: Move from key handle to key identifier

Browse Source 
Move all the PSA crypto APIs using key handles
to use key identifiers but psa_key_open() and
psa_key_close(). This is done without modifying
any test as key handles and key identifiers are
now the same.

Update the library modules using PSA crypto APIs
to get rid of key handles.

Programs and unit tests are updated to not use
key handles in subsequent commits, not in this
one.

Signed-off-by: Ronald Cron <ronald.cron@arm.com>
This commit is contained in:
Ronald Cron 2020-08-04 09:51:30 +02:00
parent e4f6d5c5fe
commit cf56a0a320
20 changed files with 445 additions and 415 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -208,7 +208,7 @@ The design goals of the PSA cryptography API include:
* The API distinguishes caller memory from internal memory, which allows the library to be implemented in an isolated space for additional security. Library calls can be implemented as direct function calls if isolation is not desired, and as remote procedure calls if isolation is desired. * The API distinguishes caller memory from internal memory, which allows the library to be implemented in an isolated space for additional security. Library calls can be implemented as direct function calls if isolation is not desired, and as remote procedure calls if isolation is desired.
* The structure of internal data is hidden to the application, which allows substituting alternative implementations at build time or run time, for example, in order to take advantage of hardware accelerators. * The structure of internal data is hidden to the application, which allows substituting alternative implementations at build time or run time, for example, in order to take advantage of hardware accelerators.
* All access to the keys happens through handles, which allows support for external cryptoprocessors that is transparent to applications. * All access to the keys happens through key identifiers, which allows support for external cryptoprocessors that is transparent to applications.
* The interface to algorithms is generic, favoring algorithm agility. * The interface to algorithms is generic, favoring algorithm agility.
* The interface is designed to be easy to use and hard to accidentally misuse. * The interface is designed to be easy to use and hard to accidentally misuse.

4
docs/architecture/testing/invasive-testing.md
View File

@ -100,7 +100,7 @@ Resources include:
* Memory. * Memory.
* Files in storage (PSA API only — in the Mbed TLS API, black-box unit tests are sufficient). * Files in storage (PSA API only — in the Mbed TLS API, black-box unit tests are sufficient).
* Key handles (PSA API only). * Key slots (PSA API only).
* Key slots in a secure element (PSA SE HAL). * Key slots in a secure element (PSA SE HAL).
* Communication handles (PSA crypto service only). * Communication handles (PSA crypto service only).
@ -116,7 +116,7 @@ When code should clean up resources, how do we know that they have truly been cl
* Zeroization of confidential data after use. * Zeroization of confidential data after use.
* Freeing memory. * Freeing memory.
* Closing key handles. * Freeing key slots.
* Freeing key slots in a secure element. * Freeing key slots in a secure element.
* Deleting files in storage (PSA API only). * Deleting files in storage (PSA API only).

64
docs/getting_started.md
View File

@ -64,7 +64,7 @@ To use the Mbed Crypto APIs, call `psa_crypto_init()` before calling any other A
### Importing a key ### Importing a key
To use a key for cryptography operations in Mbed Crypto, you need to first To use a key for cryptography operations in Mbed Crypto, you need to first
import it. Importing the key creates a handle that refers to the key for use import it. The import operation returns the identifier of the key for use
with other function calls. with other function calls.
**Prerequisites to importing keys:** **Prerequisites to importing keys:**
@ -76,7 +76,7 @@ void import_a_key(const uint8_t *key, size_t key_len)
{ {
psa_status_t status; psa_status_t status;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_handle_t handle; psa_key_id_t key;
printf("Import an AES key...\t"); printf("Import an AES key...\t");
fflush(stdout); fflush(stdout);
@ -95,7 +95,7 @@ void import_a_key(const uint8_t *key, size_t key_len)
psa_set_key_bits(&attributes, 128); psa_set_key_bits(&attributes, 128);
/* Import the key */ /* Import the key */
status = psa_import_key(&attributes, key, key_len, &handle); status = psa_import_key(&attributes, key, key_len, &key);
if (status != PSA_SUCCESS) { if (status != PSA_SUCCESS) {
printf("Failed to import key\n"); printf("Failed to import key\n");
return; return;
@ -106,7 +106,7 @@ void import_a_key(const uint8_t *key, size_t key_len)
psa_reset_key_attributes(&attributes); psa_reset_key_attributes(&attributes);
/* Destroy the key */ /* Destroy the key */
psa_destroy_key(handle); psa_destroy_key(key);
mbedtls_psa_crypto_free(); mbedtls_psa_crypto_free();
} }
@ -135,7 +135,7 @@ void sign_a_message_using_rsa(const uint8_t *key, size_t key_len)
0xa9, 0xe8, 0xcc, 0xac, 0xd0, 0xf6, 0x54, 0x5c}; 0xa9, 0xe8, 0xcc, 0xac, 0xd0, 0xf6, 0x54, 0x5c};
uint8_t signature[PSA_SIGNATURE_MAX_SIZE] = {0}; uint8_t signature[PSA_SIGNATURE_MAX_SIZE] = {0};
size_t signature_length; size_t signature_length;
psa_key_handle_t handle; psa_key_id_t key;
printf("Sign a message...\t"); printf("Sign a message...\t");
fflush(stdout); fflush(stdout);
@ -154,14 +154,14 @@ void sign_a_message_using_rsa(const uint8_t *key, size_t key_len)
psa_set_key_bits(&attributes, 1024); psa_set_key_bits(&attributes, 1024);
/* Import the key */ /* Import the key */
status = psa_import_key(&attributes, key, key_len, &handle); status = psa_import_key(&attributes, key, key_len, &key);
if (status != PSA_SUCCESS) { if (status != PSA_SUCCESS) {
printf("Failed to import key\n"); printf("Failed to import key\n");
return; return;
} }
/* Sign message using the key */ /* Sign message using the key */
status = psa_sign_hash(handle, PSA_ALG_RSA_PKCS1V15_SIGN_RAW, status = psa_sign_hash(key, PSA_ALG_RSA_PKCS1V15_SIGN_RAW,
hash, sizeof(hash), hash, sizeof(hash),
signature, sizeof(signature), signature, sizeof(signature),
&signature_length); &signature_length);
@ -176,7 +176,7 @@ void sign_a_message_using_rsa(const uint8_t *key, size_t key_len)
psa_reset_key_attributes(&attributes); psa_reset_key_attributes(&attributes);
/* Destroy the key */ /* Destroy the key */
psa_destroy_key(handle); psa_destroy_key(key);
mbedtls_psa_crypto_free(); mbedtls_psa_crypto_free();
} }
@ -188,7 +188,7 @@ Mbed Crypto supports encrypting and decrypting messages using various symmetric
**Prerequisites to working with the symmetric cipher API:** **Prerequisites to working with the symmetric cipher API:**
* Initialize the library with a successful call to `psa_crypto_init()`. * Initialize the library with a successful call to `psa_crypto_init()`.
* Have a handle to a symmetric key. This key's usage flags must include `PSA_KEY_USAGE_ENCRYPT` to allow encryption or `PSA_KEY_USAGE_DECRYPT` to allow decryption. * Have a symmetric key. This key's usage flags must include `PSA_KEY_USAGE_ENCRYPT` to allow encryption or `PSA_KEY_USAGE_DECRYPT` to allow decryption.
**To encrypt a message with a symmetric cipher:** **To encrypt a message with a symmetric cipher:**
1. Allocate an operation (`psa_cipher_operation_t`) structure to pass to the cipher functions. 1. Allocate an operation (`psa_cipher_operation_t`) structure to pass to the cipher functions.
@ -213,7 +213,7 @@ void encrypt_with_symmetric_ciphers(const uint8_t *key, size_t key_len)
size_t iv_len; size_t iv_len;
uint8_t output[block_size]; uint8_t output[block_size];
size_t output_len; size_t output_len;
psa_key_handle_t handle; psa_key_id_t key;
psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT; psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
printf("Encrypt with cipher...\t"); printf("Encrypt with cipher...\t");
@ -232,7 +232,7 @@ void encrypt_with_symmetric_ciphers(const uint8_t *key, size_t key_len)
psa_set_key_algorithm(&attributes, alg); psa_set_key_algorithm(&attributes, alg);
psa_set_key_type(&attributes, PSA_KEY_TYPE_AES); psa_set_key_type(&attributes, PSA_KEY_TYPE_AES);
psa_set_key_bits(&attributes, 128); psa_set_key_bits(&attributes, 128);
status = psa_import_key(&attributes, key, key_len, &handle); status = psa_import_key(&attributes, key, key_len, &key);
if (status != PSA_SUCCESS) { if (status != PSA_SUCCESS) {
printf("Failed to import a key\n"); printf("Failed to import a key\n");
return; return;
@ -240,7 +240,7 @@ void encrypt_with_symmetric_ciphers(const uint8_t *key, size_t key_len)
psa_reset_key_attributes(&attributes); psa_reset_key_attributes(&attributes);
/* Encrypt the plaintext */ /* Encrypt the plaintext */
status = psa_cipher_encrypt_setup(&operation, handle, alg); status = psa_cipher_encrypt_setup(&operation, key, alg);
if (status != PSA_SUCCESS) { if (status != PSA_SUCCESS) {
printf("Failed to begin cipher operation\n"); printf("Failed to begin cipher operation\n");
return; return;
@ -268,7 +268,7 @@ void encrypt_with_symmetric_ciphers(const uint8_t *key, size_t key_len)
psa_cipher_abort(&operation); psa_cipher_abort(&operation);
/* Destroy the key */ /* Destroy the key */
psa_destroy_key(handle); psa_destroy_key(key);
mbedtls_psa_crypto_free(); mbedtls_psa_crypto_free();
} }
@ -298,7 +298,7 @@ void decrypt_with_symmetric_ciphers(const uint8_t *key, size_t key_len)
uint8_t iv[block_size] = ENCRYPTED_WITH_IV; uint8_t iv[block_size] = ENCRYPTED_WITH_IV;
uint8_t output[block_size]; uint8_t output[block_size];
size_t output_len; size_t output_len;
psa_key_handle_t handle; psa_key_id_t key;
printf("Decrypt with cipher...\t"); printf("Decrypt with cipher...\t");
fflush(stdout); fflush(stdout);
@ -316,7 +316,7 @@ void decrypt_with_symmetric_ciphers(const uint8_t *key, size_t key_len)
psa_set_key_algorithm(&attributes, alg); psa_set_key_algorithm(&attributes, alg);
psa_set_key_type(&attributes, PSA_KEY_TYPE_AES); psa_set_key_type(&attributes, PSA_KEY_TYPE_AES);
psa_set_key_bits(&attributes, 128); psa_set_key_bits(&attributes, 128);
status = psa_import_key(&attributes, key, key_len, &handle); status = psa_import_key(&attributes, key, key_len, &key);
if (status != PSA_SUCCESS) { if (status != PSA_SUCCESS) {
printf("Failed to import a key\n"); printf("Failed to import a key\n");
return; return;
@ -324,7 +324,7 @@ void decrypt_with_symmetric_ciphers(const uint8_t *key, size_t key_len)
psa_reset_key_attributes(&attributes); psa_reset_key_attributes(&attributes);
/* Decrypt the ciphertext */ /* Decrypt the ciphertext */
status = psa_cipher_decrypt_setup(&operation, handle, alg); status = psa_cipher_decrypt_setup(&operation, key, alg);
if (status != PSA_SUCCESS) { if (status != PSA_SUCCESS) {
printf("Failed to begin cipher operation\n"); printf("Failed to begin cipher operation\n");
return; return;
@ -352,7 +352,7 @@ void decrypt_with_symmetric_ciphers(const uint8_t *key, size_t key_len)
psa_cipher_abort(&operation); psa_cipher_abort(&operation);
/* Destroy the key */ /* Destroy the key */
psa_destroy_key(handle); psa_destroy_key(key);
mbedtls_psa_crypto_free(); mbedtls_psa_crypto_free();
} }
@ -592,8 +592,8 @@ derived from the key, salt and info provided:
PSA_KEY_DERIVATION_OPERATION_INIT; PSA_KEY_DERIVATION_OPERATION_INIT;
size_t derived_bits = 128; size_t derived_bits = 128;
size_t capacity = PSA_BITS_TO_BYTES(derived_bits); size_t capacity = PSA_BITS_TO_BYTES(derived_bits);
psa_key_handle_t base_key; psa_key_id_t base_key;
psa_key_handle_t derived_key; psa_key_id_t derived_key;
printf("Derive a key (HKDF)...\t"); printf("Derive a key (HKDF)...\t");
fflush(stdout); fflush(stdout);
@ -702,7 +702,7 @@ This example shows how to authenticate and encrypt a message:
size_t output_length = 0; size_t output_length = 0;
size_t tag_length = 16; size_t tag_length = 16;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_handle_t handle; psa_key_id_t key;
printf("Authenticate encrypt...\t"); printf("Authenticate encrypt...\t");
fflush(stdout); fflush(stdout);
@ -726,11 +726,11 @@ This example shows how to authenticate and encrypt a message:
psa_set_key_algorithm(&attributes, PSA_ALG_CCM); psa_set_key_algorithm(&attributes, PSA_ALG_CCM);
psa_set_key_type(&attributes, PSA_KEY_TYPE_AES); psa_set_key_type(&attributes, PSA_KEY_TYPE_AES);
psa_set_key_bits(&attributes, 128); psa_set_key_bits(&attributes, 128);
status = psa_import_key(&attributes, key, sizeof(key), &handle); status = psa_import_key(&attributes, key, sizeof(key), &key);
psa_reset_key_attributes(&attributes); psa_reset_key_attributes(&attributes);
/* Authenticate and encrypt */ /* Authenticate and encrypt */
status = psa_aead_encrypt(handle, PSA_ALG_CCM, status = psa_aead_encrypt(key, PSA_ALG_CCM,
nonce, sizeof(nonce), nonce, sizeof(nonce),
additional_data, sizeof(additional_data), additional_data, sizeof(additional_data),
input_data, sizeof(input_data), input_data, sizeof(input_data),
@ -747,7 +747,7 @@ This example shows how to authenticate and encrypt a message:
free(output_data); free(output_data);
/* Destroy the key */ /* Destroy the key */
psa_destroy_key(handle); psa_destroy_key(key);
mbedtls_psa_crypto_free(); mbedtls_psa_crypto_free();
``` ```
@ -756,7 +756,7 @@ This example shows how to authenticate and decrypt a message:
```C ```C
psa_status_t status; psa_status_t status;
static const uint8_t key[] = { static const uint8_t key_data[] = {
0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF }; 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF };
static const uint8_t nonce[] = { static const uint8_t nonce[] = {
@ -773,7 +773,7 @@ This example shows how to authenticate and decrypt a message:
size_t output_size = 0; size_t output_size = 0;
size_t output_length = 0; size_t output_length = 0;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_handle_t handle; psa_key_id_t key;
printf("Authenticate decrypt...\t"); printf("Authenticate decrypt...\t");
fflush(stdout); fflush(stdout);
@ -797,7 +797,7 @@ This example shows how to authenticate and decrypt a message:
psa_set_key_algorithm(&attributes, PSA_ALG_CCM); psa_set_key_algorithm(&attributes, PSA_ALG_CCM);
psa_set_key_type(&attributes, PSA_KEY_TYPE_AES); psa_set_key_type(&attributes, PSA_KEY_TYPE_AES);
psa_set_key_bits(&attributes, 128); psa_set_key_bits(&attributes, 128);
status = psa_import_key(&attributes, key, sizeof(key), &handle); status = psa_import_key(&attributes, key_data, sizeof(key_data), &key);
if (status != PSA_SUCCESS) { if (status != PSA_SUCCESS) {
printf("Failed to import a key\n"); printf("Failed to import a key\n");
return; return;
@ -805,7 +805,7 @@ This example shows how to authenticate and decrypt a message:
psa_reset_key_attributes(&attributes); psa_reset_key_attributes(&attributes);
/* Authenticate and decrypt */ /* Authenticate and decrypt */
status = psa_aead_decrypt(handle, PSA_ALG_CCM, status = psa_aead_decrypt(key, PSA_ALG_CCM,
nonce, sizeof(nonce), nonce, sizeof(nonce),
additional_data, sizeof(additional_data), additional_data, sizeof(additional_data),
input_data, sizeof(input_data), input_data, sizeof(input_data),
@ -822,7 +822,7 @@ This example shows how to authenticate and decrypt a message:
free(output_data); free(output_data);
/* Destroy the key */ /* Destroy the key */
psa_destroy_key(handle); psa_destroy_key(key);
mbedtls_psa_crypto_free(); mbedtls_psa_crypto_free();
``` ```
@ -848,7 +848,7 @@ Mbed Crypto provides a simple way to generate a key or key pair.
size_t exported_length = 0; size_t exported_length = 0;
static uint8_t exported[PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(key_bits)]; static uint8_t exported[PSA_KEY_EXPORT_ECC_PUBLIC_KEY_MAX_SIZE(key_bits)];
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_handle_t handle; psa_key_id_t key;
printf("Generate a key pair...\t"); printf("Generate a key pair...\t");
fflush(stdout); fflush(stdout);
@ -867,14 +867,14 @@ Mbed Crypto provides a simple way to generate a key or key pair.
psa_set_key_type(&attributes, psa_set_key_type(&attributes,
PSA_KEY_TYPE_ECC_KEY_PAIR(PSA_ECC_FAMILY_SECP_R1)); PSA_KEY_TYPE_ECC_KEY_PAIR(PSA_ECC_FAMILY_SECP_R1));
psa_set_key_bits(&attributes, key_bits); psa_set_key_bits(&attributes, key_bits);
status = psa_generate_key(&attributes, &handle); status = psa_generate_key(&attributes, &key);
if (status != PSA_SUCCESS) { if (status != PSA_SUCCESS) {
printf("Failed to generate key\n"); printf("Failed to generate key\n");
return; return;
} }
psa_reset_key_attributes(&attributes); psa_reset_key_attributes(&attributes);
status = psa_export_public_key(handle, exported, sizeof(exported), status = psa_export_public_key(key, exported, sizeof(exported),
&exported_length); &exported_length);
if (status != PSA_SUCCESS) { if (status != PSA_SUCCESS) {
printf("Failed to export public key %ld\n", status); printf("Failed to export public key %ld\n", status);
@ -884,7 +884,7 @@ Mbed Crypto provides a simple way to generate a key or key pair.
printf("Exported a public key\n"); printf("Exported a public key\n");
/* Destroy the key */ /* Destroy the key */
psa_destroy_key(handle); psa_destroy_key(key);
mbedtls_psa_crypto_free(); mbedtls_psa_crypto_free();
``` ```

4
docs/proposed/psa-driver-developer-guide.md
View File

@ -36,10 +36,6 @@ A driver therefore consists of:
Mbed TLS calls driver entry points [as specified in the PSA Cryptography Driver Interface specification](psa-driver-interface.html#driver-entry-points) except as otherwise indicated in this section. Mbed TLS calls driver entry points [as specified in the PSA Cryptography Driver Interface specification](psa-driver-interface.html#driver-entry-points) except as otherwise indicated in this section.
### Key handles
Mbed TLS currently implements the interface for opening and closing persistent keys from version 1.0 beta 3 of the PSA Crypto specification. As a consequence, functions that operate on an existing key take an argument of type `psa_key_handle_t` instead of `psa_key_id_t`. Functions that create a new key take an argument of type `psa_key_handle_t *` instead of `psa_key_id_t *`.
## Building and testing your driver ## Building and testing your driver
<!-- TODO --> <!-- TODO -->

4
docs/proposed/psa-driver-interface.md
View File

@ -580,8 +580,8 @@ psa_set_key_type(&attributes, PSA_KEY_TYPE_AES);
psa_set_key_size(&attributes, 128); psa_set_key_size(&attributes, 128);
psa_set_key_algorithm(&attributes, PSA_ALG_GCM); psa_set_key_algorithm(&attributes, PSA_ALG_GCM);
psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT); psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT | PSA_KEY_USAGE_DECRYPT);
psa_key_handle_t handle = 0; psa_key_id_t key;
psa_generate_key(&attributes, &handle); psa_generate_key(&attributes, &key);
``` ```
## Using opaque drivers from an application ## Using opaque drivers from an application

2
include/mbedtls/cipher_internal.h
View File

@ -134,7 +134,7 @@ typedef enum
typedef struct typedef struct
{ {
psa_algorithm_t alg; psa_algorithm_t alg;
psa_key_handle_t slot; psa_key_id_t slot;
mbedtls_cipher_psa_key_ownership slot_state; mbedtls_cipher_psa_key_ownership slot_state;
} mbedtls_cipher_context_psa; } mbedtls_cipher_context_psa;
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */

11
include/mbedtls/pk.h
View File

@ -331,12 +331,13 @@ int mbedtls_pk_setup( mbedtls_pk_context *ctx, const mbedtls_pk_info_t *info );
* *
* \return \c 0 on success. * \return \c 0 on success.
* \return #MBEDTLS_ERR_PK_BAD_INPUT_DATA on invalid input * \return #MBEDTLS_ERR_PK_BAD_INPUT_DATA on invalid input
* (context already used, invalid key handle). * (context already used, invalid key identifier).
* \return #MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE if the key is not an * \return #MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE if the key is not an
* ECC key pair. * ECC key pair.
* \return #MBEDTLS_ERR_PK_ALLOC_FAILED on allocation failure. * \return #MBEDTLS_ERR_PK_ALLOC_FAILED on allocation failure.
*/ */
int mbedtls_pk_setup_opaque( mbedtls_pk_context *ctx, const psa_key_handle_t key ); int mbedtls_pk_setup_opaque( mbedtls_pk_context *ctx,
const psa_key_id_t key );
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */
#if defined(MBEDTLS_PK_RSA_ALT_SUPPORT) #if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
@ -858,9 +859,9 @@ int mbedtls_pk_load_file( const char *path, unsigned char **buf, size_t *n );
* *
* \param pk Input: the EC key to import to a PSA key. * \param pk Input: the EC key to import to a PSA key.
* Output: a PK context wrapping that PSA key. * Output: a PK context wrapping that PSA key.
* \param handle Output: a PSA key handle. * \param key Output: a PSA key identifier.
* It's the caller's responsibility to call * It's the caller's responsibility to call
* psa_destroy_key() on that handle after calling * psa_destroy_key() on that key identifier after calling
* mbedtls_pk_free() on the PK context. * mbedtls_pk_free() on the PK context.
* \param hash_alg The hash algorithm to allow for use with that key. * \param hash_alg The hash algorithm to allow for use with that key.
* *
@ -868,7 +869,7 @@ int mbedtls_pk_load_file( const char *path, unsigned char **buf, size_t *n );
* \return An Mbed TLS error code otherwise. * \return An Mbed TLS error code otherwise.
*/ */
int mbedtls_pk_wrap_as_opaque( mbedtls_pk_context *pk, int mbedtls_pk_wrap_as_opaque( mbedtls_pk_context *pk,
psa_key_handle_t *handle, psa_key_id_t *key,
psa_algorithm_t hash_alg ); psa_algorithm_t hash_alg );
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */

15
include/mbedtls/ssl.h
View File

@ -1063,11 +1063,12 @@ struct mbedtls_ssl_config
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED) #if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
#if defined(MBEDTLS_USE_PSA_CRYPTO) #if defined(MBEDTLS_USE_PSA_CRYPTO)
psa_key_handle_t psk_opaque; /*!< PSA key slot holding opaque PSK. psa_key_id_t psk_opaque; /*!< PSA key slot holding opaque PSK. This field
* This field should only be set via * should only be set via
* mbedtls_ssl_conf_psk_opaque(). * mbedtls_ssl_conf_psk_opaque().
* If either no PSK or a raw PSK have * If either no PSK or a raw PSK have been
* been configured, this has value \c 0. */ * configured, this has value \c 0.
*/
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */
unsigned char *psk; /*!< The raw pre-shared key. This field should unsigned char *psk; /*!< The raw pre-shared key. This field should
@ -2814,7 +2815,7 @@ int mbedtls_ssl_conf_psk( mbedtls_ssl_config *conf,
* \return An \c MBEDTLS_ERR_SSL_XXX error code on failure. * \return An \c MBEDTLS_ERR_SSL_XXX error code on failure.
*/ */
int mbedtls_ssl_conf_psk_opaque( mbedtls_ssl_config *conf, int mbedtls_ssl_conf_psk_opaque( mbedtls_ssl_config *conf,
psa_key_handle_t psk, psa_key_id_t psk,
const unsigned char *psk_identity, const unsigned char *psk_identity,
size_t psk_identity_len ); size_t psk_identity_len );
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */
@ -2860,7 +2861,7 @@ int mbedtls_ssl_set_hs_psk( mbedtls_ssl_context *ssl,
* \return An \c MBEDTLS_ERR_SSL_XXX error code on failure. * \return An \c MBEDTLS_ERR_SSL_XXX error code on failure.
*/ */
int mbedtls_ssl_set_hs_psk_opaque( mbedtls_ssl_context *ssl, int mbedtls_ssl_set_hs_psk_opaque( mbedtls_ssl_context *ssl,
psa_key_handle_t psk ); psa_key_id_t psk );
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */
/** /**

12
include/mbedtls/ssl_internal.h
View File

@ -443,7 +443,7 @@ struct mbedtls_ssl_handshake_params
#if defined(MBEDTLS_USE_PSA_CRYPTO) #if defined(MBEDTLS_USE_PSA_CRYPTO)
psa_key_type_t ecdh_psa_type; psa_key_type_t ecdh_psa_type;
uint16_t ecdh_bits; uint16_t ecdh_bits;
psa_key_handle_t ecdh_psa_privkey; psa_key_id_t ecdh_psa_privkey;
unsigned char ecdh_psa_peerkey[MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH]; unsigned char ecdh_psa_peerkey[MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH];
size_t ecdh_psa_peerkey_len; size_t ecdh_psa_peerkey_len;
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */
@ -462,7 +462,7 @@ struct mbedtls_ssl_handshake_params
#endif #endif
#if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED) #if defined(MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED)
#if defined(MBEDTLS_USE_PSA_CRYPTO) #if defined(MBEDTLS_USE_PSA_CRYPTO)
psa_key_handle_t psk_opaque; /*!< Opaque PSK from the callback */ psa_key_id_t psk_opaque; /*!< Opaque PSK from the callback */
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */
unsigned char *psk; /*!< PSK from the callback */ unsigned char *psk; /*!< PSK from the callback */
size_t psk_len; /*!< Length of PSK from callback */ size_t psk_len; /*!< Length of PSK from callback */
@ -1061,16 +1061,16 @@ static inline int mbedtls_ssl_get_psk( const mbedtls_ssl_context *ssl,
* 2. static PSK configured by \c mbedtls_ssl_conf_psk_opaque() * 2. static PSK configured by \c mbedtls_ssl_conf_psk_opaque()
* Return an opaque PSK * Return an opaque PSK
*/ */
static inline psa_key_handle_t mbedtls_ssl_get_opaque_psk( static inline psa_key_id_t mbedtls_ssl_get_opaque_psk(
const mbedtls_ssl_context *ssl ) const mbedtls_ssl_context *ssl )
{ {
if( ! psa_key_handle_is_null( ssl->handshake->psk_opaque ) ) if( ! mbedtls_svc_key_id_is_null( ssl->handshake->psk_opaque ) )
return( ssl->handshake->psk_opaque ); return( ssl->handshake->psk_opaque );
if( ! psa_key_handle_is_null( ssl->conf->psk_opaque ) ) if( ! mbedtls_svc_key_id_is_null( ssl->conf->psk_opaque ) )
return( ssl->conf->psk_opaque ); return( ssl->conf->psk_opaque );
return( PSA_KEY_HANDLE_INIT ); return( MBEDTLS_SVC_KEY_ID_INIT );
} }
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */

318
include/psa/crypto.h
View File

@ -348,7 +348,7 @@ static size_t psa_get_key_bits(const psa_key_attributes_t *attributes);
* Once you have called this function on an attribute structure, * Once you have called this function on an attribute structure,
* you must call psa_reset_key_attributes() to free these resources. * you must call psa_reset_key_attributes() to free these resources.
* *
* \param[in] handle Handle to the key to query. * \param[in] key Identifier of the key to query.
* \param[in,out] attributes On success, the attributes of the key. * \param[in,out] attributes On success, the attributes of the key.
* On failure, equivalent to a * On failure, equivalent to a
* freshly-initialized structure. * freshly-initialized structure.
@ -364,7 +364,7 @@ static size_t psa_get_key_bits(const psa_key_attributes_t *attributes);
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_get_key_attributes(psa_key_handle_t handle, psa_status_t psa_get_key_attributes(mbedtls_svc_key_id_t key,
psa_key_attributes_t *attributes); psa_key_attributes_t *attributes);
/** Reset a key attribute structure to a freshly initialized state. /** Reset a key attribute structure to a freshly initialized state.
@ -387,94 +387,6 @@ void psa_reset_key_attributes(psa_key_attributes_t *attributes);
* @{ * @{
*/ */
/** Open a handle to an existing persistent key.
*
* Open a handle to a persistent key. A key is persistent if it was created
* with a lifetime other than #PSA_KEY_LIFETIME_VOLATILE. A persistent key
* always has a nonzero key identifier, set with psa_set_key_id() when
* creating the key. Implementations may provide additional pre-provisioned
* keys that can be opened with psa_open_key(). Such keys have an application
* key identifier in the vendor range, as documented in the description of
* #psa_key_id_t.
*
* The application must eventually close the handle with psa_close_key() or
* psa_destroy_key() to release associated resources. If the application dies
* without calling one of these functions, the implementation should perform
* the equivalent of a call to psa_close_key().
*
* Some implementations permit an application to open the same key multiple
* times. If this is successful, each call to psa_open_key() will return a
* different key handle.
*
* \note Applications that rely on opening a key multiple times will not be
* portable to implementations that only permit a single key handle to be
* opened. See also :ref:\`key-handles\`.
*
* \param key The persistent identifier of the key.
* \param[out] handle On success, a handle to the key.
*
* \retval #PSA_SUCCESS
* Success. The application can now use the value of `*handle`
* to access the key.
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
* The implementation does not have sufficient resources to open the
* key. This can be due to reaching an implementation limit on the
* number of open keys, the number of open key handles, or available
* memory.
* \retval #PSA_ERROR_DOES_NOT_EXIST
* There is no persistent key with key identifier \p id.
* \retval #PSA_ERROR_INVALID_ARGUMENT
* \p id is not a valid persistent key identifier.
* \retval #PSA_ERROR_NOT_PERMITTED
* The specified key exists, but the application does not have the
* permission to access it. Note that this specification does not
* define any way to create such a key, but it may be possible
* through implementation-specific means.
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
* \retval #PSA_ERROR_CORRUPTION_DETECTED
* \retval #PSA_ERROR_STORAGE_FAILURE
* \retval #PSA_ERROR_BAD_STATE
* The library has not been previously initialized by psa_crypto_init().
* It is implementation-dependent whether a failure to initialize
* results in this error code.
*/
psa_status_t psa_open_key( mbedtls_svc_key_id_t key,
psa_key_handle_t *handle );
/** Close a key handle.
*
* If the handle designates a volatile key, this will destroy the key material
* and free all associated resources, just like psa_destroy_key().
*
* If this is the last open handle to a persistent key, then closing the handle
* will free all resources associated with the key in volatile memory. The key
* data in persistent storage is not affected and can be opened again later
* with a call to psa_open_key().
*
* Closing the key handle makes the handle invalid, and the key handle
* must not be used again by the application.
*
* \note If the key handle was used to set up an active
* :ref:\`multipart operation <multipart-operations>\`, then closing the
* key handle can cause the multipart operation to fail. Applications should
* maintain the key handle until after the multipart operation has finished.
*
* \param handle The key handle to close.
* If this is \c 0, do nothing and return \c PSA_SUCCESS.
*
* \retval #PSA_SUCCESS
* \p handle was a valid handle or \c 0. It is now closed.
* \retval #PSA_ERROR_INVALID_HANDLE
* \p handle is not a valid handle nor \c 0.
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
* \retval #PSA_ERROR_CORRUPTION_DETECTED
* \retval #PSA_ERROR_BAD_STATE
* The library has not been previously initialized by psa_crypto_init().
* It is implementation-dependent whether a failure to initialize
* results in this error code.
*/
psa_status_t psa_close_key(psa_key_handle_t handle);
/** Make a copy of a key. /** Make a copy of a key.
* *
* Copy key material from one location to another. * Copy key material from one location to another.
@ -512,7 +424,10 @@ psa_status_t psa_close_key(psa_key_handle_t handle);
* The effect of this function on implementation-defined attributes is * The effect of this function on implementation-defined attributes is
* implementation-defined. * implementation-defined.
* *
* \param source_handle The key to copy. It must be a valid key handle. * \param source_key The key to copy. It must allow the usage
* PSA_KEY_USAGE_COPY. If a private or secret key is
* being copied outside of a secure element it must
* also allow PSA_KEY_USAGE_EXPORT.
* \param[in] attributes The attributes for the new key. * \param[in] attributes The attributes for the new key.
* They are used as follows: * They are used as follows:
* - The key type and size may be 0. If either is * - The key type and size may be 0. If either is
@ -526,12 +441,12 @@ psa_status_t psa_close_key(psa_key_handle_t handle);
* the source key and \p attributes so that * the source key and \p attributes so that
* both sets of restrictions apply, as * both sets of restrictions apply, as
* described in the documentation of this function. * described in the documentation of this function.
* \param[out] target_handle On success, a handle to the newly created key. * \param[out] target_key On success, an identifier for the newly created
* \c 0 on failure. * key. \c 0 on failure.
* *
* \retval #PSA_SUCCESS * \retval #PSA_SUCCESS
* \retval #PSA_ERROR_INVALID_HANDLE * \retval #PSA_ERROR_INVALID_HANDLE
* \p source_handle is invalid. * \p source_key is invalid.
* \retval #PSA_ERROR_ALREADY_EXISTS * \retval #PSA_ERROR_ALREADY_EXISTS
* This is an attempt to create a persistent key, and there is * This is an attempt to create a persistent key, and there is
* already a persistent key with the given identifier. * already a persistent key with the given identifier.
@ -559,9 +474,9 @@ psa_status_t psa_close_key(psa_key_handle_t handle);
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_copy_key(psa_key_handle_t source_handle, psa_status_t psa_copy_key(mbedtls_svc_key_id_t source_key,
const psa_key_attributes_t *attributes, const psa_key_attributes_t *attributes,
psa_key_handle_t *target_handle); mbedtls_svc_key_id_t *target_key);
/** /**
@ -572,28 +487,22 @@ psa_status_t psa_copy_key(psa_key_handle_t source_handle,
* make a best effort to ensure that that the key material cannot be recovered. * make a best effort to ensure that that the key material cannot be recovered.
* *
* This function also erases any metadata such as policies and frees * This function also erases any metadata such as policies and frees
* resources associated with the key. To free all resources associated with * resources associated with the key.
* the key, all handles to the key must be closed or destroyed.
*
* Destroying the key makes the handle invalid, and the key handle
* must not be used again by the application. Using other open handles to the
* destroyed key in a cryptographic operation will result in an error.
* *
* If a key is currently in use in a multipart operation, then destroying the * If a key is currently in use in a multipart operation, then destroying the
* key will cause the multipart operation to fail. * key will cause the multipart operation to fail.
* *
* \param handle Handle to the key to erase. * \param key Identifier of the key to erase. If this is \c 0, do nothing and
* If this is \c 0, do nothing and return \c PSA_SUCCESS. * return PSA_SUCCESS.
* *
* \retval #PSA_SUCCESS * \retval #PSA_SUCCESS
* \p handle was a valid handle and the key material that it * \p key was a valid identifier and the key material that it
* referred to has been erased. * referred to has been erased. Alternatively, \p key is \c 0.
* Alternatively, \p handle is \c 0.
* \retval #PSA_ERROR_NOT_PERMITTED * \retval #PSA_ERROR_NOT_PERMITTED
* The key cannot be erased because it is * The key cannot be erased because it is
* read-only, either due to a policy or due to physical restrictions. * read-only, either due to a policy or due to physical restrictions.
* \retval #PSA_ERROR_INVALID_HANDLE * \retval #PSA_ERROR_INVALID_HANDLE
* \p handle is not a valid handle nor \c 0. * \p key is not a valid identifier nor \c 0.
* \retval #PSA_ERROR_COMMUNICATION_FAILURE * \retval #PSA_ERROR_COMMUNICATION_FAILURE
* There was an failure in communication with the cryptoprocessor. * There was an failure in communication with the cryptoprocessor.
* The key material may still be present in the cryptoprocessor. * The key material may still be present in the cryptoprocessor.
@ -611,7 +520,7 @@ psa_status_t psa_copy_key(psa_key_handle_t source_handle,
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_destroy_key(psa_key_handle_t handle); psa_status_t psa_destroy_key(mbedtls_svc_key_id_t key);
/**@}*/ /**@}*/
@ -646,7 +555,7 @@ psa_status_t psa_destroy_key(psa_key_handle_t handle);
* \p data buffer. * \p data buffer.
* If the key size in \p attributes is nonzero, * If the key size in \p attributes is nonzero,
* it must be equal to the size from \p data. * it must be equal to the size from \p data.
* \param[out] handle On success, a handle to the newly created key. * \param[out] key On success, an identifier to the newly created key.
* \c 0 on failure. * \c 0 on failure.
* \param[in] data Buffer containing the key data. The content of this * \param[in] data Buffer containing the key data. The content of this
* buffer is interpreted according to the type declared * buffer is interpreted according to the type declared
@ -691,7 +600,7 @@ psa_status_t psa_destroy_key(psa_key_handle_t handle);
psa_status_t psa_import_key(const psa_key_attributes_t *attributes, psa_status_t psa_import_key(const psa_key_attributes_t *attributes,
const uint8_t *data, const uint8_t *data,
size_t data_length, size_t data_length,
psa_key_handle_t *handle); mbedtls_svc_key_id_t *key);
@ -752,7 +661,9 @@ psa_status_t psa_import_key(const psa_key_attributes_t *attributes,
* *
* The policy on the key must have the usage flag #PSA_KEY_USAGE_EXPORT set. * The policy on the key must have the usage flag #PSA_KEY_USAGE_EXPORT set.
* *
* \param handle Handle to the key to export. * \param key Identifier of the key to export. It must allow the
* usage PSA_KEY_USAGE_EXPORT, unless it is a public
* key.
* \param[out] data Buffer where the key data is to be written. * \param[out] data Buffer where the key data is to be written.
* \param data_size Size of the \p data buffer in bytes. * \param data_size Size of the \p data buffer in bytes.
* \param[out] data_length On success, the number of bytes * \param[out] data_length On success, the number of bytes
@ -779,7 +690,7 @@ psa_status_t psa_import_key(const psa_key_attributes_t *attributes,
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_export_key(psa_key_handle_t handle, psa_status_t psa_export_key(mbedtls_svc_key_id_t key,
uint8_t *data, uint8_t *data,
size_t data_size, size_t data_size,
size_t *data_length); size_t *data_length);
@ -822,7 +733,7 @@ psa_status_t psa_export_key(psa_key_handle_t handle,
* Exporting a public key object or the public part of a key pair is * Exporting a public key object or the public part of a key pair is
* always permitted, regardless of the key's usage flags. * always permitted, regardless of the key's usage flags.
* *
* \param handle Handle to the key to export. * \param key Identifier of the key to export.
* \param[out] data Buffer where the key data is to be written. * \param[out] data Buffer where the key data is to be written.
* \param data_size Size of the \p data buffer in bytes. * \param data_size Size of the \p data buffer in bytes.
* \param[out] data_length On success, the number of bytes * \param[out] data_length On success, the number of bytes
@ -849,7 +760,7 @@ psa_status_t psa_export_key(psa_key_handle_t handle,
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_export_public_key(psa_key_handle_t handle, psa_status_t psa_export_public_key(mbedtls_svc_key_id_t key,
uint8_t *data, uint8_t *data,
size_t data_size, size_t data_size,
size_t *data_length); size_t *data_length);
@ -1226,7 +1137,8 @@ psa_status_t psa_hash_clone(const psa_hash_operation_t *source_operation,
* about the MAC value which could allow an attacker to guess * about the MAC value which could allow an attacker to guess
* a valid MAC and thereby bypass security controls. * a valid MAC and thereby bypass security controls.
* *
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the operation. It
* must allow the usage PSA_KEY_USAGE_SIGN_MESSAGE.
* \param alg The MAC algorithm to compute (\c PSA_ALG_XXX value * \param alg The MAC algorithm to compute (\c PSA_ALG_XXX value
* such that #PSA_ALG_IS_MAC(\p alg) is true). * such that #PSA_ALG_IS_MAC(\p alg) is true).
* \param[in] input Buffer containing the input message. * \param[in] input Buffer containing the input message.
@ -1241,7 +1153,7 @@ psa_status_t psa_hash_clone(const psa_hash_operation_t *source_operation,
* \retval #PSA_ERROR_INVALID_HANDLE * \retval #PSA_ERROR_INVALID_HANDLE
* \retval #PSA_ERROR_NOT_PERMITTED * \retval #PSA_ERROR_NOT_PERMITTED
* \retval #PSA_ERROR_INVALID_ARGUMENT * \retval #PSA_ERROR_INVALID_ARGUMENT
* \p handle is not compatible with \p alg. * \p key is not compatible with \p alg.
* \retval #PSA_ERROR_NOT_SUPPORTED * \retval #PSA_ERROR_NOT_SUPPORTED
* \p alg is not supported or is not a MAC algorithm. * \p alg is not supported or is not a MAC algorithm.
* \retval #PSA_ERROR_BUFFER_TOO_SMALL * \retval #PSA_ERROR_BUFFER_TOO_SMALL
@ -1257,7 +1169,7 @@ psa_status_t psa_hash_clone(const psa_hash_operation_t *source_operation,
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_mac_compute(psa_key_handle_t handle, psa_status_t psa_mac_compute(mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *input, const uint8_t *input,
size_t input_length, size_t input_length,
@ -1267,7 +1179,8 @@ psa_status_t psa_mac_compute(psa_key_handle_t handle,
/** Calculate the MAC of a message and compare it with a reference value. /** Calculate the MAC of a message and compare it with a reference value.
* *
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the operation. It
* must allow the usage PSA_KEY_USAGE_VERIFY_MESSAGE.
* \param alg The MAC algorithm to compute (\c PSA_ALG_XXX value * \param alg The MAC algorithm to compute (\c PSA_ALG_XXX value
* such that #PSA_ALG_IS_MAC(\p alg) is true). * such that #PSA_ALG_IS_MAC(\p alg) is true).
* \param[in] input Buffer containing the input message. * \param[in] input Buffer containing the input message.
@ -1283,7 +1196,7 @@ psa_status_t psa_mac_compute(psa_key_handle_t handle,
* \retval #PSA_ERROR_INVALID_HANDLE * \retval #PSA_ERROR_INVALID_HANDLE
* \retval #PSA_ERROR_NOT_PERMITTED * \retval #PSA_ERROR_NOT_PERMITTED
* \retval #PSA_ERROR_INVALID_ARGUMENT * \retval #PSA_ERROR_INVALID_ARGUMENT
* \p handle is not compatible with \p alg. * \p key is not compatible with \p alg.
* \retval #PSA_ERROR_NOT_SUPPORTED * \retval #PSA_ERROR_NOT_SUPPORTED
* \p alg is not supported or is not a MAC algorithm. * \p alg is not supported or is not a MAC algorithm.
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
@ -1297,7 +1210,7 @@ psa_status_t psa_mac_compute(psa_key_handle_t handle,
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_mac_verify(psa_key_handle_t handle, psa_status_t psa_mac_verify(mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *input, const uint8_t *input,
size_t input_length, size_t input_length,
@ -1382,9 +1295,9 @@ static psa_mac_operation_t psa_mac_operation_init(void);
* \param[in,out] operation The operation object to set up. It must have * \param[in,out] operation The operation object to set up. It must have
* been initialized as per the documentation for * been initialized as per the documentation for
* #psa_mac_operation_t and not yet in use. * #psa_mac_operation_t and not yet in use.
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the operation. It
* It must remain valid until the operation * must remain valid until the operation terminates.
* terminates. * It must allow the usage PSA_KEY_USAGE_SIGN_MESSAGE.
* \param alg The MAC algorithm to compute (\c PSA_ALG_XXX value * \param alg The MAC algorithm to compute (\c PSA_ALG_XXX value
* such that #PSA_ALG_IS_MAC(\p alg) is true). * such that #PSA_ALG_IS_MAC(\p alg) is true).
* *
@ -1393,7 +1306,7 @@ static psa_mac_operation_t psa_mac_operation_init(void);
* \retval #PSA_ERROR_INVALID_HANDLE * \retval #PSA_ERROR_INVALID_HANDLE
* \retval #PSA_ERROR_NOT_PERMITTED * \retval #PSA_ERROR_NOT_PERMITTED
* \retval #PSA_ERROR_INVALID_ARGUMENT * \retval #PSA_ERROR_INVALID_ARGUMENT
* \p handle is not compatible with \p alg. * \p key is not compatible with \p alg.
* \retval #PSA_ERROR_NOT_SUPPORTED * \retval #PSA_ERROR_NOT_SUPPORTED
* \p alg is not supported or is not a MAC algorithm. * \p alg is not supported or is not a MAC algorithm.
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
@ -1410,7 +1323,7 @@ static psa_mac_operation_t psa_mac_operation_init(void);
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_mac_sign_setup(psa_mac_operation_t *operation, psa_status_t psa_mac_sign_setup(psa_mac_operation_t *operation,
psa_key_handle_t handle, mbedtls_svc_key_id_t key,
psa_algorithm_t alg); psa_algorithm_t alg);
/** Set up a multipart MAC verification operation. /** Set up a multipart MAC verification operation.
@ -1444,9 +1357,10 @@ psa_status_t psa_mac_sign_setup(psa_mac_operation_t *operation,
* \param[in,out] operation The operation object to set up. It must have * \param[in,out] operation The operation object to set up. It must have
* been initialized as per the documentation for * been initialized as per the documentation for
* #psa_mac_operation_t and not yet in use. * #psa_mac_operation_t and not yet in use.
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the operation. It
* It must remain valid until the operation * must remain valid until the operation terminates.
* terminates. * It must allow the usage
* PSA_KEY_USAGE_VERIFY_MESSAGE.
* \param alg The MAC algorithm to compute (\c PSA_ALG_XXX value * \param alg The MAC algorithm to compute (\c PSA_ALG_XXX value
* such that #PSA_ALG_IS_MAC(\p alg) is true). * such that #PSA_ALG_IS_MAC(\p alg) is true).
* *
@ -1472,7 +1386,7 @@ psa_status_t psa_mac_sign_setup(psa_mac_operation_t *operation,
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_mac_verify_setup(psa_mac_operation_t *operation, psa_status_t psa_mac_verify_setup(psa_mac_operation_t *operation,
psa_key_handle_t handle, mbedtls_svc_key_id_t key,
psa_algorithm_t alg); psa_algorithm_t alg);
/** Add a message fragment to a multipart MAC operation. /** Add a message fragment to a multipart MAC operation.
@ -1639,9 +1553,8 @@ psa_status_t psa_mac_abort(psa_mac_operation_t *operation);
* vector). Use the multipart operation interface with a * vector). Use the multipart operation interface with a
* #psa_cipher_operation_t object to provide other forms of IV. * #psa_cipher_operation_t object to provide other forms of IV.
* *
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the operation.
* It must remain valid until the operation * It must allow the usage PSA_KEY_USAGE_ENCRYPT.
* terminates.
* \param alg The cipher algorithm to compute * \param alg The cipher algorithm to compute
* (\c PSA_ALG_XXX value such that * (\c PSA_ALG_XXX value such that
* #PSA_ALG_IS_CIPHER(\p alg) is true). * #PSA_ALG_IS_CIPHER(\p alg) is true).
@ -1659,7 +1572,7 @@ psa_status_t psa_mac_abort(psa_mac_operation_t *operation);
* \retval #PSA_ERROR_INVALID_HANDLE * \retval #PSA_ERROR_INVALID_HANDLE
* \retval #PSA_ERROR_NOT_PERMITTED * \retval #PSA_ERROR_NOT_PERMITTED
* \retval #PSA_ERROR_INVALID_ARGUMENT * \retval #PSA_ERROR_INVALID_ARGUMENT
* \p handle is not compatible with \p alg. * \p key is not compatible with \p alg.
* \retval #PSA_ERROR_NOT_SUPPORTED * \retval #PSA_ERROR_NOT_SUPPORTED
* \p alg is not supported or is not a cipher algorithm. * \p alg is not supported or is not a cipher algorithm.
* \retval #PSA_ERROR_BUFFER_TOO_SMALL * \retval #PSA_ERROR_BUFFER_TOO_SMALL
@ -1673,7 +1586,7 @@ psa_status_t psa_mac_abort(psa_mac_operation_t *operation);
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_cipher_encrypt(psa_key_handle_t handle, psa_status_t psa_cipher_encrypt(mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *input, const uint8_t *input,
size_t input_length, size_t input_length,
@ -1685,9 +1598,10 @@ psa_status_t psa_cipher_encrypt(psa_key_handle_t handle,
* *
* This function decrypts a message encrypted with a symmetric cipher. * This function decrypts a message encrypted with a symmetric cipher.
* *
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the operation.
* It must remain valid until the operation * It must remain valid until the operation
* terminates. * terminates. It must allow the usage
* PSA_KEY_USAGE_DECRYPT.
* \param alg The cipher algorithm to compute * \param alg The cipher algorithm to compute
* (\c PSA_ALG_XXX value such that * (\c PSA_ALG_XXX value such that
* #PSA_ALG_IS_CIPHER(\p alg) is true). * #PSA_ALG_IS_CIPHER(\p alg) is true).
@ -1705,7 +1619,7 @@ psa_status_t psa_cipher_encrypt(psa_key_handle_t handle,
* \retval #PSA_ERROR_INVALID_HANDLE * \retval #PSA_ERROR_INVALID_HANDLE
* \retval #PSA_ERROR_NOT_PERMITTED * \retval #PSA_ERROR_NOT_PERMITTED
* \retval #PSA_ERROR_INVALID_ARGUMENT * \retval #PSA_ERROR_INVALID_ARGUMENT
* \p handle is not compatible with \p alg. * \p key is not compatible with \p alg.
* \retval #PSA_ERROR_NOT_SUPPORTED * \retval #PSA_ERROR_NOT_SUPPORTED
* \p alg is not supported or is not a cipher algorithm. * \p alg is not supported or is not a cipher algorithm.
* \retval #PSA_ERROR_BUFFER_TOO_SMALL * \retval #PSA_ERROR_BUFFER_TOO_SMALL
@ -1719,7 +1633,7 @@ psa_status_t psa_cipher_encrypt(psa_key_handle_t handle,
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_cipher_decrypt(psa_key_handle_t handle, psa_status_t psa_cipher_decrypt(mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *input, const uint8_t *input,
size_t input_length, size_t input_length,
@ -1805,9 +1719,10 @@ static psa_cipher_operation_t psa_cipher_operation_init(void);
* \param[in,out] operation The operation object to set up. It must have * \param[in,out] operation The operation object to set up. It must have
* been initialized as per the documentation for * been initialized as per the documentation for
* #psa_cipher_operation_t and not yet in use. * #psa_cipher_operation_t and not yet in use.
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the operation.
* It must remain valid until the operation * It must remain valid until the operation
* terminates. * terminates. It must allow the usage
* PSA_KEY_USAGE_ENCRYPT.
* \param alg The cipher algorithm to compute * \param alg The cipher algorithm to compute
* (\c PSA_ALG_XXX value such that * (\c PSA_ALG_XXX value such that
* #PSA_ALG_IS_CIPHER(\p alg) is true). * #PSA_ALG_IS_CIPHER(\p alg) is true).
@ -1817,7 +1732,7 @@ static psa_cipher_operation_t psa_cipher_operation_init(void);
* \retval #PSA_ERROR_INVALID_HANDLE * \retval #PSA_ERROR_INVALID_HANDLE
* \retval #PSA_ERROR_NOT_PERMITTED * \retval #PSA_ERROR_NOT_PERMITTED
* \retval #PSA_ERROR_INVALID_ARGUMENT * \retval #PSA_ERROR_INVALID_ARGUMENT
* \p handle is not compatible with \p alg. * \p key is not compatible with \p alg.
* \retval #PSA_ERROR_NOT_SUPPORTED * \retval #PSA_ERROR_NOT_SUPPORTED
* \p alg is not supported or is not a cipher algorithm. * \p alg is not supported or is not a cipher algorithm.
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
@ -1833,7 +1748,7 @@ static psa_cipher_operation_t psa_cipher_operation_init(void);
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_cipher_encrypt_setup(psa_cipher_operation_t *operation, psa_status_t psa_cipher_encrypt_setup(psa_cipher_operation_t *operation,
psa_key_handle_t handle, mbedtls_svc_key_id_t key,
psa_algorithm_t alg); psa_algorithm_t alg);
/** Set the key for a multipart symmetric decryption operation. /** Set the key for a multipart symmetric decryption operation.
@ -1868,9 +1783,10 @@ psa_status_t psa_cipher_encrypt_setup(psa_cipher_operation_t *operation,
* \param[in,out] operation The operation object to set up. It must have * \param[in,out] operation The operation object to set up. It must have
* been initialized as per the documentation for * been initialized as per the documentation for
* #psa_cipher_operation_t and not yet in use. * #psa_cipher_operation_t and not yet in use.
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the operation.
* It must remain valid until the operation * It must remain valid until the operation
* terminates. * terminates. It must allow the usage
* PSA_KEY_USAGE_DECRYPT.
* \param alg The cipher algorithm to compute * \param alg The cipher algorithm to compute
* (\c PSA_ALG_XXX value such that * (\c PSA_ALG_XXX value such that
* #PSA_ALG_IS_CIPHER(\p alg) is true). * #PSA_ALG_IS_CIPHER(\p alg) is true).
@ -1880,7 +1796,7 @@ psa_status_t psa_cipher_encrypt_setup(psa_cipher_operation_t *operation,
* \retval #PSA_ERROR_INVALID_HANDLE * \retval #PSA_ERROR_INVALID_HANDLE
* \retval #PSA_ERROR_NOT_PERMITTED * \retval #PSA_ERROR_NOT_PERMITTED
* \retval #PSA_ERROR_INVALID_ARGUMENT * \retval #PSA_ERROR_INVALID_ARGUMENT
* \p handle is not compatible with \p alg. * \p key is not compatible with \p alg.
* \retval #PSA_ERROR_NOT_SUPPORTED * \retval #PSA_ERROR_NOT_SUPPORTED
* \p alg is not supported or is not a cipher algorithm. * \p alg is not supported or is not a cipher algorithm.
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
@ -1896,7 +1812,7 @@ psa_status_t psa_cipher_encrypt_setup(psa_cipher_operation_t *operation,
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_cipher_decrypt_setup(psa_cipher_operation_t *operation, psa_status_t psa_cipher_decrypt_setup(psa_cipher_operation_t *operation,
psa_key_handle_t handle, mbedtls_svc_key_id_t key,
psa_algorithm_t alg); psa_algorithm_t alg);
/** Generate an IV for a symmetric encryption operation. /** Generate an IV for a symmetric encryption operation.
@ -2110,7 +2026,9 @@ psa_status_t psa_cipher_abort(psa_cipher_operation_t *operation);
/** Process an authenticated encryption operation. /** Process an authenticated encryption operation.
* *
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the
* operation. It must allow the usage
* PSA_KEY_USAGE_ENCRYPT.
* \param alg The AEAD algorithm to compute * \param alg The AEAD algorithm to compute
* (\c PSA_ALG_XXX value such that * (\c PSA_ALG_XXX value such that
* #PSA_ALG_IS_AEAD(\p alg) is true). * #PSA_ALG_IS_AEAD(\p alg) is true).
@ -2141,7 +2059,7 @@ psa_status_t psa_cipher_abort(psa_cipher_operation_t *operation);
* \retval #PSA_ERROR_INVALID_HANDLE * \retval #PSA_ERROR_INVALID_HANDLE
* \retval #PSA_ERROR_NOT_PERMITTED * \retval #PSA_ERROR_NOT_PERMITTED
* \retval #PSA_ERROR_INVALID_ARGUMENT * \retval #PSA_ERROR_INVALID_ARGUMENT
* \p handle is not compatible with \p alg. * \p key is not compatible with \p alg.
* \retval #PSA_ERROR_NOT_SUPPORTED * \retval #PSA_ERROR_NOT_SUPPORTED
* \p alg is not supported or is not an AEAD algorithm. * \p alg is not supported or is not an AEAD algorithm.
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
@ -2156,7 +2074,7 @@ psa_status_t psa_cipher_abort(psa_cipher_operation_t *operation);
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_aead_encrypt(psa_key_handle_t handle, psa_status_t psa_aead_encrypt(mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *nonce, const uint8_t *nonce,
size_t nonce_length, size_t nonce_length,
@ -2170,7 +2088,9 @@ psa_status_t psa_aead_encrypt(psa_key_handle_t handle,
/** Process an authenticated decryption operation. /** Process an authenticated decryption operation.
* *
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the
* operation. It must allow the usage
* PSA_KEY_USAGE_DECRYPT.
* \param alg The AEAD algorithm to compute * \param alg The AEAD algorithm to compute
* (\c PSA_ALG_XXX value such that * (\c PSA_ALG_XXX value such that
* #PSA_ALG_IS_AEAD(\p alg) is true). * #PSA_ALG_IS_AEAD(\p alg) is true).
@ -2201,7 +2121,7 @@ psa_status_t psa_aead_encrypt(psa_key_handle_t handle,
* The ciphertext is not authentic. * The ciphertext is not authentic.
* \retval #PSA_ERROR_NOT_PERMITTED * \retval #PSA_ERROR_NOT_PERMITTED
* \retval #PSA_ERROR_INVALID_ARGUMENT * \retval #PSA_ERROR_INVALID_ARGUMENT
* \p handle is not compatible with \p alg. * \p key is not compatible with \p alg.
* \retval #PSA_ERROR_NOT_SUPPORTED * \retval #PSA_ERROR_NOT_SUPPORTED
* \p alg is not supported or is not an AEAD algorithm. * \p alg is not supported or is not an AEAD algorithm.
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
@ -2216,7 +2136,7 @@ psa_status_t psa_aead_encrypt(psa_key_handle_t handle,
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_aead_decrypt(psa_key_handle_t handle, psa_status_t psa_aead_decrypt(mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *nonce, const uint8_t *nonce,
size_t nonce_length, size_t nonce_length,
@ -2312,9 +2232,10 @@ static psa_aead_operation_t psa_aead_operation_init(void);
* \param[in,out] operation The operation object to set up. It must have * \param[in,out] operation The operation object to set up. It must have
* been initialized as per the documentation for * been initialized as per the documentation for
* #psa_aead_operation_t and not yet in use. * #psa_aead_operation_t and not yet in use.
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the operation.
* It must remain valid until the operation * It must remain valid until the operation
* terminates. * terminates. It must allow the usage
* PSA_KEY_USAGE_ENCRYPT.
* \param alg The AEAD algorithm to compute * \param alg The AEAD algorithm to compute
* (\c PSA_ALG_XXX value such that * (\c PSA_ALG_XXX value such that
* #PSA_ALG_IS_AEAD(\p alg) is true). * #PSA_ALG_IS_AEAD(\p alg) is true).
@ -2326,7 +2247,7 @@ static psa_aead_operation_t psa_aead_operation_init(void);
* \retval #PSA_ERROR_INVALID_HANDLE * \retval #PSA_ERROR_INVALID_HANDLE
* \retval #PSA_ERROR_NOT_PERMITTED * \retval #PSA_ERROR_NOT_PERMITTED
* \retval #PSA_ERROR_INVALID_ARGUMENT * \retval #PSA_ERROR_INVALID_ARGUMENT
* \p handle is not compatible with \p alg. * \p key is not compatible with \p alg.
* \retval #PSA_ERROR_NOT_SUPPORTED * \retval #PSA_ERROR_NOT_SUPPORTED
* \p alg is not supported or is not an AEAD algorithm. * \p alg is not supported or is not an AEAD algorithm.
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
@ -2340,7 +2261,7 @@ static psa_aead_operation_t psa_aead_operation_init(void);
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_aead_encrypt_setup(psa_aead_operation_t *operation, psa_status_t psa_aead_encrypt_setup(psa_aead_operation_t *operation,
psa_key_handle_t handle, mbedtls_svc_key_id_t key,
psa_algorithm_t alg); psa_algorithm_t alg);
/** Set the key for a multipart authenticated decryption operation. /** Set the key for a multipart authenticated decryption operation.
@ -2378,9 +2299,10 @@ psa_status_t psa_aead_encrypt_setup(psa_aead_operation_t *operation,
* \param[in,out] operation The operation object to set up. It must have * \param[in,out] operation The operation object to set up. It must have
* been initialized as per the documentation for * been initialized as per the documentation for
* #psa_aead_operation_t and not yet in use. * #psa_aead_operation_t and not yet in use.
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the operation.
* It must remain valid until the operation * It must remain valid until the operation
* terminates. * terminates. It must allow the usage
* PSA_KEY_USAGE_DECRYPT.
* \param alg The AEAD algorithm to compute * \param alg The AEAD algorithm to compute
* (\c PSA_ALG_XXX value such that * (\c PSA_ALG_XXX value such that
* #PSA_ALG_IS_AEAD(\p alg) is true). * #PSA_ALG_IS_AEAD(\p alg) is true).
@ -2392,7 +2314,7 @@ psa_status_t psa_aead_encrypt_setup(psa_aead_operation_t *operation,
* \retval #PSA_ERROR_INVALID_HANDLE * \retval #PSA_ERROR_INVALID_HANDLE
* \retval #PSA_ERROR_NOT_PERMITTED * \retval #PSA_ERROR_NOT_PERMITTED
* \retval #PSA_ERROR_INVALID_ARGUMENT * \retval #PSA_ERROR_INVALID_ARGUMENT
* \p handle is not compatible with \p alg. * \p key is not compatible with \p alg.
* \retval #PSA_ERROR_NOT_SUPPORTED * \retval #PSA_ERROR_NOT_SUPPORTED
* \p alg is not supported or is not an AEAD algorithm. * \p alg is not supported or is not an AEAD algorithm.
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
@ -2406,7 +2328,7 @@ psa_status_t psa_aead_encrypt_setup(psa_aead_operation_t *operation,
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_aead_decrypt_setup(psa_aead_operation_t *operation, psa_status_t psa_aead_decrypt_setup(psa_aead_operation_t *operation,
psa_key_handle_t handle, mbedtls_svc_key_id_t key,
psa_algorithm_t alg); psa_algorithm_t alg);
/** Generate a random nonce for an authenticated encryption operation. /** Generate a random nonce for an authenticated encryption operation.
@ -2864,10 +2786,11 @@ psa_status_t psa_aead_abort(psa_aead_operation_t *operation);
* parameter to this function. You can use #PSA_ALG_SIGN_GET_HASH(\p alg) * parameter to this function. You can use #PSA_ALG_SIGN_GET_HASH(\p alg)
* to determine the hash algorithm to use. * to determine the hash algorithm to use.
* *
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the operation.
* It must be an asymmetric key pair. * It must be an asymmetric key pair. The key must
* allow the usage PSA_KEY_USAGE_SIGN_HASH.
* \param alg A signature algorithm that is compatible with * \param alg A signature algorithm that is compatible with
* the type of \p handle. * the type of \p key.
* \param[in] hash The hash or message to sign. * \param[in] hash The hash or message to sign.
* \param hash_length Size of the \p hash buffer in bytes. * \param hash_length Size of the \p hash buffer in bytes.
* \param[out] signature Buffer where the signature is to be written. * \param[out] signature Buffer where the signature is to be written.
@ -2883,7 +2806,7 @@ psa_status_t psa_aead_abort(psa_aead_operation_t *operation);
* determine a sufficient buffer size by calling * determine a sufficient buffer size by calling
* #PSA_SIGN_OUTPUT_SIZE(\c key_type, \c key_bits, \p alg) * #PSA_SIGN_OUTPUT_SIZE(\c key_type, \c key_bits, \p alg)
* where \c key_type and \c key_bits are the type and bit-size * where \c key_type and \c key_bits are the type and bit-size
* respectively of \p handle. * respectively of \p key.
* \retval #PSA_ERROR_NOT_SUPPORTED * \retval #PSA_ERROR_NOT_SUPPORTED
* \retval #PSA_ERROR_INVALID_ARGUMENT * \retval #PSA_ERROR_INVALID_ARGUMENT
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
@ -2897,7 +2820,7 @@ psa_status_t psa_aead_abort(psa_aead_operation_t *operation);
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_sign_hash(psa_key_handle_t handle, psa_status_t psa_sign_hash(mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *hash, const uint8_t *hash,
size_t hash_length, size_t hash_length,
@ -2914,10 +2837,11 @@ psa_status_t psa_sign_hash(psa_key_handle_t handle,
* parameter to this function. You can use #PSA_ALG_SIGN_GET_HASH(\p alg) * parameter to this function. You can use #PSA_ALG_SIGN_GET_HASH(\p alg)
* to determine the hash algorithm to use. * to determine the hash algorithm to use.
* *
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the operation. It
* It must be a public key or an asymmetric key pair. * must be a public key or an asymmetric key pair. The
* key must allow the usage PSA_KEY_USAGE_VERIFY_HASH.
* \param alg A signature algorithm that is compatible with * \param alg A signature algorithm that is compatible with
* the type of \p handle. * the type of \p key.
* \param[in] hash The hash or message whose signature is to be * \param[in] hash The hash or message whose signature is to be
* verified. * verified.
* \param hash_length Size of the \p hash buffer in bytes. * \param hash_length Size of the \p hash buffer in bytes.
@ -2943,7 +2867,7 @@ psa_status_t psa_sign_hash(psa_key_handle_t handle,
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_verify_hash(psa_key_handle_t handle, psa_status_t psa_verify_hash(mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *hash, const uint8_t *hash,
size_t hash_length, size_t hash_length,
@ -2953,11 +2877,12 @@ psa_status_t psa_verify_hash(psa_key_handle_t handle,
/** /**
* \brief Encrypt a short message with a public key. * \brief Encrypt a short message with a public key.
* *
* \param handle Handle to the key to use for the operation. * \param key Identifer of the key to use for the operation.
* It must be a public key or an asymmetric * It must be a public key or an asymmetric key
* key pair. * pair. It must allow the usage
* PSA_KEY_USAGE_ENCRYPT.
* \param alg An asymmetric encryption algorithm that is * \param alg An asymmetric encryption algorithm that is
* compatible with the type of \p handle. * compatible with the type of \p key.
* \param[in] input The message to encrypt. * \param[in] input The message to encrypt.
* \param input_length Size of the \p input buffer in bytes. * \param input_length Size of the \p input buffer in bytes.
* \param[in] salt A salt or label, if supported by the * \param[in] salt A salt or label, if supported by the
@ -2986,7 +2911,7 @@ psa_status_t psa_verify_hash(psa_key_handle_t handle,
* determine a sufficient buffer size by calling * determine a sufficient buffer size by calling
* #PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE(\c key_type, \c key_bits, \p alg) * #PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE(\c key_type, \c key_bits, \p alg)
* where \c key_type and \c key_bits are the type and bit-size * where \c key_type and \c key_bits are the type and bit-size
* respectively of \p handle. * respectively of \p key.
* \retval #PSA_ERROR_NOT_SUPPORTED * \retval #PSA_ERROR_NOT_SUPPORTED
* \retval #PSA_ERROR_INVALID_ARGUMENT * \retval #PSA_ERROR_INVALID_ARGUMENT
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
@ -3000,7 +2925,7 @@ psa_status_t psa_verify_hash(psa_key_handle_t handle,
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_asymmetric_encrypt(psa_key_handle_t handle, psa_status_t psa_asymmetric_encrypt(mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *input, const uint8_t *input,
size_t input_length, size_t input_length,
@ -3013,10 +2938,11 @@ psa_status_t psa_asymmetric_encrypt(psa_key_handle_t handle,
/** /**
* \brief Decrypt a short message with a private key. * \brief Decrypt a short message with a private key.
* *
* \param handle Handle to the key to use for the operation. * \param key Identifier of the key to use for the operation.
* It must be an asymmetric key pair. * It must be an asymmetric key pair. It must
* allow the usage PSA_KEY_USAGE_DECRYPT.
* \param alg An asymmetric encryption algorithm that is * \param alg An asymmetric encryption algorithm that is
* compatible with the type of \p handle. * compatible with the type of \p key.
* \param[in] input The message to decrypt. * \param[in] input The message to decrypt.
* \param input_length Size of the \p input buffer in bytes. * \param input_length Size of the \p input buffer in bytes.
* \param[in] salt A salt or label, if supported by the * \param[in] salt A salt or label, if supported by the
@ -3045,7 +2971,7 @@ psa_status_t psa_asymmetric_encrypt(psa_key_handle_t handle,
* determine a sufficient buffer size by calling * determine a sufficient buffer size by calling
* #PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE(\c key_type, \c key_bits, \p alg) * #PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE(\c key_type, \c key_bits, \p alg)
* where \c key_type and \c key_bits are the type and bit-size * where \c key_type and \c key_bits are the type and bit-size
* respectively of \p handle. * respectively of \p key.
* \retval #PSA_ERROR_NOT_SUPPORTED * \retval #PSA_ERROR_NOT_SUPPORTED
* \retval #PSA_ERROR_INVALID_ARGUMENT * \retval #PSA_ERROR_INVALID_ARGUMENT
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
@ -3060,7 +2986,7 @@ psa_status_t psa_asymmetric_encrypt(psa_key_handle_t handle,
* It is implementation-dependent whether a failure to initialize * It is implementation-dependent whether a failure to initialize
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_asymmetric_decrypt(psa_key_handle_t handle, psa_status_t psa_asymmetric_decrypt(mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *input, const uint8_t *input,
size_t input_length, size_t input_length,
@ -3318,9 +3244,9 @@ psa_status_t psa_key_derivation_input_bytes(
* psa_key_derivation_setup() and must not * psa_key_derivation_setup() and must not
* have produced any output yet. * have produced any output yet.
* \param step Which step the input data is for. * \param step Which step the input data is for.
* \param handle Handle to the key. It must have an * \param key Identifier of the key. It must have an
* appropriate type for \p step and must * appropriate type for step and must allow the
* allow the usage #PSA_KEY_USAGE_DERIVE. * usage PSA_KEY_USAGE_DERIVE.
* *
* \retval #PSA_SUCCESS * \retval #PSA_SUCCESS
* Success. * Success.
@ -3346,7 +3272,7 @@ psa_status_t psa_key_derivation_input_bytes(
psa_status_t psa_key_derivation_input_key( psa_status_t psa_key_derivation_input_key(
psa_key_derivation_operation_t *operation, psa_key_derivation_operation_t *operation,
psa_key_derivation_step_t step, psa_key_derivation_step_t step,
psa_key_handle_t handle); mbedtls_svc_key_id_t key);
/** Perform a key agreement and use the shared secret as input to a key /** Perform a key agreement and use the shared secret as input to a key
* derivation. * derivation.
@ -3371,7 +3297,8 @@ psa_status_t psa_key_derivation_input_key(
* The operation must be ready for an * The operation must be ready for an
* input of the type given by \p step. * input of the type given by \p step.
* \param step Which step the input data is for. * \param step Which step the input data is for.
* \param private_key Handle to the private key to use. * \param private_key Identifier of the private key to use. It must
* allow the usage PSA_KEY_USAGE_DERIVE.
* \param[in] peer_key Public key of the peer. The peer key must be in the * \param[in] peer_key Public key of the peer. The peer key must be in the
* same format that psa_import_key() accepts for the * same format that psa_import_key() accepts for the
* public key type corresponding to the type of * public key type corresponding to the type of
@ -3415,7 +3342,7 @@ psa_status_t psa_key_derivation_input_key(
psa_status_t psa_key_derivation_key_agreement( psa_status_t psa_key_derivation_key_agreement(
psa_key_derivation_operation_t *operation, psa_key_derivation_operation_t *operation,
psa_key_derivation_step_t step, psa_key_derivation_step_t step,
psa_key_handle_t private_key, mbedtls_svc_key_id_t private_key,
const uint8_t *peer_key, const uint8_t *peer_key,
size_t peer_key_length); size_t peer_key_length);
@ -3559,8 +3486,8 @@ psa_status_t psa_key_derivation_output_bytes(
* *
* \param[in] attributes The attributes for the new key. * \param[in] attributes The attributes for the new key.
* \param[in,out] operation The key derivation operation object to read from. * \param[in,out] operation The key derivation operation object to read from.
* \param[out] handle On success, a handle to the newly created key. * \param[out] key On success, an identifier for the newly created
* \c 0 on failure. * key. \c 0 on failure.
* *
* \retval #PSA_SUCCESS * \retval #PSA_SUCCESS
* Success. * Success.
@ -3599,7 +3526,7 @@ psa_status_t psa_key_derivation_output_bytes(
psa_status_t psa_key_derivation_output_key( psa_status_t psa_key_derivation_output_key(
const psa_key_attributes_t *attributes, const psa_key_attributes_t *attributes,
psa_key_derivation_operation_t *operation, psa_key_derivation_operation_t *operation,
psa_key_handle_t *handle); mbedtls_svc_key_id_t *key);
/** Abort a key derivation operation. /** Abort a key derivation operation.
* *
@ -3640,7 +3567,8 @@ psa_status_t psa_key_derivation_abort(
* (\c PSA_ALG_XXX value such that * (\c PSA_ALG_XXX value such that
* #PSA_ALG_IS_RAW_KEY_AGREEMENT(\p alg) * #PSA_ALG_IS_RAW_KEY_AGREEMENT(\p alg)
* is true). * is true).
* \param private_key Handle to the private key to use. * \param private_key Identifier of the private key to use. It must
* allow the usage PSA_KEY_USAGE_DERIVE.
* \param[in] peer_key Public key of the peer. It must be * \param[in] peer_key Public key of the peer. It must be
* in the same format that psa_import_key() * in the same format that psa_import_key()
* accepts. The standard formats for public * accepts. The standard formats for public
@ -3678,7 +3606,7 @@ psa_status_t psa_key_derivation_abort(
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_raw_key_agreement(psa_algorithm_t alg, psa_status_t psa_raw_key_agreement(psa_algorithm_t alg,
psa_key_handle_t private_key, mbedtls_svc_key_id_t private_key,
const uint8_t *peer_key, const uint8_t *peer_key,
size_t peer_key_length, size_t peer_key_length,
uint8_t *output, uint8_t *output,
@ -3734,8 +3662,8 @@ psa_status_t psa_generate_random(uint8_t *output,
* attributes. * attributes.
* *
* \param[in] attributes The attributes for the new key. * \param[in] attributes The attributes for the new key.
* \param[out] handle On success, a handle to the newly created key. * \param[out] key On success, an identifier for the newly created
* \c 0 on failure. * key. \c 0 on failure.
* *
* \retval #PSA_SUCCESS * \retval #PSA_SUCCESS
* Success. * Success.
@ -3759,7 +3687,7 @@ psa_status_t psa_generate_random(uint8_t *output,
* results in this error code. * results in this error code.
*/ */
psa_status_t psa_generate_key(const psa_key_attributes_t *attributes, psa_status_t psa_generate_key(const psa_key_attributes_t *attributes,
psa_key_handle_t *handle); mbedtls_svc_key_id_t *key);
/**@}*/ /**@}*/

135
include/psa/crypto_compat.h
View File

@ -34,6 +34,40 @@
extern "C" { extern "C" {
#endif #endif
/*
* To support temporary both openless APIs and psa_open_key(), define
* psa_key_handle_t to be equal to mbedtls_svc_key_id_t. Do not mark the
* type and its utility macros and functions deprecated yet. This will be done
* in a subsequent phase.
*/
typedef mbedtls_svc_key_id_t psa_key_handle_t;
#define PSA_KEY_HANDLE_INIT MBEDTLS_SVC_KEY_ID_INIT
/** Compare two handles.
*
* \param handle1 First handle.
* \param handle2 Second handle.
*
* \return Non-zero if the two handles are equal, zero otherwise.
*/
static inline int psa_key_handle_equal( psa_key_handle_t handle1,
psa_key_handle_t handle2 )
{
return( mbedtls_svc_key_id_equal( handle1, handle2 ) );
}
/** Check wether an handle is null.
*
* \param handle Handle
*
* \return Non-zero if the handle is null, zero otherwise.
*/
static inline int psa_key_handle_is_null( psa_key_handle_t handle )
{
return( mbedtls_svc_key_id_is_null( handle ) );
}
#if !defined(MBEDTLS_DEPRECATED_REMOVED) #if !defined(MBEDTLS_DEPRECATED_REMOVED)
/* /*
@ -223,6 +257,107 @@ MBEDTLS_PSA_DEPRECATED static inline psa_status_t psa_asymmetric_verify( psa_key
#define PSA_DH_GROUP_CUSTOM \ #define PSA_DH_GROUP_CUSTOM \
MBEDTLS_DEPRECATED_CONSTANT( psa_dh_family_t, PSA_DH_FAMILY_CUSTOM ) MBEDTLS_DEPRECATED_CONSTANT( psa_dh_family_t, PSA_DH_FAMILY_CUSTOM )
/** Open a handle to an existing persistent key.
*
* Open a handle to a persistent key. A key is persistent if it was created
* with a lifetime other than #PSA_KEY_LIFETIME_VOLATILE. A persistent key
* always has a nonzero key identifier, set with psa_set_key_id() when
* creating the key. Implementations may provide additional pre-provisioned
* keys that can be opened with psa_open_key(). Such keys have an application
* key identifier in the vendor range, as documented in the description of
* #psa_key_id_t.
*
* The application must eventually close the handle with psa_close_key() or
* psa_destroy_key() to release associated resources. If the application dies
* without calling one of these functions, the implementation should perform
* the equivalent of a call to psa_close_key().
*
* Some implementations permit an application to open the same key multiple
* times. If this is successful, each call to psa_open_key() will return a
* different key handle.
*
* \note This API is not part of the PSA Cryptography API Release 1.0.0
* specification. It was defined in the 1.0 Beta 3 version of the
* specification but was removed in the 1.0.0 released version. This API is
* kept for the time being to not break applications relying on it. It is not
* deprecated yet but will be in the near future.
*
* \note Applications that rely on opening a key multiple times will not be
* portable to implementations that only permit a single key handle to be
* opened. See also :ref:\`key-handles\`.
*
*
* \param key The persistent identifier of the key.
* \param[out] handle On success, a handle to the key.
*
* \retval #PSA_SUCCESS
* Success. The application can now use the value of `*handle`
* to access the key.
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
* The implementation does not have sufficient resources to open the
* key. This can be due to reaching an implementation limit on the
* number of open keys, the number of open key handles, or available
* memory.
* \retval #PSA_ERROR_DOES_NOT_EXIST
* There is no persistent key with key identifier \p id.
* \retval #PSA_ERROR_INVALID_ARGUMENT
* \p id is not a valid persistent key identifier.
* \retval #PSA_ERROR_NOT_PERMITTED
* The specified key exists, but the application does not have the
* permission to access it. Note that this specification does not
* define any way to create such a key, but it may be possible
* through implementation-specific means.
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
* \retval #PSA_ERROR_CORRUPTION_DETECTED
* \retval #PSA_ERROR_STORAGE_FAILURE
* \retval #PSA_ERROR_BAD_STATE
* The library has not been previously initialized by psa_crypto_init().
* It is implementation-dependent whether a failure to initialize
* results in this error code.
*/
psa_status_t psa_open_key( mbedtls_svc_key_id_t key,
psa_key_handle_t *handle );
/** Close a key handle.
*
* If the handle designates a volatile key, this will destroy the key material
* and free all associated resources, just like psa_destroy_key().
*
* If this is the last open handle to a persistent key, then closing the handle
* will free all resources associated with the key in volatile memory. The key
* data in persistent storage is not affected and can be opened again later
* with a call to psa_open_key().
*
* Closing the key handle makes the handle invalid, and the key handle
* must not be used again by the application.
*
* \note This API is not part of the PSA Cryptography API Release 1.0.0
* specification. It was defined in the 1.0 Beta 3 version of the
* specification but was removed in the 1.0.0 released version. This API is
* kept for the time being to not break applications relying on it. It is not
* deprecated yet but will be in the near future.
*
* \note If the key handle was used to set up an active
* :ref:\`multipart operation <multipart-operations>\`, then closing the
* key handle can cause the multipart operation to fail. Applications should
* maintain the key handle until after the multipart operation has finished.
*
* \param handle The key handle to close.
* If this is \c 0, do nothing and return \c PSA_SUCCESS.
*
* \retval #PSA_SUCCESS
* \p handle was a valid handle or \c 0. It is now closed.
* \retval #PSA_ERROR_INVALID_HANDLE
* \p handle is not a valid handle nor \c 0.
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
* \retval #PSA_ERROR_CORRUPTION_DETECTED
* \retval #PSA_ERROR_BAD_STATE
* The library has not been previously initialized by psa_crypto_init().
* It is implementation-dependent whether a failure to initialize
* results in this error code.
*/
psa_status_t psa_close_key(psa_key_handle_t handle);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

8
include/psa/crypto_types.h
View File

@ -247,12 +247,6 @@ typedef struct
#endif /* !MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER */ #endif /* !MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER */
/*
* To support temporary both openless APIs and psa_open_key(), define
* psa_key_handle_t to be equal to mbedtls_svc_key_id_t.
*/
typedef mbedtls_svc_key_id_t psa_key_handle_t;
/**@}*/ /**@}*/
/** \defgroup policy Key policies /** \defgroup policy Key policies
@ -358,7 +352,7 @@ typedef uint32_t psa_key_usage_t;
* -# Call a key creation function: psa_import_key(), psa_generate_key(), * -# Call a key creation function: psa_import_key(), psa_generate_key(),
* psa_key_derivation_output_key() or psa_copy_key(). This function reads * psa_key_derivation_output_key() or psa_copy_key(). This function reads
* the attribute structure, creates a key with these attributes, and * the attribute structure, creates a key with these attributes, and
* outputs a handle to the newly created key. * outputs a key identifier to the newly created key.
* -# The attribute structure is now no longer necessary. * -# The attribute structure is now no longer necessary.
* You may call psa_reset_key_attributes(), although this is optional * You may call psa_reset_key_attributes(), although this is optional
* with the workflow presented here because the attributes currently * with the workflow presented here because the attributes currently

40
include/psa/crypto_values.h
View File

@ -108,7 +108,7 @@
* as applicable. * as applicable.
* *
* Implementations shall not return this error code to indicate that a * Implementations shall not return this error code to indicate that a
* key handle is invalid, but shall return #PSA_ERROR_INVALID_HANDLE * key identifier is invalid, but shall return #PSA_ERROR_INVALID_HANDLE
* instead. */ * instead. */
#define PSA_ERROR_BAD_STATE ((psa_status_t)-137) #define PSA_ERROR_BAD_STATE ((psa_status_t)-137)
@ -118,7 +118,7 @@
* combination of parameters are recognized as invalid. * combination of parameters are recognized as invalid.
* *
* Implementations shall not return this error code to indicate that a * Implementations shall not return this error code to indicate that a
* key handle is invalid, but shall return #PSA_ERROR_INVALID_HANDLE * key identifier is invalid, but shall return #PSA_ERROR_INVALID_HANDLE
* instead. * instead.
*/ */
#define PSA_ERROR_INVALID_ARGUMENT ((psa_status_t)-135) #define PSA_ERROR_INVALID_ARGUMENT ((psa_status_t)-135)
@ -266,7 +266,7 @@
* to read from a resource. */ * to read from a resource. */
#define PSA_ERROR_INSUFFICIENT_DATA ((psa_status_t)-143) #define PSA_ERROR_INSUFFICIENT_DATA ((psa_status_t)-143)
/** The key handle is not valid. See also :ref:\`key-handles\`. /** The key identifier is not valid. See also :ref:\`key-handles\`.
*/ */
#define PSA_ERROR_INVALID_HANDLE ((psa_status_t)-136) #define PSA_ERROR_INVALID_HANDLE ((psa_status_t)-136)
@ -769,9 +769,9 @@
* an algorithm built from `PSA_xxx_SIGNATURE` and a specific hash. Each * an algorithm built from `PSA_xxx_SIGNATURE` and a specific hash. Each
* call to sign or verify a message may use a different hash. * call to sign or verify a message may use a different hash.
* ``` * ```
* psa_sign_hash(handle, PSA_xxx_SIGNATURE(PSA_ALG_SHA_256), ...); * psa_sign_hash(key, PSA_xxx_SIGNATURE(PSA_ALG_SHA_256), ...);
* psa_sign_hash(handle, PSA_xxx_SIGNATURE(PSA_ALG_SHA_512), ...); * psa_sign_hash(key, PSA_xxx_SIGNATURE(PSA_ALG_SHA_512), ...);
* psa_sign_hash(handle, PSA_xxx_SIGNATURE(PSA_ALG_SHA3_256), ...); * psa_sign_hash(key, PSA_xxx_SIGNATURE(PSA_ALG_SHA3_256), ...);
* ``` * ```
* *
* This value may not be used to build other algorithms that are * This value may not be used to build other algorithms that are
@ -1561,7 +1561,7 @@
/** The default lifetime for volatile keys. /** The default lifetime for volatile keys.
* *
* A volatile key only exists as long as the handle to it is not closed. * A volatile key only exists as long as the identifier to it is not destroyed.
* The key material is guaranteed to be erased on a power reset. * The key material is guaranteed to be erased on a power reset.
* *
* A key with this lifetime is typically stored in the RAM area of the * A key with this lifetime is typically stored in the RAM area of the
@ -1756,32 +1756,6 @@ static inline int mbedtls_svc_key_id_is_null( mbedtls_svc_key_id_t key )
#endif /* !MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER */ #endif /* !MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER */
#define PSA_KEY_HANDLE_INIT MBEDTLS_SVC_KEY_ID_INIT
/** Compare two handles.
*
* \param handle1 First handle.
* \param handle2 Second handle.
*
* \return Non-zero if the two handles are equal, zero otherwise.
*/
static inline int psa_key_handle_equal( psa_key_handle_t handle1,
psa_key_handle_t handle2 )
{
return( mbedtls_svc_key_id_equal( handle1, handle2 ) );
}
/** Check wether an handle is null.
*
* \param handle Handle
*
* \return Non-zero if the handle is null, zero otherwise.
*/
static inline int psa_key_handle_is_null( psa_key_handle_t handle )
{
return( mbedtls_svc_key_id_is_null( handle ) );
}
/**@}*/ /**@}*/
/** \defgroup policy Key policies /** \defgroup policy Key policies

15
library/pk.c
View File

@ -150,11 +150,12 @@ int mbedtls_pk_setup( mbedtls_pk_context *ctx, const mbedtls_pk_info_t *info )
/* /*
* Initialise a PSA-wrapping context * Initialise a PSA-wrapping context
*/ */
int mbedtls_pk_setup_opaque( mbedtls_pk_context *ctx, const psa_key_handle_t key ) int mbedtls_pk_setup_opaque( mbedtls_pk_context *ctx,
const psa_key_id_t key )
{ {
const mbedtls_pk_info_t * const info = &mbedtls_pk_opaque_info; const mbedtls_pk_info_t * const info = &mbedtls_pk_opaque_info;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_handle_t *pk_ctx; psa_key_id_t *pk_ctx;
psa_key_type_t type; psa_key_type_t type;
if( ctx == NULL || ctx->pk_info != NULL ) if( ctx == NULL || ctx->pk_info != NULL )
@ -174,7 +175,7 @@ int mbedtls_pk_setup_opaque( mbedtls_pk_context *ctx, const psa_key_handle_t key
ctx->pk_info = info; ctx->pk_info = info;
pk_ctx = (psa_key_handle_t *) ctx->pk_ctx; pk_ctx = (psa_key_id_t *) ctx->pk_ctx;
*pk_ctx = key; *pk_ctx = key;
return( 0 ); return( 0 );
@ -587,12 +588,12 @@ mbedtls_pk_type_t mbedtls_pk_get_type( const mbedtls_pk_context *ctx )
* Currently only works for EC private keys. * Currently only works for EC private keys.
*/ */
int mbedtls_pk_wrap_as_opaque( mbedtls_pk_context *pk, int mbedtls_pk_wrap_as_opaque( mbedtls_pk_context *pk,
psa_key_handle_t *handle, psa_key_id_t *key,
psa_algorithm_t hash_alg ) psa_algorithm_t hash_alg )
{ {
#if !defined(MBEDTLS_ECP_C) #if !defined(MBEDTLS_ECP_C)
((void) pk); ((void) pk);
((void) handle); ((void) key);
((void) hash_alg); ((void) hash_alg);
return( MBEDTLS_ERR_PK_TYPE_MISMATCH ); return( MBEDTLS_ERR_PK_TYPE_MISMATCH );
#else #else
@ -624,14 +625,14 @@ int mbedtls_pk_wrap_as_opaque( mbedtls_pk_context *pk,
psa_set_key_algorithm( &attributes, PSA_ALG_ECDSA(hash_alg) ); psa_set_key_algorithm( &attributes, PSA_ALG_ECDSA(hash_alg) );
/* import private key into PSA */ /* import private key into PSA */
if( PSA_SUCCESS != psa_import_key( &attributes, d, d_len, handle ) ) if( PSA_SUCCESS != psa_import_key( &attributes, d, d_len, key ) )
return( MBEDTLS_ERR_PK_HW_ACCEL_FAILED ); return( MBEDTLS_ERR_PK_HW_ACCEL_FAILED );
/* make PK context wrap the key slot */ /* make PK context wrap the key slot */
mbedtls_pk_free( pk ); mbedtls_pk_free( pk );
mbedtls_pk_init( pk ); mbedtls_pk_init( pk );
return( mbedtls_pk_setup_opaque( pk, *handle ) ); return( mbedtls_pk_setup_opaque( pk, *key ) );
#endif /* MBEDTLS_ECP_C */ #endif /* MBEDTLS_ECP_C */
} }
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */

16
library/pk_wrap.c
View File

@ -543,7 +543,7 @@ static int ecdsa_verify_wrap( void *ctx_arg, mbedtls_md_type_t md_alg,
mbedtls_ecdsa_context *ctx = ctx_arg; mbedtls_ecdsa_context *ctx = ctx_arg;
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_handle_t key_handle = PSA_KEY_HANDLE_INIT; psa_key_id_t key_id = 0;
psa_status_t status; psa_status_t status;
mbedtls_pk_context key; mbedtls_pk_context key;
int key_len; int key_len;
@ -576,7 +576,7 @@ static int ecdsa_verify_wrap( void *ctx_arg, mbedtls_md_type_t md_alg,
status = psa_import_key( &attributes, status = psa_import_key( &attributes,
buf + sizeof( buf ) - key_len, key_len, buf + sizeof( buf ) - key_len, key_len,
&key_handle ); &key_id );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
ret = mbedtls_psa_err_translate_pk( status ); ret = mbedtls_psa_err_translate_pk( status );
@ -598,7 +598,7 @@ static int ecdsa_verify_wrap( void *ctx_arg, mbedtls_md_type_t md_alg,
goto cleanup; goto cleanup;
} }
if( psa_verify_hash( key_handle, psa_sig_md, if( psa_verify_hash( key_id, psa_sig_md,
hash, hash_len, hash, hash_len,
buf, 2 * signature_part_size ) buf, 2 * signature_part_size )
!= PSA_SUCCESS ) != PSA_SUCCESS )
@ -615,7 +615,7 @@ static int ecdsa_verify_wrap( void *ctx_arg, mbedtls_md_type_t md_alg,
ret = 0; ret = 0;
cleanup: cleanup:
psa_destroy_key( key_handle ); psa_destroy_key( key_id );
return( ret ); return( ret );
} }
#else /* MBEDTLS_USE_PSA_CRYPTO */ #else /* MBEDTLS_USE_PSA_CRYPTO */
@ -870,7 +870,7 @@ const mbedtls_pk_info_t mbedtls_rsa_alt_info = {
static void *pk_opaque_alloc_wrap( void ) static void *pk_opaque_alloc_wrap( void )
{ {
void *ctx = mbedtls_calloc( 1, sizeof( psa_key_handle_t ) ); void *ctx = mbedtls_calloc( 1, sizeof( psa_key_id_t ) );
/* no _init() function to call, an calloc() already zeroized */ /* no _init() function to call, an calloc() already zeroized */
@ -879,13 +879,13 @@ static void *pk_opaque_alloc_wrap( void )
static void pk_opaque_free_wrap( void *ctx ) static void pk_opaque_free_wrap( void *ctx )
{ {
mbedtls_platform_zeroize( ctx, sizeof( psa_key_handle_t ) ); mbedtls_platform_zeroize( ctx, sizeof( psa_key_id_t ) );
mbedtls_free( ctx ); mbedtls_free( ctx );
} }
static size_t pk_opaque_get_bitlen( const void *ctx ) static size_t pk_opaque_get_bitlen( const void *ctx )
{ {
const psa_key_handle_t *key = (const psa_key_handle_t *) ctx; const psa_key_id_t *key = (const psa_key_id_t *) ctx;
size_t bits; size_t bits;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
@ -1008,7 +1008,7 @@ static int pk_opaque_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
((void) p_rng); ((void) p_rng);
return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE ); return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
#else /* !MBEDTLS_ECDSA_C */ #else /* !MBEDTLS_ECDSA_C */
const psa_key_handle_t *key = (const psa_key_handle_t *) ctx; const psa_key_id_t *key = (const psa_key_id_t *) ctx;
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_algorithm_t alg = PSA_ALG_ECDSA( mbedtls_psa_translate_md( md_alg ) ); psa_algorithm_t alg = PSA_ALG_ECDSA( mbedtls_psa_translate_md( md_alg ) );
size_t buf_len; size_t buf_len;

10
library/pkwrite.c
View File

@ -198,13 +198,13 @@ int mbedtls_pk_write_pubkey( unsigned char **p, unsigned char *start,
if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_OPAQUE ) if( mbedtls_pk_get_type( key ) == MBEDTLS_PK_OPAQUE )
{ {
size_t buffer_size; size_t buffer_size;
psa_key_handle_t* key_slot = (psa_key_handle_t*) key->pk_ctx; psa_key_id_t* key_id = (psa_key_id_t*) key->pk_ctx;
if ( *p < start ) if ( *p < start )
return( MBEDTLS_ERR_PK_BAD_INPUT_DATA ); return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
buffer_size = (size_t)( *p - start ); buffer_size = (size_t)( *p - start );
if ( psa_export_public_key( *key_slot, start, buffer_size, &len ) if ( psa_export_public_key( *key_id, start, buffer_size, &len )
!= PSA_SUCCESS ) != PSA_SUCCESS )
{ {
return( MBEDTLS_ERR_PK_BAD_INPUT_DATA ); return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
@ -265,12 +265,12 @@ int mbedtls_pk_write_pubkey_der( mbedtls_pk_context *key, unsigned char *buf, si
{ {
psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
psa_key_type_t key_type; psa_key_type_t key_type;
psa_key_handle_t handle; psa_key_id_t key_id;
psa_ecc_family_t curve; psa_ecc_family_t curve;
size_t bits; size_t bits;
handle = *((psa_key_handle_t*) key->pk_ctx ); key_id = *((psa_key_id_t*) key->pk_ctx );
if( PSA_SUCCESS != psa_get_key_attributes( handle, &attributes ) ) if( PSA_SUCCESS != psa_get_key_attributes( key_id, &attributes ) )
return( MBEDTLS_ERR_PK_HW_ACCEL_FAILED ); return( MBEDTLS_ERR_PK_HW_ACCEL_FAILED );
key_type = psa_get_key_type( &attributes ); key_type = psa_get_key_type( &attributes );
bits = psa_get_key_bits( &attributes ); bits = psa_get_key_bits( &attributes );

139
library/psa_crypto.c
View File

@ -1190,7 +1190,7 @@ static psa_status_t psa_restrict_key_policy(
/** Retrieve a slot which must contain a key. The key must have allow all the /** Retrieve a slot which must contain a key. The key must have allow all the
* usage flags set in \p usage. If \p alg is nonzero, the key must allow * usage flags set in \p usage. If \p alg is nonzero, the key must allow
* operations with this algorithm. */ * operations with this algorithm. */
static psa_status_t psa_get_key_from_slot( psa_key_handle_t handle, static psa_status_t psa_get_key_from_slot( mbedtls_svc_key_id_t key,
psa_key_slot_t **p_slot, psa_key_slot_t **p_slot,
psa_key_usage_t usage, psa_key_usage_t usage,
psa_algorithm_t alg ) psa_algorithm_t alg )
@ -1200,7 +1200,7 @@ static psa_status_t psa_get_key_from_slot( psa_key_handle_t handle,
*p_slot = NULL; *p_slot = NULL;
status = psa_get_key_slot( handle, &slot ); status = psa_get_key_slot( key, &slot );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( status ); return( status );
@ -1230,12 +1230,12 @@ static psa_status_t psa_get_key_from_slot( psa_key_handle_t handle,
* until secure element support is fully implemented. * until secure element support is fully implemented.
*/ */
#if defined(MBEDTLS_PSA_CRYPTO_SE_C) #if defined(MBEDTLS_PSA_CRYPTO_SE_C)
static psa_status_t psa_get_transparent_key( psa_key_handle_t handle, static psa_status_t psa_get_transparent_key( mbedtls_svc_key_id_t key,
psa_key_slot_t **p_slot, psa_key_slot_t **p_slot,
psa_key_usage_t usage, psa_key_usage_t usage,
psa_algorithm_t alg ) psa_algorithm_t alg )
{ {
psa_status_t status = psa_get_key_from_slot( handle, p_slot, usage, alg ); psa_status_t status = psa_get_key_from_slot( key, p_slot, usage, alg );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( status ); return( status );
if( psa_key_slot_is_external( *p_slot ) ) if( psa_key_slot_is_external( *p_slot ) )
@ -1247,8 +1247,8 @@ static psa_status_t psa_get_transparent_key( psa_key_handle_t handle,
} }
#else /* MBEDTLS_PSA_CRYPTO_SE_C */ #else /* MBEDTLS_PSA_CRYPTO_SE_C */
/* With no secure element support, all keys are transparent. */ /* With no secure element support, all keys are transparent. */
#define psa_get_transparent_key( handle, p_slot, usage, alg ) \ #define psa_get_transparent_key( key, p_slot, usage, alg ) \
psa_get_key_from_slot( handle, p_slot, usage, alg ) psa_get_key_from_slot( key, p_slot, usage, alg )
#endif /* MBEDTLS_PSA_CRYPTO_SE_C */ #endif /* MBEDTLS_PSA_CRYPTO_SE_C */
/** Wipe key data from a slot. Preserve metadata such as the policy. */ /** Wipe key data from a slot. Preserve metadata such as the policy. */
@ -1291,7 +1291,7 @@ psa_status_t psa_wipe_key_slot( psa_key_slot_t *slot )
return( status ); return( status );
} }
psa_status_t psa_destroy_key( psa_key_handle_t handle ) psa_status_t psa_destroy_key( mbedtls_svc_key_id_t key )
{ {
psa_key_slot_t *slot; psa_key_slot_t *slot;
psa_status_t status; /* status of the last operation */ psa_status_t status; /* status of the last operation */
@ -1300,10 +1300,10 @@ psa_status_t psa_destroy_key( psa_key_handle_t handle )
psa_se_drv_table_entry_t *driver; psa_se_drv_table_entry_t *driver;
#endif /* MBEDTLS_PSA_CRYPTO_SE_C */ #endif /* MBEDTLS_PSA_CRYPTO_SE_C */
if( psa_key_handle_is_null( handle ) ) if( mbedtls_svc_key_id_is_null( key ) )
return( PSA_SUCCESS ); return( PSA_SUCCESS );
status = psa_get_key_slot( handle, &slot ); status = psa_get_key_slot( key, &slot );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( status ); return( status );
@ -1470,7 +1470,7 @@ exit:
/** Retrieve all the publicly-accessible attributes of a key. /** Retrieve all the publicly-accessible attributes of a key.
*/ */
psa_status_t psa_get_key_attributes( psa_key_handle_t handle, psa_status_t psa_get_key_attributes( mbedtls_svc_key_id_t key,
psa_key_attributes_t *attributes ) psa_key_attributes_t *attributes )
{ {
psa_key_slot_t *slot; psa_key_slot_t *slot;
@ -1478,7 +1478,7 @@ psa_status_t psa_get_key_attributes( psa_key_handle_t handle,
psa_reset_key_attributes( attributes ); psa_reset_key_attributes( attributes );
status = psa_get_key_from_slot( handle, &slot, 0, 0 ); status = psa_get_key_from_slot( key, &slot, 0, 0 );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( status ); return( status );
@ -1683,7 +1683,7 @@ static psa_status_t psa_internal_export_key( const psa_key_slot_t *slot,
} }
} }
psa_status_t psa_export_key( psa_key_handle_t handle, psa_status_t psa_export_key( mbedtls_svc_key_id_t key,
uint8_t *data, uint8_t *data,
size_t data_size, size_t data_size,
size_t *data_length ) size_t *data_length )
@ -1700,14 +1700,14 @@ psa_status_t psa_export_key( psa_key_handle_t handle,
/* Export requires the EXPORT flag. There is an exception for public keys, /* Export requires the EXPORT flag. There is an exception for public keys,
* which don't require any flag, but psa_get_key_from_slot takes * which don't require any flag, but psa_get_key_from_slot takes
* care of this. */ * care of this. */
status = psa_get_key_from_slot( handle, &slot, PSA_KEY_USAGE_EXPORT, 0 ); status = psa_get_key_from_slot( key, &slot, PSA_KEY_USAGE_EXPORT, 0 );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( status ); return( status );
return( psa_internal_export_key( slot, data, data_size, return( psa_internal_export_key( slot, data, data_size,
data_length, 0 ) ); data_length, 0 ) );
} }
psa_status_t psa_export_public_key( psa_key_handle_t handle, psa_status_t psa_export_public_key( mbedtls_svc_key_id_t key,
uint8_t *data, uint8_t *data,
size_t data_size, size_t data_size,
size_t *data_length ) size_t *data_length )
@ -1722,7 +1722,7 @@ psa_status_t psa_export_public_key( psa_key_handle_t handle,
*data_length = 0; *data_length = 0;
/* Exporting a public key doesn't require a usage flag. */ /* Exporting a public key doesn't require a usage flag. */
status = psa_get_key_from_slot( handle, &slot, 0, 0 ); status = psa_get_key_from_slot( key, &slot, 0, 0 );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( status ); return( status );
return( psa_internal_export_key( slot, data, data_size, return( psa_internal_export_key( slot, data, data_size,
@ -1825,7 +1825,8 @@ static psa_status_t psa_validate_key_attributes(
* *
* This function is intended to be used as follows: * This function is intended to be used as follows:
* -# Call psa_start_key_creation() to allocate a key slot, prepare * -# Call psa_start_key_creation() to allocate a key slot, prepare
* it with the specified attributes, and assign it a handle. * it with the specified attributes, and in case of a volatile key assign it
* a volatile key identifier.
* -# Populate the slot with the key material. * -# Populate the slot with the key material.
* -# Call psa_finish_key_creation() to finalize the creation of the slot. * -# Call psa_finish_key_creation() to finalize the creation of the slot.
* In case of failure at any step, stop the sequence and call * In case of failure at any step, stop the sequence and call
@ -1833,7 +1834,7 @@ static psa_status_t psa_validate_key_attributes(
* *
* \param method An identification of the calling function. * \param method An identification of the calling function.
* \param[in] attributes Key attributes for the new key. * \param[in] attributes Key attributes for the new key.
* \param[out] handle On success, a handle for the allocated slot. * \param[out] key On success, identifier of the key.
* \param[out] p_slot On success, a pointer to the prepared slot. * \param[out] p_slot On success, a pointer to the prepared slot.
* \param[out] p_drv On any return, the driver for the key, if any. * \param[out] p_drv On any return, the driver for the key, if any.
* NULL for a transparent key. * NULL for a transparent key.
@ -1846,7 +1847,7 @@ static psa_status_t psa_validate_key_attributes(
static psa_status_t psa_start_key_creation( static psa_status_t psa_start_key_creation(
psa_key_creation_method_t method, psa_key_creation_method_t method,
const psa_key_attributes_t *attributes, const psa_key_attributes_t *attributes,
psa_key_handle_t *handle, mbedtls_svc_key_id_t *key,
psa_key_slot_t **p_slot, psa_key_slot_t **p_slot,
psa_se_drv_table_entry_t **p_drv ) psa_se_drv_table_entry_t **p_drv )
{ {
@ -1938,7 +1939,7 @@ static psa_status_t psa_start_key_creation(
} }
#endif /* MBEDTLS_PSA_CRYPTO_SE_C */ #endif /* MBEDTLS_PSA_CRYPTO_SE_C */
*handle = slot->attr.id; *key = slot->attr.id;
return( PSA_SUCCESS ); return( PSA_SUCCESS );
} }
@ -1956,7 +1957,7 @@ static psa_status_t psa_start_key_creation(
* or NULL for a transparent key. * or NULL for a transparent key.
* *
* \retval #PSA_SUCCESS * \retval #PSA_SUCCESS
* The key was successfully created. The handle is now valid. * The key was successfully created.
* \return If this function fails, the key slot is an invalid state. * \return If this function fails, the key slot is an invalid state.
* You must call psa_fail_key_creation() to wipe and free the slot. * You must call psa_fail_key_creation() to wipe and free the slot.
*/ */
@ -2138,7 +2139,7 @@ static psa_status_t psa_validate_optional_attributes(
psa_status_t psa_import_key( const psa_key_attributes_t *attributes, psa_status_t psa_import_key( const psa_key_attributes_t *attributes,
const uint8_t *data, const uint8_t *data,
size_t data_length, size_t data_length,
psa_key_handle_t *handle ) mbedtls_svc_key_id_t *key )
{ {
psa_status_t status; psa_status_t status;
psa_key_slot_t *slot = NULL; psa_key_slot_t *slot = NULL;
@ -2151,7 +2152,7 @@ psa_status_t psa_import_key( const psa_key_attributes_t *attributes,
return( PSA_ERROR_INVALID_ARGUMENT ); return( PSA_ERROR_INVALID_ARGUMENT );
status = psa_start_key_creation( PSA_KEY_CREATION_IMPORT, attributes, status = psa_start_key_creation( PSA_KEY_CREATION_IMPORT, attributes,
handle, &slot, &driver ); key, &slot, &driver );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
goto exit; goto exit;
@ -2197,7 +2198,7 @@ exit:
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
psa_fail_key_creation( slot, driver ); psa_fail_key_creation( slot, driver );
*handle = PSA_KEY_HANDLE_INIT; *key = MBEDTLS_SVC_KEY_ID_INIT;
} }
return( status ); return( status );
} }
@ -2209,7 +2210,7 @@ psa_status_t mbedtls_psa_register_se_key(
psa_status_t status; psa_status_t status;
psa_key_slot_t *slot = NULL; psa_key_slot_t *slot = NULL;
psa_se_drv_table_entry_t *driver = NULL; psa_se_drv_table_entry_t *driver = NULL;
psa_key_handle_t handle = PSA_KEY_HANDLE_INIT; mbedtls_svc_key_id_t key = MBEDTLS_SVC_KEY_ID_INIT;
/* Leaving attributes unspecified is not currently supported. /* Leaving attributes unspecified is not currently supported.
* It could make sense to query the key type and size from the * It could make sense to query the key type and size from the
@ -2221,7 +2222,7 @@ psa_status_t mbedtls_psa_register_se_key(
return( PSA_ERROR_NOT_SUPPORTED ); return( PSA_ERROR_NOT_SUPPORTED );
status = psa_start_key_creation( PSA_KEY_CREATION_REGISTER, attributes, status = psa_start_key_creation( PSA_KEY_CREATION_REGISTER, attributes,
&handle, &slot, &driver ); &key, &slot, &driver );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
goto exit; goto exit;
@ -2233,7 +2234,7 @@ exit:
psa_fail_key_creation( slot, driver ); psa_fail_key_creation( slot, driver );
} }
/* Registration doesn't keep the key in RAM. */ /* Registration doesn't keep the key in RAM. */
psa_close_key( handle ); psa_close_key( key );
return( status ); return( status );
} }
#endif /* MBEDTLS_PSA_CRYPTO_SE_C */ #endif /* MBEDTLS_PSA_CRYPTO_SE_C */
@ -2253,9 +2254,9 @@ static psa_status_t psa_copy_key_material( const psa_key_slot_t *source,
return( PSA_SUCCESS ); return( PSA_SUCCESS );
} }
psa_status_t psa_copy_key( psa_key_handle_t source_handle, psa_status_t psa_copy_key( mbedtls_svc_key_id_t source_key,
const psa_key_attributes_t *specified_attributes, const psa_key_attributes_t *specified_attributes,
psa_key_handle_t *target_handle ) mbedtls_svc_key_id_t *target_key )
{ {
psa_status_t status; psa_status_t status;
psa_key_slot_t *source_slot = NULL; psa_key_slot_t *source_slot = NULL;
@ -2263,7 +2264,7 @@ psa_status_t psa_copy_key( psa_key_handle_t source_handle,
psa_key_attributes_t actual_attributes = *specified_attributes; psa_key_attributes_t actual_attributes = *specified_attributes;
psa_se_drv_table_entry_t *driver = NULL; psa_se_drv_table_entry_t *driver = NULL;
status = psa_get_transparent_key( source_handle, &source_slot, status = psa_get_transparent_key( source_key, &source_slot,
PSA_KEY_USAGE_COPY, 0 ); PSA_KEY_USAGE_COPY, 0 );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
goto exit; goto exit;
@ -2280,7 +2281,7 @@ psa_status_t psa_copy_key( psa_key_handle_t source_handle,
status = psa_start_key_creation( PSA_KEY_CREATION_COPY, status = psa_start_key_creation( PSA_KEY_CREATION_COPY,
&actual_attributes, &actual_attributes,
target_handle, &target_slot, &driver ); target_key, &target_slot, &driver );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
goto exit; goto exit;
@ -2302,7 +2303,7 @@ exit:
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
psa_fail_key_creation( target_slot, driver ); psa_fail_key_creation( target_slot, driver );
*target_handle = PSA_KEY_HANDLE_INIT; *target_key = MBEDTLS_SVC_KEY_ID_INIT;
} }
return( status ); return( status );
} }
@ -3086,7 +3087,7 @@ cleanup:
#endif /* MBEDTLS_MD_C */ #endif /* MBEDTLS_MD_C */
static psa_status_t psa_mac_setup( psa_mac_operation_t *operation, static psa_status_t psa_mac_setup( psa_mac_operation_t *operation,
psa_key_handle_t handle, mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
int is_sign ) int is_sign )
{ {
@ -3110,7 +3111,7 @@ static psa_status_t psa_mac_setup( psa_mac_operation_t *operation,
if( is_sign ) if( is_sign )
operation->is_sign = 1; operation->is_sign = 1;
status = psa_get_transparent_key( handle, &slot, usage, alg ); status = psa_get_transparent_key( key, &slot, usage, alg );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
goto exit; goto exit;
key_bits = psa_get_key_slot_bits( slot ); key_bits = psa_get_key_slot_bits( slot );
@ -3203,17 +3204,17 @@ exit:
} }
psa_status_t psa_mac_sign_setup( psa_mac_operation_t *operation, psa_status_t psa_mac_sign_setup( psa_mac_operation_t *operation,
psa_key_handle_t handle, mbedtls_svc_key_id_t key,
psa_algorithm_t alg ) psa_algorithm_t alg )
{ {
return( psa_mac_setup( operation, handle, alg, 1 ) ); return( psa_mac_setup( operation, key, alg, 1 ) );
} }
psa_status_t psa_mac_verify_setup( psa_mac_operation_t *operation, psa_status_t psa_mac_verify_setup( psa_mac_operation_t *operation,
psa_key_handle_t handle, mbedtls_svc_key_id_t key,
psa_algorithm_t alg ) psa_algorithm_t alg )
{ {
return( psa_mac_setup( operation, handle, alg, 0 ) ); return( psa_mac_setup( operation, key, alg, 0 ) );
} }
psa_status_t psa_mac_update( psa_mac_operation_t *operation, psa_status_t psa_mac_update( psa_mac_operation_t *operation,
@ -3688,7 +3689,7 @@ cleanup:
} }
#endif /* defined(MBEDTLS_PSA_BUILTIN_ALG_ECDSA) || defined(MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA */ #endif /* defined(MBEDTLS_PSA_BUILTIN_ALG_ECDSA) || defined(MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA */
psa_status_t psa_sign_hash( psa_key_handle_t handle, psa_status_t psa_sign_hash( mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *hash, const uint8_t *hash,
size_t hash_length, size_t hash_length,
@ -3707,7 +3708,7 @@ psa_status_t psa_sign_hash( psa_key_handle_t handle,
if( signature_size == 0 ) if( signature_size == 0 )
return( PSA_ERROR_BUFFER_TOO_SMALL ); return( PSA_ERROR_BUFFER_TOO_SMALL );
status = psa_get_key_from_slot( handle, &slot, PSA_KEY_USAGE_SIGN_HASH, alg ); status = psa_get_key_from_slot( key, &slot, PSA_KEY_USAGE_SIGN_HASH, alg );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
goto exit; goto exit;
if( ! PSA_KEY_TYPE_IS_KEY_PAIR( slot->attr.type ) ) if( ! PSA_KEY_TYPE_IS_KEY_PAIR( slot->attr.type ) )
@ -3806,7 +3807,7 @@ exit:
return( status ); return( status );
} }
psa_status_t psa_verify_hash( psa_key_handle_t handle, psa_status_t psa_verify_hash( mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *hash, const uint8_t *hash,
size_t hash_length, size_t hash_length,
@ -3816,7 +3817,8 @@ psa_status_t psa_verify_hash( psa_key_handle_t handle,
psa_key_slot_t *slot; psa_key_slot_t *slot;
psa_status_t status; psa_status_t status;
status = psa_get_key_from_slot( handle, &slot, PSA_KEY_USAGE_VERIFY_HASH, alg ); status = psa_get_key_from_slot( key, &slot,
PSA_KEY_USAGE_VERIFY_HASH, alg );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( status ); return( status );
@ -3897,7 +3899,7 @@ static void psa_rsa_oaep_set_padding_mode( psa_algorithm_t alg,
} }
#endif /* defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PKCS1_V21) */ #endif /* defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PKCS1_V21) */
psa_status_t psa_asymmetric_encrypt( psa_key_handle_t handle, psa_status_t psa_asymmetric_encrypt( mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *input, const uint8_t *input,
size_t input_length, size_t input_length,
@ -3921,7 +3923,7 @@ psa_status_t psa_asymmetric_encrypt( psa_key_handle_t handle,
if( ! PSA_ALG_IS_RSA_OAEP( alg ) && salt_length != 0 ) if( ! PSA_ALG_IS_RSA_OAEP( alg ) && salt_length != 0 )
return( PSA_ERROR_INVALID_ARGUMENT ); return( PSA_ERROR_INVALID_ARGUMENT );
status = psa_get_transparent_key( handle, &slot, PSA_KEY_USAGE_ENCRYPT, alg ); status = psa_get_transparent_key( key, &slot, PSA_KEY_USAGE_ENCRYPT, alg );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( status ); return( status );
if( ! ( PSA_KEY_TYPE_IS_PUBLIC_KEY( slot->attr.type ) || if( ! ( PSA_KEY_TYPE_IS_PUBLIC_KEY( slot->attr.type ) ||
@ -3993,7 +3995,7 @@ rsa_exit:
} }
} }
psa_status_t psa_asymmetric_decrypt( psa_key_handle_t handle, psa_status_t psa_asymmetric_decrypt( mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *input, const uint8_t *input,
size_t input_length, size_t input_length,
@ -4017,7 +4019,7 @@ psa_status_t psa_asymmetric_decrypt( psa_key_handle_t handle,
if( ! PSA_ALG_IS_RSA_OAEP( alg ) && salt_length != 0 ) if( ! PSA_ALG_IS_RSA_OAEP( alg ) && salt_length != 0 )
return( PSA_ERROR_INVALID_ARGUMENT ); return( PSA_ERROR_INVALID_ARGUMENT );
status = psa_get_transparent_key( handle, &slot, PSA_KEY_USAGE_DECRYPT, alg ); status = psa_get_transparent_key( key, &slot, PSA_KEY_USAGE_DECRYPT, alg );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( status ); return( status );
if( ! PSA_KEY_TYPE_IS_KEY_PAIR( slot->attr.type ) ) if( ! PSA_KEY_TYPE_IS_KEY_PAIR( slot->attr.type ) )
@ -4095,7 +4097,7 @@ rsa_exit:
/****************************************************************/ /****************************************************************/
static psa_status_t psa_cipher_setup( psa_cipher_operation_t *operation, static psa_status_t psa_cipher_setup( psa_cipher_operation_t *operation,
psa_key_handle_t handle, mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
mbedtls_operation_t cipher_operation ) mbedtls_operation_t cipher_operation )
{ {
@ -4117,7 +4119,7 @@ static psa_status_t psa_cipher_setup( psa_cipher_operation_t *operation,
return( PSA_ERROR_INVALID_ARGUMENT ); return( PSA_ERROR_INVALID_ARGUMENT );
/* Fetch key material from key storage. */ /* Fetch key material from key storage. */
status = psa_get_key_from_slot( handle, &slot, usage, alg ); status = psa_get_key_from_slot( key, &slot, usage, alg );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
goto exit; goto exit;
@ -4248,17 +4250,17 @@ exit:
} }
psa_status_t psa_cipher_encrypt_setup( psa_cipher_operation_t *operation, psa_status_t psa_cipher_encrypt_setup( psa_cipher_operation_t *operation,
psa_key_handle_t handle, mbedtls_svc_key_id_t key,
psa_algorithm_t alg ) psa_algorithm_t alg )
{ {
return( psa_cipher_setup( operation, handle, alg, MBEDTLS_ENCRYPT ) ); return( psa_cipher_setup( operation, key, alg, MBEDTLS_ENCRYPT ) );
} }
psa_status_t psa_cipher_decrypt_setup( psa_cipher_operation_t *operation, psa_status_t psa_cipher_decrypt_setup( psa_cipher_operation_t *operation,
psa_key_handle_t handle, mbedtls_svc_key_id_t key,
psa_algorithm_t alg ) psa_algorithm_t alg )
{ {
return( psa_cipher_setup( operation, handle, alg, MBEDTLS_DECRYPT ) ); return( psa_cipher_setup( operation, key, alg, MBEDTLS_DECRYPT ) );
} }
psa_status_t psa_cipher_generate_iv( psa_cipher_operation_t *operation, psa_status_t psa_cipher_generate_iv( psa_cipher_operation_t *operation,
@ -4643,7 +4645,7 @@ static void psa_aead_abort_internal( aead_operation_t *operation )
} }
static psa_status_t psa_aead_setup( aead_operation_t *operation, static psa_status_t psa_aead_setup( aead_operation_t *operation,
psa_key_handle_t handle, mbedtls_svc_key_id_t key,
psa_key_usage_t usage, psa_key_usage_t usage,
psa_algorithm_t alg ) psa_algorithm_t alg )
{ {
@ -4651,7 +4653,7 @@ static psa_status_t psa_aead_setup( aead_operation_t *operation,
size_t key_bits; size_t key_bits;
mbedtls_cipher_id_t cipher_id; mbedtls_cipher_id_t cipher_id;
status = psa_get_transparent_key( handle, &operation->slot, usage, alg ); status = psa_get_transparent_key( key, &operation->slot, usage, alg );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( status ); return( status );
@ -4737,7 +4739,7 @@ cleanup:
return( status ); return( status );
} }
psa_status_t psa_aead_encrypt( psa_key_handle_t handle, psa_status_t psa_aead_encrypt( mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *nonce, const uint8_t *nonce,
size_t nonce_length, size_t nonce_length,
@ -4755,7 +4757,7 @@ psa_status_t psa_aead_encrypt( psa_key_handle_t handle,
*ciphertext_length = 0; *ciphertext_length = 0;
status = psa_aead_setup( &operation, handle, PSA_KEY_USAGE_ENCRYPT, alg ); status = psa_aead_setup( &operation, key, PSA_KEY_USAGE_ENCRYPT, alg );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( status ); return( status );
@ -4851,7 +4853,7 @@ static psa_status_t psa_aead_unpadded_locate_tag( size_t tag_length,
return( PSA_SUCCESS ); return( PSA_SUCCESS );
} }
psa_status_t psa_aead_decrypt( psa_key_handle_t handle, psa_status_t psa_aead_decrypt( mbedtls_svc_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const uint8_t *nonce, const uint8_t *nonce,
size_t nonce_length, size_t nonce_length,
@ -4869,7 +4871,7 @@ psa_status_t psa_aead_decrypt( psa_key_handle_t handle,
*plaintext_length = 0; *plaintext_length = 0;
status = psa_aead_setup( &operation, handle, PSA_KEY_USAGE_DECRYPT, alg ); status = psa_aead_setup( &operation, key, PSA_KEY_USAGE_DECRYPT, alg );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( status ); return( status );
@ -5368,7 +5370,7 @@ exit:
psa_status_t psa_key_derivation_output_key( const psa_key_attributes_t *attributes, psa_status_t psa_key_derivation_output_key( const psa_key_attributes_t *attributes,
psa_key_derivation_operation_t *operation, psa_key_derivation_operation_t *operation,
psa_key_handle_t *handle ) mbedtls_svc_key_id_t *key )
{ {
psa_status_t status; psa_status_t status;
psa_key_slot_t *slot = NULL; psa_key_slot_t *slot = NULL;
@ -5383,7 +5385,7 @@ psa_status_t psa_key_derivation_output_key( const psa_key_attributes_t *attribut
return( PSA_ERROR_NOT_PERMITTED ); return( PSA_ERROR_NOT_PERMITTED );
status = psa_start_key_creation( PSA_KEY_CREATION_DERIVE, status = psa_start_key_creation( PSA_KEY_CREATION_DERIVE,
attributes, handle, &slot, &driver ); attributes, key, &slot, &driver );
#if defined(MBEDTLS_PSA_CRYPTO_SE_C) #if defined(MBEDTLS_PSA_CRYPTO_SE_C)
if( driver != NULL ) if( driver != NULL )
{ {
@ -5402,7 +5404,7 @@ psa_status_t psa_key_derivation_output_key( const psa_key_attributes_t *attribut
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
psa_fail_key_creation( slot, driver ); psa_fail_key_creation( slot, driver );
*handle = PSA_KEY_HANDLE_INIT; *key = MBEDTLS_SVC_KEY_ID_INIT;
} }
return( status ); return( status );
} }
@ -5765,14 +5767,13 @@ psa_status_t psa_key_derivation_input_bytes(
psa_status_t psa_key_derivation_input_key( psa_status_t psa_key_derivation_input_key(
psa_key_derivation_operation_t *operation, psa_key_derivation_operation_t *operation,
psa_key_derivation_step_t step, psa_key_derivation_step_t step,
psa_key_handle_t handle ) mbedtls_svc_key_id_t key )
{ {
psa_key_slot_t *slot; psa_key_slot_t *slot;
psa_status_t status; psa_status_t status;
status = psa_get_transparent_key( handle, &slot, status = psa_get_transparent_key( key, &slot,
PSA_KEY_USAGE_DERIVE, PSA_KEY_USAGE_DERIVE, operation->alg );
operation->alg );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
psa_key_derivation_abort( operation ); psa_key_derivation_abort( operation );
@ -5931,7 +5932,7 @@ exit:
psa_status_t psa_key_derivation_key_agreement( psa_key_derivation_operation_t *operation, psa_status_t psa_key_derivation_key_agreement( psa_key_derivation_operation_t *operation,
psa_key_derivation_step_t step, psa_key_derivation_step_t step,
psa_key_handle_t private_key, mbedtls_svc_key_id_t private_key,
const uint8_t *peer_key, const uint8_t *peer_key,
size_t peer_key_length ) size_t peer_key_length )
{ {
@ -5959,7 +5960,7 @@ psa_status_t psa_key_derivation_key_agreement( psa_key_derivation_operation_t *o
} }
psa_status_t psa_raw_key_agreement( psa_algorithm_t alg, psa_status_t psa_raw_key_agreement( psa_algorithm_t alg,
psa_key_handle_t private_key, mbedtls_svc_key_id_t private_key,
const uint8_t *peer_key, const uint8_t *peer_key,
size_t peer_key_length, size_t peer_key_length,
uint8_t *output, uint8_t *output,
@ -6212,7 +6213,7 @@ static psa_status_t psa_generate_key_internal(
} }
psa_status_t psa_generate_key( const psa_key_attributes_t *attributes, psa_status_t psa_generate_key( const psa_key_attributes_t *attributes,
psa_key_handle_t *handle ) mbedtls_svc_key_id_t *key )
{ {
psa_status_t status; psa_status_t status;
psa_key_slot_t *slot = NULL; psa_key_slot_t *slot = NULL;
@ -6224,7 +6225,7 @@ psa_status_t psa_generate_key( const psa_key_attributes_t *attributes,
return( PSA_ERROR_INVALID_ARGUMENT ); return( PSA_ERROR_INVALID_ARGUMENT );
status = psa_start_key_creation( PSA_KEY_CREATION_GENERATE, status = psa_start_key_creation( PSA_KEY_CREATION_GENERATE,
attributes, handle, &slot, &driver ); attributes, key, &slot, &driver );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
goto exit; goto exit;
@ -6244,7 +6245,7 @@ exit:
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
psa_fail_key_creation( slot, driver ); psa_fail_key_creation( slot, driver );
*handle = PSA_KEY_HANDLE_INIT; *key = MBEDTLS_SVC_KEY_ID_INIT;
} }
return( status ); return( status );
} }

4
library/ssl_cli.c
View File

@ -63,7 +63,7 @@ static int ssl_conf_has_static_psk( mbedtls_ssl_config const *conf )
return( 1 ); return( 1 );
#if defined(MBEDTLS_USE_PSA_CRYPTO) #if defined(MBEDTLS_USE_PSA_CRYPTO)
if( ! psa_key_handle_is_null( conf->psk_opaque ) ) if( ! mbedtls_svc_key_id_is_null( conf->psk_opaque ) )
return( 1 ); return( 1 );
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */
@ -3802,7 +3802,7 @@ static int ssl_write_client_key_exchange( mbedtls_ssl_context *ssl )
status = psa_destroy_key( handshake->ecdh_psa_privkey ); status = psa_destroy_key( handshake->ecdh_psa_privkey );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED ); return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
handshake->ecdh_psa_privkey = PSA_KEY_HANDLE_INIT; handshake->ecdh_psa_privkey = MBEDTLS_SVC_KEY_ID_INIT;
} }
else else
#endif /* MBEDTLS_USE_PSA_CRYPTO && #endif /* MBEDTLS_USE_PSA_CRYPTO &&

6
library/ssl_srv.c
View File

@ -157,7 +157,7 @@ static int ssl_conf_has_psk_or_cb( mbedtls_ssl_config const *conf )
return( 1 ); return( 1 );
#if defined(MBEDTLS_USE_PSA_CRYPTO) #if defined(MBEDTLS_USE_PSA_CRYPTO)
if( ! psa_key_handle_is_null( conf->psk_opaque ) ) if( ! mbedtls_svc_key_id_is_null( conf->psk_opaque ) )
return( 1 ); return( 1 );
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */
@ -172,13 +172,13 @@ static int ssl_use_opaque_psk( mbedtls_ssl_context const *ssl )
/* If we've used a callback to select the PSK, /* If we've used a callback to select the PSK,
* the static configuration is irrelevant. */ * the static configuration is irrelevant. */
if( ! psa_key_handle_is_null( ssl->handshake->psk_opaque ) ) if( ! mbedtls_svc_key_id_is_null( ssl->handshake->psk_opaque ) )
return( 1 ); return( 1 );
return( 0 ); return( 0 );
} }
if( ! psa_key_handle_is_null( ssl->conf->psk_opaque ) ) if( ! mbedtls_svc_key_id_is_null( ssl->conf->psk_opaque ) )
return( 1 ); return( 1 );
return( 0 ); return( 0 );

51
library/ssl_tls.c
View File

@ -446,7 +446,7 @@ exit:
#if defined(MBEDTLS_USE_PSA_CRYPTO) #if defined(MBEDTLS_USE_PSA_CRYPTO)
static psa_status_t setup_psa_key_derivation( psa_key_derivation_operation_t* derivation, static psa_status_t setup_psa_key_derivation( psa_key_derivation_operation_t* derivation,
psa_key_handle_t slot, psa_key_id_t key,
psa_algorithm_t alg, psa_algorithm_t alg,
const unsigned char* seed, size_t seed_length, const unsigned char* seed, size_t seed_length,
const unsigned char* label, size_t label_length, const unsigned char* label, size_t label_length,
@ -466,7 +466,7 @@ static psa_status_t setup_psa_key_derivation( psa_key_derivation_operation_t* de
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( status ); return( status );
if( psa_key_handle_is_null( slot ) ) if( mbedtls_svc_key_id_is_null( key ) )
{ {
status = psa_key_derivation_input_bytes( status = psa_key_derivation_input_bytes(
derivation, PSA_KEY_DERIVATION_INPUT_SECRET, derivation, PSA_KEY_DERIVATION_INPUT_SECRET,
@ -475,8 +475,7 @@ static psa_status_t setup_psa_key_derivation( psa_key_derivation_operation_t* de
else else
{ {
status = psa_key_derivation_input_key( status = psa_key_derivation_input_key(
derivation, PSA_KEY_DERIVATION_INPUT_SECRET, derivation, PSA_KEY_DERIVATION_INPUT_SECRET, key );
slot );
} }
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( status ); return( status );
@ -507,7 +506,7 @@ static int tls_prf_generic( mbedtls_md_type_t md_type,
{ {
psa_status_t status; psa_status_t status;
psa_algorithm_t alg; psa_algorithm_t alg;
psa_key_handle_t master_slot = PSA_KEY_HANDLE_INIT; psa_key_id_t master_key = MBEDTLS_SVC_KEY_ID_INIT;
psa_key_derivation_operation_t derivation = psa_key_derivation_operation_t derivation =
PSA_KEY_DERIVATION_OPERATION_INIT; PSA_KEY_DERIVATION_OPERATION_INIT;
@ -521,7 +520,7 @@ static int tls_prf_generic( mbedtls_md_type_t md_type,
* this PRF is also used to derive an IV, in particular in EAP-TLS, * this PRF is also used to derive an IV, in particular in EAP-TLS,
* and for this use case it makes sense to have a 0-length "secret". * and for this use case it makes sense to have a 0-length "secret".
* Since the key API doesn't allow importing a key of length 0, * Since the key API doesn't allow importing a key of length 0,
* keep master_slot=0, which setup_psa_key_derivation() understands * keep master_key=0, which setup_psa_key_derivation() understands
* to mean a 0-length "secret" input. */ * to mean a 0-length "secret" input. */
if( slen != 0 ) if( slen != 0 )
{ {
@ -530,13 +529,13 @@ static int tls_prf_generic( mbedtls_md_type_t md_type,
psa_set_key_algorithm( &key_attributes, alg ); psa_set_key_algorithm( &key_attributes, alg );
psa_set_key_type( &key_attributes, PSA_KEY_TYPE_DERIVE ); psa_set_key_type( &key_attributes, PSA_KEY_TYPE_DERIVE );
status = psa_import_key( &key_attributes, secret, slen, &master_slot ); status = psa_import_key( &key_attributes, secret, slen, &master_key );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED ); return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
} }
status = setup_psa_key_derivation( &derivation, status = setup_psa_key_derivation( &derivation,
master_slot, alg, master_key, alg,
random, rlen, random, rlen,
(unsigned char const *) label, (unsigned char const *) label,
(size_t) strlen( label ), (size_t) strlen( label ),
@ -544,7 +543,7 @@ static int tls_prf_generic( mbedtls_md_type_t md_type,
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
psa_key_derivation_abort( &derivation ); psa_key_derivation_abort( &derivation );
psa_destroy_key( master_slot ); psa_destroy_key( master_key );
return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED ); return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
} }
@ -552,19 +551,19 @@ static int tls_prf_generic( mbedtls_md_type_t md_type,
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
psa_key_derivation_abort( &derivation ); psa_key_derivation_abort( &derivation );
psa_destroy_key( master_slot ); psa_destroy_key( master_key );
return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED ); return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
} }
status = psa_key_derivation_abort( &derivation ); status = psa_key_derivation_abort( &derivation );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
{ {
psa_destroy_key( master_slot ); psa_destroy_key( master_key );
return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED ); return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
} }
if( ! psa_key_handle_is_null( master_slot ) ) if( ! mbedtls_svc_key_id_is_null( master_key ) )
status = psa_destroy_key( master_slot ); status = psa_destroy_key( master_key );
if( status != PSA_SUCCESS ) if( status != PSA_SUCCESS )
return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED ); return( MBEDTLS_ERR_SSL_HW_ACCEL_FAILED );
@ -707,13 +706,13 @@ static int ssl_use_opaque_psk( mbedtls_ssl_context const *ssl )
{ {
/* If we've used a callback to select the PSK, /* If we've used a callback to select the PSK,
* the static configuration is irrelevant. */ * the static configuration is irrelevant. */
if( ! psa_key_handle_is_null( ssl->handshake->psk_opaque ) ) if( ! mbedtls_svc_key_id_is_null( ssl->handshake->psk_opaque ) )
return( 1 ); return( 1 );
return( 0 ); return( 0 );
} }
if( ! psa_key_handle_is_null( ssl->conf->psk_opaque ) ) if( ! mbedtls_svc_key_id_is_null( ssl->conf->psk_opaque ) )
return( 1 ); return( 1 );
return( 0 ); return( 0 );
@ -1514,7 +1513,7 @@ static int ssl_compute_master( mbedtls_ssl_handshake_params *handshake,
/* Perform PSK-to-MS expansion in a single step. */ /* Perform PSK-to-MS expansion in a single step. */
psa_status_t status; psa_status_t status;
psa_algorithm_t alg; psa_algorithm_t alg;
psa_key_handle_t psk; psa_key_id_t psk;
psa_key_derivation_operation_t derivation = psa_key_derivation_operation_t derivation =
PSA_KEY_DERIVATION_OPERATION_INIT; PSA_KEY_DERIVATION_OPERATION_INIT;
mbedtls_md_type_t hash_alg = handshake->ciphersuite_info->mac; mbedtls_md_type_t hash_alg = handshake->ciphersuite_info->mac;
@ -4344,11 +4343,11 @@ static void ssl_conf_remove_psk( mbedtls_ssl_config *conf )
{ {
/* Remove reference to existing PSK, if any. */ /* Remove reference to existing PSK, if any. */
#if defined(MBEDTLS_USE_PSA_CRYPTO) #if defined(MBEDTLS_USE_PSA_CRYPTO)
if( ! psa_key_handle_is_null( conf->psk_opaque ) ) if( ! mbedtls_svc_key_id_is_null( conf->psk_opaque ) )
{ {
/* The maintenance of the PSK key slot is the /* The maintenance of the PSK key slot is the
* user's responsibility. */ * user's responsibility. */
conf->psk_opaque = PSA_KEY_HANDLE_INIT; conf->psk_opaque = MBEDTLS_SVC_KEY_ID_INIT;
} }
/* This and the following branch should never /* This and the following branch should never
* be taken simultaenously as we maintain the * be taken simultaenously as we maintain the
@ -4432,9 +4431,9 @@ int mbedtls_ssl_conf_psk( mbedtls_ssl_config *conf,
static void ssl_remove_psk( mbedtls_ssl_context *ssl ) static void ssl_remove_psk( mbedtls_ssl_context *ssl )
{ {
#if defined(MBEDTLS_USE_PSA_CRYPTO) #if defined(MBEDTLS_USE_PSA_CRYPTO)
if( ! psa_key_handle_is_null( ssl->handshake->psk_opaque ) ) if( ! mbedtls_svc_key_id_is_null( ssl->handshake->psk_opaque ) )
{ {
ssl->handshake->psk_opaque = PSA_KEY_HANDLE_INIT; ssl->handshake->psk_opaque = MBEDTLS_SVC_KEY_ID_INIT;
} }
else else
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */
@ -4469,7 +4468,7 @@ int mbedtls_ssl_set_hs_psk( mbedtls_ssl_context *ssl,
#if defined(MBEDTLS_USE_PSA_CRYPTO) #if defined(MBEDTLS_USE_PSA_CRYPTO)
int mbedtls_ssl_conf_psk_opaque( mbedtls_ssl_config *conf, int mbedtls_ssl_conf_psk_opaque( mbedtls_ssl_config *conf,
psa_key_handle_t psk_slot, psa_key_id_t psk,
const unsigned char *psk_identity, const unsigned char *psk_identity,
size_t psk_identity_len ) size_t psk_identity_len )
{ {
@ -4478,9 +4477,9 @@ int mbedtls_ssl_conf_psk_opaque( mbedtls_ssl_config *conf,
ssl_conf_remove_psk( conf ); ssl_conf_remove_psk( conf );
/* Check and set opaque PSK */ /* Check and set opaque PSK */
if( psa_key_handle_is_null( psk_slot ) ) if( mbedtls_svc_key_id_is_null( psk ) )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA ); return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
conf->psk_opaque = psk_slot; conf->psk_opaque = psk;
/* Check and set PSK Identity */ /* Check and set PSK Identity */
ret = ssl_conf_set_psk_identity( conf, psk_identity, ret = ssl_conf_set_psk_identity( conf, psk_identity,
@ -4492,14 +4491,14 @@ int mbedtls_ssl_conf_psk_opaque( mbedtls_ssl_config *conf,
} }
int mbedtls_ssl_set_hs_psk_opaque( mbedtls_ssl_context *ssl, int mbedtls_ssl_set_hs_psk_opaque( mbedtls_ssl_context *ssl,
psa_key_handle_t psk_slot ) psa_key_id_t psk )
{ {
if( ( psa_key_handle_is_null( psk_slot ) ) || if( ( mbedtls_svc_key_id_is_null( psk ) ) ||
( ssl->handshake == NULL ) ) ( ssl->handshake == NULL ) )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA ); return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
ssl_remove_psk( ssl ); ssl_remove_psk( ssl );
ssl->handshake->psk_opaque = psk_slot; ssl->handshake->psk_opaque = psk;
return( 0 ); return( 0 );
} }
#endif /* MBEDTLS_USE_PSA_CRYPTO */ #endif /* MBEDTLS_USE_PSA_CRYPTO */