TrustedFirmware Git Browser
Code Review Sign In
review.trustedfirmware.org / mirror / mbed-tls / d532a663d0fe3ee758bf9598abe043bea99624f2 / . / library / psa_crypto_driver_wrappers.h
blob: ea6aee32eb0001dee4ba3f2d8dc3a2b880ba87dd [file] [log] [blame]
Minos Galanakise8a68332024-03-22 11:50:14 +0000[diff] [blame]1/*
2 * Functions to delegate cryptographic operations to an available
3 * and appropriate accelerator.
4 * Warning: This file is now auto-generated.
5 */
6/* Copyright The Mbed TLS Contributors
7 * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
8 */
9
10
11/* BEGIN-common headers */
12#include "common.h"
13#include "psa_crypto_aead.h"
14#include "psa_crypto_cipher.h"
15#include "psa_crypto_core.h"
16#include "psa_crypto_driver_wrappers_no_static.h"
17#include "psa_crypto_hash.h"
18#include "psa_crypto_mac.h"
19#include "psa_crypto_pake.h"
20#include "psa_crypto_rsa.h"
21
22#include "mbedtls/platform.h"
23#include "mbedtls/constant_time.h"
24/* END-common headers */
25
26#if defined(MBEDTLS_PSA_CRYPTO_C)
27
28/* BEGIN-driver headers */
29/* Headers for mbedtls_test opaque driver */
30#if defined(PSA_CRYPTO_DRIVER_TEST)
31#include "test/drivers/test_driver.h"
32
33#endif
34/* Headers for mbedtls_test transparent driver */
35#if defined(PSA_CRYPTO_DRIVER_TEST)
36#include "test/drivers/test_driver.h"
37
38#endif
39/* Headers for p256 transparent driver */
40#if defined(MBEDTLS_PSA_P256M_DRIVER_ENABLED)
41#include "../3rdparty/p256-m/p256-m_driver_entrypoints.h"
42
43#endif
44
45/* END-driver headers */
46
47/* Auto-generated values depending on which drivers are registered.
48 * ID 0 is reserved for unallocated operations.
49 * ID 1 is reserved for the Mbed TLS software driver. */
50/* BEGIN-driver id definition */
51#define PSA_CRYPTO_MBED_TLS_DRIVER_ID (1)
52#define MBEDTLS_TEST_OPAQUE_DRIVER_ID (2)
53#define MBEDTLS_TEST_TRANSPARENT_DRIVER_ID (3)
54#define P256_TRANSPARENT_DRIVER_ID (4)
55
56/* END-driver id */
57
58/* BEGIN-Common Macro definitions */
59
60/* END-Common Macro definitions */
61
62/* Support the 'old' SE interface when asked to */
63#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
64/* PSA_CRYPTO_DRIVER_PRESENT is defined when either a new-style or old-style
65 * SE driver is present, to avoid unused argument errors at compile time. */
66#ifndef PSA_CRYPTO_DRIVER_PRESENT
67#define PSA_CRYPTO_DRIVER_PRESENT
68#endif
69#include "psa_crypto_se.h"
70#endif
71
72static inline psa_status_t psa_driver_wrapper_init( void )
73{
74 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
75
76#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
77 status = psa_init_all_se_drivers( );
78 if( status != PSA_SUCCESS )
79 return( status );
80#endif
81
82#if defined(PSA_CRYPTO_DRIVER_TEST)
83 status = mbedtls_test_transparent_init( );
84 if( status != PSA_SUCCESS )
85 return( status );
86
87 status = mbedtls_test_opaque_init( );
88 if( status != PSA_SUCCESS )
89 return( status );
90#endif
91
92 (void) status;
93 return( PSA_SUCCESS );
94}
95
96static inline void psa_driver_wrapper_free( void )
97{
98#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
99 /* Unregister all secure element drivers, so that we restart from
100 * a pristine state. */
101 psa_unregister_all_se_drivers( );
102#endif /* MBEDTLS_PSA_CRYPTO_SE_C */
103
104#if defined(PSA_CRYPTO_DRIVER_TEST)
105 mbedtls_test_transparent_free( );
106 mbedtls_test_opaque_free( );
107#endif
108}
109
110/* Start delegation functions */
111static inline psa_status_t psa_driver_wrapper_sign_message(
112 const psa_key_attributes_t *attributes,
113 const uint8_t *key_buffer,
114 size_t key_buffer_size,
115 psa_algorithm_t alg,
116 const uint8_t *input,
117 size_t input_length,
118 uint8_t *signature,
119 size_t signature_size,
120 size_t *signature_length )
121{
122 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
123 psa_key_location_t location =
124 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
125
126 switch( location )
127 {
128 case PSA_KEY_LOCATION_LOCAL_STORAGE:
129 /* Key is stored in the slot in export representation, so
130 * cycle through all known transparent accelerators */
131#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
132#if defined(PSA_CRYPTO_DRIVER_TEST)
133 status = mbedtls_test_transparent_signature_sign_message(
134 attributes,
135 key_buffer,
136 key_buffer_size,
137 alg,
138 input,
139 input_length,
140 signature,
141 signature_size,
142 signature_length );
143 /* Declared with fallback == true */
144 if( status != PSA_ERROR_NOT_SUPPORTED )
145 return( status );
146#endif /* PSA_CRYPTO_DRIVER_TEST */
147#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
148 break;
149
150 /* Add cases for opaque driver here */
151#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
152#if defined(PSA_CRYPTO_DRIVER_TEST)
153 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
154 status = mbedtls_test_opaque_signature_sign_message(
155 attributes,
156 key_buffer,
157 key_buffer_size,
158 alg,
159 input,
160 input_length,
161 signature,
162 signature_size,
163 signature_length );
164 if( status != PSA_ERROR_NOT_SUPPORTED )
165 return( status );
166 break;
167#endif /* PSA_CRYPTO_DRIVER_TEST */
168#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
169 default:
170 /* Key is declared with a lifetime not known to us */
171 (void)status;
172 break;
173 }
174
175 return( psa_sign_message_builtin( attributes,
176 key_buffer,
177 key_buffer_size,
178 alg,
179 input,
180 input_length,
181 signature,
182 signature_size,
183 signature_length ) );
184}
185
186static inline psa_status_t psa_driver_wrapper_verify_message(
187 const psa_key_attributes_t *attributes,
188 const uint8_t *key_buffer,
189 size_t key_buffer_size,
190 psa_algorithm_t alg,
191 const uint8_t *input,
192 size_t input_length,
193 const uint8_t *signature,
194 size_t signature_length )
195{
196 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
197 psa_key_location_t location =
198 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
199
200 switch( location )
201 {
202 case PSA_KEY_LOCATION_LOCAL_STORAGE:
203 /* Key is stored in the slot in export representation, so
204 * cycle through all known transparent accelerators */
205#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
206#if defined(PSA_CRYPTO_DRIVER_TEST)
207 status = mbedtls_test_transparent_signature_verify_message(
208 attributes,
209 key_buffer,
210 key_buffer_size,
211 alg,
212 input,
213 input_length,
214 signature,
215 signature_length );
216 /* Declared with fallback == true */
217 if( status != PSA_ERROR_NOT_SUPPORTED )
218 return( status );
219#endif /* PSA_CRYPTO_DRIVER_TEST */
220#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
221 break;
222
223 /* Add cases for opaque driver here */
224#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
225#if defined(PSA_CRYPTO_DRIVER_TEST)
226 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
227 return( mbedtls_test_opaque_signature_verify_message(
228 attributes,
229 key_buffer,
230 key_buffer_size,
231 alg,
232 input,
233 input_length,
234 signature,
235 signature_length ) );
236 if( status != PSA_ERROR_NOT_SUPPORTED )
237 return( status );
238 break;
239#endif /* PSA_CRYPTO_DRIVER_TEST */
240#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
241 default:
242 /* Key is declared with a lifetime not known to us */
243 (void)status;
244 break;
245 }
246
247 return( psa_verify_message_builtin( attributes,
248 key_buffer,
249 key_buffer_size,
250 alg,
251 input,
252 input_length,
253 signature,
254 signature_length ) );
255}
256
257static inline psa_status_t psa_driver_wrapper_sign_hash(
258 const psa_key_attributes_t *attributes,
259 const uint8_t *key_buffer, size_t key_buffer_size,
260 psa_algorithm_t alg, const uint8_t *hash, size_t hash_length,
261 uint8_t *signature, size_t signature_size, size_t *signature_length )
262{
263 /* Try dynamically-registered SE interface first */
264#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
265 const psa_drv_se_t *drv;
266 psa_drv_se_context_t *drv_context;
267
268 if( psa_get_se_driver( psa_get_key_lifetime(attributes), &drv, &drv_context ) )
269 {
270 if( drv->asymmetric == NULL ||
271 drv->asymmetric->p_sign == NULL )
272 {
273 /* Key is defined in SE, but we have no way to exercise it */
274 return( PSA_ERROR_NOT_SUPPORTED );
275 }
276 return( drv->asymmetric->p_sign(
277 drv_context, *( (psa_key_slot_number_t *)key_buffer ),
278 alg, hash, hash_length,
279 signature, signature_size, signature_length ) );
280 }
281#endif /* MBEDTLS_PSA_CRYPTO_SE_C */
282
283 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
284 psa_key_location_t location =
285 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
286
287 switch( location )
288 {
289 case PSA_KEY_LOCATION_LOCAL_STORAGE:
290 /* Key is stored in the slot in export representation, so
291 * cycle through all known transparent accelerators */
292#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
293#if defined(PSA_CRYPTO_DRIVER_TEST)
294 status = mbedtls_test_transparent_signature_sign_hash( attributes,
295 key_buffer,
296 key_buffer_size,
297 alg,
298 hash,
299 hash_length,
300 signature,
301 signature_size,
302 signature_length );
303 /* Declared with fallback == true */
304 if( status != PSA_ERROR_NOT_SUPPORTED )
305 return( status );
306#endif /* PSA_CRYPTO_DRIVER_TEST */
307#if defined (MBEDTLS_PSA_P256M_DRIVER_ENABLED)
308 if( PSA_KEY_TYPE_IS_ECC( psa_get_key_type(attributes) ) &&
309 PSA_ALG_IS_ECDSA(alg) &&
310 !PSA_ALG_ECDSA_IS_DETERMINISTIC( alg ) &&
311 PSA_KEY_TYPE_ECC_GET_FAMILY(psa_get_key_type(attributes)) == PSA_ECC_FAMILY_SECP_R1 &&
312 psa_get_key_bits(attributes) == 256 )
313 {
314 status = p256_transparent_sign_hash( attributes,
315 key_buffer,
316 key_buffer_size,
317 alg,
318 hash,
319 hash_length,
320 signature,
321 signature_size,
322 signature_length );
323 if( status != PSA_ERROR_NOT_SUPPORTED )
324 return( status );
325 }
326#endif /* MBEDTLS_PSA_P256M_DRIVER_ENABLED */
327#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
328 /* Fell through, meaning no accelerator supports this operation */
329 return( psa_sign_hash_builtin( attributes,
330 key_buffer,
331 key_buffer_size,
332 alg,
333 hash,
334 hash_length,
335 signature,
336 signature_size,
337 signature_length ) );
338
339 /* Add cases for opaque driver here */
340#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
341#if defined(PSA_CRYPTO_DRIVER_TEST)
342 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
343 return( mbedtls_test_opaque_signature_sign_hash( attributes,
344 key_buffer,
345 key_buffer_size,
346 alg,
347 hash,
348 hash_length,
349 signature,
350 signature_size,
351 signature_length ) );
352#endif /* PSA_CRYPTO_DRIVER_TEST */
353#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
354 default:
355 /* Key is declared with a lifetime not known to us */
356 (void)status;
357 return( PSA_ERROR_INVALID_ARGUMENT );
358 }
359}
360
361static inline psa_status_t psa_driver_wrapper_verify_hash(
362 const psa_key_attributes_t *attributes,
363 const uint8_t *key_buffer, size_t key_buffer_size,
364 psa_algorithm_t alg, const uint8_t *hash, size_t hash_length,
365 const uint8_t *signature, size_t signature_length )
366{
367 /* Try dynamically-registered SE interface first */
368#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
369 const psa_drv_se_t *drv;
370 psa_drv_se_context_t *drv_context;
371
372 if( psa_get_se_driver( psa_get_key_lifetime(attributes), &drv, &drv_context ) )
373 {
374 if( drv->asymmetric == NULL ||
375 drv->asymmetric->p_verify == NULL )
376 {
377 /* Key is defined in SE, but we have no way to exercise it */
378 return( PSA_ERROR_NOT_SUPPORTED );
379 }
380 return( drv->asymmetric->p_verify(
381 drv_context, *( (psa_key_slot_number_t *)key_buffer ),
382 alg, hash, hash_length,
383 signature, signature_length ) );
384 }
385#endif /* MBEDTLS_PSA_CRYPTO_SE_C */
386
387 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
388 psa_key_location_t location =
389 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
390
391 switch( location )
392 {
393 case PSA_KEY_LOCATION_LOCAL_STORAGE:
394 /* Key is stored in the slot in export representation, so
395 * cycle through all known transparent accelerators */
396#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
397#if defined(PSA_CRYPTO_DRIVER_TEST)
398 status = mbedtls_test_transparent_signature_verify_hash(
399 attributes,
400 key_buffer,
401 key_buffer_size,
402 alg,
403 hash,
404 hash_length,
405 signature,
406 signature_length );
407 /* Declared with fallback == true */
408 if( status != PSA_ERROR_NOT_SUPPORTED )
409 return( status );
410#endif /* PSA_CRYPTO_DRIVER_TEST */
411#if defined (MBEDTLS_PSA_P256M_DRIVER_ENABLED)
412 if( PSA_KEY_TYPE_IS_ECC( psa_get_key_type(attributes) ) &&
413 PSA_ALG_IS_ECDSA(alg) &&
414 !PSA_ALG_ECDSA_IS_DETERMINISTIC( alg ) &&
415 PSA_KEY_TYPE_ECC_GET_FAMILY(psa_get_key_type(attributes)) == PSA_ECC_FAMILY_SECP_R1 &&
416 psa_get_key_bits(attributes) == 256 )
417 {
418 status = p256_transparent_verify_hash( attributes,
419 key_buffer,
420 key_buffer_size,
421 alg,
422 hash,
423 hash_length,
424 signature,
425 signature_length );
426 if( status != PSA_ERROR_NOT_SUPPORTED )
427 return( status );
428 }
429#endif /* MBEDTLS_PSA_P256M_DRIVER_ENABLED */
430#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
431
432 return( psa_verify_hash_builtin( attributes,
433 key_buffer,
434 key_buffer_size,
435 alg,
436 hash,
437 hash_length,
438 signature,
439 signature_length ) );
440
441 /* Add cases for opaque driver here */
442#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
443#if defined(PSA_CRYPTO_DRIVER_TEST)
444 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
445 return( mbedtls_test_opaque_signature_verify_hash( attributes,
446 key_buffer,
447 key_buffer_size,
448 alg,
449 hash,
450 hash_length,
451 signature,
452 signature_length ) );
453#endif /* PSA_CRYPTO_DRIVER_TEST */
454#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
455 default:
456 /* Key is declared with a lifetime not known to us */
457 (void)status;
458 return( PSA_ERROR_INVALID_ARGUMENT );
459 }
460}
461
462static inline uint32_t psa_driver_wrapper_sign_hash_get_num_ops(
463 psa_sign_hash_interruptible_operation_t *operation )
464{
465 switch( operation->id )
466 {
467 /* If uninitialised, return 0, as no work can have been done. */
468 case 0:
469 return 0;
470
471 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
472 return(mbedtls_psa_sign_hash_get_num_ops(&operation->ctx.mbedtls_ctx));
473
474#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
475#if defined(PSA_CRYPTO_DRIVER_TEST)
476 /* Add test driver tests here */
477
478#endif /* PSA_CRYPTO_DRIVER_TEST */
479#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
480 }
481
482 /* Can't happen (see discussion in #8271) */
483 return 0;
484}
485
486static inline uint32_t psa_driver_wrapper_verify_hash_get_num_ops(
487 psa_verify_hash_interruptible_operation_t *operation )
488{
489 switch( operation->id )
490 {
491 /* If uninitialised, return 0, as no work can have been done. */
492 case 0:
493 return 0;
494
495 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
496 return (mbedtls_psa_verify_hash_get_num_ops(&operation->ctx.mbedtls_ctx));
497
498#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
499#if defined(PSA_CRYPTO_DRIVER_TEST)
500 /* Add test driver tests here */
501
502#endif /* PSA_CRYPTO_DRIVER_TEST */
503#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
504
505 }
506
507 /* Can't happen (see discussion in #8271) */
508 return 0;
509}
510
511static inline psa_status_t psa_driver_wrapper_sign_hash_start(
512 psa_sign_hash_interruptible_operation_t *operation,
513 const psa_key_attributes_t *attributes, const uint8_t *key_buffer,
514 size_t key_buffer_size, psa_algorithm_t alg,
515 const uint8_t *hash, size_t hash_length )
516{
517 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
518 psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(
519 psa_get_key_lifetime(attributes) );
520
521 switch( location )
522 {
523 case PSA_KEY_LOCATION_LOCAL_STORAGE:
524 /* Key is stored in the slot in export representation, so
525 * cycle through all known transparent accelerators */
526
527#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
528#if defined(PSA_CRYPTO_DRIVER_TEST)
529
530 /* Add test driver tests here */
531
532 /* Declared with fallback == true */
533
534#endif /* PSA_CRYPTO_DRIVER_TEST */
535#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
536
537 /* Fell through, meaning no accelerator supports this operation */
538 operation->id = PSA_CRYPTO_MBED_TLS_DRIVER_ID;
539 status = mbedtls_psa_sign_hash_start( &operation->ctx.mbedtls_ctx,
540 attributes,
541 key_buffer, key_buffer_size,
542 alg, hash, hash_length );
543 break;
544
545 /* Add cases for opaque driver here */
546
547 default:
548 /* Key is declared with a lifetime not known to us */
549 status = PSA_ERROR_INVALID_ARGUMENT;
550 break;
551 }
552
553 return( status );
554}
555
556static inline psa_status_t psa_driver_wrapper_sign_hash_complete(
557 psa_sign_hash_interruptible_operation_t *operation,
558 uint8_t *signature, size_t signature_size,
559 size_t *signature_length )
560{
561 switch( operation->id )
562 {
563 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
564 return( mbedtls_psa_sign_hash_complete( &operation->ctx.mbedtls_ctx,
565 signature, signature_size,
566 signature_length ) );
567
568#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
569#if defined(PSA_CRYPTO_DRIVER_TEST)
570 /* Add test driver tests here */
571
572#endif /* PSA_CRYPTO_DRIVER_TEST */
573#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
574 }
575
576 ( void ) signature;
577 ( void ) signature_size;
578 ( void ) signature_length;
579
580 return( PSA_ERROR_INVALID_ARGUMENT );
581}
582
583static inline psa_status_t psa_driver_wrapper_sign_hash_abort(
584 psa_sign_hash_interruptible_operation_t *operation )
585{
586 switch( operation->id )
587 {
588 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
589 return( mbedtls_psa_sign_hash_abort( &operation->ctx.mbedtls_ctx ) );
590
591#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
592#if defined(PSA_CRYPTO_DRIVER_TEST)
593 /* Add test driver tests here */
594
595#endif /* PSA_CRYPTO_DRIVER_TEST */
596#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
597 }
598
599 return( PSA_ERROR_INVALID_ARGUMENT );
600}
601
602static inline psa_status_t psa_driver_wrapper_verify_hash_start(
603 psa_verify_hash_interruptible_operation_t *operation,
604 const psa_key_attributes_t *attributes, const uint8_t *key_buffer,
605 size_t key_buffer_size, psa_algorithm_t alg,
606 const uint8_t *hash, size_t hash_length,
607 const uint8_t *signature, size_t signature_length )
608{
609 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
610 psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(
611 psa_get_key_lifetime(attributes) );
612
613 switch( location )
614 {
615 case PSA_KEY_LOCATION_LOCAL_STORAGE:
616 /* Key is stored in the slot in export representation, so
617 * cycle through all known transparent accelerators */
618
619#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
620#if defined(PSA_CRYPTO_DRIVER_TEST)
621
622 /* Add test driver tests here */
623
624 /* Declared with fallback == true */
625
626#endif /* PSA_CRYPTO_DRIVER_TEST */
627#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
628
629 /* Fell through, meaning no accelerator supports this operation */
630 operation->id = PSA_CRYPTO_MBED_TLS_DRIVER_ID;
631 status = mbedtls_psa_verify_hash_start( &operation->ctx.mbedtls_ctx,
632 attributes,
633 key_buffer, key_buffer_size,
634 alg, hash, hash_length,
635 signature, signature_length );
636 break;
637
638 /* Add cases for opaque driver here */
639
640 default:
641 /* Key is declared with a lifetime not known to us */
642 status = PSA_ERROR_INVALID_ARGUMENT;
643 break;
644 }
645
646 return( status );
647}
648
649static inline psa_status_t psa_driver_wrapper_verify_hash_complete(
650 psa_verify_hash_interruptible_operation_t *operation )
651{
652 switch( operation->id )
653 {
654 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
655 return( mbedtls_psa_verify_hash_complete(
656 &operation->ctx.mbedtls_ctx
657 ) );
658
659#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
660#if defined(PSA_CRYPTO_DRIVER_TEST)
661 /* Add test driver tests here */
662
663#endif /* PSA_CRYPTO_DRIVER_TEST */
664#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
665 }
666
667 return( PSA_ERROR_INVALID_ARGUMENT );
668}
669
670static inline psa_status_t psa_driver_wrapper_verify_hash_abort(
671 psa_verify_hash_interruptible_operation_t *operation )
672{
673 switch( operation->id )
674 {
675 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
676 return( mbedtls_psa_verify_hash_abort( &operation->ctx.mbedtls_ctx
677 ) );
678
679#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
680#if defined(PSA_CRYPTO_DRIVER_TEST)
681 /* Add test driver tests here */
682
683#endif /* PSA_CRYPTO_DRIVER_TEST */
684#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
685 }
686
687 return( PSA_ERROR_INVALID_ARGUMENT );
688}
689
690/** Calculate the key buffer size required to store the key material of a key
691 * associated with an opaque driver from input key data.
692 *
693 * \param[in] attributes The key attributes
694 * \param[in] data The input key data.
695 * \param[in] data_length The input data length.
696 * \param[out] key_buffer_size Minimum buffer size to contain the key material.
697 *
698 * \retval #PSA_SUCCESS \emptydescription
699 * \retval #PSA_ERROR_INVALID_ARGUMENT \emptydescription
700 * \retval #PSA_ERROR_NOT_SUPPORTED \emptydescription
701 */
702static inline psa_status_t psa_driver_wrapper_get_key_buffer_size_from_key_data(
703 const psa_key_attributes_t *attributes,
704 const uint8_t *data,
705 size_t data_length,
706 size_t *key_buffer_size )
707{
708 psa_key_location_t location =
709 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
710 psa_key_type_t key_type = psa_get_key_type(attributes);
711
712 *key_buffer_size = 0;
713 switch( location )
714 {
715#if defined(PSA_CRYPTO_DRIVER_TEST)
716 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
717 *key_buffer_size = mbedtls_test_opaque_size_function( key_type,
718 PSA_BYTES_TO_BITS( data_length ) );
719 return( ( *key_buffer_size != 0 ) ?
720 PSA_SUCCESS : PSA_ERROR_NOT_SUPPORTED );
721#endif /* PSA_CRYPTO_DRIVER_TEST */
722
723 default:
724 (void)key_type;
725 (void)data;
726 (void)data_length;
727 return( PSA_ERROR_INVALID_ARGUMENT );
728 }
729}
730
731static inline psa_status_t psa_driver_wrapper_generate_key(
732 const psa_key_attributes_t *attributes,
733 const psa_key_production_parameters_t *params, size_t params_data_length,
734 uint8_t *key_buffer, size_t key_buffer_size, size_t *key_buffer_length )
735{
736 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
737 psa_key_location_t location =
738 PSA_KEY_LIFETIME_GET_LOCATION(psa_get_key_lifetime(attributes));
739
740#if defined(PSA_WANT_KEY_TYPE_RSA_KEY_PAIR_GENERATE)
741 int is_default_production =
742 psa_key_production_parameters_are_default(params, params_data_length);
743 if( location != PSA_KEY_LOCATION_LOCAL_STORAGE && !is_default_production )
744 {
745 /* We don't support passing custom production parameters
746 * to drivers yet. */
747 return PSA_ERROR_NOT_SUPPORTED;
748 }
749#else
750 int is_default_production = 1;
751 (void) is_default_production;
752#endif
753
754 /* Try dynamically-registered SE interface first */
755#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
756 const psa_drv_se_t *drv;
757 psa_drv_se_context_t *drv_context;
758
759 if( psa_get_se_driver( psa_get_key_lifetime(attributes), &drv, &drv_context ) )
760 {
761 size_t pubkey_length = 0; /* We don't support this feature yet */
762 if( drv->key_management == NULL ||
763 drv->key_management->p_generate == NULL )
764 {
765 /* Key is defined as being in SE, but we have no way to generate it */
766 return( PSA_ERROR_NOT_SUPPORTED );
767 }
768 return( drv->key_management->p_generate(
769 drv_context,
770 *( (psa_key_slot_number_t *)key_buffer ),
771 attributes, NULL, 0, &pubkey_length ) );
772 }
773#endif /* MBEDTLS_PSA_CRYPTO_SE_C */
774
775 switch( location )
776 {
777 case PSA_KEY_LOCATION_LOCAL_STORAGE:
778#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
779 /* Transparent drivers are limited to generating asymmetric keys. */
780 /* We don't support passing custom production parameters
781 * to drivers yet. */
782 if( PSA_KEY_TYPE_IS_ASYMMETRIC( psa_get_key_type(attributes) ) &&
783 is_default_production )
784 {
785 /* Cycle through all known transparent accelerators */
786#if defined(PSA_CRYPTO_DRIVER_TEST)
787 status = mbedtls_test_transparent_generate_key(
788 attributes, key_buffer, key_buffer_size,
789 key_buffer_length );
790 /* Declared with fallback == true */
791 if( status != PSA_ERROR_NOT_SUPPORTED )
792 break;
793#endif /* PSA_CRYPTO_DRIVER_TEST */
794#if defined(MBEDTLS_PSA_P256M_DRIVER_ENABLED)
795 if( PSA_KEY_TYPE_IS_ECC( psa_get_key_type(attributes) ) &&
796 psa_get_key_type(attributes) == PSA_KEY_TYPE_ECC_KEY_PAIR(PSA_ECC_FAMILY_SECP_R1) &&
797 psa_get_key_bits(attributes) == 256 )
798 {
799 status = p256_transparent_generate_key( attributes,
800 key_buffer,
801 key_buffer_size,
802 key_buffer_length );
803 if( status != PSA_ERROR_NOT_SUPPORTED )
804 break;
805 }
806
807#endif /* MBEDTLS_PSA_P256M_DRIVER_ENABLED */
808 }
809#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
810
811 /* Software fallback */
812 status = psa_generate_key_internal(
813 attributes, params, params_data_length,
814 key_buffer, key_buffer_size, key_buffer_length );
815 break;
816
817 /* Add cases for opaque driver here */
818#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
819#if defined(PSA_CRYPTO_DRIVER_TEST)
820 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
821 status = mbedtls_test_opaque_generate_key(
822 attributes, key_buffer, key_buffer_size, key_buffer_length );
823 break;
824#endif /* PSA_CRYPTO_DRIVER_TEST */
825#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
826
827 default:
828 /* Key is declared with a lifetime not known to us */
829 status = PSA_ERROR_INVALID_ARGUMENT;
830 break;
831 }
832
833 return( status );
834}
835
836static inline psa_status_t psa_driver_wrapper_import_key(
837 const psa_key_attributes_t *attributes,
838 const uint8_t *data,
839 size_t data_length,
840 uint8_t *key_buffer,
841 size_t key_buffer_size,
842 size_t *key_buffer_length,
843 size_t *bits )
844{
845
846 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
847 psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(
848 psa_get_key_lifetime( attributes ) );
849
850 /* Try dynamically-registered SE interface first */
851#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
852 const psa_drv_se_t *drv;
853 psa_drv_se_context_t *drv_context;
854
855 if( psa_get_se_driver( psa_get_key_lifetime(attributes), &drv, &drv_context ) )
856 {
857 if( drv->key_management == NULL ||
858 drv->key_management->p_import == NULL )
859 return( PSA_ERROR_NOT_SUPPORTED );
860
861 /* The driver should set the number of key bits, however in
862 * case it doesn't, we initialize bits to an invalid value. */
863 *bits = PSA_MAX_KEY_BITS + 1;
864 status = drv->key_management->p_import(
865 drv_context,
866 *( (psa_key_slot_number_t *)key_buffer ),
867 attributes, data, data_length, bits );
868
869 if( status != PSA_SUCCESS )
870 return( status );
871
872 if( (*bits) > PSA_MAX_KEY_BITS )
873 return( PSA_ERROR_NOT_SUPPORTED );
874
875 return( PSA_SUCCESS );
876 }
877#endif /* MBEDTLS_PSA_CRYPTO_SE_C */
878
879 switch( location )
880 {
881 case PSA_KEY_LOCATION_LOCAL_STORAGE:
882 /* Key is stored in the slot in export representation, so
883 * cycle through all known transparent accelerators */
884#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
885
886#if (defined(PSA_CRYPTO_DRIVER_TEST) )
887 status = mbedtls_test_transparent_import_key
888 (attributes,
889 data,
890 data_length,
891 key_buffer,
892 key_buffer_size,
893 key_buffer_length,
894 bits
895 );
896
897 if( status != PSA_ERROR_NOT_SUPPORTED )
898 return( status );
899#endif
900
901#if (defined(MBEDTLS_PSA_P256M_DRIVER_ENABLED) )
902 status = p256_transparent_import_key
903 (attributes,
904 data,
905 data_length,
906 key_buffer,
907 key_buffer_size,
908 key_buffer_length,
909 bits
910 );
911
912 if( status != PSA_ERROR_NOT_SUPPORTED )
913 return( status );
914#endif
915
916
917#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
918
919 /* Fell through, meaning no accelerator supports this operation */
920 return( psa_import_key_into_slot( attributes,
921 data, data_length,
922 key_buffer, key_buffer_size,
923 key_buffer_length, bits ) );
924 /* Add cases for opaque driver here */
925#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
926
927#if (defined(PSA_CRYPTO_DRIVER_TEST) )
928 case 0x7fffff:
929 return( mbedtls_test_opaque_import_key
930 (attributes,
931 data,
932 data_length,
933 key_buffer,
934 key_buffer_size,
935 key_buffer_length,
936 bits
937 ));
938#endif
939
940
941#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
942 default:
943 (void)status;
944 return( PSA_ERROR_INVALID_ARGUMENT );
945 }
946
947}
948
949static inline psa_status_t psa_driver_wrapper_export_key(
950 const psa_key_attributes_t *attributes,
951 const uint8_t *key_buffer, size_t key_buffer_size,
952 uint8_t *data, size_t data_size, size_t *data_length )
953
954{
955
956 psa_status_t status = PSA_ERROR_INVALID_ARGUMENT;
957 psa_key_location_t location = PSA_KEY_LIFETIME_GET_LOCATION(
958 psa_get_key_lifetime( attributes ) );
959
960 /* Try dynamically-registered SE interface first */
961#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
962 const psa_drv_se_t *drv;
963 psa_drv_se_context_t *drv_context;
964
965 if( psa_get_se_driver( psa_get_key_lifetime(attributes), &drv, &drv_context ) )
966 {
967 if( ( drv->key_management == NULL ) ||
968 ( drv->key_management->p_export == NULL ) )
969 {
970 return( PSA_ERROR_NOT_SUPPORTED );
971 }
972
973 return( drv->key_management->p_export(
974 drv_context,
975 *( (psa_key_slot_number_t *)key_buffer ),
976 data, data_size, data_length ) );
977 }
978#endif /* MBEDTLS_PSA_CRYPTO_SE_C */
979
980 switch( location )
981 {
982 case PSA_KEY_LOCATION_LOCAL_STORAGE:
983 return( psa_export_key_internal( attributes,
984 key_buffer,
985 key_buffer_size,
986 data,
987 data_size,
988 data_length ) );
989
990 /* Add cases for opaque driver here */
991#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
992
993#if (defined(PSA_CRYPTO_DRIVER_TEST) )
994 case 0x7fffff:
995 return( mbedtls_test_opaque_export_key
996 (attributes,
997 key_buffer,
998 key_buffer_size,
999 data,
1000 data_size,
1001 data_length
1002 ));
1003#endif
1004
1005
1006#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1007 default:
1008 /* Key is declared with a lifetime not known to us */
1009 return( status );
1010 }
1011
1012}
1013
1014static inline psa_status_t psa_driver_wrapper_copy_key(
1015 psa_key_attributes_t *attributes,
1016 const uint8_t *source_key, size_t source_key_length,
1017 uint8_t *target_key_buffer, size_t target_key_buffer_size,
1018 size_t *target_key_buffer_length )
1019{
1020
1021 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
1022 psa_key_location_t location =
1023 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
1024
1025#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
1026 const psa_drv_se_t *drv;
1027 psa_drv_se_context_t *drv_context;
1028
1029 if( psa_get_se_driver( psa_get_key_lifetime(attributes), &drv, &drv_context ) )
1030 {
1031 /* Copying to a secure element is not implemented yet. */
1032 return( PSA_ERROR_NOT_SUPPORTED );
1033 }
1034#endif /* MBEDTLS_PSA_CRYPTO_SE_C */
1035
1036 switch( location )
1037 {
1038#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1039
1040#if (defined(PSA_CRYPTO_DRIVER_TEST) )
1041 case 0x7fffff:
1042 return( mbedtls_test_opaque_copy_key
1043 (attributes,
1044 source_key,
1045 source_key_length,
1046 target_key_buffer,
1047 target_key_buffer_size,
1048 target_key_buffer_length
1049 ));
1050#endif
1051
1052
1053#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1054 default:
1055 (void)source_key;
1056 (void)source_key_length;
1057 (void)target_key_buffer;
1058 (void)target_key_buffer_size;
1059 (void)target_key_buffer_length;
1060 status = PSA_ERROR_INVALID_ARGUMENT;
1061 }
1062 return( status );
1063
1064}
1065
1066/*
1067 * Cipher functions
1068 */
1069static inline psa_status_t psa_driver_wrapper_cipher_encrypt(
1070 const psa_key_attributes_t *attributes,
1071 const uint8_t *key_buffer,
1072 size_t key_buffer_size,
1073 psa_algorithm_t alg,
1074 const uint8_t *iv,
1075 size_t iv_length,
1076 const uint8_t *input,
1077 size_t input_length,
1078 uint8_t *output,
1079 size_t output_size,
1080 size_t *output_length )
1081{
1082 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
1083 psa_key_location_t location =
1084 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
1085
1086 switch( location )
1087 {
1088 case PSA_KEY_LOCATION_LOCAL_STORAGE:
1089 /* Key is stored in the slot in export representation, so
1090 * cycle through all known transparent accelerators */
1091#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1092#if defined(PSA_CRYPTO_DRIVER_TEST)
1093 status = mbedtls_test_transparent_cipher_encrypt( attributes,
1094 key_buffer,
1095 key_buffer_size,
1096 alg,
1097 iv,
1098 iv_length,
1099 input,
1100 input_length,
1101 output,
1102 output_size,
1103 output_length );
1104 /* Declared with fallback == true */
1105 if( status != PSA_ERROR_NOT_SUPPORTED )
1106 return( status );
1107#endif /* PSA_CRYPTO_DRIVER_TEST */
1108#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1109
1110#if defined(MBEDTLS_PSA_BUILTIN_CIPHER)
1111 return( mbedtls_psa_cipher_encrypt( attributes,
1112 key_buffer,
1113 key_buffer_size,
1114 alg,
1115 iv,
1116 iv_length,
1117 input,
1118 input_length,
1119 output,
1120 output_size,
1121 output_length ) );
1122#else
1123 return( PSA_ERROR_NOT_SUPPORTED );
1124#endif /* MBEDTLS_PSA_BUILTIN_CIPHER */
1125
1126 /* Add cases for opaque driver here */
1127#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1128#if defined(PSA_CRYPTO_DRIVER_TEST)
1129 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
1130 return( mbedtls_test_opaque_cipher_encrypt( attributes,
1131 key_buffer,
1132 key_buffer_size,
1133 alg,
1134 iv,
1135 iv_length,
1136 input,
1137 input_length,
1138 output,
1139 output_size,
1140 output_length ) );
1141#endif /* PSA_CRYPTO_DRIVER_TEST */
1142#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1143
1144 default:
1145 /* Key is declared with a lifetime not known to us */
1146 (void)status;
1147 (void)key_buffer;
1148 (void)key_buffer_size;
1149 (void)alg;
1150 (void)iv;
1151 (void)iv_length;
1152 (void)input;
1153 (void)input_length;
1154 (void)output;
1155 (void)output_size;
1156 (void)output_length;
1157 return( PSA_ERROR_INVALID_ARGUMENT );
1158 }
1159}
1160
1161static inline psa_status_t psa_driver_wrapper_cipher_decrypt(
1162 const psa_key_attributes_t *attributes,
1163 const uint8_t *key_buffer,
1164 size_t key_buffer_size,
1165 psa_algorithm_t alg,
1166 const uint8_t *input,
1167 size_t input_length,
1168 uint8_t *output,
1169 size_t output_size,
1170 size_t *output_length )
1171{
1172 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
1173 psa_key_location_t location =
1174 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
1175
1176 switch( location )
1177 {
1178 case PSA_KEY_LOCATION_LOCAL_STORAGE:
1179 /* Key is stored in the slot in export representation, so
1180 * cycle through all known transparent accelerators */
1181#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1182#if defined(PSA_CRYPTO_DRIVER_TEST)
1183 status = mbedtls_test_transparent_cipher_decrypt( attributes,
1184 key_buffer,
1185 key_buffer_size,
1186 alg,
1187 input,
1188 input_length,
1189 output,
1190 output_size,
1191 output_length );
1192 /* Declared with fallback == true */
1193 if( status != PSA_ERROR_NOT_SUPPORTED )
1194 return( status );
1195#endif /* PSA_CRYPTO_DRIVER_TEST */
1196#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1197
1198#if defined(MBEDTLS_PSA_BUILTIN_CIPHER)
1199 return( mbedtls_psa_cipher_decrypt( attributes,
1200 key_buffer,
1201 key_buffer_size,
1202 alg,
1203 input,
1204 input_length,
1205 output,
1206 output_size,
1207 output_length ) );
1208#else
1209 return( PSA_ERROR_NOT_SUPPORTED );
1210#endif /* MBEDTLS_PSA_BUILTIN_CIPHER */
1211
1212 /* Add cases for opaque driver here */
1213#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1214#if defined(PSA_CRYPTO_DRIVER_TEST)
1215 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
1216 return( mbedtls_test_opaque_cipher_decrypt( attributes,
1217 key_buffer,
1218 key_buffer_size,
1219 alg,
1220 input,
1221 input_length,
1222 output,
1223 output_size,
1224 output_length ) );
1225#endif /* PSA_CRYPTO_DRIVER_TEST */
1226#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1227
1228 default:
1229 /* Key is declared with a lifetime not known to us */
1230 (void)status;
1231 (void)key_buffer;
1232 (void)key_buffer_size;
1233 (void)alg;
1234 (void)input;
1235 (void)input_length;
1236 (void)output;
1237 (void)output_size;
1238 (void)output_length;
1239 return( PSA_ERROR_INVALID_ARGUMENT );
1240 }
1241}
1242
1243static inline psa_status_t psa_driver_wrapper_cipher_encrypt_setup(
1244 psa_cipher_operation_t *operation,
1245 const psa_key_attributes_t *attributes,
1246 const uint8_t *key_buffer, size_t key_buffer_size,
1247 psa_algorithm_t alg )
1248{
1249 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
1250 psa_key_location_t location =
1251 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
1252
1253 switch( location )
1254 {
1255 case PSA_KEY_LOCATION_LOCAL_STORAGE:
1256 /* Key is stored in the slot in export representation, so
1257 * cycle through all known transparent accelerators */
1258#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1259#if defined(PSA_CRYPTO_DRIVER_TEST)
1260 status = mbedtls_test_transparent_cipher_encrypt_setup(
1261 &operation->ctx.transparent_test_driver_ctx,
1262 attributes,
1263 key_buffer,
1264 key_buffer_size,
1265 alg );
1266 /* Declared with fallback == true */
1267 if( status == PSA_SUCCESS )
1268 operation->id = MBEDTLS_TEST_TRANSPARENT_DRIVER_ID;
1269
1270 if( status != PSA_ERROR_NOT_SUPPORTED )
1271 return( status );
1272#endif /* PSA_CRYPTO_DRIVER_TEST */
1273#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1274#if defined(MBEDTLS_PSA_BUILTIN_CIPHER)
1275 /* Fell through, meaning no accelerator supports this operation */
1276 status = mbedtls_psa_cipher_encrypt_setup( &operation->ctx.mbedtls_ctx,
1277 attributes,
1278 key_buffer,
1279 key_buffer_size,
1280 alg );
1281 if( status == PSA_SUCCESS )
1282 operation->id = PSA_CRYPTO_MBED_TLS_DRIVER_ID;
1283
1284 if( status != PSA_ERROR_NOT_SUPPORTED )
1285 return( status );
1286#endif /* MBEDTLS_PSA_BUILTIN_CIPHER */
1287 return( PSA_ERROR_NOT_SUPPORTED );
1288
1289 /* Add cases for opaque driver here */
1290#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1291#if defined(PSA_CRYPTO_DRIVER_TEST)
1292 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
1293 status = mbedtls_test_opaque_cipher_encrypt_setup(
1294 &operation->ctx.opaque_test_driver_ctx,
1295 attributes,
1296 key_buffer, key_buffer_size,
1297 alg );
1298
1299 if( status == PSA_SUCCESS )
1300 operation->id = MBEDTLS_TEST_OPAQUE_DRIVER_ID;
1301
1302 return( status );
1303#endif /* PSA_CRYPTO_DRIVER_TEST */
1304#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1305 default:
1306 /* Key is declared with a lifetime not known to us */
1307 (void)status;
1308 (void)operation;
1309 (void)key_buffer;
1310 (void)key_buffer_size;
1311 (void)alg;
1312 return( PSA_ERROR_INVALID_ARGUMENT );
1313 }
1314}
1315
1316static inline psa_status_t psa_driver_wrapper_cipher_decrypt_setup(
1317 psa_cipher_operation_t *operation,
1318 const psa_key_attributes_t *attributes,
1319 const uint8_t *key_buffer, size_t key_buffer_size,
1320 psa_algorithm_t alg )
1321{
1322 psa_status_t status = PSA_ERROR_INVALID_ARGUMENT;
1323 psa_key_location_t location =
1324 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
1325
1326 switch( location )
1327 {
1328 case PSA_KEY_LOCATION_LOCAL_STORAGE:
1329 /* Key is stored in the slot in export representation, so
1330 * cycle through all known transparent accelerators */
1331#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1332#if defined(PSA_CRYPTO_DRIVER_TEST)
1333 status = mbedtls_test_transparent_cipher_decrypt_setup(
1334 &operation->ctx.transparent_test_driver_ctx,
1335 attributes,
1336 key_buffer,
1337 key_buffer_size,
1338 alg );
1339 /* Declared with fallback == true */
1340 if( status == PSA_SUCCESS )
1341 operation->id = MBEDTLS_TEST_TRANSPARENT_DRIVER_ID;
1342
1343 if( status != PSA_ERROR_NOT_SUPPORTED )
1344 return( status );
1345#endif /* PSA_CRYPTO_DRIVER_TEST */
1346#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1347#if defined(MBEDTLS_PSA_BUILTIN_CIPHER)
1348 /* Fell through, meaning no accelerator supports this operation */
1349 status = mbedtls_psa_cipher_decrypt_setup( &operation->ctx.mbedtls_ctx,
1350 attributes,
1351 key_buffer,
1352 key_buffer_size,
1353 alg );
1354 if( status == PSA_SUCCESS )
1355 operation->id = PSA_CRYPTO_MBED_TLS_DRIVER_ID;
1356
1357 return( status );
1358#else /* MBEDTLS_PSA_BUILTIN_CIPHER */
1359 return( PSA_ERROR_NOT_SUPPORTED );
1360#endif /* MBEDTLS_PSA_BUILTIN_CIPHER */
1361
1362 /* Add cases for opaque driver here */
1363#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1364#if defined(PSA_CRYPTO_DRIVER_TEST)
1365 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
1366 status = mbedtls_test_opaque_cipher_decrypt_setup(
1367 &operation->ctx.opaque_test_driver_ctx,
1368 attributes,
1369 key_buffer, key_buffer_size,
1370 alg );
1371
1372 if( status == PSA_SUCCESS )
1373 operation->id = MBEDTLS_TEST_OPAQUE_DRIVER_ID;
1374
1375 return( status );
1376#endif /* PSA_CRYPTO_DRIVER_TEST */
1377#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1378 default:
1379 /* Key is declared with a lifetime not known to us */
1380 (void)status;
1381 (void)operation;
1382 (void)key_buffer;
1383 (void)key_buffer_size;
1384 (void)alg;
1385 return( PSA_ERROR_INVALID_ARGUMENT );
1386 }
1387}
1388
1389static inline psa_status_t psa_driver_wrapper_cipher_set_iv(
1390 psa_cipher_operation_t *operation,
1391 const uint8_t *iv,
1392 size_t iv_length )
1393{
1394 switch( operation->id )
1395 {
1396#if defined(MBEDTLS_PSA_BUILTIN_CIPHER)
1397 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
1398 return( mbedtls_psa_cipher_set_iv( &operation->ctx.mbedtls_ctx,
1399 iv,
1400 iv_length ) );
1401#endif /* MBEDTLS_PSA_BUILTIN_CIPHER */
1402
1403#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1404#if defined(PSA_CRYPTO_DRIVER_TEST)
1405 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
1406 return( mbedtls_test_transparent_cipher_set_iv(
1407 &operation->ctx.transparent_test_driver_ctx,
1408 iv, iv_length ) );
1409
1410 case MBEDTLS_TEST_OPAQUE_DRIVER_ID:
1411 return( mbedtls_test_opaque_cipher_set_iv(
1412 &operation->ctx.opaque_test_driver_ctx,
1413 iv, iv_length ) );
1414#endif /* PSA_CRYPTO_DRIVER_TEST */
1415#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1416 }
1417
1418 (void)iv;
1419 (void)iv_length;
1420
1421 return( PSA_ERROR_INVALID_ARGUMENT );
1422}
1423
1424static inline psa_status_t psa_driver_wrapper_cipher_update(
1425 psa_cipher_operation_t *operation,
1426 const uint8_t *input,
1427 size_t input_length,
1428 uint8_t *output,
1429 size_t output_size,
1430 size_t *output_length )
1431{
1432 switch( operation->id )
1433 {
1434#if defined(MBEDTLS_PSA_BUILTIN_CIPHER)
1435 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
1436 return( mbedtls_psa_cipher_update( &operation->ctx.mbedtls_ctx,
1437 input,
1438 input_length,
1439 output,
1440 output_size,
1441 output_length ) );
1442#endif /* MBEDTLS_PSA_BUILTIN_CIPHER */
1443
1444#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1445#if defined(PSA_CRYPTO_DRIVER_TEST)
1446 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
1447 return( mbedtls_test_transparent_cipher_update(
1448 &operation->ctx.transparent_test_driver_ctx,
1449 input, input_length,
1450 output, output_size, output_length ) );
1451
1452 case MBEDTLS_TEST_OPAQUE_DRIVER_ID:
1453 return( mbedtls_test_opaque_cipher_update(
1454 &operation->ctx.opaque_test_driver_ctx,
1455 input, input_length,
1456 output, output_size, output_length ) );
1457#endif /* PSA_CRYPTO_DRIVER_TEST */
1458#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1459 }
1460
1461 (void)input;
1462 (void)input_length;
1463 (void)output;
1464 (void)output_size;
1465 (void)output_length;
1466
1467 return( PSA_ERROR_INVALID_ARGUMENT );
1468}
1469
1470static inline psa_status_t psa_driver_wrapper_cipher_finish(
1471 psa_cipher_operation_t *operation,
1472 uint8_t *output,
1473 size_t output_size,
1474 size_t *output_length )
1475{
1476 switch( operation->id )
1477 {
1478#if defined(MBEDTLS_PSA_BUILTIN_CIPHER)
1479 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
1480 return( mbedtls_psa_cipher_finish( &operation->ctx.mbedtls_ctx,
1481 output,
1482 output_size,
1483 output_length ) );
1484#endif /* MBEDTLS_PSA_BUILTIN_CIPHER */
1485
1486#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1487#if defined(PSA_CRYPTO_DRIVER_TEST)
1488 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
1489 return( mbedtls_test_transparent_cipher_finish(
1490 &operation->ctx.transparent_test_driver_ctx,
1491 output, output_size, output_length ) );
1492
1493 case MBEDTLS_TEST_OPAQUE_DRIVER_ID:
1494 return( mbedtls_test_opaque_cipher_finish(
1495 &operation->ctx.opaque_test_driver_ctx,
1496 output, output_size, output_length ) );
1497#endif /* PSA_CRYPTO_DRIVER_TEST */
1498#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1499 }
1500
1501 (void)output;
1502 (void)output_size;
1503 (void)output_length;
1504
1505 return( PSA_ERROR_INVALID_ARGUMENT );
1506}
1507
1508static inline psa_status_t psa_driver_wrapper_cipher_abort(
1509 psa_cipher_operation_t *operation )
1510{
1511 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
1512
1513 switch( operation->id )
1514 {
1515#if defined(MBEDTLS_PSA_BUILTIN_CIPHER)
1516 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
1517 return( mbedtls_psa_cipher_abort( &operation->ctx.mbedtls_ctx ) );
1518#endif /* MBEDTLS_PSA_BUILTIN_CIPHER */
1519
1520#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1521#if defined(PSA_CRYPTO_DRIVER_TEST)
1522 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
1523 status = mbedtls_test_transparent_cipher_abort(
1524 &operation->ctx.transparent_test_driver_ctx );
1525 mbedtls_platform_zeroize(
1526 &operation->ctx.transparent_test_driver_ctx,
1527 sizeof( operation->ctx.transparent_test_driver_ctx ) );
1528 return( status );
1529
1530 case MBEDTLS_TEST_OPAQUE_DRIVER_ID:
1531 status = mbedtls_test_opaque_cipher_abort(
1532 &operation->ctx.opaque_test_driver_ctx );
1533 mbedtls_platform_zeroize(
1534 &operation->ctx.opaque_test_driver_ctx,
1535 sizeof( operation->ctx.opaque_test_driver_ctx ) );
1536 return( status );
1537#endif /* PSA_CRYPTO_DRIVER_TEST */
1538#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1539 }
1540
1541 (void)status;
1542 return( PSA_ERROR_INVALID_ARGUMENT );
1543}
1544
1545/*
1546 * Hashing functions
1547 */
1548static inline psa_status_t psa_driver_wrapper_hash_compute(
1549 psa_algorithm_t alg,
1550 const uint8_t *input,
1551 size_t input_length,
1552 uint8_t *hash,
1553 size_t hash_size,
1554 size_t *hash_length)
1555{
1556 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
1557
1558 /* Try accelerators first */
1559#if defined(PSA_CRYPTO_DRIVER_TEST)
1560 status = mbedtls_test_transparent_hash_compute(
1561 alg, input, input_length, hash, hash_size, hash_length );
1562 if( status != PSA_ERROR_NOT_SUPPORTED )
1563 return( status );
1564#endif
1565
1566 /* If software fallback is compiled in, try fallback */
1567#if defined(MBEDTLS_PSA_BUILTIN_HASH)
1568 status = mbedtls_psa_hash_compute( alg, input, input_length,
1569 hash, hash_size, hash_length );
1570 if( status != PSA_ERROR_NOT_SUPPORTED )
1571 return( status );
1572#endif
1573 (void) status;
1574 (void) alg;
1575 (void) input;
1576 (void) input_length;
1577 (void) hash;
1578 (void) hash_size;
1579 (void) hash_length;
1580
1581 return( PSA_ERROR_NOT_SUPPORTED );
1582}
1583
1584static inline psa_status_t psa_driver_wrapper_hash_setup(
1585 psa_hash_operation_t *operation,
1586 psa_algorithm_t alg )
1587{
1588 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
1589
1590 /* Try setup on accelerators first */
1591#if defined(PSA_CRYPTO_DRIVER_TEST)
1592 status = mbedtls_test_transparent_hash_setup(
1593 &operation->ctx.test_driver_ctx, alg );
1594 if( status == PSA_SUCCESS )
1595 operation->id = MBEDTLS_TEST_TRANSPARENT_DRIVER_ID;
1596
1597 if( status != PSA_ERROR_NOT_SUPPORTED )
1598 return( status );
1599#endif
1600
1601 /* If software fallback is compiled in, try fallback */
1602#if defined(MBEDTLS_PSA_BUILTIN_HASH)
1603 status = mbedtls_psa_hash_setup( &operation->ctx.mbedtls_ctx, alg );
1604 if( status == PSA_SUCCESS )
1605 operation->id = PSA_CRYPTO_MBED_TLS_DRIVER_ID;
1606
1607 if( status != PSA_ERROR_NOT_SUPPORTED )
1608 return( status );
1609#endif
1610 /* Nothing left to try if we fall through here */
1611 (void) status;
1612 (void) operation;
1613 (void) alg;
1614 return( PSA_ERROR_NOT_SUPPORTED );
1615}
1616
1617static inline psa_status_t psa_driver_wrapper_hash_clone(
1618 const psa_hash_operation_t *source_operation,
1619 psa_hash_operation_t *target_operation )
1620{
1621 switch( source_operation->id )
1622 {
1623#if defined(MBEDTLS_PSA_BUILTIN_HASH)
1624 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
1625 target_operation->id = PSA_CRYPTO_MBED_TLS_DRIVER_ID;
1626 return( mbedtls_psa_hash_clone( &source_operation->ctx.mbedtls_ctx,
1627 &target_operation->ctx.mbedtls_ctx ) );
1628#endif
1629#if defined(PSA_CRYPTO_DRIVER_TEST)
1630 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
1631 target_operation->id = MBEDTLS_TEST_TRANSPARENT_DRIVER_ID;
1632 return( mbedtls_test_transparent_hash_clone(
1633 &source_operation->ctx.test_driver_ctx,
1634 &target_operation->ctx.test_driver_ctx ) );
1635#endif
1636 default:
1637 (void) target_operation;
1638 return( PSA_ERROR_BAD_STATE );
1639 }
1640}
1641
1642static inline psa_status_t psa_driver_wrapper_hash_update(
1643 psa_hash_operation_t *operation,
1644 const uint8_t *input,
1645 size_t input_length )
1646{
1647 switch( operation->id )
1648 {
1649#if defined(MBEDTLS_PSA_BUILTIN_HASH)
1650 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
1651 return( mbedtls_psa_hash_update( &operation->ctx.mbedtls_ctx,
1652 input, input_length ) );
1653#endif
1654#if defined(PSA_CRYPTO_DRIVER_TEST)
1655 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
1656 return( mbedtls_test_transparent_hash_update(
1657 &operation->ctx.test_driver_ctx,
1658 input, input_length ) );
1659#endif
1660 default:
1661 (void) input;
1662 (void) input_length;
1663 return( PSA_ERROR_BAD_STATE );
1664 }
1665}
1666
1667static inline psa_status_t psa_driver_wrapper_hash_finish(
1668 psa_hash_operation_t *operation,
1669 uint8_t *hash,
1670 size_t hash_size,
1671 size_t *hash_length )
1672{
1673 switch( operation->id )
1674 {
1675#if defined(MBEDTLS_PSA_BUILTIN_HASH)
1676 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
1677 return( mbedtls_psa_hash_finish( &operation->ctx.mbedtls_ctx,
1678 hash, hash_size, hash_length ) );
1679#endif
1680#if defined(PSA_CRYPTO_DRIVER_TEST)
1681 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
1682 return( mbedtls_test_transparent_hash_finish(
1683 &operation->ctx.test_driver_ctx,
1684 hash, hash_size, hash_length ) );
1685#endif
1686 default:
1687 (void) hash;
1688 (void) hash_size;
1689 (void) hash_length;
1690 return( PSA_ERROR_BAD_STATE );
1691 }
1692}
1693
1694static inline psa_status_t psa_driver_wrapper_hash_abort(
1695 psa_hash_operation_t *operation )
1696{
1697 switch( operation->id )
1698 {
1699#if defined(MBEDTLS_PSA_BUILTIN_HASH)
1700 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
1701 return( mbedtls_psa_hash_abort( &operation->ctx.mbedtls_ctx ) );
1702#endif
1703#if defined(PSA_CRYPTO_DRIVER_TEST)
1704 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
1705 return( mbedtls_test_transparent_hash_abort(
1706 &operation->ctx.test_driver_ctx ) );
1707#endif
1708 default:
1709 return( PSA_ERROR_BAD_STATE );
1710 }
1711}
1712
1713static inline psa_status_t psa_driver_wrapper_aead_encrypt(
1714 const psa_key_attributes_t *attributes,
1715 const uint8_t *key_buffer, size_t key_buffer_size,
1716 psa_algorithm_t alg,
1717 const uint8_t *nonce, size_t nonce_length,
1718 const uint8_t *additional_data, size_t additional_data_length,
1719 const uint8_t *plaintext, size_t plaintext_length,
1720 uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length )
1721{
1722 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
1723 psa_key_location_t location =
1724 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
1725
1726 switch( location )
1727 {
1728 case PSA_KEY_LOCATION_LOCAL_STORAGE:
1729 /* Key is stored in the slot in export representation, so
1730 * cycle through all known transparent accelerators */
1731
1732#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1733#if defined(PSA_CRYPTO_DRIVER_TEST)
1734 status = mbedtls_test_transparent_aead_encrypt(
1735 attributes, key_buffer, key_buffer_size,
1736 alg,
1737 nonce, nonce_length,
1738 additional_data, additional_data_length,
1739 plaintext, plaintext_length,
1740 ciphertext, ciphertext_size, ciphertext_length );
1741 /* Declared with fallback == true */
1742 if( status != PSA_ERROR_NOT_SUPPORTED )
1743 return( status );
1744#endif /* PSA_CRYPTO_DRIVER_TEST */
1745#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1746
1747 /* Fell through, meaning no accelerator supports this operation */
1748 return( mbedtls_psa_aead_encrypt(
1749 attributes, key_buffer, key_buffer_size,
1750 alg,
1751 nonce, nonce_length,
1752 additional_data, additional_data_length,
1753 plaintext, plaintext_length,
1754 ciphertext, ciphertext_size, ciphertext_length ) );
1755
1756 /* Add cases for opaque driver here */
1757
1758 default:
1759 /* Key is declared with a lifetime not known to us */
1760 (void)status;
1761 return( PSA_ERROR_INVALID_ARGUMENT );
1762 }
1763}
1764
1765static inline psa_status_t psa_driver_wrapper_aead_decrypt(
1766 const psa_key_attributes_t *attributes,
1767 const uint8_t *key_buffer, size_t key_buffer_size,
1768 psa_algorithm_t alg,
1769 const uint8_t *nonce, size_t nonce_length,
1770 const uint8_t *additional_data, size_t additional_data_length,
1771 const uint8_t *ciphertext, size_t ciphertext_length,
1772 uint8_t *plaintext, size_t plaintext_size, size_t *plaintext_length )
1773{
1774 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
1775 psa_key_location_t location =
1776 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
1777
1778 switch( location )
1779 {
1780 case PSA_KEY_LOCATION_LOCAL_STORAGE:
1781 /* Key is stored in the slot in export representation, so
1782 * cycle through all known transparent accelerators */
1783
1784#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1785#if defined(PSA_CRYPTO_DRIVER_TEST)
1786 status = mbedtls_test_transparent_aead_decrypt(
1787 attributes, key_buffer, key_buffer_size,
1788 alg,
1789 nonce, nonce_length,
1790 additional_data, additional_data_length,
1791 ciphertext, ciphertext_length,
1792 plaintext, plaintext_size, plaintext_length );
1793 /* Declared with fallback == true */
1794 if( status != PSA_ERROR_NOT_SUPPORTED )
1795 return( status );
1796#endif /* PSA_CRYPTO_DRIVER_TEST */
1797#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1798
1799 /* Fell through, meaning no accelerator supports this operation */
1800 return( mbedtls_psa_aead_decrypt(
1801 attributes, key_buffer, key_buffer_size,
1802 alg,
1803 nonce, nonce_length,
1804 additional_data, additional_data_length,
1805 ciphertext, ciphertext_length,
1806 plaintext, plaintext_size, plaintext_length ) );
1807
1808 /* Add cases for opaque driver here */
1809
1810 default:
1811 /* Key is declared with a lifetime not known to us */
1812 (void)status;
1813 return( PSA_ERROR_INVALID_ARGUMENT );
1814 }
1815}
1816
1817static inline psa_status_t psa_driver_wrapper_aead_encrypt_setup(
1818 psa_aead_operation_t *operation,
1819 const psa_key_attributes_t *attributes,
1820 const uint8_t *key_buffer, size_t key_buffer_size,
1821 psa_algorithm_t alg )
1822{
1823 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
1824 psa_key_location_t location =
1825 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
1826
1827 switch( location )
1828 {
1829 case PSA_KEY_LOCATION_LOCAL_STORAGE:
1830 /* Key is stored in the slot in export representation, so
1831 * cycle through all known transparent accelerators */
1832
1833#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1834#if defined(PSA_CRYPTO_DRIVER_TEST)
1835 operation->id = MBEDTLS_TEST_TRANSPARENT_DRIVER_ID;
1836 status = mbedtls_test_transparent_aead_encrypt_setup(
1837 &operation->ctx.transparent_test_driver_ctx,
1838 attributes, key_buffer, key_buffer_size,
1839 alg );
1840
1841 /* Declared with fallback == true */
1842 if( status != PSA_ERROR_NOT_SUPPORTED )
1843 return( status );
1844#endif /* PSA_CRYPTO_DRIVER_TEST */
1845#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1846
1847 /* Fell through, meaning no accelerator supports this operation */
1848 operation->id = PSA_CRYPTO_MBED_TLS_DRIVER_ID;
1849 status = mbedtls_psa_aead_encrypt_setup(
1850 &operation->ctx.mbedtls_ctx, attributes,
1851 key_buffer, key_buffer_size,
1852 alg );
1853
1854 return( status );
1855
1856 /* Add cases for opaque driver here */
1857
1858 default:
1859 /* Key is declared with a lifetime not known to us */
1860 (void)status;
1861 return( PSA_ERROR_INVALID_ARGUMENT );
1862 }
1863}
1864
1865static inline psa_status_t psa_driver_wrapper_aead_decrypt_setup(
1866 psa_aead_operation_t *operation,
1867 const psa_key_attributes_t *attributes,
1868 const uint8_t *key_buffer, size_t key_buffer_size,
1869 psa_algorithm_t alg )
1870{
1871 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
1872 psa_key_location_t location =
1873 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
1874
1875 switch( location )
1876 {
1877 case PSA_KEY_LOCATION_LOCAL_STORAGE:
1878 /* Key is stored in the slot in export representation, so
1879 * cycle through all known transparent accelerators */
1880
1881#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1882#if defined(PSA_CRYPTO_DRIVER_TEST)
1883 operation->id = MBEDTLS_TEST_TRANSPARENT_DRIVER_ID;
1884 status = mbedtls_test_transparent_aead_decrypt_setup(
1885 &operation->ctx.transparent_test_driver_ctx,
1886 attributes,
1887 key_buffer, key_buffer_size,
1888 alg );
1889
1890 /* Declared with fallback == true */
1891 if( status != PSA_ERROR_NOT_SUPPORTED )
1892 return( status );
1893#endif /* PSA_CRYPTO_DRIVER_TEST */
1894#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1895
1896 /* Fell through, meaning no accelerator supports this operation */
1897 operation->id = PSA_CRYPTO_MBED_TLS_DRIVER_ID;
1898 status = mbedtls_psa_aead_decrypt_setup(
1899 &operation->ctx.mbedtls_ctx,
1900 attributes,
1901 key_buffer, key_buffer_size,
1902 alg );
1903
1904 return( status );
1905
1906 /* Add cases for opaque driver here */
1907
1908 default:
1909 /* Key is declared with a lifetime not known to us */
1910 (void)status;
1911 return( PSA_ERROR_INVALID_ARGUMENT );
1912 }
1913}
1914
1915static inline psa_status_t psa_driver_wrapper_aead_set_nonce(
1916 psa_aead_operation_t *operation,
1917 const uint8_t *nonce,
1918 size_t nonce_length )
1919{
1920 switch( operation->id )
1921 {
1922#if defined(MBEDTLS_PSA_BUILTIN_AEAD)
1923 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
1924 return( mbedtls_psa_aead_set_nonce( &operation->ctx.mbedtls_ctx,
1925 nonce,
1926 nonce_length ) );
1927
1928#endif /* MBEDTLS_PSA_BUILTIN_AEAD */
1929
1930#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1931#if defined(PSA_CRYPTO_DRIVER_TEST)
1932 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
1933 return( mbedtls_test_transparent_aead_set_nonce(
1934 &operation->ctx.transparent_test_driver_ctx,
1935 nonce, nonce_length ) );
1936
1937 /* Add cases for opaque driver here */
1938
1939#endif /* PSA_CRYPTO_DRIVER_TEST */
1940#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1941 }
1942
1943 (void)nonce;
1944 (void)nonce_length;
1945
1946 return( PSA_ERROR_INVALID_ARGUMENT );
1947}
1948
1949static inline psa_status_t psa_driver_wrapper_aead_set_lengths(
1950 psa_aead_operation_t *operation,
1951 size_t ad_length,
1952 size_t plaintext_length )
1953{
1954 switch( operation->id )
1955 {
1956#if defined(MBEDTLS_PSA_BUILTIN_AEAD)
1957 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
1958 return( mbedtls_psa_aead_set_lengths( &operation->ctx.mbedtls_ctx,
1959 ad_length,
1960 plaintext_length ) );
1961
1962#endif /* MBEDTLS_PSA_BUILTIN_AEAD */
1963
1964#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1965#if defined(PSA_CRYPTO_DRIVER_TEST)
1966 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
1967 return( mbedtls_test_transparent_aead_set_lengths(
1968 &operation->ctx.transparent_test_driver_ctx,
1969 ad_length, plaintext_length ) );
1970
1971 /* Add cases for opaque driver here */
1972
1973#endif /* PSA_CRYPTO_DRIVER_TEST */
1974#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
1975 }
1976
1977 (void)ad_length;
1978 (void)plaintext_length;
1979
1980 return( PSA_ERROR_INVALID_ARGUMENT );
1981}
1982
1983static inline psa_status_t psa_driver_wrapper_aead_update_ad(
1984 psa_aead_operation_t *operation,
1985 const uint8_t *input,
1986 size_t input_length )
1987{
1988 switch( operation->id )
1989 {
1990#if defined(MBEDTLS_PSA_BUILTIN_AEAD)
1991 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
1992 return( mbedtls_psa_aead_update_ad( &operation->ctx.mbedtls_ctx,
1993 input,
1994 input_length ) );
1995
1996#endif /* MBEDTLS_PSA_BUILTIN_AEAD */
1997
1998#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
1999#if defined(PSA_CRYPTO_DRIVER_TEST)
2000 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
2001 return( mbedtls_test_transparent_aead_update_ad(
2002 &operation->ctx.transparent_test_driver_ctx,
2003 input, input_length ) );
2004
2005 /* Add cases for opaque driver here */
2006
2007#endif /* PSA_CRYPTO_DRIVER_TEST */
2008#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2009 }
2010
2011 (void)input;
2012 (void)input_length;
2013
2014 return( PSA_ERROR_INVALID_ARGUMENT );
2015}
2016
2017static inline psa_status_t psa_driver_wrapper_aead_update(
2018 psa_aead_operation_t *operation,
2019 const uint8_t *input,
2020 size_t input_length,
2021 uint8_t *output,
2022 size_t output_size,
2023 size_t *output_length )
2024{
2025 switch( operation->id )
2026 {
2027#if defined(MBEDTLS_PSA_BUILTIN_AEAD)
2028 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
2029 return( mbedtls_psa_aead_update( &operation->ctx.mbedtls_ctx,
2030 input, input_length,
2031 output, output_size,
2032 output_length ) );
2033
2034#endif /* MBEDTLS_PSA_BUILTIN_AEAD */
2035
2036#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2037#if defined(PSA_CRYPTO_DRIVER_TEST)
2038 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
2039 return( mbedtls_test_transparent_aead_update(
2040 &operation->ctx.transparent_test_driver_ctx,
2041 input, input_length, output, output_size,
2042 output_length ) );
2043
2044 /* Add cases for opaque driver here */
2045
2046#endif /* PSA_CRYPTO_DRIVER_TEST */
2047#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2048 }
2049
2050 (void)input;
2051 (void)input_length;
2052 (void)output;
2053 (void)output_size;
2054 (void)output_length;
2055
2056 return( PSA_ERROR_INVALID_ARGUMENT );
2057}
2058
2059static inline psa_status_t psa_driver_wrapper_aead_finish(
2060 psa_aead_operation_t *operation,
2061 uint8_t *ciphertext,
2062 size_t ciphertext_size,
2063 size_t *ciphertext_length,
2064 uint8_t *tag,
2065 size_t tag_size,
2066 size_t *tag_length )
2067{
2068 switch( operation->id )
2069 {
2070#if defined(MBEDTLS_PSA_BUILTIN_AEAD)
2071 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
2072 return( mbedtls_psa_aead_finish( &operation->ctx.mbedtls_ctx,
2073 ciphertext,
2074 ciphertext_size,
2075 ciphertext_length, tag,
2076 tag_size, tag_length ) );
2077
2078#endif /* MBEDTLS_PSA_BUILTIN_AEAD */
2079
2080#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2081#if defined(PSA_CRYPTO_DRIVER_TEST)
2082 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
2083 return( mbedtls_test_transparent_aead_finish(
2084 &operation->ctx.transparent_test_driver_ctx,
2085 ciphertext, ciphertext_size,
2086 ciphertext_length, tag, tag_size, tag_length ) );
2087
2088 /* Add cases for opaque driver here */
2089
2090#endif /* PSA_CRYPTO_DRIVER_TEST */
2091#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2092 }
2093
2094 (void)ciphertext;
2095 (void)ciphertext_size;
2096 (void)ciphertext_length;
2097 (void)tag;
2098 (void)tag_size;
2099 (void)tag_length;
2100
2101 return( PSA_ERROR_INVALID_ARGUMENT );
2102}
2103
2104static inline psa_status_t psa_driver_wrapper_aead_verify(
2105 psa_aead_operation_t *operation,
2106 uint8_t *plaintext,
2107 size_t plaintext_size,
2108 size_t *plaintext_length,
2109 const uint8_t *tag,
2110 size_t tag_length )
2111{
2112 switch( operation->id )
2113 {
2114#if defined(MBEDTLS_PSA_BUILTIN_AEAD)
2115 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
2116 {
2117 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
2118 uint8_t check_tag[PSA_AEAD_TAG_MAX_SIZE];
2119 size_t check_tag_length;
2120
2121 status = mbedtls_psa_aead_finish( &operation->ctx.mbedtls_ctx,
2122 plaintext,
2123 plaintext_size,
2124 plaintext_length,
2125 check_tag,
2126 sizeof( check_tag ),
2127 &check_tag_length );
2128
2129 if( status == PSA_SUCCESS )
2130 {
2131 if( tag_length != check_tag_length ||
2132 mbedtls_ct_memcmp( tag, check_tag, tag_length )
2133 != 0 )
2134 status = PSA_ERROR_INVALID_SIGNATURE;
2135 }
2136
2137 mbedtls_platform_zeroize( check_tag, sizeof( check_tag ) );
2138
2139 return( status );
2140 }
2141
2142#endif /* MBEDTLS_PSA_BUILTIN_AEAD */
2143
2144#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2145#if defined(PSA_CRYPTO_DRIVER_TEST)
2146 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
2147 return( mbedtls_test_transparent_aead_verify(
2148 &operation->ctx.transparent_test_driver_ctx,
2149 plaintext, plaintext_size,
2150 plaintext_length, tag, tag_length ) );
2151
2152 /* Add cases for opaque driver here */
2153
2154#endif /* PSA_CRYPTO_DRIVER_TEST */
2155#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2156 }
2157
2158 (void)plaintext;
2159 (void)plaintext_size;
2160 (void)plaintext_length;
2161 (void)tag;
2162 (void)tag_length;
2163
2164 return( PSA_ERROR_INVALID_ARGUMENT );
2165}
2166
2167static inline psa_status_t psa_driver_wrapper_aead_abort(
2168 psa_aead_operation_t *operation )
2169{
2170 switch( operation->id )
2171 {
2172#if defined(MBEDTLS_PSA_BUILTIN_AEAD)
2173 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
2174 return( mbedtls_psa_aead_abort( &operation->ctx.mbedtls_ctx ) );
2175
2176#endif /* MBEDTLS_PSA_BUILTIN_AEAD */
2177
2178#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2179#if defined(PSA_CRYPTO_DRIVER_TEST)
2180 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
2181 return( mbedtls_test_transparent_aead_abort(
2182 &operation->ctx.transparent_test_driver_ctx ) );
2183
2184 /* Add cases for opaque driver here */
2185
2186#endif /* PSA_CRYPTO_DRIVER_TEST */
2187#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2188 }
2189
2190 return( PSA_ERROR_INVALID_ARGUMENT );
2191}
2192
2193/*
2194 * MAC functions
2195 */
2196static inline psa_status_t psa_driver_wrapper_mac_compute(
2197 const psa_key_attributes_t *attributes,
2198 const uint8_t *key_buffer,
2199 size_t key_buffer_size,
2200 psa_algorithm_t alg,
2201 const uint8_t *input,
2202 size_t input_length,
2203 uint8_t *mac,
2204 size_t mac_size,
2205 size_t *mac_length )
2206{
2207 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
2208 psa_key_location_t location =
2209 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
2210
2211 switch( location )
2212 {
2213 case PSA_KEY_LOCATION_LOCAL_STORAGE:
2214 /* Key is stored in the slot in export representation, so
2215 * cycle through all known transparent accelerators */
2216#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2217#if defined(PSA_CRYPTO_DRIVER_TEST)
2218 status = mbedtls_test_transparent_mac_compute(
2219 attributes, key_buffer, key_buffer_size, alg,
2220 input, input_length,
2221 mac, mac_size, mac_length );
2222 /* Declared with fallback == true */
2223 if( status != PSA_ERROR_NOT_SUPPORTED )
2224 return( status );
2225#endif /* PSA_CRYPTO_DRIVER_TEST */
2226#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2227#if defined(MBEDTLS_PSA_BUILTIN_MAC)
2228 /* Fell through, meaning no accelerator supports this operation */
2229 status = mbedtls_psa_mac_compute(
2230 attributes, key_buffer, key_buffer_size, alg,
2231 input, input_length,
2232 mac, mac_size, mac_length );
2233 if( status != PSA_ERROR_NOT_SUPPORTED )
2234 return( status );
2235#endif /* MBEDTLS_PSA_BUILTIN_MAC */
2236 return( PSA_ERROR_NOT_SUPPORTED );
2237
2238 /* Add cases for opaque driver here */
2239#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2240#if defined(PSA_CRYPTO_DRIVER_TEST)
2241 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
2242 status = mbedtls_test_opaque_mac_compute(
2243 attributes, key_buffer, key_buffer_size, alg,
2244 input, input_length,
2245 mac, mac_size, mac_length );
2246 return( status );
2247#endif /* PSA_CRYPTO_DRIVER_TEST */
2248#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2249 default:
2250 /* Key is declared with a lifetime not known to us */
2251 (void) key_buffer;
2252 (void) key_buffer_size;
2253 (void) alg;
2254 (void) input;
2255 (void) input_length;
2256 (void) mac;
2257 (void) mac_size;
2258 (void) mac_length;
2259 (void) status;
2260 return( PSA_ERROR_INVALID_ARGUMENT );
2261 }
2262}
2263
2264static inline psa_status_t psa_driver_wrapper_mac_sign_setup(
2265 psa_mac_operation_t *operation,
2266 const psa_key_attributes_t *attributes,
2267 const uint8_t *key_buffer,
2268 size_t key_buffer_size,
2269 psa_algorithm_t alg )
2270{
2271 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
2272 psa_key_location_t location =
2273 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
2274
2275 switch( location )
2276 {
2277 case PSA_KEY_LOCATION_LOCAL_STORAGE:
2278 /* Key is stored in the slot in export representation, so
2279 * cycle through all known transparent accelerators */
2280#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2281#if defined(PSA_CRYPTO_DRIVER_TEST)
2282 status = mbedtls_test_transparent_mac_sign_setup(
2283 &operation->ctx.transparent_test_driver_ctx,
2284 attributes,
2285 key_buffer, key_buffer_size,
2286 alg );
2287 /* Declared with fallback == true */
2288 if( status == PSA_SUCCESS )
2289 operation->id = MBEDTLS_TEST_TRANSPARENT_DRIVER_ID;
2290
2291 if( status != PSA_ERROR_NOT_SUPPORTED )
2292 return( status );
2293#endif /* PSA_CRYPTO_DRIVER_TEST */
2294#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2295#if defined(MBEDTLS_PSA_BUILTIN_MAC)
2296 /* Fell through, meaning no accelerator supports this operation */
2297 status = mbedtls_psa_mac_sign_setup( &operation->ctx.mbedtls_ctx,
2298 attributes,
2299 key_buffer, key_buffer_size,
2300 alg );
2301 if( status == PSA_SUCCESS )
2302 operation->id = PSA_CRYPTO_MBED_TLS_DRIVER_ID;
2303
2304 if( status != PSA_ERROR_NOT_SUPPORTED )
2305 return( status );
2306#endif /* MBEDTLS_PSA_BUILTIN_MAC */
2307 return( PSA_ERROR_NOT_SUPPORTED );
2308
2309 /* Add cases for opaque driver here */
2310#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2311#if defined(PSA_CRYPTO_DRIVER_TEST)
2312 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
2313 status = mbedtls_test_opaque_mac_sign_setup(
2314 &operation->ctx.opaque_test_driver_ctx,
2315 attributes,
2316 key_buffer, key_buffer_size,
2317 alg );
2318
2319 if( status == PSA_SUCCESS )
2320 operation->id = MBEDTLS_TEST_OPAQUE_DRIVER_ID;
2321
2322 return( status );
2323#endif /* PSA_CRYPTO_DRIVER_TEST */
2324#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2325 default:
2326 /* Key is declared with a lifetime not known to us */
2327 (void) status;
2328 (void) operation;
2329 (void) key_buffer;
2330 (void) key_buffer_size;
2331 (void) alg;
2332 return( PSA_ERROR_INVALID_ARGUMENT );
2333 }
2334}
2335
2336static inline psa_status_t psa_driver_wrapper_mac_verify_setup(
2337 psa_mac_operation_t *operation,
2338 const psa_key_attributes_t *attributes,
2339 const uint8_t *key_buffer,
2340 size_t key_buffer_size,
2341 psa_algorithm_t alg )
2342{
2343 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
2344 psa_key_location_t location =
2345 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
2346
2347 switch( location )
2348 {
2349 case PSA_KEY_LOCATION_LOCAL_STORAGE:
2350 /* Key is stored in the slot in export representation, so
2351 * cycle through all known transparent accelerators */
2352#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2353#if defined(PSA_CRYPTO_DRIVER_TEST)
2354 status = mbedtls_test_transparent_mac_verify_setup(
2355 &operation->ctx.transparent_test_driver_ctx,
2356 attributes,
2357 key_buffer, key_buffer_size,
2358 alg );
2359 /* Declared with fallback == true */
2360 if( status == PSA_SUCCESS )
2361 operation->id = MBEDTLS_TEST_TRANSPARENT_DRIVER_ID;
2362
2363 if( status != PSA_ERROR_NOT_SUPPORTED )
2364 return( status );
2365#endif /* PSA_CRYPTO_DRIVER_TEST */
2366#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2367#if defined(MBEDTLS_PSA_BUILTIN_MAC)
2368 /* Fell through, meaning no accelerator supports this operation */
2369 status = mbedtls_psa_mac_verify_setup( &operation->ctx.mbedtls_ctx,
2370 attributes,
2371 key_buffer, key_buffer_size,
2372 alg );
2373 if( status == PSA_SUCCESS )
2374 operation->id = PSA_CRYPTO_MBED_TLS_DRIVER_ID;
2375
2376 if( status != PSA_ERROR_NOT_SUPPORTED )
2377 return( status );
2378#endif /* MBEDTLS_PSA_BUILTIN_MAC */
2379 return( PSA_ERROR_NOT_SUPPORTED );
2380
2381 /* Add cases for opaque driver here */
2382#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2383#if defined(PSA_CRYPTO_DRIVER_TEST)
2384 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
2385 status = mbedtls_test_opaque_mac_verify_setup(
2386 &operation->ctx.opaque_test_driver_ctx,
2387 attributes,
2388 key_buffer, key_buffer_size,
2389 alg );
2390
2391 if( status == PSA_SUCCESS )
2392 operation->id = MBEDTLS_TEST_OPAQUE_DRIVER_ID;
2393
2394 return( status );
2395#endif /* PSA_CRYPTO_DRIVER_TEST */
2396#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2397 default:
2398 /* Key is declared with a lifetime not known to us */
2399 (void) status;
2400 (void) operation;
2401 (void) key_buffer;
2402 (void) key_buffer_size;
2403 (void) alg;
2404 return( PSA_ERROR_INVALID_ARGUMENT );
2405 }
2406}
2407
2408static inline psa_status_t psa_driver_wrapper_mac_update(
2409 psa_mac_operation_t *operation,
2410 const uint8_t *input,
2411 size_t input_length )
2412{
2413 switch( operation->id )
2414 {
2415#if defined(MBEDTLS_PSA_BUILTIN_MAC)
2416 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
2417 return( mbedtls_psa_mac_update( &operation->ctx.mbedtls_ctx,
2418 input, input_length ) );
2419#endif /* MBEDTLS_PSA_BUILTIN_MAC */
2420
2421#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2422#if defined(PSA_CRYPTO_DRIVER_TEST)
2423 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
2424 return( mbedtls_test_transparent_mac_update(
2425 &operation->ctx.transparent_test_driver_ctx,
2426 input, input_length ) );
2427
2428 case MBEDTLS_TEST_OPAQUE_DRIVER_ID:
2429 return( mbedtls_test_opaque_mac_update(
2430 &operation->ctx.opaque_test_driver_ctx,
2431 input, input_length ) );
2432#endif /* PSA_CRYPTO_DRIVER_TEST */
2433#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2434 default:
2435 (void) input;
2436 (void) input_length;
2437 return( PSA_ERROR_INVALID_ARGUMENT );
2438 }
2439}
2440
2441static inline psa_status_t psa_driver_wrapper_mac_sign_finish(
2442 psa_mac_operation_t *operation,
2443 uint8_t *mac,
2444 size_t mac_size,
2445 size_t *mac_length )
2446{
2447 switch( operation->id )
2448 {
2449#if defined(MBEDTLS_PSA_BUILTIN_MAC)
2450 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
2451 return( mbedtls_psa_mac_sign_finish( &operation->ctx.mbedtls_ctx,
2452 mac, mac_size, mac_length ) );
2453#endif /* MBEDTLS_PSA_BUILTIN_MAC */
2454
2455#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2456#if defined(PSA_CRYPTO_DRIVER_TEST)
2457 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
2458 return( mbedtls_test_transparent_mac_sign_finish(
2459 &operation->ctx.transparent_test_driver_ctx,
2460 mac, mac_size, mac_length ) );
2461
2462 case MBEDTLS_TEST_OPAQUE_DRIVER_ID:
2463 return( mbedtls_test_opaque_mac_sign_finish(
2464 &operation->ctx.opaque_test_driver_ctx,
2465 mac, mac_size, mac_length ) );
2466#endif /* PSA_CRYPTO_DRIVER_TEST */
2467#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2468 default:
2469 (void) mac;
2470 (void) mac_size;
2471 (void) mac_length;
2472 return( PSA_ERROR_INVALID_ARGUMENT );
2473 }
2474}
2475
2476static inline psa_status_t psa_driver_wrapper_mac_verify_finish(
2477 psa_mac_operation_t *operation,
2478 const uint8_t *mac,
2479 size_t mac_length )
2480{
2481 switch( operation->id )
2482 {
2483#if defined(MBEDTLS_PSA_BUILTIN_MAC)
2484 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
2485 return( mbedtls_psa_mac_verify_finish( &operation->ctx.mbedtls_ctx,
2486 mac, mac_length ) );
2487#endif /* MBEDTLS_PSA_BUILTIN_MAC */
2488
2489#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2490#if defined(PSA_CRYPTO_DRIVER_TEST)
2491 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
2492 return( mbedtls_test_transparent_mac_verify_finish(
2493 &operation->ctx.transparent_test_driver_ctx,
2494 mac, mac_length ) );
2495
2496 case MBEDTLS_TEST_OPAQUE_DRIVER_ID:
2497 return( mbedtls_test_opaque_mac_verify_finish(
2498 &operation->ctx.opaque_test_driver_ctx,
2499 mac, mac_length ) );
2500#endif /* PSA_CRYPTO_DRIVER_TEST */
2501#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2502 default:
2503 (void) mac;
2504 (void) mac_length;
2505 return( PSA_ERROR_INVALID_ARGUMENT );
2506 }
2507}
2508
2509static inline psa_status_t psa_driver_wrapper_mac_abort(
2510 psa_mac_operation_t *operation )
2511{
2512 switch( operation->id )
2513 {
2514#if defined(MBEDTLS_PSA_BUILTIN_MAC)
2515 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
2516 return( mbedtls_psa_mac_abort( &operation->ctx.mbedtls_ctx ) );
2517#endif /* MBEDTLS_PSA_BUILTIN_MAC */
2518
2519#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2520#if defined(PSA_CRYPTO_DRIVER_TEST)
2521 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
2522 return( mbedtls_test_transparent_mac_abort(
2523 &operation->ctx.transparent_test_driver_ctx ) );
2524 case MBEDTLS_TEST_OPAQUE_DRIVER_ID:
2525 return( mbedtls_test_opaque_mac_abort(
2526 &operation->ctx.opaque_test_driver_ctx ) );
2527#endif /* PSA_CRYPTO_DRIVER_TEST */
2528#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2529 default:
2530 return( PSA_ERROR_INVALID_ARGUMENT );
2531 }
2532}
2533
2534/*
2535 * Asymmetric cryptography
2536 */
2537static inline psa_status_t psa_driver_wrapper_asymmetric_encrypt(
2538 const psa_key_attributes_t *attributes, const uint8_t *key_buffer,
2539 size_t key_buffer_size, psa_algorithm_t alg, const uint8_t *input,
2540 size_t input_length, const uint8_t *salt, size_t salt_length,
2541 uint8_t *output, size_t output_size, size_t *output_length )
2542{
2543 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
2544 psa_key_location_t location =
2545 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
2546
2547 switch( location )
2548 {
2549 case PSA_KEY_LOCATION_LOCAL_STORAGE:
2550 /* Key is stored in the slot in export representation, so
2551 * cycle through all known transparent accelerators */
2552#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2553#if defined(PSA_CRYPTO_DRIVER_TEST)
2554 status = mbedtls_test_transparent_asymmetric_encrypt( attributes,
2555 key_buffer, key_buffer_size, alg, input, input_length,
2556 salt, salt_length, output, output_size,
2557 output_length );
2558 /* Declared with fallback == true */
2559 if( status != PSA_ERROR_NOT_SUPPORTED )
2560 return( status );
2561#endif /* PSA_CRYPTO_DRIVER_TEST */
2562#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2563 return( mbedtls_psa_asymmetric_encrypt( attributes,
2564 key_buffer, key_buffer_size, alg, input, input_length,
2565 salt, salt_length, output, output_size, output_length )
2566 );
2567 /* Add cases for opaque driver here */
2568#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2569#if defined(PSA_CRYPTO_DRIVER_TEST)
2570 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
2571 return( mbedtls_test_opaque_asymmetric_encrypt( attributes,
2572 key_buffer, key_buffer_size, alg, input, input_length,
2573 salt, salt_length, output, output_size, output_length )
2574 );
2575#endif /* PSA_CRYPTO_DRIVER_TEST */
2576#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2577
2578 default:
2579 /* Key is declared with a lifetime not known to us */
2580 (void)status;
2581 (void)key_buffer;
2582 (void)key_buffer_size;
2583 (void)alg;
2584 (void)input;
2585 (void)input_length;
2586 (void)salt;
2587 (void)salt_length;
2588 (void)output;
2589 (void)output_size;
2590 (void)output_length;
2591 return( PSA_ERROR_INVALID_ARGUMENT );
2592 }
2593}
2594
2595static inline psa_status_t psa_driver_wrapper_asymmetric_decrypt(
2596 const psa_key_attributes_t *attributes, const uint8_t *key_buffer,
2597 size_t key_buffer_size, psa_algorithm_t alg, const uint8_t *input,
2598 size_t input_length, const uint8_t *salt, size_t salt_length,
2599 uint8_t *output, size_t output_size, size_t *output_length )
2600{
2601 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
2602 psa_key_location_t location =
2603 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
2604
2605 switch( location )
2606 {
2607 case PSA_KEY_LOCATION_LOCAL_STORAGE:
2608 /* Key is stored in the slot in export representation, so
2609 * cycle through all known transparent accelerators */
2610#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2611#if defined(PSA_CRYPTO_DRIVER_TEST)
2612 status = mbedtls_test_transparent_asymmetric_decrypt( attributes,
2613 key_buffer, key_buffer_size, alg, input, input_length,
2614 salt, salt_length, output, output_size,
2615 output_length );
2616 /* Declared with fallback == true */
2617 if( status != PSA_ERROR_NOT_SUPPORTED )
2618 return( status );
2619#endif /* PSA_CRYPTO_DRIVER_TEST */
2620#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2621 return( mbedtls_psa_asymmetric_decrypt( attributes,
2622 key_buffer, key_buffer_size, alg,input, input_length,
2623 salt, salt_length, output, output_size,
2624 output_length ) );
2625 /* Add cases for opaque driver here */
2626#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2627#if defined(PSA_CRYPTO_DRIVER_TEST)
2628 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
2629 return( mbedtls_test_opaque_asymmetric_decrypt( attributes,
2630 key_buffer, key_buffer_size, alg, input, input_length,
2631 salt, salt_length, output, output_size,
2632 output_length ) );
2633#endif /* PSA_CRYPTO_DRIVER_TEST */
2634#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2635
2636 default:
2637 /* Key is declared with a lifetime not known to us */
2638 (void)status;
2639 (void)key_buffer;
2640 (void)key_buffer_size;
2641 (void)alg;
2642 (void)input;
2643 (void)input_length;
2644 (void)salt;
2645 (void)salt_length;
2646 (void)output;
2647 (void)output_size;
2648 (void)output_length;
2649 return( PSA_ERROR_INVALID_ARGUMENT );
2650 }
2651}
2652
2653static inline psa_status_t psa_driver_wrapper_key_agreement(
2654 const psa_key_attributes_t *attributes,
2655 const uint8_t *key_buffer,
2656 size_t key_buffer_size,
2657 psa_algorithm_t alg,
2658 const uint8_t *peer_key,
2659 size_t peer_key_length,
2660 uint8_t *shared_secret,
2661 size_t shared_secret_size,
2662 size_t *shared_secret_length
2663 )
2664{
2665 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
2666 psa_key_location_t location =
2667 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime(attributes) );
2668
2669 switch( location )
2670 {
2671 case PSA_KEY_LOCATION_LOCAL_STORAGE:
2672 /* Key is stored in the slot in export representation, so
2673 * cycle through all known transparent accelerators */
2674#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2675#if defined(PSA_CRYPTO_DRIVER_TEST)
2676 status =
2677 mbedtls_test_transparent_key_agreement( attributes,
2678 key_buffer, key_buffer_size, alg, peer_key,
2679 peer_key_length, shared_secret, shared_secret_size,
2680 shared_secret_length );
2681 if( status != PSA_ERROR_NOT_SUPPORTED )
2682 return( status );
2683#endif /* PSA_CRYPTO_DRIVER_TEST */
2684#if defined(MBEDTLS_PSA_P256M_DRIVER_ENABLED)
2685 if( PSA_KEY_TYPE_IS_ECC( psa_get_key_type(attributes) ) &&
2686 PSA_ALG_IS_ECDH(alg) &&
2687 PSA_KEY_TYPE_ECC_GET_FAMILY(psa_get_key_type(attributes)) == PSA_ECC_FAMILY_SECP_R1 &&
2688 psa_get_key_bits(attributes) == 256 )
2689 {
2690 status = p256_transparent_key_agreement( attributes,
2691 key_buffer,
2692 key_buffer_size,
2693 alg,
2694 peer_key,
2695 peer_key_length,
2696 shared_secret,
2697 shared_secret_size,
2698 shared_secret_length );
2699 if( status != PSA_ERROR_NOT_SUPPORTED)
2700 return( status );
2701 }
2702#endif /* MBEDTLS_PSA_P256M_DRIVER_ENABLED */
2703#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2704
2705 /* Software Fallback */
2706 status = psa_key_agreement_raw_builtin( attributes,
2707 key_buffer,
2708 key_buffer_size,
2709 alg,
2710 peer_key,
2711 peer_key_length,
2712 shared_secret,
2713 shared_secret_size,
2714 shared_secret_length );
2715 return( status );
2716#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2717#if defined(PSA_CRYPTO_DRIVER_TEST)
2718 case PSA_CRYPTO_TEST_DRIVER_LOCATION:
2719 return( mbedtls_test_opaque_key_agreement( attributes,
2720 key_buffer, key_buffer_size, alg, peer_key,
2721 peer_key_length, shared_secret, shared_secret_size,
2722 shared_secret_length ) );
2723#endif /* PSA_CRYPTO_DRIVER_TEST */
2724#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2725
2726 default:
2727 (void) attributes;
2728 (void) key_buffer;
2729 (void) key_buffer_size;
2730 (void) peer_key;
2731 (void) peer_key_length;
2732 (void) shared_secret;
2733 (void) shared_secret_size;
2734 (void) shared_secret_length;
2735 return( PSA_ERROR_NOT_SUPPORTED );
2736
2737 }
2738}
2739
2740static inline psa_status_t psa_driver_wrapper_pake_setup(
2741 psa_pake_operation_t *operation,
2742 const psa_crypto_driver_pake_inputs_t *inputs )
2743{
2744 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
2745
2746 psa_key_location_t location =
2747 PSA_KEY_LIFETIME_GET_LOCATION( psa_get_key_lifetime( &inputs->attributes ) );
2748
2749 switch( location )
2750 {
2751 case PSA_KEY_LOCATION_LOCAL_STORAGE:
2752 /* Key is stored in the slot in export representation, so
2753 * cycle through all known transparent accelerators */
2754 status = PSA_ERROR_NOT_SUPPORTED;
2755#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2756#if defined(PSA_CRYPTO_DRIVER_TEST)
2757 status = mbedtls_test_transparent_pake_setup(
2758 &operation->data.ctx.transparent_test_driver_ctx,
2759 inputs );
2760 if( status == PSA_SUCCESS )
2761 operation->id = MBEDTLS_TEST_TRANSPARENT_DRIVER_ID;
2762 /* Declared with fallback == true */
2763 if( status != PSA_ERROR_NOT_SUPPORTED )
2764 return( status );
2765#endif /* PSA_CRYPTO_DRIVER_TEST */
2766#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2767#if defined(MBEDTLS_PSA_BUILTIN_PAKE)
2768 status = mbedtls_psa_pake_setup( &operation->data.ctx.mbedtls_ctx,
2769 inputs );
2770 if( status == PSA_SUCCESS )
2771 operation->id = PSA_CRYPTO_MBED_TLS_DRIVER_ID;
2772#endif
2773 return status;
2774 /* Add cases for opaque driver here */
2775 default:
2776 /* Key is declared with a lifetime not known to us */
2777 (void)operation;
2778 return( PSA_ERROR_INVALID_ARGUMENT );
2779 }
2780}
2781
2782static inline psa_status_t psa_driver_wrapper_pake_output(
2783 psa_pake_operation_t *operation,
2784 psa_crypto_driver_pake_step_t step,
2785 uint8_t *output,
2786 size_t output_size,
2787 size_t *output_length )
2788{
2789 switch( operation->id )
2790 {
2791#if defined(MBEDTLS_PSA_BUILTIN_PAKE)
2792 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
2793 return( mbedtls_psa_pake_output( &operation->data.ctx.mbedtls_ctx, step,
2794 output, output_size, output_length ) );
2795#endif /* MBEDTLS_PSA_BUILTIN_PAKE */
2796
2797#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2798#if defined(PSA_CRYPTO_DRIVER_TEST)
2799 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
2800 return( mbedtls_test_transparent_pake_output(
2801 &operation->data.ctx.transparent_test_driver_ctx,
2802 step, output, output_size, output_length ) );
2803#endif /* PSA_CRYPTO_DRIVER_TEST */
2804#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2805 default:
2806 (void) step;
2807 (void) output;
2808 (void) output_size;
2809 (void) output_length;
2810 return( PSA_ERROR_INVALID_ARGUMENT );
2811 }
2812}
2813
2814static inline psa_status_t psa_driver_wrapper_pake_input(
2815 psa_pake_operation_t *operation,
2816 psa_crypto_driver_pake_step_t step,
2817 const uint8_t *input,
2818 size_t input_length )
2819{
2820 switch( operation->id )
2821 {
2822#if defined(MBEDTLS_PSA_BUILTIN_PAKE)
2823 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
2824 return( mbedtls_psa_pake_input( &operation->data.ctx.mbedtls_ctx,
2825 step, input,
2826 input_length ) );
2827#endif /* MBEDTLS_PSA_BUILTIN_PAKE */
2828
2829#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2830#if defined(PSA_CRYPTO_DRIVER_TEST)
2831 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
2832 return( mbedtls_test_transparent_pake_input(
2833 &operation->data.ctx.transparent_test_driver_ctx,
2834 step,
2835 input, input_length ) );
2836#endif /* PSA_CRYPTO_DRIVER_TEST */
2837#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2838 default:
2839 (void) step;
2840 (void) input;
2841 (void) input_length;
2842 return( PSA_ERROR_INVALID_ARGUMENT );
2843 }
2844}
2845
2846static inline psa_status_t psa_driver_wrapper_pake_get_implicit_key(
2847 psa_pake_operation_t *operation,
2848 uint8_t *output, size_t output_size,
2849 size_t *output_length )
2850{
2851 switch( operation->id )
2852 {
2853#if defined(MBEDTLS_PSA_BUILTIN_PAKE)
2854 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
2855 return( mbedtls_psa_pake_get_implicit_key( &operation->data.ctx.mbedtls_ctx,
2856 output, output_size, output_length ) );
2857#endif /* MBEDTLS_PSA_BUILTIN_PAKE */
2858
2859#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2860#if defined(PSA_CRYPTO_DRIVER_TEST)
2861 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
2862 return( mbedtls_test_transparent_pake_get_implicit_key(
2863 &operation->data.ctx.transparent_test_driver_ctx,
2864 output, output_size, output_length ) );
2865#endif /* PSA_CRYPTO_DRIVER_TEST */
2866#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2867 default:
2868 (void) output;
2869 (void) output_size;
2870 (void) output_length;
2871 return( PSA_ERROR_INVALID_ARGUMENT );
2872 }
2873}
2874
2875static inline psa_status_t psa_driver_wrapper_pake_abort(
2876 psa_pake_operation_t * operation )
2877{
2878 switch( operation->id )
2879 {
2880#if defined(MBEDTLS_PSA_BUILTIN_PAKE)
2881 case PSA_CRYPTO_MBED_TLS_DRIVER_ID:
2882 return( mbedtls_psa_pake_abort( &operation->data.ctx.mbedtls_ctx ) );
2883#endif /* MBEDTLS_PSA_BUILTIN_PAKE */
2884
2885#if defined(PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT)
2886#if defined(PSA_CRYPTO_DRIVER_TEST)
2887 case MBEDTLS_TEST_TRANSPARENT_DRIVER_ID:
2888 return( mbedtls_test_transparent_pake_abort(
2889 &operation->data.ctx.transparent_test_driver_ctx ) );
2890#endif /* PSA_CRYPTO_DRIVER_TEST */
2891#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
2892 default:
2893 return( PSA_ERROR_INVALID_ARGUMENT );
2894 }
2895}
2896
2897#endif /* MBEDTLS_PSA_CRYPTO_C */