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 #if !defined(_CFG_CRYPTO_WITH_MAC) 155 TEE_Result crypto_mac_alloc_ctx(void **ctx __unused, uint32_t algo __unused) 156 { 157 return TEE_ERROR_NOT_IMPLEMENTED; 158 } 159 160 void crypto_mac_free_ctx(void *ctx, uint32_t algo __unused) 161 { 162 if (ctx) 163 assert(0); 164 } 165 166 void crypto_mac_copy_state(void *dst_ctx __unused, void *src_ctx __unused, 167 uint32_t algo __unused) 168 { 169 assert(0); 170 } 171 172 TEE_Result crypto_mac_init(void *ctx __unused, uint32_t algo __unused, 173 const uint8_t *key __unused, size_t len __unused) 174 { 175 return TEE_ERROR_NOT_IMPLEMENTED; 176 } 177 178 TEE_Result crypto_mac_update(void *ctx __unused, uint32_t algo __unused, 179 const uint8_t *data __unused, size_t len __unused) 180 { 181 return TEE_ERROR_NOT_IMPLEMENTED; 182 } 183 184 TEE_Result crypto_mac_final(void *ctx __unused, uint32_t algo __unused, 185 uint8_t *digest __unused, 186 size_t digest_len __unused) 187 { 188 return TEE_ERROR_NOT_IMPLEMENTED; 189 } 190 #endif /*_CFG_CRYPTO_WITH_MAC*/ 191 192 TEE_Result crypto_authenc_alloc_ctx(void **ctx, uint32_t algo) 193 { 194 switch (algo) { 195 #if defined(CFG_CRYPTO_CCM) 196 case TEE_ALG_AES_CCM: 197 return crypto_aes_ccm_alloc_ctx(ctx); 198 #endif 199 #if defined(CFG_CRYPTO_GCM) 200 case TEE_ALG_AES_GCM: 201 return crypto_aes_gcm_alloc_ctx(ctx); 202 #endif 203 default: 204 return TEE_ERROR_NOT_IMPLEMENTED; 205 } 206 } 207 208 void crypto_authenc_free_ctx(void *ctx, uint32_t algo) 209 { 210 switch (algo) { 211 #if defined(CFG_CRYPTO_CCM) 212 case TEE_ALG_AES_CCM: 213 crypto_aes_ccm_free_ctx(ctx); 214 break; 215 #endif 216 #if defined(CFG_CRYPTO_GCM) 217 case TEE_ALG_AES_GCM: 218 crypto_aes_gcm_free_ctx(ctx); 219 break; 220 #endif 221 default: 222 if (ctx) 223 assert(0); 224 } 225 } 226 227 void crypto_authenc_copy_state(void *dst_ctx, void *src_ctx, uint32_t algo) 228 { 229 switch (algo) { 230 #if defined(CFG_CRYPTO_CCM) 231 case TEE_ALG_AES_CCM: 232 crypto_aes_ccm_copy_state(dst_ctx, src_ctx); 233 break; 234 #endif 235 #if defined(CFG_CRYPTO_GCM) 236 case TEE_ALG_AES_GCM: 237 crypto_aes_gcm_copy_state(dst_ctx, src_ctx); 238 break; 239 #endif 240 default: 241 assert(0); 242 } 243 } 244 245 TEE_Result crypto_authenc_init(void *ctx __maybe_unused, 246 uint32_t algo __maybe_unused, 247 TEE_OperationMode mode __maybe_unused, 248 const uint8_t *key __maybe_unused, 249 size_t key_len __maybe_unused, 250 const uint8_t *nonce __maybe_unused, 251 size_t nonce_len __maybe_unused, 252 size_t tag_len __maybe_unused, 253 size_t aad_len __maybe_unused, 254 size_t payload_len __maybe_unused) 255 { 256 switch (algo) { 257 #if defined(CFG_CRYPTO_CCM) 258 case TEE_ALG_AES_CCM: 259 return crypto_aes_ccm_init(ctx, mode, key, key_len, nonce, 260 nonce_len, tag_len, aad_len, 261 payload_len); 262 #endif 263 #if defined(CFG_CRYPTO_GCM) 264 case TEE_ALG_AES_GCM: 265 return crypto_aes_gcm_init(ctx, mode, key, key_len, nonce, 266 nonce_len, tag_len); 267 #endif 268 default: 269 return TEE_ERROR_NOT_IMPLEMENTED; 270 } 271 } 272 273 TEE_Result crypto_authenc_update_aad(void *ctx __maybe_unused, 274 uint32_t algo __maybe_unused, 275 TEE_OperationMode mode __unused, 276 const uint8_t *data __maybe_unused, 277 size_t len __maybe_unused) 278 { 279 switch (algo) { 280 #if defined(CFG_CRYPTO_CCM) 281 case TEE_ALG_AES_CCM: 282 return crypto_aes_ccm_update_aad(ctx, data, len); 283 #endif 284 #if defined(CFG_CRYPTO_GCM) 285 case TEE_ALG_AES_GCM: 286 return crypto_aes_gcm_update_aad(ctx, data, len); 287 #endif 288 default: 289 return TEE_ERROR_NOT_IMPLEMENTED; 290 } 291 } 292 293 TEE_Result crypto_authenc_update_payload(void *ctx __maybe_unused, 294 uint32_t algo __maybe_unused, 295 TEE_OperationMode mode __maybe_unused, 296 const uint8_t *src_data __maybe_unused, 297 size_t src_len __maybe_unused, 298 uint8_t *dst_data __maybe_unused, 299 size_t *dst_len __maybe_unused) 300 { 301 size_t dl = *dst_len; 302 303 *dst_len = src_len; 304 if (dl < src_len) 305 return TEE_ERROR_SHORT_BUFFER; 306 307 switch (algo) { 308 #if defined(CFG_CRYPTO_CCM) 309 case TEE_ALG_AES_CCM: 310 return crypto_aes_ccm_update_payload(ctx, mode, src_data, 311 src_len, dst_data); 312 #endif 313 #if defined(CFG_CRYPTO_GCM) 314 case TEE_ALG_AES_GCM: 315 return crypto_aes_gcm_update_payload(ctx, mode, src_data, 316 src_len, dst_data); 317 #endif 318 default: 319 return TEE_ERROR_NOT_IMPLEMENTED; 320 } 321 } 322 323 TEE_Result crypto_authenc_enc_final(void *ctx __maybe_unused, 324 uint32_t algo __maybe_unused, 325 const uint8_t *src_data __maybe_unused, 326 size_t src_len __maybe_unused, 327 uint8_t *dst_data __maybe_unused, 328 size_t *dst_len __maybe_unused, 329 uint8_t *dst_tag __maybe_unused, 330 size_t *dst_tag_len __maybe_unused) 331 { 332 size_t dl = *dst_len; 333 334 *dst_len = src_len; 335 if (dl < src_len) 336 return TEE_ERROR_SHORT_BUFFER; 337 338 switch (algo) { 339 #if defined(CFG_CRYPTO_CCM) 340 case TEE_ALG_AES_CCM: 341 return crypto_aes_ccm_enc_final(ctx, src_data, src_len, 342 dst_data, dst_tag, dst_tag_len); 343 #endif 344 #if defined(CFG_CRYPTO_GCM) 345 case TEE_ALG_AES_GCM: 346 return crypto_aes_gcm_enc_final(ctx, src_data, src_len, 347 dst_data, dst_tag, dst_tag_len); 348 #endif 349 default: 350 return TEE_ERROR_NOT_IMPLEMENTED; 351 } 352 } 353 354 TEE_Result crypto_authenc_dec_final(void *ctx __maybe_unused, 355 uint32_t algo __maybe_unused, 356 const uint8_t *src_data __maybe_unused, 357 size_t src_len __maybe_unused, 358 uint8_t *dst_data __maybe_unused, 359 size_t *dst_len __maybe_unused, 360 const uint8_t *tag __maybe_unused, 361 size_t tag_len __maybe_unused) 362 { 363 size_t dl = *dst_len; 364 365 *dst_len = src_len; 366 if (dl < src_len) 367 return TEE_ERROR_SHORT_BUFFER; 368 369 switch (algo) { 370 #if defined(CFG_CRYPTO_CCM) 371 case TEE_ALG_AES_CCM: 372 return crypto_aes_ccm_dec_final(ctx, src_data, src_len, 373 dst_data, tag, tag_len); 374 #endif 375 #if defined(CFG_CRYPTO_GCM) 376 case TEE_ALG_AES_GCM: 377 return crypto_aes_gcm_dec_final(ctx, src_data, src_len, 378 dst_data, tag, tag_len); 379 #endif 380 default: 381 return TEE_ERROR_NOT_IMPLEMENTED; 382 } 383 } 384 385 void crypto_authenc_final(void *ctx __maybe_unused, 386 uint32_t algo __maybe_unused) 387 { 388 switch (algo) { 389 #if defined(CFG_CRYPTO_CCM) 390 case TEE_ALG_AES_CCM: 391 crypto_aes_ccm_final(ctx); 392 break; 393 #endif 394 #if defined(CFG_CRYPTO_GCM) 395 case TEE_ALG_AES_GCM: 396 crypto_aes_gcm_final(ctx); 397 break; 398 #endif 399 default: 400 break; 401 } 402 } 403 404 #if !defined(_CFG_CRYPTO_WITH_ACIPHER) 405 struct bignum *crypto_bignum_allocate(size_t size_bits __unused) 406 { 407 return NULL; 408 } 409 410 TEE_Result crypto_bignum_bin2bn(const uint8_t *from __unused, 411 size_t fromsize __unused, 412 struct bignum *to __unused) 413 { 414 return TEE_ERROR_NOT_IMPLEMENTED; 415 } 416 417 size_t crypto_bignum_num_bytes(struct bignum *a __unused) 418 { 419 return 0; 420 } 421 422 size_t crypto_bignum_num_bits(struct bignum *a __unused) 423 { 424 return 0; 425 } 426 427 /* 428 * crypto_bignum_allocate() and crypto_bignum_bin2bn() failing should be 429 * enough to guarantee that the functions calling this function aren't 430 * called, but just in case add a panic() here to avoid unexpected 431 * behavoir. 432 */ 433 static void bignum_cant_happen(void) 434 { 435 volatile bool b = true; 436 437 /* Avoid warning about function does not return */ 438 if (b) 439 panic(); 440 } 441 442 void crypto_bignum_bn2bin(const struct bignum *from __unused, 443 uint8_t *to __unused) 444 { 445 bignum_cant_happen(); 446 } 447 448 void crypto_bignum_copy(struct bignum *to __unused, 449 const struct bignum *from __unused) 450 { 451 bignum_cant_happen(); 452 } 453 454 void crypto_bignum_free(struct bignum *a) 455 { 456 if (a) 457 panic(); 458 } 459 460 void crypto_bignum_clear(struct bignum *a __unused) 461 { 462 bignum_cant_happen(); 463 } 464 465 /* return -1 if a<b, 0 if a==b, +1 if a>b */ 466 int32_t crypto_bignum_compare(struct bignum *a __unused, 467 struct bignum *b __unused) 468 { 469 bignum_cant_happen(); 470 return -1; 471 } 472 #endif /*!_CFG_CRYPTO_WITH_ACIPHER*/ 473 474 #if !defined(CFG_CRYPTO_RSA) || !defined(_CFG_CRYPTO_WITH_ACIPHER) 475 TEE_Result crypto_acipher_alloc_rsa_keypair(struct rsa_keypair *s __unused, 476 size_t key_size_bits __unused) 477 { 478 return TEE_ERROR_NOT_IMPLEMENTED; 479 } 480 481 TEE_Result 482 crypto_acipher_alloc_rsa_public_key(struct rsa_public_key *s __unused, 483 size_t key_size_bits __unused) 484 { 485 return TEE_ERROR_NOT_IMPLEMENTED; 486 } 487 488 void crypto_acipher_free_rsa_public_key(struct rsa_public_key *s __unused) 489 { 490 } 491 492 TEE_Result crypto_acipher_gen_rsa_key(struct rsa_keypair *key __unused, 493 size_t key_size __unused) 494 { 495 return TEE_ERROR_NOT_IMPLEMENTED; 496 } 497 498 TEE_Result crypto_acipher_rsanopad_decrypt(struct rsa_keypair *key __unused, 499 const uint8_t *src __unused, 500 size_t src_len __unused, 501 uint8_t *dst __unused, 502 size_t *dst_len __unused) 503 { 504 return TEE_ERROR_NOT_IMPLEMENTED; 505 } 506 507 TEE_Result crypto_acipher_rsanopad_encrypt(struct rsa_public_key *key __unused, 508 const uint8_t *src __unused, 509 size_t src_len __unused, 510 uint8_t *dst __unused, 511 size_t *dst_len __unused) 512 { 513 return TEE_ERROR_NOT_IMPLEMENTED; 514 } 515 516 TEE_Result crypto_acipher_rsaes_decrypt(uint32_t algo __unused, 517 struct rsa_keypair *key __unused, 518 const uint8_t *label __unused, 519 size_t label_len __unused, 520 const uint8_t *src __unused, 521 size_t src_len __unused, 522 uint8_t *dst __unused, 523 size_t *dst_len __unused) 524 { 525 return TEE_ERROR_NOT_IMPLEMENTED; 526 } 527 528 TEE_Result crypto_acipher_rsaes_encrypt(uint32_t algo __unused, 529 struct rsa_public_key *key __unused, 530 const uint8_t *label __unused, 531 size_t label_len __unused, 532 const uint8_t *src __unused, 533 size_t src_len __unused, 534 uint8_t *dst __unused, 535 size_t *dst_len __unused) 536 { 537 return TEE_ERROR_NOT_IMPLEMENTED; 538 } 539 540 TEE_Result crypto_acipher_rsassa_sign(uint32_t algo __unused, 541 struct rsa_keypair *key __unused, 542 int salt_len __unused, 543 const uint8_t *msg __unused, 544 size_t msg_len __unused, 545 uint8_t *sig __unused, 546 size_t *sig_len __unused) 547 { 548 return TEE_ERROR_NOT_IMPLEMENTED; 549 } 550 551 TEE_Result crypto_acipher_rsassa_verify(uint32_t algo __unused, 552 struct rsa_public_key *key __unused, 553 int salt_len __unused, 554 const uint8_t *msg __unused, 555 size_t msg_len __unused, 556 const uint8_t *sig __unused, 557 size_t sig_len __unused) 558 { 559 return TEE_ERROR_NOT_IMPLEMENTED; 560 } 561 #endif /*!CFG_CRYPTO_RSA || !_CFG_CRYPTO_WITH_ACIPHER*/ 562 563 #if !defined(CFG_CRYPTO_DSA) || !defined(_CFG_CRYPTO_WITH_ACIPHER) 564 TEE_Result crypto_acipher_alloc_dsa_keypair(struct dsa_keypair *s __unused, 565 size_t key_size_bits __unused) 566 { 567 return TEE_ERROR_NOT_IMPLEMENTED; 568 } 569 570 TEE_Result 571 crypto_acipher_alloc_dsa_public_key(struct dsa_public_key *s __unused, 572 size_t key_size_bits __unused) 573 { 574 return TEE_ERROR_NOT_IMPLEMENTED; 575 } 576 577 TEE_Result crypto_acipher_gen_dsa_key(struct dsa_keypair *key __unused, 578 size_t key_size __unused) 579 { 580 return TEE_ERROR_NOT_IMPLEMENTED; 581 } 582 583 TEE_Result crypto_acipher_dsa_sign(uint32_t algo __unused, 584 struct dsa_keypair *key __unused, 585 const uint8_t *msg __unused, 586 size_t msg_len __unused, 587 uint8_t *sig __unused, 588 size_t *sig_len __unused) 589 { 590 return TEE_ERROR_NOT_IMPLEMENTED; 591 } 592 593 TEE_Result crypto_acipher_dsa_verify(uint32_t algo __unused, 594 struct dsa_public_key *key __unused, 595 const uint8_t *msg __unused, 596 size_t msg_len __unused, 597 const uint8_t *sig __unused, 598 size_t sig_len __unused) 599 { 600 return TEE_ERROR_NOT_IMPLEMENTED; 601 } 602 #endif /*!CFG_CRYPTO_DSA || !_CFG_CRYPTO_WITH_ACIPHER*/ 603 604 #if !defined(CFG_CRYPTO_DH) || !defined(_CFG_CRYPTO_WITH_ACIPHER) 605 TEE_Result crypto_acipher_alloc_dh_keypair(struct dh_keypair *s __unused, 606 size_t key_size_bits __unused) 607 { 608 return TEE_ERROR_NOT_IMPLEMENTED; 609 } 610 611 TEE_Result crypto_acipher_gen_dh_key(struct dh_keypair *key __unused, 612 struct bignum *q __unused, 613 size_t xbits __unused) 614 { 615 return TEE_ERROR_NOT_IMPLEMENTED; 616 } 617 618 TEE_Result 619 crypto_acipher_dh_shared_secret(struct dh_keypair *private_key __unused, 620 struct bignum *public_key __unused, 621 struct bignum *secret __unused) 622 { 623 return TEE_ERROR_NOT_IMPLEMENTED; 624 } 625 #endif /*!CFG_CRYPTO_DH || !_CFG_CRYPTO_WITH_ACIPHER*/ 626 627 #if !defined(CFG_CRYPTO_ECC) || !defined(_CFG_CRYPTO_WITH_ACIPHER) 628 TEE_Result 629 crypto_acipher_alloc_ecc_public_key(struct ecc_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_alloc_ecc_keypair(struct ecc_keypair *s __unused, 636 size_t key_size_bits __unused) 637 { 638 return TEE_ERROR_NOT_IMPLEMENTED; 639 } 640 641 void crypto_acipher_free_ecc_public_key(struct ecc_public_key *s __unused) 642 { 643 } 644 645 TEE_Result crypto_acipher_gen_ecc_key(struct ecc_keypair *key __unused) 646 { 647 return TEE_ERROR_NOT_IMPLEMENTED; 648 } 649 650 TEE_Result crypto_acipher_ecc_sign(uint32_t algo __unused, 651 struct ecc_keypair *key __unused, 652 const uint8_t *msg __unused, 653 size_t msg_len __unused, 654 uint8_t *sig __unused, 655 size_t *sig_len __unused) 656 { 657 return TEE_ERROR_NOT_IMPLEMENTED; 658 } 659 660 TEE_Result crypto_acipher_ecc_verify(uint32_t algo __unused, 661 struct ecc_public_key *key __unused, 662 const uint8_t *msg __unused, 663 size_t msg_len __unused, 664 const uint8_t *sig __unused, 665 size_t sig_len __unused) 666 { 667 return TEE_ERROR_NOT_IMPLEMENTED; 668 } 669 670 TEE_Result 671 crypto_acipher_ecc_shared_secret(struct ecc_keypair *private_key __unused, 672 struct ecc_public_key *public_key __unused, 673 void *secret __unused, 674 unsigned long *secret_len __unused) 675 { 676 return TEE_ERROR_NOT_IMPLEMENTED; 677 } 678 #endif /*!CFG_CRYPTO_ECC || !_CFG_CRYPTO_WITH_ACIPHER*/ 679