1 // SPDX-License-Identifier: BSD-2-Clause 2 /* 3 * Copyright (c) 2017, Linaro Limited 4 */ 5 6 #include <assert.h> 7 #include <compiler.h> 8 #include <crypto/aes-ccm.h> 9 #include <crypto/aes-gcm.h> 10 #include <crypto/crypto.h> 11 #include <crypto/crypto_impl.h> 12 #include <kernel/panic.h> 13 #include <stdlib.h> 14 #include <string.h> 15 #include <utee_defines.h> 16 17 TEE_Result crypto_hash_alloc_ctx(void **ctx, uint32_t algo) 18 { 19 TEE_Result res = TEE_SUCCESS; 20 struct crypto_hash_ctx *c = NULL; 21 22 switch (algo) { 23 case TEE_ALG_MD5: 24 res = crypto_md5_alloc_ctx(&c); 25 break; 26 case TEE_ALG_SHA1: 27 res = crypto_sha1_alloc_ctx(&c); 28 break; 29 case TEE_ALG_SHA224: 30 res = crypto_sha224_alloc_ctx(&c); 31 break; 32 case TEE_ALG_SHA256: 33 res = crypto_sha256_alloc_ctx(&c); 34 break; 35 case TEE_ALG_SHA384: 36 res = crypto_sha384_alloc_ctx(&c); 37 break; 38 case TEE_ALG_SHA512: 39 res = crypto_sha512_alloc_ctx(&c); 40 break; 41 default: 42 return TEE_ERROR_NOT_IMPLEMENTED; 43 } 44 45 if (!res) 46 *ctx = c; 47 48 return res; 49 } 50 51 static const struct crypto_hash_ops *hash_ops(void *ctx) 52 { 53 struct crypto_hash_ctx *c = ctx; 54 55 assert(c && c->ops); 56 57 return c->ops; 58 } 59 60 void crypto_hash_free_ctx(void *ctx, uint32_t algo __unused) 61 { 62 if (ctx) 63 hash_ops(ctx)->free_ctx(ctx); 64 } 65 66 void crypto_hash_copy_state(void *dst_ctx, void *src_ctx, 67 uint32_t algo __unused) 68 { 69 hash_ops(dst_ctx)->copy_state(dst_ctx, src_ctx); 70 } 71 72 TEE_Result crypto_hash_init(void *ctx, uint32_t algo __unused) 73 { 74 return hash_ops(ctx)->init(ctx); 75 } 76 77 TEE_Result crypto_hash_update(void *ctx, uint32_t algo __unused, 78 const uint8_t *data, size_t len) 79 { 80 return hash_ops(ctx)->update(ctx, data, len); 81 } 82 83 TEE_Result crypto_hash_final(void *ctx, uint32_t algo __unused, 84 uint8_t *digest, size_t len) 85 { 86 return hash_ops(ctx)->final(ctx, digest, len); 87 } 88 89 #if !defined(_CFG_CRYPTO_WITH_CIPHER) 90 TEE_Result crypto_cipher_alloc_ctx(void **ctx __unused, uint32_t algo __unused) 91 { 92 return TEE_ERROR_NOT_IMPLEMENTED; 93 } 94 95 void crypto_cipher_free_ctx(void *ctx, uint32_t algo __unused) 96 { 97 if (ctx) 98 assert(0); 99 } 100 101 void crypto_cipher_copy_state(void *dst_ctx __unused, void *src_ctx __unused, 102 uint32_t algo __unused) 103 { 104 assert(0); 105 } 106 107 TEE_Result crypto_cipher_init(void *ctx __unused, uint32_t algo __unused, 108 TEE_OperationMode mode __unused, 109 const uint8_t *key1 __unused, 110 size_t key1_len __unused, 111 const uint8_t *key2 __unused, 112 size_t key2_len __unused, 113 const uint8_t *iv __unused, 114 size_t iv_len __unused) 115 { 116 return TEE_ERROR_NOT_IMPLEMENTED; 117 } 118 119 TEE_Result crypto_cipher_update(void *ctx __unused, uint32_t algo __unused, 120 TEE_OperationMode mode __unused, 121 bool last_block __unused, 122 const uint8_t *data __unused, 123 size_t len __unused, uint8_t *dst __unused) 124 { 125 return TEE_ERROR_NOT_IMPLEMENTED; 126 } 127 128 void crypto_cipher_final(void *ctx __unused, uint32_t algo __unused) 129 { 130 } 131 #endif /*_CFG_CRYPTO_WITH_CIPHER*/ 132 133 TEE_Result crypto_cipher_get_block_size(uint32_t algo, size_t *size) 134 { 135 uint32_t class = TEE_ALG_GET_CLASS(algo); 136 137 if (class != TEE_OPERATION_CIPHER && class != TEE_OPERATION_MAC && 138 class != TEE_OPERATION_AE) 139 return TEE_ERROR_BAD_PARAMETERS; 140 141 switch (TEE_ALG_GET_MAIN_ALG(algo)) { 142 case TEE_MAIN_ALGO_AES: 143 *size = TEE_AES_BLOCK_SIZE; 144 return TEE_SUCCESS; 145 case TEE_MAIN_ALGO_DES: 146 case TEE_MAIN_ALGO_DES3: 147 *size = TEE_DES_BLOCK_SIZE; 148 return TEE_SUCCESS; 149 default: 150 return TEE_ERROR_NOT_SUPPORTED; 151 } 152 } 153 154 TEE_Result crypto_mac_alloc_ctx(void **ctx, uint32_t algo) 155 { 156 TEE_Result res = TEE_SUCCESS; 157 struct crypto_mac_ctx *c = NULL; 158 159 switch (algo) { 160 case TEE_ALG_HMAC_MD5: 161 res = crypto_hmac_md5_alloc_ctx(&c); 162 break; 163 case TEE_ALG_HMAC_SHA1: 164 res = crypto_hmac_sha1_alloc_ctx(&c); 165 break; 166 case TEE_ALG_HMAC_SHA224: 167 res = crypto_hmac_sha224_alloc_ctx(&c); 168 break; 169 case TEE_ALG_HMAC_SHA256: 170 res = crypto_hmac_sha256_alloc_ctx(&c); 171 break; 172 case TEE_ALG_HMAC_SHA384: 173 res = crypto_hmac_sha384_alloc_ctx(&c); 174 break; 175 case TEE_ALG_HMAC_SHA512: 176 res = crypto_hmac_sha512_alloc_ctx(&c); 177 break; 178 case TEE_ALG_AES_CBC_MAC_NOPAD: 179 res = crypto_aes_cbc_mac_nopad_alloc_ctx(&c); 180 break; 181 case TEE_ALG_AES_CBC_MAC_PKCS5: 182 res = crypto_aes_cbc_mac_pkcs5_alloc_ctx(&c); 183 break; 184 case TEE_ALG_DES_CBC_MAC_NOPAD: 185 res = crypto_des_cbc_mac_nopad_alloc_ctx(&c); 186 break; 187 case TEE_ALG_DES_CBC_MAC_PKCS5: 188 res = crypto_des_cbc_mac_pkcs5_alloc_ctx(&c); 189 break; 190 case TEE_ALG_DES3_CBC_MAC_NOPAD: 191 res = crypto_des3_cbc_mac_nopad_alloc_ctx(&c); 192 break; 193 case TEE_ALG_DES3_CBC_MAC_PKCS5: 194 res = crypto_des3_cbc_mac_pkcs5_alloc_ctx(&c); 195 break; 196 case TEE_ALG_AES_CMAC: 197 res = crypto_aes_cmac_alloc_ctx(&c); 198 break; 199 default: 200 return TEE_ERROR_NOT_SUPPORTED; 201 } 202 203 if (!res) 204 *ctx = c; 205 206 return res; 207 } 208 209 static const struct crypto_mac_ops *mac_ops(void *ctx) 210 { 211 struct crypto_mac_ctx *c = ctx; 212 213 assert(c && c->ops); 214 215 return c->ops; 216 } 217 218 void crypto_mac_free_ctx(void *ctx, uint32_t algo __unused) 219 { 220 if (ctx) 221 mac_ops(ctx)->free_ctx(ctx); 222 } 223 224 void crypto_mac_copy_state(void *dst_ctx, void *src_ctx, uint32_t algo __unused) 225 { 226 mac_ops(dst_ctx)->copy_state(dst_ctx, src_ctx); 227 } 228 229 TEE_Result crypto_mac_init(void *ctx, uint32_t algo __unused, 230 const uint8_t *key, size_t len) 231 { 232 return mac_ops(ctx)->init(ctx, key, len); 233 } 234 235 TEE_Result crypto_mac_update(void *ctx, uint32_t algo __unused, 236 const uint8_t *data, size_t len) 237 { 238 if (!len) 239 return TEE_SUCCESS; 240 241 return mac_ops(ctx)->update(ctx, data, len); 242 } 243 244 TEE_Result crypto_mac_final(void *ctx, uint32_t algo __unused, 245 uint8_t *digest, size_t digest_len) 246 { 247 return mac_ops(ctx)->final(ctx, digest, digest_len); 248 } 249 250 TEE_Result crypto_authenc_alloc_ctx(void **ctx, uint32_t algo) 251 { 252 switch (algo) { 253 #if defined(CFG_CRYPTO_CCM) 254 case TEE_ALG_AES_CCM: 255 return crypto_aes_ccm_alloc_ctx(ctx); 256 #endif 257 #if defined(CFG_CRYPTO_GCM) 258 case TEE_ALG_AES_GCM: 259 return crypto_aes_gcm_alloc_ctx(ctx); 260 #endif 261 default: 262 return TEE_ERROR_NOT_IMPLEMENTED; 263 } 264 } 265 266 void crypto_authenc_free_ctx(void *ctx, uint32_t algo) 267 { 268 switch (algo) { 269 #if defined(CFG_CRYPTO_CCM) 270 case TEE_ALG_AES_CCM: 271 crypto_aes_ccm_free_ctx(ctx); 272 break; 273 #endif 274 #if defined(CFG_CRYPTO_GCM) 275 case TEE_ALG_AES_GCM: 276 crypto_aes_gcm_free_ctx(ctx); 277 break; 278 #endif 279 default: 280 if (ctx) 281 assert(0); 282 } 283 } 284 285 void crypto_authenc_copy_state(void *dst_ctx, void *src_ctx, uint32_t algo) 286 { 287 switch (algo) { 288 #if defined(CFG_CRYPTO_CCM) 289 case TEE_ALG_AES_CCM: 290 crypto_aes_ccm_copy_state(dst_ctx, src_ctx); 291 break; 292 #endif 293 #if defined(CFG_CRYPTO_GCM) 294 case TEE_ALG_AES_GCM: 295 crypto_aes_gcm_copy_state(dst_ctx, src_ctx); 296 break; 297 #endif 298 default: 299 assert(0); 300 } 301 } 302 303 TEE_Result crypto_authenc_init(void *ctx __maybe_unused, 304 uint32_t algo __maybe_unused, 305 TEE_OperationMode mode __maybe_unused, 306 const uint8_t *key __maybe_unused, 307 size_t key_len __maybe_unused, 308 const uint8_t *nonce __maybe_unused, 309 size_t nonce_len __maybe_unused, 310 size_t tag_len __maybe_unused, 311 size_t aad_len __maybe_unused, 312 size_t payload_len __maybe_unused) 313 { 314 switch (algo) { 315 #if defined(CFG_CRYPTO_CCM) 316 case TEE_ALG_AES_CCM: 317 return crypto_aes_ccm_init(ctx, mode, key, key_len, nonce, 318 nonce_len, tag_len, aad_len, 319 payload_len); 320 #endif 321 #if defined(CFG_CRYPTO_GCM) 322 case TEE_ALG_AES_GCM: 323 return crypto_aes_gcm_init(ctx, mode, key, key_len, nonce, 324 nonce_len, tag_len); 325 #endif 326 default: 327 return TEE_ERROR_NOT_IMPLEMENTED; 328 } 329 } 330 331 TEE_Result crypto_authenc_update_aad(void *ctx __maybe_unused, 332 uint32_t algo __maybe_unused, 333 TEE_OperationMode mode __unused, 334 const uint8_t *data __maybe_unused, 335 size_t len __maybe_unused) 336 { 337 switch (algo) { 338 #if defined(CFG_CRYPTO_CCM) 339 case TEE_ALG_AES_CCM: 340 return crypto_aes_ccm_update_aad(ctx, data, len); 341 #endif 342 #if defined(CFG_CRYPTO_GCM) 343 case TEE_ALG_AES_GCM: 344 return crypto_aes_gcm_update_aad(ctx, data, len); 345 #endif 346 default: 347 return TEE_ERROR_NOT_IMPLEMENTED; 348 } 349 } 350 351 TEE_Result crypto_authenc_update_payload(void *ctx __maybe_unused, 352 uint32_t algo __maybe_unused, 353 TEE_OperationMode mode __maybe_unused, 354 const uint8_t *src_data __maybe_unused, 355 size_t src_len __maybe_unused, 356 uint8_t *dst_data __maybe_unused, 357 size_t *dst_len __maybe_unused) 358 { 359 size_t dl = *dst_len; 360 361 *dst_len = src_len; 362 if (dl < src_len) 363 return TEE_ERROR_SHORT_BUFFER; 364 365 switch (algo) { 366 #if defined(CFG_CRYPTO_CCM) 367 case TEE_ALG_AES_CCM: 368 return crypto_aes_ccm_update_payload(ctx, mode, src_data, 369 src_len, dst_data); 370 #endif 371 #if defined(CFG_CRYPTO_GCM) 372 case TEE_ALG_AES_GCM: 373 return crypto_aes_gcm_update_payload(ctx, mode, src_data, 374 src_len, dst_data); 375 #endif 376 default: 377 return TEE_ERROR_NOT_IMPLEMENTED; 378 } 379 } 380 381 TEE_Result crypto_authenc_enc_final(void *ctx __maybe_unused, 382 uint32_t algo __maybe_unused, 383 const uint8_t *src_data __maybe_unused, 384 size_t src_len __maybe_unused, 385 uint8_t *dst_data __maybe_unused, 386 size_t *dst_len __maybe_unused, 387 uint8_t *dst_tag __maybe_unused, 388 size_t *dst_tag_len __maybe_unused) 389 { 390 size_t dl = *dst_len; 391 392 *dst_len = src_len; 393 if (dl < src_len) 394 return TEE_ERROR_SHORT_BUFFER; 395 396 switch (algo) { 397 #if defined(CFG_CRYPTO_CCM) 398 case TEE_ALG_AES_CCM: 399 return crypto_aes_ccm_enc_final(ctx, src_data, src_len, 400 dst_data, dst_tag, dst_tag_len); 401 #endif 402 #if defined(CFG_CRYPTO_GCM) 403 case TEE_ALG_AES_GCM: 404 return crypto_aes_gcm_enc_final(ctx, src_data, src_len, 405 dst_data, dst_tag, dst_tag_len); 406 #endif 407 default: 408 return TEE_ERROR_NOT_IMPLEMENTED; 409 } 410 } 411 412 TEE_Result crypto_authenc_dec_final(void *ctx __maybe_unused, 413 uint32_t algo __maybe_unused, 414 const uint8_t *src_data __maybe_unused, 415 size_t src_len __maybe_unused, 416 uint8_t *dst_data __maybe_unused, 417 size_t *dst_len __maybe_unused, 418 const uint8_t *tag __maybe_unused, 419 size_t tag_len __maybe_unused) 420 { 421 size_t dl = *dst_len; 422 423 *dst_len = src_len; 424 if (dl < src_len) 425 return TEE_ERROR_SHORT_BUFFER; 426 427 switch (algo) { 428 #if defined(CFG_CRYPTO_CCM) 429 case TEE_ALG_AES_CCM: 430 return crypto_aes_ccm_dec_final(ctx, src_data, src_len, 431 dst_data, tag, tag_len); 432 #endif 433 #if defined(CFG_CRYPTO_GCM) 434 case TEE_ALG_AES_GCM: 435 return crypto_aes_gcm_dec_final(ctx, src_data, src_len, 436 dst_data, tag, tag_len); 437 #endif 438 default: 439 return TEE_ERROR_NOT_IMPLEMENTED; 440 } 441 } 442 443 void crypto_authenc_final(void *ctx __maybe_unused, 444 uint32_t algo __maybe_unused) 445 { 446 switch (algo) { 447 #if defined(CFG_CRYPTO_CCM) 448 case TEE_ALG_AES_CCM: 449 crypto_aes_ccm_final(ctx); 450 break; 451 #endif 452 #if defined(CFG_CRYPTO_GCM) 453 case TEE_ALG_AES_GCM: 454 crypto_aes_gcm_final(ctx); 455 break; 456 #endif 457 default: 458 break; 459 } 460 } 461 462 #if !defined(_CFG_CRYPTO_WITH_ACIPHER) 463 struct bignum *crypto_bignum_allocate(size_t size_bits __unused) 464 { 465 return NULL; 466 } 467 468 TEE_Result crypto_bignum_bin2bn(const uint8_t *from __unused, 469 size_t fromsize __unused, 470 struct bignum *to __unused) 471 { 472 return TEE_ERROR_NOT_IMPLEMENTED; 473 } 474 475 size_t crypto_bignum_num_bytes(struct bignum *a __unused) 476 { 477 return 0; 478 } 479 480 size_t crypto_bignum_num_bits(struct bignum *a __unused) 481 { 482 return 0; 483 } 484 485 /* 486 * crypto_bignum_allocate() and crypto_bignum_bin2bn() failing should be 487 * enough to guarantee that the functions calling this function aren't 488 * called, but just in case add a panic() here to avoid unexpected 489 * behavoir. 490 */ 491 static void bignum_cant_happen(void) 492 { 493 volatile bool b = true; 494 495 /* Avoid warning about function does not return */ 496 if (b) 497 panic(); 498 } 499 500 void crypto_bignum_bn2bin(const struct bignum *from __unused, 501 uint8_t *to __unused) 502 { 503 bignum_cant_happen(); 504 } 505 506 void crypto_bignum_copy(struct bignum *to __unused, 507 const struct bignum *from __unused) 508 { 509 bignum_cant_happen(); 510 } 511 512 void crypto_bignum_free(struct bignum *a) 513 { 514 if (a) 515 panic(); 516 } 517 518 void crypto_bignum_clear(struct bignum *a __unused) 519 { 520 bignum_cant_happen(); 521 } 522 523 /* return -1 if a<b, 0 if a==b, +1 if a>b */ 524 int32_t crypto_bignum_compare(struct bignum *a __unused, 525 struct bignum *b __unused) 526 { 527 bignum_cant_happen(); 528 return -1; 529 } 530 #endif /*!_CFG_CRYPTO_WITH_ACIPHER*/ 531 532 #if !defined(CFG_CRYPTO_RSA) || !defined(_CFG_CRYPTO_WITH_ACIPHER) 533 TEE_Result crypto_acipher_alloc_rsa_keypair(struct rsa_keypair *s __unused, 534 size_t key_size_bits __unused) 535 { 536 return TEE_ERROR_NOT_IMPLEMENTED; 537 } 538 539 TEE_Result 540 crypto_acipher_alloc_rsa_public_key(struct rsa_public_key *s __unused, 541 size_t key_size_bits __unused) 542 { 543 return TEE_ERROR_NOT_IMPLEMENTED; 544 } 545 546 void crypto_acipher_free_rsa_public_key(struct rsa_public_key *s __unused) 547 { 548 } 549 550 TEE_Result crypto_acipher_gen_rsa_key(struct rsa_keypair *key __unused, 551 size_t key_size __unused) 552 { 553 return TEE_ERROR_NOT_IMPLEMENTED; 554 } 555 556 TEE_Result crypto_acipher_rsanopad_decrypt(struct rsa_keypair *key __unused, 557 const uint8_t *src __unused, 558 size_t src_len __unused, 559 uint8_t *dst __unused, 560 size_t *dst_len __unused) 561 { 562 return TEE_ERROR_NOT_IMPLEMENTED; 563 } 564 565 TEE_Result crypto_acipher_rsanopad_encrypt(struct rsa_public_key *key __unused, 566 const uint8_t *src __unused, 567 size_t src_len __unused, 568 uint8_t *dst __unused, 569 size_t *dst_len __unused) 570 { 571 return TEE_ERROR_NOT_IMPLEMENTED; 572 } 573 574 TEE_Result crypto_acipher_rsaes_decrypt(uint32_t algo __unused, 575 struct rsa_keypair *key __unused, 576 const uint8_t *label __unused, 577 size_t label_len __unused, 578 const uint8_t *src __unused, 579 size_t src_len __unused, 580 uint8_t *dst __unused, 581 size_t *dst_len __unused) 582 { 583 return TEE_ERROR_NOT_IMPLEMENTED; 584 } 585 586 TEE_Result crypto_acipher_rsaes_encrypt(uint32_t algo __unused, 587 struct rsa_public_key *key __unused, 588 const uint8_t *label __unused, 589 size_t label_len __unused, 590 const uint8_t *src __unused, 591 size_t src_len __unused, 592 uint8_t *dst __unused, 593 size_t *dst_len __unused) 594 { 595 return TEE_ERROR_NOT_IMPLEMENTED; 596 } 597 598 TEE_Result crypto_acipher_rsassa_sign(uint32_t algo __unused, 599 struct rsa_keypair *key __unused, 600 int salt_len __unused, 601 const uint8_t *msg __unused, 602 size_t msg_len __unused, 603 uint8_t *sig __unused, 604 size_t *sig_len __unused) 605 { 606 return TEE_ERROR_NOT_IMPLEMENTED; 607 } 608 609 TEE_Result crypto_acipher_rsassa_verify(uint32_t algo __unused, 610 struct rsa_public_key *key __unused, 611 int salt_len __unused, 612 const uint8_t *msg __unused, 613 size_t msg_len __unused, 614 const uint8_t *sig __unused, 615 size_t sig_len __unused) 616 { 617 return TEE_ERROR_NOT_IMPLEMENTED; 618 } 619 #endif /*!CFG_CRYPTO_RSA || !_CFG_CRYPTO_WITH_ACIPHER*/ 620 621 #if !defined(CFG_CRYPTO_DSA) || !defined(_CFG_CRYPTO_WITH_ACIPHER) 622 TEE_Result crypto_acipher_alloc_dsa_keypair(struct dsa_keypair *s __unused, 623 size_t key_size_bits __unused) 624 { 625 return TEE_ERROR_NOT_IMPLEMENTED; 626 } 627 628 TEE_Result 629 crypto_acipher_alloc_dsa_public_key(struct dsa_public_key *s __unused, 630 size_t key_size_bits __unused) 631 { 632 return TEE_ERROR_NOT_IMPLEMENTED; 633 } 634 635 TEE_Result crypto_acipher_gen_dsa_key(struct dsa_keypair *key __unused, 636 size_t key_size __unused) 637 { 638 return TEE_ERROR_NOT_IMPLEMENTED; 639 } 640 641 TEE_Result crypto_acipher_dsa_sign(uint32_t algo __unused, 642 struct dsa_keypair *key __unused, 643 const uint8_t *msg __unused, 644 size_t msg_len __unused, 645 uint8_t *sig __unused, 646 size_t *sig_len __unused) 647 { 648 return TEE_ERROR_NOT_IMPLEMENTED; 649 } 650 651 TEE_Result crypto_acipher_dsa_verify(uint32_t algo __unused, 652 struct dsa_public_key *key __unused, 653 const uint8_t *msg __unused, 654 size_t msg_len __unused, 655 const uint8_t *sig __unused, 656 size_t sig_len __unused) 657 { 658 return TEE_ERROR_NOT_IMPLEMENTED; 659 } 660 #endif /*!CFG_CRYPTO_DSA || !_CFG_CRYPTO_WITH_ACIPHER*/ 661 662 #if !defined(CFG_CRYPTO_DH) || !defined(_CFG_CRYPTO_WITH_ACIPHER) 663 TEE_Result crypto_acipher_alloc_dh_keypair(struct dh_keypair *s __unused, 664 size_t key_size_bits __unused) 665 { 666 return TEE_ERROR_NOT_IMPLEMENTED; 667 } 668 669 TEE_Result crypto_acipher_gen_dh_key(struct dh_keypair *key __unused, 670 struct bignum *q __unused, 671 size_t xbits __unused) 672 { 673 return TEE_ERROR_NOT_IMPLEMENTED; 674 } 675 676 TEE_Result 677 crypto_acipher_dh_shared_secret(struct dh_keypair *private_key __unused, 678 struct bignum *public_key __unused, 679 struct bignum *secret __unused) 680 { 681 return TEE_ERROR_NOT_IMPLEMENTED; 682 } 683 #endif /*!CFG_CRYPTO_DH || !_CFG_CRYPTO_WITH_ACIPHER*/ 684 685 #if !defined(CFG_CRYPTO_ECC) || !defined(_CFG_CRYPTO_WITH_ACIPHER) 686 TEE_Result 687 crypto_acipher_alloc_ecc_public_key(struct ecc_public_key *s __unused, 688 size_t key_size_bits __unused) 689 { 690 return TEE_ERROR_NOT_IMPLEMENTED; 691 } 692 693 TEE_Result crypto_acipher_alloc_ecc_keypair(struct ecc_keypair *s __unused, 694 size_t key_size_bits __unused) 695 { 696 return TEE_ERROR_NOT_IMPLEMENTED; 697 } 698 699 void crypto_acipher_free_ecc_public_key(struct ecc_public_key *s __unused) 700 { 701 } 702 703 TEE_Result crypto_acipher_gen_ecc_key(struct ecc_keypair *key __unused) 704 { 705 return TEE_ERROR_NOT_IMPLEMENTED; 706 } 707 708 TEE_Result crypto_acipher_ecc_sign(uint32_t algo __unused, 709 struct ecc_keypair *key __unused, 710 const uint8_t *msg __unused, 711 size_t msg_len __unused, 712 uint8_t *sig __unused, 713 size_t *sig_len __unused) 714 { 715 return TEE_ERROR_NOT_IMPLEMENTED; 716 } 717 718 TEE_Result crypto_acipher_ecc_verify(uint32_t algo __unused, 719 struct ecc_public_key *key __unused, 720 const uint8_t *msg __unused, 721 size_t msg_len __unused, 722 const uint8_t *sig __unused, 723 size_t sig_len __unused) 724 { 725 return TEE_ERROR_NOT_IMPLEMENTED; 726 } 727 728 TEE_Result 729 crypto_acipher_ecc_shared_secret(struct ecc_keypair *private_key __unused, 730 struct ecc_public_key *public_key __unused, 731 void *secret __unused, 732 unsigned long *secret_len __unused) 733 { 734 return TEE_ERROR_NOT_IMPLEMENTED; 735 } 736 #endif /*!CFG_CRYPTO_ECC || !_CFG_CRYPTO_WITH_ACIPHER*/ 737