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