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