Gilles Peskine | 961849f | 2018-11-30 18:54:54 +0100 | [diff] [blame] | 1 | /* |
| 2 | * PSA crypto layer on top of Mbed TLS crypto |
| 3 | */ |
Bence Szépkúti | 8697465 | 2020-06-15 11:59:37 +0200 | [diff] [blame] | 4 | /* |
Bence Szépkúti | 1e14827 | 2020-08-07 13:07:28 +0200 | [diff] [blame] | 5 | * Copyright The Mbed TLS Contributors |
Dave Rodgman | 16799db | 2023-11-02 19:47:20 +0000 | [diff] [blame] | 6 | * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later |
Gilles Peskine | 961849f | 2018-11-30 18:54:54 +0100 | [diff] [blame] | 7 | */ |
| 8 | |
| 9 | #ifndef PSA_CRYPTO_SLOT_MANAGEMENT_H |
| 10 | #define PSA_CRYPTO_SLOT_MANAGEMENT_H |
| 11 | |
Gilles Peskine | 011e428 | 2019-06-26 18:34:38 +0200 | [diff] [blame] | 12 | #include "psa/crypto.h" |
Ronald Cron | c4d1b51 | 2020-07-31 11:26:37 +0200 | [diff] [blame] | 13 | #include "psa_crypto_core.h" |
Gilles Peskine | 011e428 | 2019-06-26 18:34:38 +0200 | [diff] [blame] | 14 | #include "psa_crypto_se.h" |
| 15 | |
Ronald Cron | 2a99315 | 2020-07-17 14:13:26 +0200 | [diff] [blame] | 16 | /** Range of volatile key identifiers. |
| 17 | * |
Steven Cooreman | 863470a | 2021-02-15 14:03:19 +0100 | [diff] [blame] | 18 | * The last #MBEDTLS_PSA_KEY_SLOT_COUNT identifiers of the implementation |
| 19 | * range of key identifiers are reserved for volatile key identifiers. |
Ronald Cron | 9678355 | 2020-10-19 12:06:30 +0200 | [diff] [blame] | 20 | * A volatile key identifier is equal to #PSA_KEY_ID_VOLATILE_MIN plus the |
Ronald Cron | 2a99315 | 2020-07-17 14:13:26 +0200 | [diff] [blame] | 21 | * index of the key slot containing the volatile key definition. |
| 22 | */ |
| 23 | |
| 24 | /** The minimum value for a volatile key identifier. |
| 25 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 26 | #define PSA_KEY_ID_VOLATILE_MIN (PSA_KEY_ID_VENDOR_MAX - \ |
| 27 | MBEDTLS_PSA_KEY_SLOT_COUNT + 1) |
Ronald Cron | 2a99315 | 2020-07-17 14:13:26 +0200 | [diff] [blame] | 28 | |
| 29 | /** The maximum value for a volatile key identifier. |
| 30 | */ |
| 31 | #define PSA_KEY_ID_VOLATILE_MAX PSA_KEY_ID_VENDOR_MAX |
| 32 | |
Ronald Cron | 97c8ad5 | 2020-10-15 11:17:11 +0200 | [diff] [blame] | 33 | /** Test whether a key identifier is a volatile key identifier. |
| 34 | * |
| 35 | * \param key_id Key identifier to test. |
| 36 | * |
| 37 | * \retval 1 |
| 38 | * The key identifier is a volatile key identifier. |
| 39 | * \retval 0 |
| 40 | * The key identifier is not a volatile key identifier. |
| 41 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 42 | static inline int psa_key_id_is_volatile(psa_key_id_t key_id) |
Ronald Cron | 97c8ad5 | 2020-10-15 11:17:11 +0200 | [diff] [blame] | 43 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 44 | return (key_id >= PSA_KEY_ID_VOLATILE_MIN) && |
| 45 | (key_id <= PSA_KEY_ID_VOLATILE_MAX); |
Ronald Cron | 97c8ad5 | 2020-10-15 11:17:11 +0200 | [diff] [blame] | 46 | } |
| 47 | |
Ronald Cron | 5c52292 | 2020-11-14 16:35:34 +0100 | [diff] [blame] | 48 | /** Get the description of a key given its identifier and lock it. |
Gilles Peskine | 0982903 | 2018-12-10 17:00:38 +0100 | [diff] [blame] | 49 | * |
Ronald Cron | 5c52292 | 2020-11-14 16:35:34 +0100 | [diff] [blame] | 50 | * The descriptions of volatile keys and loaded persistent keys are stored in |
| 51 | * key slots. This function returns a pointer to the key slot containing the |
| 52 | * description of a key given its identifier. |
Ronald Cron | c4d1b51 | 2020-07-31 11:26:37 +0200 | [diff] [blame] | 53 | * |
Ronald Cron | 5c52292 | 2020-11-14 16:35:34 +0100 | [diff] [blame] | 54 | * In case of a persistent key, the function loads the description of the key |
| 55 | * into a key slot if not already done. |
Ronald Cron | c4d1b51 | 2020-07-31 11:26:37 +0200 | [diff] [blame] | 56 | * |
Ryan Everett | 098c665 | 2024-01-03 13:03:36 +0000 | [diff] [blame] | 57 | * On success, the returned key slot has been registered for reading. |
| 58 | * It is the responsibility of the caller to call psa_unregister_read(slot) |
| 59 | * when they have finished reading the contents of the slot. |
Ronald Cron | f95a2b1 | 2020-10-22 15:24:49 +0200 | [diff] [blame] | 60 | * |
Ronald Cron | c4d1b51 | 2020-07-31 11:26:37 +0200 | [diff] [blame] | 61 | * \param key Key identifier to query. |
Gilles Peskine | 0982903 | 2018-12-10 17:00:38 +0100 | [diff] [blame] | 62 | * \param[out] p_slot On success, `*p_slot` contains a pointer to the |
Ronald Cron | c4d1b51 | 2020-07-31 11:26:37 +0200 | [diff] [blame] | 63 | * key slot containing the description of the key |
| 64 | * identified by \p key. |
Gilles Peskine | 0982903 | 2018-12-10 17:00:38 +0100 | [diff] [blame] | 65 | * |
Ronald Cron | c4d1b51 | 2020-07-31 11:26:37 +0200 | [diff] [blame] | 66 | * \retval #PSA_SUCCESS |
Ronald Cron | 1d12d87 | 2020-11-18 17:21:22 +0100 | [diff] [blame] | 67 | * \p *p_slot contains a pointer to the key slot containing the |
| 68 | * description of the key identified by \p key. |
| 69 | * The key slot counter has been incremented. |
Ronald Cron | c4d1b51 | 2020-07-31 11:26:37 +0200 | [diff] [blame] | 70 | * \retval #PSA_ERROR_BAD_STATE |
Ryan Everett | dfe8bf8 | 2024-01-12 17:45:05 +0000 | [diff] [blame] | 71 | * The library has not been initialized. |
Ronald Cron | c4d1b51 | 2020-07-31 11:26:37 +0200 | [diff] [blame] | 72 | * \retval #PSA_ERROR_INVALID_HANDLE |
| 73 | * \p key is not a valid key identifier. |
| 74 | * \retval #PSA_ERROR_INSUFFICIENT_MEMORY |
| 75 | * \p key is a persistent key identifier. The implementation does not |
| 76 | * have sufficient resources to load the persistent key. This can be |
| 77 | * due to a lack of empty key slot, or available memory. |
| 78 | * \retval #PSA_ERROR_DOES_NOT_EXIST |
| 79 | * There is no key with key identifier \p key. |
Gilles Peskine | ed73355 | 2023-02-14 19:21:09 +0100 | [diff] [blame] | 80 | * \retval #PSA_ERROR_CORRUPTION_DETECTED \emptydescription |
| 81 | * \retval #PSA_ERROR_STORAGE_FAILURE \emptydescription |
| 82 | * \retval #PSA_ERROR_DATA_CORRUPT \emptydescription |
Gilles Peskine | 0982903 | 2018-12-10 17:00:38 +0100 | [diff] [blame] | 83 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 84 | psa_status_t psa_get_and_lock_key_slot(mbedtls_svc_key_id_t key, |
| 85 | psa_key_slot_t **p_slot); |
Gilles Peskine | 66fb126 | 2018-12-10 16:29:04 +0100 | [diff] [blame] | 86 | |
Gilles Peskine | 0982903 | 2018-12-10 17:00:38 +0100 | [diff] [blame] | 87 | /** Initialize the key slot structures. |
| 88 | * |
Ronald Cron | 9678355 | 2020-10-19 12:06:30 +0200 | [diff] [blame] | 89 | * \retval #PSA_SUCCESS |
Gilles Peskine | 0982903 | 2018-12-10 17:00:38 +0100 | [diff] [blame] | 90 | * Currently this function always succeeds. |
| 91 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 92 | psa_status_t psa_initialize_key_slots(void); |
Gilles Peskine | 66fb126 | 2018-12-10 16:29:04 +0100 | [diff] [blame] | 93 | |
Gilles Peskine | 0982903 | 2018-12-10 17:00:38 +0100 | [diff] [blame] | 94 | /** Delete all data from key slots in memory. |
| 95 | * |
| 96 | * This does not affect persistent storage. */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 97 | void psa_wipe_all_key_slots(void); |
Gilles Peskine | 66fb126 | 2018-12-10 16:29:04 +0100 | [diff] [blame] | 98 | |
Ryan Everett | 2afb516 | 2023-12-22 15:59:45 +0000 | [diff] [blame] | 99 | /** Find a free key slot and reserve it to be filled with a key. |
Gilles Peskine | 41e50d2 | 2019-07-31 15:01:55 +0200 | [diff] [blame] | 100 | * |
Ryan Everett | 2afb516 | 2023-12-22 15:59:45 +0000 | [diff] [blame] | 101 | * This function finds a key slot that is free, |
| 102 | * sets its state to PSA_SLOT_FILLING and then returns the slot. |
| 103 | * |
| 104 | * On success, the key slot's state is PSA_SLOT_FILLING. |
| 105 | * It is the responsibility of the caller to change the slot's state to |
| 106 | * PSA_SLOT_EMPTY/FULL once key creation has finished. |
Gilles Peskine | f46f81c | 2019-05-27 14:53:10 +0200 | [diff] [blame] | 107 | * |
Ronald Cron | 2a99315 | 2020-07-17 14:13:26 +0200 | [diff] [blame] | 108 | * \param[out] volatile_key_id On success, volatile key identifier |
| 109 | * associated to the returned slot. |
| 110 | * \param[out] p_slot On success, a pointer to the slot. |
Gilles Peskine | f46f81c | 2019-05-27 14:53:10 +0200 | [diff] [blame] | 111 | * |
Gilles Peskine | ed73355 | 2023-02-14 19:21:09 +0100 | [diff] [blame] | 112 | * \retval #PSA_SUCCESS \emptydescription |
Ryan Everett | 2afb516 | 2023-12-22 15:59:45 +0000 | [diff] [blame] | 113 | * \retval #PSA_ERROR_INSUFFICIENT_MEMORY |
| 114 | * There were no free key slots. |
Ryan Everett | dfe8bf8 | 2024-01-12 17:45:05 +0000 | [diff] [blame] | 115 | * \retval #PSA_ERROR_BAD_STATE \emptydescription |
| 116 | * \retval #PSA_ERROR_CORRUPTION_DETECTED |
Ryan Everett | 2afb516 | 2023-12-22 15:59:45 +0000 | [diff] [blame] | 117 | * This function attempted to operate on a key slot which was in an |
| 118 | * unexpected state. |
Gilles Peskine | f46f81c | 2019-05-27 14:53:10 +0200 | [diff] [blame] | 119 | */ |
Ryan Everett | 2afb516 | 2023-12-22 15:59:45 +0000 | [diff] [blame] | 120 | psa_status_t psa_reserve_free_key_slot(psa_key_id_t *volatile_key_id, |
| 121 | psa_key_slot_t **p_slot); |
| 122 | |
Ryan Everett | 4a78277 | 2024-01-04 10:53:26 +0000 | [diff] [blame] | 123 | /** Change the state of a key slot. |
| 124 | * |
| 125 | * This function changes the state of the key slot from expected_state to |
| 126 | * new state. If the state of the slot was not expected_state, the state is |
| 127 | * unchanged. |
| 128 | * |
Ryan Everett | fb02d57 | 2024-01-08 11:13:03 +0000 | [diff] [blame] | 129 | * If multi-threading is enabled, the caller must hold the |
| 130 | * global key slot mutex. |
| 131 | * |
Ryan Everett | 4a78277 | 2024-01-04 10:53:26 +0000 | [diff] [blame] | 132 | * \param[in] slot The key slot. |
| 133 | * \param[in] expected_state The current state of the slot. |
| 134 | * \param[in] new_state The new state of the slot. |
| 135 | * |
| 136 | * \retval #PSA_SUCCESS |
| 137 | The key slot's state variable is new_state. |
Ryan Everett | dfe8bf8 | 2024-01-12 17:45:05 +0000 | [diff] [blame] | 138 | * \retval #PSA_ERROR_CORRUPTION_DETECTED |
Ryan Everett | 4a78277 | 2024-01-04 10:53:26 +0000 | [diff] [blame] | 139 | * The slot's state was not expected_state. |
| 140 | */ |
| 141 | static inline psa_status_t psa_key_slot_state_transition( |
| 142 | psa_key_slot_t *slot, psa_key_slot_state_t expected_state, |
| 143 | psa_key_slot_state_t new_state) |
| 144 | { |
| 145 | if (slot->state != expected_state) { |
Ryan Everett | dfe8bf8 | 2024-01-12 17:45:05 +0000 | [diff] [blame] | 146 | return PSA_ERROR_CORRUPTION_DETECTED; |
Ryan Everett | 4a78277 | 2024-01-04 10:53:26 +0000 | [diff] [blame] | 147 | } |
| 148 | slot->state = new_state; |
| 149 | return PSA_SUCCESS; |
| 150 | } |
Gilles Peskine | f46f81c | 2019-05-27 14:53:10 +0200 | [diff] [blame] | 151 | |
Ryan Everett | 39cc9d7 | 2023-12-21 17:57:14 +0000 | [diff] [blame] | 152 | /** Register as a reader of a key slot. |
Ronald Cron | f95a2b1 | 2020-10-22 15:24:49 +0200 | [diff] [blame] | 153 | * |
Ryan Everett | 39cc9d7 | 2023-12-21 17:57:14 +0000 | [diff] [blame] | 154 | * This function increments the key slot registered reader counter by one. |
Ryan Everett | fb02d57 | 2024-01-08 11:13:03 +0000 | [diff] [blame] | 155 | * If multi-threading is enabled, the caller must hold the |
| 156 | * global key slot mutex. |
Ronald Cron | f95a2b1 | 2020-10-22 15:24:49 +0200 | [diff] [blame] | 157 | * \param[in] slot The key slot. |
Ronald Cron | cbf6a1d | 2020-11-13 15:59:59 +0100 | [diff] [blame] | 158 | * |
| 159 | * \retval #PSA_SUCCESS |
Ryan Everett | 39cc9d7 | 2023-12-21 17:57:14 +0000 | [diff] [blame] | 160 | The key slot registered reader counter was incremented. |
Ronald Cron | cbf6a1d | 2020-11-13 15:59:59 +0100 | [diff] [blame] | 161 | * \retval #PSA_ERROR_CORRUPTION_DETECTED |
Ryan Everett | 39cc9d7 | 2023-12-21 17:57:14 +0000 | [diff] [blame] | 162 | * The reader counter already reached its maximum value and was not |
Ryan Everett | dfe8bf8 | 2024-01-12 17:45:05 +0000 | [diff] [blame] | 163 | * increased, or the slot's state was not PSA_SLOT_FULL. |
Ronald Cron | f95a2b1 | 2020-10-22 15:24:49 +0200 | [diff] [blame] | 164 | */ |
Ryan Everett | 39cc9d7 | 2023-12-21 17:57:14 +0000 | [diff] [blame] | 165 | static inline psa_status_t psa_register_read(psa_key_slot_t *slot) |
Ronald Cron | f95a2b1 | 2020-10-22 15:24:49 +0200 | [diff] [blame] | 166 | { |
Ryan Everett | dfe8bf8 | 2024-01-12 17:45:05 +0000 | [diff] [blame] | 167 | if ((slot->state != PSA_SLOT_FULL) || |
| 168 | (slot->registered_readers >= SIZE_MAX)) { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 169 | return PSA_ERROR_CORRUPTION_DETECTED; |
| 170 | } |
Ryan Everett | 39cc9d7 | 2023-12-21 17:57:14 +0000 | [diff] [blame] | 171 | slot->registered_readers++; |
Ronald Cron | cbf6a1d | 2020-11-13 15:59:59 +0100 | [diff] [blame] | 172 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 173 | return PSA_SUCCESS; |
Ronald Cron | f95a2b1 | 2020-10-22 15:24:49 +0200 | [diff] [blame] | 174 | } |
| 175 | |
Ryan Everett | 39cc9d7 | 2023-12-21 17:57:14 +0000 | [diff] [blame] | 176 | /** Unregister from reading a key slot. |
Ronald Cron | f95a2b1 | 2020-10-22 15:24:49 +0200 | [diff] [blame] | 177 | * |
Ryan Everett | 39cc9d7 | 2023-12-21 17:57:14 +0000 | [diff] [blame] | 178 | * This function decrements the key slot registered reader counter by one. |
| 179 | * If the state of the slot is PSA_SLOT_PENDING_DELETION, |
| 180 | * and there is only one registered reader (the caller), |
Ryan Everett | 558da2f | 2024-01-19 12:59:28 +0000 | [diff] [blame^] | 181 | * this function will call psa_wipe_key_slot(). |
Ryan Everett | fb02d57 | 2024-01-08 11:13:03 +0000 | [diff] [blame] | 182 | * If multi-threading is enabled, the caller must hold the |
| 183 | * global key slot mutex. |
Ronald Cron | f95a2b1 | 2020-10-22 15:24:49 +0200 | [diff] [blame] | 184 | * |
| 185 | * \note To ease the handling of errors in retrieving a key slot |
| 186 | * a NULL input pointer is valid, and the function returns |
| 187 | * successfully without doing anything in that case. |
| 188 | * |
| 189 | * \param[in] slot The key slot. |
| 190 | * \retval #PSA_SUCCESS |
Ryan Everett | 39cc9d7 | 2023-12-21 17:57:14 +0000 | [diff] [blame] | 191 | * \p slot is NULL or the key slot reader counter has been |
| 192 | * decremented (and potentially wiped) successfully. |
Ronald Cron | f95a2b1 | 2020-10-22 15:24:49 +0200 | [diff] [blame] | 193 | * \retval #PSA_ERROR_CORRUPTION_DETECTED |
Ryan Everett | 39cc9d7 | 2023-12-21 17:57:14 +0000 | [diff] [blame] | 194 | * The slot's state was neither PSA_SLOT_FULL nor |
Ryan Everett | dfe8bf8 | 2024-01-12 17:45:05 +0000 | [diff] [blame] | 195 | * PSA_SLOT_PENDING_DELETION. |
| 196 | * Or a wipe was attempted and the slot's state was not |
| 197 | * PSA_SLOT_PENDING_DELETION. |
| 198 | * Or registered_readers was equal to 0. |
Ronald Cron | f95a2b1 | 2020-10-22 15:24:49 +0200 | [diff] [blame] | 199 | */ |
Ryan Everett | 39cc9d7 | 2023-12-21 17:57:14 +0000 | [diff] [blame] | 200 | psa_status_t psa_unregister_read(psa_key_slot_t *slot); |
Ronald Cron | f95a2b1 | 2020-10-22 15:24:49 +0200 | [diff] [blame] | 201 | |
Gilles Peskine | 011e428 | 2019-06-26 18:34:38 +0200 | [diff] [blame] | 202 | /** Test whether a lifetime designates a key in an external cryptoprocessor. |
| 203 | * |
| 204 | * \param lifetime The lifetime to test. |
| 205 | * |
| 206 | * \retval 1 |
| 207 | * The lifetime designates an external key. There should be a |
| 208 | * registered driver for this lifetime, otherwise the key cannot |
| 209 | * be created or manipulated. |
| 210 | * \retval 0 |
| 211 | * The lifetime designates a key that is volatile or in internal |
| 212 | * storage. |
| 213 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 214 | static inline int psa_key_lifetime_is_external(psa_key_lifetime_t lifetime) |
Gilles Peskine | 011e428 | 2019-06-26 18:34:38 +0200 | [diff] [blame] | 215 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 216 | return PSA_KEY_LIFETIME_GET_LOCATION(lifetime) |
| 217 | != PSA_KEY_LOCATION_LOCAL_STORAGE; |
Gilles Peskine | 011e428 | 2019-06-26 18:34:38 +0200 | [diff] [blame] | 218 | } |
| 219 | |
Steven Cooreman | 8c1e759 | 2020-06-17 14:52:05 +0200 | [diff] [blame] | 220 | /** Validate a key's location. |
Gilles Peskine | d167b94 | 2019-04-19 18:19:40 +0200 | [diff] [blame] | 221 | * |
Steven Cooreman | 81fe7c3 | 2020-06-08 18:37:19 +0200 | [diff] [blame] | 222 | * This function checks whether the key's attributes point to a location that |
| 223 | * is known to the PSA Core, and returns the driver function table if the key |
| 224 | * is to be found in an external location. |
Gilles Peskine | d167b94 | 2019-04-19 18:19:40 +0200 | [diff] [blame] | 225 | * |
Steven Cooreman | 8c1e759 | 2020-06-17 14:52:05 +0200 | [diff] [blame] | 226 | * \param[in] lifetime The key lifetime attribute. |
Steven Cooreman | 81fe7c3 | 2020-06-08 18:37:19 +0200 | [diff] [blame] | 227 | * \param[out] p_drv On success, when a key is located in external |
| 228 | * storage, returns a pointer to the driver table |
| 229 | * associated with the key's storage location. |
Gilles Peskine | 011e428 | 2019-06-26 18:34:38 +0200 | [diff] [blame] | 230 | * |
Gilles Peskine | ed73355 | 2023-02-14 19:21:09 +0100 | [diff] [blame] | 231 | * \retval #PSA_SUCCESS \emptydescription |
| 232 | * \retval #PSA_ERROR_INVALID_ARGUMENT \emptydescription |
Gilles Peskine | d167b94 | 2019-04-19 18:19:40 +0200 | [diff] [blame] | 233 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 234 | psa_status_t psa_validate_key_location(psa_key_lifetime_t lifetime, |
| 235 | psa_se_drv_table_entry_t **p_drv); |
Steven Cooreman | 81fe7c3 | 2020-06-08 18:37:19 +0200 | [diff] [blame] | 236 | |
Ronald Cron | d2ed481 | 2020-07-17 16:11:30 +0200 | [diff] [blame] | 237 | /** Validate the persistence of a key. |
Steven Cooreman | 81fe7c3 | 2020-06-08 18:37:19 +0200 | [diff] [blame] | 238 | * |
Ronald Cron | 27238fc | 2020-07-23 12:30:41 +0200 | [diff] [blame] | 239 | * \param[in] lifetime The key lifetime attribute. |
Steven Cooreman | 81fe7c3 | 2020-06-08 18:37:19 +0200 | [diff] [blame] | 240 | * |
Gilles Peskine | ed73355 | 2023-02-14 19:21:09 +0100 | [diff] [blame] | 241 | * \retval #PSA_SUCCESS \emptydescription |
Ronald Cron | de825e6 | 2021-04-01 13:59:10 +0200 | [diff] [blame] | 242 | * \retval #PSA_ERROR_NOT_SUPPORTED The key is persistent but persistent keys |
| 243 | * are not supported. |
Steven Cooreman | 81fe7c3 | 2020-06-08 18:37:19 +0200 | [diff] [blame] | 244 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 245 | psa_status_t psa_validate_key_persistence(psa_key_lifetime_t lifetime); |
Ronald Cron | d2ed481 | 2020-07-17 16:11:30 +0200 | [diff] [blame] | 246 | |
| 247 | /** Validate a key identifier. |
| 248 | * |
Ronald Cron | fc9c556 | 2020-10-15 19:24:49 +0200 | [diff] [blame] | 249 | * \param[in] key The key identifier. |
| 250 | * \param[in] vendor_ok Non-zero to indicate that key identifiers in the |
| 251 | * vendor range are allowed, volatile key identifiers |
| 252 | * excepted \c 0 otherwise. |
Ronald Cron | d2ed481 | 2020-07-17 16:11:30 +0200 | [diff] [blame] | 253 | * |
Ronald Cron | 77e412c | 2021-03-31 17:36:31 +0200 | [diff] [blame] | 254 | * \retval <> 0 if the key identifier is valid, 0 otherwise. |
Ronald Cron | d2ed481 | 2020-07-17 16:11:30 +0200 | [diff] [blame] | 255 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 256 | int psa_is_valid_key_id(mbedtls_svc_key_id_t key, int vendor_ok); |
Gilles Peskine | d167b94 | 2019-04-19 18:19:40 +0200 | [diff] [blame] | 257 | |
Gilles Peskine | 961849f | 2018-11-30 18:54:54 +0100 | [diff] [blame] | 258 | #endif /* PSA_CRYPTO_SLOT_MANAGEMENT_H */ |