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