Branch data Line data Source code
1 : : /*
2 : : * PSA crypto layer on top of Mbed TLS crypto
3 : : */
4 : : /*
5 : : * Copyright The Mbed TLS Contributors
6 : : * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
7 : : */
8 : :
9 : : #include "common.h"
10 : :
11 : : #if defined(MBEDTLS_PSA_CRYPTO_C)
12 : :
13 : : #include "psa/crypto.h"
14 : :
15 : : #include "psa_crypto_core.h"
16 : : #include "psa_crypto_driver_wrappers_no_static.h"
17 : : #include "psa_crypto_slot_management.h"
18 : : #include "psa_crypto_storage.h"
19 : : #if defined(MBEDTLS_PSA_CRYPTO_SE_C)
20 : : #include "psa_crypto_se.h"
21 : : #endif
22 : :
23 : : #include <stdlib.h>
24 : : #include <string.h>
25 : : #include "mbedtls/platform.h"
26 : : #if defined(MBEDTLS_THREADING_C)
27 : : #include "mbedtls/threading.h"
28 : : #endif
29 : :
30 : :
31 : :
32 : : /* Make sure we have distinct ranges of key identifiers for distinct
33 : : * purposes. */
34 : : MBEDTLS_STATIC_ASSERT(PSA_KEY_ID_USER_MIN < PSA_KEY_ID_USER_MAX,
35 : : "Empty user key ID range");
36 : : MBEDTLS_STATIC_ASSERT(PSA_KEY_ID_VENDOR_MIN < PSA_KEY_ID_VENDOR_MAX,
37 : : "Empty vendor key ID range");
38 : : MBEDTLS_STATIC_ASSERT(MBEDTLS_PSA_KEY_ID_BUILTIN_MIN <= MBEDTLS_PSA_KEY_ID_BUILTIN_MAX,
39 : : "Empty builtin key ID range");
40 : : MBEDTLS_STATIC_ASSERT(PSA_KEY_ID_VOLATILE_MIN <= PSA_KEY_ID_VOLATILE_MAX,
41 : : "Empty volatile key ID range");
42 : :
43 : : MBEDTLS_STATIC_ASSERT(PSA_KEY_ID_USER_MAX < PSA_KEY_ID_VENDOR_MIN ||
44 : : PSA_KEY_ID_VENDOR_MAX < PSA_KEY_ID_USER_MIN,
45 : : "Overlap between user key IDs and vendor key IDs");
46 : :
47 : : MBEDTLS_STATIC_ASSERT(PSA_KEY_ID_VENDOR_MIN <= MBEDTLS_PSA_KEY_ID_BUILTIN_MIN &&
48 : : MBEDTLS_PSA_KEY_ID_BUILTIN_MAX <= PSA_KEY_ID_VENDOR_MAX,
49 : : "Builtin key identifiers are not in the vendor range");
50 : :
51 : : MBEDTLS_STATIC_ASSERT(PSA_KEY_ID_VENDOR_MIN <= PSA_KEY_ID_VOLATILE_MIN &&
52 : : PSA_KEY_ID_VOLATILE_MAX <= PSA_KEY_ID_VENDOR_MAX,
53 : : "Volatile key identifiers are not in the vendor range");
54 : :
55 : : MBEDTLS_STATIC_ASSERT(PSA_KEY_ID_VOLATILE_MAX < MBEDTLS_PSA_KEY_ID_BUILTIN_MIN ||
56 : : MBEDTLS_PSA_KEY_ID_BUILTIN_MAX < PSA_KEY_ID_VOLATILE_MIN,
57 : : "Overlap between builtin key IDs and volatile key IDs");
58 : :
59 : :
60 : :
61 : : #if defined(MBEDTLS_PSA_KEY_STORE_DYNAMIC)
62 : :
63 : : /* Dynamic key store.
64 : : *
65 : : * The key store consists of multiple slices.
66 : : *
67 : : * The volatile keys are stored in variable-sized tables called slices.
68 : : * Slices are allocated on demand and deallocated when possible.
69 : : * The size of slices increases exponentially, so the average overhead
70 : : * (number of slots that are allocated but not used) is roughly
71 : : * proportional to the number of keys (with a factor that grows
72 : : * when the key store is fragmented).
73 : : *
74 : : * One slice is dedicated to the cache of persistent and built-in keys.
75 : : * For simplicity, they are separated from volatile keys. This cache
76 : : * slice has a fixed size and has the slice index KEY_SLOT_CACHE_SLICE_INDEX,
77 : : * located after the slices for volatile keys.
78 : : */
79 : :
80 : : /* Size of the last slice containing the cache of persistent and built-in keys. */
81 : : #define PERSISTENT_KEY_CACHE_COUNT MBEDTLS_PSA_KEY_SLOT_COUNT
82 : :
83 : : /* Volatile keys are stored in slices 0 through
84 : : * (KEY_SLOT_VOLATILE_SLICE_COUNT - 1) inclusive.
85 : : * Each slice is twice the size of the previous slice.
86 : : * Volatile key identifiers encode the slice number as follows:
87 : : * bits 30..31: 0b10 (mandated by the PSA Crypto specification).
88 : : * bits 25..29: slice index (0...KEY_SLOT_VOLATILE_SLICE_COUNT-1)
89 : : * bits 0..24: slot index in slice
90 : : */
91 : : #define KEY_ID_SLOT_INDEX_WIDTH 25u
92 : : #define KEY_ID_SLICE_INDEX_WIDTH 5u
93 : :
94 : : #define KEY_SLOT_VOLATILE_SLICE_BASE_LENGTH 16u
95 : : #define KEY_SLOT_VOLATILE_SLICE_COUNT 22u
96 : : #define KEY_SLICE_COUNT (KEY_SLOT_VOLATILE_SLICE_COUNT + 1u)
97 : : #define KEY_SLOT_CACHE_SLICE_INDEX KEY_SLOT_VOLATILE_SLICE_COUNT
98 : :
99 : :
100 : : /* Check that the length of the largest slice (calculated as
101 : : * KEY_SLICE_LENGTH_MAX below) does not overflow size_t. We use
102 : : * an indirect method in case the calculation of KEY_SLICE_LENGTH_MAX
103 : : * itself overflows uintmax_t: if (BASE_LENGTH << c)
104 : : * overflows size_t then BASE_LENGTH > SIZE_MAX >> c.
105 : : */
106 : : #if (KEY_SLOT_VOLATILE_SLICE_BASE_LENGTH > \
107 : : SIZE_MAX >> (KEY_SLOT_VOLATILE_SLICE_COUNT - 1))
108 : : #error "Maximum slice length overflows size_t"
109 : : #endif
110 : :
111 : : #if KEY_ID_SLICE_INDEX_WIDTH + KEY_ID_SLOT_INDEX_WIDTH > 30
112 : : #error "Not enough room in volatile key IDs for slice index and slot index"
113 : : #endif
114 : : #if KEY_SLOT_VOLATILE_SLICE_COUNT > (1 << KEY_ID_SLICE_INDEX_WIDTH)
115 : : #error "Too many slices to fit the slice index in a volatile key ID"
116 : : #endif
117 : : #define KEY_SLICE_LENGTH_MAX \
118 : : (KEY_SLOT_VOLATILE_SLICE_BASE_LENGTH << (KEY_SLOT_VOLATILE_SLICE_COUNT - 1))
119 : : #if KEY_SLICE_LENGTH_MAX > 1 << KEY_ID_SLOT_INDEX_WIDTH
120 : : #error "Not enough room in volatile key IDs for a slot index in the largest slice"
121 : : #endif
122 : : #if KEY_ID_SLICE_INDEX_WIDTH > 8
123 : : #error "Slice index does not fit in uint8_t for psa_key_slot_t::slice_index"
124 : : #endif
125 : :
126 : :
127 : : /* Calculate the volatile key id to use for a given slot.
128 : : * This function assumes valid parameter values. */
129 : : static psa_key_id_t volatile_key_id_of_index(size_t slice_idx,
130 : : size_t slot_idx)
131 : : {
132 : : /* We assert above that the slice and slot indexes fit in separate
133 : : * bit-fields inside psa_key_id_t, which is a 32-bit type per the
134 : : * PSA Cryptography specification. */
135 : : return (psa_key_id_t) (0x40000000u |
136 : : (slice_idx << KEY_ID_SLOT_INDEX_WIDTH) |
137 : : slot_idx);
138 : : }
139 : :
140 : : /* Calculate the slice containing the given volatile key.
141 : : * This function assumes valid parameter values. */
142 : : static size_t slice_index_of_volatile_key_id(psa_key_id_t key_id)
143 : : {
144 : : size_t mask = (1LU << KEY_ID_SLICE_INDEX_WIDTH) - 1;
145 : : return (key_id >> KEY_ID_SLOT_INDEX_WIDTH) & mask;
146 : : }
147 : :
148 : : /* Calculate the index of the slot containing the given volatile key.
149 : : * This function assumes valid parameter values. */
150 : : static size_t slot_index_of_volatile_key_id(psa_key_id_t key_id)
151 : : {
152 : : return key_id & ((1LU << KEY_ID_SLOT_INDEX_WIDTH) - 1);
153 : : }
154 : :
155 : : /* In global_data.first_free_slot_index, use this special value to
156 : : * indicate that the slice is full. */
157 : : #define FREE_SLOT_INDEX_NONE ((size_t) -1)
158 : :
159 : : #if defined(MBEDTLS_TEST_HOOKS)
160 : : size_t psa_key_slot_volatile_slice_count(void)
161 : : {
162 : : return KEY_SLOT_VOLATILE_SLICE_COUNT;
163 : : }
164 : : #endif
165 : :
166 : : #else /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
167 : :
168 : : /* Static key store.
169 : : *
170 : : * All the keys (volatile or persistent) are in a single slice.
171 : : * We only use slices as a concept to allow some differences between
172 : : * static and dynamic key store management to be buried in auxiliary
173 : : * functions.
174 : : */
175 : :
176 : : #define PERSISTENT_KEY_CACHE_COUNT MBEDTLS_PSA_KEY_SLOT_COUNT
177 : : #define KEY_SLICE_COUNT 1u
178 : : #define KEY_SLOT_CACHE_SLICE_INDEX 0
179 : :
180 : : #endif /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
181 : :
182 : :
183 : : typedef struct {
184 : : #if defined(MBEDTLS_PSA_KEY_STORE_DYNAMIC)
185 : : psa_key_slot_t *key_slices[KEY_SLICE_COUNT];
186 : : size_t first_free_slot_index[KEY_SLOT_VOLATILE_SLICE_COUNT];
187 : : #else /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
188 : : psa_key_slot_t key_slots[MBEDTLS_PSA_KEY_SLOT_COUNT];
189 : : #endif /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
190 : : uint8_t key_slots_initialized;
191 : : } psa_global_data_t;
192 : :
193 : : static psa_global_data_t global_data;
194 : :
195 : 546 : static uint8_t psa_get_key_slots_initialized(void)
196 : : {
197 : 546 : uint8_t initialized;
198 : :
199 : : #if defined(MBEDTLS_THREADING_C)
200 : : mbedtls_mutex_lock(&mbedtls_threading_psa_globaldata_mutex);
201 : : #endif /* defined(MBEDTLS_THREADING_C) */
202 : :
203 : 546 : initialized = global_data.key_slots_initialized;
204 : :
205 : : #if defined(MBEDTLS_THREADING_C)
206 : : mbedtls_mutex_unlock(&mbedtls_threading_psa_globaldata_mutex);
207 : : #endif /* defined(MBEDTLS_THREADING_C) */
208 : :
209 : 546 : return initialized;
210 : : }
211 : :
212 : :
213 : :
214 : : /** The length of the given slice in the key slot table.
215 : : *
216 : : * \param slice_idx The slice number. It must satisfy
217 : : * 0 <= slice_idx < KEY_SLICE_COUNT.
218 : : *
219 : : * \return The number of elements in the given slice.
220 : : */
221 : : static inline size_t key_slice_length(size_t slice_idx);
222 : :
223 : : /** Get a pointer to the slot where the given volatile key is located.
224 : : *
225 : : * \param key_id The key identifier. It must be a valid volatile key
226 : : * identifier.
227 : : * \return A pointer to the only slot that the given key
228 : : * can be in. Note that the slot may be empty or
229 : : * contain a different key.
230 : : */
231 : : static inline psa_key_slot_t *get_volatile_key_slot(psa_key_id_t key_id);
232 : :
233 : : /** Get a pointer to an entry in the persistent key cache.
234 : : *
235 : : * \param slot_idx The index in the table. It must satisfy
236 : : * 0 <= slot_idx < PERSISTENT_KEY_CACHE_COUNT.
237 : : * \return A pointer to the slot containing the given
238 : : * persistent key cache entry.
239 : : */
240 : : static inline psa_key_slot_t *get_persistent_key_slot(size_t slot_idx);
241 : :
242 : : /** Get a pointer to a slot given by slice and index.
243 : : *
244 : : * \param slice_idx The slice number. It must satisfy
245 : : * 0 <= slice_idx < KEY_SLICE_COUNT.
246 : : * \param slot_idx An index in the given slice. It must satisfy
247 : : * 0 <= slot_idx < key_slice_length(slice_idx).
248 : : *
249 : : * \return A pointer to the given slot.
250 : : */
251 : : static inline psa_key_slot_t *get_key_slot(size_t slice_idx, size_t slot_idx);
252 : :
253 : : #if defined(MBEDTLS_PSA_KEY_STORE_DYNAMIC)
254 : :
255 : : #if defined(MBEDTLS_TEST_HOOKS)
256 : : size_t (*mbedtls_test_hook_psa_volatile_key_slice_length)(size_t slice_idx) = NULL;
257 : : #endif
258 : :
259 : : static inline size_t key_slice_length(size_t slice_idx)
260 : : {
261 : : if (slice_idx == KEY_SLOT_CACHE_SLICE_INDEX) {
262 : : return PERSISTENT_KEY_CACHE_COUNT;
263 : : } else {
264 : : #if defined(MBEDTLS_TEST_HOOKS)
265 : : if (mbedtls_test_hook_psa_volatile_key_slice_length != NULL) {
266 : : return mbedtls_test_hook_psa_volatile_key_slice_length(slice_idx);
267 : : }
268 : : #endif
269 : : return KEY_SLOT_VOLATILE_SLICE_BASE_LENGTH << slice_idx;
270 : : }
271 : : }
272 : :
273 : : static inline psa_key_slot_t *get_volatile_key_slot(psa_key_id_t key_id)
274 : : {
275 : : size_t slice_idx = slice_index_of_volatile_key_id(key_id);
276 : : if (slice_idx >= KEY_SLOT_VOLATILE_SLICE_COUNT) {
277 : : return NULL;
278 : : }
279 : : size_t slot_idx = slot_index_of_volatile_key_id(key_id);
280 : : if (slot_idx >= key_slice_length(slice_idx)) {
281 : : return NULL;
282 : : }
283 : : psa_key_slot_t *slice = global_data.key_slices[slice_idx];
284 : : if (slice == NULL) {
285 : : return NULL;
286 : : }
287 : : return &slice[slot_idx];
288 : : }
289 : :
290 : : static inline psa_key_slot_t *get_persistent_key_slot(size_t slot_idx)
291 : : {
292 : : return &global_data.key_slices[KEY_SLOT_CACHE_SLICE_INDEX][slot_idx];
293 : : }
294 : :
295 : : static inline psa_key_slot_t *get_key_slot(size_t slice_idx, size_t slot_idx)
296 : : {
297 : : return &global_data.key_slices[slice_idx][slot_idx];
298 : : }
299 : :
300 : : #else /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
301 : :
302 : 0 : static inline size_t key_slice_length(size_t slice_idx)
303 : : {
304 : 0 : (void) slice_idx;
305 : 0 : return ARRAY_LENGTH(global_data.key_slots);
306 : : }
307 : :
308 : 374 : static inline psa_key_slot_t *get_volatile_key_slot(psa_key_id_t key_id)
309 : : {
310 : 374 : MBEDTLS_STATIC_ASSERT(ARRAY_LENGTH(global_data.key_slots) <=
311 : : PSA_KEY_ID_VOLATILE_MAX - PSA_KEY_ID_VOLATILE_MIN + 1,
312 : : "The key slot array is larger than the volatile key ID range");
313 : 374 : return &global_data.key_slots[key_id - PSA_KEY_ID_VOLATILE_MIN];
314 : : }
315 : :
316 : 0 : static inline psa_key_slot_t *get_persistent_key_slot(size_t slot_idx)
317 : : {
318 : 0 : return &global_data.key_slots[slot_idx];
319 : : }
320 : :
321 : 172 : static inline psa_key_slot_t *get_key_slot(size_t slice_idx, size_t slot_idx)
322 : : {
323 : 172 : (void) slice_idx;
324 : 172 : return &global_data.key_slots[slot_idx];
325 : : }
326 : :
327 : : #endif /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
328 : :
329 : :
330 : :
331 : 0 : int psa_is_valid_key_id(mbedtls_svc_key_id_t key, int vendor_ok)
332 : : {
333 : 0 : psa_key_id_t key_id = MBEDTLS_SVC_KEY_ID_GET_KEY_ID(key);
334 : :
335 [ # # ]: 0 : if ((PSA_KEY_ID_USER_MIN <= key_id) &&
336 : : (key_id <= PSA_KEY_ID_USER_MAX)) {
337 : : return 1;
338 : : }
339 : :
340 : 0 : if (vendor_ok &&
341 [ # # ]: 0 : (PSA_KEY_ID_VENDOR_MIN <= key_id) &&
342 [ # # ]: 0 : (key_id <= PSA_KEY_ID_VENDOR_MAX)) {
343 : 0 : return 1;
344 : : }
345 : :
346 : : return 0;
347 : : }
348 : :
349 : : /** Get the description in memory of a key given its identifier and lock it.
350 : : *
351 : : * The descriptions of volatile keys and loaded persistent keys are
352 : : * stored in key slots. This function returns a pointer to the key slot
353 : : * containing the description of a key given its identifier.
354 : : *
355 : : * The function searches the key slots containing the description of the key
356 : : * with \p key identifier. The function does only read accesses to the key
357 : : * slots. The function does not load any persistent key thus does not access
358 : : * any storage.
359 : : *
360 : : * For volatile key identifiers, only one key slot is queried as a volatile
361 : : * key with identifier key_id can only be stored in slot of index
362 : : * ( key_id - #PSA_KEY_ID_VOLATILE_MIN ).
363 : : *
364 : : * On success, the function locks the key slot. It is the responsibility of
365 : : * the caller to unlock the key slot when it does not access it anymore.
366 : : *
367 : : * If multi-threading is enabled, the caller must hold the
368 : : * global key slot mutex.
369 : : *
370 : : * \param key Key identifier to query.
371 : : * \param[out] p_slot On success, `*p_slot` contains a pointer to the
372 : : * key slot containing the description of the key
373 : : * identified by \p key.
374 : : *
375 : : * \retval #PSA_SUCCESS
376 : : * The pointer to the key slot containing the description of the key
377 : : * identified by \p key was returned.
378 : : * \retval #PSA_ERROR_INVALID_HANDLE
379 : : * \p key is not a valid key identifier.
380 : : * \retval #PSA_ERROR_DOES_NOT_EXIST
381 : : * There is no key with key identifier \p key in the key slots.
382 : : */
383 : 374 : static psa_status_t psa_get_and_lock_key_slot_in_memory(
384 : : mbedtls_svc_key_id_t key, psa_key_slot_t **p_slot)
385 : : {
386 : 374 : psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
387 : 374 : psa_key_id_t key_id = MBEDTLS_SVC_KEY_ID_GET_KEY_ID(key);
388 : 374 : size_t slot_idx;
389 : 374 : psa_key_slot_t *slot = NULL;
390 : :
391 [ + - ]: 374 : if (psa_key_id_is_volatile(key_id)) {
392 : 374 : slot = get_volatile_key_slot(key_id);
393 : :
394 : : /* Check if both the PSA key identifier key_id and the owner
395 : : * identifier of key match those of the key slot. */
396 [ + - ]: 374 : if (slot != NULL &&
397 [ + - ]: 374 : slot->state == PSA_SLOT_FULL &&
398 [ - + ]: 374 : mbedtls_svc_key_id_equal(key, slot->attr.id)) {
399 : : status = PSA_SUCCESS;
400 : : } else {
401 : : status = PSA_ERROR_DOES_NOT_EXIST;
402 : : }
403 : : } else {
404 [ # # ]: 0 : if (!psa_is_valid_key_id(key, 1)) {
405 : : return PSA_ERROR_INVALID_HANDLE;
406 : : }
407 : :
408 [ # # ]: 0 : for (slot_idx = 0; slot_idx < PERSISTENT_KEY_CACHE_COUNT; slot_idx++) {
409 : 0 : slot = get_persistent_key_slot(slot_idx);
410 : : /* Only consider slots which are in a full state. */
411 [ # # ]: 0 : if ((slot->state == PSA_SLOT_FULL) &&
412 [ # # ]: 0 : (mbedtls_svc_key_id_equal(key, slot->attr.id))) {
413 : : break;
414 : : }
415 : : }
416 : 0 : status = (slot_idx < MBEDTLS_PSA_KEY_SLOT_COUNT) ?
417 [ # # ]: 0 : PSA_SUCCESS : PSA_ERROR_DOES_NOT_EXIST;
418 : : }
419 : :
420 : : if (status == PSA_SUCCESS) {
421 : 374 : status = psa_register_read(slot);
422 [ + - ]: 374 : if (status == PSA_SUCCESS) {
423 : 374 : *p_slot = slot;
424 : : }
425 : : }
426 : :
427 : : return status;
428 : : }
429 : :
430 : 1 : psa_status_t psa_initialize_key_slots(void)
431 : : {
432 : : #if defined(MBEDTLS_PSA_KEY_STORE_DYNAMIC)
433 : : global_data.key_slices[KEY_SLOT_CACHE_SLICE_INDEX] =
434 : : mbedtls_calloc(PERSISTENT_KEY_CACHE_COUNT,
435 : : sizeof(*global_data.key_slices[KEY_SLOT_CACHE_SLICE_INDEX]));
436 : : if (global_data.key_slices[KEY_SLOT_CACHE_SLICE_INDEX] == NULL) {
437 : : return PSA_ERROR_INSUFFICIENT_MEMORY;
438 : : }
439 : : #else /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
440 : : /* Nothing to do: program startup and psa_wipe_all_key_slots() both
441 : : * guarantee that the key slots are initialized to all-zero, which
442 : : * means that all the key slots are in a valid, empty state. The global
443 : : * data mutex is already held when calling this function, so no need to
444 : : * lock it here, to set the flag. */
445 : : #endif /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
446 : :
447 : 1 : global_data.key_slots_initialized = 1;
448 : 1 : return PSA_SUCCESS;
449 : : }
450 : :
451 : 0 : void psa_wipe_all_key_slots(void)
452 : : {
453 [ # # ]: 0 : for (size_t slice_idx = 0; slice_idx < KEY_SLICE_COUNT; slice_idx++) {
454 : : #if defined(MBEDTLS_PSA_KEY_STORE_DYNAMIC)
455 : : if (global_data.key_slices[slice_idx] == NULL) {
456 : : continue;
457 : : }
458 : : #endif /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
459 [ # # ]: 0 : for (size_t slot_idx = 0; slot_idx < key_slice_length(slice_idx); slot_idx++) {
460 : 0 : psa_key_slot_t *slot = get_key_slot(slice_idx, slot_idx);
461 : : #if defined(MBEDTLS_PSA_KEY_STORE_DYNAMIC)
462 : : /* When MBEDTLS_PSA_KEY_STORE_DYNAMIC is disabled, calling
463 : : * psa_wipe_key_slot() on an unused slot is useless, but it
464 : : * happens to work (because we flip the state to PENDING_DELETION).
465 : : *
466 : : * When MBEDTLS_PSA_KEY_STORE_DYNAMIC is enabled,
467 : : * psa_wipe_key_slot() needs to have a valid slice_index
468 : : * field, but that value might not be correct in a
469 : : * free slot, so we must not call it.
470 : : *
471 : : * Bypass the call to psa_wipe_key_slot() if the slot is empty,
472 : : * but only if MBEDTLS_PSA_KEY_STORE_DYNAMIC is enabled, to save
473 : : * a few bytes of code size otherwise.
474 : : */
475 : : if (slot->state == PSA_SLOT_EMPTY) {
476 : : continue;
477 : : }
478 : : #endif
479 : 0 : slot->var.occupied.registered_readers = 1;
480 : 0 : slot->state = PSA_SLOT_PENDING_DELETION;
481 : 0 : (void) psa_wipe_key_slot(slot);
482 : : }
483 : : #if defined(MBEDTLS_PSA_KEY_STORE_DYNAMIC)
484 : : mbedtls_free(global_data.key_slices[slice_idx]);
485 : : global_data.key_slices[slice_idx] = NULL;
486 : : #endif /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
487 : : }
488 : :
489 : : #if defined(MBEDTLS_PSA_KEY_STORE_DYNAMIC)
490 : : for (size_t slice_idx = 0; slice_idx < KEY_SLOT_VOLATILE_SLICE_COUNT; slice_idx++) {
491 : : global_data.first_free_slot_index[slice_idx] = 0;
492 : : }
493 : : #endif /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
494 : :
495 : : /* The global data mutex is already held when calling this function. */
496 : 0 : global_data.key_slots_initialized = 0;
497 : 0 : }
498 : :
499 : : #if defined(MBEDTLS_PSA_KEY_STORE_DYNAMIC)
500 : :
501 : : static psa_status_t psa_allocate_volatile_key_slot(psa_key_id_t *key_id,
502 : : psa_key_slot_t **p_slot)
503 : : {
504 : : size_t slice_idx;
505 : : for (slice_idx = 0; slice_idx < KEY_SLOT_VOLATILE_SLICE_COUNT; slice_idx++) {
506 : : if (global_data.first_free_slot_index[slice_idx] != FREE_SLOT_INDEX_NONE) {
507 : : break;
508 : : }
509 : : }
510 : : if (slice_idx == KEY_SLOT_VOLATILE_SLICE_COUNT) {
511 : : return PSA_ERROR_INSUFFICIENT_MEMORY;
512 : : }
513 : :
514 : : if (global_data.key_slices[slice_idx] == NULL) {
515 : : global_data.key_slices[slice_idx] =
516 : : mbedtls_calloc(key_slice_length(slice_idx),
517 : : sizeof(psa_key_slot_t));
518 : : if (global_data.key_slices[slice_idx] == NULL) {
519 : : return PSA_ERROR_INSUFFICIENT_MEMORY;
520 : : }
521 : : }
522 : : psa_key_slot_t *slice = global_data.key_slices[slice_idx];
523 : :
524 : : size_t slot_idx = global_data.first_free_slot_index[slice_idx];
525 : : *key_id = volatile_key_id_of_index(slice_idx, slot_idx);
526 : :
527 : : psa_key_slot_t *slot = &slice[slot_idx];
528 : : size_t next_free = slot_idx + 1 + slot->var.free.next_free_relative_to_next;
529 : : if (next_free >= key_slice_length(slice_idx)) {
530 : : next_free = FREE_SLOT_INDEX_NONE;
531 : : }
532 : : global_data.first_free_slot_index[slice_idx] = next_free;
533 : : /* The .next_free field is not meaningful when the slot is not free,
534 : : * so give it the same content as freshly initialized memory. */
535 : : slot->var.free.next_free_relative_to_next = 0;
536 : :
537 : : psa_status_t status = psa_key_slot_state_transition(slot,
538 : : PSA_SLOT_EMPTY,
539 : : PSA_SLOT_FILLING);
540 : : if (status != PSA_SUCCESS) {
541 : : /* The only reason for failure is if the slot state was not empty.
542 : : * This indicates that something has gone horribly wrong.
543 : : * In this case, we leave the slot out of the free list, and stop
544 : : * modifying it. This minimizes any further corruption. The slot
545 : : * is a memory leak, but that's a lesser evil. */
546 : : return status;
547 : : }
548 : :
549 : : *p_slot = slot;
550 : : /* We assert at compile time that the slice index fits in uint8_t. */
551 : : slot->slice_index = (uint8_t) slice_idx;
552 : : return PSA_SUCCESS;
553 : : }
554 : :
555 : : psa_status_t psa_free_key_slot(size_t slice_idx,
556 : : psa_key_slot_t *slot)
557 : : {
558 : :
559 : : if (slice_idx == KEY_SLOT_CACHE_SLICE_INDEX) {
560 : : /* This is a cache entry. We don't maintain a free list, so
561 : : * there's nothing to do. */
562 : : return PSA_SUCCESS;
563 : : }
564 : : if (slice_idx >= KEY_SLOT_VOLATILE_SLICE_COUNT) {
565 : : return PSA_ERROR_CORRUPTION_DETECTED;
566 : : }
567 : :
568 : : psa_key_slot_t *slice = global_data.key_slices[slice_idx];
569 : : psa_key_slot_t *slice_end = slice + key_slice_length(slice_idx);
570 : : if (slot < slice || slot >= slice_end) {
571 : : /* The slot isn't actually in the slice! We can't detect that
572 : : * condition for sure, because the pointer comparison itself is
573 : : * undefined behavior in that case. That same condition makes the
574 : : * subtraction to calculate the slot index also UB.
575 : : * Give up now to avoid causing further corruption.
576 : : */
577 : : return PSA_ERROR_CORRUPTION_DETECTED;
578 : : }
579 : : size_t slot_idx = slot - slice;
580 : :
581 : : size_t next_free = global_data.first_free_slot_index[slice_idx];
582 : : if (next_free >= key_slice_length(slice_idx)) {
583 : : /* The slot was full. The newly freed slot thus becomes the
584 : : * end of the free list. */
585 : : next_free = key_slice_length(slice_idx);
586 : : }
587 : : global_data.first_free_slot_index[slice_idx] = slot_idx;
588 : : slot->var.free.next_free_relative_to_next =
589 : : (int32_t) next_free - (int32_t) slot_idx - 1;
590 : :
591 : : return PSA_SUCCESS;
592 : : }
593 : : #endif /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
594 : :
595 : 172 : psa_status_t psa_reserve_free_key_slot(psa_key_id_t *volatile_key_id,
596 : : psa_key_slot_t **p_slot)
597 : : {
598 : 172 : psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
599 : 172 : size_t slot_idx;
600 : 172 : psa_key_slot_t *selected_slot, *unused_persistent_key_slot;
601 : :
602 [ - + ]: 172 : if (!psa_get_key_slots_initialized()) {
603 : 0 : status = PSA_ERROR_BAD_STATE;
604 : 0 : goto error;
605 : : }
606 : :
607 : : #if defined(MBEDTLS_PSA_KEY_STORE_DYNAMIC)
608 : : if (volatile_key_id != NULL) {
609 : : return psa_allocate_volatile_key_slot(volatile_key_id, p_slot);
610 : : }
611 : : #endif /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
612 : :
613 : : /* With a dynamic key store, allocate an entry in the cache slice,
614 : : * applicable only to non-volatile keys that get cached in RAM.
615 : : * With a static key store, allocate an entry in the sole slice,
616 : : * applicable to all keys. */
617 : 172 : selected_slot = unused_persistent_key_slot = NULL;
618 [ + - ]: 172 : for (slot_idx = 0; slot_idx < PERSISTENT_KEY_CACHE_COUNT; slot_idx++) {
619 : 172 : psa_key_slot_t *slot = get_key_slot(KEY_SLOT_CACHE_SLICE_INDEX, slot_idx);
620 [ - + ]: 172 : if (slot->state == PSA_SLOT_EMPTY) {
621 : : selected_slot = slot;
622 : : break;
623 : : }
624 : :
625 [ # # # # ]: 0 : if ((unused_persistent_key_slot == NULL) &&
626 : 0 : (slot->state == PSA_SLOT_FULL) &&
627 [ # # ]: 0 : (!psa_key_slot_has_readers(slot)) &&
628 [ # # ]: 0 : (!PSA_KEY_LIFETIME_IS_VOLATILE(slot->attr.lifetime))) {
629 : 0 : unused_persistent_key_slot = slot;
630 : : }
631 : : }
632 : :
633 : : /*
634 : : * If there is no unused key slot and there is at least one unlocked key
635 : : * slot containing the description of a persistent key, recycle the first
636 : : * such key slot we encountered. If we later need to operate on the
637 : : * persistent key we are evicting now, we will reload its description from
638 : : * storage.
639 : : */
640 : 172 : if ((selected_slot == NULL) &&
641 [ - + ]: 172 : (unused_persistent_key_slot != NULL)) {
642 : 0 : selected_slot = unused_persistent_key_slot;
643 : 0 : psa_register_read(selected_slot);
644 : 0 : status = psa_wipe_key_slot(selected_slot);
645 [ # # ]: 0 : if (status != PSA_SUCCESS) {
646 : 0 : goto error;
647 : : }
648 : : }
649 : :
650 [ + - ]: 172 : if (selected_slot != NULL) {
651 : 172 : status = psa_key_slot_state_transition(selected_slot, PSA_SLOT_EMPTY,
652 : : PSA_SLOT_FILLING);
653 [ - + ]: 172 : if (status != PSA_SUCCESS) {
654 : 0 : goto error;
655 : : }
656 : :
657 : : #if defined(MBEDTLS_PSA_KEY_STORE_DYNAMIC)
658 : : selected_slot->slice_index = KEY_SLOT_CACHE_SLICE_INDEX;
659 : : #endif /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
660 : :
661 : : #if !defined(MBEDTLS_PSA_KEY_STORE_DYNAMIC)
662 [ + - ]: 172 : if (volatile_key_id != NULL) {
663 : : /* Refresh slot_idx, for when the slot is not the original
664 : : * selected_slot but rather unused_persistent_key_slot. */
665 : 172 : slot_idx = selected_slot - global_data.key_slots;
666 : 172 : *volatile_key_id = PSA_KEY_ID_VOLATILE_MIN + (psa_key_id_t) slot_idx;
667 : : }
668 : : #endif
669 : 172 : *p_slot = selected_slot;
670 : :
671 : 172 : return PSA_SUCCESS;
672 : : }
673 : : status = PSA_ERROR_INSUFFICIENT_MEMORY;
674 : :
675 : 0 : error:
676 : 0 : *p_slot = NULL;
677 : :
678 : 0 : return status;
679 : : }
680 : :
681 : : #if defined(MBEDTLS_PSA_CRYPTO_STORAGE_C)
682 : : static psa_status_t psa_load_persistent_key_into_slot(psa_key_slot_t *slot)
683 : : {
684 : : psa_status_t status = PSA_SUCCESS;
685 : : uint8_t *key_data = NULL;
686 : : size_t key_data_length = 0;
687 : :
688 : : status = psa_load_persistent_key(&slot->attr,
689 : : &key_data, &key_data_length);
690 : : if (status != PSA_SUCCESS) {
691 : : goto exit;
692 : : }
693 : :
694 : : #if defined(MBEDTLS_PSA_CRYPTO_SE_C)
695 : : /* Special handling is required for loading keys associated with a
696 : : * dynamically registered SE interface. */
697 : : const psa_drv_se_t *drv;
698 : : psa_drv_se_context_t *drv_context;
699 : : if (psa_get_se_driver(slot->attr.lifetime, &drv, &drv_context)) {
700 : : psa_se_key_data_storage_t *data;
701 : :
702 : : if (key_data_length != sizeof(*data)) {
703 : : status = PSA_ERROR_DATA_INVALID;
704 : : goto exit;
705 : : }
706 : : data = (psa_se_key_data_storage_t *) key_data;
707 : : status = psa_copy_key_material_into_slot(
708 : : slot, data->slot_number, sizeof(data->slot_number));
709 : : goto exit;
710 : : }
711 : : #endif /* MBEDTLS_PSA_CRYPTO_SE_C */
712 : :
713 : : status = psa_copy_key_material_into_slot(slot, key_data, key_data_length);
714 : : if (status != PSA_SUCCESS) {
715 : : goto exit;
716 : : }
717 : :
718 : : exit:
719 : : psa_free_persistent_key_data(key_data, key_data_length);
720 : : return status;
721 : : }
722 : : #endif /* MBEDTLS_PSA_CRYPTO_STORAGE_C */
723 : :
724 : : #if defined(MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS)
725 : :
726 : : static psa_status_t psa_load_builtin_key_into_slot(psa_key_slot_t *slot)
727 : : {
728 : : psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
729 : : psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
730 : : psa_key_lifetime_t lifetime = PSA_KEY_LIFETIME_VOLATILE;
731 : : psa_drv_slot_number_t slot_number = 0;
732 : : size_t key_buffer_size = 0;
733 : : size_t key_buffer_length = 0;
734 : :
735 : : if (!psa_key_id_is_builtin(
736 : : MBEDTLS_SVC_KEY_ID_GET_KEY_ID(slot->attr.id))) {
737 : : return PSA_ERROR_DOES_NOT_EXIST;
738 : : }
739 : :
740 : : /* Check the platform function to see whether this key actually exists */
741 : : status = mbedtls_psa_platform_get_builtin_key(
742 : : slot->attr.id, &lifetime, &slot_number);
743 : : if (status != PSA_SUCCESS) {
744 : : return status;
745 : : }
746 : :
747 : : /* Set required key attributes to ensure get_builtin_key can retrieve the
748 : : * full attributes. */
749 : : psa_set_key_id(&attributes, slot->attr.id);
750 : : psa_set_key_lifetime(&attributes, lifetime);
751 : :
752 : : /* Get the full key attributes from the driver in order to be able to
753 : : * calculate the required buffer size. */
754 : : status = psa_driver_wrapper_get_builtin_key(
755 : : slot_number, &attributes,
756 : : NULL, 0, NULL);
757 : : if (status != PSA_ERROR_BUFFER_TOO_SMALL) {
758 : : /* Builtin keys cannot be defined by the attributes alone */
759 : : if (status == PSA_SUCCESS) {
760 : : status = PSA_ERROR_CORRUPTION_DETECTED;
761 : : }
762 : : return status;
763 : : }
764 : :
765 : : /* If the key should exist according to the platform, then ask the driver
766 : : * what its expected size is. */
767 : : status = psa_driver_wrapper_get_key_buffer_size(&attributes,
768 : : &key_buffer_size);
769 : : if (status != PSA_SUCCESS) {
770 : : return status;
771 : : }
772 : :
773 : : /* Allocate a buffer of the required size and load the builtin key directly
774 : : * into the (now properly sized) slot buffer. */
775 : : status = psa_allocate_buffer_to_slot(slot, key_buffer_size);
776 : : if (status != PSA_SUCCESS) {
777 : : return status;
778 : : }
779 : :
780 : : status = psa_driver_wrapper_get_builtin_key(
781 : : slot_number, &attributes,
782 : : slot->key.data, slot->key.bytes, &key_buffer_length);
783 : : if (status != PSA_SUCCESS) {
784 : : goto exit;
785 : : }
786 : :
787 : : /* Copy actual key length and core attributes into the slot on success */
788 : : slot->key.bytes = key_buffer_length;
789 : : slot->attr = attributes;
790 : : exit:
791 : : if (status != PSA_SUCCESS) {
792 : : psa_remove_key_data_from_memory(slot);
793 : : }
794 : : return status;
795 : : }
796 : : #endif /* MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS */
797 : :
798 : 374 : psa_status_t psa_get_and_lock_key_slot(mbedtls_svc_key_id_t key,
799 : : psa_key_slot_t **p_slot)
800 : : {
801 : 374 : psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
802 : :
803 : 374 : *p_slot = NULL;
804 [ + - ]: 374 : if (!psa_get_key_slots_initialized()) {
805 : : return PSA_ERROR_BAD_STATE;
806 : : }
807 : :
808 : : #if defined(MBEDTLS_THREADING_C)
809 : : /* We need to set status as success, otherwise CORRUPTION_DETECTED
810 : : * would be returned if the lock fails. */
811 : : status = PSA_SUCCESS;
812 : : /* If the key is persistent and not loaded, we cannot unlock the mutex
813 : : * between checking if the key is loaded and setting the slot as FULL,
814 : : * as otherwise another thread may load and then destroy the key
815 : : * in the meantime. */
816 : : PSA_THREADING_CHK_RET(mbedtls_mutex_lock(
817 : : &mbedtls_threading_key_slot_mutex));
818 : : #endif
819 : : /*
820 : : * On success, the pointer to the slot is passed directly to the caller
821 : : * thus no need to unlock the key slot here.
822 : : */
823 : 374 : status = psa_get_and_lock_key_slot_in_memory(key, p_slot);
824 [ - + ]: 374 : if (status != PSA_ERROR_DOES_NOT_EXIST) {
825 : : #if defined(MBEDTLS_THREADING_C)
826 : : PSA_THREADING_CHK_RET(mbedtls_mutex_unlock(
827 : : &mbedtls_threading_key_slot_mutex));
828 : : #endif
829 : : return status;
830 : : }
831 : :
832 : : /* Loading keys from storage requires support for such a mechanism */
833 : : #if defined(MBEDTLS_PSA_CRYPTO_STORAGE_C) || \
834 : : defined(MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS)
835 : :
836 : : status = psa_reserve_free_key_slot(NULL, p_slot);
837 : : if (status != PSA_SUCCESS) {
838 : : #if defined(MBEDTLS_THREADING_C)
839 : : PSA_THREADING_CHK_RET(mbedtls_mutex_unlock(
840 : : &mbedtls_threading_key_slot_mutex));
841 : : #endif
842 : : return status;
843 : : }
844 : :
845 : : (*p_slot)->attr.id = key;
846 : : (*p_slot)->attr.lifetime = PSA_KEY_LIFETIME_PERSISTENT;
847 : :
848 : : status = PSA_ERROR_DOES_NOT_EXIST;
849 : : #if defined(MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS)
850 : : /* Load keys in the 'builtin' range through their own interface */
851 : : status = psa_load_builtin_key_into_slot(*p_slot);
852 : : #endif /* MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS */
853 : :
854 : : #if defined(MBEDTLS_PSA_CRYPTO_STORAGE_C)
855 : : if (status == PSA_ERROR_DOES_NOT_EXIST) {
856 : : status = psa_load_persistent_key_into_slot(*p_slot);
857 : : }
858 : : #endif /* defined(MBEDTLS_PSA_CRYPTO_STORAGE_C) */
859 : :
860 : : if (status != PSA_SUCCESS) {
861 : : psa_wipe_key_slot(*p_slot);
862 : :
863 : : /* If the key does not exist, we need to return
864 : : * PSA_ERROR_INVALID_HANDLE. */
865 : : if (status == PSA_ERROR_DOES_NOT_EXIST) {
866 : : status = PSA_ERROR_INVALID_HANDLE;
867 : : }
868 : : } else {
869 : : /* Add implicit usage flags. */
870 : : psa_extend_key_usage_flags(&(*p_slot)->attr.policy.usage);
871 : :
872 : : psa_key_slot_state_transition((*p_slot), PSA_SLOT_FILLING,
873 : : PSA_SLOT_FULL);
874 : : status = psa_register_read(*p_slot);
875 : : }
876 : :
877 : : #else /* MBEDTLS_PSA_CRYPTO_STORAGE_C || MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS */
878 : 0 : status = PSA_ERROR_INVALID_HANDLE;
879 : : #endif /* MBEDTLS_PSA_CRYPTO_STORAGE_C || MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS */
880 : :
881 : 0 : if (status != PSA_SUCCESS) {
882 : 0 : *p_slot = NULL;
883 : : }
884 : : #if defined(MBEDTLS_THREADING_C)
885 : : PSA_THREADING_CHK_RET(mbedtls_mutex_unlock(
886 : : &mbedtls_threading_key_slot_mutex));
887 : : #endif
888 : 0 : return status;
889 : : }
890 : :
891 : 374 : psa_status_t psa_unregister_read(psa_key_slot_t *slot)
892 : : {
893 [ - + ]: 374 : if (slot == NULL) {
894 : : return PSA_SUCCESS;
895 : : }
896 [ + - ]: 374 : if ((slot->state != PSA_SLOT_FULL) &&
897 : : (slot->state != PSA_SLOT_PENDING_DELETION)) {
898 : : return PSA_ERROR_CORRUPTION_DETECTED;
899 : : }
900 : :
901 : : /* If we are the last reader and the slot is marked for deletion,
902 : : * we must wipe the slot here. */
903 [ + + ]: 374 : if ((slot->state == PSA_SLOT_PENDING_DELETION) &&
904 [ + - ]: 172 : (slot->var.occupied.registered_readers == 1)) {
905 : 172 : return psa_wipe_key_slot(slot);
906 : : }
907 : :
908 [ + - ]: 202 : if (psa_key_slot_has_readers(slot)) {
909 : 202 : slot->var.occupied.registered_readers--;
910 : 202 : return PSA_SUCCESS;
911 : : }
912 : :
913 : : /*
914 : : * As the return error code may not be handled in case of multiple errors,
915 : : * do our best to report if there are no registered readers. Assert with
916 : : * MBEDTLS_TEST_HOOK_TEST_ASSERT that there are registered readers:
917 : : * if the MBEDTLS_TEST_HOOKS configuration option is enabled and
918 : : * the function is called as part of the execution of a test suite, the
919 : : * execution of the test suite is stopped in error if the assertion fails.
920 : : */
921 : : MBEDTLS_TEST_HOOK_TEST_ASSERT(psa_key_slot_has_readers(slot));
922 : : return PSA_ERROR_CORRUPTION_DETECTED;
923 : : }
924 : :
925 : 202 : psa_status_t psa_unregister_read_under_mutex(psa_key_slot_t *slot)
926 : : {
927 : 202 : psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
928 : : #if defined(MBEDTLS_THREADING_C)
929 : : /* We need to set status as success, otherwise CORRUPTION_DETECTED
930 : : * would be returned if the lock fails. */
931 : : status = PSA_SUCCESS;
932 : : PSA_THREADING_CHK_RET(mbedtls_mutex_lock(
933 : : &mbedtls_threading_key_slot_mutex));
934 : : #endif
935 : 202 : status = psa_unregister_read(slot);
936 : : #if defined(MBEDTLS_THREADING_C)
937 : : PSA_THREADING_CHK_RET(mbedtls_mutex_unlock(
938 : : &mbedtls_threading_key_slot_mutex));
939 : : #endif
940 : 202 : return status;
941 : : }
942 : :
943 : 172 : psa_status_t psa_validate_key_location(psa_key_lifetime_t lifetime,
944 : : psa_se_drv_table_entry_t **p_drv)
945 : : {
946 : 172 : if (psa_key_lifetime_is_external(lifetime)) {
947 : : #if defined(MBEDTLS_PSA_CRYPTO_SE_C)
948 : : /* Check whether a driver is registered against this lifetime */
949 : : psa_se_drv_table_entry_t *driver = psa_get_se_driver_entry(lifetime);
950 : : if (driver != NULL) {
951 : : if (p_drv != NULL) {
952 : : *p_drv = driver;
953 : : }
954 : : return PSA_SUCCESS;
955 : : }
956 : : #else /* MBEDTLS_PSA_CRYPTO_SE_C */
957 : : (void) p_drv;
958 : : #endif /* MBEDTLS_PSA_CRYPTO_SE_C */
959 : :
960 : : /* Key location for external keys gets checked by the wrapper */
961 : : return PSA_SUCCESS;
962 : : } else {
963 : : /* Local/internal keys are always valid */
964 : 172 : return PSA_SUCCESS;
965 : : }
966 : : }
967 : :
968 : 172 : psa_status_t psa_validate_key_persistence(psa_key_lifetime_t lifetime)
969 : : {
970 [ - + ]: 172 : if (PSA_KEY_LIFETIME_IS_VOLATILE(lifetime)) {
971 : : /* Volatile keys are always supported */
972 : : return PSA_SUCCESS;
973 : : } else {
974 : : /* Persistent keys require storage support */
975 : : #if defined(MBEDTLS_PSA_CRYPTO_STORAGE_C)
976 : : if (PSA_KEY_LIFETIME_IS_READ_ONLY(lifetime)) {
977 : : return PSA_ERROR_INVALID_ARGUMENT;
978 : : } else {
979 : : return PSA_SUCCESS;
980 : : }
981 : : #else /* MBEDTLS_PSA_CRYPTO_STORAGE_C */
982 : 0 : return PSA_ERROR_NOT_SUPPORTED;
983 : : #endif /* !MBEDTLS_PSA_CRYPTO_STORAGE_C */
984 : : }
985 : : }
986 : :
987 : 0 : psa_status_t psa_open_key(mbedtls_svc_key_id_t key, psa_key_handle_t *handle)
988 : : {
989 : : #if defined(MBEDTLS_PSA_CRYPTO_STORAGE_C) || \
990 : : defined(MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS)
991 : : psa_status_t status;
992 : : psa_key_slot_t *slot;
993 : :
994 : : status = psa_get_and_lock_key_slot(key, &slot);
995 : : if (status != PSA_SUCCESS) {
996 : : *handle = PSA_KEY_HANDLE_INIT;
997 : : if (status == PSA_ERROR_INVALID_HANDLE) {
998 : : status = PSA_ERROR_DOES_NOT_EXIST;
999 : : }
1000 : :
1001 : : return status;
1002 : : }
1003 : :
1004 : : *handle = key;
1005 : :
1006 : : return psa_unregister_read_under_mutex(slot);
1007 : :
1008 : : #else /* MBEDTLS_PSA_CRYPTO_STORAGE_C || MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS */
1009 : 0 : (void) key;
1010 : 0 : *handle = PSA_KEY_HANDLE_INIT;
1011 : 0 : return PSA_ERROR_NOT_SUPPORTED;
1012 : : #endif /* MBEDTLS_PSA_CRYPTO_STORAGE_C || MBEDTLS_PSA_CRYPTO_BUILTIN_KEYS */
1013 : : }
1014 : :
1015 : 0 : psa_status_t psa_close_key(psa_key_handle_t handle)
1016 : : {
1017 : 0 : psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
1018 : 0 : psa_key_slot_t *slot;
1019 : :
1020 [ # # ]: 0 : if (psa_key_handle_is_null(handle)) {
1021 : : return PSA_SUCCESS;
1022 : : }
1023 : :
1024 : : #if defined(MBEDTLS_THREADING_C)
1025 : : /* We need to set status as success, otherwise CORRUPTION_DETECTED
1026 : : * would be returned if the lock fails. */
1027 : : status = PSA_SUCCESS;
1028 : : PSA_THREADING_CHK_RET(mbedtls_mutex_lock(
1029 : : &mbedtls_threading_key_slot_mutex));
1030 : : #endif
1031 : 0 : status = psa_get_and_lock_key_slot_in_memory(handle, &slot);
1032 [ # # ]: 0 : if (status != PSA_SUCCESS) {
1033 [ # # ]: 0 : if (status == PSA_ERROR_DOES_NOT_EXIST) {
1034 : 0 : status = PSA_ERROR_INVALID_HANDLE;
1035 : : }
1036 : : #if defined(MBEDTLS_THREADING_C)
1037 : : PSA_THREADING_CHK_RET(mbedtls_mutex_unlock(
1038 : : &mbedtls_threading_key_slot_mutex));
1039 : : #endif
1040 : 0 : return status;
1041 : : }
1042 : :
1043 [ # # ]: 0 : if (slot->var.occupied.registered_readers == 1) {
1044 : 0 : status = psa_wipe_key_slot(slot);
1045 : : } else {
1046 : 0 : status = psa_unregister_read(slot);
1047 : : }
1048 : : #if defined(MBEDTLS_THREADING_C)
1049 : : PSA_THREADING_CHK_RET(mbedtls_mutex_unlock(
1050 : : &mbedtls_threading_key_slot_mutex));
1051 : : #endif
1052 : :
1053 : : return status;
1054 : : }
1055 : :
1056 : 0 : psa_status_t psa_purge_key(mbedtls_svc_key_id_t key)
1057 : : {
1058 : 0 : psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
1059 : 0 : psa_key_slot_t *slot;
1060 : :
1061 : : #if defined(MBEDTLS_THREADING_C)
1062 : : /* We need to set status as success, otherwise CORRUPTION_DETECTED
1063 : : * would be returned if the lock fails. */
1064 : : status = PSA_SUCCESS;
1065 : : PSA_THREADING_CHK_RET(mbedtls_mutex_lock(
1066 : : &mbedtls_threading_key_slot_mutex));
1067 : : #endif
1068 : 0 : status = psa_get_and_lock_key_slot_in_memory(key, &slot);
1069 [ # # ]: 0 : if (status != PSA_SUCCESS) {
1070 : : #if defined(MBEDTLS_THREADING_C)
1071 : : PSA_THREADING_CHK_RET(mbedtls_mutex_unlock(
1072 : : &mbedtls_threading_key_slot_mutex));
1073 : : #endif
1074 : : return status;
1075 : : }
1076 : :
1077 [ # # ]: 0 : if ((!PSA_KEY_LIFETIME_IS_VOLATILE(slot->attr.lifetime)) &&
1078 [ # # ]: 0 : (slot->var.occupied.registered_readers == 1)) {
1079 : 0 : status = psa_wipe_key_slot(slot);
1080 : : } else {
1081 : 0 : status = psa_unregister_read(slot);
1082 : : }
1083 : : #if defined(MBEDTLS_THREADING_C)
1084 : : PSA_THREADING_CHK_RET(mbedtls_mutex_unlock(
1085 : : &mbedtls_threading_key_slot_mutex));
1086 : : #endif
1087 : :
1088 : : return status;
1089 : : }
1090 : :
1091 : 0 : void mbedtls_psa_get_stats(mbedtls_psa_stats_t *stats)
1092 : : {
1093 : 0 : memset(stats, 0, sizeof(*stats));
1094 : :
1095 [ # # ]: 0 : for (size_t slice_idx = 0; slice_idx < KEY_SLICE_COUNT; slice_idx++) {
1096 : : #if defined(MBEDTLS_PSA_KEY_STORE_DYNAMIC)
1097 : : if (global_data.key_slices[slice_idx] == NULL) {
1098 : : continue;
1099 : : }
1100 : : #endif /* MBEDTLS_PSA_KEY_STORE_DYNAMIC */
1101 [ # # ]: 0 : for (size_t slot_idx = 0; slot_idx < key_slice_length(slice_idx); slot_idx++) {
1102 : 0 : const psa_key_slot_t *slot = get_key_slot(slice_idx, slot_idx);
1103 [ # # ]: 0 : if (slot->state == PSA_SLOT_EMPTY) {
1104 : 0 : ++stats->empty_slots;
1105 : 0 : continue;
1106 : : }
1107 [ # # ]: 0 : if (psa_key_slot_has_readers(slot)) {
1108 : 0 : ++stats->locked_slots;
1109 : : }
1110 [ # # ]: 0 : if (PSA_KEY_LIFETIME_IS_VOLATILE(slot->attr.lifetime)) {
1111 : 0 : ++stats->volatile_slots;
1112 : : } else {
1113 : 0 : psa_key_id_t id = MBEDTLS_SVC_KEY_ID_GET_KEY_ID(slot->attr.id);
1114 : 0 : ++stats->persistent_slots;
1115 [ # # ]: 0 : if (id > stats->max_open_internal_key_id) {
1116 : 0 : stats->max_open_internal_key_id = id;
1117 : : }
1118 : : }
1119 [ # # ]: 0 : if (PSA_KEY_LIFETIME_GET_LOCATION(slot->attr.lifetime) !=
1120 : : PSA_KEY_LOCATION_LOCAL_STORAGE) {
1121 : 0 : psa_key_id_t id = MBEDTLS_SVC_KEY_ID_GET_KEY_ID(slot->attr.id);
1122 : 0 : ++stats->external_slots;
1123 [ # # ]: 0 : if (id > stats->max_open_external_key_id) {
1124 : 0 : stats->max_open_external_key_id = id;
1125 : : }
1126 : : }
1127 : : }
1128 : : }
1129 : 0 : }
1130 : :
1131 : : #endif /* MBEDTLS_PSA_CRYPTO_C */
|
