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 72 static 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 96 static 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 */ 111 static 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 186 static 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 257 static 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 361 static 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 462 static 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 486 static 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 511 static 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 556 static 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 583 static 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 602 static 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 649 static 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 670 static 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 */ 702 static 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 731 static 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 836 static 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 949 static 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 1014 static 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 */ 1069 static 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 1161 static 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 1243 static 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 1316 static 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 1389 static 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 1424 static 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 1470 static 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 1508 static 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 */ 1548 static 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 1584 static 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 1617 static 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 1642 static 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 1667 static 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 1694 static 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 1713 static 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 1765 static 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 1817 static 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 1865 static 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 1915 static 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 1949 static 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 1983 static 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 2017 static 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 2059 static 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 2104 static 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 2167 static 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 */ 2196 static 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 2264 static 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 2336 static 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 2408 static 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 2441 static 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 2476 static 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 2509 static 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 */ 2537 static 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 2595 static 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 2653 static 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 2740 static 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 2782 static 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 2814 static 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 2846 static 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 2875 static 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 */ 2898