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