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