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